This document discusses rules and the Semantic Web Rule Language (SWRL). It defines rules as a means of representing knowledge similar to if-then statements. SWRL combines OWL and rule-based languages by allowing users to write rules that can refer to OWL classes, properties, individuals and datatypes. SWRL has an abstract and XML syntax and supports built-in predicates for manipulating data types. Rules provide more expressivity than RDFS and OWL in some cases, such as defining application behaviors, but rule-based reasoning is less performant so they should not be overused when RDFS/OWL suffice.

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

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

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

4. +
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)

5. +
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)

6. +
SWRL

7. +
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)

8. +
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

9. +
Abstract Syntax

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

11. +
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))))

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

13. +
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

14. +
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

15. +
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)

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

17. +
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

18. +
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

19. +
XML Elements (1)
•
VAR
•
IMP

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

21. +
XML Elements (cont)
•
classAtom

22. +
XML Elements (cont)
•
datarangeAtom

23. +
XML Elements (cont)
•
individualPropertyAxiom

24. +
XML Elements (cont)
•
datavaluedPropertyAxiom

25. +
XML Elements (cont)
•
sameIndividualAtom

26. +
XML Elements (cont)
•
differentIndividualsAtom

27. +
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

28. +
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

29. +
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)