Search Mailing List Archives


Limit search to: Subject & Body Subject Author
Sort by: Reverse Sort
Limit to: All This Week Last Week This Month Last Month
Select Date Range     through    

[protege-owl] Please help: complement of a class?

Scott L Holmes scottlholmes at gmail.com
Tue Jan 8 13:27:41 PST 2008


Pardon the interruption but Thomas, you are very close to explaining why I
had so much difficulty with individuals when I attempt to implement a
sequence pattern as described in [1].

After creating my sequence of individuals, I was unable to construct a class
that answers the query "What is the last item in my list?". Creating an
individual of class EmptyList as described in [1] makes no sense to me and
leads pretty quickly to inconsistencies. Also I see no way in OWL to infer
some thing that doesn't have some thing related to it. So I'm at a loss at
how to infer the last item in the list if you are only able to describe it
as that list item not followed by anything.

Scott

[1] Putting OWL in Order: Patterns for Sequences in
OWL<http://owl-workshop.man.ac.uk/acceptedLong/submission_12.pdf>,
Nick Drummond, et. al.

On Jan 8, 2008 12:21 PM, Thomas Russ <tar at isi.edu> wrote:

>
> On Jan 7, 2008, at 11:24 PM, Johann Petrak wrote:
>
> > On 2008-01-08 01:55, Thomas Russ wrote:
> >> Short answer:  Open world reasoning will make this nearly impossible.
> >>
> > hmm, I still have some hope because of the word "nearly" :)
> >
> >> Long answer is inline.
> >>
> > Thank you for your detailed explanation!
> >
> >>
> >> You can do that, but there has to be a way for the OWL reasoner to
> >> prove that those individuals CANNOT be members of ASub1, in order to
> >> know that they belong to ASub2.  The fundamental problem lies is
> >> providing enough information to allow such a proof.
> >>
> >
> > Yes - it seems I am still puzzled about what information is necessary
> > to make that proof possible.
> > I thought that when I state as a necessary condition for A
> >   hasRange only B
> > that means that in order to be a valid member of A, something must
> > have a hasRange to B if it has a hasRange to B (or doesnt have
> > a hasRange at all).
>
> Yes.  That is correct.  And this inference is one that OWL and its
> reasoners make successfully.
>
> >> The key phrase 's "know to not have".  With open world, just because
> >> the system doesn't know of a filler does NOT mean that the system
> >> knows that there isn't a filler.  The upshot of open world reasoning
> >> is that any reasoning that requires AllValuesFrom ("only") or maximum
> >> cardinality restrictions, including the special case of zero fillers,
> >> are hard to prove.  OWL does not support "negation by failure".  The
> >> main guideline for open world reasoning is:
> >>
> >>    Absence of proof is not proof of absence.
> >>
> >> So, what you have is an individual with no known fillers of property
> >> hasRange.  But there is nothing to allow us to conclude that there
> >> are
> >> no unknown or as-yet unknown fillers of property hasRange.
> >>
> >> If you want to have the inference succeed, then you must be explicit
> >> about the lack of filler.
> >>
> >> One way to do that would be to make this individual be an instance of
> >> the restriction class (max 0 hasRange).  That explicitly tells the
> >> reasoner that there are NO fillers of the hasRange relation, and
> >> therefore, the individual cannot belong to ASub1.  The additional
> >> restrictions will therefore allow inference about membership in
> >> ASub2.
> >>
> >>
> >
> > OK, but that would mean that I have to make an explicit assertion
> > about
> > every member in A that does not have a hasRange filled with B
> > and that essentially defeats the purpose, because I wanted to
> > *derive* that fact. What I really want to do is make a general
> > assertion
> > about all members in A that says that they must have a haveRange B
> > or no haveRange B and *then* conclude from the absence of haveRange B
> > that the contrary must be the case.
>
> But that is precisely a "negation by failure" form of reasoning that
> uses a Closed World Assumption. But since OWL is required to use open
> world reasoning, you can't have that.
>
> > I thought that this was called a "closure axiom" and I wondered
> > what I got wrong about providing it. Or what kind of closure
> > axiom one could provide for A instead.
> >
> > Is it possible to solve this by providing a closure axiom on
> > hasRange B such that I can determine memebers of ASub2 without
> > explicitly asserting the absence of hasRange B for each member
> > of A?
>
> Not in OWL with open world reasoning.  You have to have explicit
> positive assertions.
>
> > In other words, can I make a necessary condition for A so that unless
> > a member has hasRange B asserted, it must have max 0 hasRange.
>
> No.  That requires closed world reasoning.
>
> You would have to be explicit in providing the "max 0 hasRange"
> assertion.
>
> > And if not -- is there a pattern to make this kind of problem
> > easier to deal with? I assume it is not a rare requirement to
> > derive the membership for an individual based on the absence of
> > some property. Obviously, when I create an instance and fill
> > the form for hasRange, I cannot somehow fill it in a way that
> > says "known to be empty", but that is what I would like to
> > do.
>
> Well, in the interface, you could add the "max 0 hasRange", or more
> generally a "max N hasRange" if there are N fillers given.  In essence
> that is used to tell the system that all of the known fillers are all
> of the fillers.  Of course, this also requires that all of the fillers
> be declared to be "allDifferent", since OWL doesn't and is not allowed
> to assume that individuals with different names are different from
> each other.  That also needs to be explicitly asserted.
>
> The simplest way to add the "max 0 hasRange" restriction is to either
> create a named class with N&S condition "max 0 hasRange" and then use
> it for assertions, or else to create an anonymous class (using the
> Protege API) with that definition.  Then assert that the individuals
> have that as one of their types.  By building your own
>
> >
> > How do people usually deal with this?
>
> If they can't do the sort of manual closure given above, then they try
> to avoid the need to do closed-world reasoning in OWL.
>
> Some people also use other knowledge representation and reasoning
> systems which support closed-world reasoning.
>
> _______________________________________________
> protege-owl mailing list
> protege-owl at lists.stanford.edu
> https://mailman.stanford.edu/mailman/listinfo/protege-owl
>
> Instructions for unsubscribing:
> http://protege.stanford.edu/doc/faq.html#01a.03
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mailman.stanford.edu/pipermail/protege-owl/attachments/20080108/d240792c/attachment.html>


More information about the protege-owl mailing list