On Tue, Nov 27, 2012 at 3:31 PM, Diane Hillmann <[log in to unmask]>wrote:

> P.S. BTW, one of the best things about RDA is the relationships, all of
> which have URIs:
> (relationships between
> Works Expressions Manifestations Items
> (roles). These
> vocabularies have just over 750 properties, but some are complicated by the
> necessity of describing properties separately when they relate to different
> classes.

Since this is not code4lib, I will not reproduce my seattle lightning talk
word for word :-)

If  a property  has the same meaning, but has different values  when
asserted about objects of different types, then you can use OWL Restriction
Classes to express this.

Restriction classes may seem  incredibly counterintuitive at first, but
after a while they will seem merely credibly counterintuitive.  So instead
of diving straight in, I'll describe a simple example in simple English.


(1) Everything which is eaten by something is a food.

(2) Everything that a carnivore eats is an animal.  Everything that eats an
animal is a carnivore.

(3) Everything that a herbivore eats is a plant.  Everything that eats a
plant is a herbivore.

(4) Every fly  is an animal. Every antelope is an animal. Every flytrap is
a plant.

(5) Fred is a fly. Audrey is a flytrap.  Ann is an antelope. Noel is a
grass.  Agatha is an antelope.

(6) Audrey eats Fred. Ann eats Audrey.  Ann eats Noel.

 Let's think about how this can be translated to OWL, then consider what
other sentences are entailed.

*Translating into OWL*
(1) is easy to handle; it's saying something  that is true for everything
that  is eaten by anything.   This corresponds to a basic RDFS range

ObjectPropertyRange(:eat :food)

(2) is where things start to get harder.  We want to say some things about
eating that only apply to carnivores and animals.
Let's look at the first part: "Everything that a carnivore eats is an
In a Description Logic like OWL, what we have to say is that
 "*the class of things that are eaten by some carnivore is a subclass of

SubClassOf(ObjectSomeValuesFrom(ObjectInverseOf(:eat) :carnivore)

The second part works similarly - "*the class of things which eat some
 animal is a subclass of carnivore*"

SubClassOf(ObjectSomeValuesFrom(:eat :animal)

The translation of the  herbivore is  similar.

SubClassOf(ObjectSomeValuesFrom(ObjectInverseOf(:eat) :herbivore)
SubClassOf(ObjectSomeValuesFrom(:eat :plant)

(4,5, and 6) are simple class, instance, and property value definitions, so
I won't go in to them here.

From our example, we can infer the following information

Agatha is an animal

Ann is an animal and a herbivore.

Audrey is a plant, a carnivore, and a food.

Fred is an animal and a food.

Noel is a plant and a food.

We know that Noel is a plant because he is eaten by Ann, who ate Audrey,
making an a herbivore, and everything she eats a plant.

But see what happens if we add a sentence

(7)  Ann eats Agatha.

Now we get the following inferences:

Agatha is *a plant,* an animal, and *a food*.

Ann is an animal, *a carnivore*, and a herbivore.

Audrey is a plant, *an animal*, a carnivore and a food.

Noel is a plant, *an animal*, and a food.

Fred is still an animal and a food.

This is an example of how the term "restriction class" can seem a bit of a
misnomer.  Under the OWL/RDF semantics,  positive assertions license more
inferences, rather than serving as constraints.  Unless you specify that
something is false, it won't be assumed to be so.

Agatha being eaten by Ann (who we already know is a herbivore)  means that
Agatha must be a plant.  Conversely, Ann eating an animal means that she is
a carnivore, which means that grassy Noel must be an animal.

If we add an assertion

(8) no carnivore is a herbivore,

If we  try to run a reasoner, it will kick.  Expunging  the  whole Ann
eating Agatha incident will bring things back to the status q. a.

  Sentences (1-8) are valid Attempto Controlled English (ACE); you can use
the  ACE tab in protege, or the  online tools at to translate them into OWL.