+
Rules
Mariano Rodriguez-Muro,
Free University of Bozen-Bolzano

+
Disclaimer

License

This work is licensed under a
Creative Commons Attribution-Share Alike 3.0 License
(http://creativecommons.org/licenses/by-sa/3.0/)

+
Reading material

Chapter 7. Semantic Web Programming

Chapter 6. Foundations of Semantic Web.

+
What are rules

Means of representing knowledge

An ontology language

Can be seen as conditions statements:
if []
then []

if x is a Man and x hasChild y Father(x)

+
Why rules

Easy to understand

RDFS (and sometimes OWL) is not enough:
If a person x is the brother of somebody y, and there is z such that z is
the uncle of x, then z is the uncle of y too.
for all x,y,z, if hasBrother(x,y) & hasUncle(x,z) then hasUncle(y,z)

+
SWRL

+
7
SWRL

How can datalog and OWL be combined?

SWRL – Semantic Web Rule Language [swirl]
•
Proposal for a rule based Semantic Web Language (W3C member
submission)
http://www.w3.org/Submission/SWRL/
•
Idea: datalog rules referring to RDF classes/properties
Symbols in rules can be OWL identifiers or new symbols
•
Various further features and syntactic forms
•
Support in inference engines (very wide spread support)

+
SWRL Syntaxes

Two syntaxes:
1.
Abstract syntax based on “Extended Backus-Naur Form
notation
1. Directly translatable to a Human readable syntax (SPARQL
lie)
2.
XML Concrete Syntax
1. Parsable by existing OWL/RDF/XML parsers
2. Suitable as a exchange language for the semantic web

+
Abstract Syntax

+
Abstract Syntax Example
For the rule:
The corresponding abstract syntax:

+
Example 1
A very common use for rules is to move
property values from one individual to a
related individual
Express the fact that the style of an art
object is the same as the style of the
creator.
Artist(?x) & artistStyle(?x,?y) & Style(?y) & creator(?z,?x) ⇒ style/period(?z,?y)
Implies(Antecedent(Artist(I-variable(x))
artistStyle(I-variable(x) I-variable(y))
Style(I-variable(y))
creator(I-variable(z) I-variable(x)))
Consequent(style/period(I-variable(z) I-variable(y))))

+
RDFS as rules

Provide a translation of all RDFS axiom as rules

subClassOf

subPropertyOf

domain

range

+
Beyond RDFS

Transitivity of a property P

Reflexivity of a property P

Inverse of a property P

Equivalence of properties/classes

Sufficient conditions for class membership

+
Built ins

One of the main motivations for SWRL rules

Provide means to manipulate data

Comparisons

Mathematical transformations

List operators

Modifiers for strings, dates and times

Boolean and URI checks

URI construction

+
Built-ins examples
hasAddress(?creditCardMachine, ?ccAddress) ^
hasAddress(?customer, ?custAddress) ^
hasState(?ccAddress, ?ccState) ^
hasState(?custAddress, ?custState) ^
swrlb:equal(?custState, ?ccState) ^
hasBirthday(?customer, ?bDate) ^
swrlb:subtractYearMonthDurations(?diff, ?today, ?bDate) ^
swrlb:greaterThanOrEqual(?diff, "P18Y0M")
→ LegalCigaretteBuyer(?customer)

+
Built-ins examples
foaf:Person(?person) ^
foaf:gender(?person, "female") ^
foaf:name(?person, ?name)
→ swrlb:stringConcat(?s, "Dear Ms. ", ?name, ":") ^
hasFormalGreeting(?person, ?s)

+
Empty antecedents/consequent

Empty antecedent indicate the
consequent is ALWAYS true

State class/property
disjointness

Empty consequents indicate the
antecedent is a contradiction

State a FK-like constraint

State number-restriction
constraints

Allow to define FACTs and
CONSTRAINTS

+
XML Concrete Syntax
•
Based on OWL XML Presentation Syntax and RuleML
•
The SWRL XML syntax uses the OWL XML Ontology root
element and some of its subelements:
•
VersionInfo
•
PriorVersion
•
BackwardCompatibleWith
•
IncompatibleWith
•
Imports
•
Annotation
•
Class
•
EnumeratedClass
•SubClassOf
•EquivalentClasses
•DisjointClasses
•DatatypeProperty
•ObjectProperty
•SubPropertyOf
•EquivalentProperties
•Individual
•SameIndividual
•DifferentIndividuals

+
XML Elements (1)
•
VAR
•
IMP

+
XML Element (2)
•
Rlab
•
Body
•
Head

+
XML Elements (cont)
•
classAtom

+
XML Elements (cont)
•
datarangeAtom

+
XML Elements (cont)
•
individualPropertyAxiom

+
XML Elements (cont)
•
datavaluedPropertyAxiom

+
XML Elements (cont)
•
sameIndividualAtom

+
XML Elements (cont)
•
differentIndividualsAtom

+
XML Elements (cont)
•
builtInAtom

Built in atoms include: Comparison, Mathematical transformations, List operators, Modifiers for strings, dates and times,
Boolean and URI checks, URI constructions

+
When RDFS/Rules
RDFS/OWL

Expressivity for RDFS/OWL
is enough

Use is knowledge sharing

Application requires high
performance/uses
specialized reasoner

Application requires standard
behavior
Rules

Expressivity only captures by
rules

Use is application behavior

Application requires complex
reasoning

Application relies on a particular
inference engine only

+
Conclusion

Rules are a VERY expressive (powerful) ontology language

Rules can capture most inferences provided by RDFS (part of OWL
too)

Rules shouldn’t be abused. Performance of rule based reasoning is
suboptimal w.r.t. RDFS/OWL specialized reasoning.

Rules can be a powerful mean to capture application behiavor.

Note, although SWRL is the defacto rule language for the semantic
web, there are new standards, i.e. RIF, that might take over in the
future (further information in FSW Chapter 6)