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

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

From: pat hayes <phayes@ai.uwf.edu>
Date: Mon, 17 Feb 2003 18:31:02 -0600
Message-Id: <p05111b05ba76cd02c659@[10.0.100.86]>
To: "Jeff Z Pan" <pan@cs.man.ac.uk>
Cc: <www-rdf-comments@w3.org>

Most of the issues raised by this comment have already been addressed 
in various archived email discussions, many of them concern other 
languages than RDF(S), and many of them are opinions rather than 
facts.

I will give a summary of my own personal responses in this message. A 
more formal response as Editor may follow later, after consultation 
with the WG.  Right now however I do not see in this message any 
comments which can be responded to editorially, since they do not 
directly impinge on the text of the RDF Semantics document but seem 
to be a much more broad-based commentary on the entire RDF enterprise.

-Pat
--------------

>Recent research (http://dl-web.man.ac.uk/rdfsfa/paper.htm) has shown that
>RDF Schema (RDFS) has a non-standard metamodeling architecture

Opinion. There are no 'standards' in this area. The paper cited makes 
this claim but does not establish it or give objective reasons to 
agree with it.

>, which makes
>some elements in the model have dual roles in the RDFS specification.

I would ask for this notion of 'role' to be clarified before giving a 
detailed response. The existing RDFS model theory does not recognize 
any 'roles'.

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

There is no such thing as a 'standard' model theory. The formal 
techniques used in the RDF MT are considered standard in several 
areas of formal semantics.

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

The term 'RDF+MT" is not used in any document I am aware of, so I am 
obliged to guess that you are meaning to refer to the OWL-RDF model 
theory.  If not, please explain further.

If so, the following problems were all mentioned and discussed, and 
have all been faced and solved, by the Webont WG in extending the 
RDFS model theory to OWL. There were no fundamental problems, in 
fact: a positive result that some of us found surprising.

>*Problem 1 (Too few entailments) [1]: In "RDF+ MT", closure rules are used
>to represent semantic conditions to facilitate entailment.

Strictly speaking that is not quite accurate. The normative model 
theory itself does not refer to closure rules: they are described in 
informative parts of the RDF semantics document in order to give a 
basic syntactic characterization of the valid inferences sanctioned 
by the MT, as a convenience for implementers of inference engines.

You may be referring to the extra closure semantic principles used in 
the OWL-RDF MT to ensure that the universe of discourse contains 
intersections, unions, etc.., a comment more properly addressed to 
Webont rather than the RDF core WG.  If so, see below.

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

This comment is ambiguous, but incorrect in either interpretation. If 
understood as referring to RDF(S), then it is simply inapplicable: 
the fact that there are not 'too few' entailments is shown directly 
by the lemmas in the RDF Semantics document. If it is understood as 
applying to a semantic extension such as OWL, then the relevant 
closure principles are in fact expressed explicitly in the OWL-RDF 
semantics document.

>  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 RDFS, the answer is because the relevant construction "...type (A 
and B and C) " cannot be directly expressed in this form. One can of 
course assert the three types separately, and the RDFS model theory 
then assigns the appropriate meaning and supports the appropriate 
entailments, trivally (subgraph lemma).

In a semantic extension, such as OWL, which does allow this kind of 
expressivity, the model theory does indeed need to be further 
constrained by imposing appropriate closure conditions. The OWL-RDF 
model theory does this, for example. However, *any* such semantic 
extension will *always* need to have suitable extra constraints 
added, since RDFS itself assigns no meaning to these constructs. So I 
fail to see the point of this observation or why it is considered to 
be a problem.

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

One should not do this in RDF(S), since their existence is not a 
logical consequence of the intended meaning of RDF(S). This addition 
would be a major change to the language. In OWL, the relevant closure 
principles (not comprehension axioms) are listed in the existing 
documentation.

>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

It is indeed tricky to get these semantics exactly right, but this is 
not the reason why. The hard issues arise from divergences of opinion 
regarding datatyping mechanisms, small but tricky details of XML 
syntax, things like that.

It is easy to write appropriate semantic closure conditions: they 
correspond to a typical form of entailment (with a conclusion that 
something of the relevant type exists) which can often be used as a 
test case in discussions, and can be generated semi-mechanically from 
the syntax. The fundamental model theory is in fact very robust, and 
does not itself create any theoretical difficulties of its own. The 
OWL-RDF MT consists of simple transcriptions of the original OWL MT 
into RDF notation, plus a catalog of the required closure conditions 
on the universe.  Getting the basic mapping correct took a few weeks 
in the case of OWL, the first time this task was tackled, and the 
time was largely taken up with misunderstandings about syntactic 
details. It would not have taken any shorter a time if the RDF(S) 
model theory were more 'conventional', since essentially the same 
issues would have arisen in that case, eg as a result of the use of 
the collection vocabulary in the OWL-RDF syntax. In fact, several of 
the technical devices that were needed in order to achieve the 
required layering utilize the special properties of the more general 
RDF model theory; the need to have an intensional interpretation of 
restriction properties is perhaps the most vivid of these. Without 
this, the OWL semantic layering would in fact have been impossible.

>, and it is more difficult to prove that they are
>correct (adding enough but not too many objects into the universe).

Actually it is pretty easy; there is a uniform technique available, 
based on Herbrand's theorem. Although some folk asserted that this 
difficulty would be great, it turned out to be a chimera.

>*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.

Indeed, it is. Your assertion (that the class existed) would be 
logically false, ie a contradiction, as you observe. So this comment 
amounts to the observation that it is possible to assert 
contradictions in a reasonably expressive language like OWL. But this 
is obvious, and would be true no matter what model theory we used, eg 
one can assert that some class has no more than 3 and no fewer than 4 
members, or that something is not equal to its intersection with 
itself, or any number of other logically impossible things. So I fail 
to see what point is being made.

This example has been discussed at enormous length and thoroughness 
in archived emails from the Webont working group starting over a year 
ago now, so there seems little point in raising this example at this 
late stage unless there is something new to be said about it.

>According to the comprehension axioms, we must add all possible class
>objects into the domain, and the above contradiction class is one of them.

That is incorrect. If we were so foolish as to claim a naive 
comprehension principle then we would be enmeshed in a Russel-style 
paradoxical contradiction, but no competent semanticist would make 
this classical mistake, and nobody on any WG has, to my knowledge. 
The extra semantic conditions one requires for OWL-RDF are based not 
on comprehension from assertions, but on a recursive closure 
principle applied to terms, in effect, like the Herbrand universe 
construction in first-order logic (and they can indeed be seen as 
instances of that construction applied to a suitable translation of 
OWL-RDF into FOL). Similar formal devices, suitably adapted, were 
used by Henkin to provide a first-order model theory for type theory, 
and by Aczel to provide a relative consistency proof for 
non-well-founded set theory. They are all based on the second 
recursion theorem, and hence have a well-understood mathematical 
basis.

>In this way, all the interpretations will have such contradiction classes,
>and thus have ill-defined class memberships.

False.

>*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 is formally correct, and has been noted before, also in archived 
Webont email discussions, but I do not consider it to be a 'problem'. 
The moral of examples like this is that one needs to pay attention to 
the semantics of the formalism when stating very general claims. The 
'naive FOL' assertion that there is only one thing, John, in the 
universe (I leave aside the point that to make any such assertion in 
a semantic web context is so ridiculous as to border on insanity) 
would translate not into the assertion that everything in the 
universe of discourse equals John, but that every *individual* in the 
universe of discourse equals John. If attention is paid to this minor 
point of how to use the formalism, then everything works out as 
intended and there is no problem. This point has been (heatedly) 
discussed in detail in the email thread which begins at 
http://philebus.tamu.edu/pipermail/kif/2002-September/001266.html;
see in particular 
http://philebus.tamu.edu/pipermail/kif/2002-September/001268.html.

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

The RDFS language allows existential quantification over properties 
and classes. This is part of the original design of the language, not 
something imposed on it by the semantics. Given this essentially 
syntactic property of the language, given the existence of deployed 
code which can handle this situation, and given our WG charter to 
clarify rather than change the formalism, it would have been 
irresponsible, in my view, to have insisted on imposing a textbook 
model theory which would have made many of the basic constructions of 
the formalism illegal or invalid; particularly when there is in fact 
no rational or mathematical requirement to impose such restrictions, 
as has been clear for approximately 15 years since Aczel's pioneering 
work, which has been used throughout applied philosophical logic but 
which has not yet found its way into undergraduate logic textbooks.

It is possible to layer FOL languages on the RDFS semantics. It is 
also possible to define FOL languages with RDFS-style semantics, such 
as the emerging Common Logic standard http://cl.tamu.edu/, submitted 
to ISO (ISO/IEC JTC1 SC32)

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

"Consequence" is inaccurate. At the time DAML was being specified, 
RDFS did not yet have a model theory; that is why the DAML MT does 
not refer to the RDF MT. OWL-RDF, an extension of DAML, uses the same 
basic syntactic embedding into the RDF graph but has a fully defined 
model theory which conforms to the RDFS model theory.

>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].

The reasons for there being two semantics have more to do with the 
syntactic restrictions imposed on OWL-DL for essentially 
computational reasons, and to satisfy the formal tastes of some 
members of the Webont working group.  The RDFS model theory applies 
to RDF, RDFS, OWL-Full and OWL-DL in a uniform way: it is the more 
'conventional' model theory for OWL-DL which causes the exception 
here.

----
The rest of this message concerns Lbase.
Lbase is a separate issue from RDFS, and is never cited normatively, 
but I will continue to respond as one of the Lbase authors.
-Pat
----

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

Indeed it might not.

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

That is a misleading way of expressing the intended aims of Lbase, if 
"work on" is supposed to mean "satisfy all the requirements of". The 
Lbase documentation explicitly denies any suggestion that Lbase be 
used as a uniform inference mechanism.

>, 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],

There are several styles of translation into Lbase possible, some of 
which do not reproduce the RDFS vocabulary in the Lbase translation 
in this way. The choice between them is a trade-off between ease of 
expressing the translation rules and simplicity of the resulting 
translation. I do not see any clear advantages to either option, but 
if one of them is felt inappropriate for some reason one has the 
option of using the other. They are strongly equivalent in an 
appropriate sense (which needs to be stated carefully, to be sure).

>  e.g., rdfs:subClassOf is
>not
>directly mapped to logical implication in Lbase, but must

"must" is not correct.

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

I have not yet read the work cited , but this claim is simply false. 
Or else I do not follow it. *What* 'logical implication from FOL' is 
being talked about here? And what particular syntax for FOL is being 
assumed?

>So the problem of layering FOL on top of RDFS still exists.

I was not aware that this had been mentioned as a problem by anyone. 
Surely the issue for us is mapping existing SW languages onto RDF, 
and that has been solved satisfactorily to the Webont working group 
for OWL. But in any case the most obvious problems in extending the 
OWL-style layering solution to full FOL are syntactic. When someone 
invents a way to encode quantifier syntax into RDF triples, I will 
bet that the OWL-RDF style of semantic embedding can be adapted to it 
reasonably directly. And in any case this has nothing particularly to 
do with Lbase, whose intended role is simply to be a uniform 
first-order syntax for expressing semantic conditions.

>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).

This is not a viable 'alternative approach'. It violates our WG 
charter; the restriction of RDF to a layered conventional FOL subcase 
with a conventional model theory would make the layering problem more 
acute and harder to handle, not easier (it would make the OWL-to-RDF 
layering impossible) ;  RDFS(FA) is a subset of RDFS, and hence is 
not incompatible with RDFS; and finally, although this is a purely 
personal opinion, I find layered syntaxes of this UML kind totally 
unacceptable for serious ontological work, and I know that many 
professional ontological engineers feel similarly; if anything, the 
pressure (eg from DAML-S and the military-intelligence and 
bioinformatics communities) is to allow for more expressivity, not to 
impose a useless, semantically unnecessary, user-stultifying and 
computationally expensive framework on the language for no good 
reason other than it seems to some users to be more conventional or 
'standard'; particularly when nothing in the present standard 
prevents one from adopting such a framework if they find it congenial.

Pat Hayes

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


-- 
---------------------------------------------------------------------
IHMC					(850)434 8903 or (650)494 3973   home
40 South Alcaniz St.			(850)202 4416   office
Pensacola              			(850)202 4440   fax
FL 32501           				(850)291 0667    cell
phayes@ai.uwf.edu	          http://www.coginst.uwf.edu/~phayes
s.pam@ai.uwf.edu   for spam
Received on Monday, 17 February 2003 19:31:19 GMT

This archive was generated by hypermail 2.2.0+W3C-0.50 : Friday, 21 September 2012 14:16:31 GMT