Entailment
Entailment operations determine the truth of the data you have.
owl:AllDifferent
Available in next release.
owl:distinctMembers
Available in next release.
owl:Class
All Owl types share this type.
owl:FunctionalProperty
The owl:FunctionalProperty declaration specifies that a predicate is functional. That is, there is only one possible object when a predicate is used on a given subject. If the predicate is used to refer to the subject again, then the object in the new statement must be the same object as was in the previous statement.
An example of a functional predicate is has-Father. For any given individual, there can only be one father.
The camera ontology declares the following:
<owl:ObjectProperty rdf:ID="viewFinder">
<rdf:type rdf:resource="&owl;FunctionalProperty"/>
<rdfs:domain rdf:resource="#Camera"/>
<rdfs:range rdf:resource="#Viewer"/>
</owl:ObjectProperty>
This means that the predicate viewFinder is a functional property. This statement declares that cameras have view finders of type Viewer, and that each camera can only have a single viewer.
An example of the use of this functional property is shown here:
<rdf:Description rdf:about="#duplicateWindow">
<rdf:type rdf:resource="#Camera"/>
<rdf:type rdf:resource="#Digital"/>
<body>
<Body/>
</body>
<lens>
<Lens/>
</lens>
<viewFinder rdf:resource="#ThroughTheLens"/>
<viewFinder>
<rdf:Description/>
</viewFinder>
</rdf:Description>
This declares a camera with two view finders. The first view finder is the object ThroughTheLens, while the second one is a blank node. That is, an unidentified node. Because viewFinder is functional, the second view finder must be the same object as the first.
Inferring that these nodes are equivalent can be done using the following iTQL:
select $object1 <owl:sameAs> $object2
from <rmi://mysite.com/server1#camera>
where $predicate <rdf:type> <owl:FunctionalProperty>
and $subject $predicate $object1
and $subject $predicate $object2;
The query finds all predicates of type owl:FunctionalProperty. It then finds all statements that use one subject and this predicate, and puts the objects into the variables $object1 and $object2. Unfortunately, iTQL has no way of preventing $object1 and $object2 from equaling each other, but it is not strictly invalid to find these statements. The result of the query is a triple the states that $object1 and $object2 are the same individuals.
The query returns the following:
[ http://www.xfront.com/owl/ontologies/camera/#ThroughTheLens, http://www.w3.org/2002/07/owl#sameAs,
http://www.xfront.com/owl/ontologies/camera/#ThroughTheLens ]
[ _node534, http://www.w3.org/2002/07/owl#sameAs, http://www.xfront.com/owl/ontologies/camera/#ThroughTheLens ]
[ http://www.xfront.com/owl/ontologies/camera/#ThroughTheLens, http://www.w3.org/2002/07/owl#sameAs, _node534 ]
[ _node534, http://www.w3.org/2002/07/owl#sameAs, _node534 ]
This shows that ThroughTheLens and the blank node are the same object. It also reports that the blank node is the same as itself and that ThroughTheLens is the same as itself. While these statements are redundant, they are still correct.
If the redundant statements are acceptable, this query can be used in an insert command to feed the inferred statements back into a model. Otherwise, the non-redundant data and be programmatically extracted and inserted.
owl:sameAs
The owl:sameAs declaration specifies that an instance of a type is the same instance as another object. For example, in a system where President of the United States (1992-2000) and Bill Clinton are declared separately, owl:sameAs declares that one is the same as the other.
The camera ontology declares the following:
<owl:Class rdf:ID="Modern">
<owl:sameAs rdf:resource="#Digital"/>
</owl:Class>
<owl:Class rdf:ID="badClass">
<owl:sameAs rdf:resource="#part"/>
</owl:Class>
<owl:ObjectProperty rdf:ID="piece">
<owl:sameAs rdf:resource="#part"/>
</owl:ObjectProperty>
<owl:ObjectProperty rdf:ID="badProperty">
<owl:sameAs rdf:resource="#CarryStrap"/>
</owl:ObjectProperty>
This describes a Modern class and a piece property that are the same as the Digital class and part property, respectively. It also describes badClass and badProperty, which are erroneously the same as a class and a property respectively. These errors are highlighted in the Inconsistency section, later in the document.
In the camera data there are the following three cameras:
<rdf:Description rdf:about="#SinarM">
<rdf:type rdf:resource="#Digital"/>
<rdf:type rdf:resource="#Simple-Large-Format"/>
<body>
<BodyWithNonAdjustableShutterSpeed about="#SinarMbody">
<matchingPart>
<Lens rdf:about="#SinaronDigital4.5/45DB"/>
</matchingPart>
</BodyWithNonAdjustableShutterSpeed>
</body>
<lens>
<Lens rdf:about="#SinaronDigital4.5/45DB">
<aperture>4.5</aperture>
<focal-length>45mm</focal-length> </Lens>
</lens>
</rdf:Description>
<rdf:Description rdf:about="#SinarMedium">
<owl:sameAs rdf:resource="#SinarM"/>
<lens>
<Lens rdf:about="#Sinaron-SD">
<owl:sameAs rdf:resource="#SinaronDigital4.5/45DB"/>
</Lens>
</lens>
</rdf:Description>
<rdf:Description rdf:about="#MediumSinar">
<rdf:type rdf:resource="#Digital"/>
<owl:sameAs rdf:resource="#SinarMedium"/>
</rdf:Description>
<rdf:Description rdf:about="#SameCamera">
<rdf:type rdf:resource="#Digital"/>
<owl:sameAs rdf:resource="#DifferentCamera"/>
</rdf:Description>
<rdf:Description rdf:about="#DifferentCamera">
<rdf:type rdf:resource="#Digital"/>
<owl:differentFrom rdf:resource="#SameCamera"/>
</rdf:Description>
<rdf:Description rdf:about="#badClassCamera">
<rdf:type rdf:resource="#Digital"/>
<owl:sameAs rdf:resource="#Body"/>
</rdf:Description>
<rdf:Description rdf:about="#badPropertyCamera">
<rdf:type rdf:resource="#Digital"/>
<owl:sameAs rdf:resource="#lens"/>
</rdf:Description>
This declares a camera SinarM with a body and a lens. It also declares a camera SinarMedium with a lens Sinaron-SD. SinarMedium is the same as SinarM, and the Sinaron-SD lens is the same as the lens for SinarM. Finally, there is a camera MediumSinar, which is the same as SinarMedium.
The next two cameras are SameCamera and BadCamera. These erroneously refer to each other as being the same and different. This is checked for, along with the ontology, later on in the Inconsistencies section.
The last two cameras declared are badClassCamera and badPropertyCamera. These declare themselves to be the same as a class (Body) and a property (lens), which is an error. This is also checked for in the Inconsistencies section.
The owl:sameAs statements are found directly with the following iTQL command:
select $x <owl:sameAs> $y
from <rmi://mysite.com/server1#camera>
where $x <owl:sameAs> $y;
This returns:
[ http://www.xfront.com/owl/ontologies/camera/#Modern, http://www.w3.org/2002/07/owl#sameAs,
http://www.xfront.com/owl/ontologies/camera/#Digital ]
[ http://www.xfront.com/owl/ontologies/camera/#badProperty, http://www.w3.org/2002/07/owl#sameAs,
http://www.xfront.com/owl/ontologies/camera/#CarryStrap ]
[ http://www.xfront.com/owl/ontologies/camera/#badClass, http://www.w3.org/2002/07/owl#sameAs,
http://www.xfront.com/owl/ontologies/camera/#part ]
[ http://www.xfront.com/owl/ontologies/camera/#piece, http://www.w3.org/2002/07/owl#sameAs,
http://www.xfront.com/owl/ontologies/camera/#part ]
[ http://www.xfront.com/owl/ontologies/camera/#badClassCamera, http://www.w3.org/2002/07/owl#sameAs,
http://www.xfront.com/owl/ontologies/camera/#Body ]
[ http://www.xfront.com/owl/ontologies/camera/#badPropertyCamera, http://www.w3.org/2002/07/owl#sameAs,
http://www.xfront.com/owl/ontologies/camera/#lens ]
[ http://www.xfront.com/owl/ontologies/camera/#SameCamera, http://www.w3.org/2002/07/owl#sameAs,
http://www.xfront.com/owl/ontologies/camera/#DifferentCamera ]
[ http://www.xfront.com/owl/ontologies/camera/#MediumSinar, http://www.w3.org/2002/07/owl#sameAs,
http://www.xfront.com/owl/ontologies/camera/#SinarMedium ]
[ http://www.xfront.com/owl/ontologies/camera/#Sinaron-SD, http://www.w3.org/2002/07/owl#sameAs,
http://www.xfront.com/owl/ontologies/camera/#SinaronDigital4.5/45DB ]
[ http://www.xfront.com/owl/ontologies/camera/#SinarMedium, http://www.w3.org/2002/07/owl#sameAs,
http://www.xfront.com/owl/ontologies/camera/#SinarM ]
Transitivity
owl:sameAs is a transitive predicate. For example, because MediumSinar is the same as SinarMedium, and SinarMedium is the same as SinarM, it is valid to say that MediumSinar is the same as SinarM.
Inferred statements based on the transitivity of owl:sameAs are created with the following iTQL command:
select $x <owl:sameAs> $z
from <rmi://mysite.com/server1#camera>
where trans($x <owl:sameAs> $z);
The query returns the following:
[ http://www.xfront.com/owl/ontologies/camera/#MediumSinar, http://www.w3.org/2002/07/owl#sameAs,
http://www.xfront.com/owl/ontologies/camera/#SinarM ]
Reflexivity
owl:sameAs is also a reflexive predicate. That is, any instance is the same as itself. For example, it is valid to say X <owl:sameAs> X for any value of X that is an instance.
Statements of this form are generated with the following iTQL:
select $x <owl:sameAs> $x
from <rmi://mysite.com/server1#camera>
where $x <rdf:type> $c
and $c <rdf:type> <owl:Class>;
The query returns a statement for every instance in the system. The results are too large to show here, but an example row is as follows:
[ http://www.xfront.com/owl/ontologies/camera/#SinarF2, http://www.w3.org/2002/07/owl#sameAs,
http://www.xfront.com/owl/ontologies/camera/#SinarF2 ]
Symmetry
owl:sameAs is also a symmetric predicate. That is, if one item is declared the same as a second item, then the second item must also be the same as the first item.
New statements to this effect are generated with the following iTQL:
select $x <owl:sameAs> $y
from <rmi://mysite.com/server1#camera>
where $y <owl:sameAs> $x;
The query returns the following:
[ http://www.xfront.com/owl/ontologies/camera/#Digital, http://www.w3.org/2002/07/owl#sameAs,
http://www.xfront.com/owl/ontologies/camera/#Modern ]
[ http://www.xfront.com/owl/ontologies/camera/#CarryStrap, http://www.w3.org/2002/07/owl#sameAs,
http://www.xfront.com/owl/ontologies/camera/#badProperty ]
[ http://www.xfront.com/owl/ontologies/camera/#part, http://www.w3.org/2002/07/owl#sameAs,
http://www.xfront.com/owl/ontologies/camera/#badClass ]
[ http://www.xfront.com/owl/ontologies/camera/#part, http://www.w3.org/2002/07/owl#sameAs,
http://www.xfront.com/owl/ontologies/camera/#piece ]
[ http://www.xfront.com/owl/ontologies/camera/#Body, http://www.w3.org/2002/07/owl#sameAs,
http://www.xfront.com/owl/ontologies/camera/#badClassCamera ]
[ http://www.xfront.com/owl/ontologies/camera/#lens, http://www.w3.org/2002/07/owl#sameAs,
http://www.xfront.com/owl/ontologies/camera/#badPropertyCamera ]
[ http://www.xfront.com/owl/ontologies/camera/#DifferentCamera, http://www.w3.org/2002/07/owl#sameAs,
http://www.xfront.com/owl/ontologies/camera/#SameCamera ]
[ http://www.xfront.com/owl/ontologies/camera/#SinarMedium, http://www.w3.org/2002/07/owl#sameAs,
http://www.xfront.com/owl/ontologies/camera/#MediumSinar ]
[ http://www.xfront.com/owl/ontologies/camera/#SinaronDigital4.5/45DB, http://www.w3.org/2002/07/owl#sameAs,
http://www.xfront.com/owl/ontologies/camera/#Sinaron-SD ]
[ http://www.xfront.com/owl/ontologies/camera/#SinarM, http://www.w3.org/2002/07/owl#sameAs,
http://www.xfront.com/owl/ontologies/camera/#SinarMedium ]
Another effect of this symmetry is that all properties applying to an instance also apply to everything that is the same as that instance. These statements are inferred with the following iTQL:
select $y $p $z
from <rmi://mysite.com/server1#camera>
where $x $p $z
and ($x <owl:sameAs> $y
or $y <owl:sameAs> $x);
The or statement at the end of the where clause finds owl:sameAs statements that point both ways. If the inferred statements from the previous symmetry query have already been inserted, then it is not necessary to have both options here.
The query generates 45 new statements, 5 of which are as follows:
[ http://www.xfront.com/owl/ontologies/camera/#Digital, http://www.w3.org/1999/02/22-rdf-syntax-ns#type,
http://www.w3.org/2002/07/owl#Class ]
[ http://www.xfront.com/owl/ontologies/camera/#Modern, http://www.w3.org/2000/01/rdf-schema#subClassOf,
http://www.xfront.com/owl/ontologies/camera/#Camera ]
[ http://www.xfront.com/owl/ontologies/camera/#badClass, http://www.w3.org/2000/01/rdf-schema#range,
http://www.xfront.com/owl/ontologies/camera/#PurchaseableItem ]
[ http://www.xfront.com/owl/ontologies/camera/#badPropertyCamera, http://www.w3.org/2000/01/rdf-schema#range,
http://www.xfront.com/owl/ontologies/camera/#Lens ]
[ http://www.xfront.com/owl/ontologies/camera/#badPropertyCamera, http://www.w3.org/2000/01/rdf-schema#domain,
http://www.xfront.com/owl/ontologies/camera/#Camera ]
Similarly, if X is the same as Y, then any statements that refer to X as a property need to be duplicated to refer to Y as well, using the following iTQL:
select $z $p $x
from <rmi://mysite.com/server1#camera>
where $z $p $y
and ($x <owl:sameAs> $y
or $y <owl:sameAs> $x);
Again, the or part of the query can be skipped if the symmetry statements have already been inserted.
Class Equivalence
owl:sameAs can also be used to indicate that two classes are equivalent. Since owl:equivalentClass does this as well, then these predicates can be inferred from owl:sameAs statements, with the following iTQL:
select $x <owl:equivalentClass> $y
from <rmi://mysite.com/server1#camera>
where ($x <owl:sameAs> $y
or $y <owl:sameAs> $x)
and ($x <rdf:type> <owl:Class>
or $y <rdf:type> <owl:Class>);
The query returns the following:
[ http://www.xfront.com/owl/ontologies/camera/#Modern, http://www.w3.org/2002/07/owl#equivalentClass,
http://www.xfront.com/owl/ontologies/camera/#Digital ]
[ http://www.xfront.com/owl/ontologies/camera/#Digital, http://www.w3.org/2002/07/owl#equivalentClass,
http://www.xfront.com/owl/ontologies/camera/#Modern ]
[ http://www.xfront.com/owl/ontologies/camera/#badProperty, http://www.w3.org/2002/07/owl#equivalentClass,
http://www.xfront.com/owl/ontologies/camera/#CarryStrap ]
[ http://www.xfront.com/owl/ontologies/camera/#part, http://www.w3.org/2002/07/owl#equivalentClass,
http://www.xfront.com/owl/ontologies/camera/#badClass ]
[ http://www.xfront.com/owl/ontologies/camera/#badClass, http://www.w3.org/2002/07/owl#equivalentClass,
http://www.xfront.com/owl/ontologies/camera/#part ]
[ http://www.xfront.com/owl/ontologies/camera/#badClassCamera, http://www.w3.org/2002/07/owl#equivalentClass,
http://www.xfront.com/owl/ontologies/camera/#Body ]
[ http://www.xfront.com/owl/ontologies/camera/#Body, http://www.w3.org/2002/07/owl#equivalentClass,
http://www.xfront.com/owl/ontologies/camera/#badClassCamera ]
[ http://www.xfront.com/owl/ontologies/camera/#CarryStrap, http://www.w3.org/2002/07/owl#equivalentClass,
http://www.xfront.com/owl/ontologies/camera/#badProperty ]
Note - The inclusion of badProperty in the result is detected in the inconsistency checks later.
Property Equivalence
Like class equivalence, property equivalence is described by both owl:sameAs and by owl:equivalentProperty. Because there are seven possible declaration types that refer to properties, the iTQL for the inferred statements is longer than usual:
select $x <owl:equivalentProperty> $y
from <rmi://mysite.com/server1#camera>
where ($x <owl:sameAs> $y
or $y <owl:sameAs> $x)
and ($x <rdf:type> <rdf:Property>
or $y <rdf:type> <rdf:Property>
or $x <rdf:type> <owl:ObjectProperty>
or $y <rdf:type> <owl:ObjectProperty>
or $x <rdf:type> <owl:DatatypeProperty>
or $y <rdf:type> <owl:DatatypeProperty>
or $x <rdf:type> <owl:FunctionalProperty>
or $y <rdf:type> <owl:FunctionalProperty>
or $x <rdf:type> <owl:InverseFunctionalProperty>
or $y <rdf:type> <owl:InverseFunctionalProperty>
or $x <rdf:type> <owl:TransitiveProperty>
or $y <rdf:type> <owl:TransitiveProperty>
or $x <rdf:type> <owl:SymmetricProperty>
or $y <rdf:type> <owl:SymmetricProperty>);
The query returns the following:
[ http://www.xfront.com/owl/ontologies/camera/#CarryStrap, http://www.w3.org/2002/07/owl#equivalentProperty,
http://www.xfront.com/owl/ontologies/camera/#badProperty ]
[ http://www.xfront.com/owl/ontologies/camera/#badClass, http://www.w3.org/2002/07/owl#equivalentProperty,
http://www.xfront.com/owl/ontologies/camera/#part ]
[ http://www.xfront.com/owl/ontologies/camera/#badPropertyCamera, http://www.w3.org/2002/07/owl#equivalentProperty,
http://www.xfront.com/owl/ontologies/camera/#lens ]
[ http://www.xfront.com/owl/ontologies/camera/#part, http://www.w3.org/2002/07/owl#equivalentProperty,
http://www.xfront.com/owl/ontologies/camera/#badClass ]
[ http://www.xfront.com/owl/ontologies/camera/#part, http://www.w3.org/2002/07/owl#equivalentProperty,
http://www.xfront.com/owl/ontologies/camera/#piece ]
[ http://www.xfront.com/owl/ontologies/camera/#piece, http://www.w3.org/2002/07/owl#equivalentProperty,
http://www.xfront.com/owl/ontologies/camera/#part ]
[ http://www.xfront.com/owl/ontologies/camera/#lens, http://www.w3.org/2002/07/owl#equivalentProperty,
http://www.xfront.com/owl/ontologies/camera/#badPropertyCamera ]
[ http://www.xfront.com/owl/ontologies/camera/#badProperty, http://www.w3.org/2002/07/owl#equivalentProperty,
http://www.xfront.com/owl/ontologies/camera/#CarryStrap ]
Inconsistencies
There are four types of inconsistencies associated with owl:sameAs:
- Objects declaring themselves to be the same and different at the same time.
- An instance and a class declared to be the same.
- An instance and a property declared to be the same.
- A class and a property declared to be the same.
These are all illegal in OWL-Lite.
The first inconsistency (objects declaring themselves to be both the same and different at the same time) is checked for with the following iTQL:
select $x $y
from <rmi://mysite.com/server1#camera>
where ($x <owl:sameAs> $y
or $y <owl:sameAs> $x)
and ($x <owl:differentFrom> $y
or $y <owl:differentFrom> $x);
The query returns the following:
[ http://www.xfront.com/owl/ontologies/camera/#SameCamera, http://www.xfront.com/owl/ontologies/camera/#DifferentCamera ]
[ http://www.xfront.com/owl/ontologies/camera/#DifferentCamera, http://www.xfront.com/owl/ontologies/camera/#SameCamera ]
The data declares that SameCamera is the same as DifferentCamera, while at the same time declaring DifferentCamera is different from SameCamera.
The second inconsistency (an instance and a class declared to be the same) is checked for with the following:
select $x $y
from <rmi://mysite.com/server1#camera>
where $x <rdf:type> $c
and $c <rdf:type> <owl:Class>
and $y <rdf:type> <owl:Class>
and ($x <owl:sameAs> $y
or $y <owl:sameAs> $x);
The query returns the following:
[ http://www.xfront.com/owl/ontologies/camera/#badClassCamera, http://www.xfront.com/owl/ontologies/camera/#Body ]
This data is inconsistent because badClassCamera is an instance of the Digital class, Body is a class, and there is a statement declaring them to be the same as each other.
The third inconsistency (an instance and a property declared to be the same) needs a longer test, in order to find all the property types. The query is as follows:
select $x $y
from <rmi://mysite.com/server1#camera>
where $x <rdf:type> $c
and $c <rdf:type> <owl:Class>
and ($x <owl:sameAs> $y
or $y <owl:sameAs> $x)
and ($y <rdf:type> <rdf:Property>
or $y <rdf:type> <owl:ObjectProperty>
or $y <rdf:type> <owl:DatatypeProperty>
or $y <rdf:type> <owl:FunctionalProperty>
or $y <rdf:type> <owl:InverseFunctionalProperty>
or $y <rdf:type> <owl:TransitiveProperty>
or $y <rdf:type> <owl:SymmetricProperty>);
The query returns the following:
[ http://www.xfront.com/owl/ontologies/camera/#badPropertyCamera, http://www.xfront.com/owl/ontologies/camera/#lens ]
This data is inconsistent because badPropertyCamera is an instance of the Digital class, lens is a property, and there is a statement declaring them to be the same as each other.
The last inconsistency (a class and a property declared to be the same) is checked for with the following:
select $x $y
from <rmi://mysite.com/server1#camera>
where $x <rdf:type> <owl:Class>
and ($x <owl:sameAs> $y
or $y <owl:sameAs> $x)
and ($y <rdf:type> <rdf:Property>
or $y <rdf:type> <owl:ObjectProperty>
or $y <rdf:type> <owl:DatatypeProperty>
or $y <rdf:type> <owl:FunctionalProperty>
or $y <rdf:type> <owl:InverseFunctionalProperty>
or $y <rdf:type> <owl:TransitiveProperty>
or $y <rdf:type> <owl:SymmetricProperty>);
The query returns the following:
[ http://www.xfront.com/owl/ontologies/camera/#CarryStrap, http://www.xfront.com/owl/ontologies/camera/#badProperty ]
[ http://www.xfront.com/owl/ontologies/camera/#badClass, http://www.xfront.com/owl/ontologies/camera/#part ]
This shows that the:
badPropertyproperty is declared to be the same as theCarryStrapclassbadClassclass is declared to be the same as thepartproperty
Note on Consistency Checking and Inferences
Like all inconsistency checks, the only way to test every possible condition is to infer all possible statements first. Otherwise, non-obvious inconsistencies are not shown.
owl:InverseFunctionalProperty
The owl:InverseFunctionalProperty declaration specifies that a predicate is inverse functional. That is, there is only one possible subject when a predicate is used to refer to a given object. If the predicate is used to refer to the object again, then the subject in the new statement must be the same subject as was in the previous statement.
An example of a functional predicate is an e-mail address. While individuals can have several e-mail addresses, each individual e-mail address can only refer to a single person.
The camera ontology declares the following:
<owl:InverseFunctionalProperty rdf:ID="serial-id">
<rdfs:domain rdf:resource="#Body"/>
<rdfs:range rdf:resource="#SerialID"/>
</owl:InverseFunctionalProperty>
This means that the predicate serial-id is an inverse functional property. This statement declares that SerialID uniquely identify a Body.
An example of the use of this inverse functional property is shown here:
<rdf:Description rdf:about="#doubleSerial">
<rdf:type rdf:resource="#Digital"/>
<body>
<Body rdf:about="#sharedBody">
<serial-id>
<SerialID rdf:about="#3302656895">
<serialType>numeric</serialType>
<serialValue>3302656895</serialValue>
</SerialID>
</serial-id>
</Body>
</body>
<lens>
<Lens rdf:about="#Sinaron-S">
<focal-length>135mm</focal-length>
</Lens>
</lens>
</rdf:Description>
<rdf:Description rdf:about="#doubleSerial2">
<rdf:type rdf:resource="#Digital"/>
<body>
<Body>
<serial-id>
<SerialID rdf:about="#3302656895">
<serialType>numeric</serialType>
<serialValue>3302656895</serialValue>
</SerialID>
</serial-id>
</Body>
</body>
<lens>
<Lens rdf:about="#Sinaron-SW">
<focal-length>120mm</focal-length>
</Lens>
</lens>
</rdf:Description>
This declares two cameras with bodies that have the same serial ID. The first body has the name sharedBody. Because serial-id is inverse functional, the second camera body must be the same as the first.
Inferring that these bodies are the same can be done using the following iTQL:
select $subject1 <owl:sameAs> $subject2
from <rmi://mysite.com/server1#camera>
where $predicate <rdf:type> <owl:InverseFunctionalProperty>
and $subject1 $predicate $object
and $subject2 $predicate $object;
This query finds all predicates of type owl:InverseFunctionalProperty. It then finds all statements that use an object and this predicate, and puts the subjects into the variables $subject1 and $subject2. Unfortunately, iTQL has no way of preventing $subject1 and $subject2 from equaling each other, but it is not strictly invalid to find these statements. The result of the query is a triple that states that $subject1 and $subject2 are the same individuals.
The query returns the following:
[ _node249, http://www.w3.org/2002/07/owl#sameAs, _node249 ]
[ _node249, http://www.w3.org/2002/07/owl#sameAs, http://www.xfront.com/owl/ontologies/camera/#sharedBody ]
[ http://www.xfront.com/owl/ontologies/camera/#sharedBody, http://www.w3.org/2002/07/owl#sameAs, _node249 ]
[ http://www.xfront.com/owl/ontologies/camera/#sharedBody, http://www.w3.org/2002/07/owl#sameAs,
http://www.xfront.com/owl/ontologies/camera/#sharedBody ]
This shows that sharedBody and the blank node are the same object. It also reports that the blank node is the same as itself and that sharedBody is the same as itself. While these statements are redundant, they are still correct.
If the redundant statements are acceptable, then this query can be used in an insert command to feed the inferred statements back into a model. Otherwise, the non-redundant data and be programmatically extracted and inserted.
owl:differentFrom
The owl:differentFrom declaration specifies that a node is different from another node. It can be used on any kind of node, including classes, properties, and instance data. Nodes of dissimilar types are naturally different, so this predicate is guaranteed to be used consistently in these cases. Where owl:differentFrom is more useful, is for nodes of the same type, to make it absolutely clear that two nodes cannot be considered the same as each other.
The camera ontology declares the following:
<rdf:Description rdf:about="#SinarP2">
<rdf:type rdf:resource="#Simple-Large-Format"/>
<body>
<BodyWithNonAdjustableShutterSpeed/>
</body>
<lens>
<Lens rdf:about="#Sinaron-S">
<focal-length>135mm</focal-length>
</Lens>
</lens>
</rdf:Description>
<rdf:Description rdf:about="#SinarM">
<rdf:type rdf:resource="#Digital"/>
<owl:differentFrom rdf:resource="#SinarP2"/>
<rdf:type rdf:resource="#Simple-Large-Format"/>
<body>
<BodyWithNonAdjustableShutterSpeed about="#SinarMbody">
<matchingPart>
<Lens rdf:about="#SinaronDigital4.5/45DB"/>
</matchingPart>
</BodyWithNonAdjustableShutterSpeed>
</body>
<lens>
<Lens rdf:about="#SinaronDigital4.5/45DB">
<aperture>4.5</aperture>
<focal-length>45mm</focal-length>
</Lens>
</lens>
</rdf:Description>
<rdf:Description rdf:about="#SameCamera">
<rdf:type rdf:resource="#Digital"/>
<owl:sameAs rdf:resource="#DifferentCamera"/>
</rdf:Description>
<rdf:Description rdf:about="#DifferentCamera">
<rdf:type rdf:resource="#Digital"/>
<owl:differentFrom rdf:resource="#SameCamera"/>
</rdf:Description>
This describes two cameras, SinarP2 and SinarM. There is an explicit declaration in the definition of SinarM that says it is a different object from SinarP2.
There are also two cameras that are declared for consistency checking. SameCamera declares that it is the same as DifferentCamera, while DifferentCamera declares that it is different from SameCamera. These are inconsistent declarations.
Symmetry
owl:differentFrom is a symmetric predicate. That is, for every statement declaring that one object is different from another, you can infer a reversed statement. These statements are generated with the following iTQL:
select $x <owl:differentFrom> $y
from <rmi://mysite.com/server1#camera>
where $y <owl:differentFrom> $x;
The query returns the following:
[ http://www.xfront.com/owl/ontologies/camera/#SameCamera, http://www.w3.org/2002/07/owl#differentFrom,
http://www.xfront.com/owl/ontologies/camera/#DifferentCamera ]
[ http://www.xfront.com/owl/ontologies/camera/#SinarP2, http://www.w3.org/2002/07/owl#differentFrom,
http://www.xfront.com/owl/ontologies/camera/#SinarM ]
Inconsistencies
An object that is different from another object may not also be declared to be the same as the other object. The following query returns all objects that violate this rule:
select $x $y
from <rmi://mysite.com/server1#camera>
where ($x <owl:sameAs> $y
or $y <owl:sameAs> $x)
and ($x <owl:differentFrom> $y
or $y <owl:differentFrom> $x);
Because both owl:sameAs and owl:differentFrom are symmetric, it is necessary for this query to test for the use of the predicate in each direction. For this reason, conflicting objects show up twice, in reversed order from each other.
This query returns the following:
[ http://www.xfront.com/owl/ontologies/camera/#SameCamera, http://www.xfront.com/owl/ontologies/camera/#DifferentCamera ]
[ http://www.xfront.com/owl/ontologies/camera/#DifferentCamera, http://www.xfront.com/owl/ontologies/camera/#SameCamera ]
Since this checks both owl:sameAs and owl:differentFrom, the test is also shown in the Inconsistencies section for owl:sameAs.
owl:inverseOf
owl:inverseOf is a convenience used to declare reversed relationships. For example, a hasParent property has an inverse property of hasChild. In all cases, where a statement is made using one of these properties, a reversed statement can be made with the inverse property.
owl:inverseOf is a symmetric property. That is, since hasParent is the inverse of hasChild, then hasChild is the inverse of hasParent.
owl:inverseOf only applies to items of type owl:ObjectProperty.
The ontology describes the following:
<owl:InverseFunctionalProperty rdf:ID="serial-id">
<rdfs:domain rdf:resource="#Body"/>
<rdfs:range rdf:resource="#SerialID"/>
</owl:InverseFunctionalProperty>
<owl:FunctionalProperty rdf:ID="id-for">
<rdfs:domain rdf:resource="#SerialID"/>
<rdfs:range rdf:resource="#Body"/>
<owl:inverseOf rdf:resource="#serial-id"/>
</owl:FunctionalProperty>
This describes the serial-id property, which describes the relationship between a Body and a SerialID object. It also describes the id-for relationship, which is the inverse relationship between the two. Note that because serial-id is an owl:InverseFunctionalProperty, then id-for must necessarily be an owl:FunctionalProperty. That is, in both cases, a SerialID uniquely identifies a Body.
In the camera data there are the following two cameras:
<rdf:Description rdf:about="#doubleSerial">
<rdf:type rdf:resource="#Digital"/>
<body>
<Body rdf:about="#sharedBody">
<serial-id>
<SerialID rdf:about="#3302656895">
<serialType>numeric</serialType>
<serialValue>3302656895</serialValue>
</SerialID>
</serial-id>
</Body>
</body>
<lens>
<Lens rdf:about="#Sinaron-S">
<focal-length>135mm</focal-length>
</Lens>
</lens>
</rdf:Description>
<rdf:Description rdf:about="#doubleSerial2">
<rdf:type rdf:resource="#Digital"/>
<body>
<Body>
<serial-id>
<SerialID rdf:about="#3302656895">
<serialType>numeric</serialType>
<serialValue>3302656895</serialValue>
</SerialID>
</serial-id>
</Body>
</body>
<lens>
<Lens rdf:about="#Sinaron-SW">
<focal-length>120mm</focal-length>
</Lens>
</lens>
</rdf:Description>
This declares a camera called doubleSerial with an anonymous body, and a camera called doubleSerial2 with a body called 3302656895. These cameras are also described in the section for owl:InverseFunctionalProperty, where it is inferred that the two bodies must be the same object
The statements subject to inversion are found with:
select $x $p2 $y
from <rmi://mysite.com/server1#camera>
where $p1 <owl:inverseOf> $p2
and $x $p2 $y;
This returns:
[ http://www.xfront.com/owl/ontologies/camera/#sharedBody, http://www.xfront.com/owl/ontologies/camera/#serial-id,
http://www.xfront.com/owl/ontologies/camera/#3302656895 ]
[ _node157, http://www.xfront.com/owl/ontologies/camera/#serial-id,
http://www.xfront.com/owl/ontologies/camera/#3302656895 ]
This shows the sharedBody object and the anonymous body object both referring to their serialID.
The following generates the inverted statements:
select $y $p1 $x
from <rmi://mysite.com/server1#camera>
where $p1 <owl:inverseOf> $p2
and $x $p2 $y;
This returns:
[ http://www.xfront.com/owl/ontologies/camera/#3302656895, http://www.xfront.com/owl/ontologies/camera/#id-for,
http://www.xfront.com/owl/ontologies/camera/#sharedBody ]
[ http://www.xfront.com/owl/ontologies/camera/#3302656895, http://www.xfront.com/owl/ontologies/camera/#id-for,
_node157 ]
owl:SymmetricProperty
The owl:SymmetricProperty declaration specifies that a property or predicate is symmetric. That is, if one instance uses this predicate to refer to another instance, then it is valid for the second instance to use that predicate to refer back to the first. For example, has-friend is a symmetric predicate. If the statement Fred has-friend Barney is true, then we can infer that Barney has-friend Fred is also true. Since we know the second statement is true, even if it does not exist in the model, then this is an inferred statement.
The camera ontology declares the following:
<owl:SymmetricProperty rdf:ID="matchingPart">
<rdfs:domain rdf:resource="#PurchaseableItem"/>
<rdfs:range rdf:resource="#PurchaseableItem"/>
</owl:SymmetricProperty>
This means that the predicate matchingPart is a symmetric property. It is used for PurchaseableItems to refer to other PurchaseableItems. Note that for a symmetric property, the domain and range must necessarily be the same.
An example of the use of this symmetric property is as follows:
<rdf:Description rdf:about="&camera;SinarM">
<rdf:type rdf:resource="#Digital"/>
<rdf:type rdf:resource="#Simple-Large-Format"/>
<body>
<BodyWithNonAdjustableShutterSpeed about="SinarMbody">
<matchingPart>
<Lens rdf:about="SinaronDigital4.5/45DB"/>
</matchingPart>
</BodyWithNonAdjustableShutterSpeed>
</body>
<lens>
<Lens rdf:about="SinaronDigital4.5/45DB">
<aperture>4.5</aperture>
<focal-length>45mm</focal-length>
</Lens>
</lens>
</rdf:Description>
This declares a camera with a body called SinarMbody and a lens called SinaronDigital4.5/45DB. The SinarMbody instance declares that it is a matchingPart for SinaronDigital4.5/45DB. Since matchingPart is symmetric, then this means that SinaronDigital4.5/45DB is also a matchingPart for SinarMbody.
Valid inferences like this can be found using the following iTQL:
select $subject $predicate $object
from <rmi://mysite.com/server1#camera>
where $predicate <rdf:type> <owl:SymmetricProperty>
and $object $predicate $subject;
This finds all the predicates declared to be symmetric, then finds all statements that use these predicates. It then reverses the order of the subject and object for the select clause.
The query returns the following:
[ http://www.xfront.com/owl/ontologies/camera/SinaronDigital4.5/45DB,
http://www.xfront.com/owl/ontologies/camera/#matchingPart,
http://www.xfront.com/owl/ontologies/camera/SinarMbody ]
Inferences like this can be inserted back into the model as new statements. In this case, the result is in subject predicate object format, so it can be used as the basis of a select insert query.
owl:TransitiveProperty
The owl:TransitiveProperty declaration specifies that a predicate is transitive. That is, if instance A uses this predicate to refer to instance B, and B uses the same predicate to refer to instance C, then it is valid for instance A to use that predicate to refer to instance C. For example, has-ancestor is a transitive predicate. So if the statement Enoch has-ancestor Cain is true, and Cain has-ancestor Adam is also true, then we can infer that Enoch has-ancestor Adam is also true. Since we know the last statement is true even if it does not exist in the model, then this is an inferred statement.
The camera ontology declares the following:
<owl:TransitiveProperty rdf:ID="compatibleLens">
<rdfs:domain rdf:resource="#Lens"/>
<rdfs:range rdf:resource="#Lens"/>
</owl:TransitiveProperty>
This means that the predicate compatibleLens is a transitive property. It is used for Lenses to refer to other Lenses. Note that for a transitive property, the domain and range must have a non-empty intersection. That is, the domain and range must overlap or else it would not be possible to get the chain of statements necessary to define transitivity. Typically, the domain and range will be equal.
An example of the use of the transitive property is shown here:
<rdf:Description rdf:about="&camera;SinarF2">
<rdf:type rdf:resource="#Large-Format"/>
<body>
<BodyWithNonAdjustableShutterSpeed/>
</body>
<lens>
<Lens rdf:about="Sinaron-SE">
<focal-length>360mm</focal-length>
<compatibleLens>
<Lens rdf:about="Sinaron-S"/>
</compatibleLens>
</Lens>
</lens>
<lens>
<Lens rdf:about="Sinaron-S">
<compatibleLens>
<Lens rdf:about="Sinaron-W"/>
</compatibleLens>
</Lens>
<lens>
</lens>
<Lens rdf:about="Sinaron-W">
<focal-length>200mm</focal-length>
</Lens>
</lens>
</rdf:Description>
This declares a camera with three lenses, Sinaron-SE, Sinaron-S and Sinaron-W. The Sinaron-SE lens declares that it is a compatibleLens with Sinaron-S, and Sinaron-S declares that it is a compatibleLens with Sinaron-W. Since compatibleLens is a transitive predicate, Sinaron-SE is a compatibleLens with Sinaron-W.
Valid inferences like this can be found using the following iTQL:
select $predicate subquery(
select $subject $object
from <rmi://mysite.com/server1#camera>
where trans($subject $predicate $object)
)
from <rmi://mysite.com/server1#camera>
where $predicate <rdf:type> <owl:TransitiveProperty>;
This starts by finding all predicates declared to be transitive. So that long chains of transitive statements can be found in a single query, the trans operation is used. At this time, trans requires that a predicate be fixed, so it is not possible to simply use the $predicate variable as the predicate. Instead, a subquery is executed for each predicate that is found. Inside the subquery, the $predicate variable only has a single value, so it is safe to use within trans.
The query returns the following:
[ http://www.xfront.com/owl/ontologies/camera/#compatibleLens, [$subject $object]
[http://www.xfront.com/owl/ontologies/camera/Sinaron-SE http://www.xfront.com/owl/ontologies/camera/Sinaron-W] ]
This says that for the predicate compatibleLens, there is a single subject-object pair of Sinaron-SE and Sinaron-W, which is exactly what is expected.
Inferences like this can be inserted back into the model as new statements. At this stage, some external code is required to put the result into a form that is acceptable for insertion. In the future, insertions like this will be possible using only iTQL.
owl:equivalentClass
The owl:equivalentClass declaration specifies that one class is equivalent to another class. That is, any instance of a class is treated as an instance of an equivalent class, and vice versa.
The camera ontology declares the following:
<owl:Class rdf:ID="Body">
<rdfs:subClassOf rdf:resource="#PurchaseableItem"/>
</owl:Class>
<owl:Class rdf:ID="CameraBody">
<owl:equivalentClass rdf:resource="#Body"/>
</owl:Class>
This declares two classes, CameraBody and Body, which are equivalent to each other.
An example using the CameraBody class is as follows:
<rdf:Description rdf:about="#Pentax-OptioS50">
<rdf:type rdf:resource="#Digital"/>
<lens>
<Lens>
<focal-length>35.6-107mm</focal-length>
<aperture>2.6-4.8</aperture>
</Lens>
</lens>
<body>
<CameraBody>
<shutter-speed rdf:parseType="Resource">
<min>0.0005</min>
<max>4.0</max>
<units>seconds</units>
</shutter-speed>
</CameraBody>
</body>
<cost rdf:parseType="Resource">
<rdf:value>300</rdf:value>
<currency>USD</currency>
</cost>
</rdf:Description>
This declares a digital camera Pentax-OptioS50, with a lens, a cost, and a body of type CameraBody. Since CameraBody is the equivalent of Body, then the body is also of type Body.
For simple cases it is possible to copy some of the Body information over to the CameraBody instance. However, when complex operations such as restrictions are applied to the Body class, the complexity for the CameraBody instance to meet every possible situation for Body can become unbounded. In these cases you cannot write iTQL to capture every possibility.
In order for instances of CameraBody to pick up all the information and constraints associated with being of type Body, it is necessary to declare that it is of type Body. Once this is done, all Body properties and restrictions are automatically applied to the object. The iTQL to create these declarative statements is as follows:
select $instance <owl:type> $otherclass
from <rmi://mysite.com/server1#camera>
where $instance <rdf:type> $class
and $otherclass <owl:equivalentClass> $class;
Since owl:equivalentClass is symmetric, the statement can also be declared in the opposite order. The iTQL to find both statements at once is as follows:
select $instance <owl:type> $otherclass
from <rmi://mysite.com/server1#camera>
where $instance <rdf:type> $class
and ($class <owl:equivalentClass> $otherclass
or $otherclass <owl:equivalentClass> $class);
This query returns data similar to the following:
[ _node250, http://www.w3.org/2002/07/owl#type, http://www.xfront.com/owl/ontologies/camera/#CameraBody ]
[ _node338, http://www.w3.org/2002/07/owl#type, http://www.xfront.com/owl/ontologies/camera/#CameraBody ]
[ _node378, http://www.w3.org/2002/07/owl#type, http://www.xfront.com/owl/ontologies/camera/#CameraBody ]
[ http://www.xfront.com/owl/ontologies/camera/#sharedBody, http://www.w3.org/2002/07/owl#type,
http://www.xfront.com/owl/ontologies/camera/#CameraBody ]
[ _node453, http://www.w3.org/2002/07/owl#type, http://www.xfront.com/owl/ontologies/camera/#CameraBody ]
[ _node457, http://www.w3.org/2002/07/owl#type, http://www.xfront.com/owl/ontologies/camera/#CameraBody ]
[ _node482, http://www.w3.org/2002/07/owl#type, http://www.xfront.com/owl/ontologies/camera/#CameraBody ]
[ _node496, http://www.w3.org/2002/07/owl#type, http://www.xfront.com/owl/ontologies/camera/#CameraBody ]
[ _node509, http://www.w3.org/2002/07/owl#type, http://www.xfront.com/owl/ontologies/camera/#CameraBody ]
[ _node519, http://www.w3.org/2002/07/owl#type, http://www.xfront.com/owl/ontologies/camera/#Body ]
Since the declaration is <camera:CameraBody> <owl:equivalentClass> <camera:Body>, the first nine statements result from the constraint ($otherclass <owl:equivalentClass> $class), and the last statement results from the constraint ($class <owl:equivalentClass> $otherclass).
While these queries establish the required relationships for the instance data, they do not make inferences on any ontology data. The first inference to make is based on the OWL definition that classes are considered to be subclasses of themselves. Using this information, you can infer that if two classes subclass each other, then they must be equivalent classes. This is shown in the following ontology data:
<owl:Class rdf:ID="NonPurchaseableItem">
<rdfs:subClassOf rdf:resource="&owl;Thing"/>
<rdfs:subClassOf rdf:resource="#IncludedItem"/>
</owl:Class>
<owl:Class rdf:ID="IncludedItem">
<rdfs:subClassOf rdf:resource="#NonPurchaseableItem"/>
</owl:Class>
The query to find this information is as follows:
select $x <owl:equivalentClass> $y
from <rmi://mysite.com/server1#camera>
where $x <rdfs:subClassOf> $y and $y <rdfs:subClassOf> $x;
This returns:
[ http://www.xfront.com/owl/ontologies/camera/#NonPurchaseableItem, http://www.w3.org/2002/07/owl#equivalentClass,
http://www.xfront.com/owl/ontologies/camera/#IncludedItem ]
[ http://www.xfront.com/owl/ontologies/camera/#IncludedItem, http://www.w3.org/2002/07/owl#equivalentClass,
http://www.xfront.com/owl/ontologies/camera/#NonPurchaseableItem ]
Another inference that can be made is that every class is equivalent to itself. While this is redundant information, it can be important when performing a query to find all classes that are equivalent to a given class. This is because it would be an error to exclude the given class from such a list.
The iTQL for this is as follows:
select $x <owl:equivalentClass> $x
from <rmi://mysite.com/server1#camera>
where $x <rdf:type> <owl:Class>;
The results of this query are not shown here. They just state that every class in the system is equivalent to itself.
owl:equivalentProperty
The owl:equivalentProperty declaration specifies that one property is equivalent to another property. That is, any usage of this property is treated as a usage of the equivalent property, and vice versa.
The camera ontology declares the following:
<owl:DatatypeProperty rdf:ID="aperture">
<rdfs:domain rdf:resource="#Lens"/>
<rdfs:range rdf:resource="&xsd;string"/>
</owl:DatatypeProperty>
<owl:DatatypeProperty rdf:ID="f-stop">
<owl:equivalentProperty rdf:resource="#aperture"/>
<rdfs:domain rdf:resource="#Lens"/>
<rdfs:range rdf:resource="&xsd;string"/>
</owl:DatatypeProperty>
This declares two properties, aperture and f-stop, which are equivalent to each other. These properties are of type owl:DatatypeProperty, but owl:equivalentProperty applies equally to owl:ObjectProperty.
Both of these properties are used regularly throughout the data. An example is as follows:
<rdf:Description rdf:about="#SinarM">
<rdf:type rdf:resource="#Digital"/>
<rdf:type rdf:resource="#Simple-Large-Format"/>
<body>
<BodyWithNonAdjustableShutterSpeed about="#SinarMbody">
<matchingPart>
<Lens rdf:about="#SinaronDigital4.5/45DB"/>
</matchingPart>
</BodyWithNonAdjustableShutterSpeed>
</body>
<lens>
<Lens rdf:about="#SinaronDigital4.5/45DB">
<aperture>4.5</aperture>
<focal-length>45mm</focal-length>
</Lens>
</lens>
</rdf:Description>
This declares a camera SinarM, with a SinaronDigital4.5/45DB lens. The lens has an aperture of 4.5.
In order for all the attributes of the f-stop property to apply equally to the aperture property, the new property needs to be applied in parallel to the existing property. The iTQL to create these declarative statements is as follows:
select $x $property2 $y
from <rmi://mysite.com/server1#camera>
where $x $property1 $y
and $property1 <owl:equivalentProperty> $property2;
Since owl:equivalentProperty is symmetric, the statement can also be declared in the opposite order. The iTQL to find both statements at once is as follows:
select $x $property2 $y
from <rmi://mysite.com/server1#camera>
where $x $property1 $y
and ($property1 <owl:equivalentProperty> $property2
or $property2 <owl:equivalentProperty> $property1);
The query returns data similar to the following:
[ _node349, http://www.xfront.com/owl/ontologies/camera/#aperture, 4.5-5.6 ]
[ _node437, http://www.xfront.com/owl/ontologies/camera/#aperture, 4.5-5.6 ]
[ _node511, http://www.xfront.com/owl/ontologies/camera/#aperture, 4.5-5.6 ]
[ http://www.xfront.com/owl/ontologies/camera/#SinaronDigital4.5/45DB,
http://www.xfront.com/owl/ontologies/camera/#f-stop, 4.5 ]
[ _node463, http://www.xfront.com/owl/ontologies/camera/#f-stop, 2.8-3.5 ]
[ _node270, http://www.xfront.com/owl/ontologies/camera/#f-stop, 2.6-4.8 ]
[ _node316, http://www.xfront.com/owl/ontologies/camera/#f-stop, 2.6-4.8 ]
Since the declaration is <camera:f-stop> <owl:equivalentProperty> <camera:aperture>, the first three statements result from the constraint ($property1 <owl:equivalentProperty> $property2) and the next four statements result from the constraint ($property2 <owl:equivalentClass> $property1).
While these queries establish the required relationships for the instance data, they do not make inferences on any ontology data. The first inference to make is based on the OWL definition that properties are considered to be subproperties of themselves. Using this information, you can infer that if two properties are subproperties of each other, then they must be equivalent properties. This is shown in the following ontology data:
<owl:DatatypeProperty rdf:ID="size">
<rdfs:subPropertyOf rdf:resource="#focal-length"/>
<rdfs:domain rdf:resource="#Lens"/>
<rdfs:range rdf:resource="&xsd;string"/>
</owl:DatatypeProperty>
<owl:DatatypeProperty rdf:ID="focal-length">
<rdfs:subPropertyOf rdf:resource="#size"/>
<rdfs:domain rdf:resource="#Lens"/>
<rdfs:range rdf:resource="&xsd;string"/>
</owl:DatatypeProperty>
The query to find this information is as follows:
select $x <owl:equivalentProperty> $y
from <rmi://mysite.com/server1#camera>
where $x <rdfs:subPropertyOf> $y and $y <rdfs:subPropertyOf> $x;
This returns:
[ http://www.xfront.com/owl/ontologies/camera/#size, http://www.w3.org/2002/07/owl#equivalentProperty,
http://www.xfront.com/owl/ontologies/camera/#focal-length ]
[ http://www.xfront.com/owl/ontologies/camera/#focal-length, http://www.w3.org/2002/07/owl#equivalentProperty,
http://www.xfront.com/owl/ontologies/camera/#size ]
Another inference that can be made is that every property is equivalent to itself. While this is redundant information it can be important when performing a query to find all properties that are equivalent to a given property. It would be an error to exclude the given property from such a list.
The iTQL for this is as follows:
select $x <owl:equivalentProperty> $x
from <rmi://mysite.com/server1#camera>
where $x <rdf:type> <rdf:Property>;
Without an inferencing rule to first declare that objects of all the owl property types also have type rdf:Property, then it is necessary to expand this query, as follows:
select $x <owl:equivalentProperty> $x
from <rmi://mysite.com/server1#camera>
where $x <rdf:type> <rdf:Property>
or $x <rdf:type> <owl:ObjectProperty>
or $x <rdf:type> <owl:DatatypeProperty>
or $x <rdf:type> <owl:FunctionalProperty>
or $x <rdf:type> <owl:InverseFunctionalProperty>
or $x <rdf:type> <owl:TransitiveProperty>
or $x <rdf:type> <owl:SymmetricProperty>;
Some methods of declaring the various property types in RDF/XML result in more than one type of property type statement, but other methods result in a single statement, making all of these type constraints necessary. iTQL eliminates duplicates in results, so this is not a problem.
The results of this query are not shown here. They just state that every property in the system is equivalent to itself.
owl:intersectionOf
Available in next release.
