Re: Comment on Last Call Working Draft of RDF Semantics document concerning treating classes and properties as objects

I agree with you in that RDFS has a non-standard metamodeling architecture.

Although the current RDF Semantics [1] is better than previous version, it still intertwists the ontology language layer and meta-language layer. In other words, RDF Semantics [1] 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. 

Two comments:
1) As an ontology language (at L layer [2]), RDFS should have a clear and fixed semantics based on a subset of FOL (or other well known Logic such as Order-Sorted Logic). The semantics of OWL (as an extension of RDFS at L layer) can be defined by using the same approach.

2) As a meta-language (at M layer [2]), RDFS should have another semantics (not as the current one).


Yuzhong Qu
Dept. of Computer Science and Engineering, Southeast University
Home Page: http://cse.seu.edu.cn/People/yzqu/en
Research Group: http://xobjects.seu.edu.cn

[1] RDF Semantics (ed Pat Hayes)  http://www.w3.org/TR/rdf-mt/

[2] J. Pan, I. Horrocks, Metamodeling architecture of web ontology languages. In Proceedings  of the first Semantic Web Working Symposium (SWWS'01), pages 131-149, 2001. http://www.semanticweb.org/SWWS/program/full/paper11.pdf


----- Original Message ----- 
发件人: "Jeff Z Pan" <pan@cs.man.ac.uk>
收件人: <www-rdf-comments@w3.org>
发送时间: 2003年2月15日 13:15
主题: Comment on Last Call Working Draft of RDF Semantics document concerning treating classes and properties as objects


> 
> 
> Recent research (http://dl-web.man.ac.uk/rdfsfa/paper.htm) has shown that
> RDF Schema (RDFS) has a non-standard metamodeling architecture, which makes
> some elements in the model have dual roles in the RDFS specification.  As a
> result, this can be confusing and difficult to understand and,  more
> importantly, the specification of its semantics requires a non-standard
> model theory - RDF MT. RDF MT justifies dual roles by "treating classes and
> properties as objects", which seems to be ok within RDFS. However, this
> leads to semantic problems when we extend RDFS with more expressive FOL
> constructs, and extend RDF MT to the so called ``RDF+ MT'' to give meaning
> to this extended language:
> 
> *Problem 1 (Too few entailments) [1]: In "RDF+ MT", closure rules are used
> to represent semantic conditions to facilitate entailment. However, if the
> expected class and/or property  objects are not in the universe, then the
> related closure rules are not expressible, which hence leads to too few
> entailments. E.g., does "John type (A and B and C)" entail "John type (B
> and A)"? No, because the class object "B and A" might not exist in every
> interpretation which satisfies " John type (A and B and C)" .
> 
> In order to fix the problem, one can/should also introduce, besides the
> closure rules, comprehension axioms to add all the possible missing objects
> into the universe, e.g. the "B and A" object in the above example. In order
> to support FOL constructs in the extended language, a large and complex set
> of comprehension axioms (and closure rules) must be added  to capture the
> meaning and characteristic of its additional constructs. It is very
> difficult to get them right, and it is more difficult to prove that they are
> correct (adding enough but not too many objects into the universe).
> 
> *Problem 2 (Contradiction classes)[1,2]: Since class and property objects
> are distinguished from their extensions, one can then, in the extended
> language, define a class eg:C as an instance of itself, and add a
> cardinality constraint ``=0'' on the rdf:type property that pointing to
> itself. It is impossible for one to determine the membership of this class.
> If an object is an instance of this class, then  it isn't, because instances
> should have no rdf:type property pointing to itself. But if it isn't then it
> is. This is a contradiction class.
> 
> According to the comprehension axioms, we must add all possible class
> objects into the domain, and the above contradiction class is one of them.
> In this way, all the interpretations will have such contradiction classes,
> and thus have ill-defined class memberships.
> 
> *Problem 3 (Size of the Universe)[3,4]: treating classes and properties as
> objects also triggers a problem if we set constraints on the size of the
> universe. E.g. is it possible to have an interpretation s.t. Thing <=
> {John}, "John type Person", "John type not Car"? It is possible in FOL, but
> not in "RDF+ MT". In FOL, the interpretation of John, I(John), is the only
> object in the universe; the interpretation of Person, I(Person), is a set
> with only one element I(John); the interpretation of Car, I(Car), is an
> empty set. In "RDF+ MT", since classes are also objects, John, Person and
> Car should all be interpreted as the only one object in the universe.
> However,  since I(John) is in ICEXT(I(Person)), but not in ICEXT(I(Car)),
> I(Person) and I(Car) should be different. Thus there should be at least two
> objects in the universe. In other words, the required interpretation is
> impossible in ``RDF+ MT''.
> 
> This problem shows that the interpretation of RDF MT has different features
> than the interpretation of standard FOL model theoretic semantics. This
> raises the question as to whether it is possible to layer FOL languages on
> top of both the syntax and semantics of RDFS.
> 
> More details about the above three problems can be found in [4].
> 
> As a consequence of these problems, when DAML+OIL is layering on top
> of RDFS, it uses the syntax of RDFS only, but defines its own semantics [6]
>  for the ontological primitives of RDFS. Similarly, when the Web Ontology
> Language (OWL) is layering on top of RDFS, (slightly but necessarily)
> different semantics are defined for OWL DL and OWL Full [7].
> 
> Some people believe that Lbase [8] can provide a framework for specifying
> the semantics of all of the Web ontology languages in a uniform and coherent
> way. However, that might not be so straight forward. To make the model
> theory of Lbase as the model theory of all the semantic web languages so
> as to make it possible to use a *single* inference mechanism to work on
> these
> different languages [8], Lbase must at least be expressive enough to allow
> direct
>  mapping from RDF constructs into its constructs. But according to the
>  translation rules from RDF graph to Lbase in [9], e.g., rdfs:subClassOf is
> not
> directly mapped to logical implication in Lbase, but must be explicitly
> stated,
> or axiomatised as, e.g.rdfs:subClassOf(class1,class2). That is, the
>  rdfs:subClassOf from RDF and the logical implication from FOL are not
> mapped
>  to the same thing in Lbase, which means there are no (or far less than
> enough)
>  semantic interoperability between RDFS and FOL in the Lbase framework.[3]
> So the problem of layering FOL on top of RDFS still exists.
> 
> An alternative approach is RDFS(FA) (http://dl-web.man.ac.uk/rdfsfa/) [5,4],
> which as a sub-language of RDFS has a relatively standard model theoretic
> semantics, such that FOLs, e.g. DAML+OIL and OWL DL, can be built on top of
> both the syntax and semantics of RDFS(FA).
> 
> 
> --
> Jeff Z. Pan  ( http://DL-Web.man.ac.uk/ )
> Computer Science Dept., The University of Manchester
> 
> 
> [1] http://www-db.research.bell-labs.com/user/pfps/papers/dl-2002.ps
> [2] http://www-db.research.bell-labs.com/user/pfps/papers/layering.ps
> [3]
> http://www.cs.man.ac.uk/~horrocks/Publications/download/2003/HorrocksPatelSc
> hneider.pdf
> [4]
> http://www.cs.man.ac.uk/~panz/Zhilin/download/Paper/Pan-Horrocks-rdfsfa-2002
> .pdf
> [5]
> http://www.cs.man.ac.uk/~panz/Zhilin/download/Paper/Pan-Horrocks-rdfsfa-2001
> .pdf
> [6] http://www.daml.org/2001/03/model-theoretic-semantics.html
> [7] http://www-db.research.bell-labs.com/user/pfps/owl/semantics/
> [8] http://www.w3.org/2002/06/lbase/20030116Snapshot.html
> [9] http://www.w3.org/TR/rdf-mt/#Lbase
> 
>

Received on Saturday, 15 February 2003 01:06:18 UTC