Call for Papers: ICPP 2011 (September 13-16, 2011, Taipei, Taiwan)

All humans love (all) cats

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.

Many thanks,

Cristian Cocos
Post Doctoral Fellow
Centre for Logic and Information, StFX University 54B St. Mary's Street,
Antigonish NS, Canada B2G 2W5
Tel: + 1 (902) 867-4931, Fax: +1 (902) 867-1397

Current research: "Building Decision-Support Through Dynamic Workflow
Systems for Health Care"

Re: All humans love (all) cats

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

On Fri, Oct 1, 2010 at 10:51, Cristian Cocos <cristi@...> 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.
>
> Many thanks,
>
> Cristian Cocos
> Post Doctoral Fellow
> Centre for Logic and Information, StFX University 54B St. Mary's Street,
> Antigonish NS, Canada B2G 2W5
> Tel: + 1 (902) 867-4931, Fax: +1 (902) 867-1397
>
> Current research: "Building Decision-Support Through Dynamic Workflow
> Systems for Health Care"
>
>
>
>
>
>

Re: All humans love (all) cats

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/

Re: All humans love (all) cats

RE: All humans love (all) cats

Alright Jie, so let me see if I understand this properly--see below my
comments. (As I am a little uncomfortable with the usual DL lingo, I'll  use
the standard set-theoretic jargon, though I hope this will not prevent you
from following my musings. (You may, alternatively, want to construe my
comments as addressing the semantic level.))

> EquivalentClasses( Human ObjectHasSelf( ex:pHuman ) )
> EquivalentClasses( Cat ObjectHasSelf( ex:pCat ) )

What you do, hence, is turn classes into relations: define two relations
ex:pHuman and ex:pCat as diagonals of HumanxHuman, resp. CatxCat. Did I get
it right?

> SubObjectPropertyOf( ObjectPropertyChain( ex:pHuman owl:topObjectProperty
> ex:pCat ) ex:love)

"Loves" would now be a sub-relation of the composite "pHuman o ThingxThing o
pCat," is that so?

It certainly makes sense, though I feel rather miffed by the fact that such
a simple and mundane-looking FOL statement requires such an excruciatingly
complicated workaround in order to be represented in OWL2. Would I not run
into problems with a reasoner such as Pellet, now that I've resorted to this
type of rendering?

Many thanks,

C

Re: All humans love (all) cats

On 2 Oct 2010, at 14:22, Adrian Walker 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?  

It captures the domain, whereas I'm betting that thethe above does not.

> Please note that I'm a newbie where OWL is concerned, and just a bit puzzled about what the conceptual
complexity overhead may buy.

In first order logic it's syntactically similar (i.e., from
http://korrekt.org/papers/RudolphKroetzschHitzer_DL-Concept-Product_TR_2008.pdf ):
	∀(x).∀y.Elephant(x) ∧ Mouse(y) → biggerThan(x, y)
the challenge is to encode it so that 1) it's in a decidable logic and 2) it is reasonably close in meaning.
This includes constraining individuals not mentioned in the theory and thus making some classes
unsatisfiable simply vian. (e.g.,) existential restrictions. As I recall, your system is logic
programming based and constrains the value of variables to named individuals. Thus, it merely
approximates what we're trying to encode. An analogous approximation can be achieved with DL Safe rules.

Cheers,
Bijan.

Re: All humans love (all) cats

On Sat, Oct 2, 2010 at 3:27 PM, Cristian Cocos <cristi@...> wrote:
>
>> SubObjectPropertyOf( ObjectPropertyChain( ex:pHuman owl:topObjectProperty
>> ex:pCat ) ex:love)
>
> "Loves" would now be a sub-relation of the composite "pHuman o ThingxThing o
> pCat," is that so?

It is a *super* relation of the chain. The whole idea is to connect an
*arbitrary* human to an *arbitrary* cat by some, possible composite,
role (which in this case is "pHuman o ThingxThing o pCat," and in the
Markus' solution is "pHuman o inverse of pCat"). Once it's done OWL 2
allows you to say that such a chain implies role you need (in this
case "loves").

>
> It certainly makes sense, though I feel rather miffed by the fact that such
> a simple and mundane-looking FOL statement requires such an excruciatingly
> complicated workaround in order to be represented in OWL2.

I'll leave it to others to comment on :)

>Would I not run
> into problems with a reasoner such as Pellet, now that I've resorted to this
> type of rendering?

It depends on what you mean by problems. Pellet will certainly handle
it but will have to use an appropriate completion strategy (which may
have an impact of performance but it depends on what else you have in
your KB).

Cheers,
Pavel

>
> Many thanks,
>
> C
>
>
>

--

-- 
cheers,
--pavel
http://www.cs.man.ac.uk/~klinovp

Re: All humans love (all) cats

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@...> 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@...> 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

RE: All humans love (all) cats

> > It is a *super* relation of the chain.

Super, of course. Sorry.

C