1 / 46

Automated Reasoning

General Game Playing Lecture 3. Automated Reasoning. Michael Genesereth Spring 2005. Unification. Substititions. A substitution is a finite set of pairs of variables and terms, called replacements .  = ((?x . A) ((?y . (F B)) (?V . ?W))

dara
Télécharger la présentation

Automated Reasoning

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. General Game Playing Lecture 3 Automated Reasoning Michael Genesereth Spring 2005

  2. Unification

  3. Substititions A substitution is a finite set of pairs of variables and terms, called replacements.  = ((?x . A) ((?y . (F B)) (?V . ?W)) The result of applying a substitution  to an expression  is the expression  obtained from  by replacing every occurrence of every variable in the substitution by its replacement. (P ?x ?x ?y ?Z) = (P A A (F B) ?Z)

  4. Unification A substitution  is a unifier for an expression  and an expression  if and only if =.  = ((?x . A) ((?y . (F B)) (?V . ?W))  = ((?x . A) ((?y . (F B)) (?V . ?W)) (P ?x ?y) = (P A B) (P ?x ?y) = (P A B) If two expressions have a unifier, they are said to be unifiable. Otherwise, they are nonunifiable. (P ?x ?y) (P A B)

  5. Non-Uniqueness of Unification Unifier 1: p(x,y){xa,yb,vb}=p(a,b) p(a,v){xa,yb,vb}=p(a,b) Unifier 2: p(x,y){xa,yf(w),vf(w)}=p(a,f(w)) p(a,v){xa,yf(w),vf(w)}=p(a,f(w)) Unifier 3: p(x,y){xa,yv}=p(a,v) p(a,v){xa,yv}=p(a,v)

  6. Most General Unifier A substitution  is a most general unifier (mgu) of two expressions if and only if it is as general as or more general than any other unifier. Theorem: If two expressions are unifiable, then they have an mgu that is unique up to variable permutation. p(x,y){xa,yv}=p(a,v) p(a,v){xa,yv}=p(a,v) p(x,y){xa,vy}=p(a,y) p(a,v){xa,vy}=p(a,y)

  7. Most General Unification (defun mgu (x y al) (cond ((eq x y) al) ((varp x) (mguvar x y al)) ((atom x) (cond ((varp y) (mguvar y x al)) ((atom y) (if (equalp x y) al)))) (t (cond ((varp y) (mguvar y x al)) ((atom y) nil) ((setq al (mgu (car x) (car y) al)) (mgu (cdr x) (cdr y) al))))))

  8. Most General Unification (continued) (defun mguvar (x y al) (let (dum) (cond ((setq dum (assoc x al)) (mgu (cdr dum) y al)) ((eq x (setq y (mguval y al))) al) ((mguchkp x y al)) nil) (t (acons x y al))))) (defun mguval (x al) (let (dum) (cond ((and (varp x) (setq dum (assoc x al))) (mguval (cdr dum) al)) (t x))))

  9. Problem ~hates(X,X) hates(Y,f(Y))

  10. Solution Before assigning a variable to an expression, first check that the variable does not occur within that expression. This is called, oddly enough, the occur check test. Prolog does not do the occur check (and is proud of it).

  11. Most General Unification (concluded) (defun mguchkp (p q al) (cond ((eq p q)) ((varp q) (mguchkp p (cdr (assoc q al)) al)) ((atom q) nil) (t (some #'(lambda (x) (mguchkp p x al)) q))))

  12. Example (mgu ‘(p ?x b) ‘(p a ?y)) Calling (MGU (P ?x B) (P A ?y) ((t . t))) Calling (MGU P P ((t . t))) MGUEXP returned ((t . t)) Calling (MGU ?x A ((t . t))) MGUEXP returned ((?x . A) (t . t)) Calling (MGU B ?y ((?x . A) (t . t))) MGUEXP returned ((?y . B) (?x . A) (t . t)) MGUEXP returned ((?y . B) (?x . A) (t . t)) ((?y . B) (?x . A) (t . t))

  13. Example Call: (mgu (p ?x ?x) (p a b) ((t . t))) | | Call: (mgu p p ((t . t))) | Exit: ((t . t)) | | Call: (mgu ?x a ((t . t))) | Exit: ((?x . a) (t . t)) | | Call: (mgu ?x b ((?x . a) (t . t))) | Call: (mgu a b ((?x . a) (t . t))) | Exit: nil | Exit: ((?y . b) (?x . a) (t . t)) | Exit: ((?y . b) (?x . a) (t . t))

  14. Example Call: (mgu (p (f ?x) (f ?x)) (p ?y (f a)) ((t.t))) Call: (mgu p p ((t . t))) Exit: ((t . t)) Call: (mgu (f ?x) ?y ((t . t)) Exit: ((?y . (f ?x)) (t . t))) Call: (mgu (f ?x) (f a) ((?y . (f ?x)) (t . t))) Call: (mgu f f ((?y . (f ?x)) (t . t))) Exit: ((?y . (f ?x)) (t . t))) Call: (mgu ?x a ((?y . (f ?x)) (t . t))) Exit: ((?x . a) (?y . (f ?x)) (t . t) Exit: ((?x . a) (?y . (f ?x)) (t . t)) Exit: ((?x . a) (?y . (f ?x)) (t . t))

  15. Example (mgu ‘(p (f ?x) (f ?x)) ‘(p ?y (f ?y))) Call: (MGU (P ?x ?x) (P ?y (F ?y)) ((t . t))) | Call: (MGU P P ((t . t))) | Exit: ((t . t)) | Call: (MGU (F ?x) ?y ((t . t)) | Exit: ((?y . (F ?x)) (t . t))) | Call: (MGU (F ?x) (F ?y) ((t . t)) | | Call: (MGU F F ((?y . (F ?x)) (t . t))) | | Exit: ((?y . (F ?x)) (t . t))) | | Call: (MGU ?x ?y ((?y . (F ?x)) (t . t))) | | Exit: NIL | Exit: NIL Exit: NIL NIL

  16. Evaluate (defun myevaluate (*thing* p *theory*) (let (*answers*) (myeval p nil *truth*) (nreverse (remove-duplicates *answers*)))) (defun eval (p pl al) (cond ((atom p) (evalrs p pl al)) ((eq 'not (car p)) (evalunprovable p pl al)) ((eq 'and (car p)) (eval (cadr p) (append (cddr p) pl) al)) (t (evalrs p pl al)))) (defun evalexit (pl al) (cond (pl (eval (car pl) (cdr pl) al)) (t (setq *answers* (cons (plug *thing* al) *answers*)))))

  17. Evaluate (continued) (defun evalunprovable (p pl al) (unless (eval (cadr p) (cdr p) al) (evalexit pl al))) (defun evalrs (p pl al) (do ((l *theory* (cdr l)) (rule) (bl)) ((null l)) (setq rule (stdize (car l))) (when (setq bl (mguexp p rule al)) (evalexit pl bl))))

  18. Unification

  19. Substititions A substitution is a finite set of pairs of variables and terms, called replacements. {Xa, Yf(b), VW} The result of applying a substitution  to an expression  is the expression  obtained from  by replacing every occurrence of every variable in the substitution by its replacement. p(X,X,Y,Z){Xa,Yf(b),VW}=p(a,a,f(b),Z)

  20. Unification A substitution  is a unifier for an expression  and an expression  if and only if =. p(X,Y){Xa,Yb,Vb}=p(a,b) p(a,V){Xa,Yb,Vb}=p(a,b) If two expressions have a unifier, they are said to be unifiable. Otherwise, they are nonunifiable. p(X,X) p(a,b)

  21. Non-Uniqueness of Unification Unifier 1: p(X,Y){Xa,Yb,Vb}=p(a,b) p(a,V){Xa,Yb,Vb}=p(a,b) Unifier 2: p(X,Y){Xa,Yf(W),Vf(W)}=p(a,f(W)) p(a,V){Xa,Yf(W),Vf(W)}=p(a,f(W)) Unifier 3: p(X,Y){Xa,YV}=p(a,V) p(a,V){Xa,YV}=p(a,V)

  22. Most General Unifier A substitution  is a most general unifier (mgu) of two expressions if and only if it is as general as or more general than any other unifier. Theorem: If two expressions are unifiable, then they have an mgu that is unique up to variable permutation. p(X,Y){Xa,YV}=p(a,V) p(a,V){Xa,YV}=p(a,V) p(X,Y){Xa,VY}=p(a,Y) p(a,V){Xa,VY}=p(a,Y)

  23. Most General Unification (defun mgu (x y al) (cond ((eq x y) al) ((varp x) (mguvar x y al)) ((atom x) (cond ((varp y) (mguvar y x al)) ((atom y) (if (equalp x y) al)))) (t (cond ((varp y) (mguvar y x al)) ((atom y) nil) ((setq al (mgu (car x) (car y) al)) (mgu (cdr x) (cdr y) al))))))

  24. Most General Unification (continued) (defun mguvar (x y al) (let (dum) (cond ((setq dum (assoc x al)) (mgu (cdr dum) y al)) ((eq x (setq y (mguval y al))) al) ((mguchkp x y al)) nil) (t (acons x y al))))) (defun mguval (x al) (let (dum) (cond ((and (varp x) (setq dum (assoc x al))) (mguval (cdr dum) al)) (t x))))

  25. Problem ~hates(X,X) hates(Y,f(Y))

  26. Solution Before assigning a variable to an expression, first check that the variable does not occur within that expression. This is called, oddly enough, the occur check test. Prolog does not do the occur check (and is proud of it).

  27. Most General Unification (concluded) function mguchkp (p,q,al) {cond(p=q, al; varp(p), mguchkp(p,cdr(assoc(q,al)),al); atom(q), nil; t, some(lambda(x).mguchkp(p,x,al),q))}

  28. Most General Unification (concluded) function mguchkp (p,q,al) {if (p=q) al; else if varp(p) mguchkp(p,cdr(assoc(q,al)),al); else if atom(q) nil; else some(lambda(x).mguchkp(p,x,al),q)}

  29. Example Call: mgu(p(X,b),p(a,Y),{}) | | Call: mgu(p,p,{}) | Exit: {} | | Call: mgu(X,a,{}) | Exit: {Xa} | | Call: mgu(b,Y,{Xa}) | Exit: {Yb,Xa} | Exit: {Yb,Xa}

  30. Example Call: mgu(p(X,X),p(a,b),{}) | | Call: mgu(p,p,{}) | Exit: {} | | Call: mgu(X,a,{}) | Exit: {X <- a} | | Call: mgu(X,b, {X <- a}) | Call: mgu(a,b,{X <- a}) | Exit: nil | Exit: nil | Exit: nil

  31. Example Call: mgu(p(f(X),f(X)),p(Y,f(a)),{}) | | Call: mgu(p,p,{}) | Exit: {} | | Call: mgu(f(X),Y,{}) | Exit: {Y <- f(X)} | | Call: mgu(f(X),f(a),{Y <- f(X)}) | Call: mgu(f,f,{Y <- f(X)}) | Exit: {Y <- f(X)} | Call: mgu(X,a,{Y <- f(X)} | Exit: {X <- a,Y <- f(X)} | Exit: {X <- a,Y <- f(X)} | Exit: {X <- a,Y <- f(X)}

  32. Example Call: mgu(p(X,X),p(Y,f(Y)),{}) | | Call: mgu(p,p,{}) | Exit: {} | | Call: mgu(f(X),Y,{}) | Exit: {Y <- f(X)} | | Call: mgu(f(X),f(Y),{Y <- f(X)}) | Call: mgu(f,f,{Y <- f(X)}) | Exit: {Y <- f(X)} | Call: mgu(X,Y,{Y <- f(X)}) | Exit: nil | Exit: nil | Exit: nil

  33. Evaluation

  34. Reasoning Subroutines Database: Call: theory Exit: {m(a,b), m(b,c), p(X,Y)<=m(X,Y)} Subroutines: Call: findp(p(X,Y),theory) Exit: true Call: findx(X,p(X,Y),theory) Exit: A Call: finds(X,p(X,Y),theory) Exit: {A,B}

  35. Evaluate (defun myevaluate (*thing* p *theory*) (let (*answers*) (myeval p nil *truth*) (nreverse (remove-duplicates *answers*)))) (defun eval (p pl al) (cond ((atom p) (evalrs p pl al)) ((eq 'not (car p)) (evalunprovable p pl al)) ((eq 'and (car p)) (eval (cadr p) (append (cddr p) pl) al)) (t (evalrs p pl al)))) (defun evalexit (pl al) (cond (pl (eval (car pl) (cdr pl) al)) (t (setq *answers* (cons (plug *thing* al) *answers*)))))

  36. Evaluate (continued) (defun evalunprovable (p pl al) (unless (eval (cadr p) (cdr p) al) (evalexit pl al))) (defun evalrs (p pl al) (do ((l *theory* (cdr l)) (rule) (bl)) ((null l)) (setq rule (stdize (car l))) (when (setq bl (mguexp p rule al)) (evalexit pl bl))))

  37. Deduction

  38. Reasoning Subroutines Database: Call: theory Exit: {m(a,b), m(b,c),p(X,Y)<=m(X,Y)} Subroutines: Call: findp(p(X,Y),theory) Exit: true Call: findx(X,p(X,Y),theory) Exit: A Call: finds(X,p(X,Y),theory) Exit: {A,B}

  39. Backward (defun myevaluate (*thing* p *theory*) (let (*answers*) (myeval p nil *truth*) (nreverse (remove-duplicates *answers*)))) (defun eval (p pl al) (cond ((atom p) (evalrs p pl al)) ((eq 'not (car p)) (evalunprovable p pl al)) ((eq 'and (car p)) (eval (cadr p) (append (cddr p) pl) al)) (t (evalrs p pl al)))) (defun evalexit (pl al) (cond (pl (eval (car pl) (cdr pl) al)) (t (setq *answers* (cons (plug *thing* al) *answers*)))))

  40. Backward (continued) (defun evalunprovable (p pl al) (unless (eval (cadr p) (cdr p) al) (evalexit pl al))) (defun evalrs (p pl al) (do ((l *theory* (cdr l)) (rule) (bl)) ((null l)) (setq rule (stdize (car l))) (when (setq bl (mguexp p rule al)) (evalexit pl bl))))

  41. Backward Chaining Backward Chaining is the same as reduction except that it works on rule form rather than clausal form. Reduced literals need be retained only for non-Horn premises. Cancellation and Dropping are analogous.

  42. Example

  43. Example • Given q(x) p(x) and p(a), find a term  such that q() is • true. • q(x) p(x) Premise • p(a)  Premise • goal(z) q(z) Goal • goal(z) p(z) 1, 3 • goal(a) 2, 4

  44. Example • Given q(x) p(x) and p(a) and p(b), find a term  such that • q() is true. • q(x) p(x) Premise • p(a)  Premise • p(b)  Premise • goal(z) q(z) Goal • goal(z) p(z) 1, 4 • goal(a) 2, 5 • goal(b) 3, 5

  45. Example • Given q(x) p(x) and p(a) p(b), find a term  such that • q() is true. • q(x) p(x) Premise • p(a)  p(b)  Premise • goal(z) q(z) Goal • goal(z)  p(z) 1, 3 • goal(a)  p(b)  2, 4 • goal(a)goal(b) 4, 5

More Related