Principles of an ontological modeling language construction are considered. The proposed modeling language is based on the OPENMath formalism, which is oriented to semantical representation of mathematical objects. We are basing on the concept of so-called content dictionaries of the OPENMath to represent knowledge. An ontology is constructed for Allen's interval temporal logic to show the ontological modeling possibilities of the proposed language. To support this ontology we are using the OPENMath content dictionaries, as well as developing new content dictionaries. Mapping rules from the considered ontology into Datalog are offered.
The fourth paradigm of science generates necessity
to multidisciplinary research in order to support data
analysis and its management in various data intensive
sciences (such as astronomy and astrophysics, genomics,
human brain research, Earth sciences, etc.) [
In this paper we are trying to develop an
XMLbased ontological modeling language by strengthening
the XML language by means of the OPENMath concept
[
We have certain experience of OPENMath usage in
our research. Particularly, we proposed a minor
extension of OPENMath formalism [
The paper is organized as follows: A review of the investigations to ontological modeling is presented in Section 2. Formal bases of the proposed modeling language and Allen's algebra are considered in Section 3.
In Section 4 the principles of an ontological modeling language construction are discussed by means of a nonformal example. The mapping rules from XML-based ontology into Datalog are offered in Section 5. The conclusion is provided in Section 6.
Investigations to support ontology-based information
management are intensively developing (for instance, [
A good survey of the languages for efficient support
of access to the databases satisfying the ontological
dependencies can be found in [
There are different families of ontological
languages: graph languages, frame languages, logical
languages and rule languages [
In the context of fourth paradigm of science it is important to provide a high level computationally complete language for ontological modeling. The necessity to develop such languages is connected with the possibility to define the subject domains of research and formulate solutions to scientific problems over abstract specifications. Such approach allows to abstract from resource structure when executing queries to specific data resources. Existing languages are either not computationally complete, or do not provide a high level interface.
In this section we will briefly consider the OPENMath concept. Namely, formalism and constructions on which that concept is based. Thereafter we will discuss Allen's interval temporal logic, which is used to construct an ontology on which the ontological modeling possibilities of the proposed language will be shown.
OPENMath is a standard for representation of the mathematical objects, allowing them to be exchanged between computer programs, stored in databases, or published on the Web. The considered formalism is oriented to represent semantic information and is not intended to be used directly for presentation. Any mathematical concept or fact is an example of mathematical object. OpenMath objects are such a representation of mathematical objects which assumes an XML interpretation.
Formally, an OpenMath object is a labeled tree
whose leaves are the basic OpenMath objects. The
compound objects are defined in terms of binding and
application of -calculus [
Attribution. If v is a basic object variable and t is a typed object, then attribution (v, type t) is a typed object. It denotes a variable with type t.
Abstraction. If v is a basic object variable and t, A are typed objects, then binding (, attribution (v, type t), A) is a typed object.
Application. If F and A are typed objects, then application (F, A) is a typed object. Semantic Level. OPENMath is implemented as an XML application. Its syntax is defined by syntactical rules of XML, its grammar is partially defined by its own DTD. Only syntactical validity of OPENMath objects representation can be provided on the DTD level. To check semantics, in addition to general rules inherited by XML applications, the considered application defines new syntactical rules. This is achieved by means of introduction of signature files concept, in which these rules are defined. Signature files contain the signatures of basic concepts defined in some content dictionary and are used to check the semantic validity of their representations. A content dictionary is the most important component of OPENMath concept preservation of mathematical information. In other words, content dictionaries are used to assign formal and informal semantics to all symbols (concepts) used in OPENMath objects. A content dictionary is a collection of related symbols, encoded in XML format and fixing the "meaning" of concepts independently of the application.
The formal framework for our example to
ontological modeling is based on Allen's interval
temporal logic (for more details see [
(t1 < t2) (t2 < t1) (t1 < t2) (t1 during t2) (t2 contains t1)
(t2 < t1) (t1 < t2) (t1 starts t2) (t2 startedBy t1
(t1 = t2) (t1 < t2) (t1 finishes t2) (t2 finishedBy t1)
(t2 < t1) (t1 =t2) Here, after is the inverse of before, metBy is the inverse of meets, overlapedBy is the inverse of overlaps, contains is the inverse of during, startedBy is the inverse of starts, finishedBy is the inverse of finishes, equals is symmetric and transitive. 4 Ontological Modeling Language The weakness of XML is the absence of data types concept in conventional sense. To eliminate this shortcoming and to support ontological dependencies on the XML level, we expand the XML by means of the OPENMath concept. The considered ontological modeling language coincides with XML which was strengthened by OPENMath concept. OPENMath is an extensible formalism. Its extensibility is achieved by defining new content dictionaries. We propose a minor extension of OPENMath to support the built-in data types concept of the XML Schema [27]. Namely, to model the constants of built-in data types of the XML Schema the corresponding basic objects were introduced. In the context of the considered language we consider three kinds of mechanisms to formalize subject domains: content dictionaries to define basic concepts of subject domains; signature files to define signatures of basic concepts to check the semantic validity of their representations; files of reasoning to formalize knowledge of subject domains. Defining a concept in terms of known ones we introduce a new concept (knowledge) within the considered subject domain. Thus, these files are collections of reasoning rules, which are defining the new concepts in terms of known ones in the considered subject domain.
A content dictionary which contains representation of
basic concepts of the subject domain contains two types
of information: one which is common to all content
dictionaries, and one which is restricted to a particular
basic concept definition. Definition of a new basic
concept includes name and description of the basic
concept, and also some optional information about this
concept. Specific information pertaining to the basic
concept like the signature and the defining of a concept
in terms of known ones is defined in additional files
associated with content dictionaries. Content dictionaries
contain just one part of the information that can be
associated with a basic concept in order to stepwise
define its meaning and its functionality. Signature files
and files of reasoning are used to formalize the different
aspects of subject domains. Namely, to formalize the
basic concepts formats, and to define reasoning rules to
formalize knowledge of subject domains.
4.1 An Ontology for Allen’s Interval Temporal Logic
In [
Content Dictionary for Basic Temporal Relations. The considered algebra is based on the basic temporal relations. To formalize the basic temporal relations we developed a new content dictionary named "TempRel" (temporal relation), which contains formal definitions of these relations. Below is the definition of one of them: <CD> <CDName> TempRel </CDName> <CDUses> <CDName> logic1 <CDName> <CDName> quant1 <CDName> <CDUses> <Description>
This CD defines symbols for temporal relations </Description> <CDDefinition> <Name> before </Name> <Description>
A binary relation </Description> <CMP> before(i,j)
k(meets(i,k) meets(k,j)) </CMP> <FMP> <OMOBJ> <OMA> <OMS name = “equivalent”
cd = “logic1”/> <OMA> <OMS name = “before”
cd = “TempRel”/> <OMV name = “i”/> <OMV name = “j”/> </OMA> <OMBIND> <OMS name = "exists"
cd = "quant1"/> <OMBVAR>
<OMV name = "k"> </OMBVAR> <OMA> <OMS name = “and”
cd = “logic1”/> <OMA> <OMS name = "meets"
cd = "TempRel”/> <OMV name = "i"/> <OMV name = "k"/> </OMA> <OMA> <OMS name = "meets"
cd = "TempRel"/> <OMV name = "k"/> <OMV name = "j"/> </OMA> </OMA> </OMBIND> </OMA> <OMOBJ> </FMP> </CDDefinition> Here, we used the OPENMath content dictionaries "logic1" and "quant1". In the "logic1" content dictionary the operations of Boolean algebra are defined, and in the content dictionary "quant1" the universal and existential quantifiers are defined. The above used XML elements have obvious interpretations. Only note that the element "CMP" contains the commented mathematical property of the considered basic temporal relation, and the element "FMP" contains the OPENMath representation of this property.
As is mentioned above, to check semantic
validity of the basic concepts representations we
associate extra information with content dictionaries,
namely signature files. A signature file contains the
definitions of all the basic concept signatures of the
considered content dictionary. Here we use Small
Type System [
cd = "TempRel”> <Signature name = "before"> <OMOBJ> <OMA> <OMS name = "mapsto" cd = "sts"/> <OMV name = "string"/> <OMV name = "string"/> <OMS name = "boolean"
cd = "logic1"/> </OMA> </OMOBJ> </Signature> Here, Signature introduces a symbol before and the mapsto symbol is used to construct non-dependent function spaces. The first n-1 children denote the types of the arguments, the last one denotes the return type. Reasoning rules. For modeling Allen's algebra, we developed an XML DTD, the instance of which is an XML file containing the reasoning rules of the considered subject domain. Reasoning rules can be embedded into the ontology based on the content dictionary "logic1" of OPENMath. As we noted above the reasoning rules to support ontology for Allen's interval temporal logic are based on the algebra operations and presented by means of element rdf (Rule Definition Formalism). This element contains reasoning rules, each of which defines one of the algebra operations and has two required attributes: name and type. The value of the attribute name is the name of the content dictionary on which the reasoning rules are based. The value of the attribute type is the name of the signature file, in which the formats of basic temporal relations are defined. A reasoning rule is defined by means of the rule element, which is based on the OPENMath application object and has one required attribute name. The value of this attribute is the name of the reasoning rule, which coincides with the name of the corresponding algebra operation. Below, DTD for modeling Allen's algebra operations is presented: <!-- include dtd for extended
OPENMath objects --> <!ELEMENT rdf (rule)*> <!ELEMENT rule (OMA)> <!ATTLIST rdf name #REQUIRED
type #REQUIRED> <!ATTLIST rule name(inverse| intersection|composition) "inverse"> In case when compositions of relations R and S generate a single relation T, then they are formalized using the "logic1" content dictionary of OPENMath by means of the rules of the following types: The following is an example of such a composition rule: before(X, Y) before(Y, Z) before(X, Z) Below, the XML encoding of this composition rule is presented: <rdf name = "TemRel" type = "sts"> <rule name = "composition"> <OMA> <OMS name = "implies"
cd = "logic1"/> <OMA> <OMS name = "and" cd = "logic1"/> <OMA> <OMS name="before"
cd = "TempRel"/> <OMV name = "X"/> <OMV name = "Y"/> </OMA> <OMA> <OMS name = "before"
cd = "TempRel"/> <OMV name = "Y"/> <OMV name = "Z"/> </OMA> </OMA> <OMA> <OMS name = "before"
cd = "TempRel"/>
<OMV name = "X"/>
<OMV name = "Z"/>
</OMA>
</OMA>
</rule>
In case, when compositions of relations R and S
generates a set of possible basic temporal relations {B1,
B2, ... ,Bk}, then they are formalized using the "logic1"
content dictionary of OPENMath by means of rules
of the following types:
R(X, Y) S(Y, Z) (B1(X, Z) B2(X, Z) ... Bk(X, Z))
Below is an example of such a composition rule:
meets(X, Y) during(Y, Z) (overlaps(X, Z)
during(X, Z) starts(X, Z))
Supporting inverse basic temporal relations involves
introducing the following rules in the knowledge base:
B'(X, Y) B(Y, X)
B(X, Y) B'(Y, X)
Here B is a basic temporal relation, and B' is the inverse
relation of B. In this case, we should add to the
knowledge base the following reasoning rules for basic
temporal relation before.
after(X,Y) before(Y, X)
before(X,Y) after(Y, X)
In addition to the basic temporal relations, we introduce
new temporal relations (before_starts and before_ends)
to define the sequence arising of events. Below are the
formal definitions of these relations:
before_starts(X, Y) ( Z,V)(meets(Z,X) meets(Z,V)
meets(V, Y))
before_ends(X,Y) (Z,V)(meets(X, Z) meets(Z, V)
meets(Y, V))
In the next section we will consider principles of
representation of XML-based ontology in Datalog, in
order to convert abstract representations of concepts and
their relationships in subject domain to the realization
level representations. The choice of Datalog language as
a language to support ontology is explained by the fact
that this language is one of the best logical formalism for
describing knowledge of subject domains.
5 XML-based Ontology Representation in
the Datalog
In fact, these two types of predicates are distinguished in
Datalog [
Extensional predicates, which are predicates whose relations are stored in a database, Intensional predicates, whose relations are computed by applying one or more Datalog rules.
The following rules to represent XML-based ontology in Datalog language are proposed: 1. The basic temporal relations are represented by means of extensional predicates. In other words, basic temporal relations are considered as facts, are represented as relations between events, and are stored in an extensional database. 2. The reasoning rules are represented by means of one or more Datalog rules. By means of Datalog rules we are modeling Allen's interval algebra operations. Namely, we model the unary inverse, binary intersection and binary composition operations. These Detalog rules are stored in the intensional database.
Thus, the basic temporal relations are predicates of extensional databases, and the temporal relations are predicates of intensional databases. The following is an example of basic temporal relation: E1 is an event in which John is married, and E2 is an event in which John is graduated from school. Then by means of a predicate after(E1, E2) we fix in the extensional database the following fact: "John married after graduating from school".
We use Datalog rules to infer implicitly defined information from extensional database. These rules are represented in intensional database by means of a Datalog program. As above mentioned, when compositions of relations R and S generate a single relation T, then we use the following reasoning rule on the level of the ontological modeling language to model such composition operation: R(X, Y) S(Y, Z) T(X, Z) The following Datalog representation of the considered reasoning rule is proposed: T(X, Z) R(X, Y) AND S(Y, Z) Below is an example of such Datalog rule: before(X, Z) before(X, Y) AND contains(Y, Z) In case, when compositions of relations R and S generate a set of possible basic temporal relations {B1, B2, ... ,Bk}, then it is proposed to use the following reasoning rule on the level of the ontological modeling language to model the considered composition operation: R(X, Y) S(Y, Z) (B1(X, Z) B2(X,Z) ... Bk(X, Z)) In this case, we cannot model the considered reasoning rule by means of one Datalog rule, since in Datalog it is not allowed to use disjunctions of atomic formulas as a head of rule. Therefore, we introduce a new temporal relation, which is represented as disjunctions of relations, and whose compositions must also be defined and asserted into the knowledge base. Let the relation D represent the disjunctions of relations B1, B2, ... ,Bk, then the composition of relations R and S can be represented in the intensional database as follows: D(X, Z) R(X, Y) AND S(Y, Z) The set of possible disjunctions over all basic temporal relations contains 213 relations, but tractable subsets of this set are closed under composition. Introduction of relations of type D is generated by the problem to support such relations. Namely, the set of Datalog rules defining the result of intersection of relations holding between two intervals is required to be introduced in the knowledge base. In other words, all relations which participate in the relations of type D must be represented in the knowledge base by means of such Datalog rules in which these relations are heads of such rules. Let DOS represent the disjunctions of relations during, overlaps and starts (see above considered example), then we should add into knowledge base the following Datalog rule: DOS(X, Z)
meets(X, Y) AND during(Y, Z) In addition, we should define and add Datalog rules into the knowledge base to support each relation, which participate in DOS. Below is an example of such Datalog rule: during(X, Z)
DOS(X, Z) AND before_starts(Z, X)
Let us note, that the result of the intersection of relation DOS with relation during is relation during: DOS(X, Y) during(X, Y) during(X,Y) Finally, the intersection of relation meets with relation during is an empty relation: meets(X, Y) during(X, Y) Supporting inverse relations is achieved by adding into the knowledge base the considered Datalog rules below: B'(X, Y) B(Y, X) B(X, Y) B'(Y, X) Here, B' and B are basic temporal relations. Below are examples of such Datalog rules: after(X, Y) before(Y, X) before(X, Y) after(Y, X) In this Section we considered the mapping rules from the proposed ontology into Datalog. Let us note, that when a composition operation is generated by a set of possible basic temporal relations, then this composition operation cannot be directly represented in the Datalog. In this case a necessity to model such reasoning rule by means of a Datalog program arises. In other cases, a direct representation of the reasoning rule by means of a Datalog rule is provided.
In this paper an XML-based ontological modeling language is proposed. The proposed language is a result of extension of the XML language with the OPENMath concept. The choice of OPENMath as the basic formalism is explained by the fact that the considered formalism is oriented to semantic representation of mathematical objects. Moreover, that formalism is extensible and provides a rich mathematical apparatus for formalizing the knowledge of the subject domains. The extensibility is achieved by adding new content dictionaries, in which the concepts and reasoning rules for the considered subject domains are defined. Besides the construction of new content dictionaries there is also a possibility to use content dictionaries of OPENMath in which different divisions of computational mathematics are represented, as well as to use the content dictionaries from different subject domains. It is essential that we use a computationally complete language for formalization and systematization of the subject domains knowledge. Thus, a unified interface is provided for representation and management of knowledge from different subject domains.
I am grateful to Professor Leonid Kalinichenko for scientific support and collaboration in the field of databases for many years. He represented a whole epoch in databases and his contribution is indisputable and significant. [26] Z. Szallasi. Development of genomic based diagnostics in various application domains. CEUR-WS, 2022:3-4, 2017.