Unification:

Matching Expressions
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.
Objectives
Matching names
Unify two expressions
Unification procedure
Trace an example

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
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.
Substitute a constant for a variable
Unify p(a,X) and p(a,b)
b/X, i.e., substitute b for X
1
st
expression, p(a,X), becomes p(a,b)
2
nd
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.
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))

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

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)
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)
Composition of unifiers
E is a 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)]
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)
Unification algorithm
1. function unify(E1, E2)
2. Begin
3. case
4. 1. Both E1 and E2 are constants or the empty list
5. 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
Unification algorithm cont
14. 5. Otherwise:
15. Begin
16. 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
Unify the tails
Apply substitutions
to the tails
Combine the two
results and return.
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) )

2. Unify (parents, parents)
Return {}
3. Unify ((X (father X) (mother bill)) , ( bill (father bill) Y))
Line 18
5
22
4
Return{(mother bill)/Y,
bill/Z}}
24
Example contd
3. Unify((X (father X) (mother bill)) , ( bill (father bill) Y))
4. Unify(X,bill)
5. Unify( ( (father bill) (mother bill) ), ( (father bill) Y ) )
7.. Unify (father, father)
Return{bill/X}
6. Unify ( (father bill), (father bill) )
Apply
substitution
Return {}
8. Unify ( (bill), (bill) )
Return{}
Return{}
22
18
7
9
20, 21
22
18
18
5
22
5
5
24
Return{(mother bill)/Y}
Example contd
8. Unify((bill),(bill))

9. Unify (bill, bill)
10. Unify((),())
Return{}
Return{}
11. Unify ( ((mother,bill)), (Y) )
12. Unify ( (mother,bill), Y )
13. Unify((),())
Return{(mother bill)/Y}
Return{(mother bill)/Y}
22
18
22
5
5
Return{}
5
5. Unify( ( (father bill) (mother bill) ), ( (father bill) Y ) )
18
18
12
22
24
Return{}
5
Complete trace
Go left before go right.
Go down before go up.
Leaf nodes are the trivial cases.
Branch left to call itself with head elements.
Branch right to call itself with tail elements.
(parents X (father X) (mother bill) )
(parents bill (father bill) Y )
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.