Reifying OWL2 properties with property chains

When working with biological taxa, we encounter a difficulty with OWL in that we want to state that there are relationships between taxa, but we also want to decorate and add data to those relationships. One simple example is that we want to say that the “Domestic Cat” taxon has sibling taxon “Lion” (because both of them are “Cats”), and that this relationship was discovered prehistorically.

There’s a tension. On the one hand, using a property “isChildOf” allows us to reason over taxon hierarchies. But doing it that way make it difficult to add metadata. OWL annotations don’t really do the job. The OWL DL and OWL RDF semantics are different around the are of annotations, and if you use annotations you wind up with a tower of meta, when the fact that the fact that Lions are Cats was discovered prehistorically is data, not metadata from our point of view.

There is a natural and useful way to have it both ways, however, and it involves OWL2 property chains.

---

The usual example given for property chains is the telescoping of the “grandparent” relation – A parentof B and B parentof C allows us to infer A grandparentof C. This is useful so far as it goes. Let’s start there and define a simple ontology for Taxa.

We define Taxon as a class, with properties parentof, childof, decsendantof, ancestorof, and siblingof. We define some obvious relations:

• parentof and childof are inverse;
• ancestorof and dscendantof are inverse, and they are also both transitive;
• siblingof is transitive and symmetrical.

This means that taxa will be “siblingsof” themselves … except in the special case when they have no other siblings. We’ll make the property reflexive so that taxa with no siblings do not become a special case.

We now define some property chains … but a declaration of transivity is (in effect) already a property chain. So many of the chains of interest to us are already implicitly in place.

The relation of parentof to ancestorof is interesting. You might think that these rules

• A parentof B ancestorof C → A ancestorof C
• A ancestorof B parentof C → A ancestorof C

would do the job … but where’s the bootstrap? You have to add:

• A parentof B parentof C → A ancestorof C

But this seems unneccesarily complicated. And it is. Think about this: what if there are only two taxa? You still need the relation there … but there’s no chain! Or just a chain of one. And that makes it all much clearer, because a chain of one is simply an OWL subclass relation. If you declare that the parentof relation is a subclass of ancestorof, then the transivity of ancestorof takes care of all these other rules.

So really, we are left with one property chain:

• A childof B parentof C → A siblingof C

Here’s the source code for our simple taxonomic vocabulary.

Now let’s define a simple ontology.

• Animal is an ancestor of Cat.
• Cat is a parent of DomesticCat.
• Lion is a childof Cat.
• Tiger is a childof Cat.

Here’s the source code for that simple ontology.

Once these files are loaded into protege 4.1, we find that the HermiT reasoner can indeed deduce that Tiger is a descendant of Animal, and all the other implied links that we want. But this doesn’t help us with our original problem – adding attributes to those properties.

---

In order to decorate taxon relationships, we need to pull the relationship out into a taxon relationship object. This is the method used by the TDWG ontology (see TaxonConcept#Relationship). Lets do this too – pulling out the relationships in our simple ontology into “Relationship” objects, and adding a “relationshipDescription” title to them. Protege 4 won’t let me use anonymous individuals, so I’ll just name them rel1 … rel 4. I will go to some trouble to use types rather than attributes to indicate the kind of relationship, for reasons that will soon become apparent.

The new vocabulary is here, and the new ontology is here.

This is ok, it allows us to add as much information as we wish to the relationships, but we have lost the power to infer connections.

---

The final step is quite simple. We create a property chain that says “if two taxa are joined by a ParentOf relationship object, then that implies the existence of a isParentOf property.” The rule is

• A hasParentofRelation B targetTaxon C → A parentof C

These rules are here, and an ontology pulling it all together is here.

And … that’s it! the HermiT reasoner can now infer that Tiger is a descendant of Animal and a sibling of DomesticCat, by way of relationship objects that are appropriately decorated. Really, the only thing that remains to be done to back-fit this to the TDWG ontology is to create a rules that say:

1. A TaxonRelationship object with a type equal to “parent of” is a ParentTaxonRelationship object
2. A hasRelationship property whose value is a ParentTaxonRelationship object is a hasParentRelationship property

Regrettably, protege 4.1 won’t let me specify classes by HasPropertyRange declarations. As soon as they do, we are sorted.