QCRs and DIG: Racer, FaCT and Pellet

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

QCRs and DIG: Racer, FaCT and Pellet

Elyes Lehtihet-3

Hello,

 

I need to represent an interval of values for an object property. It is not a problem with [0..n] or [1..1], but how do I correctly represent [x..y] , where y>x and y!=n ???

I know that there is an issue with the Qualified Cardinality Restrictions, but that would be great to use a DIG Reasoner to check the consistency against QCRs, which I suppose are the only solution to my problem.

 

I am using Protégé 3.1.1 with Pellet 1.3 Beta2, Racer 1.9 and FaCT++ 1.1.3

 

The Reasoners don’t support cardinality restriction on DataType Property, this limitation is going to be solved in the next version of DIG!? Does anyone know where I can find more information about that?

 

In [1], Alan Rector and Guus Schreiber claim that Racer already support QCR; FaCT++ will shortly do, the document is dated November 2005. The status of the document is: Needs final cleanup and incorporation of responses to reviews by Alistair and Jeff.

 

I created a simple ontology to test if the Non-Endorsed Owl Extension, as presented in [1], which *I think?* is replacing owl:allValuesFrom with owl:valuesFrom, works with Racer and FaCT++.

I quickly created a simple ontology (please see attached: test.owl) with Protégé, using allValueFrom restriction. I used the example of Diner and MinimalDiner, where a MinimalDiner should have only three particular types of courses. Of course, all the reasoners generated an error: MinimalDiner is inconsistent. I added SomethingElse as a subclass of course and a target of has_course, to test if it will generate an error when changing the syntax of allValuesFrom.

 

After, I manually changed allValuesFrom to valuesFrom (please see attached: testqcr.owl). The ontology, now OWL-Full, is loaded without generating any error in Protégé, except that:

1- It is quiet slow when selecting the constrained class and it doesn’t show the code.

2- Protégé replaced the constraints by some weird code : @_:A671 and @_:A680 and @_:A689 and @_:A698

3- When starting the Reasoners (Racer, Pellet and FaCT++), it start processing but never stop, or generate any inconsistency error.

I also tried with RacerPorter to see if the problem was only with Protégé, but it doesn’t want to load the ontology.

 

So, it is obvious that it doesn’t work…

Am I doing something wrong? Is there any other solution?

 

Any help would be much appreciated

 

Thanks

Elyes

 

[1] http://www.w3.org/2001/sw/BestPractices/OEP/QCR/


testqcr.owl (5K) Download Attachment
test.owl (5K) Download Attachment
Reply | Threaded
Open this post in threaded view
|

Re: QCRs and DIG: Racer, FaCT and Pellet

Ulrike Sattler
Hi,

what is it that you want to do exactly? I don't understand your "interval of values": assume we have an object property, eg,  hasChild, with Range Human, and Human has (non-disjoint) subclasses Tall, Happy, Naughty, Silly, etc. 

Do you want to describe a class by restricted the number of hasChild of a certain kind? This is what we would use qualified number restrictions for: eg, to say that a happyParent has between 2 and 4 children that are instances of Happy, or to say that a StressedParent has atleast 4 children that are instances of the UnionOf (naughty silly)...

You don't need datatype properties for this: these are for "concrete" (ie datatype) properties such as age, height, weight, etc., and there one might want to describe Tall as having a height between 190 and 200 (cm), which is completely different from the above QCRs: we would still want to have a single height, and we would like to say that its filler is a non-negative integer between 190 and 200!

Cheers, Uli


On 11 Apr 2006, at 10:39, Elyes Lehtihet wrote:

Hello,

 

I need to represent an interval of values for an object property. It is not a problem with [0..n] or [1..1], but how do I correctly represent [x..y] , where y>x and y!=n ???

I know that there is an issue with the Qualified Cardinality Restrictions, but that would be great to use a DIG Reasoner to check the consistency against QCRs, which I suppose are the only solution to my problem.

 

I am using Protégé 3.1.1 with Pellet 1.3 Beta2, Racer 1.9 and FaCT++ 1.1.3

 

The Reasoners don’t support cardinality restriction on DataType Property, this limitation is going to be solved in the next version of DIG!? Does anyone know where I can find more information about that?

 

In [1], Alan Rector and Guus Schreiber claim that Racer already support QCR; FaCT++ will shortly do, the document is dated November 2005. The status of the document is: Needs final cleanup and incorporation of responses to reviews by Alistair and Jeff.

 

I created a simple ontology to test if the Non-Endorsed Owl Extension, as presented in [1], which *I think?* is replacing owl:allValuesFrom with owl:valuesFrom, works with Racer and FaCT++.

I quickly created a simple ontology (please see attached: test.owl) with Protégé, using allValueFrom restriction. I used the example of Diner and MinimalDiner, where a MinimalDiner should have only three particular types of courses. Of course, all the reasoners generated an error: MinimalDiner is inconsistent. I added SomethingElse as a subclass of course and a target of has_course, to test if it will generate an error when changing the syntax of allValuesFrom.

 

After, I manually changed allValuesFrom to valuesFrom (please see attached: testqcr.owl). The ontology, now OWL-Full, is loaded without generating any error in Protégé, except that:

1- It is quiet slow when selecting the constrained class and it doesn’t show the code.

2- Protégé replaced the constraints by some weird code : @_:A671 and @_:A680 and @_:A689 and @_:A698

3- When starting the Reasoners (Racer, Pellet and FaCT++), it start processing but never stop, or generate any inconsistency error.

I also tried with RacerPorter to see if the problem was only with Protégé, but it doesn’t want to load the ontology.

 

So, it is obvious that it doesn’t work…

Am I doing something wrong? Is there any other solution?

 

Any help would be much appreciated

 

Thanks

Elyes

 

[1] http://www.w3.org/2001/sw/BestPractices/OEP/QCR/

<testqcr.owl>
<test.owl>

Reply | Threaded
Open this post in threaded view
|

Re: QCRs and DIG: Racer, FaCT and Pellet

Elyes Lehtihet-3

Hi Uli,

 

Thanks for your quick reply, but I am afraid I still don’t get it, maybe my example was not enough clear…

 

I need to constraint an ObjectProperty, where a Class *must have exactly n instances* of a particular ObjectProperty. I wonder if I can reuse OWL Grammar and compliant DIG Reasoner to check the consistency of such constraints.

Back to your example, that would imply that aParent must have 4 children = 2 Happy, 1 Silly, 1 Tall. Where the Reasoner *WILL* generate an inconsistency if an instance, or a subclass, of aParent has:

More or less than 4 children *and*

More or less than 2 happy children *and*

More or less than 1 silly *and*

More or less than 1 Tall *and*

 

Is there a way to model that?

 

Regards

Elyes

 


From: [hidden email] [mailto:[hidden email]] On Behalf Of Uli Sattler
Sent: Tuesday, April 11, 2006 11:00 AM
To: [hidden email]
Subject: [protege-owl] Re: QCRs and DIG: Racer, FaCT and Pellet

 

Hi,

 

what is it that you want to do exactly? I don't understand your "interval of values": assume we have an object property, eg,  hasChild, with Range Human, and Human has (non-disjoint) subclasses Tall, Happy, Naughty, Silly, etc. 

 

Do you want to describe a class by restricted the number of hasChild of a certain kind? This is what we would use qualified number restrictions for: eg, to say that a happyParent has between 2 and 4 children that are instances of Happy, or to say that a StressedParent has atleast 4 children that are instances of the UnionOf (naughty silly)...

 

You don't need datatype properties for this: these are for "concrete" (ie datatype) properties such as age, height, weight, etc., and there one might want to describe Tall as having a height between 190 and 200 (cm), which is completely different from the above QCRs: we would still want to have a single height, and we would like to say that its filler is a non-negative integer between 190 and 200!

 

Cheers, Uli

 

 

On 11 Apr 2006, at 10:39, Elyes Lehtihet wrote:



Hello,

 

I need to represent an interval of values for an object property. It is not a problem with [0..n] or [1..1], but how do I correctly represent [x..y] , where y>x and y!=n ???

I know that there is an issue with the Qualified Cardinality Restrictions, but that would be great to use a DIG Reasoner to check the consistency against QCRs, which I suppose are the only solution to my problem.

 

I am using Protégé 3.1.1 with Pellet 1.3 Beta2, Racer 1.9 and FaCT++ 1.1.3

 

The Reasoners don’t support cardinality restriction on DataType Property, this limitation is going to be solved in the next version of DIG!? Does anyone know where I can find more information about that?

 

In [1], Alan Rector and Guus Schreiber claim that Racer already support QCR; FaCT++ will shortly do, the document is dated November 2005. The status of the document is: Needs final cleanup and incorporation of responses to reviews by Alistair and Jeff.

 

I created a simple ontology to test if the Non-Endorsed Owl Extension, as presented in [1], which *I think?* is replacing owl:allValuesFrom with owl:valuesFrom, works with Racer and FaCT++.

I quickly created a simple ontology (please see attached: test.owl) with Protégé, using allValueFrom restriction. I used the example of Diner and MinimalDiner, where a MinimalDiner should have only three particular types of courses. Of course, all the reasoners generated an error: MinimalDiner is inconsistent. I added SomethingElse as a subclass of course and a target of has_course, to test if it will generate an error when changing the syntax of allValuesFrom.

 

After, I manually changed allValuesFrom to valuesFrom (please see attached: testqcr.owl). The ontology, now OWL-Full, is loaded without generating any error in Protégé, except that:

1- It is quiet slow when selecting the constrained class and it doesn’t show the code.

2- Protégé replaced the constraints by some weird code : @_:A671 and @_:A680 and @_:A689 and @_:A698

3- When starting the Reasoners (Racer, Pellet and FaCT++), it start processing but never stop, or generate any inconsistency error.

I also tried with RacerPorter to see if the problem was only with Protégé, but it doesn’t want to load the ontology.

 

So, it is obvious that it doesn’t work…

Am I doing something wrong? Is there any other solution?

 

Any help would be much appreciated

 

Thanks

Elyes

 

[1] http://www.w3.org/2001/sw/BestPractices/OEP/QCR/

<testqcr.owl>

<test.owl>

 

Reply | Threaded
Open this post in threaded view
|

Re: QCRs and DIG: Racer, FaCT and Pellet

Elyes Lehtihet-3
In reply to this post by Ulrike Sattler

Hi, again,

 

I created another example of your ontology with Parent and Children. happyParent have between 2 and 4 children that are happy. stresseParent have 4 or more children that are union of Silly and Naughty.

All the Reasoners do not generate any inconsistency error when I attach more than the number of allowed children (has_child) to any class. happyParent should not have 6 Happy children. stressedParent should not have 2 Silly and 1 Naughty….

 

Please see attached file, it might be something wrong with the way I formulate the constraints!?

 

Regards

Elyes

 


From: [hidden email] [mailto:[hidden email]] On Behalf Of Uli Sattler
Sent: Tuesday, April 11, 2006 11:00 AM
To: [hidden email]
Subject: [protege-owl] Re: QCRs and DIG: Racer, FaCT and Pellet

 

Hi,

 

what is it that you want to do exactly? I don't understand your "interval of values": assume we have an object property, eg,  hasChild, with Range Human, and Human has (non-disjoint) subclasses Tall, Happy, Naughty, Silly, etc. 

 

Do you want to describe a class by restricted the number of hasChild of a certain kind? This is what we would use qualified number restrictions for: eg, to say that a happyParent has between 2 and 4 children that are instances of Happy, or to say that a StressedParent has atleast 4 children that are instances of the UnionOf (naughty silly)...

 

You don't need datatype properties for this: these are for "concrete" (ie datatype) properties such as age, height, weight, etc., and there one might want to describe Tall as having a height between 190 and 200 (cm), which is completely different from the above QCRs: we would still want to have a single height, and we would like to say that its filler is a non-negative integer between 190 and 200!

 

Cheers, Uli

 

 

On 11 Apr 2006, at 10:39, Elyes Lehtihet wrote:



Hello,

 

I need to represent an interval of values for an object property. It is not a problem with [0..n] or [1..1], but how do I correctly represent [x..y] , where y>x and y!=n ???

I know that there is an issue with the Qualified Cardinality Restrictions, but that would be great to use a DIG Reasoner to check the consistency against QCRs, which I suppose are the only solution to my problem.

 

I am using Protégé 3.1.1 with Pellet 1.3 Beta2, Racer 1.9 and FaCT++ 1.1.3

 

The Reasoners don’t support cardinality restriction on DataType Property, this limitation is going to be solved in the next version of DIG!? Does anyone know where I can find more information about that?

 

In [1], Alan Rector and Guus Schreiber claim that Racer already support QCR; FaCT++ will shortly do, the document is dated November 2005. The status of the document is: Needs final cleanup and incorporation of responses to reviews by Alistair and Jeff.

 

I created a simple ontology to test if the Non-Endorsed Owl Extension, as presented in [1], which *I think?* is replacing owl:allValuesFrom with owl:valuesFrom, works with Racer and FaCT++.

I quickly created a simple ontology (please see attached: test.owl) with Protégé, using allValueFrom restriction. I used the example of Diner and MinimalDiner, where a MinimalDiner should have only three particular types of courses. Of course, all the reasoners generated an error: MinimalDiner is inconsistent. I added SomethingElse as a subclass of course and a target of has_course, to test if it will generate an error when changing the syntax of allValuesFrom.

 

After, I manually changed allValuesFrom to valuesFrom (please see attached: testqcr.owl). The ontology, now OWL-Full, is loaded without generating any error in Protégé, except that:

1- It is quiet slow when selecting the constrained class and it doesn’t show the code.

2- Protégé replaced the constraints by some weird code : @_:A671 and @_:A680 and @_:A689 and @_:A698

3- When starting the Reasoners (Racer, Pellet and FaCT++), it start processing but never stop, or generate any inconsistency error.

I also tried with RacerPorter to see if the problem was only with Protégé, but it doesn’t want to load the ontology.

 

So, it is obvious that it doesn’t work…

Am I doing something wrong? Is there any other solution?

 

Any help would be much appreciated

 

Thanks

Elyes

 

[1] http://www.w3.org/2001/sw/BestPractices/OEP/QCR/

<testqcr.owl>

<test.owl>

 


test-uli.owl (4K) Download Attachment
Reply | Threaded
Open this post in threaded view
|

Re: QCRs and DIG: Racer, FaCT and Pellet

Ulrike Sattler
In reply to this post by Elyes Lehtihet-3
On 11 Apr 2006, at 11:41, Elyes Lehtihet wrote:

Hi Uli,

 

Thanks for your quick reply, but I am afraid I still don’t get it, maybe my example was not enough clear…

 

I need to constraint an ObjectProperty, where a Class *must have exactly n instances* of a particular ObjectProperty. I wonder if I can reuse OWL Grammar and compliant DIG Reasoner to check the consistency of such constraints.

I think you can:

Back to your example, that would imply that

what would imply this? 

aParent must have 4 children = 2 Happy, 1 Silly, 1 Tall.

I guess you want to define such a class of Parents, say YourParent, by saying that they have 
exactly 2 happy children,
exactly 1 silly, and 
exactly 1 tall

but then an instance of YourParent could have any number of children greater than 2:

e.g., a YourParent could have 2 children, c1 and c2, c1 is happy and not tall and silly, c2 is happy and tall and not silly,
or another YourParent could have 10 children, g1 to g10, only g1 and g2 are happy, and only g3 is silly, and only g4 is tall!  

Where the Reasoner *WILL* generate an inconsistency if an instance, or a subclass, of aParent has:

More or less than 4 children *and*

More or less than 2 happy children *and*

More or less than 1 silly *and*

More or less than 1 Tall *and*

 


hmmm, I guess you aemn that a reasoner will come back with an  inconsistency in case you make a subclass of YourParent with atmost 1 happy child or at least 3 happy ones, or with at least 2 silly children, or with at least 2 tall children.

Please note that you can safely generate an instance, say bob, of YourParent without declaring any of its children! 

The reasoner will simply infer that bob has 2 happy children and...

Is there a way to model that?

 


so, what exactly do you want to model? Cheers, Uli

Regards

Elyes

 


From: [hidden email] [[hidden email]] On Behalf Of Uli Sattler
Sent: Tuesday, April 11, 2006 11:00 AM
To: [hidden email]
Subject: [protege-owl] Re: QCRs and DIG: Racer, FaCT and Pellet

 

Hi,

 

what is it that you want to do exactly? I don't understand your "interval of values": assume we have an object property, eg,  hasChild, with Range Human, and Human has (non-disjoint) subclasses Tall, Happy, Naughty, Silly, etc. 

 

Do you want to describe a class by restricted the number of hasChild of a certain kind? This is what we would use qualified number restrictions for: eg, to say that a happyParent has between 2 and 4 children that are instances of Happy, or to say that a StressedParent has atleast 4 children that are instances of the UnionOf (naughty silly)...

 

You don't need datatype properties for this: these are for "concrete" (ie datatype) properties such as age, height, weight, etc., and there one might want to describe Tall as having a height between 190 and 200 (cm), which is completely different from the above QCRs: we would still want to have a single height, and we would like to say that its filler is a non-negative integer between 190 and 200!

 

Cheers, Uli

 

 

On 11 Apr 2006, at 10:39, Elyes Lehtihet wrote:



Hello,

 

I need to represent an interval of values for an object property. It is not a problem with [0..n] or [1..1], but how do I correctly represent [x..y] , where y>x and y!=n ???

I know that there is an issue with the Qualified Cardinality Restrictions, but that would be great to use a DIG Reasoner to check the consistency against QCRs, which I suppose are the only solution to my problem.

 

I am using Protégé 3.1.1 with Pellet 1.3 Beta2, Racer 1.9 and FaCT++ 1.1.3

 

The Reasoners don’t support cardinality restriction on DataType Property, this limitation is going to be solved in the next version of DIG!? Does anyone know where I can find more information about that?

 

In [1], Alan Rector and Guus Schreiber claim that Racer already support QCR; FaCT++ will shortly do, the document is dated November 2005. The status of the document is: Needs final cleanup and incorporation of responses to reviews by Alistair and Jeff.

 

I created a simple ontology to test if the Non-Endorsed Owl Extension, as presented in [1], which *I think?* is replacing owl:allValuesFrom with owl:valuesFrom, works with Racer and FaCT++.

I quickly created a simple ontology (please see attached: test.owl) with Protégé, using allValueFrom restriction. I used the example of Diner and MinimalDiner, where a MinimalDiner should have only three particular types of courses. Of course, all the reasoners generated an error: MinimalDiner is inconsistent. I added SomethingElse as a subclass of course and a target of has_course, to test if it will generate an error when changing the syntax of allValuesFrom.

 

After, I manually changed allValuesFrom to valuesFrom (please see attached: testqcr.owl). The ontology, now OWL-Full, is loaded without generating any error in Protégé, except that:

1- It is quiet slow when selecting the constrained class and it doesn’t show the code.

2- Protégé replaced the constraints by some weird code : @_:A671 and @_:A680 and @_:A689 and @_:A698

3- When starting the Reasoners (Racer, Pellet and FaCT++), it start processing but never stop, or generate any inconsistency error.

I also tried with RacerPorter to see if the problem was only with Protégé, but it doesn’t want to load the ontology.

 

So, it is obvious that it doesn’t work…

Am I doing something wrong? Is there any other solution?

 

Any help would be much appreciated

 

Thanks

Elyes

 

[1] http://www.w3.org/2001/sw/BestPractices/OEP/QCR/

<testqcr.owl>

<test.owl>

 



Reply | Threaded
Open this post in threaded view
|

AW: Re: QCRs and DIG: Racer, FaCT and Pellet

Rajverma
In reply to this post by Elyes Lehtihet-3

Hi Uli,

 

In the test.owl ontology that Elyes has posted, these are the following constraints for the concept Minimal_Diner:

 

1. (has_course exactly 1) and (has_course only Desert)                          (Necessary & Sufficient)

2. (has_course exactly 1) and (has_course only Main_course)                 (Necessary & Sufficient)

3. (has_course exactly 1) and (has_course only SomethingElse)             (Necessary & Sufficient)

4. (has_course exactly 1) and (has_course only Starter)                         (Necessary & Sufficient)

5. has_course exactly 3                                                                       (Necessary & Sufficient)

 

6. Diner                                                                                               (Necessary)

 

7. has_course only Course                                                                    (Inherited)

 

Isn’t the following model a satisfiable model for the concept Minimal_Diner along with its restrictions?

 

                                      T

                                   /  |  \

                            hc /     |    \  hc

                               /   hc|      \

                         Desert    |    Starter

                                       |

                               Main_course

                             SomethingElse

 

If yes, then why is this concept inconsistent?

 

Cheers,

Raj

 

 

 

 


Von: [hidden email] [mailto:[hidden email]] Im Auftrag von Uli Sattler
Gese
ndet: Dienstag, 11. April 2006 12:00
An: [hidden email]
Betreff: [protege-owl] Re: QCRs and DIG: Racer, FaCT and Pellet

 

Hi,

 

what is it that you want to do exactly? I don't understand your "interval of values": assume we have an object property, eg,  hasChild, with Range Human, and Human has (non-disjoint) subclasses Tall, Happy, Naughty, Silly, etc. 

 

Do you want to describe a class by restricted the number of hasChild of a certain kind? This is what we would use qualified number restrictions for: eg, to say that a happyParent has between 2 and 4 children that are instances of Happy, or to say that a StressedParent has atleast 4 children that are instances of the UnionOf (naughty silly)...

 

You don't need datatype properties for this: these are for "concrete" (ie datatype) properties such as age, height, weight, etc., and there one might want to describe Tall as having a height between 190 and 200 (cm), which is completely different from the above QCRs: we would still want to have a single height, and we would like to say that its filler is a non-negative integer between 190 and 200!

 

Cheers, Uli

 

 

On 11 Apr 2006, at 10:39, Elyes Lehtihet wrote:



Hello,

 

I need to represent an interval of values for an object property. It is not a problem with [0..n] or [1..1], but how do I correctly represent [x..y] , where y>x and y!=n ???

I know that there is an issue with the Qualified Cardinality Restrictions, but that would be great to use a DIG Reasoner to check the consistency against QCRs, which I suppose are the only solution to my problem.

 

I am using Protégé 3.1.1 with Pellet 1.3 Beta2, Racer 1.9 and FaCT++ 1.1.3

 

The Reasoners don’t support cardinality restriction on DataType Property, this limitation is going to be solved in the next version of DIG!? Does anyone know where I can find more information about that?

 

In [1], Alan Rector and Guus Schreiber claim that Racer already support QCR; FaCT++ will shortly do, the document is dated November 2005. The status of the document is: Needs final cleanup and incorporation of responses to reviews by Alistair and Jeff.

 

I created a simple ontology to test if the Non-Endorsed Owl Extension, as presented in [1], which *I think?* is replacing owl:allValuesFrom with owl:valuesFrom, works with Racer and FaCT++.

I quickly created a simple ontology (please see attached: test.owl) with Protégé, using allValueFrom restriction. I used the example of Diner and MinimalDiner, where a MinimalDiner should have only three particular types of courses. Of course, all the reasoners generated an error: MinimalDiner is inconsistent. I added SomethingElse as a subclass of course and a target of has_course, to test if it will generate an error when changing the syntax of allValuesFrom.

 

After, I manually changed allValuesFrom to valuesFrom (please see attached: testqcr.owl). The ontology, now OWL-Full, is loaded without generating any error in Protégé, except that:

1- It is quiet slow when selecting the constrained class and it doesn’t show the code.

2- Protégé replaced the constraints by some weird code : @_:A671 and @_:A680 and @_:A689 and @_:A698

3- When starting the Reasoners (Racer, Pellet and FaCT++), it start processing but never stop, or generate any inconsistency error.

I also tried with RacerPorter to see if the problem was only with Protégé, but it doesn’t want to load the ontology.

 

So, it is obvious that it doesn’t work…

Am I doing something wrong? Is there any other solution?

 

Any help would be much appreciated

 

Thanks

Elyes

 

[1] http://www.w3.org/2001/sw/BestPractices/OEP/QCR/

<testqcr.owl>

<test.owl>

 

Reply | Threaded
Open this post in threaded view
|

Re: QCRs and DIG: Racer, FaCT and Pellet

Elyes Lehtihet-3
In reply to this post by Elyes Lehtihet-3

Hi Uli,

 

I removed rdf:datatype= "http://www.w3.org/2001/XMLSchema#int". But it doesn’t make any difference, Protégé keep adding them when loading the ontology, and the Reasoners do not tell me that happyParent shouldn’t have more than 4 Happy children instance, and stressedParent shouldn’t have less than 4 Silly or Naughty Children…

 

How do I express a restriction to be sure that a Reasoner *will* generate an inconsistency if an instance, or a subclass, of acme_Parent has:

More or less than 4 children *and*

More or less than 2 happy children *and*

More or less than 1 silly *and*

More or less than 1 Tall *and*

>hmmm, I guess you aemn that a reasoner will come back with an  inconsistency in case you make a subclass of YourParent with atmost 1 happy child or at least 3 happy ones, or with at least 2 silly children, or with at least 2 tall children.

>Please note that you can safely generate an instance, say bob, of YourParent without declaring any of its children! 

 

The problem is that I need to define the instances of the children *and* determine if an instance of acme_Parent is valid

 

Lets explain it this way: how do I say that an instance of class_a is valid only if it is strictly linked (via the ObjectProperty) to [X...Y] instance of class_b?

If it is 1..1 it is the FunctionalProperty

If it is 0..n it is the default value

But what about the rest of possible values?

 

Regards

Elyes

 


From: Uli Sattler [mailto:[hidden email]]
Sent: Tuesday, April 11, 2006 12:30 PM
To: Elyes Lehtihet
Subject: Re: [protege-owl] Re: QCRs and DIG: Racer, FaCT and Pellet

 

Hi Elyes,

 

from a quick glance, it looks as you have some syntactic errors here (there shouldn't be rdf:datatype

 

    <owl:minCardinality rdf:datatype="http://www.w3.org/2001/XMLSchema#int"

            >4</owl:minCardinality>

 

and, in contrast to what we were saying in our example, 

 

<owl:Restriction>

            <owl:allValuesFrom>

              <owl:Class>

                <owl:unionOf rdf:parseType="Collection">

                  <owl:Class rdf:ID="Silly"/>

                  <owl:Class rdf:ID="Naughty"/>

                </owl:unionOf>

              </owl:Class>

            </owl:allValuesFrom>

 

says that ALL children are silly, naughty, or both! Cheers, Uli

 

 

 

 

On 11 Apr 2006, at 12:06, Elyes Lehtihet wrote:

 

Hi, again,

 

I created another example of your ontology with Parent and Children. happyParent have between 2 and 4 children that are happy. stresseParent have 4 or more children that are union of Silly and Naughty.

All the Reasoners do not generate any inconsistency error when I attach more than the number of allowed children (has_child) to any class. happyParent should not have 6 Happy children. stressedParent should not have 2 Silly and 1 Naughty….

 

Please see attached file, it might be something wrong with the way I formulate the constraints!?

 

Regards

Elyes

 


From: [hidden email] [[hidden email]] On Behalf Of Uli Sattler
Sent: Tuesday, April 11, 2006 11:00 AM
To: [hidden email]
Subject: [protege-owl] Re: QCRs and DIG: Racer, FaCT and Pellet

 

Hi,

 

what is it that you want to do exactly? I don't understand your "interval of values": assume we have an object property, eg,  hasChild, with Range Human, and Human has (non-disjoint) subclasses Tall, Happy, Naughty, Silly, etc. 

 

Do you want to describe a class by restricted the number of hasChild of a certain kind? This is what we would use qualified number restrictions for: eg, to say that a happyParent has between 2 and 4 children that are instances of Happy, or to say that a StressedParent has atleast 4 children that are instances of the UnionOf (naughty silly)...

 

You don't need datatype properties for this: these are for "concrete" (ie datatype) properties such as age, height, weight, etc., and there one might want to describe Tall as having a height between 190 and 200 (cm), which is completely different from the above QCRs: we would still want to have a single height, and we would like to say that its filler is a non-negative integer between 190 and 200!

 

Cheers, Uli

 

 

On 11 Apr 2006, at 10:39, Elyes Lehtihet wrote:



 

Hello,

 

I need to represent an interval of values for an object property. It is not a problem with [0..n] or [1..1], but how do I correctly represent [x..y] , where y>x and y!=n ???

I know that there is an issue with the Qualified Cardinality Restrictions, but that would be great to use a DIG Reasoner to check the consistency against QCRs, which I suppose are the only solution to my problem.

 

I am using Protégé 3.1.1 with Pellet 1.3 Beta2, Racer 1.9 and FaCT++ 1.1.3

 

The Reasoners don’t support cardinality restriction on DataType Property, this limitation is going to be solved in the next version of DIG!? Does anyone know where I can find more information about that?

 

In [1], Alan Rector and Guus Schreiber claim that Racer already support QCR; FaCT++ will shortly do, the document is dated November 2005. The status of the document is: Needs final cleanup and incorporation of responses to reviews by Alistair and Jeff.

 

I created a simple ontology to test if the Non-Endorsed Owl Extension, as presented in [1], which *I think?* is replacing owl:allValuesFrom with owl:valuesFrom, works with Racer and FaCT++.

I quickly created a simple ontology (please see attached: test.owl) with Protégé, using allValueFrom restriction. I used the example of Diner and MinimalDiner, where a MinimalDiner should have only three particular types of courses. Of course, all the reasoners generated an error: MinimalDiner is inconsistent. I added SomethingElse as a subclass of course and a target of has_course, to test if it will generate an error when changing the syntax of allValuesFrom.

 

After, I manually changed allValuesFrom to valuesFrom (please see attached: testqcr.owl). The ontology, now OWL-Full, is loaded without generating any error in Protégé, except that:

1- It is quiet slow when selecting the constrained class and it doesn’t show the code.

2- Protégé replaced the constraints by some weird code : @_:A671 and @_:A680 and @_:A689 and @_:A698

3- When starting the Reasoners (Racer, Pellet and FaCT++), it start processing but never stop, or generate any inconsistency error.

I also tried with RacerPorter to see if the problem was only with Protégé, but it doesn’t want to load the ontology.

 

So, it is obvious that it doesn’t work…

Am I doing something wrong? Is there any other solution?

 

Any help would be much appreciated

 

Thanks

Elyes

 

[1] http://www.w3.org/2001/sw/BestPractices/OEP/QCR/

<testqcr.owl>

<test.owl>

 

<test-uli.owl>

 

Reply | Threaded
Open this post in threaded view
|

Re: QCRs and DIG: Racer, FaCT and Pellet

Ulrike Sattler

On 11 Apr 2006, at 13:59, Elyes Lehtihet wrote:

Hi Uli,

 

I removed rdf:datatype= "http://www.w3.org/2001/XMLSchema#int". But it doesn’t make any difference, Protégé keep adding them when loading the ontology, and the Reasoners do not tell me that happyParent shouldn’t have more than 4 Happy children instance,


hmmm, do you mean you created an instance of happyParent and gave it, say 5 happy children? In this case, the reasoner SHOULD not complain --- unless you have explicitly declared these 5 children to be all different: that is, the reasoner will simply assume that 2 of them are identical (as long as this does lead to contradiction because they are, additionally, instances of disjoint classes)....

and stressedParent shouldn’t have less than 4 Silly or Naughty Children…

 

How do I express a restriction to be sure that a Reasoner *will* generate an inconsistency if an instance, or a subclass, of acme_Parent has:

More or less than 4 children *and*

More or less than 2 happy children *and*

More or less than 1 silly *and*

More or less than 1 Tall *and*

>hmmm, I guess you aemn that a reasoner will come back with an  inconsistency in case you make a subclass of YourParent with atmost 1 happy child or at least 3 happy ones, or with at least 2 silly children, or with at least 2 tall children.

>Please note that you can safely generate an instance, say bob, of YourParent without declaring any of its children! 

 

The problem is that I need to define the instances of the children *and* determine if an instance of acme_Parent is valid

 

Lets explain it this way: how do I say that an instance of class_a is valid only if it is strictly linked (via the ObjectProperty) to [X...Y] instance of class_b?

If it is 1..1 it is the FunctionalProperty

If it is 0..n it is the default value

But what about the rest of possible values?

 

Regards

Elyes

 


From: Uli Sattler [[hidden email]]
Sent: Tuesday, April 11, 2006 12:30 PM
To: Elyes Lehtihet
Subject: Re: [protege-owl] Re: QCRs and DIG: Racer, FaCT and Pellet

 

Hi Elyes,

 

from a quick glance, it looks as you have some syntactic errors here (there shouldn't be rdf:datatype

 

    <owl:minCardinality rdf:datatype="http://www.w3.org/2001/XMLSchema#int"

            >4</owl:minCardinality>

 

and, in contrast to what we were saying in our example, 

 

<owl:Restriction>

            <owl:allValuesFrom>

              <owl:Class>

                <owl:unionOf rdf:parseType="Collection">

                  <owl:Class rdf:ID="Silly"/>

                  <owl:Class rdf:ID="Naughty"/>

                </owl:unionOf>

              </owl:Class>

            </owl:allValuesFrom>

 

says that ALL children are silly, naughty, or both! Cheers, Uli

 

 

 

 

On 11 Apr 2006, at 12:06, Elyes Lehtihet wrote:

 

Hi, again,

 

I created another example of your ontology with Parent and Children. happyParent have between 2 and 4 children that are happy. stresseParent have 4 or more children that are union of Silly and Naughty.

All the Reasoners do not generate any inconsistency error when I attach more than the number of allowed children (has_child) to any class. happyParent should not have 6 Happy children. stressedParent should not have 2 Silly and 1 Naughty….

 

Please see attached file, it might be something wrong with the way I formulate the constraints!?

 

Regards

Elyes

 


From: [hidden email] [[hidden email]] On Behalf Of Uli Sattler
Sent: Tuesday, April 11, 2006 11:00 AM
To: [hidden email]
Subject: [protege-owl] Re: QCRs and DIG: Racer, FaCT and Pellet

 

Hi,

 

what is it that you want to do exactly? I don't understand your "interval of values": assume we have an object property, eg,  hasChild, with Range Human, and Human has (non-disjoint) subclasses Tall, Happy, Naughty, Silly, etc. 

 

Do you want to describe a class by restricted the number of hasChild of a certain kind? This is what we would use qualified number restrictions for: eg, to say that a happyParent has between 2 and 4 children that are instances of Happy, or to say that a StressedParent has atleast 4 children that are instances of the UnionOf (naughty silly)...

 

You don't need datatype properties for this: these are for "concrete" (ie datatype) properties such as age, height, weight, etc., and there one might want to describe Tall as having a height between 190 and 200 (cm), which is completely different from the above QCRs: we would still want to have a single height, and we would like to say that its filler is a non-negative integer between 190 and 200!

 

Cheers, Uli

 

 

On 11 Apr 2006, at 10:39, Elyes Lehtihet wrote:



 

Hello,

 

I need to represent an interval of values for an object property. It is not a problem with [0..n] or [1..1], but how do I correctly represent [x..y] , where y>x and y!=n ???

I know that there is an issue with the Qualified Cardinality Restrictions, but that would be great to use a DIG Reasoner to check the consistency against QCRs, which I suppose are the only solution to my problem.

 

I am using Protégé 3.1.1 with Pellet 1.3 Beta2, Racer 1.9 and FaCT++ 1.1.3

 

The Reasoners don’t support cardinality restriction on DataType Property, this limitation is going to be solved in the next version of DIG!? Does anyone know where I can find more information about that?

 

In [1], Alan Rector and Guus Schreiber claim that Racer already support QCR; FaCT++ will shortly do, the document is dated November 2005. The status of the document is: Needs final cleanup and incorporation of responses to reviews by Alistair and Jeff.

 

I created a simple ontology to test if the Non-Endorsed Owl Extension, as presented in [1], which *I think?* is replacing owl:allValuesFrom with owl:valuesFrom, works with Racer and FaCT++.<

Reply | Threaded
Open this post in threaded view
|

Re: QCRs and DIG: Racer, FaCT and Pellet

Elyes Lehtihet-3
Hi Uli,

Sorry my fault... I thought that "Individuals" are automatically disjoint,
it is hard to understand why an Individual is by default equivalent to
another.
I created an instance of happyParent and six instances of Happy, where all
the instances of Happy are Different.
However it doesn't solve my problem...

So now happyParent should only accept 2 or 3 or 4 instances of Happy, no
more or less...
1- If I link more than 4 instance of Happy then it generate an error -->Good.
2- If I create an instance of happyParent without creating any instance of
Happy, the Reasoners do not generate an error.
3- If I attach only one instance of Happy, it doesn't generate an error.

Make it more simple and say that the cardinality is stricly equal to 3. An
instance of happyParent must have strictly 3 different instance of Happy.
Please have a look at the attached file, where all the individuals are
already created and constrained (allDifferent). It might be something
wrong with the way I add the Restrictions...

Regards
Elyes

>
> On 11 Apr 2006, at 13:59, Elyes Lehtihet wrote:
>
>> Hi Uli,
>>
>>
>>
>> I removed rdf:datatype= "http://www.w3.org/2001/XMLSchema#int". But
>> it doesn’t make any difference, Protégé keep adding them when
>> loading the ontology, and the Reasoners do not tell me that
>> happyParent shouldn’t have more than 4 Happy children instance,
>
> hmmm, do you mean you created an instance of happyParent and gave it,
> say 5 happy children? In this case, the reasoner SHOULD not complain
> --- unless you have explicitly declared these 5 children to be all
> different: that is, the reasoner will simply assume that 2 of them
> are identical (as long as this does lead to contradiction because
> they are, additionally, instances of disjoint classes)....
>
>> and stressedParent shouldn’t have less than 4 Silly or Naughty
>> Children…
>>
>>
>>
>> How do I express a restriction to be sure that a Reasoner *will*
>> generate an inconsistency if an instance, or a subclass, of
>> acme_Parent has:
>>
>> More or less than 4 children *and*
>>
>> More or less than 2 happy children *and*
>>
>> More or less than 1 silly *and*
>>
>> More or less than 1 Tall *and*
>>
>> >hmmm, I guess you aemn that a reasoner will come back with an
>> inconsistency in case you make a subclass of YourParent with atmost
>> 1 happy child or at least 3 happy ones, or with at least 2 silly
>> children, or with at least 2 tall children.
>>
>> >Please note that you can safely generate an instance, say bob, of
>> YourParent without declaring any of its children!
>>
>>
>>
>> The problem is that I need to define the instances of the children
>> *and* determine if an instance of acme_Parent is valid
>>
>>
>>
>> Lets explain it this way: how do I say that an instance of class_a
>> is valid only if it is strictly linked (via the ObjectProperty) to
>> [X...Y] instance of class_b?
>>
>> If it is 1..1 it is the FunctionalProperty
>>
>> If it is 0..n it is the default value
>>
>> But what about the rest of possible values?
>>
>>
>>
>> Regards
>>
>> Elyes
>>
>>
>>
>> From: Uli Sattler [mailto:[hidden email]]
>> Sent: Tuesday, April 11, 2006 12:30 PM
>> To: Elyes Lehtihet
>> Subject: Re: [protege-owl] Re: QCRs and DIG: Racer, FaCT and Pellet
>>
>>
>>
>> Hi Elyes,
>>
>>
>>
>> from a quick glance, it looks as you have some syntactic errors
>> here (there shouldn't be rdf:datatype
>>
>>
>>
>>     <owl:minCardinality rdf:datatype="http://www.w3.org/2001/
>> XMLSchema#int"
>>
>>             >4</owl:minCardinality>
>>
>>
>>
>> and, in contrast to what we were saying in our example,
>>
>>
>>
>> <owl:Restriction>
>>
>>             <owl:allValuesFrom>
>>
>>               <owl:Class>
>>
>>                 <owl:unionOf rdf:parseType="Collection">
>>
>>                   <owl:Class rdf:ID="Silly"/>
>>
>>                   <owl:Class rdf:ID="Naughty"/>
>>
>>                 </owl:unionOf>
>>
>>               </owl:Class>
>>
>>             </owl:allValuesFrom>
>>
>>
>>
>> says that ALL children are silly, naughty, or both! Cheers, Uli
>>
>>
>>
>>
>>
>>
>>
>>
>>
>> On 11 Apr 2006, at 12:06, Elyes Lehtihet wrote:
>>
>>
>>
>> Hi, again,
>>
>>
>>
>> I created another example of your ontology with Parent and
>> Children. happyParent have between 2 and 4 children that are happy.
>> stresseParent have 4 or more children that are union of Silly and
>> Naughty.
>>
>> All the Reasoners do not generate any inconsistency error when I
>> attach more than the number of allowed children (has_child) to any
>> class. happyParent should not have 6 Happy children. stressedParent
>> should not have 2 Silly and 1 Naughty….
>>
>>
>>
>> Please see attached file, it might be something wrong with the way
>> I formulate the constraints!?
>>
>>
>>
>> Regards
>>
>> Elyes
>>
>>
>>
>> From: [hidden email] [mailto:protege-owl-
>> [hidden email]] On Behalf Of Uli Sattler
>> Sent: Tuesday, April 11, 2006 11:00 AM
>> To: [hidden email]
>> Subject: [protege-owl] Re: QCRs and DIG: Racer, FaCT and Pellet
>>
>>
>>
>> Hi,
>>
>>
>>
>> what is it that you want to do exactly? I don't understand your
>> "interval of values": assume we have an object property, eg,
>> hasChild, with Range Human, and Human has (non-disjoint) subclasses
>> Tall, Happy, Naughty, Silly, etc.
>>
>>
>>
>> Do you want to describe a class by restricted the number of
>> hasChild of a certain kind? This is what we would use qualified
>> number restrictions for: eg, to say that a happyParent has between
>> 2 and 4 children that are instances of Happy, or to say that a
>> StressedParent has atleast 4 children that are instances of the
>> UnionOf (naughty silly)...
>>
>>
>>
>> You don't need datatype properties for this: these are for
>> "concrete" (ie datatype) properties such as age, height, weight,
>> etc., and there one might want to describe Tall as having a height
>> between 190 and 200 (cm), which is completely different from the
>> above QCRs: we would still want to have a single height, and we
>> would like to say that its filler is a non-negative integer between
>> 190 and 200!
>>
>>
>>
>> Cheers, Uli
>>
>>
>>
>>
>>
>> On 11 Apr 2006, at 10:39, Elyes Lehtihet wrote:
>>
>>
>>
>>
>>
>>
>> Hello,
>>
>>
>>
>> I need to represent an interval of values for an object property.
>> It is not a problem with [0..n] or [1..1], but how do I correctly
>> represent [x..y] , where y>x and y!=n ???
>>
>> I know that there is an issue with the Qualified Cardinality
>> Restrictions, but that would be great to use a DIG Reasoner to
>> check the consistency against QCRs, which I suppose are the only
>> solution to my problem.
>>
>>
>>
>> I am using Protégé 3.1.1 with Pellet 1.3 Beta2, Racer 1.9 and FaCT+
>> + 1.1.3
>>
>>
>>
>> The Reasoners don’t support cardinality restriction on DataType
>> Property, this limitation is going to be solved in the next version
>> of DIG!? Does anyone know where I can find more information about
>> that?
>>
>>
>>
>> In [1], Alan Rector and Guus Schreiber claim that Racer already
>> support QCR; FaCT++ will shortly do, the document is dated November
>> 2005. The status of the document is: Needs final cleanup and
>> incorporation of responses to reviews by Alistair and Jeff.
>>
>>
>>
>> I created a simple ontology to test if the Non-Endorsed Owl
>> Extension, as presented in [1], which *I think?* is replacing
>> owl:allValuesFrom with owl:valuesFrom, works with Racer and FaCT++.
>>
>> I quickly created a simple ontology (please see attached: test.owl)
>> with Protégé, using allValueFrom restriction. I used the example of
>> Diner and MinimalDiner, where a MinimalDiner should have only three
>> particular types of courses. Of course, all the reasoners generated
>> an error: MinimalDiner is inconsistent. I added SomethingElse as a
>> subclass of course and a target of has_course, to test if it will
>> generate an error when changing the syntax of allValuesFrom.
>>
>>
>>
>> After, I manually changed allValuesFrom to valuesFrom (please see
>> attached: testqcr.owl). The ontology, now OWL-Full, is loaded
>> without generating any error in Protégé, except that:
>>
>> 1- It is quiet slow when selecting the constrained class and it
>> doesn’t show the code.
>>
>> 2- Protégé replaced the constraints by some weird code : @_:A671
>> and @_:A680 and @_:A689 and @_:A698
>>
>> 3- When starting the Reasoners (Racer, Pellet and FaCT++), it start
>> processing but never stop, or generate any inconsistency error.
>>
>> I also tried with RacerPorter to see if the problem was only with
>> Protégé, but it doesn’t want to load the ontology.
>>
>>
>>
>> So, it is obvious that it doesn’t work…
>>
>> Am I doing something wrong? Is there any other solution?
>>
>>
>>
>> Any help would be much appreciated
>>
>>
>>
>> Thanks
>>
>> Elyes
>>
>>
>>
>> [1] http://www.w3.org/2001/sw/BestPractices/OEP/QCR/
>>
>> <testqcr.owl>
>>
>> <test.owl>
>>
>>
>>
>> <test-uli.owl>
>>
>>
>>
>>
>
>

test-alldifferent.owl (7K) Download Attachment
Reply | Threaded
Open this post in threaded view
|

Re: QCRs and DIG: Racer, FaCT and Pellet

Ulrike Sattler
On 11 Apr 2006, at 21:02, Elyes Lehtihet wrote:

> Hi Uli,
>
> Sorry my fault... I thought that "Individuals" are automatically  
> disjoint,
> it is hard to understand why an Individual is by default equivalent to
> another.

sorry, but these individuals aren't "by default equivalent to  
another": they are by default not necessarily distinct. That is, we  
do not (by default) employ the unique name assumption (UNA).

> I created an instance of happyParent and six instances of Happy,  
> where all
> the instances of Happy are Different.
> However it doesn't solve my problem...
>
> So now happyParent should only accept 2 or 3 or 4

[children that are]

> instances of Happy, no
> more or less...
> 1- If I link more than 4 instance of Happy then it generate an  
> error -->Good.
> 2- If I create an instance of happyParent without creating any  
> instance of
> Happy, the Reasoners do not generate an error.

Good: since (beside the UNA), the reasoner also employs the "open  
world assumption": what you told the reasoner is true, but it is NOT  
necessarily the case that you have told him everything. That is,  
there can be other children besides those that you told the reasoner  
about.

> 3- If I attach only one instance of Happy, it doesn't generate an  
> error.

the same

Perhaps a look at the pizza tutorial would have helped? Cheers, Uli

>
> Make it more simple and say that the cardinality is stricly equal  
> to 3. An
> instance of happyParent must have strictly 3 different instance of  
> Happy.
> Please have a look at the attached file, where all the individuals are
> already created and constrained (allDifferent). It might be something
> wrong with the way I add the Restrictions...
>
> Regards
> Elyes
>
>>
>> On 11 Apr 2006, at 13:59, Elyes Lehtihet wrote:
>>
>>> Hi Uli,
>>>
>>>
>>>
>>> I removed rdf:datatype= "http://www.w3.org/2001/XMLSchema#int". But
>>> it doesn’t make any difference, Protégé keep adding them when
>>> loading the ontology, and the Reasoners do not tell me that
>>> happyParent shouldn’t have more than 4 Happy children instance,
>>
>> hmmm, do you mean you created an instance of happyParent and gave it,
>> say 5 happy children? In this case, the reasoner SHOULD not complain
>> --- unless you have explicitly declared these 5 children to be all
>> different: that is, the reasoner will simply assume that 2 of them
>> are identical (as long as this does lead to contradiction because
>> they are, additionally, instances of disjoint classes)....
>>
>>> and stressedParent shouldn’t have less than 4 Silly or Naughty
>>> Children…
>>>
>>>
>>>
>>> How do I express a restriction to be sure that a Reasoner *will*
>>> generate an inconsistency if an instance, or a subclass, of
>>> acme_Parent has:
>>>
>>> More or less than 4 children *and*
>>>
>>> More or less than 2 happy children *and*
>>>
>>> More or less than 1 silly *and*
>>>
>>> More or less than 1 Tall *and*
>>>
>>>> hmmm, I guess you aemn that a reasoner will come back with an
>>> inconsistency in case you make a subclass of YourParent with atmost
>>> 1 happy child or at least 3 happy ones, or with at least 2 silly
>>> children, or with at least 2 tall children.
>>>
>>>> Please note that you can safely generate an instance, say bob, of
>>> YourParent without declaring any of its children!
>>>
>>>
>>>
>>> The problem is that I need to define the instances of the children
>>> *and* determine if an instance of acme_Parent is valid
>>>
>>>
>>>
>>> Lets explain it this way: how do I say that an instance of class_a
>>> is valid only if it is strictly linked (via the ObjectProperty) to
>>> [X...Y] instance of class_b?
>>>
>>> If it is 1..1 it is the FunctionalProperty
>>>
>>> If it is 0..n it is the default value
>>>
>>> But what about the rest of possible values?
>>>
>>>
>>>
>>> Regards
>>>
>>> Elyes
>>>
>>>
>>>
>>> From: Uli Sattler [mailto:[hidden email]]
>>> Sent: Tuesday, April 11, 2006 12:30 PM
>>> To: Elyes Lehtihet
>>> Subject: Re: [protege-owl] Re: QCRs and DIG: Racer, FaCT and Pellet
>>>
>>>
>>>
>>> Hi Elyes,
>>>
>>>
>>>
>>> from a quick glance, it looks as you have some syntactic errors
>>> here (there shouldn't be rdf:datatype
>>>
>>>
>>>
>>>     <owl:minCardinality rdf:datatype="http://www.w3.org/2001/
>>> XMLSchema#int"
>>>
>>>> 4</owl:minCardinality>
>>>
>>>
>>>
>>> and, in contrast to what we were saying in our example,
>>>
>>>
>>>
>>> <owl:Restriction>
>>>
>>>             <owl:allValuesFrom>
>>>
>>>               <owl:Class>
>>>
>>>                 <owl:unionOf rdf:parseType="Collection">
>>>
>>>                   <owl:Class rdf:ID="Silly"/>
>>>
>>>                   <owl:Class rdf:ID="Naughty"/>
>>>
>>>                 </owl:unionOf>
>>>
>>>               </owl:Class>
>>>
>>>             </owl:allValuesFrom>
>>>
>>>
>>>
>>> says that ALL children are silly, naughty, or both! Cheers, Uli
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>> On 11 Apr 2006, at 12:06, Elyes Lehtihet wrote:
>>>
>>>
>>>
>>> Hi, again,
>>>
>>>
>>>
>>> I created another example of your ontology with Parent and
>>> Children. happyParent have between 2 and 4 children that are happy.
>>> stresseParent have 4 or more children that are union of Silly and
>>> Naughty.
>>>
>>> All the Reasoners do not generate any inconsistency error when I
>>> attach more than the number of allowed children (has_child) to any
>>> class. happyParent should not have 6 Happy children. stressedParent
>>> should not have 2 Silly and 1 Naughty….
>>>
>>>
>>>
>>> Please see attached file, it might be something wrong with the way
>>> I formulate the constraints!?
>>>
>>>
>>>
>>> Regards
>>>
>>> Elyes
>>>
>>>
>>>
>>> From: [hidden email] [mailto:protege-owl-
>>> [hidden email]] On Behalf Of Uli Sattler
>>> Sent: Tuesday, April 11, 2006 11:00 AM
>>> To: [hidden email]
>>> Subject: [protege-owl] Re: QCRs and DIG: Racer, FaCT and Pellet
>>>
>>>
>>>
>>> Hi,
>>>
>>>
>>>
>>> what is it that you want to do exactly? I don't understand your
>>> "interval of values": assume we have an object property, eg,
>>> hasChild, with Range Human, and Human has (non-disjoint) subclasses
>>> Tall, Happy, Naughty, Silly, etc.
>>>
>>>
>>>
>>> Do you want to describe a class by restricted the number of
>>> hasChild of a certain kind? This is what we would use qualified
>>> number restrictions for: eg, to say that a happyParent has between
>>> 2 and 4 children that are instances of Happy, or to say that a
>>> StressedParent has atleast 4 children that are instances of the
>>> UnionOf (naughty silly)...
>>>
>>>
>>>
>>> You don't need datatype properties for this: these are for
>>> "concrete" (ie datatype) properties such as age, height, weight,
>>> etc., and there one might want to describe Tall as having a height
>>> between 190 and 200 (cm), which is completely different from the
>>> above QCRs: we would still want to have a single height, and we
>>> would like to say that its filler is a non-negative integer between
>>> 190 and 200!
>>>
>>>
>>>
>>> Cheers, Uli
>>>
>>>
>>>
>>>
>>>
>>> On 11 Apr 2006, at 10:39, Elyes Lehtihet wrote:
>>>
>>>
>>>
>>>
>>>
>>>
>>> Hello,
>>>
>>>
>>>
>>> I need to represent an interval of values for an object property.
>>> It is not a problem with [0..n] or [1..1], but how do I correctly
>>> represent [x..y] , where y>x and y!=n ???
>>>
>>> I know that there is an issue with the Qualified Cardinality
>>> Restrictions, but that would be great to use a DIG Reasoner to
>>> check the consistency against QCRs, which I suppose are the only
>>> solution to my problem.
>>>
>>>
>>>
>>> I am using Protégé 3.1.1 with Pellet 1.3 Beta2, Racer 1.9 and FaCT+
>>> + 1.1.3
>>>
>>>
>>>
>>> The Reasoners don’t support cardinality restriction on DataType
>>> Property, this limitation is going to be solved in the next version
>>> of DIG!? Does anyone know where I can find more information about
>>> that?
>>>
>>>
>>>
>>> In [1], Alan Rector and Guus Schreiber claim that Racer already
>>> support QCR; FaCT++ will shortly do, the document is dated November
>>> 2005. The status of the document is: Needs final cleanup and
>>> incorporation of responses to reviews by Alistair and Jeff.
>>>
>>>
>>>
>>> I created a simple ontology to test if the Non-Endorsed Owl
>>> Extension, as presented in [1], which *I think?* is replacing
>>> owl:allValuesFrom with owl:valuesFrom, works with Racer and FaCT++.
>>>
>>> I quickly created a simple ontology (please see attached: test.owl)
>>> with Protégé, using allValueFrom restriction. I used the example of
>>> Diner and MinimalDiner, where a MinimalDiner should have only three
>>> particular types of courses. Of course, all the reasoners generated
>>> an error: MinimalDiner is inconsistent. I added SomethingElse as a
>>> subclass of course and a target of has_course, to test if it will
>>> generate an error when changing the syntax of allValuesFrom.
>>>
>>>
>>>
>>> After, I manually changed allValuesFrom to valuesFrom (please see
>>> attached: testqcr.owl). The ontology, now OWL-Full, is loaded
>>> without generating any error in Protégé, except that:
>>>
>>> 1- It is quiet slow when selecting the constrained class and it
>>> doesn’t show the code.
>>>
>>> 2- Protégé replaced the constraints by some weird code : @_:A671
>>> and @_:A680 and @_:A689 and @_:A698
>>>
>>> 3- When starting the Reasoners (Racer, Pellet and FaCT++), it start
>>> processing but never stop, or generate any inconsistency error.
>>>
>>> I also tried with RacerPorter to see if the problem was only with
>>> Protégé, but it doesn’t want to load the ontology.
>>>
>>>
>>>
>>> So, it is obvious that it doesn’t work…
>>>
>>> Am I doing something wrong? Is there any other solution?
>>>
>>>
>>>
>>> Any help would be much appreciated
>>>
>>>
>>>
>>> Thanks
>>>
>>> Elyes
>>>
>>>
>>>
>>> [1] http://www.w3.org/2001/sw/BestPractices/OEP/QCR/
>>>
>>> <testqcr.owl>
>>>
>>> <test.owl>
>>>
>>>
>>>
>>> <test-uli.owl>
>>>
>>>
>>>
>>>
>>
>>
>> <test-alldifferent.owl>

-------------------------------------------------------------------------
To unsubscribe go to http://protege.stanford.edu/community/subscribe.html

Reply | Threaded
Open this post in threaded view
|

AW: Re: QCRs and DIG: Racer, FaCT and Pellet

Rajverma
In reply to this post by Elyes Lehtihet-3
Hi Uli,

So how wud I axiomatize if I want the reasoner to raise an error if my individual is not fulfilling the minimum cardinality restriction that I have on my concept?

Following this example, if the individual HappyParent has more than 4 (happy)children then the reasoner tells me that it is not possible according to the restriction that there should be atmost 4 (happy) children associated to a HappyParent. OK. On the other hand if I want to make sure that if at all there is an individual HappyParent then it should also be the case that there should be atleast 2 individual (happy)children for this HappyParent, then how to describe it? Something like, I want to describe that there are no other individual (happy)children except the ones specified, so Mr.Reasoner let me know if my individual HappyParent doesn't fulfil the restriction of atleast 2 (happy)children!

Is this something like asking for closed-world-assumption answers with an open-world-reasoning tools? If yes, does SWRL help in this case?

Cheers,
Raj





-----Ursprüngliche Nachricht-----
Von: [hidden email] [mailto:[hidden email]] Im Auftrag von Uli Sattler
Gesendet: Mittwoch, 12. April 2006 10:42
An: [hidden email]
Betreff: [protege-owl] Re: QCRs and DIG: Racer, FaCT and Pellet

On 11 Apr 2006, at 21:02, Elyes Lehtihet wrote:

> Hi Uli,
>
> Sorry my fault... I thought that "Individuals" are automatically  
> disjoint,
> it is hard to understand why an Individual is by default equivalent to
> another.

sorry, but these individuals aren't "by default equivalent to  
another": they are by default not necessarily distinct. That is, we  
do not (by default) employ the unique name assumption (UNA).

> I created an instance of happyParent and six instances of Happy,  
> where all
> the instances of Happy are Different.
> However it doesn't solve my problem...
>
> So now happyParent should only accept 2 or 3 or 4

[children that are]

> instances of Happy, no
> more or less...
> 1- If I link more than 4 instance of Happy then it generate an  
> error -->Good.
> 2- If I create an instance of happyParent without creating any  
> instance of
> Happy, the Reasoners do not generate an error.

Good: since (beside the UNA), the reasoner also employs the "open  
world assumption": what you told the reasoner is true, but it is NOT  
necessarily the case that you have told him everything. That is,  
there can be other children besides those that you told the reasoner  
about.

> 3- If I attach only one instance of Happy, it doesn't generate an  
> error.

the same

Perhaps a look at the pizza tutorial would have helped? Cheers, Uli

>
> Make it more simple and say that the cardinality is stricly equal  
> to 3. An
> instance of happyParent must have strictly 3 different instance of  
> Happy.
> Please have a look at the attached file, where all the individuals are
> already created and constrained (allDifferent). It might be something
> wrong with the way I add the Restrictions...
>
> Regards
> Elyes
>
>>
>> On 11 Apr 2006, at 13:59, Elyes Lehtihet wrote:
>>
>>> Hi Uli,
>>>
>>>
>>>
>>> I removed rdf:datatype= "http://www.w3.org/2001/XMLSchema#int". But
>>> it doesn't make any difference, Protégé keep adding them when
>>> loading the ontology, and the Reasoners do not tell me that
>>> happyParent shouldn't have more than 4 Happy children instance,
>>
>> hmmm, do you mean you created an instance of happyParent and gave it,
>> say 5 happy children? In this case, the reasoner SHOULD not complain
>> --- unless you have explicitly declared these 5 children to be all
>> different: that is, the reasoner will simply assume that 2 of them
>> are identical (as long as this does lead to contradiction because
>> they are, additionally, instances of disjoint classes)....
>>
>>> and stressedParent shouldn't have less than 4 Silly or Naughty
>>> Children...
>>>
>>>
>>>
>>> How do I express a restriction to be sure that a Reasoner *will*
>>> generate an inconsistency if an instance, or a subclass, of
>>> acme_Parent has:
>>>
>>> More or less than 4 children *and*
>>>
>>> More or less than 2 happy children *and*
>>>
>>> More or less than 1 silly *and*
>>>
>>> More or less than 1 Tall *and*
>>>
>>>> hmmm, I guess you aemn that a reasoner will come back with an
>>> inconsistency in case you make a subclass of YourParent with atmost
>>> 1 happy child or at least 3 happy ones, or with at least 2 silly
>>> children, or with at least 2 tall children.
>>>
>>>> Please note that you can safely generate an instance, say bob, of
>>> YourParent without declaring any of its children!
>>>
>>>
>>>
>>> The problem is that I need to define the instances of the children
>>> *and* determine if an instance of acme_Parent is valid
>>>
>>>
>>>
>>> Lets explain it this way: how do I say that an instance of class_a
>>> is valid only if it is strictly linked (via the ObjectProperty) to
>>> [X...Y] instance of class_b?
>>>
>>> If it is 1..1 it is the FunctionalProperty
>>>
>>> If it is 0..n it is the default value
>>>
>>> But what about the rest of possible values?
>>>
>>>
>>>
>>> Regards
>>>
>>> Elyes
>>>
>>>
>>>
>>> From: Uli Sattler [mailto:[hidden email]]
>>> Sent: Tuesday, April 11, 2006 12:30 PM
>>> To: Elyes Lehtihet
>>> Subject: Re: [protege-owl] Re: QCRs and DIG: Racer, FaCT and Pellet
>>>
>>>
>>>
>>> Hi Elyes,
>>>
>>>
>>>
>>> from a quick glance, it looks as you have some syntactic errors
>>> here (there shouldn't be rdf:datatype
>>>
>>>
>>>
>>>     <owl:minCardinality rdf:datatype="http://www.w3.org/2001/
>>> XMLSchema#int"
>>>
>>>> 4</owl:minCardinality>
>>>
>>>
>>>
>>> and, in contrast to what we were saying in our example,
>>>
>>>
>>>
>>> <owl:Restriction>
>>>
>>>             <owl:allValuesFrom>
>>>
>>>               <owl:Class>
>>>
>>>                 <owl:unionOf rdf:parseType="Collection">
>>>
>>>                   <owl:Class rdf:ID="Silly"/>
>>>
>>>                   <owl:Class rdf:ID="Naughty"/>
>>>
>>>                 </owl:unionOf>
>>>
>>>               </owl:Class>
>>>
>>>             </owl:allValuesFrom>
>>>
>>>
>>>
>>> says that ALL children are silly, naughty, or both! Cheers, Uli
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>> On 11 Apr 2006, at 12:06, Elyes Lehtihet wrote:
>>>
>>>
>>>
>>> Hi, again,
>>>
>>>
>>>
>>> I created another example of your ontology with Parent and
>>> Children. happyParent have between 2 and 4 children that are happy.
>>> stresseParent have 4 or more children that are union of Silly and
>>> Naughty.
>>>
>>> All the Reasoners do not generate any inconsistency error when I
>>> attach more than the number of allowed children (has_child) to any
>>> class. happyParent should not have 6 Happy children. stressedParent
>>> should not have 2 Silly and 1 Naughty....
>>>
>>>
>>>
>>> Please see attached file, it might be something wrong with the way
>>> I formulate the constraints!?
>>>
>>>
>>>
>>> Regards
>>>
>>> Elyes
>>>
>>>
>>>
>>> From: [hidden email] [mailto:protege-owl-
>>> [hidden email]] On Behalf Of Uli Sattler
>>> Sent: Tuesday, April 11, 2006 11:00 AM
>>> To: [hidden email]
>>> Subject: [protege-owl] Re: QCRs and DIG: Racer, FaCT and Pellet
>>>
>>>
>>>
>>> Hi,
>>>
>>>
>>>
>>> what is it that you want to do exactly? I don't understand your
>>> "interval of values": assume we have an object property, eg,
>>> hasChild, with Range Human, and Human has (non-disjoint) subclasses
>>> Tall, Happy, Naughty, Silly, etc.
>>>
>>>
>>>
>>> Do you want to describe a class by restricted the number of
>>> hasChild of a certain kind? This is what we would use qualified
>>> number restrictions for: eg, to say that a happyParent has between
>>> 2 and 4 children that are instances of Happy, or to say that a
>>> StressedParent has atleast 4 children that are instances of the
>>> UnionOf (naughty silly)...
>>>
>>>
>>>
>>> You don't need datatype properties for this: these are for
>>> "concrete" (ie datatype) properties such as age, height, weight,
>>> etc., and there one might want to describe Tall as having a height
>>> between 190 and 200 (cm), which is completely different from the
>>> above QCRs: we would still want to have a single height, and we
>>> would like to say that its filler is a non-negative integer between
>>> 190 and 200!
>>>
>>>
>>>
>>> Cheers, Uli
>>>
>>>
>>>
>>>
>>>
>>> On 11 Apr 2006, at 10:39, Elyes Lehtihet wrote:
>>>
>>>
>>>
>>>
>>>
>>>
>>> Hello,
>>>
>>>
>>>
>>> I need to represent an interval of values for an object property.
>>> It is not a problem with [0..n] or [1..1], but how do I correctly
>>> represent [x..y] , where y>x and y!=n ???
>>>
>>> I know that there is an issue with the Qualified Cardinality
>>> Restrictions, but that would be great to use a DIG Reasoner to
>>> check the consistency against QCRs, which I suppose are the only
>>> solution to my problem.
>>>
>>>
>>>
>>> I am using Protégé 3.1.1 with Pellet 1.3 Beta2, Racer 1.9 and FaCT+
>>> + 1.1.3
>>>
>>>
>>>
>>> The Reasoners don't support cardinality restriction on DataType
>>> Property, this limitation is going to be solved in the next version
>>> of DIG!? Does anyone know where I can find more information about
>>> that?
>>>
>>>
>>>
>>> In [1], Alan Rector and Guus Schreiber claim that Racer already
>>> support QCR; FaCT++ will shortly do, the document is dated November
>>> 2005. The status of the document is: Needs final cleanup and
>>> incorporation of responses to reviews by Alistair and Jeff.
>>>
>>>
>>>
>>> I created a simple ontology to test if the Non-Endorsed Owl
>>> Extension, as presented in [1], which *I think?* is replacing
>>> owl:allValuesFrom with owl:valuesFrom, works with Racer and FaCT++.
>>>
>>> I quickly created a simple ontology (please see attached: test.owl)
>>> with Protégé, using allValueFrom restriction. I used the example of
>>> Diner and MinimalDiner, where a MinimalDiner should have only three
>>> particular types of courses. Of course, all the reasoners generated
>>> an error: MinimalDiner is inconsistent. I added SomethingElse as a
>>> subclass of course and a target of has_course, to test if it will
>>> generate an error when changing the syntax of allValuesFrom.
>>>
>>>
>>>
>>> After, I manually changed allValuesFrom to valuesFrom (please see
>>> attached: testqcr.owl). The ontology, now OWL-Full, is loaded
>>> without generating any error in Protégé, except that:
>>>
>>> 1- It is quiet slow when selecting the constrained class and it
>>> doesn't show the code.
>>>
>>> 2- Protégé replaced the constraints by some weird code : @_:A671
>>> and @_:A680 and @_:A689 and @_:A698
>>>
>>> 3- When starting the Reasoners (Racer, Pellet and FaCT++), it start
>>> processing but never stop, or generate any inconsistency error.
>>>
>>> I also tried with RacerPorter to see if the problem was only with
>>> Protégé, but it doesn't want to load the ontology.
>>>
>>>
>>>
>>> So, it is obvious that it doesn't work...
>>>
>>> Am I doing something wrong? Is there any other solution?
>>>
>>>
>>>
>>> Any help would be much appreciated
>>>
>>>
>>>
>>> Thanks
>>>
>>> Elyes
>>>
>>>
>>>
>>> [1] http://www.w3.org/2001/sw/BestPractices/OEP/QCR/
>>>

-------------------------------------------------------------------------
To unsubscribe go to http://protege.stanford.edu/community/subscribe.html

Reply | Threaded
Open this post in threaded view
|

Re: AW: Re: QCRs and DIG: Racer, FaCT and Pellet

Elyes Lehtihet-3
I'll be interested to hear the answer to that...

Regards,
Elyes

-----Original Message-----
From: [hidden email]
[mailto:[hidden email]] On Behalf Of Mudunuri, Raj
Sent: Wednesday, April 12, 2006 3:47 PM
To: [hidden email]
Subject: [protege-owl] AW: Re: QCRs and DIG: Racer, FaCT and Pellet

Hi Uli,

So how wud I axiomatize if I want the reasoner to raise an error if my
individual is not fulfilling the minimum cardinality restriction that I have
on my concept?

Following this example, if the individual HappyParent has more than 4
(happy)children then the reasoner tells me that it is not possible according
to the restriction that there should be atmost 4 (happy) children associated
to a HappyParent. OK. On the other hand if I want to make sure that if at
all there is an individual HappyParent then it should also be the case that
there should be atleast 2 individual (happy)children for this HappyParent,
then how to describe it? Something like, I want to describe that there are
no other individual (happy)children except the ones specified, so
Mr.Reasoner let me know if my individual HappyParent doesn't fulfil the
restriction of atleast 2 (happy)children!

Is this something like asking for closed-world-assumption answers with an
open-world-reasoning tools? If yes, does SWRL help in this case?

Cheers,
Raj





-----Ursprüngliche Nachricht-----
Von: [hidden email]
[mailto:[hidden email]] Im Auftrag von Uli Sattler
Gesendet: Mittwoch, 12. April 2006 10:42
An: [hidden email]
Betreff: [protege-owl] Re: QCRs and DIG: Racer, FaCT and Pellet

On 11 Apr 2006, at 21:02, Elyes Lehtihet wrote:

> Hi Uli,
>
> Sorry my fault... I thought that "Individuals" are automatically  
> disjoint,
> it is hard to understand why an Individual is by default equivalent to
> another.

sorry, but these individuals aren't "by default equivalent to  
another": they are by default not necessarily distinct. That is, we  
do not (by default) employ the unique name assumption (UNA).

> I created an instance of happyParent and six instances of Happy,  
> where all
> the instances of Happy are Different.
> However it doesn't solve my problem...
>
> So now happyParent should only accept 2 or 3 or 4

[children that are]

> instances of Happy, no
> more or less...
> 1- If I link more than 4 instance of Happy then it generate an  
> error -->Good.
> 2- If I create an instance of happyParent without creating any  
> instance of
> Happy, the Reasoners do not generate an error.

Good: since (beside the UNA), the reasoner also employs the "open  
world assumption": what you told the reasoner is true, but it is NOT  
necessarily the case that you have told him everything. That is,  
there can be other children besides those that you told the reasoner  
about.

> 3- If I attach only one instance of Happy, it doesn't generate an  
> error.

the same

Perhaps a look at the pizza tutorial would have helped? Cheers, Uli

>
> Make it more simple and say that the cardinality is stricly equal  
> to 3. An
> instance of happyParent must have strictly 3 different instance of  
> Happy.
> Please have a look at the attached file, where all the individuals are
> already created and constrained (allDifferent). It might be something
> wrong with the way I add the Restrictions...
>
> Regards
> Elyes
>
>>
>> On 11 Apr 2006, at 13:59, Elyes Lehtihet wrote:
>>
>>> Hi Uli,
>>>
>>>
>>>
>>> I removed rdf:datatype= "http://www.w3.org/2001/XMLSchema#int". But
>>> it doesn't make any difference, Protégé keep adding them when
>>> loading the ontology, and the Reasoners do not tell me that
>>> happyParent shouldn't have more than 4 Happy children instance,
>>
>> hmmm, do you mean you created an instance of happyParent and gave it,
>> say 5 happy children? In this case, the reasoner SHOULD not complain
>> --- unless you have explicitly declared these 5 children to be all
>> different: that is, the reasoner will simply assume that 2 of them
>> are identical (as long as this does lead to contradiction because
>> they are, additionally, instances of disjoint classes)....
>>
>>> and stressedParent shouldn't have less than 4 Silly or Naughty
>>> Children...
>>>
>>>
>>>
>>> How do I express a restriction to be sure that a Reasoner *will*
>>> generate an inconsistency if an instance, or a subclass, of
>>> acme_Parent has:
>>>
>>> More or less than 4 children *and*
>>>
>>> More or less than 2 happy children *and*
>>>
>>> More or less than 1 silly *and*
>>>
>>> More or less than 1 Tall *and*
>>>
>>>> hmmm, I guess you aemn that a reasoner will come back with an
>>> inconsistency in case you make a subclass of YourParent with atmost
>>> 1 happy child or at least 3 happy ones, or with at least 2 silly
>>> children, or with at least 2 tall children.
>>>
>>>> Please note that you can safely generate an instance, say bob, of
>>> YourParent without declaring any of its children!
>>>
>>>
>>>
>>> The problem is that I need to define the instances of the children
>>> *and* determine if an instance of acme_Parent is valid
>>>
>>>
>>>
>>> Lets explain it this way: how do I say that an instance of class_a
>>> is valid only if it is strictly linked (via the ObjectProperty) to
>>> [X...Y] instance of class_b?
>>>
>>> If it is 1..1 it is the FunctionalProperty
>>>
>>> If it is 0..n it is the default value
>>>
>>> But what about the rest of possible values?
>>>
>>>
>>>
>>> Regards
>>>
>>> Elyes
>>>
>>>
>>>
>>> From: Uli Sattler [mailto:[hidden email]]
>>> Sent: Tuesday, April 11, 2006 12:30 PM
>>> To: Elyes Lehtihet
>>> Subject: Re: [protege-owl] Re: QCRs and DIG: Racer, FaCT and Pellet
>>>
>>>
>>>
>>> Hi Elyes,
>>>
>>>
>>>
>>> from a quick glance, it looks as you have some syntactic errors
>>> here (there shouldn't be rdf:datatype
>>>
>>>
>>>
>>>     <owl:minCardinality rdf:datatype="http://www.w3.org/2001/
>>> XMLSchema#int"
>>>
>>>> 4</owl:minCardinality>
>>>
>>>
>>>
>>> and, in contrast to what we were saying in our example,
>>>
>>>
>>>
>>> <owl:Restriction>
>>>
>>>             <owl:allValuesFrom>
>>>
>>>               <owl:Class>
>>>
>>>                 <owl:unionOf rdf:parseType="Collection">
>>>
>>>                   <owl:Class rdf:ID="Silly"/>
>>>
>>>                   <owl:Class rdf:ID="Naughty"/>
>>>
>>>                 </owl:unionOf>
>>>
>>>               </owl:Class>
>>>
>>>             </owl:allValuesFrom>
>>>
>>>
>>>
>>> says that ALL children are silly, naughty, or both! Cheers, Uli
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>> On 11 Apr 2006, at 12:06, Elyes Lehtihet wrote:
>>>
>>>
>>>
>>> Hi, again,
>>>
>>>
>>>
>>> I created another example of your ontology with Parent and
>>> Children. happyParent have between 2 and 4 children that are happy.
>>> stresseParent have 4 or more children that are union of Silly and
>>> Naughty.
>>>
>>> All the Reasoners do not generate any inconsistency error when I
>>> attach more than the number of allowed children (has_child) to any
>>> class. happyParent should not have 6 Happy children. stressedParent
>>> should not have 2 Silly and 1 Naughty....
>>>
>>>
>>>
>>> Please see attached file, it might be something wrong with the way
>>> I formulate the constraints!?
>>>
>>>
>>>
>>> Regards
>>>
>>> Elyes
>>>
>>>
>>>
>>> From: [hidden email] [mailto:protege-owl-
>>> [hidden email]] On Behalf Of Uli Sattler
>>> Sent: Tuesday, April 11, 2006 11:00 AM
>>> To: [hidden email]
>>> Subject: [protege-owl] Re: QCRs and DIG: Racer, FaCT and Pellet
>>>
>>>
>>>
>>> Hi,
>>>
>>>
>>>
>>> what is it that you want to do exactly? I don't understand your
>>> "interval of values": assume we have an object property, eg,
>>> hasChild, with Range Human, and Human has (non-disjoint) subclasses
>>> Tall, Happy, Naughty, Silly, etc.
>>>
>>>
>>>
>>> Do you want to describe a class by restricted the number of
>>> hasChild of a certain kind? This is what we would use qualified
>>> number restrictions for: eg, to say that a happyParent has between
>>> 2 and 4 children that are instances of Happy, or to say that a
>>> StressedParent has atleast 4 children that are instances of the
>>> UnionOf (naughty silly)...
>>>
>>>
>>>
>>> You don't need datatype properties for this: these are for
>>> "concrete" (ie datatype) properties such as age, height, weight,
>>> etc., and there one might want to describe Tall as having a height
>>> between 190 and 200 (cm), which is completely different from the
>>> above QCRs: we would still want to have a single height, and we
>>> would like to say that its filler is a non-negative integer between
>>> 190 and 200!
>>>
>>>
>>>
>>> Cheers, Uli
>>>
>>>
>>>
>>>
>>>
>>> On 11 Apr 2006, at 10:39, Elyes Lehtihet wrote:
>>>
>>>
>>>
>>>
>>>
>>>
>>> Hello,
>>>
>>>
>>>
>>> I need to represent an interval of values for an object property.
>>> It is not a problem with [0..n] or [1..1], but how do I correctly
>>> represent [x..y] , where y>x and y!=n ???
>>>
>>> I know that there is an issue with the Qualified Cardinality
>>> Restrictions, but that would be great to use a DIG Reasoner to
>>> check the consistency against QCRs, which I suppose are the only
>>> solution to my problem.
>>>
>>>
>>>
>>> I am using Protégé 3.1.1 with Pellet 1.3 Beta2, Racer 1.9 and FaCT+
>>> + 1.1.3
>>>
>>>
>>>
>>> The Reasoners don't support cardinality restriction on DataType
>>> Property, this limitation is going to be solved in the next version
>>> of DIG!? Does anyone know where I can find more information about
>>> that?
>>>
>>>
>>>
>>> In [1], Alan Rector and Guus Schreiber claim that Racer already
>>> support QCR; FaCT++ will shortly do, the document is dated November
>>> 2005. The status of the document is: Needs final cleanup and
>>> incorporation of responses to reviews by Alistair and Jeff.
>>>
>>>
>>>
>>> I created a simple ontology to test if the Non-Endorsed Owl
>>> Extension, as presented in [1], which *I think?* is replacing
>>> owl:allValuesFrom with owl:valuesFrom, works with Racer and FaCT++.
>>>
>>> I quickly created a simple ontology (please see attached: test.owl)
>>> with Protégé, using allValueFrom restriction. I used the example of
>>> Diner and MinimalDiner, where a MinimalDiner should have only three
>>> particular types of courses. Of course, all the reasoners generated
>>> an error: MinimalDiner is inconsistent. I added SomethingElse as a
>>> subclass of course and a target of has_course, to test if it will
>>> generate an error when changing the syntax of allValuesFrom.
>>>
>>>
>>>
>>> After, I manually changed allValuesFrom to valuesFrom (please see
>>> attached: testqcr.owl). The ontology, now OWL-Full, is loaded
>>> without generating any error in Protégé, except that:
>>>
>>> 1- It is quiet slow when selecting the constrained class and it
>>> doesn't show the code.
>>>
>>> 2- Protégé replaced the constraints by some weird code : @_:A671
>>> and @_:A680 and @_:A689 and @_:A698
>>>
>>> 3- When starting the Reasoners (Racer, Pellet and FaCT++), it start
>>> processing but never stop, or generate any inconsistency error.
>>>
>>> I also tried with RacerPorter to see if the problem was only with
>>> Protégé, but it doesn't want to load the ontology.
>>>
>>>
>>>
>>> So, it is obvious that it doesn't work...
>>>
>>> Am I doing something wrong? Is there any other solution?
>>>
>>>
>>>
>>> Any help would be much appreciated
>>>
>>>
>>>
>>> Thanks
>>>
>>> Elyes
>>>
>>>
>>>
>>> [1] http://www.w3.org/2001/sw/BestPractices/OEP/QCR/
>>>

-------------------------------------------------------------------------
To unsubscribe go to http://protege.stanford.edu/community/subscribe.html


-------------------------------------------------------------------------
To unsubscribe go to http://protege.stanford.edu/community/subscribe.html

Reply | Threaded
Open this post in threaded view
|

Re: AW: Re: QCRs and DIG: Racer, FaCT and Pellet

Ulrike Sattler
In reply to this post by Rajverma

On 12 Apr 2006, at 15:46, Mudunuri, Raj wrote:

> Hi Uli,
>
> So how wud I axiomatize if I want the reasoner to raise an error if  
> my individual is not fulfilling the minimum cardinality restriction  
> that I have on my concept?
>

you would need something that is not yet available in owl: namely  
epistemic operators ("K" is a modality that is read as "known of/that"


happyparent(a) implies K(haschild(a,b)) and K(hasChild(a,c)) and happy
(b) and happy(c) and a\neq b


alternatively, we could write a query to retrieve, for each  
happyparent x, all children of x  that are happy, count them, and  
raise a warning in case there aren't enough--

> Following this example,

which?

> if the individual HappyParent has more than 4 (happy)children then  
> the reasoner tells me that it is not possible according to the  
> restriction that there should be atmost 4 (happy) children  
> associated to a HappyParent.

only if these more than 4 children can't be merged into 4!

> OK. On the other hand if I want to make sure that if at all there  
> is an individual HappyParent then it should also be the case that  
> there should be atleast 2 individual (happy)children for this  
> HappyParent, then how to describe it?

see above!

> Something like, I want to describe that there are no other  
> individual (happy)children except the ones specified, so  
> Mr.Reasoner let me know if my individual HappyParent doesn't fulfil  
> the restriction of atleast 2 (happy)children!
>
> Is this something like asking for closed-world-assumption answers  
> with an open-world-reasoning tools? If yes, does SWRL help in this  
> case?
>


no, SWRL doesn't help --- you need "K" or a similar thing or a shell  
script (for the above work-around)! Cheers, Uli

> Cheers,
> Raj
>
>
>
>
>
> -----Ursprüngliche Nachricht-----
> Von: [hidden email] [mailto:protege-owl-
> [hidden email]] Im Auftrag von Uli Sattler
> Gesendet: Mittwoch, 12. April 2006 10:42
> An: [hidden email]
> Betreff: [protege-owl] Re: QCRs and DIG: Racer, FaCT and Pellet
>
> On 11 Apr 2006, at 21:02, Elyes Lehtihet wrote:
>
>> Hi Uli,
>>
>> Sorry my fault... I thought that "Individuals" are automatically
>> disjoint,
>> it is hard to understand why an Individual is by default  
>> equivalent to
>> another.
>
> sorry, but these individuals aren't "by default equivalent to
> another": they are by default not necessarily distinct. That is, we
> do not (by default) employ the unique name assumption (UNA).
>
>> I created an instance of happyParent and six instances of Happy,
>> where all
>> the instances of Happy are Different.
>> However it doesn't solve my problem...
>>
>> So now happyParent should only accept 2 or 3 or 4
>
> [children that are]
>
>> instances of Happy, no
>> more or less...
>> 1- If I link more than 4 instance of Happy then it generate an
>> error -->Good.
>> 2- If I create an instance of happyParent without creating any
>> instance of
>> Happy, the Reasoners do not generate an error.
>
> Good: since (beside the UNA), the reasoner also employs the "open
> world assumption": what you told the reasoner is true, but it is NOT
> necessarily the case that you have told him everything. That is,
> there can be other children besides those that you told the reasoner
> about.
>
>> 3- If I attach only one instance of Happy, it doesn't generate an
>> error.
>
> the same
>
> Perhaps a look at the pizza tutorial would have helped? Cheers, Uli
>
>>
>> Make it more simple and say that the cardinality is stricly equal
>> to 3. An
>> instance of happyParent must have strictly 3 different instance of
>> Happy.
>> Please have a look at the attached file, where all the individuals  
>> are
>> already created and constrained (allDifferent). It might be something
>> wrong with the way I add the Restrictions...
>>
>> Regards
>> Elyes
>>
>>>
>>> On 11 Apr 2006, at 13:59, Elyes Lehtihet wrote:
>>>
>>>> Hi Uli,
>>>>
>>>>
>>>>
>>>> I removed rdf:datatype= "http://www.w3.org/2001/XMLSchema#int". But
>>>> it doesn't make any difference, Protégé keep adding them when
>>>> loading the ontology, and the Reasoners do not tell me that
>>>> happyParent shouldn't have more than 4 Happy children instance,
>>>
>>> hmmm, do you mean you created an instance of happyParent and gave  
>>> it,
>>> say 5 happy children? In this case, the reasoner SHOULD not complain
>>> --- unless you have explicitly declared these 5 children to be all
>>> different: that is, the reasoner will simply assume that 2 of them
>>> are identical (as long as this does lead to contradiction because
>>> they are, additionally, instances of disjoint classes)....
>>>
>>>> and stressedParent shouldn't have less than 4 Silly or Naughty
>>>> Children...
>>>>
>>>>
>>>>
>>>> How do I express a restriction to be sure that a Reasoner *will*
>>>> generate an inconsistency if an instance, or a subclass, of
>>>> acme_Parent has:
>>>>
>>>> More or less than 4 children *and*
>>>>
>>>> More or less than 2 happy children *and*
>>>>
>>>> More or less than 1 silly *and*
>>>>
>>>> More or less than 1 Tall *and*
>>>>
>>>>> hmmm, I guess you aemn that a reasoner will come back with an
>>>> inconsistency in case you make a subclass of YourParent with atmost
>>>> 1 happy child or at least 3 happy ones, or with at least 2 silly
>>>> children, or with at least 2 tall children.
>>>>
>>>>> Please note that you can safely generate an instance, say bob, of
>>>> YourParent without declaring any of its children!
>>>>
>>>>
>>>>
>>>> The problem is that I need to define the instances of the children
>>>> *and* determine if an instance of acme_Parent is valid
>>>>
>>>>
>>>>
>>>> Lets explain it this way: how do I say that an instance of class_a
>>>> is valid only if it is strictly linked (via the ObjectProperty) to
>>>> [X...Y] instance of class_b?
>>>>
>>>> If it is 1..1 it is the FunctionalProperty
>>>>
>>>> If it is 0..n it is the default value
>>>>
>>>> But what about the rest of possible values?
>>>>
>>>>
>>>>
>>>> Regards
>>>>
>>>> Elyes
>>>>
>>>>
>>>>
>>>> From: Uli Sattler [mailto:[hidden email]]
>>>> Sent: Tuesday, April 11, 2006 12:30 PM
>>>> To: Elyes Lehtihet
>>>> Subject: Re: [protege-owl] Re: QCRs and DIG: Racer, FaCT and Pellet
>>>>
>>>>
>>>>
>>>> Hi Elyes,
>>>>
>>>>
>>>>
>>>> from a quick glance, it looks as you have some syntactic errors
>>>> here (there shouldn't be rdf:datatype
>>>>
>>>>
>>>>
>>>>     <owl:minCardinality rdf:datatype="http://www.w3.org/2001/
>>>> XMLSchema#int"
>>>>
>>>>> 4</owl:minCardinality>
>>>>
>>>>
>>>>
>>>> and, in contrast to what we were saying in our example,
>>>>
>>>>
>>>>
>>>> <owl:Restriction>
>>>>
>>>>             <owl:allValuesFrom>
>>>>
>>>>               <owl:Class>
>>>>
>>>>                 <owl:unionOf rdf:parseType="Collection">
>>>>
>>>>                   <owl:Class rdf:ID="Silly"/>
>>>>
>>>>                   <owl:Class rdf:ID="Naughty"/>
>>>>
>>>>                 </owl:unionOf>
>>>>
>>>>               </owl:Class>
>>>>
>>>>             </owl:allValuesFrom>
>>>>
>>>>
>>>>
>>>> says that ALL children are silly, naughty, or both! Cheers, Uli
>>>>
>>>>
>>>>
>>>>
>>>>
>>>>
>>>>
>>>>
>>>>
>>>> On 11 Apr 2006, at 12:06, Elyes Lehtihet wrote:
>>>>
>>>>
>>>>
>>>> Hi, again,
>>>>
>>>>
>>>>
>>>> I created another example of your ontology with Parent and
>>>> Children. happyParent have between 2 and 4 children that are happy.
>>>> stresseParent have 4 or more children that are union of Silly and
>>>> Naughty.
>>>>
>>>> All the Reasoners do not generate any inconsistency error when I
>>>> attach more than the number of allowed children (has_child) to any
>>>> class. happyParent should not have 6 Happy children. stressedParent
>>>> should not have 2 Silly and 1 Naughty....
>>>>
>>>>
>>>>
>>>> Please see attached file, it might be something wrong with the way
>>>> I formulate the constraints!?
>>>>
>>>>
>>>>
>>>> Regards
>>>>
>>>> Elyes
>>>>
>>>>
>>>>
>>>> From: [hidden email] [mailto:protege-owl-
>>>> [hidden email]] On Behalf Of Uli Sattler
>>>> Sent: Tuesday, April 11, 2006 11:00 AM
>>>> To: [hidden email]
>>>> Subject: [protege-owl] Re: QCRs and DIG: Racer, FaCT and Pellet
>>>>
>>>>
>>>>
>>>> Hi,
>>>>
>>>>
>>>>
>>>> what is it that you want to do exactly? I don't understand your
>>>> "interval of values": assume we have an object property, eg,
>>>> hasChild, with Range Human, and Human has (non-disjoint) subclasses
>>>> Tall, Happy, Naughty, Silly, etc.
>>>>
>>>>
>>>>
>>>> Do you want to describe a class by restricted the number of
>>>> hasChild of a certain kind? This is what we would use qualified
>>>> number restrictions for: eg, to say that a happyParent has between
>>>> 2 and 4 children that are instances of Happy, or to say that a
>>>> StressedParent has atleast 4 children that are instances of the
>>>> UnionOf (naughty silly)...
>>>>
>>>>
>>>>
>>>> You don't need datatype properties for this: these are for
>>>> "concrete" (ie datatype) properties such as age, height, weight,
>>>> etc., and there one might want to describe Tall as having a height
>>>> between 190 and 200 (cm), which is completely different from the
>>>> above QCRs: we would still want to have a single height, and we
>>>> would like to say that its filler is a non-negative integer between
>>>> 190 and 200!
>>>>
>>>>
>>>>
>>>> Cheers, Uli
>>>>
>>>>
>>>>
>>>>
>>>>
>>>> On 11 Apr 2006, at 10:39, Elyes Lehtihet wrote:
>>>>
>>>>
>>>>
>>>>
>>>>
>>>>
>>>> Hello,
>>>>
>>>>
>>>>
>>>> I need to represent an interval of values for an object property.
>>>> It is not a problem with [0..n] or [1..1], but how do I correctly
>>>> represent [x..y] , where y>x and y!=n ???
>>>>
>>>> I know that there is an issue with the Qualified Cardinality
>>>> Restrictions, but that would be great to use a DIG Reasoner to
>>>> check the consistency against QCRs, which I suppose are the only
>>>> solution to my problem.
>>>>
>>>>
>>>>
>>>> I am using Protégé 3.1.1 with Pellet 1.3 Beta2, Racer 1.9 and FaCT+
>>>> + 1.1.3
>>>>
>>>>
>>>>
>>>> The Reasoners don't support cardinality restriction on DataType
>>>> Property, this limitation is going to be solved in the next version
>>>> of DIG!? Does anyone know where I can find more information about
>>>> that?
>>>>
>>>>
>>>>
>>>> In [1], Alan Rector and Guus Schreiber claim that Racer already
>>>> support QCR; FaCT++ will shortly do, the document is dated November
>>>> 2005. The status of the document is: Needs final cleanup and
>>>> incorporation of responses to reviews by Alistair and Jeff.
>>>>
>>>>
>>>>
>>>> I created a simple ontology to test if the Non-Endorsed Owl
>>>> Extension, as presented in [1], which *I think?* is replacing
>>>> owl:allValuesFrom with owl:valuesFrom, works with Racer and FaCT++.
>>>>
>>>> I quickly created a simple ontology (please see attached: test.owl)
>>>> with Protégé, using allValueFrom restriction. I used the example of
>>>> Diner and MinimalDiner, where a MinimalDiner should have only three
>>>> particular types of courses. Of course, all the reasoners generated
>>>> an error: MinimalDiner is inconsistent. I added SomethingElse as a
>>>> subclass of course and a target of has_course, to test if it will
>>>> generate an error when changing the syntax of allValuesFrom.
>>>>
>>>>
>>>>
>>>> After, I manually changed allValuesFrom to valuesFrom (please see
>>>> attached: testqcr.owl). The ontology, now OWL-Full, is loaded
>>>> without generating any error in Protégé, except that:
>>>>
>>>> 1- It is quiet slow when selecting the constrained class and it
>>>> doesn't show the code.
>>>>
>>>> 2- Protégé replaced the constraints by some weird code : @_:A671
>>>> and @_:A680 and @_:A689 and @_:A698
>>>>
>>>> 3- When starting the Reasoners (Racer, Pellet and FaCT++), it start
>>>> processing but never stop, or generate any inconsistency error.
>>>>
>>>> I also tried with RacerPorter to see if the problem was only with
>>>> Protégé, but it doesn't want to load the ontology.
>>>>
>>>>
>>>>
>>>> So, it is obvious that it doesn't work...
>>>>
>>>> Am I doing something wrong? Is there any other solution?
>>>>
>>>>
>>>>
>>>> Any help would be much appreciated
>>>>
>>>>
>>>>
>>>> Thanks
>>>>
>>>> Elyes
>>>>
>>>>
>>>>
>>>> [1] http://www.w3.org/2001/sw/BestPractices/OEP/QCR/
>>>>
>
> ----------------------------------------------------------------------
> ---
> To unsubscribe go to http://protege.stanford.edu/community/ 
> subscribe.html
>

-------------------------------------------------------------------------
To unsubscribe go to http://protege.stanford.edu/community/subscribe.html

Reply | Threaded
Open this post in threaded view
|

AW: Re: AW: Re: QCRs and DIG: Racer, FaCT and Pellet

Rajverma
In reply to this post by Elyes Lehtihet-3
Thanq very much Uli... your post is very informative... It highlights one of the important aspects (short commings or features, depends on how we look at it) of OWL based ontologies and DL based reasoning...

The work around (trying to achieve this with the help of queries) is not so practical, I believe, because one normally wud like to sort out these things during classification of ABoxes but not with passing queries to check for each individual...

Sorry for consuming your time, but it wud be great if you cud clear some general doubts with very short answers...

1. I'm interested to know whether there are plans to include these epistemic operators(K) in OWL in the near future.

2. Is there any active research going on in these lines in your group?

3. If OWL is equipped with K, are the existing DL reasoners capable enuf to deal with this expressivity?

4. If they can't, does it mean that there is a need for devising new tableau algorithms (or further optimaizing the current ones) to increase the reasoning capabilities of the reasoners?

Thanks a lot,
Raj





-----Ursprüngliche Nachricht-----
Von: [hidden email] [mailto:[hidden email]] Im Auftrag von Ulrike Sattler
Gesendet: Mittwoch, 12. April 2006 18:52
An: [hidden email]
Betreff: [protege-owl] Re: AW: Re: QCRs and DIG: Racer, FaCT and Pellet


On 12 Apr 2006, at 15:46, Mudunuri, Raj wrote:

> Hi Uli,
>
> So how wud I axiomatize if I want the reasoner to raise an error if  
> my individual is not fulfilling the minimum cardinality restriction  
> that I have on my concept?
>

you would need something that is not yet available in owl: namely  
epistemic operators ("K" is a modality that is read as "known of/that"


happyparent(a) implies K(haschild(a,b)) and K(hasChild(a,c)) and happy
(b) and happy(c) and a\neq b


alternatively, we could write a query to retrieve, for each  
happyparent x, all children of x  that are happy, count them, and  
raise a warning in case there aren't enough--

> Following this example,

which?

> if the individual HappyParent has more than 4 (happy)children then  
> the reasoner tells me that it is not possible according to the  
> restriction that there should be atmost 4 (happy) children  
> associated to a HappyParent.

only if these more than 4 children can't be merged into 4!

> OK. On the other hand if I want to make sure that if at all there  
> is an individual HappyParent then it should also be the case that  
> there should be atleast 2 individual (happy)children for this  
> HappyParent, then how to describe it?

see above!

> Something like, I want to describe that there are no other  
> individual (happy)children except the ones specified, so  
> Mr.Reasoner let me know if my individual HappyParent doesn't fulfil  
> the restriction of atleast 2 (happy)children!
>
> Is this something like asking for closed-world-assumption answers  
> with an open-world-reasoning tools? If yes, does SWRL help in this  
> case?
>


no, SWRL doesn't help --- you need "K" or a similar thing or a shell  
script (for the above work-around)! Cheers, Uli

> Cheers,
> Raj
>
>
>
>
>
> -----Ursprüngliche Nachricht-----
> Von: [hidden email] [mailto:protege-owl-
> [hidden email]] Im Auftrag von Uli Sattler
> Gesendet: Mittwoch, 12. April 2006 10:42
> An: [hidden email]
> Betreff: [protege-owl] Re: QCRs and DIG: Racer, FaCT and Pellet
>
> On 11 Apr 2006, at 21:02, Elyes Lehtihet wrote:
>
>> Hi Uli,
>>
>> Sorry my fault... I thought that "Individuals" are automatically
>> disjoint,
>> it is hard to understand why an Individual is by default  
>> equivalent to
>> another.
>
> sorry, but these individuals aren't "by default equivalent to
> another": they are by default not necessarily distinct. That is, we
> do not (by default) employ the unique name assumption (UNA).
>
>> I created an instance of happyParent and six instances of Happy,
>> where all
>> the instances of Happy are Different.
>> However it doesn't solve my problem...
>>
>> So now happyParent should only accept 2 or 3 or 4
>
> [children that are]
>
>> instances of Happy, no
>> more or less...
>> 1- If I link more than 4 instance of Happy then it generate an
>> error -->Good.
>> 2- If I create an instance of happyParent without creating any
>> instance of
>> Happy, the Reasoners do not generate an error.
>
> Good: since (beside the UNA), the reasoner also employs the "open
> world assumption": what you told the reasoner is true, but it is NOT
> necessarily the case that you have told him everything. That is,
> there can be other children besides those that you told the reasoner
> about.
>
>> 3- If I attach only one instance of Happy, it doesn't generate an
>> error.
>
> the same
>
> Perhaps a look at the pizza tutorial would have helped? Cheers, Uli
>
>>
>> Make it more simple and say that the cardinality is stricly equal
>> to 3. An
>> instance of happyParent must have strictly 3 different instance of
>> Happy.
>> Please have a look at the attached file, where all the individuals  
>> are
>> already created and constrained (allDifferent). It might be something
>> wrong with the way I add the Restrictions...
>>
>> Regards
>> Elyes
>>
>>>
>>> On 11 Apr 2006, at 13:59, Elyes Lehtihet wrote:
>>>
>>>> Hi Uli,
>>>>
>>>>
>>>>
>>>> I removed rdf:datatype= "http://www.w3.org/2001/XMLSchema#int". But
>>>> it doesn't make any difference, Protégé keep adding them when
>>>> loading the ontology, and the Reasoners do not tell me that
>>>> happyParent shouldn't have more than 4 Happy children instance,
>>>
>>> hmmm, do you mean you created an instance of happyParent and gave  
>>> it,
>>> say 5 happy children? In this case, the reasoner SHOULD not complain
>>> --- unless you have explicitly declared these 5 children to be all
>>> different: that is, the reasoner will simply assume that 2 of them
>>> are identical (as long as this does lead to contradiction because
>>> they are, additionally, instances of disjoint classes)....
>>>
>>>> and stressedParent shouldn't have less than 4 Silly or Naughty
>>>> Children...
>>>>
>>>>
>>>>
>>>> How do I express a restriction to be sure that a Reasoner *will*
>>>> generate an inconsistency if an instance, or a subclass, of
>>>> acme_Parent has:
>>>>
>>>> More or less than 4 children *and*
>>>>
>>>> More or less than 2 happy children *and*
>>>>
>>>> More or less than 1 silly *and*
>>>>
>>>> More or less than 1 Tall *and*
>>>>
>>>>> hmmm, I guess you aemn that a reasoner will come back with an
>>>> inconsistency in case you make a subclass of YourParent with atmost
>>>> 1 happy child or at least 3 happy ones, or with at least 2 silly
>>>> children, or with at least 2 tall children.
>>>>
>>>>> Please note that you can safely generate an instance, say bob, of
>>>> YourParent without declaring any of its children!
>>>>
>>>>
>>>>
>>>> The problem is that I need to define the instances of the children
>>>> *and* determine if an instance of acme_Parent is valid
>>>>
>>>>
>>>>
>>>> Lets explain it this way: how do I say that an instance of class_a
>>>> is valid only if it is strictly linked (via the ObjectProperty) to
>>>> [X...Y] instance of class_b?
>>>>
>>>> If it is 1..1 it is the FunctionalProperty
>>>>
>>>> If it is 0..n it is the default value
>>>>
>>>> But what about the rest of possible values?
>>>>
>>>>
>>>>
>>>> Regards
>>>>
>>>> Elyes
>>>>
>>>>
>>>>
>>>> From: Uli Sattler [mailto:[hidden email]]
>>>> Sent: Tuesday, April 11, 2006 12:30 PM
>>>> To: Elyes Lehtihet
>>>> Subject: Re: [protege-owl] Re: QCRs and DIG: Racer, FaCT and Pellet
>>>>
>>>>
>>>>
>>>> Hi Elyes,
>>>>
>>>>
>>>>
>>>> from a quick glance, it looks as you have some syntactic errors
>>>> here (there shouldn't be rdf:datatype
>>>>
>>>>
>>>>
>>>>     <owl:minCardinality rdf:datatype="http://www.w3.org/2001/
>>>> XMLSchema#int"
>>>>
>>>>> 4</owl:minCardinality>
>>>>
>>>>
>>>>
>>>> and, in contrast to what we were saying in our example,
>>>>
>>>>
>>>>
>>>> <owl:Restriction>
>>>>
>>>>             <owl:allValuesFrom>
>>>>
>>>>               <owl:Class>
>>>>
>>>>                 <owl:unionOf rdf:parseType="Collection">
>>>>
>>>>                   <owl:Class rdf:ID="Silly"/>
>>>>
>>>>                   <owl:Class rdf:ID="Naughty"/>
>>>>
>>>>                 </owl:unionOf>
>>>>
>>>>               </owl:Class>
>>>>
>>>>             </owl:allValuesFrom>
>>>>
>>>>
>>>>
>>>> says that ALL children are silly, naughty, or both! Cheers, Uli
>>>>
>>>>
>>>>
>>>>
>>>>
>>>>
>>>>
>>>>
>>>>
>>>> On 11 Apr 2006, at 12:06, Elyes Lehtihet wrote:
>>>>
>>>>
>>>>
>>>> Hi, again,
>>>>
>>>>
>>>>
>>>> I created another example of your ontology with Parent and
>>>> Children. happyParent have between 2 and 4 children that are happy.
>>>> stresseParent have 4 or more children that are union of Silly and
>>>> Naughty.
>>>>
>>>> All the Reasoners do not generate any inconsistency error when I
>>>> attach more than the number of allowed children (has_child) to any
>>>> class. happyParent should not have 6 Happy children. stressedParent
>>>> should not have 2 Silly and 1 Naughty....
>>>>
>>>>
>>>>
>>>> Please see attached file, it might be something wrong with the way
>>>> I formulate the constraints!?
>>>>
>>>>
>>>>
>>>> Regards
>>>>
>>>> Elyes
>>>>
>>>>
>>>>
>>>> From: [hidden email] [mailto:protege-owl-
>>>> [hidden email]] On Behalf Of Uli Sattler
>>>> Sent: Tuesday, April 11, 2006 11:00 AM
>>>> To: [hidden email]
>>>> Subject: [protege-owl] Re: QCRs and DIG: Racer, FaCT and Pellet
>>>>
>>>>
>>>>
>>>> Hi,
>>>>
>>>>
>>>>
>>>> what is it that you want to do exactly? I don't understand your
>>>> "interval of values": assume we have an object property, eg,
>>>> hasChild, with Range Human, and Human has (non-disjoint) subclasses
>>>> Tall, Happy, Naughty, Silly, etc.
>>>>
>>>>
>>>>
>>>> Do you want to describe a class by restricted the number of
>>>> hasChild of a certain kind? This is what we would use qualified
>>>> number restrictions for: eg, to say that a happyParent has between
>>>> 2 and 4 children that are instances of Happy, or to say that a
>>>> StressedParent has atleast 4 children that are instances of the
>>>> UnionOf (naughty silly)...
>>>>
>>>>
>>>>
>>>> You don't need datatype properties for this: these are for
>>>> "concrete" (ie datatype) properties such as age, height, weight,
>>>> etc., and there one might want to describe Tall as having a height
>>>> between 190 and 200 (cm), which is completely different from the
>>>> above QCRs: we would still want to have a single height, and we
>>>> would like to say that its filler is a non-negative integer between
>>>> 190 and 200!
>>>>
>>>>
>>>>
>>>> Cheers, Uli
>>>>
>>>>
>>>>
>>>>
>>>>
>>>> On 11 Apr 2006, at 10:39, Elyes Lehtihet wrote:
>>>>
>>>>
>>>>
>>>>
>>>>
>>>>
>>>> Hello,
>>>>
>>>>
>>>>
>>>> I need to represent an interval of values for an object property.
>>>> It is not a problem with [0..n] or [1..1], but how do I correctly
>>>> represent [x..y] , where y>x and y!=n ???
>>>>
>>>> I know that there is an issue with the Qualified Cardinality
>>>> Restrictions, but that would be great to use a DIG Reasoner to
>>>> check the consistency against QCRs, which I suppose are the only
>>>> solution to my problem.
>>>>
>>>>
>>>>
>>>> I am using Protégé 3.1.1 with Pellet 1.3 Beta2, Racer 1.9 and FaCT+
>>>> + 1.1.3
>>>>
>>>>
>>>>
>>>> The Reasoners don't support cardinality restriction on DataType
>>>> Property, this limitation is going to be solved in the next version
>>>> of DIG!? Does anyone know where I can find more information about
>>>> that?
>>>>
>>>>
>>>>
>>>> In [1], Alan Rector and Guus Schreiber claim that Racer already
>>>> support QCR; FaCT++ will shortly do, the document is dated November
>>>> 2005. The status of the document is: Needs final cleanup and
>>>> incorporation of responses to reviews by Alistair and Jeff.
>>>>
>>>>
>>>>
>>>> I created a simple ontology to test if the Non-Endorsed Owl
>>>> Extension, as presented in [1], which *I think?* is replacing
>>>> owl:allValuesFrom with owl:valuesFrom, works with Racer and FaCT++.
>>>>
>>>> I quickly created a simple ontology (please see attached: test.owl)
>>>> with Protégé, using allValueFrom restriction. I used the example of
>>>> Diner and MinimalDiner, where a MinimalDiner should have only three
>>>> particular types of courses. Of course, all the reasoners generated
>>>> an error: MinimalDiner is inconsistent. I added SomethingElse as a
>>>> subclass of course and a target of has_course, to test if it will
>>>> generate an error when changing the syntax of allValuesFrom.
>>>>
>>>>
>>>>
>>>> After, I manually changed allValuesFrom to valuesFrom (please see
>>>> attached: testqcr.owl). The ontology, now OWL-Full, is loaded
>>>> without generating any error in Protégé, except that:
>>>>
>>>> 1- It is quiet slow when selecting the constrained class and it
>>>> doesn't show the code.
>>>>
>>>> 2- Protégé replaced the constraints by some weird code : @_:A671
>>>> and @_:A680 and @_:A689 and @_:A698
>>>>
>>>> 3- When starting the Reasoners (Racer, Pellet and FaCT++), it start
>>>> processing but never stop, or generate any inconsistency error.
>>>>
>>>> I also tried with RacerPorter to see if the problem was only with
>>>> Protégé, but it doesn't want to load the ontology.
>>>>
>>>>
>>>>
>>>> So, it is obvious that it doesn't work...
>>>>
>>>> Am I doing something wrong? Is there any other solution?
>>>>
>>>>
>>>>
>>>> Any help would be much appreciated
>>>>
>>>>
>>>>
>>>> Thanks
>>>>
>>>> Elyes
>>>>
>>>>
>>>>
>>>> [1] http://www.w3.org/2001/sw/BestPractices/OEP/QCR/
>>>>
>
> ----------------------------------------------------------------------
> ---
> To unsubscribe go to http://protege.stanford.edu/community/ 
> subscribe.html
>

-------------------------------------------------------------------------
To unsubscribe go to http://protege.stanford.edu/community/subscribe.html

-------------------------------------------------------------------------
To unsubscribe go to http://protege.stanford.edu/community/subscribe.html

Reply | Threaded
Open this post in threaded view
|

Re: AW: Re: AW: Re: QCRs and DIG: Racer, FaCT and Pellet

Ulrike Sattler
On 13 Apr 2006, at 17:17, Mudunuri, Raj wrote:

> Thanq very much Uli... your post is very informative... It  
> highlights one of the important aspects (short commings or  
> features, depends on how we look at it) of OWL based ontologies and  
> DL based reasoning...
>
> The work around (trying to achieve this with the help of queries)  
> is not so practical, I believe, because one normally wud like to  
> sort out these things during classification of ABoxes

hmm, but isn't it the case that these "must also be present  
explicitly" will indeed depend, eg, at which stage you look your  
ABox, who looks at it, etc.? Ie, I guess that these "must also be  
present explicitly" are highly context dependent, and thus should be  
separated from the logical aspect of modelling a domain.

> but not with passing queries to check for each individual...
>
> Sorry for consuming your time, but it wud be great if you cud clear  
> some general doubts with very short answers...
>
> 1. I'm interested to know whether there are plans to include these  
> epistemic operators(K) in OWL in the near future.
>

depends on what you mean by "near" and what you mean by "in OWL":  
have a look at the OWL mailinglist, eg, at

http://lists.mindswap.org/pipermail/owl/2005-December/000057.html

> 2. Is there any active research going on in these lines in your group?
>

yes, there is.

> 3. If OWL is equipped with K, are the existing DL reasoners capable  
> enuf to deal with this expressivity?
>

rumor has it that Pellet supports k in queries, which is what you want

BTW: using a spell checker would increase the readability hugely!

> 4. If they can't, does it mean that there is a need for devising  
> new tableau algorithms (or further optimaizing the current ones) to  
> increase the reasoning capabilities of the reasoners?

devising, implementing, optimizing: everything, i guess

Cheers, Uli

PS: a bit of googeling would have answered you most of your questions!

>
> Thanks a lot,
> Raj
>
>
>
>
>
> -----Ursprüngliche Nachricht-----
> Von: [hidden email] [mailto:protege-owl-
> [hidden email]] Im Auftrag von Ulrike Sattler
> Gesendet: Mittwoch, 12. April 2006 18:52
> An: [hidden email]
> Betreff: [protege-owl] Re: AW: Re: QCRs and DIG: Racer, FaCT and  
> Pellet
>
>
> On 12 Apr 2006, at 15:46, Mudunuri, Raj wrote:
>
>> Hi Uli,
>>
>> So how wud I axiomatize if I want the reasoner to raise an error if
>> my individual is not fulfilling the minimum cardinality restriction
>> that I have on my concept?
>>
>
> you would need something that is not yet available in owl: namely
> epistemic operators ("K" is a modality that is read as "known of/that"
>
>
> happyparent(a) implies K(haschild(a,b)) and K(hasChild(a,c)) and happy
> (b) and happy(c) and a\neq b
>
>
> alternatively, we could write a query to retrieve, for each
> happyparent x, all children of x  that are happy, count them, and
> raise a warning in case there aren't enough--
>
>> Following this example,
>
> which?
>
>> if the individual HappyParent has more than 4 (happy)children then
>> the reasoner tells me that it is not possible according to the
>> restriction that there should be atmost 4 (happy) children
>> associated to a HappyParent.
>
> only if these more than 4 children can't be merged into 4!
>
>> OK. On the other hand if I want to make sure that if at all there
>> is an individual HappyParent then it should also be the case that
>> there should be atleast 2 individual (happy)children for this
>> HappyParent, then how to describe it?
>
> see above!
>
>> Something like, I want to describe that there are no other
>> individual (happy)children except the ones specified, so
>> Mr.Reasoner let me know if my individual HappyParent doesn't fulfil
>> the restriction of atleast 2 (happy)children!
>>
>> Is this something like asking for closed-world-assumption answers
>> with an open-world-reasoning tools? If yes, does SWRL help in this
>> case?
>>
>
>
> no, SWRL doesn't help --- you need "K" or a similar thing or a shell
> script (for the above work-around)! Cheers, Uli
>
>> Cheers,
>> Raj
>>
>>
>>
>>
>>
>> -----Ursprüngliche Nachricht-----
>> Von: [hidden email] [mailto:protege-owl-
>> [hidden email]] Im Auftrag von Uli Sattler
>> Gesendet: Mittwoch, 12. April 2006 10:42
>> An: [hidden email]
>> Betreff: [protege-owl] Re: QCRs and DIG: Racer, FaCT and Pellet
>>
>> On 11 Apr 2006, at 21:02, Elyes Lehtihet wrote:
>>
>>> Hi Uli,
>>>
>>> Sorry my fault... I thought that "Individuals" are automatically
>>> disjoint,
>>> it is hard to understand why an Individual is by default
>>> equivalent to
>>> another.
>>
>> sorry, but these individuals aren't "by default equivalent to
>> another": they are by default not necessarily distinct. That is, we
>> do not (by default) employ the unique name assumption (UNA).
>>
>>> I created an instance of happyParent and six instances of Happy,
>>> where all
>>> the instances of Happy are Different.
>>> However it doesn't solve my problem...
>>>
>>> So now happyParent should only accept 2 or 3 or 4
>>
>> [children that are]
>>
>>> instances of Happy, no
>>> more or less...
>>> 1- If I link more than 4 instance of Happy then it generate an
>>> error -->Good.
>>> 2- If I create an instance of happyParent without creating any
>>> instance of
>>> Happy, the Reasoners do not generate an error.
>>
>> Good: since (beside the UNA), the reasoner also employs the "open
>> world assumption": what you told the reasoner is true, but it is NOT
>> necessarily the case that you have told him everything. That is,
>> there can be other children besides those that you told the reasoner
>> about.
>>
>>> 3- If I attach only one instance of Happy, it doesn't generate an
>>> error.
>>
>> the same
>>
>> Perhaps a look at the pizza tutorial would have helped? Cheers, Uli
>>
>>>
>>> Make it more simple and say that the cardinality is stricly equal
>>> to 3. An
>>> instance of happyParent must have strictly 3 different instance of
>>> Happy.
>>> Please have a look at the attached file, where all the individuals
>>> are
>>> already created and constrained (allDifferent). It might be  
>>> something
>>> wrong with the way I add the Restrictions...
>>>
>>> Regards
>>> Elyes
>>>
>>>>
>>>> On 11 Apr 2006, at 13:59, Elyes Lehtihet wrote:
>>>>
>>>>> Hi Uli,
>>>>>
>>>>>
>>>>>
>>>>> I removed rdf:datatype= "http://www.w3.org/2001/XMLSchema#int".  
>>>>> But
>>>>> it doesn't make any difference, Protégé keep adding them when
>>>>> loading the ontology, and the Reasoners do not tell me that
>>>>> happyParent shouldn't have more than 4 Happy children instance,
>>>>
>>>> hmmm, do you mean you created an instance of happyParent and gave
>>>> it,
>>>> say 5 happy children? In this case, the reasoner SHOULD not  
>>>> complain
>>>> --- unless you have explicitly declared these 5 children to be all
>>>> different: that is, the reasoner will simply assume that 2 of them
>>>> are identical (as long as this does lead to contradiction because
>>>> they are, additionally, instances of disjoint classes)....
>>>>
>>>>> and stressedParent shouldn't have less than 4 Silly or Naughty
>>>>> Children...
>>>>>
>>>>>
>>>>>
>>>>> How do I express a restriction to be sure that a Reasoner *will*
>>>>> generate an inconsistency if an instance, or a subclass, of
>>>>> acme_Parent has:
>>>>>
>>>>> More or less than 4 children *and*
>>>>>
>>>>> More or less than 2 happy children *and*
>>>>>
>>>>> More or less than 1 silly *and*
>>>>>
>>>>> More or less than 1 Tall *and*
>>>>>
>>>>>> hmmm, I guess you aemn that a reasoner will come back with an
>>>>> inconsistency in case you make a subclass of YourParent with  
>>>>> atmost
>>>>> 1 happy child or at least 3 happy ones, or with at least 2 silly
>>>>> children, or with at least 2 tall children.
>>>>>
>>>>>> Please note that you can safely generate an instance, say bob, of
>>>>> YourParent without declaring any of its children!
>>>>>
>>>>>
>>>>>
>>>>> The problem is that I need to define the instances of the children
>>>>> *and* determine if an instance of acme_Parent is valid
>>>>>
>>>>>
>>>>>
>>>>> Lets explain it this way: how do I say that an instance of class_a
>>>>> is valid only if it is strictly linked (via the ObjectProperty) to
>>>>> [X...Y] instance of class_b?
>>>>>
>>>>> If it is 1..1 it is the FunctionalProperty
>>>>>
>>>>> If it is 0..n it is the default value
>>>>>
>>>>> But what about the rest of possible values?
>>>>>
>>>>>
>>>>>
>>>>> Regards
>>>>>
>>>>> Elyes
>>>>>
>>>>>
>>>>>
>>>>> From: Uli Sattler [mailto:[hidden email]]
>>>>> Sent: Tuesday, April 11, 2006 12:30 PM
>>>>> To: Elyes Lehtihet
>>>>> Subject: Re: [protege-owl] Re: QCRs and DIG: Racer, FaCT and  
>>>>> Pellet
>>>>>
>>>>>
>>>>>
>>>>> Hi Elyes,
>>>>>
>>>>>
>>>>>
>>>>> from a quick glance, it looks as you have some syntactic errors
>>>>> here (there shouldn't be rdf:datatype
>>>>>
>>>>>
>>>>>
>>>>>     <owl:minCardinality rdf:datatype="http://www.w3.org/2001/
>>>>> XMLSchema#int"
>>>>>
>>>>>> 4</owl:minCardinality>
>>>>>
>>>>>
>>>>>
>>>>> and, in contrast to what we were saying in our example,
>>>>>
>>>>>
>>>>>
>>>>> <owl:Restriction>
>>>>>
>>>>>             <owl:allValuesFrom>
>>>>>
>>>>>               <owl:Class>
>>>>>
>>>>>                 <owl:unionOf rdf:parseType="Collection">
>>>>>
>>>>>                   <owl:Class rdf:ID="Silly"/>
>>>>>
>>>>>                   <owl:Class rdf:ID="Naughty"/>
>>>>>
>>>>>                 </owl:unionOf>
>>>>>
>>>>>               </owl:Class>
>>>>>
>>>>>             </owl:allValuesFrom>
>>>>>
>>>>>
>>>>>
>>>>> says that ALL children are silly, naughty, or both! Cheers, Uli
>>>>>
>>>>>
>>>>>
>>>>>
>>>>>
>>>>>
>>>>>
>>>>>
>>>>>
>>>>> On 11 Apr 2006, at 12:06, Elyes Lehtihet wrote:
>>>>>
>>>>>
>>>>>
>>>>> Hi, again,
>>>>>
>>>>>
>>>>>
>>>>> I created another example of your ontology with Parent and
>>>>> Children. happyParent have between 2 and 4 children that are  
>>>>> happy.
>>>>> stresseParent have 4 or more children that are union of Silly and
>>>>> Naughty.
>>>>>
>>>>> All the Reasoners do not generate any inconsistency error when I
>>>>> attach more than the number of allowed children (has_child) to any
>>>>> class. happyParent should not have 6 Happy children.  
>>>>> stressedParent
>>>>> should not have 2 Silly and 1 Naughty....
>>>>>
>>>>>
>>>>>
>>>>> Please see attached file, it might be something wrong with the way
>>>>> I formulate the constraints!?
>>>>>
>>>>>
>>>>>
>>>>> Regards
>>>>>
>>>>> Elyes
>>>>>
>>>>>
>>>>>
>>>>> From: [hidden email] [mailto:protege-owl-
>>>>> [hidden email]] On Behalf Of Uli Sattler
>>>>> Sent: Tuesday, April 11, 2006 11:00 AM
>>>>> To: [hidden email]
>>>>> Subject: [protege-owl] Re: QCRs and DIG: Racer, FaCT and Pellet
>>>>>
>>>>>
>>>>>
>>>>> Hi,
>>>>>
>>>>>
>>>>>
>>>>> what is it that you want to do exactly? I don't understand your
>>>>> "interval of values": assume we have an object property, eg,
>>>>> hasChild, with Range Human, and Human has (non-disjoint)  
>>>>> subclasses
>>>>> Tall, Happy, Naughty, Silly, etc.
>>>>>
>>>>>
>>>>>
>>>>> Do you want to describe a class by restricted the number of
>>>>> hasChild of a certain kind? This is what we would use qualified
>>>>> number restrictions for: eg, to say that a happyParent has between
>>>>> 2 and 4 children that are instances of Happy, or to say that a
>>>>> StressedParent has atleast 4 children that are instances of the
>>>>> UnionOf (naughty silly)...
>>>>>
>>>>>
>>>>>
>>>>> You don't need datatype properties for this: these are for
>>>>> "concrete" (ie datatype) properties such as age, height, weight,
>>>>> etc., and there one might want to describe Tall as having a height
>>>>> between 190 and 200 (cm), which is completely different from the
>>>>> above QCRs: we would still want to have a single height, and we
>>>>> would like to say that its filler is a non-negative integer  
>>>>> between
>>>>> 190 and 200!
>>>>>
>>>>>
>>>>>
>>>>> Cheers, Uli
>>>>>
>>>>>
>>>>>
>>>>>
>>>>>
>>>>> On 11 Apr 2006, at 10:39, Elyes Lehtihet wrote:
>>>>>
>>>>>
>>>>>
>>>>>
>>>>>
>>>>>
>>>>> Hello,
>>>>>
>>>>>
>>>>>
>>>>> I need to represent an interval of values for an object property.
>>>>> It is not a problem with [0..n] or [1..1], but how do I correctly
>>>>> represent [x..y] , where y>x and y!=n ???
>>>>>
>>>>> I know that there is an issue with the Qualified Cardinality
>>>>> Restrictions, but that would be great to use a DIG Reasoner to
>>>>> check the consistency against QCRs, which I suppose are the only
>>>>> solution to my problem.
>>>>>
>>>>>
>>>>>
>>>>> I am using Protégé 3.1.1 with Pellet 1.3 Beta2, Racer 1.9 and  
>>>>> FaCT+
>>>>> + 1.1.3
>>>>>
>>>>>
>>>>>
>>>>> The Reasoners don't support cardinality restriction on DataType
>>>>> Property, this limitation is going to be solved in the next  
>>>>> version
>>>>> of DIG!? Does anyone know where I can find more information about
>>>>> that?
>>>>>
>>>>>
>>>>>
>>>>> In [1], Alan Rector and Guus Schreiber claim that Racer already
>>>>> support QCR; FaCT++ will shortly do, the document is dated  
>>>>> November
>>>>> 2005. The status of the document is: Needs final cleanup and
>>>>> incorporation of responses to reviews by Alistair and Jeff.
>>>>>
>>>>>
>>>>>
>>>>> I created a simple ontology to test if the Non-Endorsed Owl
>>>>> Extension, as presented in [1], which *I think?* is replacing
>>>>> owl:allValuesFrom with owl:valuesFrom, works with Racer and FaCT
>>>>> ++.
>>>>>
>>>>> I quickly created a simple ontology (please see attached:  
>>>>> test.owl)
>>>>> with Protégé, using allValueFrom restriction. I used the  
>>>>> example of
>>>>> Diner and MinimalDiner, where a MinimalDiner should have only  
>>>>> three
>>>>> particular types of courses. Of course, all the reasoners  
>>>>> generated
>>>>> an error: MinimalDiner is inconsistent. I added SomethingElse as a
>>>>> subclass of course and a target of has_course, to test if it will
>>>>> generate an error when changing the syntax of allValuesFrom.
>>>>>
>>>>>
>>>>>
>>>>> After, I manually changed allValuesFrom to valuesFrom (please see
>>>>> attached: testqcr.owl). The ontology, now OWL-Full, is loaded
>>>>> without generating any error in Protégé, except that:
>>>>>
>>>>> 1- It is quiet slow when selecting the constrained class and it
>>>>> doesn't show the code.
>>>>>
>>>>> 2- Protégé replaced the constraints by some weird code : @_:A671
>>>>> and @_:A680 and @_:A689 and @_:A698
>>>>>
>>>>> 3- When starting the Reasoners (Racer, Pellet and FaCT++), it  
>>>>> start
>>>>> processing but never stop, or generate any inconsistency error.
>>>>>
>>>>> I also tried with RacerPorter to see if the problem was only with
>>>>> Protégé, but it doesn't want to load the ontology.
>>>>>
>>>>>
>>>>>
>>>>> So, it is obvious that it doesn't work...
>>>>>
>>>>> Am I doing something wrong? Is there any other solution?
>>>>>
>>>>>
>>>>>
>>>>> Any help would be much appreciated
>>>>>
>>>>>
>>>>>
>>>>> Thanks
>>>>>
>>>>> Elyes
>>>>>
>>>>>
>>>>>
>>>>> [1] http://www.w3.org/2001/sw/BestPractices/OEP/QCR/
>>>>>
>>
>> ---------------------------------------------------------------------
>> -
>> ---
>> To unsubscribe go to http://protege.stanford.edu/community/
>> subscribe.html
>>
>
> ----------------------------------------------------------------------
> ---
> To unsubscribe go to http://protege.stanford.edu/community/ 
> subscribe.html
>
> ----------------------------------------------------------------------
> ---
> To unsubscribe go to http://protege.stanford.edu/community/ 
> subscribe.html
>

-------------------------------------------------------------------------
To unsubscribe go to http://protege.stanford.edu/community/subscribe.html