Swrl 0 6 a semantic web rule language combining owl and ruleml
Sponsored Links
This presentation is the property of its rightful owner.
1 / 11

SWRL 0.6 A Semantic Web Rule Language Combining OWL and RuleML PowerPoint PPT Presentation

  • Uploaded on
  • Presentation posted in: General

SWRL 0.6 A Semantic Web Rule Language Combining OWL and RuleML. Ian Horrocks, Peter F. Patel-Schneider, Harold Boley, Said Tabet, Benjamin Grosof, Mike Dean presented by Axel Polleres http://www.daml.org/rules/proposal/. Overview. SWRL Overview Abstract Syntax Model-Theoretic Semantics

Download Presentation

SWRL 0.6 A Semantic Web Rule Language Combining OWL and RuleML

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript

SWRL 0.6A Semantic Web Rule Language Combining OWL and RuleML

Ian Horrocks, Peter F. Patel-Schneider, Harold Boley, Said Tabet, Benjamin Grosof, Mike Dean

presented by Axel Polleres



  • SWRL Overview

  • Abstract Syntax

  • Model-Theoretic Semantics

  • Not covered here: XML concrete Syntax/RDF concrete syntax

  • Usage Suggestions, why do we need rules?

  • Built-Ins

  • Decidability, why not?

SWRL Overview

  • Combines OWL DL + RuleML (basically: Horn Rules)

  • Straightforward combination

     Decidability is lost!

  • Document defines Semantics and different Syntax proposals

  • Examples for rules and usage in the document

Abstract Syntax

  • Extends OWL DL abstract syntax by a further axiom:

    axiom::= rule


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

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

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

    atom ::= description '(' i-object ')'

    | dataRange '(' d-object i-object ')'

    | individualvaluedPropertyID '(' i-object i-object ')'

    | datavaluedPropertyID '(' i-object d-object ')'

    | sameAs '(' i-object i-object ')'

    | differentFrom '(' i-object i-object ')'

    | builtIn '(' builtIn builtinID { d-object } ')'

    builtinID ::= URIreference

Hmmm, typo?

Only syntactic sugar,

can be expressed by OWL

Abstract Syntax cont’d

i-object ::= i-variable | individualID

d-object ::= d-variable | dataLiteral

i-variable ::= 'I-variable(' URIreference ')'

d-variable ::= 'D-variable(' URIreference ')'

  • Basically, you can model Horn rules where atoms can be

    C(x), P(x,y), sameAs(x,y), differentFrom(x,y),or builtIn(r,x,...) where C is an OWL description or data range, P is an OWL property, r is a built-in relation, x and y are either variables, OWL individuals or OWL data values, as appropriate.

  • Safety (cf. Ullman) is required, i.e. vars in the head have to be bound in the body.

    no magic … we now use a more human readable syntax.


  • As usual rules are satisfied by an interpretation if every variable binding satisfying the antecedent also satisfies the consequent.

  • Semantics of OWL unchanged, an interpretation

  • Satisfies an OWL ontology if all axioms (incl. rules) are satisfied.

  • No magic, no sophisticated semantics

  • BUT: decidability of either DL or Datalog alone

    is lost 

Where has all the decidability gone?

  • Problem: existential quantifiers

    + recursive rules…

    For instance (in DL syntax):

    C1(X) :- C2(X).

    C1 ⊑ ∃R.C2*


by skolemization creates C(f(a))


… etc.

* Corresponds to a rule: (∃Y.R(X,Y)) :- C2(X) which amounts to ∀ X.∃Y.R(X,Y)) v not C2(X)

Where has all the decidability gone? Cont’d

  • The simple example from the last slide might still be solved with a blocking strategy in the evaluation algorithm, but…

  • … in general, interaction of existential quantifiers and recursive rules causes troubles, by introducing function symbols

  • It is not yet completely clear to me which SWRL “fragment” is fine…

State of discussion:

  • Which F-Logic fragment corresponds how to which SWRL fragment?

    (copied from deri-wsmo-discussion, thread:

    FvH> how weak must subsets of SWRL and

    FvH> pragmatic FLogic be before they start to diverge?

    MK> My guess is that they coincide on their pure Horn subsets and that

    MK> this is the maximal such subset.

    FvH> Thanks again for confirming this. I still think the rules must also be

    FvH> non-recursive for the two to coincide (from another point in your

    FvH> email, I think we agree on this).

    RV> Personally, I don't understand why rules have to be non-recursive. This

    RV> is definitely not the case for the DLP fragment.

    MK> I don't understand either. Why does recursion fall outside of the intersection of SWRL and F-logic?

    MK> But in SWRL you can have recursion, no?

    RV> Yes.

    MK> So then recursion is in the intersection, I think.

  • Maybe Michael can comment on this further?

  • Reference for complexity & decidability of Logic Programming:

    Complexity and Expressive Power of Logic Programming , E. Dantsin, T. Eiter, G. Gottlob, and A. Voronkov

    TR version, 1999: http://www.kr.tuwien.ac.at/research/reports/rr9905.ps.gz

    Should be one of the next presentations probably in the DERI research seminar!

Conclusion & Outlook

  • Simple combination of DL and rules loses decidability.

  • Related works:

    • CARIN (Levy, Rousset, 1996)

    • Recent paper by Eiter et al. (KR 2004)

    • Description Logic Programs by Horrocks et al. (WWW 2003)

  • These works partly try to combine LP and DLs differently or impose syntactical restrictions for DL or for the rules.

Use for WSMO

  • F-Logic is FOL, thus undecidable… well, ok, semi-decidable.

  • F-Logic as in Flora is decidable but uses non-classical semantics, namely well-founded semantics for negation.

  • Use cases shall show which expressivity we need.

  • As long as we only use Horn-rules in F-Logic and don’t use function symbols, we are fine, since we don’t have existential introduction as in OWL, or no?

  • comments please! follow the discussions on the list… What are the next steps?

  • Login