W3C home > Mailing lists > Public > www-webont-wg@w3.org > May 2003

Revised proposed response to: rdf:about and owl:sameIndividualAs oddities

From: pat hayes <phayes@ai.uwf.edu>
Date: Fri, 30 May 2003 18:06:39 -0500
Message-Id: <p0521060ebafd92023fa1@[]>
To: Jim Hendler <hendler@cs.umd.edu>, www-webont-wg@w3.org

Suggested response, following Dan's correction:
Dear Jimmy

Re. your comment

I'd like to try to clarify some aspects of the OWL and RDF design, by 
responding to some of the points in your message:

>>I've been reviewing OWL, and a strange idea occurred to me.  In rdf,
>>"blank nodes" are distinct resources.  However, the "thing" that they
>>are describing is undefined [1].

Er..that is rather a nonstandard way of putting it and may be 
misleading. They do not identify any particular thing, true; but its 
not that they are describing a particular undefined thing, more that 
they are noncommittal about what the thing is. Think of a blank node 
as being like the words 'something' or 'someone' in English. If you 
say, "Joe wrote #foobar"  then you aren't exactly contradicting or 
denying the claim "Joe wrote something", you are just saying more 
about it. Notice that it would be a logical mistake to conclude from 
"Joe wrote something" that there was a special 'blank' thing called 
"something" that Joe had written.

>>The following is an example:
>>	<dc:creator>Roy G. Biv</dc:creator>

Something has Roy as its dc:creator, ie Roy wrote something.  OK.

>>However, using OWL, I could identify the resource by identifying a
>>resource which is the same as the blank one:

Well, the locution "the blank one" isnt strictly correct, as there 
isnt a single 'blank one'. Better to say, you could find out more 
about the resource that you were previously unable to identify with 
precision.  For example, you might discover later what it was that 
Joe wrote, and add that information to your OWL knowledge, and then 
be able to draw more useful conclusions (about Joe, for example). In 
general, you might find out anything: for example, you might go 
through finding out that it was a book he wrote (but you don't know 
which book) , that the book that he wrote had a co-author called Bill 
J. Hickory (you still don't know which book) and later that Bill J. 
Hickory is the author of only one book, called "The perils of Ruth" - 
now you know what book Joe wrote. Only the last stage would enable 
you to replace a blank node with an actual name.

>>	<owl:sameIndividualAs rdf:resource="#foobar" />
>>	<dc:creator>Roy G. Biv</dc:creator>
>>However, the meaning of the above statements is equivalent to a
>>"non-blank" node describing "#foobar", as in:
>><rdf:Description rdf:about="#foobar">
>>	<dc:creator>Roy G. Biv</dc:creator>

Right. In other words, if you already know what it was that Joe 
wrote, it is kind of redundant to also say that he wrote something. 
The two forms above are roughly like saying in English

Joe wrote something which was #foobar


Joe wrote #foobar

which amount to saying the same thing, in effect, since you can infer 
either of them from the other.

>>One could theoretically define the identity of all objects in that

Not sure what you mean. Certainly, it would be possible to take any 
OWL triple (Using Ntriples notation):

ex:foo ex:Property ex:baz

and replace it with

_:x ex:Property ex:baz
_:x owl:sameIndividualAs ex:foo

and the two are equivalent. And since they are, the second form is 
kind of confusing (not wrong, but confusing) since one might easily 
think, when reading it, why didn't they just write the first one?

The chief utility of owl:sameIndividualAs is not for writing out 
facts like the above in a more long-winded form, but for being able 
to *conclude* - infer -  that two names are names of the same 
individual (eg because they are both values of a functionalProperty 
applied to the same thing, or both subjects of an 
InverseFunctionalProperty with the same value). And since this kind 
of inferring is so useful, it would be a mistake to deprecate it.

>>However, that would be confusing.  Should identifying blank
>>resources with OWL, instead of RDF, be depreciated?
>>I think that having two mechanisms for identifying a resource is "messy"

It might be messy, but such mess is useful. The central idea of OWL 
on the SW is to support useful inferences, and inferring new facts is 
inherently messy in this sense because you can't always pre-guess 
*how* exactly the facts are going to be generated. Often it is best 
to allow for alternative ways to the same conclusion because one of 
them might be easier to find than another, or some of them might be 
impossible to use in some circumstances.

>>and makes the grammar combination of RDF+OWL inconsistent.

It doesn't make the grammar inconsistent. There is some redundancy, 
but as I explain above, this kind of messiness is actually useful, 
even essential, in an inferential language. OWL is highly redundant 
in this sense: often the 'same' thing can be said in  many different 

>>Except for
>>different ranges, owl:sameIndividualAs (range=resource) and rdf:about
>>(range=string) mean the same thing.  The extra syntax seems redundant.

I think there is a slight category mistake here. rdf:about is part of 
the RDF/XML syntax; it isn't a property in itself: rather, it is what 
attaches a property to the subject of a triple (or triples). So it 
doesn't really have a range in the RDFS sense. sameIndividualAs, on 
the other hand, is a genuine property, which can be used not only to 
attach a name to a blank node but also has many other uses, since it 
can be used to express identity between URIrefs.

>>If rdf:about was an actual property, then the two concepts could be

I see what you mean, but this would allow the 'combining' to be done 
only in this particular use case, which is not the primary intended 
use for owl:sameIndividualAs (and not really a very interesting use 
case, in fact); and only in the XML syntax, which is only one of the 
possible concrete syntaxes for RDF. And moreover, this *would* make 
the RDF grammar inconsistent, since rdf:about would then have two 
incompatible uses (as your example below illustrates, in fact.)

>>Furthermore, if the property-as-attribute abbreviation for
>>rdf:type was applied to rdf:about as well, then the abbreviated syntax
>>would be identical to the 1999 xml-serialization syntax [2].  However,
>>this would still allow the equivalent owl:sameIndividualAs
>>representations, such as the below example:
>><rdf:Description rdf:about="http://www.w3.org/TR/html4/strict.dtd">
>><rdf:about rdf:resource="urn:publicid:-:W3C:DTD+HTML+4.01:EN" />
>>The above seems much more intuitive than the OWL version:
>><rdf:Description rdf:about="http://www.w3.org/TR/html4/strict.dtd">
>><owl:sameIndividualAs rdf:resource="urn:publicid:-:W3C:DTD+HTML+4.01:EN"
>>Or even:
>>Just an idea [3].

In sum: owl:sameIndividualAs is basically the OWL version of 
equality. You point out (correctly) that there is little point in 
writing things like 'x property baz and x = foo' when you could just 
as well write 'foo property baz'; but the moral isn't to forbid or 
deprecate the use of equality, which has many other uses as well as 
this rather redundant way of expressing a simple fact.

In view of the above, are you still interested in pursuing your suggestion?


Pat Hayes

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 Friday, 30 May 2003 19:06:41 UTC

This archive was generated by hypermail 2.4.0 : Friday, 17 January 2020 23:04:45 UTC