Re: A Problem With The Semantics of DAML+OIL Restrictions

> This "problem" was discussed at length when we were designing the
> language (if I did around in the mail archive I can find some examples
> similar to the one you provide above). Like it or not, this is what
> you get when you use rdf, as it provides no way to specify structural
> constraints on the kinds of thing you can write (you can "say anything
> about anything").
> 
> Having said that, and although the above style of multiple constraints
> are probably best avoided (in the interests of human
> read/understandability at least), they present no inherent
> difficulties and are comparable to stating the equivalence of two
> simple restrictions - I could say much the same thing as your
> Sam-Jones example with something like:
> 
>    (Type R Restriction)
>    (onProperty R parent)
>    (toClass R person)
> 
>    (Type R2 Restriction)
>    (onProperty R2 parent)
>    (hasValue R2 Sam-Jones)
> 
>    (sameClassAs R R2)
> 
> Of course, as in your example, we can now infer that the set of
> objects who have Sam-Jones as a parent is the same as the set of
> objects all of whose parents are persons. This may not be a very
> sensible thing to say, but you can say crazy things in any tolerably
> expressive language.
> 
> The (model theoretic) semantics are clear about the meaning of
> restrictions (whether multiple or single), and they shouldn't present
> any problems for a reasoner (beyond those that are already there due
> to the ability to state arbitrary equivalences).
> 
> We deliberately chose to avoid the "solution" of using the language
> (DAML+OIL) to constrain itself (e.g., by setting cardinality
> constraints on toClass etc) as we did not want to try providing a
> semantics for this kind of usage.

Unfortunately, I don't find your reply convincing.  Specifically, I
don't see how the RDF translation of a restriction tells us what the
sufficient conditions are for membership in the class specified by the
restriction.  At the risk of being repetitive, what can we conclude from
the following RDF statements in a file?

   (Type R Restriction)
   (onProperty R parent)
   (toClass R person)

We can certainly conclude that the parents of all objects that are type
R are persons.  However, how can we legitimately conclude that an object
all of those parents are persons is type R when the very next RDF
statement in the file may be "(hasValue R Joe)"?  Those four statements
together mean that in order to be type R an object has to have Joe as a
parent and all of its parents must be persons.  Thus, the first three
RDF statements give us a different set of sufficient conditions then do
the four RDF statements.  The problem is that if there is no way of
indicating that the definition of a non-primitive class is closed
("That's all, folks"), then there is no way for that definition to
provide a set of sufficient conditions for membership in the class.  The
other constructs in DAML+OIL for defining non-primitive classes (i.e.,
intersectionOf, unionOf, complementOf) have that closure property
because they are unique properties taking either a list as the value or
a single class (in the case of complementOf).  The restrictions are
open-ended and therefore don't work as specifiers of sufficient
conditions.

By the way, I think the model theoretic semantics suffers from the same
problem as the axiomatic semantics in this matter.  That is, both of
them seem to treat each constraint in a restriction as sufficient
conditions for membership in the class.  The constraints need to be
combined when there is more than one of them in a restriction.

Richard

Received on Tuesday, 3 July 2001 10:41:19 UTC