Abstract

Although the OWL Web Ontology Language adds considerable expressive power to the Semantic Web it does have expressive limitations, particularly with respect to what can be said about properties. We present ORL (OWL Rules Language), a Horn clause rules extension to OWL that overcomes many of these limitations. ORL extends OWL in a syntactically and semantically coherent manner: the basic syntax for ORL rules is an extension of the abstract syntax for OWL DL and OWL Lite; ORL rules are given formal meaning via an extension of the OWL DL model-theoretic semantics; ORL rules are given an XML syntax based on the OWL XML presentation syntax; and a mapping from ORL rules to RDF graphs is given based on the OWL RDF/XML exchange syntax. We discuss the expressive power of ORL, showing that the ontology consistency problem is undecidable, provide several examples of ORL usage, and discuss how reasoning support for ORL might be provided.

Outline

• What:
  • What we did.
• Why:
  • Why we did it.
• How:
  • How we went about it.
• The Fine Print:
  • Everything you really need to know.
  • What you might not expect.
• Examples
  • Some example ORL rules
• Current Status:
  • What is happening to ORL.
• Conclusion:
  • Some ramblings related to ORL.

What

• ORL (OWL Rules Language) adds a single rule construct to OWL.
  • Antecedent implies consequent
  • E.g., parent(?a,?b) ∧ brother(?b,?c) → uncle(?a,?c)
• ORL is a simple extension to OWL.
  • ORL maintains the general semantic flavor of OWL.
  • No non-monotonic features are involved.
  • Model theory for ORL rules is a simple extension to the model theory for OWL.
• Different from previous rule extensions to Description Logics (CLASSIC, CARIN, DLP).
  • On top of an expressive language (OWL).
  • Rules are given a standard first-order treatment.

Why

• OWL can do a lot.
  • Define classes:
    • Student ≤ Person ∩ (∃ ssn xsd:int)
  • Define properties:
    • ssn ≤ Person × xsd:int
  • Provide information about individuals:
    • john ∈ Student ∩ (ssn : "565"^^xsd:int)
• OWL can't do everything.
  • In particular, OWL is very weak in reasoning with properties,
    • No property composition constructor,
    • Can't define uncle (as the composition of parent and brother);
  • Limitations help to ensure that reasoning is decidable for OWL DL and OWL Lite.
• Rules can provide much of what OWL can't do.
  • Defining properties, inheritance, ....
  • E.g., the brother of your parent is your uncle.
  • E.g., diseases of a body part are diseases of the body.

How

• Add a (Horn clause-like) rule axiom to OWL.
  • Antecedent implies consequent.
  • Both antecedent and consequent are bits of OWL applied to variables and individuals or data values.
• Examples:
  • parent(?a,?b) ∧ brother(?b,?c) → uncle(?a,?c)
  • bodyPart(?a,?b) ∧ disease(?b,?c) → disease(?a,?c)
  • child(?a,?b) ∧ Student(?b) → dependent(?a,?b)
• Treat as material implication.
  • A rule is satisfied if every mapping of variables to domain elements that satisfies each part of the antecedent also satisfies each part of the consequent.
  • Simple extension to OWL DL's model theory.
• ORL is monotonic.
  • No defeasible rules.
  • No negation as failure.

Syntax (abstract syntax version)

rule ::= 'Implies(' { annotation } antecedent consequent ')'

antecedent ::= 'Antecedent(' { atom } ')'
consequent ::= 'Consequent(' { atom } ')'

atom ::= description '(' i-object ')'
atom ::= individualvaluedPropertyID '(' i-object i-object ')'
atom ::= datavaluedPropertyID '(' i-object d-object ')'
atom ::= sameAs '(' i-object i-object ')'
atom ::= differentFrom '(' i-object i-object ')'

i-object ::= 'I-variable(' URIreference ')' | individualID
d-object ::= 'D-variable(' URIreference ')' | dataLiteral

All variables in a rule must occur (at least) in the antecedent.

Semantics

• Bindings are extensions of OWL interpretations that also map variables to elements of the domain in the usual manner.
• An atom is satisfied iff the mappings in a binding map the variables in the atom to domain elements that are in the extension description / in the extension of the property / the same / different.
• An antecedent is satisfied iff it has no atoms or each atom in it is satisfied.
• A consequent is satisfied iff it has an atom and each atom in it is satisfied.
• A rule is satisfied by an interpretation iff every binding that satisfies the antecedent also satisfies the consequent.
• The semantic conditions relating to axioms and ontologies are unchanged, so an interpretation satisfies an ontology iff it satisfies every axiom (including rules) and fact in the ontology.

Syntax (XML and RDF)

• XML syntax provided for ORL rules.
  • Simple extension of XML syntax for OWL.
  • Details in the paper (only).
• RDF syntax possible, but ...
• It is difficult (maybe impossible) to fit rules into the RDF vision.
  • How to represent variables without inappropriate consequences.
    • Similar to, but more difficult than, the problems encountered trying to fit OWL into the RDF vision.
  • ORL has an RDF-compatible syntax, but its semantics is not compatible with RDF semantics;
    • Treats triples for variables and rules as syntax-only, with no individual semantic consequences.

ORL Rules and Material Implication

• Rules are just like material implications.
• Can think of
  parent(?a,?b) ∧ brother(?b,?c) → uncle(?a,?c)
  as a version of
  ∀ ?a,?b,?c     parent(?a,?b) ∧ brother(?b,?c) ⊃ uncle(?a,?c).
• So, if John ∈ ≤0 uncle and John ∈ (father : Jack )
  then Jack ∈ ≤0 brother.
• This might not be what is expected!
  • Other meanings are harder to define, especially within OWL semantics.
  • Partial implementations can capture forward-chaining rule portion of this meaning.

Examples

Transferring style from an artist to his/her paintings
(from Guus Schreiber).

• Artist(?x) ∧ Style(?y) ∧ artistStyle(?x, ?y) ∧ creator(?x, ?z)
→ style/period(?z, ?y)

Inheriting trauma from body parts
(often needed in medical ontologies).

• Location(?x) ∧ Trauma(?y) ∧ isLocationOf(?x, ?y) ∧ isPartOf(?x,?z)
→ isLocationOf(?z, ?y)

Airport / Location Example

(From a larger example by Mike Dean.)

• Location(?maploc) ∧ sameLocation(?loc,?maploc) ∧
latitude(?loc,?lat) ∧ longitude(?loc,?lon)
→ latitude(?maploc,?lat) ∧ latitude(?maploc,?lon)
• Airport(?airport) ∧ location(?airport,?loc) ∧
latitude(?loc,?lat) ∧ longitude(?loc,?lon)
→ ( ∃ sameLocation ( Location ∩
          ∃ isLocationOf ( Point ∩
                    ∃ isObjectOf ( { layer } ) ) ) )(?loc)
• Airport(?airport) ∧ location(?airport,?loc) ∧
sameLocation(?loc,?maploc) ∧ Location(?point,?maploc) ∧ name(?airport,?name)
→ underlyingObject(?point,?airport) ∧ label(?point,?name)

Consequences

• OWL DL plus rules (of almost any sort) is undecidable.
  • OWL DL version of ORL is undecidable.
• OWL DL plus rules can be implemented.
  • OWL DL can be translated to FOL, and so can OWL DL plus rules.
  • Rules can be incorporated into a DL reasoner;
    • Inside the reasoner - complete (but nonterminating) - [maybe?].
    • Outside the reasoner - incomplete (but still probably nonterminating).

Current Status

• ORL has morphed into the Semantic Web Rules Language SWRL.
  • Produced by the Joint US/EU ad hoc Agent Markup Language Committee.
• SWRL has some pieces that ORL lacks;
  • Richer XML serialization syntax,
  • Built-in functions.
• SWRL has an implementation.
  • Hoolet can translate OWL DL plus SWRL rules into first-order logic and use Vampire to perform SWRL reasoning.

Conclusion

• ORL is not the final word in this area:
  • Monotonic,
  • May be too powerful.
• Nevertheless, ORL is a good starting point;
  • Target for implementation,
  • Particularly, partial implementations.