- From: Adrian Walker <adriandwalker@gmail.com>
- Date: Tue, 5 Oct 2010 17:29:52 -0400
- To: Pavel Klinov <pklinov@cs.man.ac.uk>, public-owl-dev@w3.org
- Message-ID: <AANLkTinhfZeSPQZLP=09ppiZA-iirRmb_0FGZmu82xgb@mail.gmail.com>
Hi Pavel --
A belated reply to your note.
The question I'm worrying at is that I'd like to understand what we buy with
the added complexity of OWL over rules.
You wrote: *I'm not sure which semantics
your system implements.* The system is based on the model theoretic
semantics in [1], with decidable and terminating computation as in [2].
*...it would not entail, for example, that some subset of Person love cats
(e.g. "men love cats" although men are persons).*
This also seems easy using rules, as follows [3]
some-class1 is a subclass of some-class2
all people in that-class2 love items in some-class
---------------------------------------------------
all people in that-class1 love items in that-class
this-class1 is a subclass of this-class2
========================================
Men Human Beings
Women Human Beings
all people in this-class1 love items in this-class2
===================================================
Human Beings Cats
If possible, please point me to further examples in which OWL does things
that cannot reasonably be done with rules.
Thanks, -- Adrian
[1] Towards a Theory of Declarative Knowledge, (K. Apt and H. Blair, A.
Walker). In: Foundations of
Deductive Databases and Logic Programming, J. Minker (Ed.), Morgan Kaufman
1988.
[2] Backchain Iteration: Towards a Practical Inference Method that is
Simple
Enough to be Proved Terminating, Sound and Complete. Journal of Automated
Reasoning, 11:1-22
[3] One van view, run and edit this example by pointing a browser to
www.reengineeringllc.com and choosing HumansLoveCats2 .
Internet Business Logic
A Wiki and SOA Endpoint for Executable Open Vocabulary English Q/A over SQL
and RDF
Online at www.reengineeringllc.com
Shared use is free, and there are no advertisements
Adrian Walker
Reengineering
On Sat, Oct 2, 2010 at 10:40 AM, Pavel Klinov <pklinov@cs.man.ac.uk> wrote:
> Hi Adrian,
>
> What you've suggested is a rule. One needs to be careful when adding
> rules to expressive DLs since it may easily lead to undecidability
> (SWRL is a good example). This is particularly the case with open
> rules (like, I believe, is yours although I'm not sure which semantics
> your system implements) which work for both named and unnamed objects.
>
> You may use the so called DL-safe rules which are closed in the sense
> that they only apply to named individuals. Simply put, a DL-safe rule
> looking like yours would entail "A loves B" for any *named* person A
> and any *named* cat B, but it would not entail, for example, that some
> subset of Person love cats (e.g. "men love cats" although men are
> persons).
>
> Markus' and Jie solutions will handle that situation properly.
>
> There are other types of rules such as DLP and Markus' thesis is a
> good place to read about them.
>
> Cheers,
> Pavel
>
> On Sat, Oct 2, 2010 at 2:22 PM, Adrian Walker <adriandwalker@gmail.com>
> wrote:
> > Hi Markus & All --
> >
> > As mentioned off-list to Markus, one can do this rather simply in the
> system
> > online at the site below as follows:
> >
> > some-person is a human being
> > some-animal is a cat
> > ------------------------------------------------
> > that-person loves that-animal
> >
> > So my question is please, what advantages does does the more complicated
> > method in OWL have?
> >
> > Please note that I'm a newbie where OWL is concerned, and just a bit
> puzzled
> > about what the conceptual complexity overhead may buy.
> >
> > -- Adrian
> >
> > Internet Business Logic
> > A Wiki and SOA Endpoint for Executable Open Vocabulary English Q/A over
> SQL
> > and RDF
> > Online at www.reengineeringllc.com
> > Shared use is free, and there are no advertisements
> >
> > Adrian Walker
> > Reengineering
> >
> > On Fri, Oct 1, 2010 at 2:44 PM, Markus Krötzsch
> > <markus.kroetzsch@comlab.ox.ac.uk> wrote:
> >>
> >> On 01/10/2010 16:51, Cristian Cocos wrote:
> >> > How would I write "All humans love all cats" in OWL2 please ? (I'd
> >> > appreciate a Manchester syntax rendering.) I know how to trick OWL2
> >> > to say that some fixed specified individual loves all cats, though
> >> > not the former.
> >>
> >> Note that there is a not-so-differently titled research paper on the
> same
> >> issue: "All Elephants are Bigger Than All Mice" [1]. The feature used
> here
> >> is generally known as a "concept product" (or "class product" in OWL
> terms).
> >>
> >> Jie's below explanation shows a workaround that can be used for OWL 2.
> >> This indirect encoding may not work well in practice, since tools for
> >> modelling and reasoning will not recognise that you only want to make a
> very
> >> simple statement when using the below axioms. There are other possible
> >> encodings that may or may not work better in specific situations. Here
> is
> >> one more:
> >>
> >> EquivalentClasses( :Human ObjectHasValue( :pHuman :anIndividual ) )
> >> EquivalentClasses( :Cat ObjectHasValue( :pCat :anIndividual ) )
> >> SubObjectPropertyOf( ObjectPropertyChain(
> >> :pHuman
> >> ObjectInverseOf ( :pCat )
> >> ) :love)
> >>
> >> Here :pCat, :pHuman, and :anIndividual are auxiliary entities not used
> >> anywhere else. Manchester Syntax would be something like this:
> >>
> >> ObjectProperty: love SubPropertyChain: pHuman o inv(pCat)
> >> Class: Cat EquivalentTo: pCat value anIndividual
> >> Class: Human EquivalentTo: pHuman value anIndividual
> >>
> >> Regards,
> >>
> >> Markus
> >>
> >> [1] http://korrekt.org/page/Elephants
> >> (this is a special case of DL Rules; see my dissertation for an extended
> >> discussion: http://korrekt.org/page/PhD_thesis)
> >>
> >>
> >>
> >> On 01/10/2010 17:13, Jie Bao wrote:
> >>>
> >>> Cristian
> >>>
> >>> I guess you need a rule like Human(x),Cat(y) -> love(x,y)
> >>>
> >>> The trick is to use self restrictions, the top property and property
> >>> chains to connect all x and y.
> >>>
> >>> in Functional-Style Syntax
> >>>
> >>> EquivalentClasses( Human ObjectHasSelf( ex:pHuman ) )
> >>> EquivalentClasses( Cat ObjectHasSelf( ex:pCat ) )
> >>> SubObjectPropertyOf( ObjectPropertyChain( ex:pHuman
> owl:topObjectProperty
> >>> ex:pCat ) ex:love)
> >>>
> >>> or in Manchester Syntax
> >>>
> >>> Class: Human EquivalentTo: ex:pHuman Self
> >>> Class: Cat EquivalentTo: ex:pCat Self
> >>> ObjectProperty: ex:love SubPropertyChain: ex:pHuman o
> >>> owl:topObjectProperty o ex:pCat
> >>>
> >>> Wish that helps
> >>>
> >>> Jie
> >>>
> >>
> >>
> >>
> >> --
> >> Markus Krötzsch
> >> Oxford University Computing Laboratory
> >> Room 306, Parks Road, Oxford, OX1 3QD, UK
> >> +44 (0)1865 283529 http://korrekt.org/
> >>
> >>
> >
> >
>
>
>
> --
> cheers,
> --pavel
> http://www.cs.man.ac.uk/~klinovp <http://www.cs.man.ac.uk/%7Eklinovp>
>
Received on Tuesday, 5 October 2010 21:36:34 UTC