KRR3: Inference in First-Order Logic 2: Yannick - Pencole@anu - Edu.au

KRR3: Inference in First-order logic 2
Yannick Pencolé
Yannick.Pencole@anu.edu.au
16 Mar 2005
Outline
1 Backward chaining
2 Resolution
Substitution and Composition
Definition
Given p a sentence and θ1 , θ2 two substitutions, the composition of θ1 and θ2
is the substitution θ = C OMPOSE(θ1 , θ2 ) such that:
S UBST(θ, p) = S UBST(θ1 , S UBST(θ2 , p)) = S UBST(θ2 , S UBST(θ1 , p))
Example
Sentence p is P(y ) ∧ Q(x) ⇒ R(z)
Consider θ1 = {y /Toto, z/Titi}, θ2 = {x/Tata}
S UBST(θ1 , p) = P(Toto) ∧ Q(x) ⇒ R(Titi)
S UBST(θ2 , p) = P(y ) ∧ Q(Tata) ⇒ R(z)
S UBST(C OMPOSE(θ1 , θ2 ), p) = P(Toto) ∧ Q(Tata) ⇒ R(Titi)
Backward chaining: main idea
Definition
Given a definite clause p1 ∧ · · · ∧ pn ⇒ c, c is called the Head.
p1 ∧ · · · ∧ pn is called the Body.
BC Idea
Goal-driven algorithm.
1 Unification of the goal with the head of a rule
2 Propagation of the substitution to the body. Every premise
of the body is a new goal
3 Apply BC recursively on the new goals...
Based on a depth-first search (DFS).
Backward chaining: algorithm
Backward chaining: DFS-tree
Example
{ x / Yannick }
GoodTeacher(Yannick)
Example
{ x / Yannick }
S1
{}
Person(Yannick)
S5
Example
{ x / Yannick }
S1
{}
Person(Yannick) GoodLecturesFOL(y)
S5
Example
{ x / Yannick }
S1
{}
S5
S7
{ y / M1 }
GoodLecturesLogic(M1)
S2
Example
{ x / Yannick }
S1
{} { z / People }
compose Gives(Yannick,M1,People)
S5
S7
{ y / M1 }
GoodLecturesLogic(M1)
S2
Example
{ x / Yannick }
S1
{} { z / People }
S5
S7
{ y / M1 } {}
GoodLecturesLogic(M1) GoodLecturesLogic(M1)
S2 S2
Example
{ x / Yannick }
S1
{} { z / People }
S5
S3
S7
{ y / M1 } {} {}
GoodLecturesLogic(M1) GoodLecturesLogic(M1) Have(People,M1)
S2 S2 S2
Example
{ x / Yannick }
S1
{} { z / People }
compose Students(People)
S5
S3
S7
{ y / M1 } {} {}
GoodLecturesLogic(M1) GoodLecturesLogic(M1) Have(People,M1)
S2 S2 S2
Example
{ x / Yannick }
S1
{} { z / People }
S5
S3
S7 S6
{ y / M1 } {} {} {}
GoodLecturesLogic(M1) GoodLecturesLogic(M1) Have(People,M1) Study(People, ANU)
S2 S2 S2 S4
Example
{ x / Yannick }
S1
{} { z / People }
S5
S3
S7 S6
{ y / M1 } {} {} {}
GoodLecturesLogic(M1) GoodLecturesLogic(M1) Have(People,M1) Study(People, ANU)
S2 S2 S2 S4
Answer = { x / Yannick, y / M1, z / People }

Properties of BC
Depth-first recursive proof search: space is linear in size of the

proof.
Incomplete due to infinite loops (DFS). To fix that, we have to

check the current goal against every goal in the stack.
Inefficient due to repeated subgoals. To fix that we must use a

cache of previous results (memoization)
So what? If BC is not so good, why do we talk about it? Well, it

is widely used and with good optimisations it works! (linear
algorithm): P ROLOG
Outline
1 Backward chaining
2 Resolution
Another Knowledge base
Example
Everyone who loves all animals is loved by someone. Anyone
who kills an animal is loved by no one. Jack loves all animals.
Either Jack or Curiosity killed the cat, who is named Tuna.
Did Curiosity kill the cat?

Example
“Everyone who loves all animals is loved by someone.”
Example
∀x [∀y Animal(y ) ⇒ Loves(x, y)] ⇒ [∃y Loves(y , x)]
Example
“Anyone who kills an animal is loved by no one..”

Example

∀x[∃yAnimal(y ) ∧ Kills(x, y )] ⇒ [∀z ¬Loves(z, x)]
Example

“Jack loves all animals”

Example


∀x Animal(x) ⇒ Loves(Jack, x)
Example


“Either Jack or Curiosity killed the cat, who is named Tuna”

Example



Kills(Jack , Tuna) ∨ Kills(Curiosity , Tuna)
Example



Tuna is a cat
Example



Tuna is a cat
Cat(Tuna)
Example



Tuna is a cat
Cat(Tuna)
A cat is an animal
Example



Tuna is a cat
Cat(Tuna)
A cat is an animal
∀x Cat(x) ⇒ Animal(x)
Example



Tuna is a cat
Cat(Tuna)
A cat is an animal
Question: Did Curiosity kill the cat?

Example



Tuna is a cat
Cat(Tuna)
A cat is an animal
Question: Did Curiosity kill the cat?

Kills(Curiosity , Tuna)
Conjunctive Normal Form for FOL
Conjuntive Normal Form

A sentence in a Conjunctive Normal Form is a conjunction of
clauses, each clause is a disjunction of literals.
Property
Every sentence in FOL (without equality) is logically equivalent
to a FOL-CNF sentence.
Example
“Everyone who loves all animals is loved by someone”
has the following CNF

[Animal(F (x)) ∨ Loves(G(x), x)] ∧ [¬Loves(x, F (x)) ∨ Loves(G(x), x)].
Conversion to CNF
Method
1 Elimination of implications
A ⇒ B ≡ ¬A ∨ B
2 Move ¬ inwards
3 Standardize variables
4 Skolemisation
5 Drop the universal quantifiers
6 Distribute ∨ over ∧
Move ¬ inwards and variable standardization
Rules for negated quantifiers
¬∀x p ≡ ∃x ¬p
¬∃x p ≡ ∀x ¬p
Variable standardization
(∀x P(x)) ∨ (∃x Q(x))
x is used twice but it does not represent the same thing (two
diffrent scopes). To avoid confusion, we rename:
(∀x P(x)) ∨ (∃y Q(y))

Skolemization
Definition
Skolemisation is the process of removing existential quantifiers
by elimination.
Simple case = Existential Instanciation
Complex case = Use of Skolem functions
Example
Simple case: ∃x P(x)
Using EI, we have: P(A)
Complex case: ∀x [∃y P(x, y)]

Using EI, we have: ∀x P(x, A) wrong
Use of a Skolem function F (x): ∀x P(x, F (x))
(y in is the scope of x)
Conversion to CNF: example
Example
Example
1 Eliminate implications:
∀x [¬∀y ¬Animal(y ) ∨ Loves(x, y )] ∨ [∃y Loves(y , x)]
Example
2 Move ¬ inwards
∀x [∃y ¬(¬Animal(y) ∨ Loves(x, y))] ∨ [∃y Loves(y , x)]
Example
2 Move ¬ inwards
∀x [∃y ¬¬Animal(y ) ∧ ¬Loves(x, y )] ∨ [∃y Loves(y , x)] (De
Morgan)
Example
2 Move ¬ inwards
Morgan)
∀x [∃y Animal(y) ∧ ¬Loves(x, y )] ∨ [∃y Loves(y, x)]
(double negation)
Example
2 Move ¬ inwards
Morgan)
(double negation)
3 Standardize variables:
∀x [∃y Animal(y ) ∧ ¬Loves(x, y)] ∨ [∃z Loves(z, x)]
Example
2 Move ¬ inwards
Morgan)
(double negation)
4 Skolemization: ∀x [Animal(F (x)) ∧ ¬Loves(x, F (x))] ∨ [Loves(G(x), x)]
Example
2 Move ¬ inwards
Morgan)
(double negation)
5 Drop universal quantifiers:
[Animal(F (x)) ∧ ¬Loves(x, F (x))] ∨ [Loves(G(x), x)]
Example
2 Move ¬ inwards
Morgan)
(double negation)
5 Drop universal quantifiers:
[Animal(F (x)) ∧ ¬Loves(x, F (x))] ∨ [Loves(G(x), x)]
6 Distribute ∨ over ∧:
[Animal(F (x)) ∨ Loves(G(x), x)] ∧ [¬Loves(x, F (x)) ∨ Loves(G(x), x)]
Resolution: inference rule
Rule
`1 ∨ · · · ∨ ì ∨ · · · ∨ `k , `01 ∨ · · · ∨ `0j ∨ · · · ∨ `0n

S UBST(θ, `1 ∨ · · · ∨ ì−1 ∨ ì+1 ∨ · · · ∨ `k ∨ `01 ∨ · · · ∨ `0j−1 ∨ `0j+1 ∨ · · · ∨ `0n )
with θ a substitution such that U NIFY( ì , ¬ `0j ) = θ
Example
[Animal(F (x)) ∨ Loves(G(x), x)] [¬Loves(u, v ) ∨ ¬Kills(u, v )]
Rule
`1 ∨ · · · ∨ ì ∨ · · · ∨ `k , `01 ∨ · · · ∨ `0j ∨ · · · ∨ `0n

S UBST(θ, `1 ∨ · · · ∨ ì−1 ∨ ì+1 ∨ · · · ∨ `k ∨ `01 ∨ · · · ∨ `0j−1 ∨ `0j+1 ∨ · · · ∨ `0n )
Example
[Animal(F (x)) ∨ Loves(G(x), x) ] [ ¬Loves(u, v ) ∨ ¬Kills(u, v )]

Rule
`1 ∨ · · · ∨ ì ∨ · · · ∨ `k , `01 ∨ · · · ∨ `0j ∨ · · · ∨ `0n

S UBST(θ, `1 ∨ · · · ∨ ì−1 ∨ ì+1 ∨ · · · ∨ `k ∨ `01 ∨ · · · ∨ `0j−1 ∨ `0j+1 ∨ · · · ∨ `0n )
Example

S UBST(θ, Animal(F (x)) ∨ ¬Kills(u, v ))
Rule
`1 ∨ · · · ∨ ì ∨ · · · ∨ `k , `01 ∨ · · · ∨ `0j ∨ · · · ∨ `0n

S UBST(θ, `1 ∨ · · · ∨ ì−1 ∨ ì+1 ∨ · · · ∨ `k ∨ `01 ∨ · · · ∨ `0j−1 ∨ `0j+1 ∨ · · · ∨ `0n )
Example

S UBST(θ, Animal(F (x)) ∨ ¬Kills(u, v ))
θ = {u/G(x), v /x}
Rule
`1 ∨ · · · ∨ ì ∨ · · · ∨ `k , `01 ∨ · · · ∨ `0j ∨ · · · ∨ `0n

S UBST(θ, `1 ∨ · · · ∨ ì−1 ∨ ì+1 ∨ · · · ∨ `k ∨ `01 ∨ · · · ∨ `0j−1 ∨ `0j+1 ∨ · · · ∨ `0n )
Example

Animal(F (x)) ∨ ¬Kills(G(x), x)
θ = {u/G(x), v /x}
Resolution algorithm
Definition
Proof by contradiction: given KB, to prove α, we prove that
KB ∧ ¬α is not satisfiable.
Resolution: example
Resolution Proof that Curiosity has killed the cat:

¬α is ¬Kills(Curiosity, Tuna)
Use of the factoring rule to infer Loves(G(Jack), Jack )
Dealing with equality
Paramodulation
There are several ways to deal with t1 = t2 . One of them is
Paramodulation:
`1 ∨ · · · ∨ `k ∨ t1 = t2 , `01 ∨ · · · ∨ `0n [t3 ]

S UBST(θ, `1 ∨ · · · ∨ `0n [y])
where
U NIFY (t1 , t3 ) = θ
This inference rule can be used during the resolution algorithm.
Example
Father (John) = Father (Richard) Male(Father (x))
Male(Father (Richard))
θ = {x/John} = U NIFY(Father (John), Father (x))
Theorem provers
Unlike logic programming language, Theorem provers cover FOL (no

restriction on Definite Clauses). Their algorithm is based on resolution.
Theorem prover: OTTER
Optimisations
Using the resolution algorithm in a “clever” way.
Unit preference: Inference of sentences with a minimal number of
literals (more chance to get the empty clause)
Set of support: What is the set of clauses in KB that will be useful?
Input resolution: Always using a sentence from KB or α to apply the
resolution rule.
Subsumption: Elimination of sentences that are subsumed by (more
specific than) an existing sentence in the KB.
Completeness of resolution
Any set of sentences S is representable in clausal form
Assume S is unsatisfiable, and in clausal form
Herbrand’s theorem
Some set S’ of ground instances is unsatisfiable
Ground resolution
theorem
Resolution can find a contradiction in S’
Lifting lemma
There is a resolution proof for the contradiction in S
Summary
Inference in FOL
Propositionalisation: very slow
Unification techniques: much more efficient
Generalised Modus Ponens: FC and BC on Definite
clauses
FC for deductive databases
BC for logic programming
Entailement problem is semi-decidable
Generalised resolution: complete proof system (CNF)
To Infinity and Beyond!
A dream
Using theorem proving to automatically prove everything...
A first step
To prove everything, we need to prove everything in arithmetic...
Arithmetic
Logic for arithmetic: 0, S(..), ×, +, Expt (extension of FOL, more expressive)
Gödel’s incompleteness theorem

Gödel said (after a proof on 30 pages):
“Whatever your logic is, if your logic can express arithmetic, whatever your
KB is, I can exhibit a sentence in your logic such that the sentence is entailed
by KB but there’s no way to prove it by inference thanks to your KB”
The reality
Sorry for the inconvenience...

KRR3: Inference in First-Order Logic 2: Yannick - Pencole@anu - Edu.au

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

KRR3: Inference in First-Order Logic 2: Yannick - Pencole@anu - Edu.au

Uploaded by

Copyright:

Available Formats

KRR3: Inference in First-order logic 2

S UBST(θ, p) = S UBST(θ1 , S UBST(θ2 , p)) = S UBST(θ2 , S UBST(θ1 , p))

Answer = { x / Yannick, y / M1, z / People }

Depth-first recursive proof search: space is linear in size of the

Incomplete due to infinite loops (DFS). To fix that, we have to

Inefficient due to repeated subgoals. To fix that we must use a

So what? If BC is not so good, why do we talk about it? Well, it

Did Curiosity kill the cat?

“Anyone who kills an animal is loved by no one..”

“Anyone who kills an animal is loved by no one..”

“Anyone who kills an animal is loved by no one..”

“Jack loves all animals”

“Anyone who kills an animal is loved by no one..”

“Jack loves all animals”

“Anyone who kills an animal is loved by no one..”

“Jack loves all animals”

“Either Jack or Curiosity killed the cat, who is named Tuna”

“Anyone who kills an animal is loved by no one..”

“Jack loves all animals”

“Either Jack or Curiosity killed the cat, who is named Tuna”

“Anyone who kills an animal is loved by no one..”

“Jack loves all animals”

“Either Jack or Curiosity killed the cat, who is named Tuna”

“Anyone who kills an animal is loved by no one..”

“Jack loves all animals”

“Either Jack or Curiosity killed the cat, who is named Tuna”

“Anyone who kills an animal is loved by no one..”

“Jack loves all animals”

“Either Jack or Curiosity killed the cat, who is named Tuna”

“Anyone who kills an animal is loved by no one..”

“Jack loves all animals”

“Either Jack or Curiosity killed the cat, who is named Tuna”

“Anyone who kills an animal is loved by no one..”

“Jack loves all animals”

“Either Jack or Curiosity killed the cat, who is named Tuna”

Question: Did Curiosity kill the cat?

“Anyone who kills an animal is loved by no one..”

“Jack loves all animals”

“Either Jack or Curiosity killed the cat, who is named Tuna”

Question: Did Curiosity kill the cat?

Conjuntive Normal Form

has the following CNF

Rules for negated quantifiers

(∀x P(x)) ∨ (∃y Q(y))

Complex case: ∀x [∃y P(x, y)]

`1 ∨ · · · ∨ `i ∨ · · · ∨ `k , `01 ∨ · · · ∨ `0j ∨ · · · ∨ `0n

with θ a substitution such that U NIFY( `i , ¬ `0j ) = θ

`1 ∨ · · · ∨ `i ∨ · · · ∨ `k , `01 ∨ · · · ∨ `0j ∨ · · · ∨ `0n

with θ a substitution such that U NIFY( `i , ¬ `0j ) = θ

[Animal(F (x)) ∨ Loves(G(x), x) ] [ ¬Loves(u, v ) ∨ ¬Kills(u, v )]

`1 ∨ · · · ∨ `i ∨ · · · ∨ `k , `01 ∨ · · · ∨ `0j ∨ · · · ∨ `0n

with θ a substitution such that U NIFY( `i , ¬ `0j ) = θ

[Animal(F (x)) ∨ Loves(G(x), x) ] [ ¬Loves(u, v ) ∨ ¬Kills(u, v )]

`1 ∨ · · · ∨ `i ∨ · · · ∨ `k , `01 ∨ · · · ∨ `0j ∨ · · · ∨ `0n

with θ a substitution such that U NIFY( `i , ¬ `0j ) = θ

[Animal(F (x)) ∨ Loves(G(x), x) ] [ ¬Loves(u, v ) ∨ ¬Kills(u, v )]

`1 ∨ · · · ∨ `i ∨ · · · ∨ `k , `01 ∨ · · · ∨ `0j ∨ · · · ∨ `0n

with θ a substitution such that U NIFY( `i , ¬ `0j ) = θ

[Animal(F (x)) ∨ Loves(G(x), x) ] [ ¬Loves(u, v ) ∨ ¬Kills(u, v )]

Resolution Proof that Curiosity has killed the cat:

`1 ∨ · · · ∨ `k ∨ t1 = t2 , `01 ∨ · · · ∨ `0n [t3 ]

Unlike logic programming language, Theorem provers cover FOL (no