View
75
Download
0
Category
Preview:
DESCRIPTION
Artificial Intelligence 8. The Resolution Method. Course V231 Department of Computing Imperial College, London Jeremy Gow. 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 - PowerPoint PPT Presentation
Citation preview
Artificial Intelligence 8. The Resolution Method
Course V231
Department of Computing
Imperial College, London
Jeremy Gow
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
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
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
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
Binary Resolution (Propositional)
Unit resolution rule (last lecture)AB, ¬B
A
Binary resolution ruleAB, ¬BC
AC
The literals B and ¬B are resolved
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
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
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
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)
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.)
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
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)
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)
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
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
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
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]
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
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)
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
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
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
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
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!
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
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
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
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
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
Recommended