Unification:

1. Unification: Matching Expressions

2. Motivations • You know what a well-formed FOL sentence looks like. • You know how to interpret a sentence to get its meaning from a model. • In this lecture, you will learn about one particular method that Prolog uses to help him calculate new true sentences from old ones. • The method is called unification.

3. Objectives • Matching names • Unify two expressions • Unification procedure • Trace an example

4. All men are mortal: Revisit Substitute socrates for X before applying modus ponens. X (man(X) => mortal(X)). man(socrates) man(socrates) => mortal(socrates) % substitute socrates for X mortal(socrates) % apply modus ponens

5. Matching names • To derive new true sentences, Prolog needs to use inference rules such as modus ponens. • To use modus ponens, Prolog needs to perform substitution operations, changing a variable to another variable or to a constant. • Unification is an algorithm for determining the substitutions needed to make two expressions match.

6. Substitute a constant for a variable • Unify p(a,X) and p(a,b) • b/X, i.e., substitute b for X • 1st expression, p(a,X), becomes p(a,b) • 2nd expression, p(a,b), reminds unchanged • both results in p(a,b) • Unify p(a,X) and p(Y,b) • a/Y, b/X • p(a,b) • The set of substitutions is called a unifier.

7. Substitute a function for a variable • Unify p(a,X) and p(Y,f(Y)) • a/Y • Now unify p(a,X) and p(a,f(a)) • Substitute a function for a variable • f(a)/X • p(a,f(a))

8. Unification failures • Unify p(a,X) and p(X,b) • a/X • Now unify p(a,a) and p(a,b) • failure • Unify p(a,b) and p(X,X) • a/X • Now unify p(a,b) and p(a,a) • failure

9. General and specific substitutions • General substitution • Unify p(X) and p(Y) • unifiers: Z/X, Z/Y • p(Z) • Specific substitution • Unify p(X) and p(Y) • fred/X, fred/Y • p(fred)

10. General and specific substitutions 2 • General substitution • Unify p(X, f(Y), b) and p(X, f(b), b) • b/Y • p(X, f(b),b) • Specific substitution • Unify p(X, f(Y), b) and p(X, f(b), b) • b/X, b/Y • p(b, f(b), b)

11. Composition of unifiers • E isa list of expressions. • s is a unifier of E. • g is the most general unifier of E • Then there exists another unifier s’ such that s = gs’ and Es = Egs' • Example: Unify p(X) and p(Y) • E = [p(X), p(Y)] • s = {fred/X, fred/Y} • g = {Z/X, Z/Y}. • Let s’ = {fred/Z} • gs’ = {Z/X, Z/Y} {fred/Z} = {fred/X, fred/Y} = s • Es = [p(fred), p(fred)] • Egs' = [p(Z), p(Z)]{fred/Z} = [p(fred), p(fred)]

12. List representation 1. p(a,X) (p a X) 2. p(Y, f(Y)) (p Y (f Y)) 3. parents( X, father(X), mother(bill) ) (parents X (father X) (mother bill) ) 4. parents(bill, father(bill), Y) (parents bill (father bill) Y)

13. Unification algorithm 1. function unify(E1, E2)2. Begin3. case 4. 1. Both E1 and E2 are constants or the empty list5. if E1 = E2 then return {} 6. else return Fail; 7. 2. E1 is a variable: 8. if E1 occurs in E2 then return Fail 9. else return {E2/E1}; 10. 3. E2 is a variable: 11. if E2 occurs in E1 then return Fail 12. else return {E1/E2} 13. 4. Either E1 or E2 are empty then return Fail 4 trivial or non-recursive cases

14. Unification algorithm cont’ 14. 5. Otherwise:15. Begin16. HE1 := first element of E1;17. HE2 := first element of E2;18. SUBS1 := unify(HE1, HE2);19. if SUBS1 := FAIL then return FAIL; 20. TE1 := apply(SUBS1, rest of E1);21. TE2 := apply(SUBS1, rest of E2); 22. SUBS2 := unify(TE1, TE2); 23. if SUBS2 = FAIL then return FAIL; 24. else return composition(SUBS1,SUBS2) 25. End begin 26. End case 27. End function 1 recursive case when E1 and E2 are lists. Unify the head elements Apply substitutions to the tails Unify the tails Combine the two results and return.

15. Trace Predicates: Parents(X, father(X), mother(bill)) Parents(bill, father(bill), Y) Lists: (parents X (father X) (mother bill)) (parents bill (father bill) Y) (parents X (father X) (mother bill) ) (parents bill (father bill) Y ) 1. Unify ( (parents X (father X) (mother bill)) , (parents bill (father bill) Y) ) 24 Return{(mother bill)/Y, bill/Z}} 5 Return {} Line 18 2. Unify (parents, parents) 22 4 3. Unify ((X (father X) (mother bill)) , ( bill (father bill) Y))

16. Example cont’d 22 3. Unify((X (father X) (mother bill)) , ( bill (father bill) Y)) 24 20, 21 Return{(mother bill)/Y} 9 Apply substitution Return{bill/X} 18 22 5. Unify( ( (father bill) (mother bill) ), ( (father bill) Y ) ) 4. Unify(X,bill) 7 5 Return{} 18 6. Unify ( (father bill), (father bill) ) 5 5 Return{} 22 Return {} 18 8. Unify ( (bill), (bill) ) 7.. Unify (father, father)

17. Example cont’d 5. Unify( ( (father bill) (mother bill) ), ( (father bill) Y ) ) 5 Return{} 24 Return{(mother bill)/Y} 22 18 8. Unify((bill),(bill)) 11. Unify ( ((mother,bill)), (Y) ) 5 Return{} 12 5 5 18 Return{(mother bill)/Y} Return{} Return{} 9. Unify (bill, bill) 18 22 12. Unify ( (mother,bill), Y ) 22 13. Unify((),()) 10. Unify((),())

18. Complete trace Branch left to call itself with head elements. Branch right to call itself with tail elements. Go left before go right. Go down before go up. Leaf nodes are the trivial cases. (parents X (father X) (mother bill) ) (parents bill (father bill) Y )

19. Summary • In FOL, a variable name can match a constant, predicate, or function. • Expressions are represented as lists for efficient processing. • Algorithm unify performs matching of two expressions by matching their heads first and their tails recursively. • Prolog uses unification as part of the process for deriving new true sentences.