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: Mon, 26 Aug 2002 00:07:19 -0700
Message-Id: <p05111b02b98f751dd599@[65.212.118.251]>
To: graham wideman <graham@wideman-one.com>
Cc: Frank Manola <fmanola@mitre.org>, Brian McBride <bwm@hplb.hpl.hp.com>, www-rdf-comments@w3.org

>Folks:
>
>OK, I'm up way too late, and a couple of messages from Pat arrive. 
>Now, with all due respect to Pat, who I assume is diligently 
>reflecting the customary way of describing RDF features,
>I find these great examples of things that are way difficult to get 
>traction upon (ie: just when I thought I knew something, Pat now 
>makes me think I don't! :-).

Sorry.

>So, just on a couple of fundamental points from Pat...
>
>1.
>a.
>>there isn't a sharp distinction in kind between a category of
>>classes and a different category of non-classes.
>
>...and then...
>b.
>>What makes something a class is just that it has some
>>things in it and [...]  rdf:type is what puts
>>things into a class
>
>OK, a and b seem directly contradictory. Surely applying rdf:type is 
>a pretty clear cut act, which to me looks like a "sharp 
>distinction". What the "in kind" means here I'm not sure... is 
>"kind" an RDF concept?

OK, let me take a step backwards. It is often assumed that there is a 
basic distinction ('in kind')  between classes, on the one hand, and 
the things in classes (individuals or instances or some such word is 
often used) on the other hand. On that view, there is a clear a 
priori conceptual distinction between two kinds of thing: classes, 
and the things that are in classes.   My point was that RDF does NOT 
take this 'layered' or 'stratified' view of the world. It allows 
classes to contain anything, including other classes; and it allows 
anything to act as a class. So there really isn't anything that 
*cannot* be a class in RDF, and there isn't anything that *cannot* be 
in a class.
The other thing about RDF is that it is an open-ended assertional 
language: its always possible to take some RDF and then add some more 
RDF to it and so learn more about the things being talked about. So 
at some stage you might not know that something is a class, but then 
later you might find that something has it as a type, so it is a 
class after all.

>Now, I could buy a description along the lines of "any resource can 
>play the role of class". But I'm currently resistant to believing 
>that, because (i) if it's that simple why doesn't somebody just say 
>so,

We did say so, and you said it was difficult to get traction on. :-)

>and (ii) what then is the point of rdf:type...Class.

Its just a way of saying that something is a class, ie it has some 
things in it, ie something has it as its value of the rdf:type 
property.
[Added later: actually, one could have a class with no things in it 
(an empty class), so strictly speaking a class need not actually be 
the value of an rdf:type. But the other way round certainly holds: if 
it is an rdf:type value, then its in rdfs:Class. That is one of the 
RDFS closure rules in the MT:
aaa rdf:type bbb .
-->
bbb rdf:type rdfs:Class .
]

>The more complicated assertion of "we don't regard a resource as a 
>class until something else treats it as a class" has a degree of 
>specificity that seems to suggest some nuance that I don't 
>understand.

Wow, I didnt follow that.  What kind of specificity are you talking 
about? I think you are seeing complexity where none exists. There 
isnt a hidden agenda here: a class is just a set, in effect.
Henry rdf:type ex:Feline .
just says that Henry is in the set of felines, ie that Henry is a cat.
ex:Feline rdfs:subClassOf ex:Mammal .
says that all cats are mammals. Its just basic set theory, nothing 
cunning or subtle about it.

>What suddenly happens to that resource once you realize that it's 
>been refered to, and is now, presto, considered a class? I'm fairly 
>sure nothing important,

Nothing at all. In fact I find it hard to follow your meaning here. 
What do you mean, 'suddenly happens' ? Nothing HAPPENS to the 
resource just because you find out some new facts about it.

>but this assertion has me vigilant.
>
>And that vigilance is triggered a few sentences later, where Pat says...
>
>2.
>>bwm:AClass rdf:type rdfs:Class .
>>Both the subject and object here are classes. All this says is that
>>bwm:AClass is in fact a class.
>
>... but what Pat said previously which would lead us to expect that 
>AClass is *not* in fact a class until some resource points an 
>rdf:type at it.

See above about empty classes (Sorry I gave a misleading impression.) 
But, look. You can never conclude for sure that something is NOT a 
class. Even if nobody has yet said anything about it that would make 
you think it is a class, they could always say that later, or you 
could learn it from somewhere else, and so it could be a class for 
all you know. But learning that wouldnt *change* it into a class. I 
might tell you lots of things about Henry without telling you that he 
is in fact a cat; but when I tell you that, he doesn't suddenly 
*become* a cat; he was a cat all along, but you just didn't know it.

>(Or maybe Pat meant to say that the above rdf:type causes AClass to 
>"be" an rdfs:Class, even though it's not yet a lowercase-class?). 
>Uggg.

No, no. Nothing is CAUSING anything. RDF really is not a programming 
language; its a descriptive language.

>
>Ie: all this makes me less able to assemble a coherent model of RDF 
>classness than I was a couple of emails back. :-(
>
>---------------------------------
>
>I'm totally prepared to hear that RDF supports the equivalent of 
>multiple inheritance (ie: multi subClassOf's), and that any resource 
>may or may not behave as a class in its own right (through some 
>action of rdf:type or otherwise). But I'm just having a devil of a 
>job mapping the discussion in the primer and in these emails onto a 
>single coherent set of features. All this discussion of sets, 
>extensions, Venn diagrams, examples of red-haired humans and 
>anything else not directly about the actual features of actual RDF 
>is not helping to understand actual RDF.

BUt RDF is a descriptive language: its *intended* for talking about 
things like red-haired humans and sets of things like cats and 
paintings and fish and goodness knows what. Those are the features of 
actual RDF. RDF classes aren't restricted to classes of 
datastructures, they are supposed to be classes of actual *things*.

>I repeat my previous recommendation (here slightly embellished, to 
>simply list the actual RDF *things* that are worthwhile 
>distinguishing, tell what their *features* are, and what the 
>*relationships* among them are. Specifically, as an initial guess at 
>this enumeration:
>
>Things of interest:
>-------------------
>    -- resource

Anything is, or can be, a resource. 'Resource' just means 'entity'.

>    -- resource that can act as a class

As far as RDF(S) is concerned, any resource can act as a class. Of 
course, if y'all want to keep a strict separation between classes and 
non-class things that are in the classes, then RDF doesn't *prevent* 
you doing that, but it also doesn't enforce it.

>    -- resource with special powers granted by rdf:type...Class

There are no special powers granted by being a class.

>    -- rdf:type

this is the membership relation between a thing and a class that the 
thing happens to be in. It is written in mathematics as a Greek 
lower-case e. Its often called 'is-a' or some similar name, as in: 
Henry is-a Feline.

>    -- rdfs:subClassOf

A is a subclass of B just when every member of A is a member of B. 
That's all there is to it: there is no inheritance or 'transferring' 
between the classes. This isn't OOP.

>
>Features
>--------
>
>-- What features does a resource have?

I do not know what you mean by 'feature'.  In RDF, resources have 
property values. Exactly what property values a resource has is 
open-ended, but they are required to have the ones that are asserted 
by RDF triples.

>
>-- What features beyond this does a class resource have?

A 'class resource' is any resource which is in rdfs:Class. Usually 
that will involve being the value of rdf:type for something. That is 
all there is to being a class resource. There are no special 
'features' of class resources.

>Resolving this would be very illuminating. Pat claims no added 
>features other than being referenced by rdf:type, but later seems to 
>contradict this; I previously had convinced myself that there must 
>be additional features but now am unsure.

Unconvince yourself :-)

>
>-- What features beyond this does Class have?

None.

>More illumination eagerly awaited here.
>
>Relationships
>-------------
>-- What features does rdf:type transmit from one resource to another?

None. The question is meaningless, in fact. (What do you mean by 
'transmit' ?? Relations between things don't do any transmitting, 
they simply hold. Think of the relation of fatherhood, for example.)

>  And maybe this involves "if the value is Class then rdf:type also 
>transmits X, Y, Z".
>
>-- What features does subClassOf transmit from one class to another?
>
>----------------
>....Much of this being parallel to Piotr's suggestion to discuss 
>"simple summary of the "features" of class-ness".

There are no 'features' of class-ness. This request seems to presume 
the idea that I tried above to dispel, that 'class' is a kind of type 
or category.

>
>OK, time for bed,

Me too.

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 Monday, 26 August 2002 13:32:17 GMT

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