Visions of Aestia

One of the issues I’m struggling with at the moment is the fact that OWL doesn’t really handle subclassing very completely. I’d be pleased to shown I am wrong about my assertions here.

In the OWL model I can:
- Add new properties
- Refine the domain or range of a property.

However, I cannot:
- Remove a property.
- Change the domain or range of a property to something completely different.

Frankly, these are not onerous restrictions. However, I think it’s important to remember that RDF is meant to be distributed; these restrictions make it difficult to code around errors or model poorly-defined domains.

If there is an error in a document, I have no standard way of using the definition sans error. Consider the following scenario.

animals.rdf

<owl:Class rdf:ID="mammal">
  ...
  <rdfs:subClassOf>
    <owl:Restriction>
      <owl:onProperty rdf:resource="#birthMethod" />
      <owl:hasValue rdf:resource="#liveYoung" />
    </owl:Restriction>
  </rdfs:subClassOf>
</owl:Class>

australia.rdf

<animals:mammal rdf:ID="platypus">
  <animals:birthMethod rdf:resource="animals.rdf#laysEggs" />
</animals:mammal>

Here, the first document encodes a common, if misleading, definition of a mammal. Mammals (usually) give birth to live young, and the original author mistakenly included this assumption in his ontology.

However, this definition is wrong. The platypus is a mammal that lays eggs. Clearly, the definition needs to be changed by removing the restriction, and if I in fact have control over both documents, this is easy to accomplish.
Thanks to the distributed nature of RDF, however, this may not be possible. What if I can’t correct the document or convince the author he is mistaken? I need a way to assert that the platypus is indeed a mammal, but an exceptional one that lays eggs instead of giving birth to live young (note that without cardinality restrictions I can say an animal does both).
The tack I would like to take is to define a special subclass of mammal, say egglayingMammals, that removes the restriction. But I don’t know of any way to do this short of defining my own, non-standard properties.

Now, the current fact is that most ontologies are currently being created by domain experts. But as RDF trickles down to the common developer, more and more ontologies are going to be hastily created without the input of domain experts, and will contain errors and contradictions that need to be coded around. I think we need a way to create definitions that lifts or ignores the restrictions laid down by a superclass. We need a way to assert that some parts of a definition or certain data must be ignored. We need a standard way to assert that something is wrong, or that a perceived contradiction can be ignored. It may be messy and inelegant, but frankly so is most code (and data) in the real world. Ever try to normalize address data?