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 POSOL_{2, 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 { F_{w
,s} | wÎ S*,
S ÎS}. For f Î F_{w, 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 {P_{w} |
wÎ S*}
. For PÎ P_{w}, w is called
the domain of P,
and the elements of w
are the argument sorts of P. P_{e} 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 POSOL_{m, 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 {V_{s} | 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 {I_{s} | SÎS} such that A_{^}
=Æ , and I_{s'}
Í
I_{s} for S' £ S . I_{s} is called the
carrier of the sort s, and I_{T} the universe of the
interpretation.

(2) An S^{*}´S
-indexed family of functions {I_{f} Î
I_{s1}
´ ...
´ I_{sn} ®
I_{s} | fÎF_{s1, ... , sn,
s} }.

(3) An S*-indexed family of relations {I_{p}
Í
I_{s1}
´ ... ´
I_{sn} |
P Î P_{s1, ... , sn} } such that I_{Q} Í I_{P} 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
Î
F_{e , s}.

(Sig3) An rdfs:Resource without typing is mapped to an
instance (i.e. constant) of type **T** , say some C Î
F_{e ,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 S_{1} and
rdfs:range S_{2} is mapped
to a typed predicate,say some P Î P_{s1, 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ÎF_{e , List} ,
first Î
P_{List,}_{T} , restÎ
P_{List,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 POSOL_{2, 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(C_{1}, C_{2}).

(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.** ( P_{1}
(C_{1} , X) Ù P_{2}
(X, C_{2}) ), not the conjunction
of multiple existence qualified å
-sentences e.g. ($X :
**T.** P_{1}
(C_{1} , X)) Ù
($
X :**T.** P_{2}
(X, C_{2})).

The <å ,
K> generated from a given RDFS graph by using above mapping
schema is called a POSOL_{2, 0} knowledge base of the
given RDFS graph. As we know, the generated POSOL_{2, 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 POSOL_{2,
0} knowledge base.

As described above, POSOL_{2, 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.**

- Peter F.Patel-Schneider, Dieter Fensel. Layering the Semantic
Web: Problems and Directions. In
*Proceedings of the first International Semantic Web Conference 2002 (ISWC 2002)*, Sardinia, Italia. - J. Pan and I. Horrocks. Metamodeling architecture of web
ontology languages. In
*Proc. of the First Semantic Web Working Symposium (SWWS'01)*, 131-149, 2001. - Beierle C, Hedtstuck U, etc. An Order-Sorted Logic for
Knowledge Representation systems.
*Artificial Intelligence*1992, 55:149-191.