- From: pat hayes <phayes@ai.uwf.edu>
- Date: Mon, 17 Feb 2003 18:31:02 -0600
- 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 UTC