Change - Property Relationship

Created on March 12, 2013, 12:29 a.m. by Hevok & updated on March 30, 2013, 11:01 a.m. by Hevok

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)</span><ins style="background:#e6ffe6;"> 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 &para;<br>* **owl:InverseFunctionalProperty** &para;<br> - E.g. IfisMotherOf(b,a)and is ``MotherOf(c,a)`` then it holds that b = c &para;<br> &para;<br>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. &para;<br> &para;<br>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. &para;<br> &para;<br>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. &para;<br> &para;<br>* Asymmetric Properties via **``owl:AsymmetricProperty``** &para;<br> - E.g.: if it holds that ``isLeftOf(a,b)`` then it is not possible that also ``isLeftOf(b,a)`` &para;<br>* Reflexive Properties via **``owl:ReflexsiveProperty``** &para;<br> - E.g.: isRelatedTo(x,x) &para;<br>* Irreflexive Properties via ``owl:IrreflexsiveProperty`` &para;<br> - E.g.: if ``isParentOf(x,y) then x ≠ y ¶
T ⊑ ¬∃R.Self ¶

You can never be your own parent.


Comment: Updated entry

Comment on This Data Unit