Query: Subclasses or Sibling Disjoint classes?

classic Classic list List threaded Threaded
37 messages Options
12
Reply | Threaded
Open this post in threaded view
|

Query: Subclasses or Sibling Disjoint classes?

William Fitzgerald-2
Dear OWL Gurus,

In developing my own OWL-DL ontology similar in structure to the PIZZA
OWL-DL ontology, I find myself faced with a question as to why certain
classes have not been defined as subclasses.

For example in the NamedPizza class we have 2 subclass siblings called
American and AmericanHot.

Clearly the AmericanHot is a more specialized class to that of the
American. So why has it not been classed as a subset of AmericanPizza?

One argument is that a hot American pizza is not an American pizza
(because one will burn the mouth off you and the other will not) hence
the reason for not subclassing!

However if we take another example we can see that under Vegetable
toppings we have defined HotGreenPepperTopping as been a subset of
GreenPepperTopping. In this case we do not create sibling classes but
rather we subclass.

So do you see my predicament!!!

Is there a hint of a flaw in the ontology (remembering of course that
the pizza ontology is only for demonstration purposes) or is there valid
reasons for subclassing in one area and making disjoint siblings in another?

I realize that the structure of the pizza ontology is very intuitive and
very close to how we naturally visualize the make up of Pizza's but
taking these principles to other domains can often be trickier.

regards,
Will.

--
William M. Fitzgerald,
PhD Student,
Telecommunications Software & Systems Group,
Waterford Institute of Technology,
Cork Rd.
Waterford.
Office Ph: +353 51 302937
Mobile Ph: +353 87 9527083

_______________________________________________
protege-owl mailing list
[hidden email]
https://mailman.stanford.edu/mailman/listinfo/protege-owl

Instructions for unsubscribing: http://protege.stanford.edu/doc/faq.html#01a.03 
Reply | Threaded
Open this post in threaded view
|

Re: Query: Subclasses or Sibling Disjoint classes?

Timothy Redmond

I see three issues.  The first thing is that in OWL we shouldn't need  
to build all possible subclass relationships when we write the  
ontology because the inference engine will calculate them for us.  I  
am not a modeling expert but this seems like this is a good principle  
for OWL modeling.  This doesn't help with primitive concepts but for  
defined concepts this may be useful.

Second, I have a little trouble with the NamedPizza hierarchy.  It is  
interesting that all of these guys are primitive - none of them are  
defined.  This means that there is something about a pizza that makes  
it an american pizza that is not defined in the ontology.  Thus it is  
unclear whether american pizza's and american hot pizza's should be  
disjoint because it is not clear to me what is being captured in this  
distinction.

Finally, and you might view this as nitpicking, even if you ignore  
the disjointness axioms attached to the american pizza and the  
american hot pizza, it is impossible for these two types of pizzas to  
intersect.   The american pizza has a restriction axiom that states  
that it can only have mozzarella, peperoni sausage and tomato  
toppings.  But the american hot pizza has a restriction axiom that  
states that it must have a JalapenoPepper topping.

-Timothy



On Mar 30, 2007, at 6:19 AM, william fitzgerald wrote:

> Dear OWL Gurus,
>
> In developing my own OWL-DL ontology similar in structure to the PIZZA
> OWL-DL ontology, I find myself faced with a question as to why certain
> classes have not been defined as subclasses.
>
> For example in the NamedPizza class we have 2 subclass siblings called
> American and AmericanHot.
>
> Clearly the AmericanHot is a more specialized class to that of the
> American. So why has it not been classed as a subset of AmericanPizza?
>
> One argument is that a hot American pizza is not an American pizza
> (because one will burn the mouth off you and the other will not) hence
> the reason for not subclassing!
>
> However if we take another example we can see that under Vegetable
> toppings we have defined HotGreenPepperTopping as been a subset of
> GreenPepperTopping. In this case we do not create sibling classes but
> rather we subclass.
>
> So do you see my predicament!!!
>
> Is there a hint of a flaw in the ontology (remembering of course that
> the pizza ontology is only for demonstration purposes) or is there  
> valid
> reasons for subclassing in one area and making disjoint siblings in  
> another?
>
> I realize that the structure of the pizza ontology is very  
> intuitive and
> very close to how we naturally visualize the make up of Pizza's but
> taking these principles to other domains can often be trickier.
>
> regards,
> Will.
>
> --
> William M. Fitzgerald,
> PhD Student,
> Telecommunications Software & Systems Group,
> Waterford Institute of Technology,
> Cork Rd.
> Waterford.
> Office Ph: +353 51 302937
> Mobile Ph: +353 87 9527083
>
> _______________________________________________
> protege-owl mailing list
> [hidden email]
> https://mailman.stanford.edu/mailman/listinfo/protege-owl
>
> Instructions for unsubscribing: http://protege.stanford.edu/doc/ 
> faq.html#01a.03

_______________________________________________
protege-owl mailing list
[hidden email]
https://mailman.stanford.edu/mailman/listinfo/protege-owl

Instructions for unsubscribing: http://protege.stanford.edu/doc/faq.html#01a.03 
Reply | Threaded
Open this post in threaded view
|

Re: Query: Subclasses or Sibling Disjoint classes?

William Fitzgerald-2
Dear Timothy and OWL users,

1) I agree with your first point entirely and the whole point of using
OWL-DL is to have poly-hierarchies sorted automatically via the reasoner.

2) You are spotting some issues with the NamedPizza layout also. I just
fired up protege and made all these NamedPizza's complete classes. there
is no major difference in the outcome ( alot of classes now defined
under UnClosedPizza of course) and in fact the hierarchy looks more
complete.

3) yep you are correct. I was only referring to the idea of having a
AmericanHot defined as a subclass of American but i didn't bother
thinking about the restrictions. Placing AmericanHot under American will
cause an error due to the fact that the restrictions (hasTopping) on the
now parent class American will kick in under the reasoner.

So what we conclude?

Question 1: it seems that all these NamedPizza's are in themselves
closed for finalized (disjoint siblings and specific restrictions) to
what they are made up of, so why not make them complete classes?

It seems that an AmericanHot pizza is infact quite different in the
ontology model to American pizza despite the fact they share a lot of
the same principles! it seems natural and more likely in a programming
environment to have a class American and a more specialised class called
AmericanHot which inherits its parents qualities plus its own and
possibly overrides some of the parent restrictions.

Question 2: hence in OWL-DL, can a sublcass override parent classes
restrictions in Protege etc.?

it seems the answer is no, and hence why the Pizza developers make both
American and AmericanHot disjoint sibling classes. However given
question 2 is probably a NO, then why was Question 1 not applied?

maybe alot of the design issues are down to OWL-DL limitations and a
complete mapping to OO programing does not overlap in a precise way
(code optimzation).

hence in java you would have a 2 separate java classes American and
AmericanHot driven by the Pizza Ontology rather than having 2 classes
American and AmericanHot with AmericanHot as a subclass of American and
having AmericanHot override properties of its parent class if required.

that is:
class American{ //class desription}
class AmericanHot {//class description}

rather than:
class American{ //class desription}
class AmericanHot extends American {//class description}

I welcome any comments in relation to this or any other features that
may come to mind?

All I am trying to do is get into the mind set of correct modeling using
DL and OWL-DL, and in a correct and formal way. I would like to be able
to stand over any model I develop and have exact answers to why its
modeled in a particular way.

regards,
Will.



Timothy Redmond wrote:

>
> I see three issues.  The first thing is that in OWL we shouldn't need
> to build all possible subclass relationships when we write the
> ontology because the inference engine will calculate them for us.  I
> am not a modeling expert but this seems like this is a good principle
> for OWL modeling.  This doesn't help with primitive concepts but for
> defined concepts this may be useful.
>
> Second, I have a little trouble with the NamedPizza hierarchy.  It is
> interesting that all of these guys are primitive - none of them are
> defined.  This means that there is something about a pizza that makes
> it an american pizza that is not defined in the ontology.  Thus it is
> unclear whether american pizza's and american hot pizza's should be
> disjoint because it is not clear to me what is being captured in this
> distinction.
>
> Finally, and you might view this as nitpicking, even if you ignore the
> disjointness axioms attached to the american pizza and the american
> hot pizza, it is impossible for these two types of pizzas to
> intersect.   The american pizza has a restriction axiom that states
> that it can only have mozzarella, peperoni sausage and tomato
> toppings.  But the american hot pizza has a restriction axiom that
> states that it must have a JalapenoPepper topping.
>
> -Timothy
>
>
>
> On Mar 30, 2007, at 6:19 AM, william fitzgerald wrote:
>
>> Dear OWL Gurus,
>>
>> In developing my own OWL-DL ontology similar in structure to the PIZZA
>> OWL-DL ontology, I find myself faced with a question as to why certain
>> classes have not been defined as subclasses.
>>
>> For example in the NamedPizza class we have 2 subclass siblings called
>> American and AmericanHot.
>>
>> Clearly the AmericanHot is a more specialized class to that of the
>> American. So why has it not been classed as a subset of AmericanPizza?
>>
>> One argument is that a hot American pizza is not an American pizza
>> (because one will burn the mouth off you and the other will not) hence
>> the reason for not subclassing!
>>
>> However if we take another example we can see that under Vegetable
>> toppings we have defined HotGreenPepperTopping as been a subset of
>> GreenPepperTopping. In this case we do not create sibling classes but
>> rather we subclass.
>>
>> So do you see my predicament!!!
>>
>> Is there a hint of a flaw in the ontology (remembering of course that
>> the pizza ontology is only for demonstration purposes) or is there valid
>> reasons for subclassing in one area and making disjoint siblings in
>> another?
>>
>> I realize that the structure of the pizza ontology is very intuitive and
>> very close to how we naturally visualize the make up of Pizza's but
>> taking these principles to other domains can often be trickier.
>>
>> regards,
>> Will.
>>
>> --William M. Fitzgerald,
>> PhD Student,
>> Telecommunications Software & Systems Group,
>> Waterford Institute of Technology,
>> Cork Rd.
>> Waterford.
>> Office Ph: +353 51 302937
>> Mobile Ph: +353 87 9527083
>>
>> _______________________________________________
>> protege-owl mailing list
>> [hidden email]
>> https://mailman.stanford.edu/mailman/listinfo/protege-owl
>>
>> Instructions for unsubscribing:
>> http://protege.stanford.edu/doc/faq.html#01a.03
>

--
William M. Fitzgerald,
PhD Student,
Telecommunications Software & Systems Group,
Waterford Institute of Technology,
Cork Rd.
Waterford.
Office Ph: +353 51 302937
Mobile Ph: +353 87 9527083

_______________________________________________
protege-owl mailing list
[hidden email]
https://mailman.stanford.edu/mailman/listinfo/protege-owl

Instructions for unsubscribing: http://protege.stanford.edu/doc/faq.html#01a.03 
Reply | Threaded
Open this post in threaded view
|

Re: Query: Subclasses or Sibling Disjoint classes?

Ronald Cornet
Will,

Thanks for raising these issues.
I've been playing with the pizza ontology, and also ran into some issues, which I do have to write down however.

I want to counter your "AmericanHot isa American" suggestion.

Support you order an American pizza (thinking you get the mild one), but the creative pizzaman decides to give you an AmericanHot, he will, in your model, satisfy your request, although I'm quite sure you will not be satisfied by what you get...

Am I right?

Regards, Ronald

###############################################################
Ronald Cornet, PhD                    email: [hidden email]
dept. of Medical Informatics          phone: +31 (0)20 566 5188
Academic Medical Center, Room J1B-115 fax:   +31 (0)20 691 9840
P.O.Box 22700                         www: http://kik.amc.uva.nl/home/rcornet/
1100 DE  Amsterdam
The Netherlands                       'The truth is out there'

> -----Original Message-----
> From: [hidden email]
> [mailto:[hidden email]] On Behalf
> Of william fitzgerald
> Sent: Monday, April 02, 2007 11:33
> To: User support for the Protege-OWL editor
> Subject: Re: [protege-owl] Query: Subclasses or Sibling
> Disjoint classes?
>
> Dear Timothy and OWL users,
>
> 1) I agree with your first point entirely and the whole point
> of using OWL-DL is to have poly-hierarchies sorted
> automatically via the reasoner.
>
> 2) You are spotting some issues with the NamedPizza layout
> also. I just fired up protege and made all these NamedPizza's
> complete classes. there is no major difference in the outcome
> ( alot of classes now defined under UnClosedPizza of course)
> and in fact the hierarchy looks more complete.
>
> 3) yep you are correct. I was only referring to the idea of
> having a AmericanHot defined as a subclass of American but i
> didn't bother thinking about the restrictions. Placing
> AmericanHot under American will cause an error due to the
> fact that the restrictions (hasTopping) on the now parent
> class American will kick in under the reasoner.
>
> So what we conclude?
>
> Question 1: it seems that all these NamedPizza's are in
> themselves closed for finalized (disjoint siblings and
> specific restrictions) to what they are made up of, so why
> not make them complete classes?
>
> It seems that an AmericanHot pizza is infact quite different
> in the ontology model to American pizza despite the fact they
> share a lot of the same principles! it seems natural and more
> likely in a programming environment to have a class American
> and a more specialised class called AmericanHot which
> inherits its parents qualities plus its own and possibly
> overrides some of the parent restrictions.
>
> Question 2: hence in OWL-DL, can a sublcass override parent
> classes restrictions in Protege etc.?
>
> it seems the answer is no, and hence why the Pizza developers
> make both American and AmericanHot disjoint sibling classes.
> However given question 2 is probably a NO, then why was
> Question 1 not applied?
>
> maybe alot of the design issues are down to OWL-DL
> limitations and a complete mapping to OO programing does not
> overlap in a precise way (code optimzation).
>
> hence in java you would have a 2 separate java classes
> American and AmericanHot driven by the Pizza Ontology rather
> than having 2 classes American and AmericanHot with
> AmericanHot as a subclass of American and having AmericanHot
> override properties of its parent class if required.
>
> that is:
> class American{ //class desription}
> class AmericanHot {//class description}
>
> rather than:
> class American{ //class desription}
> class AmericanHot extends American {//class description}
>
> I welcome any comments in relation to this or any other
> features that may come to mind?
>
> All I am trying to do is get into the mind set of correct
> modeling using DL and OWL-DL, and in a correct and formal
> way. I would like to be able to stand over any model I
> develop and have exact answers to why its modeled in a particular way.
>
> regards,
> Will.
>
>
>
> Timothy Redmond wrote:
> >
> > I see three issues.  The first thing is that in OWL we
> shouldn't need
> > to build all possible subclass relationships when we write the
> > ontology because the inference engine will calculate them
> for us.  I
> > am not a modeling expert but this seems like this is a good
> principle
> > for OWL modeling.  This doesn't help with primitive
> concepts but for
> > defined concepts this may be useful.
> >
> > Second, I have a little trouble with the NamedPizza
> hierarchy.  It is
> > interesting that all of these guys are primitive - none of them are
> > defined.  This means that there is something about a pizza
> that makes
> > it an american pizza that is not defined in the ontology.  
> Thus it is
> > unclear whether american pizza's and american hot pizza's should be
> > disjoint because it is not clear to me what is being
> captured in this
> > distinction.
> >
> > Finally, and you might view this as nitpicking, even if you
> ignore the
> > disjointness axioms attached to the american pizza and the american
> > hot pizza, it is impossible for these two types of pizzas to
> > intersect.   The american pizza has a restriction axiom that states
> > that it can only have mozzarella, peperoni sausage and tomato
> > toppings.  But the american hot pizza has a restriction axiom that
> > states that it must have a JalapenoPepper topping.
> >
> > -Timothy
> >
> >
> >
> > On Mar 30, 2007, at 6:19 AM, william fitzgerald wrote:
> >
> >> Dear OWL Gurus,
> >>
> >> In developing my own OWL-DL ontology similar in structure to the
> >> PIZZA OWL-DL ontology, I find myself faced with a question
> as to why
> >> certain classes have not been defined as subclasses.
> >>
> >> For example in the NamedPizza class we have 2 subclass siblings
> >> called American and AmericanHot.
> >>
> >> Clearly the AmericanHot is a more specialized class to that of the
> >> American. So why has it not been classed as a subset of
> AmericanPizza?
> >>
> >> One argument is that a hot American pizza is not an American pizza
> >> (because one will burn the mouth off you and the other will not)
> >> hence the reason for not subclassing!
> >>
> >> However if we take another example we can see that under Vegetable
> >> toppings we have defined HotGreenPepperTopping as been a subset of
> >> GreenPepperTopping. In this case we do not create sibling
> classes but
> >> rather we subclass.
> >>
> >> So do you see my predicament!!!
> >>
> >> Is there a hint of a flaw in the ontology (remembering of
> course that
> >> the pizza ontology is only for demonstration purposes) or is there
> >> valid reasons for subclassing in one area and making disjoint
> >> siblings in another?
> >>
> >> I realize that the structure of the pizza ontology is very
> intuitive
> >> and very close to how we naturally visualize the make up
> of Pizza's
> >> but taking these principles to other domains can often be trickier.
> >>
> >> regards,
> >> Will.
> >>
> >> --William M. Fitzgerald,
> >> PhD Student,
> >> Telecommunications Software & Systems Group, Waterford
> Institute of
> >> Technology, Cork Rd.
> >> Waterford.
> >> Office Ph: +353 51 302937
> >> Mobile Ph: +353 87 9527083
> >>
> >> _______________________________________________
> >> protege-owl mailing list
> >> [hidden email]
> >> https://mailman.stanford.edu/mailman/listinfo/protege-owl
> >>
> >> Instructions for unsubscribing:
> >> http://protege.stanford.edu/doc/faq.html#01a.03
> >
>
> --
> William M. Fitzgerald,
> PhD Student,
> Telecommunications Software & Systems Group, Waterford
> Institute of Technology, Cork Rd.
> Waterford.
> Office Ph: +353 51 302937
> Mobile Ph: +353 87 9527083
>
> _______________________________________________
> protege-owl mailing list
> [hidden email]
> https://mailman.stanford.edu/mailman/listinfo/protege-owl
>
> Instructions for unsubscribing:
> http://protege.stanford.edu/doc/faq.html#01a.03
>
>

_______________________________________________
protege-owl mailing list
[hidden email]
https://mailman.stanford.edu/mailman/listinfo/protege-owl

Instructions for unsubscribing: http://protege.stanford.edu/doc/faq.html#01a.03 
Reply | Threaded
Open this post in threaded view
|

Re: Query: Subclasses or Sibling Disjoint classes?

William Fitzgerald-2
Hi Ronald,

yes you are correct, i would not be happy getting the mouth burnt off me :-)

Ok, so there seems to be a reason to create sibling classes as opposed
to subclasses in the case of the Pizza ontology.

However, the question that still begs to be answered is why have we not
defined the named pizza's as complete classes, given that we are happy
with the membership constraints over them?

To counter what you have said about our creative pizzaman we could avoid
getting the wrong pizza by stating i will have a regular American pizza
or i'll have a AmericanMild pizza or AmericanHot pizza.

they are all kinds of American pizza but are also specalised in their
own right.

So in OWL-DL you would have for example:
NamedPizza
                    <--- AmericanPizza (hasTopping only (hasTopping only
(MozzarellaTopping or PeperoniSausageTopping or TomatoTopping))
                                                    <--- AmericanRegular
(in fact this class is really redundant but just added it anyway)
                                                    <--- AmericanHot
(hasTopping only ( HotGreenPepperTopping or JalapenoPepperTopping))
                                                    <--- AmericanMild
(hasTopping only (HotGreenPepperTopping))

Notice for space reasons i have not included the Existential
restrictions but you get the idea. i realise that the reasoner would
throw and error due to the closure axioms. my point is just to highlight
that in a tree like structure it also appears that having SUBCLASSES
makes sense rather than DISJOINT SIBLINGS.

And why not make these classes COMPLETE! I think once we start applying
closure axioms you are getting very specific in what you want.

In java this may be done like this:
class AmericaPizza{//properties}
class AmericaPizzaMild extends AmericanPizza{//inherit parent properties
and overide methods if needed}
class AmericaPizzaHot extends AmericanPizza{}
class AmericaPizzaRegular extends AmericanPizza{}


However sticking with the disjoint siblings method in java you don't
optimize your code reuse:
class AmericaPizza{}
class AmericaPizzaMild{}
class AmericaPizzaHot{}

I suppose what it boils down to is in my root original email,  I
compared what we are discussing now with HotGreenPepperTopping and
GreenPepperTopping whereby SUBCLASSING comes into play and not DISJOINT
SIBLINGS.

Why is it one way for one concept and another for a different concept!!!

That is, why have we not defined HotGreenPepperTopping and
GreenPepperTopping as DISJOINT SIBLINGS. Back to your "experimental
pizzaman" what if i order GreenPepperToppings but he adds
HotGreenPepperToppings? So why have we not "disjoint sibling" these classes?

Its puzzling isn't it, or at least it is too me.

regards,
Will.


Ronald Cornet wrote:

> Will,
>
> Thanks for raising these issues.
> I've been playing with the pizza ontology, and also ran into some issues, which I do have to write down however.
>
> I want to counter your "AmericanHot isa American" suggestion.
>
> Support you order an American pizza (thinking you get the mild one), but the creative pizzaman decides to give you an AmericanHot, he will, in your model, satisfy your request, although I'm quite sure you will not be satisfied by what you get...
>
> Am I right?
>
> Regards, Ronald
>
> ###############################################################
> Ronald Cornet, PhD                    email: [hidden email]
> dept. of Medical Informatics          phone: +31 (0)20 566 5188
> Academic Medical Center, Room J1B-115 fax:   +31 (0)20 691 9840
> P.O.Box 22700                         www: http://kik.amc.uva.nl/home/rcornet/
> 1100 DE  Amsterdam
> The Netherlands                       'The truth is out there'
>
>  
>> -----Original Message-----
>> From: [hidden email]
>> [mailto:[hidden email]] On Behalf
>> Of william fitzgerald
>> Sent: Monday, April 02, 2007 11:33
>> To: User support for the Protege-OWL editor
>> Subject: Re: [protege-owl] Query: Subclasses or Sibling
>> Disjoint classes?
>>
>> Dear Timothy and OWL users,
>>
>> 1) I agree with your first point entirely and the whole point
>> of using OWL-DL is to have poly-hierarchies sorted
>> automatically via the reasoner.
>>
>> 2) You are spotting some issues with the NamedPizza layout
>> also. I just fired up protege and made all these NamedPizza's
>> complete classes. there is no major difference in the outcome
>> ( alot of classes now defined under UnClosedPizza of course)
>> and in fact the hierarchy looks more complete.
>>
>> 3) yep you are correct. I was only referring to the idea of
>> having a AmericanHot defined as a subclass of American but i
>> didn't bother thinking about the restrictions. Placing
>> AmericanHot under American will cause an error due to the
>> fact that the restrictions (hasTopping) on the now parent
>> class American will kick in under the reasoner.
>>
>> So what we conclude?
>>
>> Question 1: it seems that all these NamedPizza's are in
>> themselves closed for finalized (disjoint siblings and
>> specific restrictions) to what they are made up of, so why
>> not make them complete classes?
>>
>> It seems that an AmericanHot pizza is infact quite different
>> in the ontology model to American pizza despite the fact they
>> share a lot of the same principles! it seems natural and more
>> likely in a programming environment to have a class American
>> and a more specialised class called AmericanHot which
>> inherits its parents qualities plus its own and possibly
>> overrides some of the parent restrictions.
>>
>> Question 2: hence in OWL-DL, can a sublcass override parent
>> classes restrictions in Protege etc.?
>>
>> it seems the answer is no, and hence why the Pizza developers
>> make both American and AmericanHot disjoint sibling classes.
>> However given question 2 is probably a NO, then why was
>> Question 1 not applied?
>>
>> maybe alot of the design issues are down to OWL-DL
>> limitations and a complete mapping to OO programing does not
>> overlap in a precise way (code optimzation).
>>
>> hence in java you would have a 2 separate java classes
>> American and AmericanHot driven by the Pizza Ontology rather
>> than having 2 classes American and AmericanHot with
>> AmericanHot as a subclass of American and having AmericanHot
>> override properties of its parent class if required.
>>
>> that is:
>> class American{ //class desription}
>> class AmericanHot {//class description}
>>
>> rather than:
>> class American{ //class desription}
>> class AmericanHot extends American {//class description}
>>
>> I welcome any comments in relation to this or any other
>> features that may come to mind?
>>
>> All I am trying to do is get into the mind set of correct
>> modeling using DL and OWL-DL, and in a correct and formal
>> way. I would like to be able to stand over any model I
>> develop and have exact answers to why its modeled in a particular way.
>>
>> regards,
>> Will.
>>
>>
>>
>> Timothy Redmond wrote:
>>    
>>> I see three issues.  The first thing is that in OWL we
>>>      
>> shouldn't need
>>    
>>> to build all possible subclass relationships when we write the
>>> ontology because the inference engine will calculate them
>>>      
>> for us.  I
>>    
>>> am not a modeling expert but this seems like this is a good
>>>      
>> principle
>>    
>>> for OWL modeling.  This doesn't help with primitive
>>>      
>> concepts but for
>>    
>>> defined concepts this may be useful.
>>>
>>> Second, I have a little trouble with the NamedPizza
>>>      
>> hierarchy.  It is
>>    
>>> interesting that all of these guys are primitive - none of them are
>>> defined.  This means that there is something about a pizza
>>>      
>> that makes
>>    
>>> it an american pizza that is not defined in the ontology.  
>>>      
>> Thus it is
>>    
>>> unclear whether american pizza's and american hot pizza's should be
>>> disjoint because it is not clear to me what is being
>>>      
>> captured in this
>>    
>>> distinction.
>>>
>>> Finally, and you might view this as nitpicking, even if you
>>>      
>> ignore the
>>    
>>> disjointness axioms attached to the american pizza and the american
>>> hot pizza, it is impossible for these two types of pizzas to
>>> intersect.   The american pizza has a restriction axiom that states
>>> that it can only have mozzarella, peperoni sausage and tomato
>>> toppings.  But the american hot pizza has a restriction axiom that
>>> states that it must have a JalapenoPepper topping.
>>>
>>> -Timothy
>>>
>>>
>>>
>>> On Mar 30, 2007, at 6:19 AM, william fitzgerald wrote:
>>>
>>>      
>>>> Dear OWL Gurus,
>>>>
>>>> In developing my own OWL-DL ontology similar in structure to the
>>>> PIZZA OWL-DL ontology, I find myself faced with a question
>>>>        
>> as to why
>>    
>>>> certain classes have not been defined as subclasses.
>>>>
>>>> For example in the NamedPizza class we have 2 subclass siblings
>>>> called American and AmericanHot.
>>>>
>>>> Clearly the AmericanHot is a more specialized class to that of the
>>>> American. So why has it not been classed as a subset of
>>>>        
>> AmericanPizza?
>>    
>>>> One argument is that a hot American pizza is not an American pizza
>>>> (because one will burn the mouth off you and the other will not)
>>>> hence the reason for not subclassing!
>>>>
>>>> However if we take another example we can see that under Vegetable
>>>> toppings we have defined HotGreenPepperTopping as been a subset of
>>>> GreenPepperTopping. In this case we do not create sibling
>>>>        
>> classes but
>>    
>>>> rather we subclass.
>>>>
>>>> So do you see my predicament!!!
>>>>
>>>> Is there a hint of a flaw in the ontology (remembering of
>>>>        
>> course that
>>    
>>>> the pizza ontology is only for demonstration purposes) or is there
>>>> valid reasons for subclassing in one area and making disjoint
>>>> siblings in another?
>>>>
>>>> I realize that the structure of the pizza ontology is very
>>>>        
>> intuitive
>>    
>>>> and very close to how we naturally visualize the make up
>>>>        
>> of Pizza's
>>    
>>>> but taking these principles to other domains can often be trickier.
>>>>
>>>> regards,
>>>> Will.
>>>>
>>>> --William M. Fitzgerald,
>>>> PhD Student,
>>>> Telecommunications Software & Systems Group, Waterford
>>>>        
>> Institute of
>>    
>>>> Technology, Cork Rd.
>>>> Waterford.
>>>> Office Ph: +353 51 302937
>>>> Mobile Ph: +353 87 9527083
>>>>
>>>> _______________________________________________
>>>> protege-owl mailing list
>>>> [hidden email]
>>>> https://mailman.stanford.edu/mailman/listinfo/protege-owl
>>>>
>>>> Instructions for unsubscribing:
>>>> http://protege.stanford.edu/doc/faq.html#01a.03
>>>>        
>> --
>> William M. Fitzgerald,
>> PhD Student,
>> Telecommunications Software & Systems Group, Waterford
>> Institute of Technology, Cork Rd.
>> Waterford.
>> Office Ph: +353 51 302937
>> Mobile Ph: +353 87 9527083
>>
>> _______________________________________________
>> protege-owl mailing list
>> [hidden email]
>> https://mailman.stanford.edu/mailman/listinfo/protege-owl
>>
>> Instructions for unsubscribing:
>> http://protege.stanford.edu/doc/faq.html#01a.03
>>
>>
>>    
>
>  

--
William M. Fitzgerald,
PhD Student,
Telecommunications Software & Systems Group,
Waterford Institute of Technology,
Cork Rd.
Waterford.
Office Ph: +353 51 302937
Mobile Ph: +353 87 9527083

_______________________________________________
protege-owl mailing list
[hidden email]
https://mailman.stanford.edu/mailman/listinfo/protege-owl

Instructions for unsubscribing: http://protege.stanford.edu/doc/faq.html#01a.03 
Reply | Threaded
Open this post in threaded view
|

Query: Subclasses or Sibling

Ronald Cornet
William, and others (please see the question in item 2 below),

I agree that it would make much sense to define the named pizzas as complete classes.

There are many reasons why it makes sense.

This also brings me to a question I have for a while....

If I instantiate a pizza, and put some ingredients on it, I would like it to be detected as a NamedPizza, if it is.
So if I make a pizza with mozarella and tomatoes, I would like it to be recognized as a Margherita (I'm doing this by head, maybe the ingredients of Margherita are slightly different).
This requires:
1. Margherita being defined as a "complete class", i.e., with necessary and sufficient conditions. I can handle that, and would prefer this in the Pizza example.
2. I would have to express that the toppings I've put on my pizza are the only toppings. Does anyone know how to do that in Protégé? I.e., how can I "close the world" when I've instantiated a pizza?

Regards, Ronald

###############################################################
Ronald Cornet, PhD                    email: [hidden email]
dept. of Medical Informatics          phone: +31 (0)20 566 5188
Academic Medical Center, Room J1B-115 fax:   +31 (0)20 691 9840
P.O.Box 22700                         www: http://kik.amc.uva.nl/home/rcornet/
1100 DE  Amsterdam
The Netherlands                       'The truth is out there'

> -----Original Message-----
> From: william fitzgerald [mailto:[hidden email]]
> Sent: Monday, April 02, 2007 12:30
> To: [hidden email]
> Cc: User support for the Protege-OWL editor
> Subject: Re: [protege-owl] Query: Subclasses or Sibling
> Disjoint classes?
>
> Hi Ronald,
>
> yes you are correct, i would not be happy getting the mouth
> burnt off me :-)
>
> Ok, so there seems to be a reason to create sibling classes
> as opposed to subclasses in the case of the Pizza ontology.
>
> However, the question that still begs to be answered is why
> have we not defined the named pizza's as complete classes,
> given that we are happy with the membership constraints over them?
>
> To counter what you have said about our creative pizzaman we
> could avoid getting the wrong pizza by stating i will have a
> regular American pizza or i'll have a AmericanMild pizza or
> AmericanHot pizza.
>
> they are all kinds of American pizza but are also specalised
> in their own right.
>
> So in OWL-DL you would have for example:
> NamedPizza
>                     <--- AmericanPizza (hasTopping only
> (hasTopping only (MozzarellaTopping or PeperoniSausageTopping
> or TomatoTopping))
>                                                     <---
> AmericanRegular (in fact this class is really redundant but
> just added it anyway)
>                                                     <---
> AmericanHot (hasTopping only ( HotGreenPepperTopping or
> JalapenoPepperTopping))
>                                                     <---
> AmericanMild (hasTopping only (HotGreenPepperTopping))
>
> Notice for space reasons i have not included the Existential
> restrictions but you get the idea. i realise that the
> reasoner would throw and error due to the closure axioms. my
> point is just to highlight that in a tree like structure it
> also appears that having SUBCLASSES makes sense rather than
> DISJOINT SIBLINGS.
>
> And why not make these classes COMPLETE! I think once we
> start applying closure axioms you are getting very specific
> in what you want.
>
> In java this may be done like this:
> class AmericaPizza{//properties}
> class AmericaPizzaMild extends AmericanPizza{//inherit parent
> properties and overide methods if needed} class
> AmericaPizzaHot extends AmericanPizza{} class
> AmericaPizzaRegular extends AmericanPizza{}
>
>
> However sticking with the disjoint siblings method in java
> you don't optimize your code reuse:
> class AmericaPizza{}
> class AmericaPizzaMild{}
> class AmericaPizzaHot{}
>
> I suppose what it boils down to is in my root original email,
>  I compared what we are discussing now with
> HotGreenPepperTopping and GreenPepperTopping whereby
> SUBCLASSING comes into play and not DISJOINT SIBLINGS.
>
> Why is it one way for one concept and another for a different
> concept!!!
>
> That is, why have we not defined HotGreenPepperTopping and
> GreenPepperTopping as DISJOINT SIBLINGS. Back to your
> "experimental pizzaman" what if i order GreenPepperToppings
> but he adds HotGreenPepperToppings? So why have we not
> "disjoint sibling" these classes?
>
> Its puzzling isn't it, or at least it is too me.
>
> regards,
> Will.
>
>
> Ronald Cornet wrote:
> > Will,
> >
> > Thanks for raising these issues.
> > I've been playing with the pizza ontology, and also ran
> into some issues, which I do have to write down however.
> >
> > I want to counter your "AmericanHot isa American" suggestion.
> >
> > Support you order an American pizza (thinking you get the
> mild one), but the creative pizzaman decides to give you an
> AmericanHot, he will, in your model, satisfy your request,
> although I'm quite sure you will not be satisfied by what you get...
> >
> > Am I right?
> >
> > Regards, Ronald
> >
> > ###############################################################
> > Ronald Cornet, PhD                    email: [hidden email]
> > dept. of Medical Informatics          phone: +31 (0)20 566 5188
> > Academic Medical Center, Room J1B-115 fax:   +31 (0)20 691 9840
> > P.O.Box 22700                         www:
> http://kik.amc.uva.nl/home/rcornet/
> > 1100 DE  Amsterdam
> > The Netherlands                       'The truth is out there'
> >
> >
> >> -----Original Message-----
> >> From: [hidden email]
> >> [mailto:[hidden email]] On Behalf Of
> >> william fitzgerald
> >> Sent: Monday, April 02, 2007 11:33
> >> To: User support for the Protege-OWL editor
> >> Subject: Re: [protege-owl] Query: Subclasses or Sibling Disjoint
> >> classes?
> >>
> >> Dear Timothy and OWL users,
> >>
> >> 1) I agree with your first point entirely and the whole point of
> >> using OWL-DL is to have poly-hierarchies sorted
> automatically via the
> >> reasoner.
> >>
> >> 2) You are spotting some issues with the NamedPizza layout also. I
> >> just fired up protege and made all these NamedPizza's complete
> >> classes. there is no major difference in the outcome ( alot of
> >> classes now defined under UnClosedPizza of course) and in fact the
> >> hierarchy looks more complete.
> >>
> >> 3) yep you are correct. I was only referring to the idea
> of having a
> >> AmericanHot defined as a subclass of American but i didn't bother
> >> thinking about the restrictions. Placing AmericanHot under
> American
> >> will cause an error due to the fact that the restrictions
> >> (hasTopping) on the now parent class American will kick in
> under the
> >> reasoner.
> >>
> >> So what we conclude?
> >>
> >> Question 1: it seems that all these NamedPizza's are in themselves
> >> closed for finalized (disjoint siblings and specific
> restrictions) to
> >> what they are made up of, so why not make them complete classes?
> >>
> >> It seems that an AmericanHot pizza is infact quite
> different in the
> >> ontology model to American pizza despite the fact they
> share a lot of
> >> the same principles! it seems natural and more likely in a
> >> programming environment to have a class American and a more
> >> specialised class called AmericanHot which inherits its parents
> >> qualities plus its own and possibly overrides some of the parent
> >> restrictions.
> >>
> >> Question 2: hence in OWL-DL, can a sublcass override
> parent classes
> >> restrictions in Protege etc.?
> >>
> >> it seems the answer is no, and hence why the Pizza developers make
> >> both American and AmericanHot disjoint sibling classes.
> >> However given question 2 is probably a NO, then why was Question 1
> >> not applied?
> >>
> >> maybe alot of the design issues are down to OWL-DL
> limitations and a
> >> complete mapping to OO programing does not overlap in a
> precise way
> >> (code optimzation).
> >>
> >> hence in java you would have a 2 separate java classes
> American and
> >> AmericanHot driven by the Pizza Ontology rather than
> having 2 classes
> >> American and AmericanHot with AmericanHot as a subclass of
> American
> >> and having AmericanHot override properties of its parent class if
> >> required.
> >>
> >> that is:
> >> class American{ //class desription}
> >> class AmericanHot {//class description}
> >>
> >> rather than:
> >> class American{ //class desription}
> >> class AmericanHot extends American {//class description}
> >>
> >> I welcome any comments in relation to this or any other
> features that
> >> may come to mind?
> >>
> >> All I am trying to do is get into the mind set of correct modeling
> >> using DL and OWL-DL, and in a correct and formal way. I
> would like to
> >> be able to stand over any model I develop and have exact
> answers to
> >> why its modeled in a particular way.
> >>
> >> regards,
> >> Will.
> >>
> >>
> >>
> >> Timothy Redmond wrote:
> >>
> >>> I see three issues.  The first thing is that in OWL we
> >>>
> >> shouldn't need
> >>
> >>> to build all possible subclass relationships when we write the
> >>> ontology because the inference engine will calculate them
> >>>
> >> for us.  I
> >>
> >>> am not a modeling expert but this seems like this is a good
> >>>
> >> principle
> >>
> >>> for OWL modeling.  This doesn't help with primitive
> >>>
> >> concepts but for
> >>
> >>> defined concepts this may be useful.
> >>>
> >>> Second, I have a little trouble with the NamedPizza
> >>>
> >> hierarchy.  It is
> >>
> >>> interesting that all of these guys are primitive - none
> of them are
> >>> defined.  This means that there is something about a pizza
> >>>
> >> that makes
> >>
> >>> it an american pizza that is not defined in the ontology.
> >>>
> >> Thus it is
> >>
> >>> unclear whether american pizza's and american hot pizza's
> should be
> >>> disjoint because it is not clear to me what is being
> >>>
> >> captured in this
> >>
> >>> distinction.
> >>>
> >>> Finally, and you might view this as nitpicking, even if you
> >>>
> >> ignore the
> >>
> >>> disjointness axioms attached to the american pizza and
> the american
> >>> hot pizza, it is impossible for these two types of pizzas to
> >>> intersect.   The american pizza has a restriction axiom
> that states
> >>> that it can only have mozzarella, peperoni sausage and tomato
> >>> toppings.  But the american hot pizza has a restriction
> axiom that
> >>> states that it must have a JalapenoPepper topping.
> >>>
> >>> -Timothy
> >>>
> >>>
> >>>
> >>> On Mar 30, 2007, at 6:19 AM, william fitzgerald wrote:
> >>>
> >>>
> >>>> Dear OWL Gurus,
> >>>>
> >>>> In developing my own OWL-DL ontology similar in structure to the
> >>>> PIZZA OWL-DL ontology, I find myself faced with a question
> >>>>
> >> as to why
> >>
> >>>> certain classes have not been defined as subclasses.
> >>>>
> >>>> For example in the NamedPizza class we have 2 subclass siblings
> >>>> called American and AmericanHot.
> >>>>
> >>>> Clearly the AmericanHot is a more specialized class to
> that of the
> >>>> American. So why has it not been classed as a subset of
> >>>>
> >> AmericanPizza?
> >>
> >>>> One argument is that a hot American pizza is not an
> American pizza
> >>>> (because one will burn the mouth off you and the other will not)
> >>>> hence the reason for not subclassing!
> >>>>
> >>>> However if we take another example we can see that under
> Vegetable
> >>>> toppings we have defined HotGreenPepperTopping as been a
> subset of
> >>>> GreenPepperTopping. In this case we do not create sibling
> >>>>
> >> classes but
> >>
> >>>> rather we subclass.
> >>>>
> >>>> So do you see my predicament!!!
> >>>>
> >>>> Is there a hint of a flaw in the ontology (remembering of
> >>>>
> >> course that
> >>
> >>>> the pizza ontology is only for demonstration purposes)
> or is there
> >>>> valid reasons for subclassing in one area and making disjoint
> >>>> siblings in another?
> >>>>
> >>>> I realize that the structure of the pizza ontology is very
> >>>>
> >> intuitive
> >>
> >>>> and very close to how we naturally visualize the make up
> >>>>
> >> of Pizza's
> >>
> >>>> but taking these principles to other domains can often
> be trickier.
> >>>>
> >>>> regards,
> >>>> Will.
> >>>>
> >>>> --William M. Fitzgerald,
> >>>> PhD Student,
> >>>> Telecommunications Software & Systems Group, Waterford
> >>>>
> >> Institute of
> >>
> >>>> Technology, Cork Rd.
> >>>> Waterford.
> >>>> Office Ph: +353 51 302937
> >>>> Mobile Ph: +353 87 9527083
> >>>>
> >>>> _______________________________________________
> >>>> protege-owl mailing list
> >>>> [hidden email]
> >>>> https://mailman.stanford.edu/mailman/listinfo/protege-owl
> >>>>
> >>>> Instructions for unsubscribing:
> >>>> http://protege.stanford.edu/doc/faq.html#01a.03
> >>>>
> >> --
> >> William M. Fitzgerald,
> >> PhD Student,
> >> Telecommunications Software & Systems Group, Waterford
> Institute of
> >> Technology, Cork Rd.
> >> Waterford.
> >> Office Ph: +353 51 302937
> >> Mobile Ph: +353 87 9527083
> >>
> >> _______________________________________________
> >> protege-owl mailing list
> >> [hidden email]
> >> https://mailman.stanford.edu/mailman/listinfo/protege-owl
> >>
> >> Instructions for unsubscribing:
> >> http://protege.stanford.edu/doc/faq.html#01a.03
> >>
> >>
> >>
> >
> >
>
> --
> William M. Fitzgerald,
> PhD Student,
> Telecommunications Software & Systems Group, Waterford
> Institute of Technology, Cork Rd.
> Waterford.
> Office Ph: +353 51 302937
> Mobile Ph: +353 87 9527083
>
>
>

_______________________________________________
protege-owl mailing list
[hidden email]
https://mailman.stanford.edu/mailman/listinfo/protege-owl

Instructions for unsubscribing: http://protege.stanford.edu/doc/faq.html#01a.03 
Reply | Threaded
Open this post in threaded view
|

Re: Query: Subclasses or Sibling

William Fitzgerald-2
Hi Robert,

I wonder if we have any Pizza developers ie. the Manchester University
gurus out there that cans shed some light on our queries.

I am not sure if I fully understand item 2 of your request, but when I
build my ontology in Protege, weather a class is primitive or complete I
use the closure axiom (\forall) across the properties that I want to
restrict to certain classes. In the Classes GUI on the left are a
hierarchy of classes and on the right you have property restrictions.
right click on a \exists property for example \exists hasTopping XYX and
then scroll to option for axiom closure.

Has this answered your question?

Will.
 

Ronald Cornet wrote:

> William, and others (please see the question in item 2 below),
>
> I agree that it would make much sense to define the named pizzas as complete classes.
>
> There are many reasons why it makes sense.
>
> This also brings me to a question I have for a while....
>
> If I instantiate a pizza, and put some ingredients on it, I would like it to be detected as a NamedPizza, if it is.
> So if I make a pizza with mozarella and tomatoes, I would like it to be recognized as a Margherita (I'm doing this by head, maybe the ingredients of Margherita are slightly different).
> This requires:
> 1. Margherita being defined as a "complete class", i.e., with necessary and sufficient conditions. I can handle that, and would prefer this in the Pizza example.
> 2. I would have to express that the toppings I've put on my pizza are the only toppings. Does anyone know how to do that in Protégé? I.e., how can I "close the world" when I've instantiated a pizza?
>
> Regards, Ronald
>
> ###############################################################
> Ronald Cornet, PhD                    email: [hidden email]
> dept. of Medical Informatics          phone: +31 (0)20 566 5188
> Academic Medical Center, Room J1B-115 fax:   +31 (0)20 691 9840
> P.O.Box 22700                         www: http://kik.amc.uva.nl/home/rcornet/
> 1100 DE  Amsterdam
> The Netherlands                       'The truth is out there'
>
>  
>> -----Original Message-----
>> From: william fitzgerald [mailto:[hidden email]]
>> Sent: Monday, April 02, 2007 12:30
>> To: [hidden email]
>> Cc: User support for the Protege-OWL editor
>> Subject: Re: [protege-owl] Query: Subclasses or Sibling
>> Disjoint classes?
>>
>> Hi Ronald,
>>
>> yes you are correct, i would not be happy getting the mouth
>> burnt off me :-)
>>
>> Ok, so there seems to be a reason to create sibling classes
>> as opposed to subclasses in the case of the Pizza ontology.
>>
>> However, the question that still begs to be answered is why
>> have we not defined the named pizza's as complete classes,
>> given that we are happy with the membership constraints over them?
>>
>> To counter what you have said about our creative pizzaman we
>> could avoid getting the wrong pizza by stating i will have a
>> regular American pizza or i'll have a AmericanMild pizza or
>> AmericanHot pizza.
>>
>> they are all kinds of American pizza but are also specalised
>> in their own right.
>>
>> So in OWL-DL you would have for example:
>> NamedPizza
>>                     <--- AmericanPizza (hasTopping only
>> (hasTopping only (MozzarellaTopping or PeperoniSausageTopping
>> or TomatoTopping))
>>                                                     <---
>> AmericanRegular (in fact this class is really redundant but
>> just added it anyway)
>>                                                     <---
>> AmericanHot (hasTopping only ( HotGreenPepperTopping or
>> JalapenoPepperTopping))
>>                                                     <---
>> AmericanMild (hasTopping only (HotGreenPepperTopping))
>>
>> Notice for space reasons i have not included the Existential
>> restrictions but you get the idea. i realise that the
>> reasoner would throw and error due to the closure axioms. my
>> point is just to highlight that in a tree like structure it
>> also appears that having SUBCLASSES makes sense rather than
>> DISJOINT SIBLINGS.
>>
>> And why not make these classes COMPLETE! I think once we
>> start applying closure axioms you are getting very specific
>> in what you want.
>>
>> In java this may be done like this:
>> class AmericaPizza{//properties}
>> class AmericaPizzaMild extends AmericanPizza{//inherit parent
>> properties and overide methods if needed} class
>> AmericaPizzaHot extends AmericanPizza{} class
>> AmericaPizzaRegular extends AmericanPizza{}
>>
>>
>> However sticking with the disjoint siblings method in java
>> you don't optimize your code reuse:
>> class AmericaPizza{}
>> class AmericaPizzaMild{}
>> class AmericaPizzaHot{}
>>
>> I suppose what it boils down to is in my root original email,
>>  I compared what we are discussing now with
>> HotGreenPepperTopping and GreenPepperTopping whereby
>> SUBCLASSING comes into play and not DISJOINT SIBLINGS.
>>
>> Why is it one way for one concept and another for a different
>> concept!!!
>>
>> That is, why have we not defined HotGreenPepperTopping and
>> GreenPepperTopping as DISJOINT SIBLINGS. Back to your
>> "experimental pizzaman" what if i order GreenPepperToppings
>> but he adds HotGreenPepperToppings? So why have we not
>> "disjoint sibling" these classes?
>>
>> Its puzzling isn't it, or at least it is too me.
>>
>> regards,
>> Will.
>>
>>
>> Ronald Cornet wrote:
>>    
>>> Will,
>>>
>>> Thanks for raising these issues.
>>> I've been playing with the pizza ontology, and also ran
>>>      
>> into some issues, which I do have to write down however.
>>    
>>> I want to counter your "AmericanHot isa American" suggestion.
>>>
>>> Support you order an American pizza (thinking you get the
>>>      
>> mild one), but the creative pizzaman decides to give you an
>> AmericanHot, he will, in your model, satisfy your request,
>> although I'm quite sure you will not be satisfied by what you get...
>>    
>>> Am I right?
>>>
>>> Regards, Ronald
>>>
>>> ###############################################################
>>> Ronald Cornet, PhD                    email: [hidden email]
>>> dept. of Medical Informatics          phone: +31 (0)20 566 5188
>>> Academic Medical Center, Room J1B-115 fax:   +31 (0)20 691 9840
>>> P.O.Box 22700                         www:
>>>      
>> http://kik.amc.uva.nl/home/rcornet/
>>    
>>> 1100 DE  Amsterdam
>>> The Netherlands                       'The truth is out there'
>>>
>>>
>>>      
>>>> -----Original Message-----
>>>> From: [hidden email]
>>>> [mailto:[hidden email]] On Behalf Of
>>>> william fitzgerald
>>>> Sent: Monday, April 02, 2007 11:33
>>>> To: User support for the Protege-OWL editor
>>>> Subject: Re: [protege-owl] Query: Subclasses or Sibling Disjoint
>>>> classes?
>>>>
>>>> Dear Timothy and OWL users,
>>>>
>>>> 1) I agree with your first point entirely and the whole point of
>>>> using OWL-DL is to have poly-hierarchies sorted
>>>>        
>> automatically via the
>>    
>>>> reasoner.
>>>>
>>>> 2) You are spotting some issues with the NamedPizza layout also. I
>>>> just fired up protege and made all these NamedPizza's complete
>>>> classes. there is no major difference in the outcome ( alot of
>>>> classes now defined under UnClosedPizza of course) and in fact the
>>>> hierarchy looks more complete.
>>>>
>>>> 3) yep you are correct. I was only referring to the idea
>>>>        
>> of having a
>>    
>>>> AmericanHot defined as a subclass of American but i didn't bother
>>>> thinking about the restrictions. Placing AmericanHot under
>>>>        
>> American
>>    
>>>> will cause an error due to the fact that the restrictions
>>>> (hasTopping) on the now parent class American will kick in
>>>>        
>> under the
>>    
>>>> reasoner.
>>>>
>>>> So what we conclude?
>>>>
>>>> Question 1: it seems that all these NamedPizza's are in themselves
>>>> closed for finalized (disjoint siblings and specific
>>>>        
>> restrictions) to
>>    
>>>> what they are made up of, so why not make them complete classes?
>>>>
>>>> It seems that an AmericanHot pizza is infact quite
>>>>        
>> different in the
>>    
>>>> ontology model to American pizza despite the fact they
>>>>        
>> share a lot of
>>    
>>>> the same principles! it seems natural and more likely in a
>>>> programming environment to have a class American and a more
>>>> specialised class called AmericanHot which inherits its parents
>>>> qualities plus its own and possibly overrides some of the parent
>>>> restrictions.
>>>>
>>>> Question 2: hence in OWL-DL, can a sublcass override
>>>>        
>> parent classes
>>    
>>>> restrictions in Protege etc.?
>>>>
>>>> it seems the answer is no, and hence why the Pizza developers make
>>>> both American and AmericanHot disjoint sibling classes.
>>>> However given question 2 is probably a NO, then why was Question 1
>>>> not applied?
>>>>
>>>> maybe alot of the design issues are down to OWL-DL
>>>>        
>> limitations and a
>>    
>>>> complete mapping to OO programing does not overlap in a
>>>>        
>> precise way
>>    
>>>> (code optimzation).
>>>>
>>>> hence in java you would have a 2 separate java classes
>>>>        
>> American and
>>    
>>>> AmericanHot driven by the Pizza Ontology rather than
>>>>        
>> having 2 classes
>>    
>>>> American and AmericanHot with AmericanHot as a subclass of
>>>>        
>> American
>>    
>>>> and having AmericanHot override properties of its parent class if
>>>> required.
>>>>
>>>> that is:
>>>> class American{ //class desription}
>>>> class AmericanHot {//class description}
>>>>
>>>> rather than:
>>>> class American{ //class desription}
>>>> class AmericanHot extends American {//class description}
>>>>
>>>> I welcome any comments in relation to this or any other
>>>>        
>> features that
>>    
>>>> may come to mind?
>>>>
>>>> All I am trying to do is get into the mind set of correct modeling
>>>> using DL and OWL-DL, and in a correct and formal way. I
>>>>        
>> would like to
>>    
>>>> be able to stand over any model I develop and have exact
>>>>        
>> answers to
>>    
>>>> why its modeled in a particular way.
>>>>
>>>> regards,
>>>> Will.
>>>>
>>>>
>>>>
>>>> Timothy Redmond wrote:
>>>>
>>>>        
>>>>> I see three issues.  The first thing is that in OWL we
>>>>>
>>>>>          
>>>> shouldn't need
>>>>
>>>>        
>>>>> to build all possible subclass relationships when we write the
>>>>> ontology because the inference engine will calculate them
>>>>>
>>>>>          
>>>> for us.  I
>>>>
>>>>        
>>>>> am not a modeling expert but this seems like this is a good
>>>>>
>>>>>          
>>>> principle
>>>>
>>>>        
>>>>> for OWL modeling.  This doesn't help with primitive
>>>>>
>>>>>          
>>>> concepts but for
>>>>
>>>>        
>>>>> defined concepts this may be useful.
>>>>>
>>>>> Second, I have a little trouble with the NamedPizza
>>>>>
>>>>>          
>>>> hierarchy.  It is
>>>>
>>>>        
>>>>> interesting that all of these guys are primitive - none
>>>>>          
>> of them are
>>    
>>>>> defined.  This means that there is something about a pizza
>>>>>
>>>>>          
>>>> that makes
>>>>
>>>>        
>>>>> it an american pizza that is not defined in the ontology.
>>>>>
>>>>>          
>>>> Thus it is
>>>>
>>>>        
>>>>> unclear whether american pizza's and american hot pizza's
>>>>>          
>> should be
>>    
>>>>> disjoint because it is not clear to me what is being
>>>>>
>>>>>          
>>>> captured in this
>>>>
>>>>        
>>>>> distinction.
>>>>>
>>>>> Finally, and you might view this as nitpicking, even if you
>>>>>
>>>>>          
>>>> ignore the
>>>>
>>>>        
>>>>> disjointness axioms attached to the american pizza and
>>>>>          
>> the american
>>    
>>>>> hot pizza, it is impossible for these two types of pizzas to
>>>>> intersect.   The american pizza has a restriction axiom
>>>>>          
>> that states
>>    
>>>>> that it can only have mozzarella, peperoni sausage and tomato
>>>>> toppings.  But the american hot pizza has a restriction
>>>>>          
>> axiom that
>>    
>>>>> states that it must have a JalapenoPepper topping.
>>>>>
>>>>> -Timothy
>>>>>
>>>>>
>>>>>
>>>>> On Mar 30, 2007, at 6:19 AM, william fitzgerald wrote:
>>>>>
>>>>>
>>>>>          
>>>>>> Dear OWL Gurus,
>>>>>>
>>>>>> In developing my own OWL-DL ontology similar in structure to the
>>>>>> PIZZA OWL-DL ontology, I find myself faced with a question
>>>>>>
>>>>>>            
>>>> as to why
>>>>
>>>>        
>>>>>> certain classes have not been defined as subclasses.
>>>>>>
>>>>>> For example in the NamedPizza class we have 2 subclass siblings
>>>>>> called American and AmericanHot.
>>>>>>
>>>>>> Clearly the AmericanHot is a more specialized class to
>>>>>>            
>> that of the
>>    
>>>>>> American. So why has it not been classed as a subset of
>>>>>>
>>>>>>            
>>>> AmericanPizza?
>>>>
>>>>        
>>>>>> One argument is that a hot American pizza is not an
>>>>>>            
>> American pizza
>>    
>>>>>> (because one will burn the mouth off you and the other will not)
>>>>>> hence the reason for not subclassing!
>>>>>>
>>>>>> However if we take another example we can see that under
>>>>>>            
>> Vegetable
>>    
>>>>>> toppings we have defined HotGreenPepperTopping as been a
>>>>>>            
>> subset of
>>    
>>>>>> GreenPepperTopping. In this case we do not create sibling
>>>>>>
>>>>>>            
>>>> classes but
>>>>
>>>>        
>>>>>> rather we subclass.
>>>>>>
>>>>>> So do you see my predicament!!!
>>>>>>
>>>>>> Is there a hint of a flaw in the ontology (remembering of
>>>>>>
>>>>>>            
>>>> course that
>>>>
>>>>        
>>>>>> the pizza ontology is only for demonstration purposes)
>>>>>>            
>> or is there
>>    
>>>>>> valid reasons for subclassing in one area and making disjoint
>>>>>> siblings in another?
>>>>>>
>>>>>> I realize that the structure of the pizza ontology is very
>>>>>>
>>>>>>            
>>>> intuitive
>>>>
>>>>        
>>>>>> and very close to how we naturally visualize the make up
>>>>>>
>>>>>>            
>>>> of Pizza's
>>>>
>>>>        
>>>>>> but taking these principles to other domains can often
>>>>>>            
>> be trickier.
>>    
>>>>>> regards,
>>>>>> Will.
>>>>>>
>>>>>> --William M. Fitzgerald,
>>>>>> PhD Student,
>>>>>> Telecommunications Software & Systems Group, Waterford
>>>>>>
>>>>>>            
>>>> Institute of
>>>>
>>>>        
>>>>>> Technology, Cork Rd.
>>>>>> Waterford.
>>>>>> Office Ph: +353 51 302937
>>>>>> Mobile Ph: +353 87 9527083
>>>>>>
>>>>>> _______________________________________________
>>>>>> protege-owl mailing list
>>>>>> [hidden email]
>>>>>> https://mailman.stanford.edu/mailman/listinfo/protege-owl
>>>>>>
>>>>>> Instructions for unsubscribing:
>>>>>> http://protege.stanford.edu/doc/faq.html#01a.03
>>>>>>
>>>>>>            
>>>> --
>>>> William M. Fitzgerald,
>>>> PhD Student,
>>>> Telecommunications Software & Systems Group, Waterford
>>>>        
>> Institute of
>>    
>>>> Technology, Cork Rd.
>>>> Waterford.
>>>> Office Ph: +353 51 302937
>>>> Mobile Ph: +353 87 9527083
>>>>
>>>> _______________________________________________
>>>> protege-owl mailing list
>>>> [hidden email]
>>>> https://mailman.stanford.edu/mailman/listinfo/protege-owl
>>>>
>>>> Instructions for unsubscribing:
>>>> http://protege.stanford.edu/doc/faq.html#01a.03
>>>>
>>>>
>>>>
>>>>        
>>>      
>> --
>> William M. Fitzgerald,
>> PhD Student,
>> Telecommunications Software & Systems Group, Waterford
>> Institute of Technology, Cork Rd.
>> Waterford.
>> Office Ph: +353 51 302937
>> Mobile Ph: +353 87 9527083
>>
>>
>>
>>    
>
> _______________________________________________
> protege-owl mailing list
> [hidden email]
> https://mailman.stanford.edu/mailman/listinfo/protege-owl
>
> Instructions for unsubscribing: http://protege.stanford.edu/doc/faq.html#01a.03 
>
>  

--
William M. Fitzgerald,
PhD Student,
Telecommunications Software & Systems Group,
Waterford Institute of Technology,
Cork Rd.
Waterford.
Office Ph: +353 51 302937
Mobile Ph: +353 87 9527083

_______________________________________________
protege-owl mailing list
[hidden email]
https://mailman.stanford.edu/mailman/listinfo/protege-owl

Instructions for unsubscribing: http://protege.stanford.edu/doc/faq.html#01a.03 
Reply | Threaded
Open this post in threaded view
|

Re: Query: Subclasses or Sibling

Ronald Cornet
> I wonder if we have any Pizza developers ie. the Manchester
> University gurus out there that cans shed some light on our queries.

I hope so!

> I am not sure if I fully understand item 2 of your request,
> but when I build my ontology in Protege, weather a class is
> primitive or complete I use the closure axiom (\forall)
> across the properties that I want to restrict to certain
> classes. In the Classes GUI on the left are a hierarchy of
> classes and on the right you have property restrictions.
> right click on a \exists property for example \exists
> hasTopping XYX and then scroll to option for axiom closure.
>
> Has this answered your question?

No, I understand how to do this with classes, as you describe above.
I do not understand how to do this with instances.

So I instantiate a pizza, put some ingredients on it, and then want to express there aren't any other ingredients.

Ronald

_______________________________________________
protege-owl mailing list
[hidden email]
https://mailman.stanford.edu/mailman/listinfo/protege-owl

Instructions for unsubscribing: http://protege.stanford.edu/doc/faq.html#01a.03 
Reply | Threaded
Open this post in threaded view
|

Re: Query: Subclasses or Sibling

William Fitzgerald-2
Hi Ronald,

I would have thought that you wouldn't need to do this.

That is, you defined a class of anonymous individuals that have
relationships to other individuals of other classes. hence any instance
of a class then must comply with those class restrictions in order to be
a member.

so a Class RonaldPizza that has relationship restrictions as follows:
\exist hasTopping Cheese \sqcap
\exist hasTopping Tomato \sqcap
\forall hasTopping(Cheese \sqcup Tomato)

So RonaldPizza is restricted to having Cheese and Tomato and only those
toppings. if an instance or individual is a member of this class then it
must comply with those restrictions. And it complies with different
levels of compliance based on RoanldPizza been primitive or complete.

So an instance ronpizza1 of RonaldPizza when placed in your mouth must
only have a taste of tomato and cheese and nothing else.

Hence no need to close off instances per say.

Agree?


Ronald Cornet wrote:

>> I wonder if we have any Pizza developers ie. the Manchester
>> University gurus out there that cans shed some light on our queries.
>>    
>
> I hope so!
>
>  
>> I am not sure if I fully understand item 2 of your request,
>> but when I build my ontology in Protege, weather a class is
>> primitive or complete I use the closure axiom (\forall)
>> across the properties that I want to restrict to certain
>> classes. In the Classes GUI on the left are a hierarchy of
>> classes and on the right you have property restrictions.
>> right click on a \exists property for example \exists
>> hasTopping XYX and then scroll to option for axiom closure.
>>
>> Has this answered your question?
>>    
>
> No, I understand how to do this with classes, as you describe above.
> I do not understand how to do this with instances.
>
> So I instantiate a pizza, put some ingredients on it, and then want to express there aren't any other ingredients.
>
> Ronald
>
>  

--
William M. Fitzgerald,
PhD Student,
Telecommunications Software & Systems Group,
Waterford Institute of Technology,
Cork Rd.
Waterford.
Office Ph: +353 51 302937
Mobile Ph: +353 87 9527083

_______________________________________________
protege-owl mailing list
[hidden email]
https://mailman.stanford.edu/mailman/listinfo/protege-owl

Instructions for unsubscribing: http://protege.stanford.edu/doc/faq.html#01a.03 
Reply | Threaded
Open this post in threaded view
|

Re: Query: Subclasses or Sibling

Ronald Cornet
> Agree?

Yes and no.
I agree it works the way you do it.
But I like to do it this way:
I instantiate "Pizza" (NOT RonaldPizza) and put cheese and tomato on it.
I want to ask the reasoner: what is the 'name' of this pizza, and get the answer "RonaldPizza".
As long as I don't make explicit that this instantiated Pizza only contains cheese and tomato, it will not be recognized as a RonaldPizza.

Agree?
Anyone knows a solution?

Ronald


> Hi Ronald,
>
> I would have thought that you wouldn't need to do this.
>
> That is, you defined a class of anonymous individuals that
> have relationships to other individuals of other classes.
> hence any instance of a class then must comply with those
> class restrictions in order to be a member.
>
> so a Class RonaldPizza that has relationship restrictions as follows:
> \exist hasTopping Cheese \sqcap
> \exist hasTopping Tomato \sqcap
> \forall hasTopping(Cheese \sqcup Tomato)
>
> So RonaldPizza is restricted to having Cheese and Tomato and
> only those toppings. if an instance or individual is a member
> of this class then it must comply with those restrictions.
> And it complies with different levels of compliance based on
> RoanldPizza been primitive or complete.
>
> So an instance ronpizza1 of RonaldPizza when placed in your
> mouth must only have a taste of tomato and cheese and nothing else.
>
> Hence no need to close off instances per say.
>
>
>
> Ronald Cornet wrote:
> >> I wonder if we have any Pizza developers ie. the Manchester
> >> University gurus out there that cans shed some light on
> our queries.
> >>
> >
> > I hope so!
> >
> >
> >> I am not sure if I fully understand item 2 of your
> request, but when
> >> I build my ontology in Protege, weather a class is primitive or
> >> complete I use the closure axiom (\forall) across the
> properties that
> >> I want to restrict to certain classes. In the Classes GUI
> on the left
> >> are a hierarchy of classes and on the right you have property
> >> restrictions.
> >> right click on a \exists property for example \exists
> hasTopping XYX
> >> and then scroll to option for axiom closure.
> >>
> >> Has this answered your question?
> >>
> >
> > No, I understand how to do this with classes, as you describe above.
> > I do not understand how to do this with instances.
> >
> > So I instantiate a pizza, put some ingredients on it, and
> then want to express there aren't any other ingredients.
> >
> > Ronald
> >
> >
>
> --
> William M. Fitzgerald,
> PhD Student,
> Telecommunications Software & Systems Group, Waterford
> Institute of Technology, Cork Rd.
> Waterford.
> Office Ph: +353 51 302937
> Mobile Ph: +353 87 9527083
>
> _______________________________________________
> protege-owl mailing list
> [hidden email]
> https://mailman.stanford.edu/mailman/listinfo/protege-owl
>
> Instructions for unsubscribing:
> http://protege.stanford.edu/doc/faq.html#01a.03
>
>

_______________________________________________
protege-owl mailing list
[hidden email]
https://mailman.stanford.edu/mailman/listinfo/protege-owl

Instructions for unsubscribing: http://protege.stanford.edu/doc/faq.html#01a.03 
Reply | Threaded
Open this post in threaded view
|

Re: Query: Subclasses or Sibling

William Fitzgerald-2
Ronald,

Two possible solutions but we need the experts here on this one:

Method1:
You can still kind of answer your question using DL reasoning via
CLASSES as opposed to instances.

So you create an individual of the class Pizza, under subsumption that
individual should be re-organized in the hierarchy however lets suppose
you defined a COMPLETE class in Pizza called:

MenuToppingChoice \equiv
\exist hasTopping Cheese \sqcap
\exist hasTopping Tomato \sqcap

Note no closure.

given the RonaldPizza definition (previouse email) the reasoner will now
classify it under MenuToppingChoice also. hence any pizza instance that
is a RonaldPizza instance is an instance of your query or probe class
MenuToppingChoice and hence you found your pizza!

Method 2:

I think dealing with individuals is more a rules engine thing than a DL
reasoner area.

So you could use SWRL to reason/infer over individuals. From what I can
tell SWRL will answer questions like: Ronald has a brother called Bob,
Ronald has a daughter called Alice. is Bob an uncle? SWRL, i believe can
answer those questions.

Protege has a SWRL plugin tab.

I hope the experts in ontologies can provide you with a definitive
answer here.

regards,
Will.


Ronald Cornet wrote:

>> Agree?
>>    
>
> Yes and no.
> I agree it works the way you do it.
> But I like to do it this way:
> I instantiate "Pizza" (NOT RonaldPizza) and put cheese and tomato on it.
> I want to ask the reasoner: what is the 'name' of this pizza, and get the answer "RonaldPizza".
> As long as I don't make explicit that this instantiated Pizza only contains cheese and tomato, it will not be recognized as a RonaldPizza.
>
> Agree?
> Anyone knows a solution?
>
> Ronald
>
>
>  
>> Hi Ronald,
>>
>> I would have thought that you wouldn't need to do this.
>>
>> That is, you defined a class of anonymous individuals that
>> have relationships to other individuals of other classes.
>> hence any instance of a class then must comply with those
>> class restrictions in order to be a member.
>>
>> so a Class RonaldPizza that has relationship restrictions as follows:
>> \exist hasTopping Cheese \sqcap
>> \exist hasTopping Tomato \sqcap
>> \forall hasTopping(Cheese \sqcup Tomato)
>>
>> So RonaldPizza is restricted to having Cheese and Tomato and
>> only those toppings. if an instance or individual is a member
>> of this class then it must comply with those restrictions.
>> And it complies with different levels of compliance based on
>> RoanldPizza been primitive or complete.
>>
>> So an instance ronpizza1 of RonaldPizza when placed in your
>> mouth must only have a taste of tomato and cheese and nothing else.
>>
>> Hence no need to close off instances per say.
>>
>>
>>
>> Ronald Cornet wrote:
>>    
>>>> I wonder if we have any Pizza developers ie. the Manchester
>>>> University gurus out there that cans shed some light on
>>>>        
>> our queries.
>>    
>>> I hope so!
>>>
>>>
>>>      
>>>> I am not sure if I fully understand item 2 of your
>>>>        
>> request, but when
>>    
>>>> I build my ontology in Protege, weather a class is primitive or
>>>> complete I use the closure axiom (\forall) across the
>>>>        
>> properties that
>>    
>>>> I want to restrict to certain classes. In the Classes GUI
>>>>        
>> on the left
>>    
>>>> are a hierarchy of classes and on the right you have property
>>>> restrictions.
>>>> right click on a \exists property for example \exists
>>>>        
>> hasTopping XYX
>>    
>>>> and then scroll to option for axiom closure.
>>>>
>>>> Has this answered your question?
>>>>
>>>>        
>>> No, I understand how to do this with classes, as you describe above.
>>> I do not understand how to do this with instances.
>>>
>>> So I instantiate a pizza, put some ingredients on it, and
>>>      
>> then want to express there aren't any other ingredients.
>>    
>>> Ronald
>>>
>>>
>>>      
>> --
>> William M. Fitzgerald,
>> PhD Student,
>> Telecommunications Software & Systems Group, Waterford
>> Institute of Technology, Cork Rd.
>> Waterford.
>> Office Ph: +353 51 302937
>> Mobile Ph: +353 87 9527083
>>
>> _______________________________________________
>> protege-owl mailing list
>> [hidden email]
>> https://mailman.stanford.edu/mailman/listinfo/protege-owl
>>
>> Instructions for unsubscribing:
>> http://protege.stanford.edu/doc/faq.html#01a.03
>>
>>
>>    
>
> _______________________________________________
> protege-owl mailing list
> [hidden email]
> https://mailman.stanford.edu/mailman/listinfo/protege-owl
>
> Instructions for unsubscribing: http://protege.stanford.edu/doc/faq.html#01a.03 
>
>  

--
William M. Fitzgerald,
PhD Student,
Telecommunications Software & Systems Group,
Waterford Institute of Technology,
Cork Rd.
Waterford.
Office Ph: +353 51 302937
Mobile Ph: +353 87 9527083

_______________________________________________
protege-owl mailing list
[hidden email]
https://mailman.stanford.edu/mailman/listinfo/protege-owl

Instructions for unsubscribing: http://protege.stanford.edu/doc/faq.html#01a.03 
Reply | Threaded
Open this post in threaded view
|

Re: Query: Subclasses or Sibling

John Goodwin
In reply to this post by Ronald Cornet
> > Agree?
>
> Yes and no.
> I agree it works the way you do it.
> But I like to do it this way:
> I instantiate "Pizza" (NOT RonaldPizza) and put cheese and tomato on
it.
> I want to ask the reasoner: what is the 'name' of this pizza, and get
the
> answer "RonaldPizza".

How do you put Cheese and Tomato on it? Do you create an instance of
Cheese and an instance of Tomato and then say

pizza hasTopping cheese1
pizza hasTopping tomato1

?


> As long as I don't make explicit that this instantiated Pizza only
> contains cheese and tomato, it will not be recognized as a
RonaldPizza.
>
> Agree?

Yes

> Anyone knows a solution?

The only solution I can come up with is using nominals

So I would say

pizza1 rdf:type Pizza

pizza1 rdf:type hasTopping some Cheese and hasTopping some Pizza and
hasTopping only (Cheese or Tomato)

or

{pizza1} subClassOf hasTopping some Cheese and hasTopping some Pizza and
hasTopping only (Cheese or Tomato)


OR

pizza1 rdf:type Pizza
cheese1 rdf:type Cheese
tomato1 rdf:type Tomato
pizza1 hasTopping cheese1
pizza1 hasTopping tomato1
{pizza1} subClassOf hasTopping only (Cheese or Tomato)

Either way I close off the topping allowed for the pizza by making the
class {pizza1} a subclass of hasTopping only (Cheese or Tomato)


John

.


This email is only intended for the person to whom it is addressed and may contain confidential information. If you have received this email in error, please notify the sender and delete this email which must not be copied, distributed or disclosed to any other person.

Unless stated otherwise, the contents of this email are personal to the writer and do not represent the official view of Ordnance Survey. Nor can any contract be formed on Ordnance Survey's behalf via email. We reserve the right to monitor emails and attachments without prior notice.

Thank you for your cooperation.

Ordnance Survey
Romsey Road
Southampton SO16 4GU
Tel: 08456 050505
http://www.ordnancesurvey.co.uk

_______________________________________________
protege-owl mailing list
[hidden email]
https://mailman.stanford.edu/mailman/listinfo/protege-owl

Instructions for unsubscribing: http://protege.stanford.edu/doc/faq.html#01a.03 
Reply | Threaded
Open this post in threaded view
|

Re: Query: Subclasses or Sibling

Ronald Cornet
In reply to this post by William Fitzgerald-2
William,

Regarding method 1:
I'm not fond of "poisoning" an ontology with all kinds of probe-classes or instances-represented-as-classes.

Moreover, still the question remains: is it possible in Protégé to express closure at an instance level (for whatever purpose...)

Regarding method 2:
I'll have to look into this, I don't know much about SWRL.
Thanks for this suggestion!

Regards, Ronald


###############################################################
Ronald Cornet, PhD                    email: [hidden email]
dept. of Medical Informatics          phone: +31 (0)20 566 5188
Academic Medical Center, Room J1B-115 fax:   +31 (0)20 691 9840
P.O.Box 22700                         www: http://kik.amc.uva.nl/home/rcornet/
1100 DE  Amsterdam
The Netherlands                       'The truth is out there'

> -----Original Message-----
> From: william fitzgerald [mailto:[hidden email]]
> Sent: Tuesday, April 03, 2007 12:00
> To: [hidden email]; User support for the Protege-OWL editor
> Subject: Re: [protege-owl] Query: Subclasses or Sibling
>
> Ronald,
>
> Two possible solutions but we need the experts here on this one:
>
> Method1:
> You can still kind of answer your question using DL reasoning
> via CLASSES as opposed to instances.
>
> So you create an individual of the class Pizza, under
> subsumption that individual should be re-organized in the
> hierarchy however lets suppose you defined a COMPLETE class
> in Pizza called:
>
> MenuToppingChoice \equiv
> \exist hasTopping Cheese \sqcap
> \exist hasTopping Tomato \sqcap
>
> Note no closure.
>
> given the RonaldPizza definition (previouse email) the
> reasoner will now classify it under MenuToppingChoice also.
> hence any pizza instance that is a RonaldPizza instance is an
> instance of your query or probe class MenuToppingChoice and
> hence you found your pizza!
>
> Method 2:
>
> I think dealing with individuals is more a rules engine thing
> than a DL reasoner area.
>
> So you could use SWRL to reason/infer over individuals. From
> what I can tell SWRL will answer questions like: Ronald has a
> brother called Bob, Ronald has a daughter called Alice. is
> Bob an uncle? SWRL, i believe can answer those questions.
>
> Protege has a SWRL plugin tab.
>
> I hope the experts in ontologies can provide you with a
> definitive answer here.
>
> regards,
> Will.
>
>
> Ronald Cornet wrote:
> >> Agree?
> >>
> >
> > Yes and no.
> > I agree it works the way you do it.
> > But I like to do it this way:
> > I instantiate "Pizza" (NOT RonaldPizza) and put cheese and
> tomato on it.
> > I want to ask the reasoner: what is the 'name' of this
> pizza, and get the answer "RonaldPizza".
> > As long as I don't make explicit that this instantiated
> Pizza only contains cheese and tomato, it will not be
> recognized as a RonaldPizza.
> >
> > Agree?
> > Anyone knows a solution?
> >
> > Ronald
> >
> >
> >
> >> Hi Ronald,
> >>
> >> I would have thought that you wouldn't need to do this.
> >>
> >> That is, you defined a class of anonymous individuals that have
> >> relationships to other individuals of other classes.
> >> hence any instance of a class then must comply with those class
> >> restrictions in order to be a member.
> >>
> >> so a Class RonaldPizza that has relationship restrictions
> as follows:
> >> \exist hasTopping Cheese \sqcap
> >> \exist hasTopping Tomato \sqcap
> >> \forall hasTopping(Cheese \sqcup Tomato)
> >>
> >> So RonaldPizza is restricted to having Cheese and Tomato and only
> >> those toppings. if an instance or individual is a member of this
> >> class then it must comply with those restrictions.
> >> And it complies with different levels of compliance based on
> >> RoanldPizza been primitive or complete.
> >>
> >> So an instance ronpizza1 of RonaldPizza when placed in your mouth
> >> must only have a taste of tomato and cheese and nothing else.
> >>
> >> Hence no need to close off instances per say.
> >>
> >>
> >>
> >> Ronald Cornet wrote:
> >>
> >>>> I wonder if we have any Pizza developers ie. the Manchester
> >>>> University gurus out there that cans shed some light on
> >>>>
> >> our queries.
> >>
> >>> I hope so!
> >>>
> >>>
> >>>
> >>>> I am not sure if I fully understand item 2 of your
> >>>>
> >> request, but when
> >>
> >>>> I build my ontology in Protege, weather a class is primitive or
> >>>> complete I use the closure axiom (\forall) across the
> >>>>
> >> properties that
> >>
> >>>> I want to restrict to certain classes. In the Classes GUI
> >>>>
> >> on the left
> >>
> >>>> are a hierarchy of classes and on the right you have property
> >>>> restrictions.
> >>>> right click on a \exists property for example \exists
> >>>>
> >> hasTopping XYX
> >>
> >>>> and then scroll to option for axiom closure.
> >>>>
> >>>> Has this answered your question?
> >>>>
> >>>>
> >>> No, I understand how to do this with classes, as you
> describe above.
> >>> I do not understand how to do this with instances.
> >>>
> >>> So I instantiate a pizza, put some ingredients on it, and
> >>>
> >> then want to express there aren't any other ingredients.
> >>
> >>> Ronald
> >>>
> >>>
> >>>
> >> --
> >> William M. Fitzgerald,
> >> PhD Student,
> >> Telecommunications Software & Systems Group, Waterford
> Institute of
> >> Technology, Cork Rd.
> >> Waterford.
> >> Office Ph: +353 51 302937
> >> Mobile Ph: +353 87 9527083
> >>
> >> _______________________________________________
> >> protege-owl mailing list
> >> [hidden email]
> >> https://mailman.stanford.edu/mailman/listinfo/protege-owl
> >>
> >> Instructions for unsubscribing:
> >> http://protege.stanford.edu/doc/faq.html#01a.03
> >>
> >>
> >>
> >
> > _______________________________________________
> > protege-owl mailing list
> > [hidden email]
> > https://mailman.stanford.edu/mailman/listinfo/protege-owl
> >
> > Instructions for unsubscribing:
> > http://protege.stanford.edu/doc/faq.html#01a.03
> >
> >
>
> --
> William M. Fitzgerald,
> PhD Student,
> Telecommunications Software & Systems Group, Waterford
> Institute of Technology, Cork Rd.
> Waterford.
> Office Ph: +353 51 302937
> Mobile Ph: +353 87 9527083
>
>
>

_______________________________________________
protege-owl mailing list
[hidden email]
https://mailman.stanford.edu/mailman/listinfo/protege-owl

Instructions for unsubscribing: http://protege.stanford.edu/doc/faq.html#01a.03 
Reply | Threaded
Open this post in threaded view
|

Re: Query: Subclasses or Sibling

Ronald Cornet
In reply to this post by John Goodwin
> How do you put Cheese and Tomato on it? Do you create an
> instance of Cheese and an instance of Tomato and then say
>
> pizza hasTopping cheese1
> pizza hasTopping tomato1
>
> ?

Yes!

I agree that your representations below work.
But is there any way to do this in protégé?
If I create an instance of pizza, I get the frames for ingredients (and base), but these are only suitable for specifying:
> pizza1 hasTopping cheese1
> pizza1 hasTopping tomato1

I wouldn't know how to specify the other parts of your statements.

Regards, Ronald

> The only solution I can come up with is using nominals
>
> So I would say
>
> pizza1 rdf:type Pizza
>
> pizza1 rdf:type hasTopping some Cheese and hasTopping some
> Pizza and hasTopping only (Cheese or Tomato)
>
> or
>
> {pizza1} subClassOf hasTopping some Cheese and hasTopping
> some Pizza and hasTopping only (Cheese or Tomato)
>
>
> OR
>
> pizza1 rdf:type Pizza
> cheese1 rdf:type Cheese
> tomato1 rdf:type Tomato
> pizza1 hasTopping cheese1
> pizza1 hasTopping tomato1
> {pizza1} subClassOf hasTopping only (Cheese or Tomato)
>
> Either way I close off the topping allowed for the pizza by
> making the class {pizza1} a subclass of hasTopping only
> (Cheese or Tomato)
>
>
> John
>
> .
>
>
> This email is only intended for the person to whom it is
> addressed and may contain confidential information. If you
> have received this email in error, please notify the sender
> and delete this email which must not be copied, distributed
> or disclosed to any other person.
>
> Unless stated otherwise, the contents of this email are
> personal to the writer and do not represent the official view
> of Ordnance Survey. Nor can any contract be formed on
> Ordnance Survey's behalf via email. We reserve the right to
> monitor emails and attachments without prior notice.
>
> Thank you for your cooperation.
>
> Ordnance Survey
> Romsey Road
> Southampton SO16 4GU
> Tel: 08456 050505
> http://www.ordnancesurvey.co.uk
>  
>

_______________________________________________
protege-owl mailing list
[hidden email]
https://mailman.stanford.edu/mailman/listinfo/protege-owl

Instructions for unsubscribing: http://protege.stanford.edu/doc/faq.html#01a.03 
Reply | Threaded
Open this post in threaded view
|

Re: Query: Subclasses or Sibling

John Goodwin
> I agree that your representations below work.
> But is there any way to do this in protégé?
> If I create an instance of pizza, I get the frames for ingredients (and
> base), but these are only suitable for specifying:
> > pizza1 hasTopping cheese1
> > pizza1 hasTopping tomato1
>
> I wouldn't know how to specify the other parts of your statements.

If you are using Protégé 3.x the only way I can think of (and the way I did it) is to create a class:

Pizza1 subClassOf Pizza

Create an instance of Pizza called pizza1

Then say:

Pizza1 = {pizza1}

(literally type "{pizza1}" in the necessary and sufficient condition block for that class - this is basically saying Pizza1 = oneOf{pizza1})


The add a necessary condition

Pizza1 subClassOf hasTopping only (Cheese or Tomato)

Admittedly it's a bit messy, but it's more a way of getting round some of the editing limitations.

In Protégé 4 alpha you can actually directly assert (under the individual tab and in the asserted types box) that

pizza1 instanceOf hasTopping only (Cheese or Tomato)

which should do the job.

John


.


This email is only intended for the person to whom it is addressed and may contain confidential information. If you have received this email in error, please notify the sender and delete this email which must not be copied, distributed or disclosed to any other person.

Unless stated otherwise, the contents of this email are personal to the writer and do not represent the official view of Ordnance Survey. Nor can any contract be formed on Ordnance Survey's behalf via email. We reserve the right to monitor emails and attachments without prior notice.

Thank you for your cooperation.

Ordnance Survey
Romsey Road
Southampton SO16 4GU
Tel: 08456 050505
http://www.ordnancesurvey.co.uk

_______________________________________________
protege-owl mailing list
[hidden email]
https://mailman.stanford.edu/mailman/listinfo/protege-owl

Instructions for unsubscribing: http://protege.stanford.edu/doc/faq.html#01a.03 
Reply | Threaded
Open this post in threaded view
|

Re: Query: Subclasses or Sibling

Ronald Cornet
> In Protégé 4 alpha you can actually directly assert (under
> the individual tab and in the asserted types box) that
>
> pizza1 instanceOf hasTopping only (Cheese or Tomato)
>

Thanks for this, John.
I had downloaded 4 alpha, but didn't experiment with it.
Your comment makes it worthwhile to start experimenting!

Regards, Ronald

_______________________________________________
protege-owl mailing list
[hidden email]
https://mailman.stanford.edu/mailman/listinfo/protege-owl

Instructions for unsubscribing: http://protege.stanford.edu/doc/faq.html#01a.03 
Reply | Threaded
Open this post in threaded view
|

Re: Query: Subclasses or Sibling

William Fitzgerald-2
In reply to this post by John Goodwin
Hi John,

Will the ontology be still in OWL-DL?

stating a class is also an individual [Pizza1 = oneOf{pizza1}] I think
is out of scope of DL.

Maybe I am misunderstanding you.


John Goodwin wrote:

>> I agree that your representations below work.
>> But is there any way to do this in protégé?
>> If I create an instance of pizza, I get the frames for ingredients (and
>> base), but these are only suitable for specifying:
>>    
>>> pizza1 hasTopping cheese1
>>> pizza1 hasTopping tomato1
>>>      
>> I wouldn't know how to specify the other parts of your statements.
>>    
>
> If you are using Protégé 3.x the only way I can think of (and the way I did it) is to create a class:
>
> Pizza1 subClassOf Pizza
>
> Create an instance of Pizza called pizza1
>
> Then say:
>
> Pizza1 = {pizza1}
>
> (literally type "{pizza1}" in the necessary and sufficient condition block for that class - this is basically saying Pizza1 = oneOf{pizza1})
>
>
> The add a necessary condition
>
> Pizza1 subClassOf hasTopping only (Cheese or Tomato)
>
> Admittedly it's a bit messy, but it's more a way of getting round some of the editing limitations.
>
> In Protégé 4 alpha you can actually directly assert (under the individual tab and in the asserted types box) that
>
> pizza1 instanceOf hasTopping only (Cheese or Tomato)
>
> which should do the job.
>
> John
>
>
> .
>
>
> This email is only intended for the person to whom it is addressed and may contain confidential information. If you have received this email in error, please notify the sender and delete this email which must not be copied, distributed or disclosed to any other person.
>
> Unless stated otherwise, the contents of this email are personal to the writer and do not represent the official view of Ordnance Survey. Nor can any contract be formed on Ordnance Survey's behalf via email. We reserve the right to monitor emails and attachments without prior notice.
>
> Thank you for your cooperation.
>
> Ordnance Survey
> Romsey Road
> Southampton SO16 4GU
> Tel: 08456 050505
> http://www.ordnancesurvey.co.uk
>
> _______________________________________________
> protege-owl mailing list
> [hidden email]
> https://mailman.stanford.edu/mailman/listinfo/protege-owl
>
> Instructions for unsubscribing: http://protege.stanford.edu/doc/faq.html#01a.03 
>
>  

--
William M. Fitzgerald,
PhD Student,
Telecommunications Software & Systems Group,
Waterford Institute of Technology,
Cork Rd.
Waterford.
Office Ph: +353 51 302937
Mobile Ph: +353 87 9527083

_______________________________________________
protege-owl mailing list
[hidden email]
https://mailman.stanford.edu/mailman/listinfo/protege-owl

Instructions for unsubscribing: http://protege.stanford.edu/doc/faq.html#01a.03 
Reply | Threaded
Open this post in threaded view
|

Re: Query: Subclasses or Sibling

Matthew Horridge
> Will the ontology be still in OWL-DL?


Yes.

> stating a class is also an individual [Pizza1 = oneOf{pizza1}] I think
> is out of scope of DL.

This is within the bounds of OWL-DL.

In Protege 3.X you can also try the OWL-DL Individuals Tab, which  
adds the capability of adding anonymous types to individuals.

Cheers,

Matthew



> Maybe I am misunderstanding you.
>
>
> John Goodwin wrote:
>>> I agree that your representations below work.
>>> But is there any way to do this in protégé?
>>> If I create an instance of pizza, I get the frames for  
>>> ingredients (and
>>> base), but these are only suitable for specifying:
>>>
>>>> pizza1 hasTopping cheese1
>>>> pizza1 hasTopping tomato1
>>>>
>>> I wouldn't know how to specify the other parts of your statements.
>>>
>>
>> If you are using Protégé 3.x the only way I can think of (and the  
>> way I did it) is to create a class:
>>
>> Pizza1 subClassOf Pizza
>>
>> Create an instance of Pizza called pizza1
>>
>> Then say:
>>
>> Pizza1 = {pizza1}
>>
>> (literally type "{pizza1}" in the necessary and sufficient  
>> condition block for that class - this is basically saying Pizza1 =  
>> oneOf{pizza1})
>>
>>
>> The add a necessary condition
>>
>> Pizza1 subClassOf hasTopping only (Cheese or Tomato)
>>
>> Admittedly it's a bit messy, but it's more a way of getting round  
>> some of the editing limitations.
>>
>> In Protégé 4 alpha you can actually directly assert (under the  
>> individual tab and in the asserted types box) that
>>
>> pizza1 instanceOf hasTopping only (Cheese or Tomato)
>>
>> which should do the job.
>>
>> John
>>
>>
>> .
>>
>>
>> This email is only intended for the person to whom it is addressed  
>> and may contain confidential information. If you have received  
>> this email in error, please notify the sender and delete this  
>> email which must not be copied, distributed or disclosed to any  
>> other person.
>>
>> Unless stated otherwise, the contents of this email are personal  
>> to the writer and do not represent the official view of Ordnance  
>> Survey. Nor can any contract be formed on Ordnance Survey's behalf  
>> via email. We reserve the right to monitor emails and attachments  
>> without prior notice.
>>
>> Thank you for your cooperation.
>>
>> Ordnance Survey
>> Romsey Road
>> Southampton SO16 4GU
>> Tel: 08456 050505
>> http://www.ordnancesurvey.co.uk
>>
>> _______________________________________________
>> protege-owl mailing list
>> [hidden email]
>> https://mailman.stanford.edu/mailman/listinfo/protege-owl
>>
>> Instructions for unsubscribing: http://protege.stanford.edu/doc/ 
>> faq.html#01a.03
>>
>>
>
> --
> William M. Fitzgerald,
> PhD Student,
> Telecommunications Software & Systems Group,
> Waterford Institute of Technology,
> Cork Rd.
> Waterford.
> Office Ph: +353 51 302937
> Mobile Ph: +353 87 9527083
>
> _______________________________________________
> protege-owl mailing list
> [hidden email]
> https://mailman.stanford.edu/mailman/listinfo/protege-owl
>
> Instructions for unsubscribing: http://protege.stanford.edu/doc/ 
> faq.html#01a.03

_______________________________________________
protege-owl mailing list
[hidden email]
https://mailman.stanford.edu/mailman/listinfo/protege-owl

Instructions for unsubscribing: http://protege.stanford.edu/doc/faq.html#01a.03 
Reply | Threaded
Open this post in threaded view
|

Re: Query: Subclasses or Sibling

John Goodwin
In reply to this post by William Fitzgerald-2
> Hi John,
>
> Will the ontology be still in OWL-DL?
>
> stating a class is also an individual [Pizza1 = oneOf{pizza1}] I think
> is out of scope of DL.
>
> Maybe I am misunderstanding you.

Sorry - probably should have used a different name for the class and instance (and not just capitalised the class name) to make it clear. So I really want to say:

Pizza1 = oneOf(mypizza)
Then:

Pizza1 subclassOf hasTopping only (Cheese or Tomato)

I only do it this way to get round editing limitations in Protégé 3.x as there is no way to directly say

{mypizza} subClassOf hasTopping only (Cheese or Tomato)

Or

mypizza instanceOf hasTopping only (Cheese or Tomato)

(both of which are OWL DL)

John

.


This email is only intended for the person to whom it is addressed and may contain confidential information. If you have received this email in error, please notify the sender and delete this email which must not be copied, distributed or disclosed to any other person.

Unless stated otherwise, the contents of this email are personal to the writer and do not represent the official view of Ordnance Survey. Nor can any contract be formed on Ordnance Survey's behalf via email. We reserve the right to monitor emails and attachments without prior notice.

Thank you for your cooperation.

Ordnance Survey
Romsey Road
Southampton SO16 4GU
Tel: 08456 050505
http://www.ordnancesurvey.co.uk

_______________________________________________
protege-owl mailing list
[hidden email]
https://mailman.stanford.edu/mailman/listinfo/protege-owl

Instructions for unsubscribing: http://protege.stanford.edu/doc/faq.html#01a.03 
Reply | Threaded
Open this post in threaded view
|

Re: Query: Subclasses or Sibling

John Goodwin


> > Hi John,
> >
> > Will the ontology be still in OWL-DL?
> >
> > stating a class is also an individual [Pizza1 = oneOf{pizza1}] I think
> > is out of scope of DL.
> >
> > Maybe I am misunderstanding you.
>
> Sorry - probably should have used a different name for the class and
> instance (and not just capitalised the class name) to make it clear. So I
> really want to say:
>
> Pizza1 = oneOf(mypizza)
> Then:
>
> Pizza1 subclassOf hasTopping only (Cheese or Tomato)
>
> I only do it this way to get round editing limitations in Protégé 3.x as
> there is no way to directly say


Although, as Matthew points out, there is a plug-in that lets you.

John

.


This email is only intended for the person to whom it is addressed and may contain confidential information. If you have received this email in error, please notify the sender and delete this email which must not be copied, distributed or disclosed to any other person.

Unless stated otherwise, the contents of this email are personal to the writer and do not represent the official view of Ordnance Survey. Nor can any contract be formed on Ordnance Survey's behalf via email. We reserve the right to monitor emails and attachments without prior notice.

Thank you for your cooperation.

Ordnance Survey
Romsey Road
Southampton SO16 4GU
Tel: 08456 050505
http://www.ordnancesurvey.co.uk

_______________________________________________
protege-owl mailing list
[hidden email]
https://mailman.stanford.edu/mailman/listinfo/protege-owl

Instructions for unsubscribing: http://protege.stanford.edu/doc/faq.html#01a.03 
12