Created on March 12, 2013, 12:29 a.m. by Hevok & updated by Hevok on May 2, 2013, 5:33 p.m.

There can be Subproperties of Properties. So Property Hierarchies can be defined which is simply be done via `rdfs:subPropertyOf`

. We can reuse the already existing `rdfs:subPropertyOf`

Property to define an OWL Subproperty. However, in OWL one can define more. For instance one can state that one Property is the inverse of another Property. For example `hasChild`

is the inverse Property of `hasParent`

. One can define this via `owl:inverseOf`

. One can also define when two Properties are identical with the `owl:equivalent`

Property.

For example, `is made of`

is an ObjectProperty that is Subproperty of `consists of`

. On the other hand, one can say the Property, `is processed to`

is the inverse of `is made of`

. In Description Logics the corresponding inverse is defined simply with a minus sign.

- Properties Hierarchies can be created via Specializations:
`rdfs:subPropertyOf`

- Inverse Properties are defined via
`owl:inverseOf`

- Identical Properties are defined via
`owl:equivalentProperty`

`:isMadeOf a owl:ObjectProperty ; rdfs:subPropertyOf :consistsOf . :isProcessedTo a owl:ObjectProperty ; owl:inveraseOf :isMadeOf .`

DL:

```
isMadeOf ⊑ consistsOf
osProcessedTo- ≡ isMadeOf
```

OWL allows to define Transitive Properties. For example, for the Property `is part of`

if it is defined as Transitive Property, one can state that if a is part of b and b `is part of`

c, then a should also `be part of`

c.

One can also define a symmetric Property, such as that a `is neighbor of`

b so that is holds that b also `is neighbor of`

a.

On the other hand one can define functional Properties. For example `has mother`

is a functional property and a has mother b and a is also mother c, then it must also hold that b is equivalent, i.e. the same Individual as c. If one wants to define a Property that is a functional Property then one simply needs to state the the Property Class belongs to the Class `owl:FunctionalProperty`

.

The other way around one can define inverse Functional Properties where one simple turns around the Property and states for instance b `is mother of`

a and c `is mother of`

a, then b and c must be the same.

`owl:TransitiveProperty`

- E.g. if
`isPartOf(a,b)`

and`isPartOf(b,c)`

then it holds that`isPartOf(a,c)`

`owl:SymmetricProperty`

- E.g.: if
`isNeighborOf(a,b)`

, then it holds that`isNeighborOf(b,a)`

`owl:FunctionalProperty`

- E.g. if
`hasMother(a,b)`

and ``hasMother(a,c), then it holds that b = c `owl:InverseFunctionalProperty`

- E.g. If
`isMotherOf(b,a)` and is`

MotherOf(c,a)`` then it holds that b = c

One can also define that a Property of the Class `AsymmetricProperty`

. For an `AsymmetricProperty`

it holds if two Individuals are connected via an `AsymmtricProperty`

, they are not connected the other way around. For example defining a Property like `isLeftOf`

and `is left of`

is a Property of a and b, then of course b is not left of a. Thus it is not possible and hence is an asymmetric Property.

Then on can also define a Reflexive Property which means that in a Reflexive Property each Individual where the Property is applied the result is connected with itself. For example each single Individual is related with itself. This s possible because it is reflexive, which means an Individual that is part of or connected via this Property which is of type Reflexive Property will always be connected with this Property with itself.

Of course one can also define an `Irreflexive Property`

where the opposite holds which means when one defines for example x is Parent of y, then x can never be the same as y. In Description Logics one defines this as Role R which is when applied on self not allowed.

- Asymmetric Properties via
`owl:AsymmetricProperty`

- E.g.: if it holds that
`isLeftOf(a,b)`

then it is not possible that also`isLeftOf(b,a)`

- E.g.: if it holds that
- Reflexive Properties via
`owl:ReflexsiveProperty`

- E.g.: isRelatedTo(x,x)

- Irreflexive Properties via
`owl:IrreflexsiveProperty`

- E.g.: if
``isParentOf(x,y)`

then x ≠ y T ⊑ ¬∃R.Self

- E.g.: if

You can never be your own parent.

## Comment on This Data Unit