When to use rdf:Type vs rdfs:subClassOf

Question

I am fairly familiar with ontologies and OWL and use them all the time. But one idea has always eluded me and when I try to find a good answer there are always contradictions. That is, when to use rdf:Type vs rdf:subClassOf.

I mapped out the RDF, RDFS, and OWL ontologies as a graph in an attempt to understand the pattern and have also read several explanations. Let me start by sharing some links to the diagrams I made, as well as the explanations and why it hasnt reconciled for me.

RDF/RDFS Type chart:

RDF/RDFS Class chart:

OWL Type chart:

OWL Class chart:

Looking through this I see no obvious pattern that might explain the meaning of the two verbs. Though I do notice that while virtually every object has a type few of them have a parent class (explicitly).

Next when I look up the answer I get a lot of tutorials and they largely explain "Type" as indicating an individual. Similar subClassing is usually described as subsets with the classes being sets. So for example cat rdf:subClassOf animal makes sense but for type it would have to be something more like mittens rdf:Type cat. Thats all well and good but when I look at the ontologies I listed above this doesn't seem to match that idea.

For example FunctionalProperty is clearly not an individual but a set of properties that are functional (can only be applied once per object). So one might expect it not to have a type at all. Yet according to the schema FunctionalProperty is a type of Class, not a type of Property, but it is a subclass of Property. Why?

My guess, is that the individual vs set explanation is probably just not a good explanation. It seems it has more to do with what functionality is inhereted maybe? For example a FunctionalProperty has the same domain and range as its parent class Property, but a different domain and range than its parent type, which is just an unrestricted class... Maybe subclassing inherets restrictions where subtyping does not?

I also notice weird things where sometimes subPropertyOf is used for properties and other times subClassOf is used. For example FunctionalProperty is defined as a subClassOf Property and not a subPropertyOf it, which is what I'd expect.

Any explanation to help me understand when to use one vs the other would be very much appreciated, thank you.

Answer 1

I think you're right to think in terms of inherited functionality.

Consider your example of owl:FunctionalProperty. To say that owl:FunctionalProperty is a type of Class and not a type of Property, is to say that owl:FunctionalProperty is a Class and is not a Property. If owl:FunctionalProperty were a Property, it would make sense to use it as a predicate term in a triple-statement, right? Then, you would be able to say something like:

<individualA> owl:FunctionalProperty <individualB>

But this triple has no clear semantic meaning.

Since owl:FunctionalProperty is a Class, we can say that individual entities are members of that class. For example, we can define the property :hasMother as a type of functional property:

:hasMother rdf:type owl:FunctionalProperty

On the other hand, if owl:FunctionalProperty were a Property, this would not make sense. Properties, in RDF, do not have members. Only classes have members.

Similarly, owl:FunctionalProperty is a subclass of Property because it is a class of properties (a narrower class), not an individual property.

To summarize:

• owl:FunctionalProperty is a subclass of Property, rather than a type of property, because it is a class of properties, not an actual property.

• We can tell the above because owl:FunctionalProperty has instances/members, namely particular functional properties. Classes can have these, but Properties cannot. Also, it makes sense to use owl:FunctionalProperty as a subject or object in a triple, but not as a predicate. This also indicates that it is a class rather than a property.

Hope this makes sense.