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:
- Why:
- How:
- The Fine Print:
- Everything you really need to know.
- What you might not expect.
- Examples
- 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:
- 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.
- 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.