W3C home > Mailing lists > Public > w3c-rdfcore-wg@w3.org > August 2001

Re: Draft Minutes 2001-08-24

From: Brian McBride <bwm@hplb.hpl.hp.com>
Date: Wed, 29 Aug 2001 12:17:26 +0100
Message-ID: <3B8CCF46.5FAC5090@hplb.hpl.hp.com>
To: pat hayes <phayes@ai.uwf.edu>
CC: w3c-rdfcore-wg@w3.org
I'll ask Jema to put it on the agenda.  You haven't met Jema yet.  I'm
hoping to introduce her on Friday.

Brian


pat hayes wrote:
> 
> 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 Wednesday, 29 August 2001 07:20:57 EDT

This archive was generated by hypermail pre-2.1.9 : Wednesday, 3 September 2003 09:38:49 EDT