1. Chapter 5 Logic and Inference: Rules
Grigoris Antoniou
Paul Groth
Frank van Harmelen
Rinke Hoekstra
Chapter 5
A Semantic Web Primer

2. Lecture Outline Introduction
Example of Monotonic Rules: Family Relationships
Monotonic Rules: Syntax
OWL2 RL: Description Logic Meets Rules
Rule Interchange Format: RIF
Semantic Web Rules Language (SWRL)
Rules in SPARQL: SPIN
Nonmonotonic Rules: Motivation and Syntax
Example of Nonmonotonic Rules: Brokered Trade
Rule Markup Language (RuleML)
Summary
Chapter 5
A Semantic Web Primer

3. Knowledge Representation
The subjects presented so far were related to the representation of knowledge （知识表示，KR）
Knowledge about content of Web resources
Knowledge about concepts and their relationships
Knowledge representation was studied long before the emergence of WWW in AI, or even earlier in philosophy (e.g. ancient Greek Aristotle, father of logic)
Logic is still the foundation of KR, particularly in the form of predicate logic (aka first-order logic)
Chapter 5
A Semantic Web Primer

4. The Importance of Logic
High-level language for expressing knowledge in a transparent way
High expressive power
Well-understood formal semantics, assigning an unambiguous meaning to logical statements
A precise notion of logical consequence （逻辑后承，也称为逻辑推论）, determining whether a statement follows semantically from a set of other statements (premises，前提)
The primary motivation of logic was the study of objective laws（客观）of logical consequence
Chapter 5
A Semantic Web Primer

5. The Importance of Logic
Proof systems（证明系统）can automatically derive statements syntactically from a set of premises
There exist proof systems for which semantic logical consequence coincides with syntactic derivation
Soundness（正确性）: all derived statements semantically follow premises
Completeness（完备性）: all logical consequences of premises can be derived 5
Chapter 5
A Semantic Web Primer

6. The Importance of Logic
Predicate logic is unique in the sense that sound and complete proof systems do exist
Not for more expressive logics (higher-order logics)
Because of the existence of proof systems, logic can provide explanations for answers by tracing a proof that leads to a logical consequence
Chapter 5
A Semantic Web Primer

7. Specializations of Predicate Logic: RDF and OWL2 Profiles
RDF and OWL2 profiles are specializations of predicate logic
They provide a syntax that fits well with the intended use（使用目的） – Web languages based on tags
They define reasonable subsets of logic
Trade-off between the expressive power and the computational complexity
Most OWL variants correspond to a description logic , a subset of predicate logic
Chapter 5
A Semantic Web Primer

8. Specializations of Predicate Logic: Horn Logic (Rule Systems)
A rule has the form: A1, . . ., An  B
Ai and B are atomic formulas (a formula that contains no logical connectives or equivalently a formula that has no strict subformulas )
There are 2 ways of reading such a rule:
Deductive rules（推导式规则）: If A1,..., An are known to be true, then B is also true
Reactive rules（反应式规则）: If the conditions A1,..., An are true, then carry out the action B
Chapter 5
A Semantic Web Primer

9. Description Logics vs. Horn Logic
Orthogonal（正交的）: neither of them is a subset of the other
It is impossible to define the class of happy spouses as those who are married to their best friend in description logics
This can be done easily using rules:
married(X, Y), bestFriend(X, Y)  happySpouse(X, Y)
Chapter 5
A Semantic Web Primer

10. Description Logics vs. Horn Logic
On the other hand, rules cannot (in the general case) assert
Negation/complement of classes
Disjunctive/union information (e.g. a person is either a man or a woman)
Existential quantification (存在量化，e.g. all persons have a father) 10
Chapter 5
A Semantic Web Primer

11. Monotonic vs. Non-monotonic Rules
Example: An online vendor wants to give a special discount if it is a customer’s birthday
Solution 1
R1: If birthday, then special discount
R2: If not birthday, then not special discount
But what happens if a customer refuses to provide his birthday due to privacy concerns?
Chapter 5
A Semantic Web Primer

12. Monotonic vs. Non-monotonic Rules
Solution 2
R1: If birthday, then special discount
R2’: If birthday is not known, then not special discount
Solves the problem but:
The premise of rule R2' is not within the expressive power of predicate logic
We need a new kind of rule system
Chapter 5
A Semantic Web Primer

13. Monotonic vs. Non-monotonic Rules
The solution with rules R1 and R2 works in case we have complete information about the situation
The new kind of rule system will find application in cases where the available information is incomplete
Predicate logic and its special cases are monotonic（单调的）in the following sense
Chapter 5
A Semantic Web Primer

14. Monotonic vs. Non-monotonic Rules
If a conclusion can be drawn, it remains valid even if new knowledge becomes available
But, the conclusion “not special discount” in rule R2’ may become invalid if the customer’s birthday becomes known at a later stage
R2’: If birthday is not known, then not special discount
This behaviour is nonmonotonic（非单调的）because the addition of new information leads to a loss of consequence 14
Chapter 5
A Semantic Web Primer

15. Rules on the Semantic Web
Rule technology has been around for decades, finding extensive use in practice and reaching significant maturity
It is far more difficult to standardize this area in the context of the (Semantic) Web
A W3C working group has developed the Rule Interchange Format (RIF) standard
was designed for the exchange of rules across different applications
Chapter 5
A Semantic Web Primer

16. Rules on the Semantic Web
Intended to serve as an interchange format among different rule systems, RIF combines many features, thus being quite complex
There are various alternatives
Rules over RDF can be expressed using SPARQL constructs; one recent proposal is SPIN
SWRL couples OWL DL functionality with certain types of rules
OWL2 RL 16
Chapter 5
A Semantic Web Primer

17. Lecture Outline 17 Introduction
Example of Monotonic Rules: Family Relationships
Monotonic Rules: Syntax
OWL2 RL: Description Logic Meets Rules
Rule Interchange Format: RIF
Semantic Web Rules Language (SWRL)
Rules in SPARQL: SPIN
Nonmonotonic Rules: Motivation and Syntax
Example of Nonmonotonic Rules: Brokered Trade
Rule Markup Language (RuleML)
Summary 17
Chapter 5
A Semantic Web Primer

18. Family Relationships Facts in a database about relationships:
mother (X,Y), X is the mother of Y
father (X,Y) X is the father of Y
male(X) X is male
female(X), X is female
Inferred relationships using rules parent: a parent is either a father or a mother
mother (X,Y)  parent (X,Y)
father (X,Y)  parent (X,Y)
Chapter 5
A Semantic Web Primer

19. Inferred Relationships
We can also define a brother to be a male person sharing a parent:
male (X), parent (P, X), parent (P, Y), notSame (X, Y)  brother (X, Y)
Similarly, we can define sister as follows
female(X), parent(P,X), parent(P,Y), notSame(X,Y)  sister(X,Y)
Chapter 5
A Semantic Web Primer

20. Inferred Relationships
An uncle is a brother of a parent:
brother (X,P), parent (P,Y)  uncle (X,Y)
A grandmother is the mother of a parent
mother (X,P), parent (P,Y)  grandmother (X,Y)
An ancestor is either a parent or an ancestor of a parent
parent (X,Y)  ancestor (X,Y)
ancestor (X,P), parent (P,Y)  ancestor (X,Y) 20
Chapter 5
A Semantic Web Primer

21. Inferred Relationships
How to define a relationship cousin?
We can define a cousin to be a person who is the child of the brother/sister of a parent:
parent (X,Y), brother(P,X), parent(P, U)  cousin (Y,U)
parent (X,Y), sister(P,X), parent(P, U)  cousin (Y,U) 21
Chapter 5
A Semantic Web Primer

22. Lecture Outline 22 Introduction
Example of Monotonic Rules: Family Relationships
Monotonic Rules: Syntax
OWL2 RL: Description Logic Meets Rules
Rule Interchange Format: RIF
Semantic Web Rules Language (SWRL)
Rules in SPARQL: SPIN
Nonmonotonic Rules: Motivation and Syntax
Example of Nonmonotonic Rules: Brokered Trade
Rule Markup Language (RuleML)
Summary 22
Chapter 5
A Semantic Web Primer

23. Monotonic Rules – Syntax
loyalCustomer (X), age(X) > 60  discount (X)
We distinguish some ingredients of rules:
Variables（变量）which are placeholders for values: X
Constants（常量）denote fixed values: 60
Predicates（谓词）relate objects: loyalCustomer, discount
Function symbols （函数符号）which return a value for certain arguments: age
Chapter 5
A Semantic Web Primer

24. Rules B1, . . . , Bn  A A, B1, ... , Bn are atomic formulas
A is the head of the rule
B1, ... , Bn are the premises (body of the rule)
The commas in the rule body are read conjunctively（合取）
Variables may occur in A, B1, ... , Bn
loyalCustomer (X), age(X) > 60  discount (X) (applied to any customer)
Implicitly universally quantified（全称量化）
Chapter 5
A Semantic Web Primer

25. Rules B1, . . . , Bn  A 25 In summary, a rule r
is interpreted as the following formula, denoted by pl(r):
X1···Xk((B1  ···  Bn)  A)
Or equivalently,
X1···Xk(A  ¬ B1   ¬ Bn)
where X1,…Xk are all variables occurring in A, B1,…, Bn 25
Chapter 5
A Semantic Web Primer

26. Facts and Logic Programs
A fact（事实）is an atomic formula, e.g. loyalCustomer(a345678)
The variables of a fact are implicitly universally quantified
A logic program（逻辑程序）P is a finite set of facts and rules
Its predicate logic translation（谓词逻辑解释）pl(P) is the set of all predicate logic interpretations of rules and facts in P
Chapter 5
A Semantic Web Primer

27. Goals A goal denotes a query G asked to a logic program
The form: B1, , Bn 
If n = 0 we have the empty goal 
Chapter 5
A Semantic Web Primer

28. Predicate Logic Interpretation of Goals
X1···Xk(¬ B1   ¬ Bn)
Where X1, ... , Xk are all variables occurring in B1 , ..., Bn
Same as pl(r), with the rule head omitted
Equivalently: ¬ X Xk (B1   Bn)
Suppose we know p(a) and we have the goal p(X) 
We want to know if there is a value for which p(X) is true
We expect a positive answer because of the fact p(a)
Thus p(X) is existentially quantified（存在量化）
Chapter 5
A Semantic Web Primer

29. Why Negate the Formula?
We use a proof technique from mathematics called proof by contradiction （反证法）:
Prove that A follows from B by assuming that A is false and deriving a contradiction, when combined with B
In logic programming we prove that a goal can be answered positively by negating the goal and proving that we get a contradiction using the logic program
e.g., given the following logic program we get a logical contradiction
Chapter 5
A Semantic Web Primer

30. An Example p(a) ¬X p(X)
The 2nd formula says that no element has the property p
The 1st formula says that the value of a does have the property p
Thus Xp(X) follows from p(a)
Chapter 5
A Semantic Web Primer

31. Lecture Outline 31 Introduction
Example of Monotonic Rules: Family Relationships
Monotonic Rules: Syntax
OWL2 RL: Description Logic Meets Rules
Rule Interchange Format: RIF
Semantic Web Rules Language (SWRL)
Rules in SPARQL: SPIN
Nonmonotonic Rules: Motivation and Syntax
Example of Nonmonotonic Rules: Brokered Trade
Rule Markup Language (RuleML)
Summary 31
Chapter 5
A Semantic Web Primer

32. OWL2 RL: DL Meets Rules
Description logics and horn logic（function-free rule system）are orthogonal
To integrate both into one framework, the simplest approach is to consider the intersection of both logics
The part of one language can be translated in a semantics-preserving way to the other―OWL2 RL seeks to capture this fragment of OWL 32
Chapter 5
A Semantic Web Primer

33. OWL2 RL: DL Meets Rules 33 Advantages:
From the modeler’s perspective, one can use either OWL or rules for modeling purposes
From the implementation perspective, either description logic reasoners or deductive rule systems can be used
We will show how many constructs of RDFS and OWL2 RL can be expressed in Horn logic and some constructs that cannot be 33
Chapter 5
A Semantic Web Primer

34. RDF and RDF Schema
A triple of the form (a,P,b) in RDF can be expressed as a fact P(a,b)
An instance declaration of the form type(a,C) (stating a is an instance of class C) can be expressed as C(a)
The fact that C is a subclass (or subproperty) of D can be expressed as C(X)  D(X)
C is the domain of property P: P(X, Y)  C(X)
Chapter 5
A Semantic Web Primer

35. OWL
equivalentClass(C,D) (or equivalentProperty) can be expressed by the pair of rules
C(X)  D(X)
D(X)  C(X)
Transitivity of a property P can be expressed as
P(X,Y),P(Y,Z)  P(X,Z)
Chapter 5
A Semantic Web Primer

36. OWL
The intersection of C1 and C2 is a subclass of D can be expressed as
C1 (X),C2(X)  D(X)
C is subclass of the intersection of D1 and D2 can be expressed as
C(X)  D1(X)
C(X)  D2(X)
Chapter 5
A Semantic Web Primer

37. OWL
The union of C1 and C2 is a subclass of D can be expressed by the pair of rules
C1(X)  D (X)
C2(X)  D (X)
The opposite direction cannot be expressed in Horn logic. There are cases where the translation is possible
For instance, D1 is a subclass of D2, and the rule C(X)  D2 (X) is sufficient to express C is a subclass of union of D1 and D2
How about C is a subclass of the union of D1 and D2?
Chapter 5
A Semantic Web Primer

38. Restrictions in OWL :C rdfs:subClassOf [rdf:type owl:Restriction;
owl:onProperty :P;
owl:allValuesFrom :D].
can be expressed in Horn logic as follows:
C(X), P(X, Y)  D(Y)
The opposite direction cannot in general be expressed
Chapter 5
A Semantic Web Primer

39. Restrictions in OWL [rdf:type owl:Restriction; owl:onProperty :P;
owl:someValuesFrom :D] rdfs:subClassOf :C.
can be expressed in Horn logic as follows:
P(X, Y), D(Y)  C(X)
The opposite direction cannot in general be expressed
Also, cardinality constraints and complement classes cannot be expressed
Chapter 5
A Semantic Web Primer

40. Lecture Outline 40 Introduction
Example of Monotonic Rules: Family Relationships
Monotonic Rules: Syntax
OWL2 RL: Description Logic Meets Rules
Rule Interchange Format: RIF
Semantic Web Rules Language (SWRL)
Rules in SPARQL: SPIN
Nonmonotonic Rules: Motivation and Syntax
Example of Nonmonotonic Rules: Brokered Trade
Rule Markup Language (RuleML)
Summary 40
Chapter 5
A Semantic Web Primer

41. Rule Interchange Format: RIF
Rule Technology have existed for decades, exhibiting a broad variety
The aim of the W3C Rule Interchange Format Working Group was not to develop a new rule language that would fit all purposes
Rather, it would focus on the interchange among various rule systems on the Web
The approach was to develop a family of languages, called dialects: logic-based dialects and rules with actions 41
Chapter 5
A Semantic Web Primer

42. Logic-based Dialects
These are meant to include rule languages that are based on some form of logic, e.g. first-order logic and various logic programming approaches
The concrete dialects developed so far under this branch are:
RIF Core, essentially corresponding to function-free Horn logic
RIF Basic Logic Dialect (BLD), essentially corresponding to Horn logic with equality 42
Chapter 5
A Semantic Web Primer

43. Rules with Actions
These are meant to include production systems and reactive rules
The concrete dialect developed so far in this branch is
Production Rule Dialect (RIF-PRD) 43
Chapter 5
A Semantic Web Primer

44. RIF-BLD
Expected to support a uniform set of commonly used data types (integer, boolean, string, date), “built-in” predicates (numeric-greater than, starts-with), and functions (replace, numeric-subtract) ranging over these data types
Suppose we wish to express the following rules:
An actor is a movie star if he has starred in more than three successful movies, produced in a span of at least five years
A film is successful if it has received critical acclaim（欢呼喝彩）or was financially successful 44
Chapter 5
A Semantic Web Primer

45. Rules Expressed in RIF-BLD
Document {
Prefix(func <
Prefix(pred <
Prefix(rdfs <
Prefix(imdbrel <
Prefix(dbpedia <
Prefix(ibdbrel <
Group( 45
Chapter 5
A Semantic Web Primer

46. Rules Expressed in RIF-BLD
Forall ?Actor ?Film ?Year (
If And( dbpedia:starring(?Film ?Actor)
dbpedia:dateOfFilm(?Film ?Year)
Then dbpedia:starredInYear(?Film ?Actor ?Year) } 46
Chapter 5
A Semantic Web Primer

47. Rules Expressed in RIF-BLD
Forall ?Actor (
if (Exists ?Film1 ?Film2 ?Film3 ?Year1 ?Year2 ?Year3
And (dbpedia:starredInYear(?Film1 ?Actor ?Year1)
dbpedia:starredInYear(?Film2 ?Actor ?Year2)
dbpedia:starredInYear(?Film3 ?Actor ?Year3)
External (pred:numeric-greater-than (
External(funcnumeric-subtract ?Year1 ?Year3) 5))) 47
Chapter 5
A Semantic Web Primer

48. Rules Expressed in RIF-BLD
dbpedia:successful(?Film1)
dbpedia:successful(?Film2)
dbpedia:successful(?Film3)
External (pred:literal-not-identical(?Film1 ?Film2))
External (pred:literal-not-identical(?Film1 ?Film3))
External (pred:literal-not-identical(?Film2 ?Film3)) }
Then dbpedia:movieStar(?Actor) ) 48
Chapter 5
A Semantic Web Primer

49. Rules Expressed in RIF-BLD
Forall ?Film (
If Or (
External(pred:numeric-greater-than(
dbpedia:criticalRating(?Film 8))
dbpedia:boxOfficeGross(?Film) )))
Then dbpedia:successful(?Film) ) 49
Chapter 5
A Semantic Web Primer

50. Rules Expressed in RIF-BLD
The use of External in applying built-in predicate
The use of Group to put together a number of rules
The use of frames
The basic idea is to represent objects as frames and their properties as slots
Information expressed in RIF-BLD using the notation
oid[slot1->value1…slotn->valuen] 50
Chapter 5
A Semantic Web Primer

51. Compatibility with RDF and OWL
A major feature of RIF is that it is compatible with the RDF and OWL standards
One can reason a combination of RIF, RDF, and OWL documents
The basic idea of combining RIF with RDF is to represent RDF triples using RIF frame formulas
A triple s p o is represented as s[p -> o]
The semantic definitions are the triple is satisfied iff the corresponding RIF frame formula is satisfied, too 51
Chapter 5
A Semantic Web Primer

52. Compatibility with RDF and OWL
For example, if the RDF triple
ex:GoneWithTheWind ex:FilmYear ex:1939
is true, then so is the RIF fact
ex:GoneWithTheWind[ex:FilmYear->ex:1939] 52
Chapter 5
A Semantic Web Primer

53. Compatibility between RDF and RIF
Given the RIF rule (which states that the Hollywood Production Code was in place between 1930 and 1968)
Group(
Forall ?Film(
If And( ?Film[ex:FilmYear->?Year]
External(pred:dateGreaterThan(?Year 1930))
External(pred:dateGreaterThan(1968 ?Year)))
Then ?Film[ex:HollywoodProductionCode->ex:True] )
ex:GoneWithTheWind[ex:HolywoodProductionCode->ex:True]
ex:GoneWithTheWind ex:HolywoodProductionCode ex:True 53
Chapter 5
A Semantic Web Primer

54. Compatibility between OWL and RIF
Similar techniques are used to achieve compatibility between OWL and RIF
The main features are:
The semantics of OWL and RIF are compatible
One can infer conclusions from certain combinations of OWL axioms and RIF knowledge
OWL2 RL can be implemented in RIF 54
Chapter 5
A Semantic Web Primer

55. OWL2 RL in RIF
OWL2 RL is partially described by a set of first-order rules, thus forming the basis for implementation using rules
OWL2 RL rules can be categorized in four categories:
Triple pattern rules
Inconsistency rules
List rules
Datatype rules 55
Chapter 5
A Semantic Web Primer

56. Triple Pattern Rules
Derive certain RDF triples from a conjunction of RDF triple patterns
The triple pattern rules take the form:
If then
T(s1, p1, o1) T(s, p, o) T(sn, pn, on)
where each argument to the T predicate may be a variable, an IRI or literal value 56
Chapter 5
A Semantic Web Primer

57. Triple Pattern Rules
Translation of these rules to the RIF core presentation syntax is straightforward:
Group (    Forall ?v1 ... ?vn (      s[p->o] :- And( s1[p1->o1] ... sn[pn->on] ))  ) 57
Chapter 5
A Semantic Web Primer

58. Inconsistency Rules
A number of the OWL2 RL rules detect inconsistencies in the original RDF graph. They express this by deriving a distinguished propositional symbol（命题符号）false. If
then
T(?p1, owl:propertyDisjointWith, ?p2)
T(?x, ?p1, ?y)
T(?x, ?p2, ?y)
false 58
Chapter 5
A Semantic Web Primer

59. such rules using a distinguished nullary predicate rif:error()
such rules using a distinguished nullary predicate rif:error(). If this predicate is derived then the original RDF graph is inconsistent under OWL 2 RL semantics
Inconsistency Rules
Such rules are translated using a distinguished nullary（空元）predicate rif:error().
If this predicate is derived then the original RDF graph is inconsistent under OWL 2 RL semantics
Forall ?p1 ?p2 ?x ?y ( rif:error() :- And( ?p1[owl:propertyDisjointWith->?p2]  ?x[?p1->?y]  ?x[?p2->?y] ) ) 59
Chapter 5
A Semantic Web Primer

60. List Rules
A number of OWL2 RL rules involve processing OWL expressions that include RDF lists
Two approaches are possible to express these rules in RIF
One may use recursive（递归）rules to traverse RDF graphs at runtime
One may take a preprocessing（预处理）approach in which rules are directly instantiated（实例化）for the lists that occurs in the input RDF graph
(See for more details.) 60
Chapter 5
A Semantic Web Primer

61. List Rules
For instance, inconsistent pairs rules check whether any pair of entries from a list match a certain criterion and if they do an error is signaled
eq-diff2
T(?x, rdf:type, owl:AllDifferent) T(?x, owl:members, ?y) LIST[?y, ?z1, ..., ?zn] T(?zi, owl:sameAs, ?zj)
false
for each 1 ≤ i < j ≤ n 61
Chapter 5
A Semantic Web Primer

62. List Rules
eq-diff2
T(?x, rdf:type, owl:AllDifferent) T(?x, owl:members, ?y) LIST[?y, ?z1, ..., ?zn] T(?zi, owl:sameAs, ?zj)
false
for each 1 ≤ i < j ≤ n
(* <#eq-diff2> *)
Forall ?x ?y ?z1 ?z2 ?iz1 ?iz2 ( rif:error() :- And (   ?x[rdf:type -> owl:AllDifferent]   ?x[owl:members -> ?y] External(pred:list-contains(?y ?z1)) ?iz1 = External(func:index-of(?y ?z1)) External(pred:list-contains(?y ?z2))  ?iz2 = External(func:index-of(?y ?z2)) External( pred:numeric-not-equal ( ?iz1 ?iz2 ) )   ?z1[owl:sameAs->?z2] ) ) 62
Chapter 5
A Semantic Web Primer

63. Datatype Rules
Provide type checking and value equality/inequality checking for typed literals
For example, such rules may derive owl:sameAs triples for literals with the same value (e.g. 1 and 1.0)
An inconsistency occurs when a literal is specified to be an instance of a data type but its value is outside the value space of that data type 63
Chapter 5
A Semantic Web Primer

64. Lecture Outline 64 Introduction
Example of Monotonic Rules: Family Relationships
Monotonic Rules: Syntax
OWL2 RL: Description Logic Meets Rules
Rule Interchange Format: RIF
Semantic Web Rules Language (SWRL)
Rules in SPARQL: SPIN
Nonmonotonic Rules: Motivation and Syntax
Example of Nonmonotonic Rules: Brokered Trade
Rule Markup Language (RuleML)
Summary 64
Chapter 5
A Semantic Web Primer

65. Semantic Web Rules Language
A rule in SWRL has the form
B1, … , Bn  A1, … , Am
Commas denote conjunction on both sides
A1, … , Am, B1, … , Bn can be of the form C(x), P(x,y), sameAs(x,y), or differentFrom(x,y)
where C is an OWL description, P is an OWL property, and x, y are Datalog variables, OWL individuals, or OWL data values 65
Chapter 5
A Semantic Web Primer

66. SWRL Properties
If the head of a rule has more than one atom, the rule can be transformed to an equivalent set of rules with one atom in the head
Expressions, such as restrictions, can appear in the head or body of a rule
This feature adds significant expressive power to OWL, but at the high price of undecidability（不可判定性） 66
Chapter 5
A Semantic Web Primer

67. OWL2 RL vs. SWRL
OWL2 RL uses a very conservative approach, trying to combine the advantages of both languages (description logics and function-free rules) in their common sublanguage
SWRL takes a more maximalist approach and unites their respective expressivities
The challenge is to identify sublanguages of SWRL that find the right balance between expressive power and computational tractability 67
Chapter 5
A Semantic Web Primer

68. Lecture Outline 68 Introduction
Example of Monotonic Rules: Family Relationships
Monotonic Rules: Syntax
OWL2 RL: Description Logic Meets Rules
Rule Interchange Format: RIF
Semantic Web Rules Language (SWRL)
Rules in SPARQL: SPIN
Nonmonotonic Rules: Motivation and Syntax
Example of Nonmonotonic Rules: Brokered Trade
Rule Markup Language (RuleML)
Summary 68
Chapter 5
A Semantic Web Primer

69. Rules in SPARQL: SPIN
Rules can be expressed in SPARQL using its CONSTRUCT feature
For instance, the rule
grandparent(X,Z)<-parent(Y,Z), parent(X,Y)
can be expressed as
CONSTRUCT {
?X grandParent ?Z.
} WHERE { ?Y parent ?Z.
?X parent ?Y. } 69
Chapter 5
A Semantic Web Primer

70. Ideas and Features of SPIN
Uses ideas of object-oriented modeling in associating rules to classes
Rules may represent behavior of that class
Expresses rules by SPARQL constructs CONSTRUCT, DELETE, and INSERT, and constraints using ASK
Provides abstract mechanisms for rules using Templates, which encapsulates parameterized SPARQL queries 70
Chapter 5
A Semantic Web Primer

71. OWL2 RL Rules Expressed in SPIN
For example, the rule
C2(X) <- C1(X), equivalentClass(C1, C2)
can be expressed in SPARQL as
CONSTRUCT {
?X rdf:type ?C2. }
WHERE {
?X rdf:type ?C1.
?C1 equivalentClass ?C2. 71
Chapter 5
A Semantic Web Primer

72. Lecture Outline 72 Introduction
Example of Monotonic Rules: Family Relationships
Monotonic Rules: Syntax
OWL2 RL: Description Logic Meets Rules
Rule Interchange Format: RIF
Semantic Web Rules Language (SWRL)
Rules in SPARQL: SPIN
Nonmonotonic Rules: Motivation and Syntax
Example of Nonmonotonic Rules: Brokered Trade
Rule Markup Language (RuleML)
Summary 72
Chapter 5
A Semantic Web Primer

73. Motivation – Negation in Rule Head
In nonmonotonic rule systems, a rule may not be applied even if all premises are known because we have to consider contrary（相矛盾的）reasoning chains
Now we consider defeasible （可废止）rules that can be defeated by other rules
Negated atoms（否定的原子公式）may occur in the head and the body of rules, to allow for conflicts
p(X)  q(X)
r(X)  ¬q(X) 73
Chapter 5
A Semantic Web Primer

74. Defeasible Rules 74 p(X)  q(X)
r(X)  ¬q(X)
Given also the facts p(a) and r(a), we conclude neither q(a) nor ¬q(a)
typical example of 2 rules blocking each other
Conflict may be resolved using priorities among rules
Suppose we knew somehow that the 1st rule is stronger than the 2nd, then we could derive q(a) 74
Chapter 5
A Semantic Web Primer

75. Origin of Rule Priorities
Higher authority
e.g. in law, federal law preempts（优先于）state law
e.g. in business administration, higher management has more authority than middle management
Recency（最近）
Specificity（特殊性）
A typical example is a general rule with some exceptions
We abstract from the specific prioritization principle
We assume the existence of an external priority relation on the set of rules 75
Chapter 5
A Semantic Web Primer

76. Rule Priorities r1: p(X)  q(X) 76 r2: r(X)  ¬q(X) r1 > r2
Rules have a unique label
The priority relation to be acyclic（无环的）
That is, it is impossible to have cycles of the form
r1 > r2> r3… > rn >r1 76
Chapter 5
A Semantic Web Primer

77. Competing Rules
In simple cases two rules are competing only if one head is the negation of the other
But in many cases once a predicate p is derived, some other predicates are excluded from holding
e.g., an investment consultant may base his recommendations on three levels of risk investors are willing to take: low, moderate, and high
Only one risk level per investor is allowed to hold 77
Chapter 5
A Semantic Web Primer

78. Defeasible Rules: Syntax
r : L1, ..., Ln  L
r is the label
{L1, ..., Ln } is the body (or premises) and L the head
L, L1, ..., Ln are positive or negative literals
A literal is an atomic formula p(t1,...,tm) or its negation ¬p(t1,...,tm)
No function symbols may occur in the rule 78
Chapter 5
A Semantic Web Primer

79. Defeasible Logic Programs
A defeasible logic program is a triple (F,R,>) consisting of
a set F of facts
a finite set R of defeasible rules
an acyclic binary relation > on R
A set of pairs r > r' where r and r' are labels of rules in R 79
Chapter 5
A Semantic Web Primer

80. Lecture Outline 80 Introduction
Example of Monotonic Rules: Family Relationships
Monotonic Rules: Syntax
OWL2 RL: Description Logic Meets Rules
Rule Interchange Format: RIF
Semantic Web Rules Language (SWRL)
Rules in SPARQL: SPIN
Nonmonotonic Rules: Motivation and Syntax
Example of Nonmonotonic Rules: Brokered Trade
Rule Markup Language (RuleML)
Summary 80
Chapter 5
A Semantic Web Primer

81. Brokered Trade
Brokered trades（有经纪人的交易）take place via an independent third party, the broker
The broker matches the buyer’s requirements and the sellers’ capabilities, and proposes a transaction when both parties can be satisfied by the trade
The application is apartment renting, an activity that is common and often tedious and time-consuming 81
Chapter 5
A Semantic Web Primer

82. The Potential Buyer’s Requirements
Carlos is looking for an apartment
At least 45 sq m with at least 2 bedrooms
Elevator if on 3rd floor or higher
Pet animals must be allowed
Carlos is willing to pay:
$ 300 for a centrally located 45 sq m apartment
$ 250 for a similar flat in the suburbs
An extra $ 5 per square meter for a larger apartment
An extra $ 2 per square meter for a garden
He is unable to pay more than $ 400 in total
If given the choice, he would go for the cheapest option
His second priority is the presence of a garden
His lowest priority is additional space 82
Chapter 5
A Semantic Web Primer

83. Formalization of Carlos’s Requirements – Predicates Used
apartment(x) stating x is an apartment
size(x,y) y is the size of apartment x (in sq m)
bedrooms(x,y) x has y bedrooms
price(x,y) y is the price for x
floor(x,y) x is on the y-th floor
garden(x,y) x has a garden of size y 83
Chapter 5
A Semantic Web Primer

84. Formalization of Carlos’s Requirements – Predicates Used
elevator(x) there is an elevator in the house of x
pets(x) pets are allowed in x
central(x) x is centrally located
acceptable(x), flat x satisfies Carlos’s requirements
offer(x,y), Carlos is willing to pay $ y for flat x 84
Chapter 5
A Semantic Web Primer

85. Formalization of Carlos’s Requirements – Rules
r1: apartment(X) acceptable(X)
r2: bedrooms(X,Y), Y < 2  ¬acceptable(X)
r3: size(X,Y), Y < 45  ¬acceptable(X)
r4: ¬pets(X)  ¬acceptable(X)
r5: floor(X,Y), Y > 2,¬elevator(X)  ¬acceptable(X)
r6: price(X,Y), Y > 400  ¬acceptable(X)
r2 > r1, r3 > r1, r4 > r1, r5 > r1, r6 > r1 85
Chapter 5
A Semantic Web Primer

86. Formalization of Carlos’s Requirements – Rules
r7: size(X,Y), Y ≥ 45, garden(X,Z), central(X) 
offer(X, *Z + 5*(Y − 45))
r8: size(X,Y), Y ≥ 45, garden(X,Z), ¬central(X) 
offer(X, *Z + 5(Y − 45))
r9: offer(X,Y), price(X,Z), Y < Z  ¬acceptable(X)
r9 > r1 86
Chapter 5
A Semantic Web Primer

87. Representation of Available Apartments
bedrooms(a1,1)
size(a1,50)
central(a1)
floor(a1,1)
¬elevator(a1)
pets(a1)
garden(a1,0)
price(a1,300) 87
Chapter 5
A Semantic Web Primer

88. Representation of Available Apartments
Flat
Bedrooms
Size
Central
Floor
Elevator
Pets
Garden
Price a1 1 50
yes no
300 a2 2 45
335 a3 65
350 a4 55 15
330 a5 3 a6 60
370 a7 12
375 88
Chapter 5
A Semantic Web Primer

89. Determining Acceptable Apartments
If we match Carlos’s requirements and the available apartments, we see that
flat a1 is not acceptable because it has one bedroom only (rule r2)
flats a4 and a6 are unacceptable because pets are not allowed (rule r4)
for a2, Carlos is willing to pay $ 300, but the price is higher (rules r7 and r9)
flats a3, a5, and a7 are acceptable (rule r1) 89
Chapter 5
A Semantic Web Primer

90. Selecting an Apartment
r10: acceptable(X)  cheapest(X)
r11: acceptable(X), price(X,Z), acceptable(Y), price(Y,W), W < Z  ¬cheapest(X)
r12: cheapest(X)  largestGarden(X)
r13: cheapest(X), garden(X,Z), cheapest(Y), garden(Y,W), W > Z  ¬largestGarden(X) 90
Chapter 5
A Semantic Web Primer

91. Selecting an Apartment
r14: largestGarden(X)  rent(X)
r15: largestGarden(X), size(X,Z), largestGarden(Y), size(Y,W), W > Z ¬ rent(X)
r11 > r10, r13 > r12, r15 > r14
The final selection is a5 and Carlos will soon move in 91
Chapter 5
A Semantic Web Primer

92. Lecture Outline 92 Introduction
Example of Monotonic Rules: Family Relationships
Monotonic Rules: Syntax
OWL2 RL: Description Logic Meets Rules
Rule Interchange Format: RIF
Semantic Web Rules Language (SWRL)
Rules in SPARQL: SPIN
Nonmonotonic Rules: Motivation and Syntax
Example of Nonmonotonic Rules: Brokered Trade
Rule Markup Language (RuleML)
Summary 92
Chapter 5
A Semantic Web Primer

93. RuleML
RuleML is a long-running effort to develop markup of rules on the Web
A family of rule markup languages, corresponding to different kinds of rule languages
The RuleML family provides descriptions of rule markup language in XML 93
Chapter 5
A Semantic Web Primer

94. Example: Customer Discount
The discount for a customer buying a product is 7.5 percent if the customer is premium and the product is luxury
<Implies>
<then>
<Atom>
<Rel>discount</Rel>
<Var>customer</Var>
<Var>product</Var>
<Ind>7.5 percent</Ind>
</Atom>
</then> 94
Chapter 5
A Semantic Web Primer

95. Example: Customer Discount
<if>
<And>
<Atom>
<Rel>premioum</Rel>
<Var>customer</Var>
</Atom>
<Rel>luxury</Rel>
<Var>product</Var>
</And>
</if>
</Implies> 95
Chapter 5
A Semantic Web Primer

96. SWRL using RuleML
SWRL is an extension of RuleML, and its use is straightforward
For instance, we show the representation of the rule
brother(X,Y), childOf(Z,Y)  uncle(X,Z)
in the XML syntax of SWRL using RuleML 1.0 96
Chapter 5
A Semantic Web Primer

97. Example: Uncle of 97 <ruleml:Implies> <ruleml:then>
brother(X,Y), childOf(Z,Y)  uncle(X,Z)
<ruleml:Implies>
<ruleml:then>
<swrlx : individualPropertyAtom
swrlx : property=“uncle”>
<ruleml:Var>X</ruleml:Var>
<ruleml:Var>Z</ruleml:Var>
</swrlx : individualPropertyAtom>
</ruleml:then> 97
Chapter 5
A Semantic Web Primer

98. Example: Uncle of (2) 98 <ruleml:And>
<ruleml:if>
<ruleml:And>
<swrlx : individualPropertyAtom
swrlx : property=“brother”>
<ruleml:Var>X</ruleml:Var>
<ruleml:Var>Y</ruleml:Var>
</swrlx : individualPropertyAtom>
swrlx : property=“childOf”> 98
Chapter 5
A Semantic Web Primer

99. Example: Uncle of (3) 99 <ruleml:Var>Y</ruleml:Var>
<ruleml:Var>Z</ruleml:Var>
<ruleml:Var>Y</ruleml:Var>
</swrlx:individualPropertyAtom>
</ruleml:And>
</ruleml:if>
</ruleml:Implies> 99
Chapter 5
A Semantic Web Primer

100. Lecture Outline 100100 Introduction
Example of Monotonic Rules: Family Relationships
Monotonic Rules: Syntax
OWL2 RL: Description Logic Meets Rules
Rule Interchange Format: RIF
Semantic Web Rules Language (SWRL)
Rules in SPARQL: SPIN
Nonmonotonic Rules: Motivation and Syntax
Example of Nonmonotonic Rules: Brokered Trade
Rule Markup Language (RuleML)
Summary
100100
Chapter 5
A Semantic Web Primer

101. Summary
Rules on the (semantic) Web form a very rich and heterogeneous landscape
Horn logic is a subset of predicate logic that allows efficient reasoning, orthogonal to description logics
Horn logic is the basis of monotonic rules
RIF is a new standard for rules on the Web. Its logical dialect BLD is based on Horn logic
101101
Chapter 5
A Semantic Web Primer

102. Summary
OWL2 RL is essentially the intersection of DL and Horn logic and can be embedded in RIF
SWRL is a much richer rule language, combining DL features with restricted types of rules
Nonmonotonic rules are useful in situations where the available information is incomplete
They are rules that may be overridden by contrary evidence
102102
Chapter 5
A Semantic Web Primer

103. Summary
Priorities are used to resolve some conflicts between nonmonotonic rules
Representation XML-like languages, such as those provided by RIF and RuleML, is straightforward
103103
Chapter 5
A Semantic Web Primer