Re: [Use Case] ETRI-UC1: Filling the holes of OWL ontology

Hi all.

JH says:

> I'm just trying to get people to be very careful about what they  
> are claiming -- when we move to RL, we need to be careful about  
> what is required for grounding variables (i.e. the rule above would  
> be safe if you made it
> Uncle001: hasUncle(?x,?y) :- hasChild(?z,?x) ^ hasSibling(?z,?y) ^  
> Man(?y) ^ Person(?z) ^Person(?y)

Does this mean "DL safe"?

There is a perfectly nice (pre-)existing definition in logic  
programming of a "safe rule" by which the above rule (without the  
addition of the last two goals) is "safe".

Just want to make sure we're keeping our terminology clear.

> This open vs. closed world reasoning can get tricky, and even in  
> closed worlds, you have to be careful exactly what you are claiming.

That's an interesting point and I don't want to get us all off the  
track, but let's consider Jim's question again:

> umm, well, yeah sort of - there is an issue that if I tell you
>  Uncle(John, Mary) it is unclear to me that you could conclude from  
> the rules above that
>    hasChild(?z, Mary)

Right, if this is the only rule and you're assuming a prolog-like  
semantics.  Depends on what you want a "definition" of uncle to be  
and how much of the classical flavor of that you want to preserve in  
your rules.  If you want (switching to CLIF syntax with classical  
semantics for a second, if you'll allow) the definition to be:

(forall (x y z) (iff (uncle x y) (and (parent x z) (brother z y)))

then

(forall (x y z) (implies (uncle x y) (and (parent x z) (brother z  
y))), so
(forall (x y) (implies (uncle x y) (exists (z) (and (parent x z)  
(brother z y))))

with a skolem, you can turn this latter into two rules (switching  
back now to Prology syntax and semantics):

parent(X,f(X,Y)) :- uncle(X,Y).
brother(f(X,Y),Y) :- uncle(X,Y).

so if: uncle(mary,john), then

parent(mary,X), and
brother(X,john)

both follow.

> (or that it would be inconsistent for Mary to be in a class of  
> people who have no parents) without grounding the assertions (i.e.  
> using some sort of safe reasoning)

Well, aside from such a class being completely uninteresting except  
by virtue of being a purely logical construct on top of actually  
having parents...  :-D

But seriously, this is, I think, one of the central issues with the  
classical vs NAF/CWA, and Jim's point here really illustrates it  
well.  With languages like OWL-DL, you get classes like "people who  
have no parents" for free precisely *because* these languages blur  
the line between ontology and logic.  In exchange for that blurring,  
you get all the classical niceties without having to sweat the  
details.  Notice, however, that this does not follow from the use of  
classical logic.  Given something like CL (or OWL-Full), you can  
easily delineate your real classes (like people) from your logical  
constructions (people with no parents).

On the rule view, if you need such a class, then you can create it  
and axiomatize it.  For many, the following would work:

orphan(X) :- person(X), not child(X,Y)

If you don't like the NAF-ness of the "no parents" condition, then  
use a LP language that includes the classical negation

orphan(X) :- person(X), neg child(X,Y)

and, if you want the contrapositive and all that stuff I mentioned  
above, you can do that too.

I don't know what the right answer is in some global sense but I know  
it's not as simple as somehow painting the LP folks as being somehow  
naive or vague about what they "claim" just because they aren't  
making the assumptions that come with the use of (a particular) DL.

	.bill



Bill Andersen (andersen@ontologyworks.com)
Chief Scientist
Ontology Works, Inc. (www.ontologyworks.com)
1132 Annapolis Road, Suite 104,
Odenton, MD 21113
Office: 410-674-7600
Cell: 443-858-6444
Fax: 410-674-6075

Received on Tuesday, 13 December 2005 08:24:08 UTC