![Page 1: Artificial Intelligence 8. The Resolution Method Course V231 Department of Computing Imperial College, London Jeremy Gow](https://reader033.vdocuments.us/reader033/viewer/2022051210/5515c78c550346c6278b463e/html5/thumbnails/1.jpg)
Artificial Intelligence 8. The Resolution Method
Course V231
Department of Computing
Imperial College, London
Jeremy Gow
![Page 2: Artificial Intelligence 8. The Resolution Method Course V231 Department of Computing Imperial College, London Jeremy Gow](https://reader033.vdocuments.us/reader033/viewer/2022051210/5515c78c550346c6278b463e/html5/thumbnails/2.jpg)
Soundness & Completeness
Want to prove theorem T from Axioms Ax Chosen a set of inference rules R A B means B is entailed by A A B means B is derived from A using R
R should be sound: if A B then A B
Want R to be complete: if A B then A B
![Page 3: Artificial Intelligence 8. The Resolution Method Course V231 Department of Computing Imperial College, London Jeremy Gow](https://reader033.vdocuments.us/reader033/viewer/2022051210/5515c78c550346c6278b463e/html5/thumbnails/3.jpg)
Choose Your Search Space
Soundness and completeness of R isn’t enough We want a reasonable search space
– R determines operators, so influences the space– Can I see where I’m going? (Heuristic measure)– Can I restrict options at each state? (Branching)
Three main approaches– Forwards chaining: no heuristic guidance– Backwards chaining: large branching (many things entail KB)– Proof by refutation: clear goal (false), forwards inference
![Page 4: Artificial Intelligence 8. The Resolution Method Course V231 Department of Computing Imperial College, London Jeremy Gow](https://reader033.vdocuments.us/reader033/viewer/2022051210/5515c78c550346c6278b463e/html5/thumbnails/4.jpg)
Proof by Refutation
Proof by contradiction, reductio ad absurdum
1. Negate the theorem & add to axioms (¬T,Ax)
2. Use rules of inference to derive the False So sentences (¬T,Ax) can’t all be true (unsatisfiable) But the axioms Ax are true Hence the negated theorem ¬T must be false Hence the theorem T must be true
![Page 5: Artificial Intelligence 8. The Resolution Method Course V231 Department of Computing Imperial College, London Jeremy Gow](https://reader033.vdocuments.us/reader033/viewer/2022051210/5515c78c550346c6278b463e/html5/thumbnails/5.jpg)
The Resolution Method
Proof by refutation with a single inference rule– No need to worry about choice of rule– Just how we apply the one rule
Resolution is complete for FOL– Refutation-complete [Robinson 1965]
If (¬T,Ax) unsatisfiable it will derive a contradiction
– So if will prove any true theorem of FOL
Even so, it might take a long time (> universe)– Even fairly trivial theorems can take a long time– Can use search heuristics to speed it up (next lecture)– No guarantees if it’s not a theorem
![Page 6: Artificial Intelligence 8. The Resolution Method Course V231 Department of Computing Imperial College, London Jeremy Gow](https://reader033.vdocuments.us/reader033/viewer/2022051210/5515c78c550346c6278b463e/html5/thumbnails/6.jpg)
Binary Resolution (Propositional)
Unit resolution rule (last lecture)AB, ¬B
A
Binary resolution ruleAB, ¬BC
AC
The literals B and ¬B are resolved
![Page 7: Artificial Intelligence 8. The Resolution Method Course V231 Department of Computing Imperial College, London Jeremy Gow](https://reader033.vdocuments.us/reader033/viewer/2022051210/5515c78c550346c6278b463e/html5/thumbnails/7.jpg)
Binary Resolution (First-Order)
Binary resolution ruleAB, ¬CD
Subst(, AD)
if substitution s.t. Subst(,B) = Subst(,C)
The literals B and ¬C are resolved– B and C have been made the same by
![Page 8: Artificial Intelligence 8. The Resolution Method Course V231 Department of Computing Imperial College, London Jeremy Gow](https://reader033.vdocuments.us/reader033/viewer/2022051210/5515c78c550346c6278b463e/html5/thumbnails/8.jpg)
Resolution in FOL (This Lecture)
What if KB contains non-disjuncts?– Preprocessing step: rewrite to CNF
How do we find substitution ?– The unification algorithm
But what if more than two disjuncts?– Extend binary resolution to full resolution
![Page 9: Artificial Intelligence 8. The Resolution Method Course V231 Department of Computing Imperial College, London Jeremy Gow](https://reader033.vdocuments.us/reader033/viewer/2022051210/5515c78c550346c6278b463e/html5/thumbnails/9.jpg)
Conjunctive Normal Form
A conjunction of clauses– Each clause is a disjunction of literals– Prop. literal: proposition or negated proposition– FO literal: predicate or negated predicate
No quantifiers (all variables implicitly universal) Example FO clause
likes(george, X) ¬likes(tony, houseof(george)) ¬is_mad(maggie)
Any FO sentence can be rewritten as CNF
![Page 10: Artificial Intelligence 8. The Resolution Method Course V231 Department of Computing Imperial College, London Jeremy Gow](https://reader033.vdocuments.us/reader033/viewer/2022051210/5515c78c550346c6278b463e/html5/thumbnails/10.jpg)
Converting FOL to CNF (see notes)
1. Eliminate implication/equivalence (rewrite)
2. Move ¬ inwards (rewrite)
3. Rename variables apart (substitution)
4. Move quantifiers outwards (rewrite)
5. Skolemise existential variables (substitution)
6. Distribute over (rewrite)
7. Flatten binary connectives (rewrite)
8. (Optional: Reintroduce implications)
![Page 11: Artificial Intelligence 8. The Resolution Method Course V231 Department of Computing Imperial College, London Jeremy Gow](https://reader033.vdocuments.us/reader033/viewer/2022051210/5515c78c550346c6278b463e/html5/thumbnails/11.jpg)
Example CNF Conversion
Propositional example (B (A C)) (B ¬A)
1. Remove implication:¬(B (A C)) (B ¬A)
2. Move ¬ inwards (De Morgan’s x 2):(¬B ¬(A C)) (B ¬A)
(¬B (¬A ¬C)) (B ¬A)
(Skip 3 to 5 as no variables.)
![Page 12: Artificial Intelligence 8. The Resolution Method Course V231 Department of Computing Imperial College, London Jeremy Gow](https://reader033.vdocuments.us/reader033/viewer/2022051210/5515c78c550346c6278b463e/html5/thumbnails/12.jpg)
Example CNF Conversion (Contd)
(¬B (¬A ¬C)) (B ¬A)
6. Distribute over :(¬B (B ¬A)) ((¬A ¬C) (B ¬A))
7. Flatten connectives(¬B B ¬A) (¬A ¬C B ¬A)
Drop 1st clause (¬B B), remove duplicate from 2nd:¬A ¬C B
![Page 13: Artificial Intelligence 8. The Resolution Method Course V231 Department of Computing Imperial College, London Jeremy Gow](https://reader033.vdocuments.us/reader033/viewer/2022051210/5515c78c550346c6278b463e/html5/thumbnails/13.jpg)
Kowalski Normal Form
Can reintroduce to CNF, e.g.¬A ¬C B becomes (A C) B
Kowalski form
(A1 … An) (B1 … Bn) Binary resolution…
AB, BCAC
Resembles Horn clauses (basis for Prolog)
![Page 14: Artificial Intelligence 8. The Resolution Method Course V231 Department of Computing Imperial College, London Jeremy Gow](https://reader033.vdocuments.us/reader033/viewer/2022051210/5515c78c550346c6278b463e/html5/thumbnails/14.jpg)
Skolemisation
Replace V with a ‘something’ term– If no preceeding U use fresh Skolem constant– Otherwise fresh Skolem function
parameterised by all preceeding U
X Y (person(X) has(X, Y) heart(Y))
to
person(X) has(X, f(X)) heart(f(X))
(The particular heart f(X) depends on person X)
![Page 15: Artificial Intelligence 8. The Resolution Method Course V231 Department of Computing Imperial College, London Jeremy Gow](https://reader033.vdocuments.us/reader033/viewer/2022051210/5515c78c550346c6278b463e/html5/thumbnails/15.jpg)
Substitutions & Inference Rules
Propositional inference rules used in first-order logic But in FOL we can make substitutions
– Sometimes a substitution can allow a rule to be applied– cf. FO binary resolution
knows(john, X) hates(john, X)
knows(john, mary)
Substitution + Modus Ponens: infer hates(john, mary) Need to find substitution that makes literals equal
– Known as a unifier
![Page 16: Artificial Intelligence 8. The Resolution Method Course V231 Department of Computing Imperial College, London Jeremy Gow](https://reader033.vdocuments.us/reader033/viewer/2022051210/5515c78c550346c6278b463e/html5/thumbnails/16.jpg)
Unifying Predicates
We unified these two predicates: knows(john, X) and knows(john, mary) By saying that X should be substituted by mary
– Why? Because john = john and can {X\mary}
For knows(jack, mary) and knows(john, X)– john doesn’t match jack– So we cannot unify the two predicates– Hence we cannot use the rule of inference
![Page 17: Artificial Intelligence 8. The Resolution Method Course V231 Department of Computing Imperial College, London Jeremy Gow](https://reader033.vdocuments.us/reader033/viewer/2022051210/5515c78c550346c6278b463e/html5/thumbnails/17.jpg)
Unification
Want an algorithm which:– Takes two FOL sentences as input– Outputs a substitution {X/mary, Y/Z, etc.}
Which assigns terms to variables in the sentences So that the first sentence looks exactly like the second
– Or fails if there is no way to unify the sentences
Example:Unify(“knows(john, X)”, “knows(john,mary)”) = {X/mary}
Unify(“knows(john, X)”, “knows(jack,mary)”) = Fail
![Page 18: Artificial Intelligence 8. The Resolution Method Course V231 Department of Computing Imperial College, London Jeremy Gow](https://reader033.vdocuments.us/reader033/viewer/2022051210/5515c78c550346c6278b463e/html5/thumbnails/18.jpg)
Functions Within the Unify Algorithm
isa_variable(x) – checks whether x is a variable
isa_list(x)– checks whether x is a list
head(x)– outputs the head of a list (first term)
e.g., head([a,b,c]) = a
tail(x)– outputs the elements other than the head in a list
e.g., tail([a,b,c]) = [b,c]
![Page 19: Artificial Intelligence 8. The Resolution Method Course V231 Department of Computing Imperial College, London Jeremy Gow](https://reader033.vdocuments.us/reader033/viewer/2022051210/5515c78c550346c6278b463e/html5/thumbnails/19.jpg)
More Internal Functions(Compound Expressions)
isa_compound(x) – checks whether x is compound expression– (either a predicate, a function or a connective)
args(x)– finds the subparts of the compound expression x
arguments of a predicate, function or connective
– Returns the list of arguments
op(x)– predicate name/function name/connective symbol
![Page 20: Artificial Intelligence 8. The Resolution Method Course V231 Department of Computing Imperial College, London Jeremy Gow](https://reader033.vdocuments.us/reader033/viewer/2022051210/5515c78c550346c6278b463e/html5/thumbnails/20.jpg)
Two Parts of theUnification Algorithm
Algorithm is recursive (it calls itself)– Passes around a set of substitutions, called mu– Making sure that new substitutions are consistent with old ones
unify(x,y) = unify_internal(x,y,{})– x and y are either a variable, constant, list, or compound
unify_internal(x,y,mu)– x and y are sentences, mu is a set of substitutions– finds substitutions making x look exactly like y
unify_variable(var,x,mu)– var is a variable– finds a single substitution (which may be in mu already)
![Page 21: Artificial Intelligence 8. The Resolution Method Course V231 Department of Computing Imperial College, London Jeremy Gow](https://reader033.vdocuments.us/reader033/viewer/2022051210/5515c78c550346c6278b463e/html5/thumbnails/21.jpg)
unify_internal
unify_internal(x,y,mu)
----------------------
Cases
1.if (mu=failure) then return failure
2.if (x=y) then return mu.
3.if (isa_variable(x)) then return unify_variable(x,y,mu)
4.if (isa_variable(y)) then return unify_variable(y,x,mu)
5.if (isa_compound(x) and isa_compound(y)) then return
unify_internal(args(x),args(y),unify_internal(op(x),op(y),mu))
6.if (isa_list(x) and isa_list(y)) then return
unify_internal(tail(x),tail(y),unify_internal(head(x),head(y),mu))
7.return failure
![Page 22: Artificial Intelligence 8. The Resolution Method Course V231 Department of Computing Imperial College, London Jeremy Gow](https://reader033.vdocuments.us/reader033/viewer/2022051210/5515c78c550346c6278b463e/html5/thumbnails/22.jpg)
unify_variable
unify_variable(var,x,mu) ------------------------ Cases 1. if (a substitution var/val is in mu) then return unify_internal(val,x,mu)
2. if (a substitution x/val is in mu) then return unify_internal(var,val,mu)
3. if (var occurs anywhere in x) return failure
4. add var/x to mu and return
![Page 23: Artificial Intelligence 8. The Resolution Method Course V231 Department of Computing Imperial College, London Jeremy Gow](https://reader033.vdocuments.us/reader033/viewer/2022051210/5515c78c550346c6278b463e/html5/thumbnails/23.jpg)
Notes on the Unification Algorithm
unify_internal will not match a constant to a constant, unless they are equal (case 2)
Case 5 in unify_internal checks that two compound operators are the same (e.g. same predicate name)
Case 6 in unify_internal causes the algorithm to recursivly unify the whole list
Cases 1 and 2 in unify_variable check that neither inputs have already been substituted
![Page 24: Artificial Intelligence 8. The Resolution Method Course V231 Department of Computing Imperial College, London Jeremy Gow](https://reader033.vdocuments.us/reader033/viewer/2022051210/5515c78c550346c6278b463e/html5/thumbnails/24.jpg)
The Occurs Check
Suppose we needed to substitute X with f(X,Y)– This would give us f(X,Y) instead of X– But there is still an X in there,
so the substitution isn’t complete:
we need f(f(X,Y),Y), then f(f(f(X,Y),Y),Y) and so on
We need to avoid this situation– Otherwise the algorithm won’t stop– Case 3 in unify_variable checks this– Known as the “occurs check”
Occurs check slows the algorithm down– Order (n2), where n is size of expressions being unified
![Page 25: Artificial Intelligence 8. The Resolution Method Course V231 Department of Computing Imperial College, London Jeremy Gow](https://reader033.vdocuments.us/reader033/viewer/2022051210/5515c78c550346c6278b463e/html5/thumbnails/25.jpg)
An Example Unification
Suppose we want to unify these sentences:1. p(X,tony) q(george,X,Z)2. p(f(tony),tony) q(B,C,maggie)
By inspection, this is a good substitution:– {X/f(tony), B/george, C/f(tony), Z/maggie}
This makes both sentences become:– p(f(tony),tony) q(george, f(tony), maggie)
Note that we want to substitute X for C– But we have substituted f(tony) for X already
See the notes for this as a worked example– Using the unification algorithm– Requires five iterations!
![Page 26: Artificial Intelligence 8. The Resolution Method Course V231 Department of Computing Imperial College, London Jeremy Gow](https://reader033.vdocuments.us/reader033/viewer/2022051210/5515c78c550346c6278b463e/html5/thumbnails/26.jpg)
Binary Resolution (First-Order)
Binary resolution rule (using unification)AB, ¬CD
Subst(, AD)
if Unify(B, C) =
Unification algorithm finds Most General Unifier (MGU) – Don’t substitute any more than need to
![Page 27: Artificial Intelligence 8. The Resolution Method Course V231 Department of Computing Imperial College, London Jeremy Gow](https://reader033.vdocuments.us/reader033/viewer/2022051210/5515c78c550346c6278b463e/html5/thumbnails/27.jpg)
The Full Resolution Rule
If Unify(Pj, ¬Qk) = (¬ makes them unifiable)
P1 … Pm, Q1 … Qn
Subst(, P1 … (no Pj) … Pm Q1 … (no Qk) ... Qn)
Pj and Qk are resolved Arbitrary number of disjuncts Relies on preprocessing into CNF
![Page 28: Artificial Intelligence 8. The Resolution Method Course V231 Department of Computing Imperial College, London Jeremy Gow](https://reader033.vdocuments.us/reader033/viewer/2022051210/5515c78c550346c6278b463e/html5/thumbnails/28.jpg)
Using Full Resolution
Sentences already in CNF
Pick two clauses– Pick positive literal P from first– Pick negative literal N from second– Find MGU of ¬P and N – Write both clauses as one big disjunction
With P and N missing Apply to the new clause
![Page 29: Artificial Intelligence 8. The Resolution Method Course V231 Department of Computing Imperial College, London Jeremy Gow](https://reader033.vdocuments.us/reader033/viewer/2022051210/5515c78c550346c6278b463e/html5/thumbnails/29.jpg)
Resolution Proof Search
Keep on resolving clause pairs– Eventually result in zero-length clause– This indicates that some literal K was true at the
same time as the literal ¬K Only way to reduce sentence to be empty
– Hence there was an inconsistency– Which proves the theorem
Topic of the next lecture
![Page 30: Artificial Intelligence 8. The Resolution Method Course V231 Department of Computing Imperial College, London Jeremy Gow](https://reader033.vdocuments.us/reader033/viewer/2022051210/5515c78c550346c6278b463e/html5/thumbnails/30.jpg)
Coursework: War of Life
http://www.doc.ic.ac.uk/~sgc/teaching/v231/
Two player version of Game of Life– Implement several strategies in Prolog– Run a tournament
On CATE this afternoon Submit via CATE (more to follow…) Deadline: 3 weeks today