Search Mailing List Archives

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

[protege-owl] Inheritance?

Poovendran Moodley moodleyp at
Thu Jan 14 03:09:25 PST 2010

Hi Thomas,

Thank you for your reply, it's was greatly useful! It's always exciting
learning these new things - especially when the puzzle pieces fall into
place :) I have a few more question that are in line...

On Thu, Jan 14, 2010 at 1:23 AM, Thomas Russ <tar at> wrote:

>  I understand that I can create an equivalence class so that any
>> individual with certain properties belong to said class, but I want the
>> opposite to be possible: if an individual is part of the class then it
>> should inherit the object properties (linking to the appropriate
>> individuals) specified for that class.
> An equivalence class really is equivalent.  It means that inferences work
> in both directions.  You will generally need to run a reasoner in order to
> see this.

I actually did test to see if inference worked in both directions, but the
FaCT++ reasoner gave an inconsistency error so I assumed inference didn't
work because I provided an individual that wasn't really equivalent and that
the individual must first meet the property constraint. I imagine I had made
a mistake somewhere else down the line because your situation below worked
wonderfully :)

> As a simple example, if you define a class
>   50-year-old  ==  Person and (hasValue age 50)

I wasn't sure if *age* should be an object or data property. So I tried
both: as a data property, Bill was inferred as a 50-year-old, where the
class 50-year-old has the equivalence class "Person and (age value 50)."
However, Fred was not inferred to have the data property of age being 50
(though Fred, of course was inferred to be a Person since 50-year-old is-a

If I treat age as being an object property: in my ontology I created the *
hasValue* object property for this, with the Range being "age some int." I
created a new class, *50YearOld* with equivalence class "Person and
(hasValue value 50)," where 50 is an individual that has age 50.
I added Jack as an individual to this class and Jack was inferred to have
the object property: hasValue 50. And that's what I've been searching for!
For anyone interested, I've attached the ontology I used to test Thomas's

> You can then make the following assertions:
>   Fred  type  50-year-old
>   Bill  type Person
>   Bill  age 50
> Bill will be recognized as belonging to the class "50-year-old".  Fred will
> have an inferred property value for "age" of 50.
> Where the difference becomes apparent and will diverge from what you might
> get from an object-oriented perspective is if you use some of the other
> restrictions.  Most interesting would be, for example the "allValuesFrom" or
> the "minCardinality" restrictions.

In Protege 4, the class expression editor doesn't support the keywords *
allValuesFrom* or *minCardinality*. I think I managed to try out using *
allValuesFrom* but I'm not sure how to express *minCardinality*.

> If you were to define
>   A  == B and (allValuesFrom P 50-year-old)

I used that class A has the equivalence class: B and (P only 50-year-old).
Indeed, *i-2* was inferred to be of type 50-year-old. It didn't gain the
data property age 50 but if I used the other *50YearOld* class in the
equivalence class (described above) then *i-2* did get the "hasValue 50"
object property inference as expected.

> and then assert
>   i-1  type  A
>   i-1  P  i-2
> then the inference engine will conclude that i-2 must be of type
> 50-year-old, and that information will be available for further reasoning.
>  In particular, the reasoner will figure out that the age of i-2 must be 50.
> Instead, if you were to define
>   X = Y and (minCardinality P 3)

I suspected that the keyword *only* could mean *allValuesFrom*, and it
seemed to work as such. I suspect that the keyword *min* means *
minCardinality* but I'm unable to construct a valid expression in Protege.
I'd love to know how it's done :D

> and then assert
>  i-3 type X
> then the reasoner will conclude that i-3 has at least 3 values for property
> P, but it won't be able to tell you which ones they are.  This is where open
> world reasoning comes into play.  Even though there are 3 fillers, they
> don't have to be specifically identified.  OWL is quite able to reason with
> just this partial information.

I'm sure it took a bit of time for this reply and I really do appreciate the
effort. I've been thinking about this for a while and I finally have a way
forward... so thank you ever so much!

Kind regards

PS I know the ontology I created isn't particularly user friendly with the
naming, sorry.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <>
-------------- next part --------------
A non-text attachment was scrubbed...
Name: Test.owl
Type: application/rdf+xml
Size: 928 bytes
Desc: not available
URL: <>

More information about the protege-owl mailing list