Download presentation

Presentation is loading. Please wait.

Published byRobert Stevenson Modified over 3 years ago

1
**Artificial Intelligence 8. The Resolution Method**

Course V231 Department of Computing Imperial College, London Jeremy Gow

2
**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

3
**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

4
**Proof by Refutation Proof by contradiction, reductio ad absurdum**

Negate the theorem & add to axioms (¬T,Ax) 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

5
**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

6
**Binary Resolution (Propositional)**

Unit resolution rule (last lecture) AB, ¬B A Binary resolution rule AB, ¬BC AC The literals B and ¬B are resolved

7
**Binary Resolution (First-Order)**

Binary resolution rule AB, ¬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

8
**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

9
**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

10
**Converting FOL to CNF (see notes)**

Eliminate implication/equivalence (rewrite) Move ¬ inwards (rewrite) Rename variables apart (substitution) Move quantifiers outwards (rewrite) Skolemise existential variables (substitution) Distribute over (rewrite) Flatten binary connectives (rewrite) (Optional: Reintroduce implications)

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

12
**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

13
**¬A ¬C B becomes (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, BC AC Resembles Horn clauses (basis for Prolog)

14
**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)

15
**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

16
**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

17
**Unification Want an algorithm which: Example:**

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

18
**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]

19
**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

20
**Two Parts of the Unification 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)

21
**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

22
**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

23
**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

24
**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

25
**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!

26
**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

27
**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

28
**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

29
**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

30
**Coursework: War of Life**

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

Similar presentations

Presentation is loading. Please wait....

OK

Resolution Proof System for First Order Logic

Resolution Proof System for First Order Logic

© 2017 SlidePlayer.com Inc.

All rights reserved.

Ads by Google

Ppt on social etiquettes of israel Ppt on allergic contact dermatitis Ppt on data handling in maths Ppt on action words for grade 1 Ppt on agriculture in india Ppt on conceptual art drawings Ppt on abstract art for sale Ppt on world environment day activities Ppt on public speaking skills Ppt on non ferrous minerals in food