A predicate-ordered sort-ordered logic (POSOL) approach is employed to develop the semantic framework for web ontology languages. POSOL extends an order-sorted logic to model the essential constructs of RDFS. A schema of mapping from RDFS graphs into POSOL2, 0 knowledge bases is given, and gives a novel treatment to RDF blank nodes. POSOL also can be used to guide us layering and building other web ontology languages on top of RDFS.
RDF Schema, Web Ontology Language, POSOL.
RDF Schema defines basic ontological modeling primitives on top of RDF. Other Semantic Web languages with richer modeling primitives are to be constructed by extending RDF Schema, among them are OIL, DAML and OWL. However, the layering of Semantic Web languages on RDFS (RDF and RDF Schema) cannot be achieved in a straightforward way [1]. To clarify the layering issue (such as layering OWL on top of RDFS), the logic framework of RDFS needs to be further explored, although the logic interpretation of RDFS has gotten some progress within the last two years.
From the point of view of meta-modeling architecture [2], the RDFS Model Theory approach is ambitious in that it tries to give the semantics of RDFS at both of ontology language layer and meta-language layer with a single mechanism. Particularly, it's not very nice as the semantics of RDFS at ontology language layer from the view of simple and clearness. In this paper, a predicate-ordered sort-ordered logic (POSOL) approach is employed to develop the semantic framework for web ontology languages. POSOL extends an order-sorted logic [3] to model the essential constructs of RDFS. This approach also can be used to guide us layering and building other web ontology languages on top of RDFS.
This section briefly introduces a Predicate-Ordered Sort-Ordered Logic (POSOL). It extends a well-defined order-sorted logic [3] to model the essential RDFS constructs.
A POSOL signature å = (S, £, F, P, £P) consists of:
(1) A partially ordered set of sorts (S, £ ) with a least element ^ and a greatest element T. (S, £) is called the sort hierarchy.
(2) An S* ´ S-indexed family of disjointed sets of function symbols { Fw ,s | wÎ S*, S ÎS}. For f Î Fw, s , w is called the domain and S the range sort of f, and the elements of w are the argument sorts of f. We use F(n) to denote the set of all n-ary function symbols.
(3) An S*-indexed family of disjointed sets of predicate symbols {Pw | wÎ S*} . For PÎ Pw, w is called the domain of P, and the elements of w are the argument sorts of P. Pe is assumed to be empty. We use P(n) to denote all n-ary predicate symbols.
(4) A partial order £ P,n on P(n) for each positive integer n. Usually we also use the notation £ P instead £ P,n to denote the partial order on P(n) without ambiguity.
In this paper, we suppose å is always a signature with equality and sort predicates except otherwise specified. In addition, we use POSOLm, n to indicate the POSOL language in which the arities of the predicates and functions are no more than m and n, respectively.
For a given POSOL signature å , a family of variables over å is an S-indexed family V of variables {Vs | SÎ S}. The well-sorted å -terms and å -formulae over V are defined following the conventional approach [3]. The ground term and å -sentence are defined as usual. A POSOL knowledge base < å , K> consists of a POSOL signature å = (S, £ , F, P, £P ) and a set of å -sentences K.
Given a POSOL signature å =(S, £ , F, P, £P ), an interpretation I of å , or simply an å -interpretation , consist of:
(1) An S-indexed family of sets {Is | SÎS} such that A^ =Æ , and Is' Í Is for S' £ S . Is is called the carrier of the sort s, and IT the universe of the interpretation.
(2) An S*´S -indexed family of functions {If Î Is1 ´ ... ´ Isn ® Is | fÎFs1, ... , sn, s }.
(3) An S*-indexed family of relations {Ip Í Is1 ´ ... ´ Isn | P Î Ps1, ... , sn } such that IQ Í IP for Q £P P.
Basically, the top sort is interpreted by a nonempty universe of discourse, the bottom sort is interpreted by the empty set, any other sort is interpreted by a subset of the universe, and the subsort relationship is interpreted by the subset relationship. Furthermore, the predicates are interpreted as relations on the corresponding subsets, and the partial order on the predicates is interpreted as the inclusion of the corresponding relations.
The satisfying relationship between the å-interpretation and the å -formula is defined as usual, so is the model of <å , K> . A theorem on the equivalence of POSOL knowledge bases is given (available at http://xobjects.seu.edu.cn/publication.htm), which can be used as the bridging between the POSOL and the order-sorted logic without ordering on predicates. This means that a POSOL knowledge base can be reduced to that of the conventional order-sorted logic.
In the most use cases of web ontology languages, such as RDFS and OWL, people and machines needn't to define following constructs:
(1) A class of classes (e.g. rdfs:Datatype, OWL:Class)
(2) A class of properties (e.g. rdfs:ContainerMembershipProperty, OWL:TransitiveProperty)
(3) A property about classes and/or properties, (e.g. OWL:equivalentClass, rdfs:subPropertyOf, rdfs:range)
These constructs are built-in constructs within a given ontology language. If people really need more powerful constructs of these kinds other than provided by existing ontology languages, they should build a new ontology language by defining new constructs of these kind, usually specify these constructs by using RDF Schema as well as a natural language. Of course, this kind of specification is not enough to clarify the complete meaning of these constructs. In this case, RDF Schema takes the role of specifying modeling primitives. Another role of RDFS is of as an ontology language, which is the main focus of this paper. A subset of RDFS as an ontology language can be given by restricting the usage of RDFS core primitives, e.g. it's forbidden to specify a new class of classes, a new class of properties, a new property about classes or properties.
From an RDFS graph, we can get a POSOL signature of the graph as follows:
(Sig1) An rdfs:Class is mapped to a sort, and an rdfs:subClassOf relationship is mapped to a subsort relationship.
(Sig2) An rdfs:Resource with rdf:type S is mapped to an instance (i.e. constant) of type S, say some C Î Fe , s.
(Sig3) An rdfs:Resource without typing is mapped to an instance (i.e. constant) of type T , say some C Î Fe ,T.
(Sig4) An rdfs:Property is mapped to a predicate, and an rdfs:subPropertyOf relationship is mapped to an ordering relationship between corresponding predicates.
(Sig5) An rdfs:Property with rdfs:domain S1 and rdfs:range S2 is mapped to a typed predicate,say some P Î Ps1, s2.
Let's take the predefined RDF collections vocaburary ( rdf:List, rdf:nil, rdf:first, rdf:rest) as an example, they are mapped to four symbols in a POSOL signature, such as List Î S, nilÎFe , List , first Î PList,T , restÎ PList,List. Another example is about RDF Literals, they are mapped to two ordered sorts, such as XMLLiteral < Literal.
Note that we should add the sort predicates to the POSOL signature of an RDFS graph, and the partial orderings on sorts and predicates should be the closure of the generated orderings. It is worth noting that the POSOL signature of an RDFS graph belongs into POSOL2, 0, and it only contains the sort predicates as its unary predicates.
As we know, there may have multiple rdfs:domain constraints and/or multiple rdfs:range constraints on a property, and multiple rdf:type constraints on an rdfs:Resource. These additional constraints can be can be mapped to å -sentences. From an RDFS graph, we can get a set of å -sentence, say K, as follows:
(Sen1) An rdfs:Resource C with additional rdf:type constraint S is mapped to a å-sentence, e.g. S(C).
(Sen2) An rdfs:Property P with additional rdfs:domain constraint S is mapped to a å-sentence, e.g. "X : T . (( $Y : T. P (X, Y) ) Þ S(X).
(Sen3) An rdfs:Property P with additional rdfs:range constraint S is mapped to a å -sentence, e.g. "Y : T . (( $X : T. P (X, Y) ) Þ S(Y).
(Sen4) An ordinary triple without blank node is mapped to a å -sentence, e.g. P(C1, C2).
(Sen5) For triples with blank node, they are divided into several groups according to the equivalence closure of a relation, which is defined as follows: if two triples have a same blank node as their ends (the subject or object of the RDF statement), we call the two triples are related with blank node. Each such group of triples related with blank node is mapped to one existence qualified å -sentence, e.g. $X : T. ( P1 (C1 , X) Ù P2 (X, C2) ), not the conjunction of multiple existence qualified å -sentences e.g. ($X : T. P1 (C1 , X)) Ù ($ X :T. P2 (X, C2)).
The <å , K> generated from a given RDFS graph by using above mapping schema is called a POSOL2, 0 knowledge base of the given RDFS graph. As we know, the generated POSOL2, 0 knowledge bases of a given RDFS graph may be different due to the different algorithms used in generating, but they should be equivalent which is guaranteed by the equivalence theorem (see section 2). More important, the meaning of a given RDFS graph can be described by using the model of the corresponding POSOL2, 0 knowledge base.
As described above, POSOL2, 0 can be used to describe the formal meaning of RDFS at ontology language layer. In addition, the RDFS graph can be analyzed under this framework. For example, rule (Sen2) implies that the knowledge base of an RDFS graph will contain universal qualified sentences if the graph contains multiple assertions of a property with unordered classes as its rdfs:domain.
Within the framework of POSOL, OWL can also be analyzed. Intuitively, the POSOL knowledge base of OWL allows more complex forms of å -sentences. We believe that POSOL can be used as a rigorous logic framework for ontology languages. Furthermore, it can be used to guide us layering and building the web ontology languages. Further research includes the mapping from OWL into the POSOL knowledge base and the efficient inference system for POSOL.
This research work is supported by NSFC with grant no. 60173036.