W3C home > Mailing lists > Public > www-webont-wg@w3.org > September 2002

Re: SEM: Reaching consensus (was Re: third version of semantics document)

From: pat hayes <phayes@ai.uwf.edu>
Date: Fri, 6 Sep 2002 01:53:26 -0700
Message-Id: <p05111b0cb99df894089a@[65.212.118.251]>
To: Jim Hendler <hendler@cs.umd.edu>
Cc: www-webont-wg@w3.org

>At 6:48 AM -0400 8/29/02, Peter F. Patel-Schneider wrote:
>>From: Jim Hendler <hendler@cs.umd.edu>
>>Subject: Re: third version of semantics document
>>Date: Wed, 28 Aug 2002 17:38:05 -0400
>>
>>>  At 10:48 AM -0400 8/28/02, Peter F. Patel-Schneider wrote:
>>>  >As an indication of how things can go wrong in a complicated 
>>>specification,
>>>  >Pat's document is very close to implying that all RDFS classes and
>>>  >properties are OWL objects.
>>>
>>>  [snip]
>>>
>>>  >
>>>  >peter
>>>
>>>  Peter, for those of us who are not as logically inclined as you,
>>>  could you make it clear why the above would be a problem and what the
>>>  consequences would be? If someone asked me "Should RDFS classes and
>>>  properties be OWL objects" I would have assumed the answer should be
>>>  yes
>>>    thanks
>>>    JH
>>
>>The first paragraph of section 1 of the document states that individuals
>>are not classes or properties.  QED
>>
>>peter
>
>I didn't ask you to prove it, I asked you to help some of us 
>understand what it means in practice and what the implications would 
>be.

Well, surely Peter's brevity makes the point that the answer is kind 
of obvious. OWL has been *defined* so that OWL classes are not 
individuals (so cannot be in classes themselves, for example.) But 
RDFS classes *are* individuals, and *can* be in RDFS classes (eg 
rdfs:Class is the class of all classes.) So clearly, RDFS classes and 
properties cannot be in OWL classes.

>The reason for this is simple, and I think ALL of you logic oriented 
>folks need to think about it a bit:
>
>  The consensus approach means that many of us in the WG who do not 
>read model theories by training or parse XML in our sleep must also 
>be convinced the solution is a good one.  Currently the abstention 
>camp outweighs those voting, and it is this group that will actually 
>be crucial to making the decision.

I will abstain from making the obvious sarcastic response at this point.

>
>As I have often in the past, I quote our charter:
>
>>  The  Working Group shall start by evaluating the technical 
>>solutions proposed in the DAML+OIL draft. If in this process the 
>>Working Group finds solutions that are agreed to be improvements 
>>over solutions suggested by DAML+OIL, those improved solutions 
>>should be used.
>
>note the word AGREED - if we don't have consensus on this issue, 
>with more than a small group of logicians stating it is solved, we 
>are not done -- the rest of the WG will need to be convinced.

Well, nobody is stopping anyone on the WG from reading anything. In 
other WGs Ive been connected with, it is usually the case that some 
technical issues are not fully understood by everyone on the group, 
and in those cases the decision is left to the subgroup of people who 
do have the relevant technical competence.  (As an example, I 
regularly switch my brain off when anyone uses the words 'XML' and 
'valid' in the same sentence.)

>
>Further, I point out the following from our charter
>
>>1.2.2 Formal Semantics
>>
>>Moreso than for a traditional programming language, a knowledge 
>>representation language needs a formal semantics to clearly 
>>delineate what is, and is not, entailed from any particular 
>>language construct or combination thereof. Such a formal semantics 
>>may be in a denotational or axiomatic form. Examples of both of 
>>these have been produced for DAML+OIL, providing examples of what 
>>is necessary for the WebONT language products.
>
>Note that this does not mandate us to do a denotational (model 
>theoretic) semantics) - and we've been told be several people in the 
>current debate that an axiomatic (and I think Lbase would count) 
>approach would be easier.

As a proponent for Lbase, let me say that the idea isn't really to 
provide an alternative semantics, so much as an alternative way of 
presenting the same semantics. That is, the idea would be to use 
Lbase as a kind of common semantic framework. One should be able to 
read off a model theory from the Lbase translation. I think that 
posing the issue in terms of MTs *versus* Lbase translations is 
misleading, and that the phrase 'axiomatic semantics' is an oxymoron.

>I think we all agree we would like a formal semantics including a 
>model theory.  I am willing to believe that good progress is being 
>made, and that we have at least a chance of reaching a consensus. 
>However, if the bulk of the WG is not convinced, the charter allows 
>us a lot of leeway to simply point at the weak D+O  MT and write 
>some stuff about the changes our successor group might want to 
>consider (i.e. resolve some of the semantic issues as POSTPONED). 
>So helping the rest of us in the WG understand the ramifications of 
>your approaches IS important.
>
>I know that I have more logical training and AI background than some 
>people in this WG, but the current conversation is reaching a point 
>of obtruseness that I simply cannot follow - which implies the same 
>is true of some other WG members.  I am therefore reminding ALL 
>sides of the semantic camp that helping the rest of understand the 
>issues is part of what you need to do.

OK, let me try to explain the particular issue here in more detail 
and give some background.

Any class-based language has an implicit notion of what counts as a 
'class'. Formal set theories developed by mathematical logicians have 
tried to come up with 'universal' theories of sets (ie classes) but 
there is no single, universal formal theory: each theory captures its 
distinctive notion of set. The mathematical logicians have spent a 
lot of time and effort over many years trying to show that various 
formal set theories are equivalent, but they usually aren't.  The 
best that one can usually do is to show that they one of the theories 
is consistent if the other one is. One particular set theory - 
Zermelo-Fraenkel, commonly known as ZF - has come to be regarded as a 
kind of touchstone, but that is because it has been the easiest to 
use in practice and the one that most others have been proven 
relatively consistent with, not because it is 'right'.  If there is 
one single fact that has emerged from about a century of formal logic 
and foundations of mathematics, it is that the notion of 'class' - 
'set' if you like - is both in some sense primary and basic to all 
mathematical thinking, and also impossible to capture exactly in a 
single formalism. To repeat, this is inevitable: different languages 
will come with different notions of 'class'.  As a recent example, 
Peter Aczel defined a set theory that allows sets that contain 
themselves. This is explicitly forbidden in almost all the previous 
formal set theories (including ZF) because it was felt that this was 
risking the Wrath of the Russellian Gods, but Aczel showed that his 
set theory was relatively consistent with ZF, ie if that is 
consistent then it is too, which is another way of saying that it is 
as kosher as any set theory can get. But the universe of Aczel's set 
theory contains sets that are impossible in ZF.

Now, RDFS takes a very generous view of classes, partly inspired by 
Aczel's work (and some feel, too generous). For example, it allows 
classes of classes, it allows 'mixed' classes (eg a class containing 
people, numbers and properties); it allows classes to contain 
themselves; it allows classes of ANYTHING.  (This isn't an accident, 
by the way. It is designed to be as unrestricted as possible, since 
it aims to be a kind of universal fit-anything base for a variety of 
further extensions.)  OWL, on the other hand, takes a much more 
restricted view of what counts as a class. It does not allow classes 
to contain other classes, or to contain properties. This means that 
one cannot simply smurge together the RDFS and OWL worlds and assume 
that 'class' means the same thing in the two languages: there are 
RDFS classes which would break the OWL rules. When putting RDFS and 
OWL together, one has to say that the OWL classes only have members 
from the OWL universe, which is smaller than (ie a subclass of) the 
RDFS universe. Similarly, OWL properties are more restricted than RDF 
properties; RDF is similarly catholic in what it allows as 
properties, eg one can have a property whose values are other 
properties, or one can have a thing which is both a class and a 
property. Neither of these are legal entities in the OWL world. Hence 
the need for the range and domain restrictions on the OWL vocabulary 
when it is embedded in RDF.

I would add that in general, we should expect that any two class 
languages taken at random might have *incompatible* assumptions about 
their universes, just like ZF and Aczel's theories do.  Avoiding this 
possibility with RDFS is one of the motivations for RDFS being so 
inclusive about what it allows to be a class. On the other hand, this 
very feature almost guarantees that other languages will take a 
different view of 'class' from RDFS. We can hope and expect that 
other languages' universes will turn out to be rdfs:subClassesOf the 
RDFS class universe, but that is the best we can reasonably hope for.

Peter's point in the above message was that the conditions as stated 
almost had the consequence that the entire RDFS vocabulary was 
'inside' the OWL universe. Which you might wish for, but which is 
like wishing that a pint jug could hold a gallon.

Hope this helps.

Pat

-- 
---------------------------------------------------------------------
IHMC					(850)434 8903   home
40 South Alcaniz St.			(850)202 4416   office
Pensacola,  FL 32501			(850)202 4440   fax
phayes@ai.uwf.edu 
http://www.coginst.uwf.edu/~phayes
Received on Friday, 6 September 2002 04:59:07 GMT

This archive was generated by hypermail 2.2.0+W3C-0.50 : Monday, 7 December 2009 10:57:52 GMT