66443 Programming Languages

Lecture Notes 4 November 1997

Logic Programming III

Unification

The discussion of unification and backtracking is based partly on a section of Kenneth C. Loudon, Programming Languages: Principles and Practice, PWS-KENT Publishing, Boston, 1993.

In Prolog the goal s = t attempts to unify the terms s and t. It succeeds if there is a way to assign values to the variables in both s and t so that the resulting terms are identical.

| ?- me = me.
yes

| ?- me=you.

no

| ?- me=X.

X = me
 

| ?- f(a,X) = f(Y,b).

X = b,
Y = a ;
no

| ?- f(X) = g(X).

no

| ?- f(X) = f(a,b).

no

| ?- f(a,g(X)) = f(Y,b).

no

| ?- f(a,g(X)) = f(Y,g(b)).

X = b,
Y = a 

| ?- X=Y.
X = _434,
Y = _434

A term is either a constant, a variable, or a function symbol followed by a sequence of terms. The last case is called a structured term and the terms in the sequence are called the arguments of the term.
A substitution is a finite set of (variable, term) pairs. Application of a substitution S = {(v1, t1), . . ., (vn, tn)} to a term t, written S(t), is defined inductively by
1. If t is a constant, S(t) is t.
2. If t is a variable, then if it is identical to vi for some i, 1 <= i <= n, then S(t) is ti; otherwise, S(t) is t.
3. If t is a structured term f(u1, . . ., um) then S(t) is f(S(u1), . . ., S(um)).
Standard unification algorithm: the inputs are two terms t1 and t2. The output is either a failure signal or a substitution S such that S(t1) is identical to S(t2).
1. A constant unifies only with itself: me = me succeeds but me = you fails.
2. A variable v that is uninstantiated unifies with any term that doesn't contain v, and becomes instantiated with that term. A variable v fails to unify with any term that contains v. A variable that is already instantiated is replaced by the term to which it is bound before proceeding.
3. Two structured terms unify only if both have the same function name and the same number of arguments, and the arguments can be unified recursively. Otherwise the unification fails.
The definition treats both terms symmetrically, in contrast to ordinary pattern matching, in which one term (the pattern) is allowed to have variables subject to instantiation, but the other (the subject) is not. For example, in pattern matching, if f(a, X) is the pattern and f(Y, b) is the subject, we can instantiate X to b but not Y to a, so the match fails. But f(a, X) unifies with f(Y, b) by instantiating X to b and Y to a.
Note how repeated occurrences of the same variable are handled. For example, f(X, h(X)) unifies with f(g(a), h(g(a))), because when the second X is encountered it is replaced by g(a), and then h(g(a)) on the left unifies with h(g(a)) on the right.
In most applications of unification, variables are renamed, if necessary, so that the two input terms have disjoint sets of variables. This is done for example in unifying a Prolog goal or subgoal term with the head term of a rule in the Prolog database. However, even if this renaming is done initially, it can still happen that recursive subcases of unification encounter pairs of terms that have variables in common. For example, . . .
Prolog's unification algorithm famously (or notoriously) differs from the standard algorithm in one respect: in unifying an uninstantiated variable v with a term t, it omits the check for v occurring in t (for the sake of efficiency). Omission of this check, called the "occurs check," can be considered a bug. (Why? What problems can it cause?)

Search Trees: a Way of Diagramming Prolog's Backtracking

Prolog considers goals left-to-right and clauses in its database in top-to-bottom order. Subgoals are considered immediately once they are set up. This search strategy can be viewed as depth-first search on a tree of possible choices.
Consider the following clauses:
```
(1) ancestor(X, Y) :- parent(X, Z), ancestor(Z,Y).
(2) ancestor(X, X).
(3) parent(amy, bob).
```
Given the goal ancestor(X, bob), Prolog's search strategy is left to right and depth first on the following tree of subgoals. Edges are labeled by the number of the clause used by Prolog for resolution, and instantiations of variables are written in curly brackets.
Leaf nodes in this tree occur either when no match is found for the leftmost clause or when all clauses have been eliminated, thus indicating success.
Whenever failure occurs, or the user indicates a continued search with a semicolon, Prolog backtracks up the tree to find further paths to a leaf, releasing instantiations of variables as it does so.
What are the advantages and disadvantages of this depth-first strategy? Consider what happens if we rewrite rule (1) as:
```
(1) ancestor(X, Y) :- ancestor(Z,Y), parent(X, Z).
```

A List Processing Example

Consider the appnd predicate, which is true if its third argument is a list that is the concatenation of its first two arguments.

appnd([],L,L).
appnd([H | T],L,[H | TL]) :-
           appnd(T,L,TL).

Here are some examples of the use of this predicate:

blackbox.cs.rpi.edu% prolog

Aquarius Prolog version 1.0 top-level (SPARC, SunOS)

| ?- consult('appnd.pro').

yes

| ?- appnd([1], [2, 3], [1, 2, 3]).

yes

| ?- appnd([1], [2, 3], [1, 2, 4]).

no

| ?- appnd([1], X, [1, 2, 4]).

X = [2,4] ;

no

Here the semicolon was typed by the user to cause prolog to search for further solutions. There were no others. But if we use two variables we can find all possible combinations of lists whose concatenation is [1, 2, 4], by typing semicolons until all combinations have been displayed:

| ?- appnd(X, Y, [1, 2, 4]).

X = [],
Y = [1,2,4] ;

X = [1],
Y = [2,4] ;

X = [1,2],
Y = [4] ;

X = [1,2,4],
Y = [] ;

no

| ?-

A good exercise is to draw the backtracking tree that Prolog builds in producing these solutions.