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.

Advertisements

5 Responses to Reifying OWL2 properties with property chains

  1. Jim Croft says:

    I know there is not much choice in the matter, but notational terminology like ancestor/parent/child/sibling is problematic in biology where these terms are in wide use with different meanings. For instance, the relationship between leopard and lion is not that of sibling but one of shared class; the relationship between cat and animal is not one of descent, but one of nested class. As a cat, it is likely that lions have a particular type of cat as an ancestor, but to say cats are ancestors to lions is not only misleading, it is systematically and evolutionarily wrong. We need to be aware of this when talking ontologically.

    • Paul Murray says:

      I suppose so. “parent”, “child” etc are idioms in computing when dealing with tree structures. Computing, linguistics, taxonomy and so on are all dealing with similar problems, and the words we each use are terribly overloaded. My favourite example is ‘type’.

  2. Jim Croft says:

    Yes, don’t talk to me about ‘type’; my least favourite term in our domain. It may not matter, but what is nagging me at the moment is a deeper concern of the validity of representing classifications, which are essentially nested sets or boxes, as trees, which imply lineage, direction and descent. Maybe the model can handle both by happenstance, but I see them as different things. We should probably talk to @ghwhitbread to see if there is anything meaningful in this sophistry and whether anything needs to be done about it. Also interesting in and abstract sort of way, is that in logic, as opposed to computer science, ‘reification’ is the _fallacy_ of treating an abstract concept as if it were the real thing. :)

  3. Paul Murray says:

    As I understand it, biological taxa more-or-less do reflect the evolutionary history of life. At one time, there actually was a first population of cat-like mammals, and our cats are descended (literally, as in a chain of “begats”, a chain of “parentof”s) from them. cf the “mitochondrial eve”.

    I read something on the interwebs about this once – a taxonomist who played trumpet, and attempted to apply biological taxomomy to bass instruments. It didn’t work – instrument makers copy each other’s work, characteristics (“genes”, in a way) leap from family to family.

    Can’t find the URL.

    Anyway – I’m a computer programmer. This page was about OWL and RDF. I’m strictly an amateur philosopher.

  4. Paul Murray says:

    Ah ha! Protege will let me specify this kind of class, but it insists on manchester syntax. Sorted.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

%d bloggers like this: