A Proposal for an OWL Rules Language
by Ian Horrocks Peter F. Patel-Schneider

Abstract

This is a description of a proposed rules extension to the OWL Web Ontology Language. It includes a high-level abstract syntax for Horn clause rules in both the OWL DL and OWL Lite sublanguages of OWL. A model-theoretic semantics is given to provide a formal meaning for OWL ontologies including rules written in this abstract syntax. An XML syntax based on the OWL XML presentation syntax and a mapping to RDF graphs based on the OWL RDF/XML exchange syntax are also given, along with several examples.

Overview

Proposal for rules extension to OWL DL and Lite
Extends set of OWL axioms to include Horn clause rules
- High-level abstract syntax extends OWL abstract syntax
- Model-theoretic semantics extends OWL model-theoretic semantics
- XML concrete syntax extends OWL XML presentation syntax
- Mapping to RDF graphs extends OWL RDF/XML syntax
Note similarity between rules and DQL query patterns

Rules Basics

Rules are of the form of an implication between an antecedent (body) and consequent (head).
- Intended meaning: whenever conditions specified in antecedent hold, conditions specified in consequent must also hold
Both antecedent and consequent consist of zero or more atoms
- Empty antecedent treated as trivially true
- Empty consequent treated as trivially false
- Multiple atoms treated as a conjunction

Rule Atoms

Atoms can be of the form
1. C(x)
2. P(x,y)
3. sameAs(x,y)
4. differentFrom(x,y)
where
- C is an OWL class
- P is an OWL property
- x is a variable or OWL individual
- y is a variable, OWL individual or OWL data value
Rules must be safe
- All variables must must occur in antecedent (body)

Rules Power

Rules proposal adds significant expressive power to OWL DL
- Combination is Undecidable (via role value maps)
Rules appear to go beyond basic Horn
- Conjunctive consequent (head)
- Class descriptions (not just class names)
- (In)equalities
But just "syntactic sugar" (could be captured in basic Horn rules)
- Conjunctive consequents transform to multiple rules (via Lloyd-Topor)
- Descriptions given names in an OWL ontology
- differentFrom(x,y) ⇒ C(x) ∧ D(y) where C and D are disjoint
- sameAs(x,y) ⇒ P(x,x) ∧ P(x,y) where P is functional

Abstract Syntax

axiom ::= rule 
rule ::= 'Implies(' { annotation } antecedent consequent ')'
antecedent ::= 'Antecedent(' { atom } ')'
consequent ::= 'Consequent(' { atom } ')'
atom ::= description '(' i-object ')'
       | individualvaluedPropertyID '(' i-object i-object ')'
       | datavaluedPropertyID '(' i-object d-object ')'
       | sameAs '(' i-object i-object ')'
       | differentFrom '(' i-object i-object ')'
i-object ::= i-variable | individualID
d-object ::= d-variable | dataLiteral
i-variable ::= 'I-variable(' URIreference ')'
d-variable ::= 'D-variable(' URIreference ')'

Example 1

Assert that the combination of the hasParent and hasBrother properties implies the hasUncle property:

Generic rule syntax

hasParent(?x1,?x2) ∧ hasBrother(?x2,?x3) ⇒ hasUncle(?x1,?x3)

Abstract OWL syntax

Implies(Antecedent(hasParent(I-variable(x1) I-variable(x2))
		   hasBrother(I-variable(x2) I-variable(x3)))
	Consequent(hasUncle(I-variable(x1) I-variable(x3))))

Gets you just what you want (and a bit more)
If John has Mary as a parent and Mary has Bill has a brother then John has Bill as an uncle

Example 2

An alternative formulation of the first example:

Generic rule syntax

hasParent(?x1,?x2) ∧ hasSibling(?x2,?x3) ∧ hasSex(?x3,Male) 
   ⇒ hasUncle(?x1,?x3)

Abstract OWL syntax

Implies(Antecedent(hasParent(I-variable(x1) I-variable(x2))
		   hasSibling(I-variable(x2) I-variable(x3))
                   hasSex(I-variable(x3) Male))
	Consequent(hasUncle(I-variable(x1) I-variable(x3))))

Note use of OWL individual (Male)

Example 3

Assert that art objects inherit the style/period of the artist that created them:

Generic rule syntax

Artist(?x1) ∧ Style(?x2) ∧ artistStyle(?x1,?x2) ∧ creator(?x1,?x3)  
   ⇒ styleOrPeriod(?x3,?x2)

Abstract OWL syntax

Implies(Antecedent(Artist(I-variable(x1)) Style(I-variable(x2))
                   artistStyle(I-variable(x1) I-variable(x2))
		   creator(I-variable(x1) I-variable(x3)))
	Consequent(styleOrPeriod(I-variable(x3) I-variable(x2))))

Rules -v- Axioms

Subset of OWL DL can be transformed into equivalent rules (and vice versa)

See Grosof et al, Description logic programs: Combining logic programs with description logic. In Proc.WWW 2003)

For example (trivially):

SubClassOf(C D)

is equivalent to

Implies(Antecedent(C(I-variable(x1)))
        Consequent(D(I-variable(x1))))

Rules -v- Axioms (cont'd)

Also:

SubClassOf(intersectionOf(A restriction(P someValuesFrom(B)))
           intersectionOf(C restriction(Q allValuesFrom(D))))

is equivalent to

Implies(Antecedent(A(I-variable(x1))
                   P(I-variable(x1) I-variable(x2))
		   B(I-variable(x2)))
	Consequent(C(I-variable(x2))))
Implies(Antecedent(A(I-variable(x1))
                   P(I-variable(x1) I-variable(x2))
		   B(I-variable(x2))
                   Q(I-variable(x1) I-variable(x3)))
	Consequent(D(I-variable(x2))))

Model-Theoretic Semantics

Extends OWL semantics with bindings, which map variables to elements of the domain
- Given OWL interpretation I, binding B(I) is an interpretation s.t.
  - S maps i-variables to elements of R
  - S maps d-variables to elements of LV_T
Atom satisfied by B(I) if following conditions met:

Atom Condition on B(I)

description(x) S(x) ∈ EC(description)

property(x,y) <S(x),S(y)> ∈ ER(property)

sameAs(x,y) S(x) = S(y)

differentFrom(x,y) S(x) ≠ S(y)
B(I) satisfies an antecedent A iff A is empty or B(I) satisfies every atom in A.
B(I) satisfies a consequent C iff C is not empty and B(I) satisfies every atom in C.
I satisfies a rule iff for every binding B such that B(I) satisfies its antecedent, B(I) also satisfies its consequent.

Atom	Condition on B(I)
description(x)	S(x) ∈ EC(description)
property(x,y)	<S(x),S(y)> ∈ ER(property)
sameAs(x,y)	S(x) = S(y)
differentFrom(x,y)	S(x) ≠ S(y)

XML Syntax

Proposed XML Syntax extends the OWL XML Presentation Syntax
Other XML syntaxes could be imagined
- e.g., a RuleML based syntax
Extending the OWL XML Presentation Syntax has several advantages:
- arbitrary OWL classes (e.g., descriptions) can be used as predicates in rules;
- rules and ontology axioms can be freely mixed;
- the existing XSLT stylesheet (owlxml2rdf.xsl) can easily be extended to provide a mapping to RDF graphs

Example 1 using extended OWL XML Syntax

<owlx:Rule> 
  <owlx:antecedent> 
    <owlx:individualPropertyAtom  owlx:property="hasParent"> 
      <owlx:Variable owlx:name="x1" />
      <owlx:Variable owlx:name="x2" />
    </owlx:individualPropertyAtom> 
    <owlx:individualPropertyAtom  owlx:property="hasBrother"> 
      <owlx:Variable owlx:name="x2" />
      <owlx:Variable owlx:name="x3" />
    </owlx:individualPropertyAtom> 
  </owlx:antecedent> 
  <owlx:consequent> 
    <owlx:individualPropertyAtom  owlx:property="hasUncle"> 
      <owlx:Variable owlx:name="x1" />
      <owlx:Variable owlx:name="x3" />
    </owlx:individualPropertyAtom> 
  </owlx:consequent> 
</owlx:Rule>

Example 2 using extended OWL XML Syntax

<owlx:Rule> 
  <owlx:antecedent> 
    <owlx:individualPropertyAtom  owlx:property="hasParent"> 
      <owlx:Variable owlx:name="x1" />
      <owlx:Variable owlx:name="x2" />
    </owlx:individualPropertyAtom> 
    <owlx:individualPropertyAtom  owlx:property="hasSibling"> 
      <owlx:Variable owlx:name="x2" />
      <owlx:Variable owlx:name="x3" />
    <owlx:individualPropertyAtom  owlx:property="hasSex"> 
      <owlx:Variable owlx:name="x3" />
      <owlx:Individual owlx:name="#male" />
    </owlx:individualPropertyAtom> 
  </owlx:antecedent> 
  <owlx:consequent> 
    <owlx:individualPropertyAtom  owlx:property="hasUncle"> 
      <owlx:Variable owlx:name="x1" />
      <owlx:Variable owlx:name="x3" />
    </owlx:individualPropertyAtom> 
  </owlx:consequent> 
</owlx:Rule>

Example 3 using extended OWL XML Syntax

<owlx:Rule> 
  <owlx:antecedent> 
    <owlx:classAtom> 
      <owlx:class="&ulan;Artist" />
      <owlx:Variable owlx:name="_x" />
    </owlx:classAtom> 
    <owlx:classAtom> 
      <owlx:class="&aat;Style" />
      <owlx:Variable owlx:name="_y" />
    </owlx:classAtom> 
    <owlx:individualPropertyAtom  owlx:property="&aatulan;artistStyle"> 
      <owlx:Variable owlx:name="_x" />
      <owlx:Variable owlx:name="_y" />
    </owlx:individualPropertyAtom> 
    <owlx:individualPropertyAtom  owlx:property="&vra;creator"> 
      <owlx:Variable owlx:name="_x" />
      <owlx:Variable owlx:name="_z" />
    </owlx:individualPropertyAtom> 
  </owlx:antecedent> 
  <owlx:consequent> 
    <owlx:individualPropertyAtom  owlx:property="&vra;style/period"> 
      <owlx:Variable owlx:name="_z" />
      <owlx:Variable owlx:name="_y" />
    </owlx:individualPropertyAtom> 
  </owlx:consequent> 
</owlx:Rule>

Mapping to RDF Graphs

Rules have variables, so treating them as a semantic extension of RDF is very difficult
Possible to provide an RDF syntax for rules
- but the semantics of the resultant RDF graphs will not be an extension of the RDF Semantics
Mapping to RDF/XML is most easily created as an extension to the XSLT transformation for the OWL XML Presentation syntax

Example 2 using extended OWL RDF Syntax

<owlr:Variable rdf:ID="_x1"/>
<owlr:Variable rdf:ID="_x2"/>
<owlr:Variable rdf:ID="_x3"/>
<owlr:Rule>
  <owlr:antecedent rdf:parseType="Collection">
    <owlr:individualPropertyAtom>
      <owlr:propertyPredicate rdf:resource="&eg;hasParent"/>
      <owlr:argument1 rdf:about="#_x1" />
      <owlr:argument2 rdf:about="#_x2" />
    </owlr:individualPropertyAtom>
    <owlr:individualPropertyAtom>
      <owlr:propertyPredicate rdf:resource="&eg;hasSibling"/>
      <owlr:argument1 rdf:about="#_x2" />
      <owlr:argument2 rdf:about="#_x3" />
    </owlr:individualPropertyAtom>
    <owlr:individualPropertyAtom>
      <owlr:propertyPredicate rdf:resource="&eg;hasSex"/>
      <owlr:argument1 rdf:about="#_x3" />
      <owlr:argument2 rdf:about="#male" />
    </owlr:individualPropertyAtom>
  </owlr:antecedent>
  <owlr:consequent rdf:parseType="Collection">
    <owlr:individualPropertyAtom>
      <owlr:propertyPredicate rdf:resource="&eg;hasUncle"/>
      <owlr:argument1 rdf:about="#_x1" />
      <owlr:argument2 rdf:about="#_x3" />
    </owlr:individualPropertyAtom>
  </owlr:consequent>
</owlr:Rule>

Extended Example (1)

From http://www.daml.org/2003/06/ruletests/translation-3.n3 (due to Mike Dean)

For every Airport there is a map Point that has the same location (latitude & longitude) as the Airport, that has the Airport as an underlyingObject and that has the Airport name as its Label

First some background knowledge (OWL axioms):

DataTypeProperty(latitude)
DataTypeProperty(longitude)

SubClassOf(map:Location
  intersectionOf(
    restriction(map:latitude someValuesFrom(xsd:double))
    restriction(map:latitude allValuesFrom(xsd:double))
    restriction(map:longitude someValuesFrom(xsd:double))
    restriction(map:longitude allValuesFrom(xsd:double))
))

Extended Example (2)

Rule asserting that if a map:Location is the sameLocation as another location, then it has the same values for latitude and longitude:

Implies(
  Antecedent(map:Location(I-variable(maploc))
             sameLocation(I-variable(loc) I-variable(maploc))
	     latitude(I-variable(loc) I-variable(lat))
	     longitude(I-variable(loc) I-variable(lon)))
  Consequent(map:latitude(I-variable(maploc) I-variable(lat))
             map:longitude(I-variable(maploc) I-variable(lon))))

Extended Example (3)

Rule asserting that wherever an Airport is located, there is some map:Location that is the sameLocation as the Airport's location and that is the location of a map Point:

ObjectProperty(map:location (inverseOf map:isLocationOf))

Implies(Antecedent(airports:Airport(I-variable(airport))
                   location(I-variable(airport) I-variable(loc))
		   latitude(I-variable(loc) I-variable(lat))
		   longitude(I-variable(loc) I-variable(lon)))
	Consequent(restriction
                    (sameLocation someValuesFrom
                      (intersectionOf
                        (map:Location restriction
                          (map:isLocationOf someValuesFrom
                            (map:Point)))))))

Note use of complex OWL description as predicate in rule;
use of OWL:someValuesFrom to assert existence of map location

Extended Example (4)

Rule asserting that a map:Point whose map:location is the map:Location of an Airport has the airport as a map:underlyingObject and has a map:label which is the name of the Airport.

ObjectProperty(map:location (inverseOf map:isLocationOf))

Implies(
  Antecedent(airports:Airport(I-variable(airport))
             location(I-variable(airport) I-variable(loc))
             sameLocation(I-variable(loc) I-variable(maploc))
             map:location(I-variable(point) I-variable(maploc))
	     airports:name(I-variable(airport) I-variable(name)))
  Consequent(map:underlyingObject(I-variable(point)
                                  I-variable(airport))
             map:label(I-variable(point) I-variable(name))))

Conclusions and Future Work

Proposal extends OWL with Rules
- Obvious extensions to OWL abstract syntax, model-theoretic semantics, XML concrete syntax and RDF/XML syntax
Provides useful "syntactic sugar", but has same power as basic Horn clause rules
Resulting language is undecidable
Implementation techniques could include:
- Use of FO theorem prover (as in Hoolet/Vampire OWL reasoner)
- Hybrid algorithms (e.g., tableaux+rules)
- "Rules engines"

Conclusions and Future Work (cont'd)

Remains to be seen if effective (in practice) implementations are possible
Future language extensions could include
- Build in functions for counting and aggregation
- ???

A Proposal for an OWL Rules Language by Ian Horrocks Peter F. Patel-Schneider

Abstract

Overview

Rules Basics

Rule Atoms

Rules Power

Abstract Syntax

Example 1

Generic rule syntax

Abstract OWL syntax

Example 2

Generic rule syntax

Abstract OWL syntax

Example 3

Generic rule syntax

Abstract OWL syntax

Rules -v- Axioms

Rules -v- Axioms (cont'd)

Model-Theoretic Semantics

XML Syntax

Example 1 using extended OWL XML Syntax

Example 2 using extended OWL XML Syntax

Example 3 using extended OWL XML Syntax

Mapping to RDF Graphs

Example 2 using extended OWL RDF Syntax

Extended Example (1)

Extended Example (2)

Extended Example (3)

Extended Example (4)

Conclusions and Future Work

Conclusions and Future Work (cont'd)

A Proposal for an OWL Rules Language
by Ian Horrocks Peter F. Patel-Schneider