Re: Draft Minutes 2001-08-24

Brian, could we put this item on the agenda for the next telecon, 
please.  I would like to get this issue settled before we publish the 
model theory, if possible.

---------------

rdfs:subClassOf loops and consistency with DAML+OIL.

At the F2F we discussed a number of pieces of feedback from the 
DAML+OIL JC. The only one that gave rise to any  significant 
discussion was their recommendation that the M&S be modified to allow 
subclass loops, ie that combinations such as

A rdfs:subclassof B
B rdfs:subclassof A

not be considered illegal, but be thought of as a way to assert that 
A and B are the same class.  Two voices were raised against this 
proposed change. One was the opinion that  disallowing subclass loops 
was accepted practice in the OO community, the other was that it 
would be incompatible with Java usage, and that if subclass loops 
were permitted then Java-based RDFS engines would need to perform 
expensive loop-detection checks to avoid syntax errors when mapping 
RDFS to Java. (I hope I have this more or less right, it is based on 
memory.) I was to report this feedback to the DAML JC and get their 
reaction, which I did today and here it is, summary first and more 
details later.

Summary
1. DAML+OIL absolutely requires subclass loops, and cannot operate 
with the current rdfs:subclassof restriction.

2. Therefore, if RDFS retains its current no-loops restriction, the 
only viable option for DAML+OIL would be to remove subClassOf from 
the rdfs namespace and to adopt its own daml:subClassOf with the 
DAML+OIL interpretation.

3. But this would have the unfortunate effect of breaking the only 
remaining substantial link between RDFS and DAML+OIL, which would be 
unfortunate for a number of reasons.

4. Therefore, DAML+OIL respectfully urges the RDFCore WG to 
reconsider the matter more carefully.
------

Elaborations.
1. DAML+OIL requires subclass loops because:
1a. When merging information from several sources, one needs to be 
able to discover during the reasoning process that two classes are 
equal (even when nobody has explicitly said they are). This ability 
is central to the class-heirarchy reasoning that is at the core of 
DAML+OIL.
1b. In any case there is no effective way to limit the language so 
that such conclusions (that one subclass is identical to another) are 
somehow forbidden.
1c. It is also not feasible to consider the no-subclass-loops 
restriction a syntactic wellformedness constraint (as it is in Java 
and OO more generally) since to check it requires general inference 
machinery. Since it can't be parse-time checkable in any reasonably 
expressive class-inference language, there is no advantage to 
imposing it as a semantic constraint.

2. If DAML+OIL introduces its own subClassOf, the only relationship 
between daml:subClassOf and rdfs:subClassOf would be that the latter 
entails the former. But this means that RDF/S engines would not be 
able to make any use of DAML subclass information, in effect 
rendering the  DAML class heirarchies invisible to RDFS. (DAML could 
make use of rdfs:subClassOf information, but only by also using other 
information which is not expressible in RDFS, eg that A is *not* a 
subclass of B. ) It would set up a one-way flow of information from 
RDFS into DAML. In practice, one would expect that DAML+OIL usage 
would simply become detached, in practice, from information expressed 
in RDFS, since the class heirarchy is the only nontrivial semantic 
connection between DAML+OIL and RDFS.

3. The development of DAML+OIL was predicated on the assumption that 
the languages would be 'layered' in some sense, so that each layer 
provided more expressive functionality than lower layers. The 
possible option in which DAML+OIL uses a more inclusive notion of 
subclass but RDFS uses a more restictive notion would make this 
'layering' so distant as to be effectively meaningless. Moreover, 
this is not an arbitrary or capricious decision, since almost any 
reasonably expressive extension of RDFS is going to have similar 
properties.

5. As a postscript, the JC offers the following observations.

5a. In general, the ability to say that one class is identical to 
another is valuable, and probably essential when putting together 
information from several different sources. Allowing subclass loops 
is an elegant way to anable the language to say this without 
introducing any new primitives. (This was one of the main motivations 
for the DAML+OIL usage, in fact, but the reasoning seems to apply to 
RDFS with just as much force.)

5b. DAML+OIL inference engines would need to detect subclass loops 
during their normal inference operations, and could (and indeed 
currently often are) be required to flag such loops when detected, 
allowing other engines, or users, to take aappropriate actions if 
required. In other words, don't feel that all is lost if the language 
allows subclass looping.

-----

Pat Hayes
---------------------------------------------------------------------
(650)859 6569 w
(650)494 3973 h (until September)
phayes@ai.uwf.edu 
http://www.coginst.uwf.edu/~phayes

Received on Tuesday, 28 August 2001 18:53:40 UTC