CS 152 - Lecture 20

Cay S. Horstmann

How Does Prolog Work?

• Informal example. Procedure

  member(X,[X|_]).
  member(X,[_|T]) :- member(X,T).

  Goal

  member(mary, [john, mary, pat]).

• Match goal with head of first clause
• Match fails: X can't be both mary and john
• Match goal with head of second clause
• Match succeeds: X = mary, _ = john, T = [mary, pat]
• Replace goal with right hand side

  member(mary, [mary, pat])

• This is the goal now. Match with head of first clause
• Match succeeds: X = mary, _ = pat
• First clause is a fact. Report true.
• Not done yet—also match with second clause...

Unification

• Given: Two terms
• Want: Definitions for variables that make the terms identical
• Example: Terms member(X,[_|T]) and member(mary, [john, mary, pat])
• Solution X = mary, _ = john, T = [mary, pat]
• Can have variables in both terms
• Unification algorithm provides “most general” variable assignment

Unification Algorithm

• Start with a pair of terms
• As the algorithm progresses, we will get a set of pairs
• Each pair has the form L = R, where L, R are either a term or a variable
• Keep choosing an equation until failure occurs or no further change is possible

  Equation	Action
  f(s1, ..., sn) = f(t1, ..., tn)	Replace with s1 = t1, ..., sn = tn
  f(s1, ..., sn) = g(t1, ..., tn) where f ≠ g	Halt with failure
  X = X	Delete the equation
  t = X where t is not a variable	Replace with X = t
  X = t where X does not occur in t and it occurs elsewhere	Apply the substitution X = t to all other terms
  X = t where X occurs in t (but t ≠ X)	Halt with failure

Unification Example

• member(X,[_|T])= member(mary, [john, mary, pat])
• Write [ | ] as cons
• member(X, cons(Z, T))= member(mary, cons(john, cons(mary, cons(pat, nil))))
• Apply rule 1:
  • X = mary
  • cons(Z, T) = cons(john, cons(mary, cons(pat, nil)))
• Do it again:
  • X = mary
  • Z= john
  • T = cons(mary, cons(pat, nil))
• We are done

The Goal Stack

• The initial goal is the first goal on the stack
• New goals are pushed on the stack
• Yields depth-first search
• Example: Clauses

  parent(james1, charles1).
  parent(charles1, charles2).
  parent(charles1, catherine).
  parent(charles1, james2).
  
  grandparent(X, Y) :- parent(X, Z), parent(Z, Y).

  Query: grandparent(james1, G)

• Unify query with head of matching clause: X = james1, Y = G
• Push new goals on stack (leftmost on top)

  parent(james1, Z)
  parent(Z, G)

• Unify top query with head of matching clause: Z = charles1
• Pop off matched goal, apply substitution. Goal stack is now

  parent(charles1, G)

• Actually, easier to store original terms + substitutions

  parent(Z, Y) / X = james1, Y = G, Z = charles1

Choice Points

• When picking a match for query head, have choices
• Goal: parent(charles1, G)
• 5 choices

  parent(james1, charles1).
  parent(charles1, charles2).
  parent(charles1, catherine).
  parent(charles1, james2).

• First head doesn't match (Unification fails because charles1 ≠ james1)
• Stash away a copy of the goal stack for later backtracking.
• Next one is applied, yielding G = charles2
• Goal stack now empty. Report result (bindings of variables in original query)
• Still two choices to go.
• Backtrack to the next one. Yields G = catherine
• Etc.

Variable Renaming

• Can have name clashes with variables
• Example:

  ancestor(X, Z) :- parent(X, Y), ancestor(Y, Z).
  ancestor(X, Y) :- parent(X, Y).

  Query: ancestor(james1, X)

• Unify ancestor(james1, X) with ancestor(X, Z)
• Each term has variable X
• Rename rule variable: ancestor(james1, X) and ancestor(X1, Z)
• Unifying substitution: X1 = james1, X = Z
• Goal stack:

  parent(X1, Y) / X1 = james1, X = Z
  ancestor(Y, Z) / X1 = james1, X = Z

• Match for topmost goal: Y = charles1
• Now top goal is ancestor(Y, Z). Unify with ancestor(X, Z).
• More name clashes. Rename to ancestor(X2, Z1)

Summary of Prolog Algorithm

• Unification: Yields substitution that makes terms match
• Goal stack: Depth-first search
• Choice points: Backtracking

Lab

Step 1: Unification

1. Consider the terms

   member(X, cons(john, cons(mary, nil)))
   member(X17, cons(X17, T))

   Compute a unifying substitution (by hand). What is it?

2. Consider the goal

   member(X, cons(john, cons(mary, nil)))

   and the clause

   member(X, cons(X, T)) :- member(X,T).

   Compute a unifying substitution of the goal and the head of the clause after renaming variables in the clause. What is it?

3. Apply the substitution to the body of the clause. What term do you get?

Step 2: How Prolog Works

Save this Prolog.scala file and load it into Eclipse.

Note these commands in Main.main:

import Prolog._
val member = new Predicate
member('X, 'X::'Xs)!
member('X, 'Y::'Ys) :- member('X, 'Ys)
member('X, 'john :: 'mary :: 'nil)?
more
more

As you can see, the implementor of this interpreter cleverly overloaded operators ! (fact), :- (provided that) and ? (query).

Note the single quote that is used for variables.

Now change Main.main to

...
showMatches = true
member('X, 'john :: 'mary :: 'nil)?
more
more

What output do you get?

Step 3: A Complete Trace

Now comes the hard part: Put together a complete trace of what the interpreter does. In each step, you can choose from

• Push goal on goal stack
• Choose next matching rule
• Use unification to compute new substitution
• Rename variables in a rule
• Pop goal off goal stack
• Display result

Use the same substitution that the Scala interpreter uses. When I ran it, the trace output started with

unify 'X with 'john = true
unify 'X16 with 'john = true
unify 'Xs17 with 'mary :: 'nil = true

My solution would be

Step 1. Push member(X, cons(john, cons(mary, nil))) on goal stack

Step 2. Choose rule member(X, cons(X, Xs)).

Step 3. Rename into member(X16, cons(X16, Xs17)).

Step 4. Use unification: X = X16, john = X16, Xs17 = cons(mary, nil) solves as X = john, X16 = john, Xs17 = cons(mary, nil).

Step 5. Unification with fact was success. Display result.

Step 6. Choose rule member(X, cons(Y, Ys)) :- member(X, Ys).

...