W3C home > Mailing lists > Public > www-rdf-comments@w3.org > January to March 2003

Issue #pan-01 Re: Comment on Last Call Working Draft of RDF Semantics document concerning treating classes and properties as objects

From: Brian McBride <bwm@hplb.hpl.hp.com>
Date: Tue, 18 Feb 2003 11:35:29 +0000
Message-Id: <>
To: "Jeff Z Pan" <pan@cs.man.ac.uk>, <www-rdf-comments@w3.org>


With Pat responding that your comments are not editorial, I'm going to try 
to identify the comments you are making for consideration by the WG.


At 21:15 14/02/2003 -0800, Jeff Z Pan wrote:

>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:

Ok - I think you are saying you are trying to extend RDF(S) to some 
(proper?) subset of FOL and are having problems.  Yes?  The rest of this 
message is an explanation of the difficulties you are experiencing.  This 
looks like a single issue to me, so I'm giving it one id:


Pat, please provide further guidance if I've got this wrong.

We'll be back in touch once the WG has considered you're comment.


>*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
>different languages [8], Lbase must at least be expressive enough to allow
>  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
>directly mapped to logical implication in Lbase, but must be explicitly
>or axiomatised as, e.g.rdfs:subClassOf(class1,class2). That is, the
>  rdfs:subClassOf from RDF and the logical implication from FOL are not
>  to the same thing in Lbase, which means there are no (or far less than
>  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
>[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 Tuesday, 18 February 2003 06:34:49 UTC

This archive was generated by hypermail 2.3.1 : Tuesday, 6 January 2015 21:15:20 UTC