W3C home > Mailing lists > Public > www-rdf-comments@w3.org > July to September 2002

Re: RDF Issue rdfs-clarify-subClass-and-instance

From: pat hayes <phayes@ai.uwf.edu>
Date: Tue, 20 Aug 2002 20:55:32 -0700
Message-Id: <p05111b06b988a305f053@[65.212.118.251]>
To: Frank Manola <fmanola@mitre.org>
Cc: graham wideman <graham@wideman-one.com>, Brian McBride <bwm@hplb.hpl.hp.com>, www-rdf-comments@w3.org

Guys:

>Graham, Brian--
>
>Thanks for the comments.  Actually, I think the situation is both 
>less complicated and more complicated than you've described it, as 
>I'll try to explain below.
>
>graham wideman wrote:
>
>>Brian:
>>
>>Heh heh heh, your writing is helpful in tone, though I'm not sure 
>>whether I'm getting clearer or muddier :-)
>>
>>1. You are right that *part* of what's confusing is the phrase "(or 
>>some subclass of rdfs:Class)". Absent that phrase, I would believe 
>>that if a resource Description has a property
>>rdf:type...Class
>>
>>then that resource is a Class, and otherwise it's not.  (If we 
>>can't delete that phrase, then I have no idea how to distinguish a 
>>Class from a non-Class.)

A class is a thing with other things in its class extension, ie with 
a nonempty class extension. Don't think of Class versus non-Class as 
a category distinction. In RDFS, anything can act as a class.

>I'm grateful for Brian's confidence in my infallibility, but I've 
>also received a comment from Peter Patel-Schneider on this, and on 
>looking at it carefully, I've decided that the inclusion of the 
>phrase "(or some subclass of rdfs:Class)" is wrong (or at least 
>unnecessarily confusing),

It certainly is not wrong.

>and the current Primer Editor's Draft (which has not yet been made 
>public) doesn't include it.   The phrase was included originally 
>because it was copied from the original RDFS Schema specification 
>(the March 2000 Candidate Rec).  However, there is nothing in that 
>document that actually illustrates that particular usage (all the 
>subclass examples are declared with rdfs:type...Class, and none of 
>the diagrams show it).   There's nothing in the current Schema draft 
>that says anything about this either.

Well, OK, but I really don't see why it is considered confusing. If 
something is in a subclass of rdfs:Class then it must be in 
rdfs:Class, right? (Imagine a Venn diagram with one bubble inside 
another and a dot in the inner bubble.) What is confusing about that?

>  Moreover, nowhere do we explain the ramifications of declaring a 
>new class by using an rdf:type property to point to a subclass of 
>rdfs:Class.

But we do this all the time.  There are no ramifications, other than 
saying that the 'declared' class (that is a very bad word to use, but 
never mind) is a member of a class of classes; in other words, it is 
a class. After all, if it were a member of a class of rabbits then it 
would be a rabbit, right?.

>Mind you, I think Brian's example works, at least up to the point 
>where we can't say anything about the class hierarchy of bwm:AClass, 
>and at that point it seems a little counterintuitive (and I think 
>we'd need to look carefully at that, were we to continue to want to 
>talk about classes being defined by having their types be subclasses,

No no no. The use of rdf:type is just saying that something is in a 
class. That is,
A rdf:type B
says that A is in the class (extension of) B. No more, no less. 
Rdfs:Class is supposed to be the generic class of classes. There are 
many interesting subclasses of rdfs:Class which someone might want to 
classify a class as belonging to, however. For example, owl:Class and 
owl:Restriction are both proper subclasses of rdfs:Class. In general, 
the 'heirarchy' of subclasses of rdfs:Class can get arbitrarily deep. 
In fact, most classification languages will use a notion of class 
that is more restrictive than rdfs:Class, so for example if there 
were a formalization of UML in RDFS then it would need to explicitly 
restrict itself to something like uml:Class (just as OWL does) since 
there are RDFS classes which are illegal in UML (or OWL).

>but I'm hesitant to have the Primer continue to use that phrase 
>without that investigation).  However, see my response to the next 
>point:

No investigation is required, but I think the phrase is OK. Maybe it 
needs some elaboration to guard against misunderstanding.

>
>
>>Or maybe the escape hatch is that it's possible to write:
>>
>>rdf:type...SomethingThatsNotAClass
>>
>>Is that legit? If it is (and I'm now thinking it is) then the 
>>earlier sentence in the primer:
>>"The RDF Schema *type* system allows resources to be defined as 
>>*instances* of one or more *classes*."
>>... is kind of misleading, since apparently the type system (ie: 
>>the system using the keyword "type") can define resources to be of 
>>something other than classes as well.
>>
>
>
>This is where things may appear a little complicated.  In the first 
>place (at least as far as I know), rdf:type doesn't require that its 
>object (the thing it points to) be a Class

Yes it does. That is, it hardly amounts to a 'requirement', but the 
object of any rdf:type triple must be a class in RDFS simply by 
definition, because the truth of that very triple guarantees that it 
has something (the subject) in its class extension. You could of 
course make anything into a class in this sense: for example if you 
assert

ex:whatever rdf:type ex:PatHayes .

then (if what you say is true) I'm an RDFS class. I might well be, 
for all I know.

>, nor does it require that an application that uses rdf:type even 
>use RDFS (note the "rdf:" namespace on rdf:type).  The intent is 
>that it be used for "type-like" things,

That phrase doesnt make sense. Anything can be 'type-like' as far as 
RDFS is concerned.

>but it doesn't specifically require RDFS classes

That seems to assume that 'RDFS classes' is a kind of category, like 
fish or furniture. But that way of thinking is a mistake. They are 
all RDFS classes, but that isn't any kind of constraint or 
requirement. The notion of 'Class' in RDFS is about as elastic as it 
is possible to be.

>;  so users could "roll their own" type systems if they wanted (or 
>point to classes or types from DAML, OWL, or some other language 
>that defines "type-like" things).

Right, they could; and when they do, they make those things, whatever 
they are, into RDFS classes. RDFS is designed to be a 'fit-all' 
system; it doesn't come with its own notion of 'class' pre-defined. 
Its a general-purpose system for reasoning about almost *any* notion 
of 'class' which anyone might dream up.

>   So "the RDFS type system" allows instances to be declared as 
>Classes, but RDF doesn't require that only RDFS classes be used (nor 
>does it require that an application even think that there *are* such 
>things as RDFS classes).  This is a point of interaction between RDF 
>and RDFS that may require a little more explanation.

I think this way of putting it is highly misleading. It suggests that 
RDFS has one notion of 'class' that might or might not be suitable 
for some purpose. We should carefully guard against giving that 
impression

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 Wednesday, 21 August 2002 05:01:32 GMT

This archive was generated by hypermail 2.2.0+W3C-0.50 : Friday, 21 September 2012 14:16:30 GMT