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.
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.
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.