@prefix :<http://expl.at#>.
:JamesCameron :directorOf :Terminator.

prefix : <http://expl.at#>
select * where {:directorOf ?y ?z}

@prefix :<http://expl.at#>.
@prefix rdfs:<http://www.w3.org/2000/01/rdf-schema#>.
:directorOf rdfs:domain :Director; rdfs:range  :Movie.

prefix : <http://expl.at#>
select * where {:Terminator a ?z}

prefix : <http://expl.at#>
select * where
{
:Terminator a ?z
filter (!strstarts(str(?z),"http://www.w3.org"))
}

We can now also ask what is James Cameron:
prefix : <http://expl.at#>
select * where {:JamesCameron a ?z}

Several other statements were also generated – for example that Director and Movie are classes, things, resources and also subclasses of owl:Thing (because any director and movie is a thing, not only the classes Director and Movie).

Now upload the following:

@prefix :<http://expl.at#>.
:TimBurton :directorOf :Batman.
:StevenSpielberg :directorOf :ET.

If you ask what is TimBurton or what is ET you will receive the right answers – Director and Movie – although you never uploaded such information explicitly. This is because the axioms remain active (until you delete them) and will keep generating relevant statements for every statement that we upload. You can also retrieve a list of all directors (or movies):
prefix : <http://expl.at#>
select * where {?x a :Director}


Upload a new axiom:
@prefix rdfs:<http://www.w3.org/2000/01/rdf-schema#>.
@prefix :<http://expl.at#>.
:Director rdfs:subClassOf :Artist.
This axiom declares the inclusion of two classes, which translates to the following rule: "any director is also an artist". Now if we ask what is JamesCameron we get richer answers - not only Director, but also Artist:

prefix : <http://expl.at#>
select * where {:JamesCameron a ?z}


Upload a new axiom:
@prefix rdfs:<http://www.w3.org/2000/01/rdf-schema#>.
@prefix :<http://expl.at#>.
:AmericanDirector rdfs:subClassOf :Director.


You may think that, based on the same reasoning, JamesCameron now also becomes an AmericanDirector. Check this with the following query:
prefix : <http://expl.at#>
select * where {:JamesCameron a ?z}


prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>
prefix : <http://expl.at#>
select * where {:AmericanDirector rdfs:subClassOf ?x}

Upload a new axiom:
@prefix rdfs:<http://www.w3.org/2000/01/rdf-schema#>.
@prefix :<http://expl.at#>.
:directorOf rdfs:subPropertyOf :creatorOf.

This axiom generates a similar hierarchy, but for properties. It will be interpreted as a logical implication: "If x is director of y, then x created y". We can check that a new relation was generated between the mentioned directors and their movies:

prefix : <http://expl.at#>
select * where {?x :creatorOf ?y}

The superproperty is a more general version of its subproperties, manifesting between the same pair of instances. Just as with the classes, the propagation works only upwards in the hierarchy. If we add the following axiom, it will not be generated between he same things:

@prefix rdfs:<http://www.w3.org/2000/01/rdf-schema#>.
@prefix : <http://expl.at#>.
:codirectorOf rdfs:subPropertyOf :directorOf.

You can check that this axiom did not generate new relations (JamesCameron is directorOf Terminator, but this does not mean he is also codirector – the relation  propagates only towards superproperties):

prefix : <http://expl.at#>
select * where {?x :codirectorOf ?y}

However, some statements were generated – the general description of the newly introduced property codirector:

prefix : <http://expl.at#>
select * where {:codirectorOf ?x ?y}


Delete the axiom that defined the original domain for directOf:
prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>
prefix : <http://expl.at#>
delete data {:directorOf rdfs:domain :Director}

Now if you ask for information about JamesCameron you will notice that everything that was deduced from the deleted axiom was also deleted:

prefix : <http://expl.at#>
select * where {:JamesCameron ?y ?x}

Also, the domain of codirectorOf does is not inherited anymore from the (deleted) domain of directorOf:

prefix : <http://expl.at#>
select * where {:codirectorOf ?x ?y}

The knowledge that JamesCameron, TimBurton, StevenSpielberg are directors also disappeared – we have no more directors:

prefix : <http://expl.at#>
select * where {?x a :Director}

OWL reasoning in GraphDB

Upload the following axioms:

@prefix : <http://expl.at#>.
@prefix owl: <http://www.w3.org/2002/07/owl#>.
:hasFriend a owl:SymmetricProperty.
:hasRelative a owl:TransitiveProperty.
:hasHusband owl:inverseOf :hasWife.


To check the effect of these axioms, upload the following statements using these axioms:

@prefix : <http://expl.at#>.
:Jim :hasFriend :George.
:Anna :hasHusband :George.
:Andrew :hasRelative :Jim.
:Jim :hasRelative :Jane.

We will check that the following statements are generated:
:George :hasFriend :Jim (because of the symmetry of friendship)
:George :hasWife :Anna (because it is inverse to the husband relationship)
:Andrew :hasRelative :Jane (because being a relative is a transitive relationship)

To check, run the following queries:
prefix : <http://expl.at#>
select *
where {?x :hasFriend ?y}
(it will show the friendship relation in both directions)

prefix : <http://expl.at#>
select *
where {?x :hasWife ?y}
(it will show George as subject and Anna as object)

prefix : <http://expl.at#>
select *
where {?x :hasRelative ?y}
(it will show three hasRelative relationships – two explicit ones and one generated between Andrew and Jane)

We can add some RDFS axioms to combine all these relations and to assign them to classes:
@prefix : <http://expl.at#>.
@prefix rdfs:<http://www.w3.org/2000/01/rdf-schema#>.
:hasWife rdfs:subPropertyOf :hasRelative.
:hasHusband rdfs:subPropertyOf :hasRelative.
:hasRelative rdfs:domain :Person; rdfs:range :Person.

The generated ones are:
:Anna :hasRelative :George.
:George :hasRelative :Anna.
:George :hasRelative :George. (because of transitivity combined with inverse)
:Anna :hasRelative :Anna. (because of transitivity combined with inverse)
:hasWife rdfs:domain :Person; rdfs:range :Person.
:hasHusband rdfs:domain :Person; rdfs:range :Person.
:Anna a :Person.
:George a :Person.
:Andrew a :Person.
:Jim a :Person.
:Jane a :Person.

Queries to check them:

prefix : <http://expl.at#>
select *
where {?x a :Person}

prefix : <http://expl.at#>
select *
where {?x :hasRelative ?y}

prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>
prefix : <http://expl.at#>
select *
where {?x rdfs:domain :Person; rdfs:range :Person}

Upload the following statements:
@prefix : <http://expl.at#>.
@prefix owl:<http://www.w3.org/2002/07/owl#>.

:hasUncle owl:propertyChainAxiom (:hasParent :hasBrother).
:John :hasParent :Richard.
:Richard :hasBrother :Mike.

The first statement is an axiom. Its rule is: "IF x hasParent y and y hasBrother z, THEN generate x hasUncle z". The generated statement is:
:John :hasUncle :Mike.

You can find it with the query:
prefix : <http://expl.at#>
select *
where
{
:John ?y ?z
}

Add the following statements:
@prefix : <http://expl.at#>.
@prefix owl: <http://www.w3.org/2002/07/owl#>.
:SolarSystemBody owl:onProperty :orbits; owl:hasValue :Sun.
:Mars :orbits :Sun.
:Earth a :SolarSystemBody.

The axiom has a double interpretation, because the reasoning works in two directions: "IF x orbits the Sun, THEN x is a Solar System Body; IF x is a SolarSystemBody, THEN x orbits the Sun".

Based on the facts provided together with the axiom, it will generate:
:Mars a :SolarSystemBody.
(from the fact that Mars orbits the Sun)
:Earth :orbits :Sun.
(from the fact that Earth is a Solar System Body)

Queries for checking:
prefix : <http://expl.at#>
select *
where {?x :orbits ?y}

prefix : <http://expl.at#>
select *
where {?x a :SolarSystemBody}

Some other statements will also be generated (:orbits a rdf:Property, :SolarSystemBody a owl:Restriction ș.a.m.d.). owl:Restriction includes all the classes that are defined by applying a restriction (here owl:hasValue) on a property (here :orbits).

Upload the statements:
@prefix : <http://expl.at#>.
@prefix owl: <http://www.w3.org/2002/07/owl#>.
@prefix xsd:  <http://www.w3.org/2001/XMLSchema#>.
:Human	owl:onProperty :hasFather;
    	owl:maxCardinality "1"^^xsd:nonNegativeInteger.
:Jack a :Human; :hasFather :Chris, :Christoph.
:Anne :hasEmail <mailto:anne@yahoo.com>.
:Ana77 :hasEmail <mailto:anne@yahoo.com>.
:hasEmail a owl:InverseFunctionalProperty.



The following statements will be generated:
:Chris owl:sameAs :Christoph.
(because both are declared as fathers of Jack, and Jack is declared as Human)
:Anne owl:sameAs :Ana77.
(because both have the same e-mail address)

We can check the generated equivalencies with a query (the filter removes statements saying that something is equivalent with itself):
prefix : <http://expl.at#>
select *
where
{
?x owl:sameAs ?y
filter (?x!=?y)
}
Observe that the equivalence is bidirectional (by default it is a symmetric property) therefore each of them is detected twice, in both directions.

The contradiction will only appear if the knowledge base also has some statements that establish a clear distinction between these individuals. Try to upload one or both of the following statements:

@prefix : <http://expl.at#>.
@prefix owl: <http://www.w3.org/2002/07/owl#>.
:Chris owl:differentFrom :Christoph.
:Anne owl:differentFrom :Ana77.


Upload the following statements:
@prefix : <http://expl.at#>.
@prefix owl: <http://www.w3.org/2002/07/owl#>.
:Human owl:unionOf (:Man :Woman).
:AustrianWriter owl:intersectionOf (:Writer :Austrian).
:Johann a :AustrianWriter, :Man.

Interpretation as rules:
•	For owl:unionOf: "IF x is the union of y and z, THEN y an z are subclasses of x "
•	For owl:intersectionOf: "IF x is the intersection of y and z, THEN x is a subclass of both y and z "

These are set operations that can be used to extend the class hiearchy, by generating additional subclass relations. The following will be generated:
:Man rdfs:subClassOf :Human.
:Woman rdfs:subClassOf :Human.
:AustrianWriter rdfs:subClassOf :Writer, :Austrian.

We can check if we query all subclass relations (we apply a filter to keep only classes created by us and to remove the axioms saying that a class is subclass of itself):
prefix : <http://expl.at#>
prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>
select ?x ?y
where
{
    ?x rdfs:subClassOf ?y
     filter (contains(str(?x),"expl.at")&&contains(str(?y),"expl.at")&&(?x!=?y))
}

Since we now have a richer class hierarchy, this will trigger additional deductions about the type of Johann. The following will be generated from the new class hierarchy:
:Johann a :Writer, :Austrian, :Human.

Check what is Johann and you will see al these types (both the explicit and the deduced ones):
prefix : <http://expl.at#>
select *
where
{
:Johann a ?x
filter contains(str(?x),"expl.at")
}



Try to upload the following:
@prefix : <http://expl.at#>.
@prefix owl: <http://www.w3.org/2002/07/owl#>.
:Man owl:disjointWith :Woman.
:Anna a :Man, :Woman.
You will get an error because there is a contradiction: Man and Woman are declared as disjoint sets (i.e., with no common elements) but on the other side we declare the Anna as being an instance of both sets.

Try to upload the following:
@prefix : <http://expl.at#>.
@prefix owl: <http://www.w3.org/2002/07/owl#>.
:Anna owl:sameAs :Ann.
:Anna owl:differentFrom :Ann.


@prefix : <http://expl.at#>.
@prefix owl: <http://www.w3.org/2002/07/owl#>.
:J :hasEmail <mailto:j@yahoo.com>.
:John :hasEmail <mailto:j@yahoo.com>.
:hasEmail a owl:InverseFunctionalProperty.
:J owl:differentFrom :John.

Try to upload the following:
@prefix : <http://expl.at#>.
@prefix owl: <http://www.w3.org/2002/07/owl#>.
@prefix xsd:  <http://www.w3.org/2001/XMLSchema#>.
:Orphan owl:onProperty :hasParent;
              owl:maxCardinality "0"^^xsd:nonNegativeInteger.
:John a :Orphan; :hasParent :Ann.


A more sophisticated version of this is where we enrich the restriction with the class of the objects of the relation. Try to upload the following:
@prefix : <http://expl.at#>.
@prefix owl: <http://www.w3.org/2002/07/owl#>.
@prefix xsd:  <http://www.w3.org/2001/XMLSchema#>.
:OrphanOfMother  	owl:onProperty :hasParent;
owl:maxQualifiedCardinality "0"^^xsd:nonNegativeInteger;
owl:onClass :Woman.
:Andrew a :OrphanOfMother; :hasParent :Mimi.
:Mimi a :Woman.


@prefix : <http://expl.at#>.
@prefix owl: <http://www.w3.org/2002/07/owl#>.
@prefix xsd:  <http://www.w3.org/2001/XMLSchema#>.
:OrphanOfMother  	owl:onProperty :hasParent;
owl:maxQualifiedCardinality "0"^^xsd:nonNegativeInteger;
owl:onClass :Woman.
:Andrew a :OrphanOfMother; :hasParent :John.

Try to upload the following:
@prefix : <http://expl.at#>.
@prefix owl: <http://www.w3.org/2002/07/owl#>.
:isMotherOf a owl:AsymmetricProperty .
:Anna :isMotherOf :Mary .
:Mary :isMotherOf :Anna .






After you create the knowledge base, connect to it and upload the following:

@prefix : <http://expl.at#>.
@prefix owl: <http://www.w3.org/2002/07/owl#>.
@prefix xsd:  <http://www.w3.org/2001/XMLSchema#>.
:Parent	owl:onProperty :hasChild;
             	owl:minCardinality "1"^^xsd:nonNegativeInteger.
:John :hasChild :Peter.

The meaning of the axiom is: "if x has at least one hasChild relation, then x is a parent".

Check the list of parents to see that the "John a Parent" statement was generated:
prefix : <http://expl.at#>
select * where {?x a :Parent}
As we already suggested, it has the same effect as rdfs:domain with the advantage that we can set minCardinality at a higher number (e.g., "IF x has minimum 2 wives, x is a Polygamous").

Now upload the contradicting statements to check how the contradiction for asymmetric properties is handled:
@prefix : <http://expl.at#>.
@prefix owl: <http://www.w3.org/2002/07/owl#>.
:isMotherOf a owl:AsymmetricProperty .



:Anna :isMotherOf :Mary .
:Mary :isMotherOf :Anna .

This time the statements are not rejected at the upload attempt. They are maked up by an anonymous node and can be queried by looking for that node:

prefix : <http://expl.at#>
select * where
{
	?prop 	a x:WrongStatement;
x:PropertyInWrongStatement ?p;
x:ParticipantInWrongStatement ?x.
}

You will get two anonymous nodes, one for each of the two contradicting statements.