Re: Negation of object properties (class NotEdgyShape should be equal to RoundShape)

Change the range of hasShape to “Shape," instead of "hasShape exactly 1 Shape”.

Also change the definition of NotEdgyShape to "not (hasShape value Edgy) and hasShape min 1”.

Then NotEdgyShape will be equivalent to RoundShape.

Your definition of NotEdgyShape allows for something has has no shape, therefore RoundShape is only a subclass of NotEdgyShape. A property is functional only means that it can have at most one value.

"not {Edgy}” and "not (hasShape value Edgy}” are not equivalent not because of the open-world assumption, but because they are different types of entities. One is about types of shapes and another is about things that may have shape. Same idea
as the color Red not being the same as a shirt that has Red color.

Assume I have a simple class Shape which is equivalent to {Edgy, Round}, where Edgy and Round are defined as different individuals.

RoundShape is defined as equivalent to "hasShape value Round".
NotEdgyShape is defined as equivalent to "not (hasShape value Edgy)"

hasShape is an object property with a range defined as "hasShape exactly 1 Shape". It is also defined as "functional".

The inferred class hierarchy is close, but not exactly what I want:

NotEdgyShape is a superclass of RoundShape, while I would like them to be equivalent.

What else do I need to define to enforce this in the ontology?

A related question is, why are these two classes not equivalent?

"not {Edgy}"
and
"not (hasShape value Edgy}

I guess it has something to do with the open world assumption, but I can't figure out how to add the necessary constraints.

I basically want to defined an enumeration {Edgy, Round} which is closed for changes, so that I can do normal set operations and have classes that represent certain subsets.

Best regards,
Peter

P.S.: The last post with attachment did not go through, so I assume it got marked as spam.
_______________________________________________
protege-user mailing list[hidden email]
https://mailman.stanford.edu/mailman/listinfo/protege-user

Re: Negation of object properties (class NotEdgyShape should be equal to RoundShape)

Hi,

> Change the range of hasShape to “Shape," instead of "hasShape exactly
> 1" Shape”. Also change the definition of NotEdgyShape to "not
> (hasShape value Edgy) and hasShape min 1”.
>
> Then NotEdgyShape will be equivalent to RoundShape.
Thanks, that worked!
The classes are now equivalent.

An individual SomeRoundObject that has a negative object property
assertion of "hasShape Edgy" will still not be classified as RoundShape.
Is there a way around this?

> A property is functional only means that it can have at most one
> value.
So the difference between "hasShape" with a range of simply "Shape"
and a range of "hasShape exactly 1 Shape" would be that the former can
be 1 or 0 Shapes and the latter exactly 1, right?

Why would I want to allow 0 shapes, when we try to exclude that case
with "hasShape min 1" in NotEdgyShape? And why does "hasShape exactly 1
Shape" not make the classes equivalent, as well?

Only setting the range of hasShape to "Shape" works, though I would
assume that this is equivalent to either of these two object restrictions:
"hasShape min 1 Shape" or "hasShape min 0 Shape".
How would a range of "Shape" be expressed as an object restriction?
Is there a program/tool that can translate between those representations?

Re: Negation of object properties (class NotEdgyShape should be equal to RoundShape)

> On Aug 9, 2018, at 12:42 PM, Peter Teloff <[hidden email]> wrote:
>
> Hi,
>
>> Change the range of hasShape to “Shape," instead of "hasShape exactly
>> 1" Shape”. Also change the definition of NotEdgyShape to "not
>> (hasShape value Edgy) and hasShape min 1”.
>> Then NotEdgyShape will be equivalent to RoundShape.
> Thanks, that worked!
> The classes are now equivalent.
>
> An individual SomeRoundObject that has a negative object property assertion of "hasShape Edgy" will still not be classified as RoundShape.
> Is there a way around this?

I don’t know what you mean by "individual SomeRoundObject that has a negative object property assertion of "hasShape Edgy””.

>
>> A property is functional only means that it can have at most one value.
> So the difference between "hasShape" with a range of simply "Shape"
> and a range of "hasShape exactly 1 Shape" would be that the former can be 1 or 0 Shapes and the latter exactly 1, right?

No. "hasShape exactly 1 Shape” is the set of things that that has exactly one shape. A ball has the “round” shape. Your range axiom says that a balloon may hasShape a ball. That doesn’t make sense as a ball is not a shape.

>
> Why would I want to allow 0 shapes, when we try to exclude that case with "hasShape min 1" in NotEdgyShape? And why does "hasShape exactly 1 Shape" not make the classes equivalent, as well?

I could have used “hasShape exactly 1”. That is not the issue. In any case hasShape being functional and NotEdgyShape being equivalents to “not (hasShape value Edgy) and hasShape min 1” implies that NotEdgyShape is equivalent to “not (hasShape value Edgy) and hasShape exactly 1”

>
> Only setting the range of hasShape to "Shape" works, though I would assume that this is equivalent to either of these two object restrictions:
> "hasShape min 1 Shape" or "hasShape min 0 Shape”.

Re: Negation of object properties (class NotEdgyShape should be equal to RoundShape)

>> An individual SomeRoundObject that has a negative object property
>> assertion of "hasShape Edgy" will still not be classified as
>> RoundShape. Is there a way around this?
>
> I don’t know what you mean by "individual SomeRoundObject that has a
> negative object property assertion of "hasShape Edgy””.
I create individuals based on sensor data and feature recognition. So
for example I have one individual that has a property assertion of
"hasShape Round" if a round feature detector recognized such a shape in
the camera image. That will allow to categorized it as a RoundShape.

But I may as well create individuals where a feature detector just
determines it is not Edgy, but not the type of shape it actually is.
In that case the individuals would have a *negative* object property
assertion of "hasShape Edgy".
Through the axioms in the ontology I'd like to deduce what it could be,
by reasoning through negation. In this simple example, since Edgy and
Round are the only option: not Edgy = Round.

So for the classes NotEdgyShape and RoundShape equivalence works, but
for individuals defined as above, with a negative object property
assertion of "hasShape Edgy”, the classification as RoundShape (or
NotEdgyShape) will not happen.

>> How would a range of "Shape" be expressed as an object
>> restriction?
>
> Why do you want to do that?

To better understand what it means to have a range of "Shape" for
hasShape vs. to have a range of "hasShape min 1" or similar.
Basically a set theoretic reduction of these expressions, so you can
clearly see what happens, by enumerating elements or looking at the
resulting sets, or similar.
I'd like a clear definition.
_______________________________________________
protege-user mailing list
[hidden email]https://mailman.stanford.edu/mailman/listinfo/protege-user

Re: Negation of object properties (class NotEdgyShape should be equal to RoundShape)

An individual SomeRoundObject that has a negative object property
assertion of "hasShape Edgy" will still not be classified as
RoundShape. Is there a way around this?

I don’t know what you mean by "individual SomeRoundObject that has a
negative object property assertion of "hasShape Edgy””.

I create individuals based on sensor data and feature recognition. So
for example I have one individual that has a property assertion of
"hasShape Round", such that it will get categorized as RoundShape.
But I may as well like to create individuals where I say it is not Edgy,
and then deduce what it should be, by reasoning through negation. In this simple case, since Edgy and Round are the only option: ot
Edgy => Round. That's why some individuals may have the *negative*
property assertion "hasShape Edgy”.

The question is how you formally express "*negative* property assertion "hasShape Edgy”. You can say an individual is a member of (not (hasShape value Edgy)).

How would a range of "Shape" be expressed as an object
restriction?

Why do you want to do that?

To better understand what it means to have a range of "Shape" for
hasShape vs. to have a range of "hasShape min 1" or similar.
Basically a set theoretic reduction of these expressions, so you can clearly see what happens, by enumerating elements or looking at the resulting sets, or similar.
I'd like a clear definition.

To express the range of hasShape as a class expression involving a property requires that you find a property P such that Round and Edgy are individuals of (P min 1). I have no idea what such a property may be. P is certainly not hasShape.

Re: Negation of object properties (class NotEdgyShape should be equal to RoundShape)

Thanks. After working with OWL and Protege for all these years, I never noticed the negative object property assertion. Good to learn about it.

It’s not sufficient to say with negation property assertion that SomeOtherRoundObject does not hasShape Edgy for it to be classified as NotEdyShapeObject or RoundShapeObject. (I renamed your classes to clarify that they are collection of things
that hasShape, instead of shapes themselves.) The individual may not have any shape. You need to add that it belongs to a class of things that have at least one shape. If you add that SomeOtherRoundObject is a member of (hasShape min 1), then it will be classified
as a RoundShapeObject.

But as mentioned earlier it does not work as I'd like.
_______________________________________________
protege-user mailing list[hidden email]
https://mailman.stanford.edu/mailman/listinfo/protege-user

Re: Negation of object properties (class NotEdgyShape should be equal to RoundShape)

Negative property assertions have been introduced in OWL 2 but
used quite rarely.

Just my two cents:

In general, the key point here is that cardinality restrictions
in OWL will suffer from

i) the Open World Assumption and
ii) **no** Unique Names Assumption

in OWL.

Moreover, functional object properties do only work as constraint
once the individuals are explicitly declared as being different
from each other. Otherwise, having multiple different objects for
a functional property just means that the objects are the same.

Lorenz

On 10.08.2018 07:57, Samson Tu wrote:

Thanks. After working with OWL and Protege for all these years, I
never noticed the negative object property assertion. Good to
learn about it.

It’s not sufficient to say with negation property
assertion that SomeOtherRoundObject does not hasShape Edgy for
it to be classified as NotEdyShapeObject or RoundShapeObject. (I
renamed your classes to clarify that they are collection of
things that hasShape, instead of shapes themselves.) The
individual may not have any shape. You need to add that it
belongs to a class of things that have at least one shape. If
you add that SomeOtherRoundObject is a member of (hasShape min
1), then it will be classified as a RoundShapeObject.