Skip to content
Chris Mungall edited this page Apr 25, 2014 · 6 revisions

Background

A graph is a set of nodes (vertices) and edges:

G = <V,E>

An edge E is tuple consisting of a source and target node, an edge type (property) and any number of annotations (tag value pairs)

E = <S,R,T,A*>

A path P is any sequence of edges connecting a source/starting node and target/end node, where each edge in the chain is connected to the successor edge's start node via its end node.

Paths can be restricted by Path rules.

Mapping OWL to graphs

SubClassOf axioms

between named classes:

SubClassOf(C D)  where C and D are named classes
===>
<C owl:subClassof D>

for class expressions:

SubClassOf(C SomeValuesFrom(P D))
===>
<C owl:subClassof SomeValuesFrom(P D)>
<SomeValuesFrom(P D) P D>

then via a further reduction step

<C owl:subClassof SomeValuesFrom(P D)>
<SomeValuesFrom(P D) P D>
===>
<C P D {type:SomeValuesFrom}>

More generally:

<C owl:subClassof x>
<x P D>
===>
<C P D {type:Type(x)}>

Where x is an anonymous OWL class expression

Equivalence Axioms

EquivalentClasses(C D ... )
===>
<C owl:equivalentTo D>
...

PropertyAssertions

ObjectPropertyAssertion(P I J)
===>
<I P J {type:ObjectPropertyAssertion}>

same idea for APE, DPE

Queries involving OWL semantics

An OWL class expression can be translated to NNF, CNF, DNF, or operated on directly by recursively applying the following procedures.

The procedures are incomplete (only cover a subset of OWL and may be incomplete for that subset). They are valid, with the exception of union / negation, which is only valid over an alternative closed-world interpretation - i.e. not OWL but useful.

Conjunctive queries

An OWL conjunctive expression

C and D and .... 

Can be processed by taking the intersection of processing all individual elements

Formally

{ x : x in q(C) /\ q(D) /\ ... }

This is VALID but INCOMPLETE. For complete queries, use Elk.

Disjunctive queries

Disjunctive queries onder open world semantics are hard. We provide a closed world interpretation.

An OWL disjunctive expression

C or D or .... 

Can be processed by taking the union of processing all individual elements

Formally

{ x : x in q(C) \/ q(D) \/ ... }

Under the OWA, this is INVALID and INCOMPLETE.

Under the CWA, This is VALID but INCOMPLETE.

ObjectSomeValuesFrom

Any class expression

P some D

Will yield paths

<_ P D>

Or paths

<_ P x> <x SubClassOf* D>

Making use of property characteristics

TBD: should inferred edges be labeled somehow?

Transitivity

Transitivity holds whether the edge is a subclass, an existential edge (e.g. from a subclassof-some-values-from) or an object property assertion.

Transitive(P)
<X P Y> <Y P Z>
===>
< X P Z>

Symmetry

ONLY HOLDS FOR OPEs

Property Chains

Reflexivity

SubClassOf is reflexive

SUbPropertyOf