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

Having just caught up on this thread I feel the basic diconnect is in
the question, "How do we know what is the sufficient condition to
be a member of restriction R"?

You never do know.  You are only given some *necessary* conditions.

You have to replace the question "is this consistent with the
restriction R?" with "is this consistent with the document D?".

As you point out, R is just an abstract thing, a class.  And
anyone can say anything about anything, you don't know
whether there are any other constraints on it.
But that doesn't matter - the purpose of the restriction is
to restrict the main class, not to be exactly specified itself.
 
The Restriction does not define a set of data with which
one can talk about being consitent. The document does.
So it *is* iuseful to ask "what is the sufficient condition for
X to be consitent with everything in this document?"

Tim


----- Original Message ----- 
From: "Richard Fikes" <fikes@KSL.Stanford.EDU>
To: "Ian Horrocks" <horrocks@cs.man.ac.uk>
Cc: "www-rdf-logic" <www-rdf-logic@w3.org>
Sent: Tuesday, July 03, 2001 10:41 AM
Subject: 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 Wednesday, 18 July 2001 23:06:58 UTC