CS 152 - Lecture 19

Cover page image

Lists in Prolog

Empty list []
List with head H and tail T [H | T]
Short form for [john | [mary | [pat | []]]] is [john, mary, pat]

Use pattern matching to define list predicates

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

Sample queries

member(mary, [john, mary, pat]).
true ;
false
member(ann, [john, mary, pat]).
false ;
member(X, [john, mary, pat]).
X = john ;
X = mary ;
X = pat ;
false.

The Append Predicate

Prolog has only predicates, not functions
append(X, Y, Z) means “It is true that Z is X appended with Y”

append([], Ys, Ys).
append([X | Xs], Ys, [X | Zs]) :- append(Xs, Ys, Zs).

Sample queries

append([john], [mary, pat], Z).
Z = [john, mary, pat].
append(X, Y, [john, mary, pat]).
X = [],
Y = [john, mary, pat] ;
X = [john],
Y = [mary, pat] ;
X = [john, mary],
Y = [pat] ;
X = [john, mary, pat],
Y = [] ;
false.

Numbers in Prolog

Prolog has integer type
Three of the comparison operators look weird
```
> >= < =< =:= =\=
```
= is unification (see next lecture), not “evaluate and assign”. The query X = 3 + 4. (or 3 + 4 = X.) yields X = 3 + 4. How helpful!
Use is operator to force arithmetic evaluation.
```
X is 3 + 4.
X = 7
```
Right hand side of is can contain variables, but they must already be bound to numbers
Prolog cannot solve equations.
```
7 = 3 + X.
false
```

Factorial predicate: factorial(N, F) means F equals N!

factorial(0, 1).
factorial(N, F) :- N > 0, N1 is N - 1, factorial(N1, F1), F is N * F1.

Note that factorial(N - 1, F1) would not work. (See the lab).

Use `is` to Evaluate Arithmetic

By default, arithmetic expressions (and all other expressions) are unevaluated.
N + 1 is internally represented as add(N, 1).
Example: numlist(A, B, L) yields the list of numbers [A, A+1, ..., B]

Naive implementation of numlist:

numlist(A, B, []) :- A > B.
numlist(A, B, [A|Xs]) :- A =< B, numlist(A + 1, B, Xs).

Doesn't work:

numlist(1, 10, X).
X = [1, 1+1, 1+1+1, 1+1+1+1, ...]

Remedy: Force computation of A + 1 with is

numlist(A, B, [A|Xs]) :- A =< B, A1 is A + 1, numlist(A1, B, Xs).

Generate and Test

With some predicates, all variables are “in or out”
```
append(X, Y, [john, mary, pat]).
```
With others, only some of the variables can be used for output.
```
factorial(3, X) => X = 6
factorial(X, 6) => fail
```
Generate-and-test idiom: Generate a list of candidate solutions, then plug in and collect the answers
```
solvefac(N,M) :- numlist(1, M, L), member(N, L), factorial(N, M).
```

Fun and Games

Two-person game has positions. Example: Figures on a chess board + next turn (white|black).
Legal moves from one position to another—predicate move(X,Y)
Position is winning if the other person can't make a legal move. Example: Checkmate
A position is a winning position if the player can force a win, no matter what the opponent does.
In Prolog, this is very easy to check:
```
win(X) :- move(X,Y), not(win(Y)).
```

A Simple Game

Pile of pebbles. Each player can take either one or two pebbles. A player wins if only one pebble is left after their turn.

Prolog code:

move([o,o|T], [o|T]).
move([o,o,o|T], [o|T]).
win(X) :- move(X,Y), not(win(Y)).

Is [o] a winning position? No—there is no move([o],_).
Is [o,o] a winning position? Yes. Take one pebble, and the other player loses.
Is [o,o,o] a winning position? Yes. Take two pebbles, and the other player loses.
Is [o,o,o,o] a winning position? No. If you take one pebble, the other player takes two. If you take two pebbles, the other player takes one.
Is [o,o,o,o,o] a winning position? Yes. If you take one pebble, the other player has a losing position. Same with[o,o,o,o,o,o]. (Take two)
But [o,o,o,o,o,o,o] is a losing position—if you take one or two, the other player can win.

Lab

Step 1: Arithmetic

Consider this definition of a power of two predicate. pow2(N,M) means that M = 2^N. (Remember, we need a predicate, not a function, at the top level in Prolog.)
```
pow2(0, 1).
pow2(N, F) :- N > 0, pow2(N-1, F1), F is 2 * F1.
```
Try it out. What is the result of pow2(3,X)?
Use the text-based tracer to trace to the step
```
3-1-1-1 > 0
```
Does it succeed? Does it fail? If so, why? What happens next?
When you are done tracing, issue the query
```
3-1-1-1 > 0.
```
at the Prolog interpreter. What result do you get?
Fix pow2 by forcing evaluation of the arithmetic. What is your code for pow2 now? Confirm that pow2(3, X) works.
Try pow2(X,8). What happens?
That's disappointing, but if you think about it, there is no way Prolog could have figured out the answer. Except...
...by trying all the possible answers. What is the result of evaluating numlist(1, 8 L)?

Now try

solvepow2(N,M) :- numlist(1, M, L), member(N, L), pow2(N, M).

Try out solvepow2(X,8). Explain why it works.

Step 2: The Game of Nim

In the game of Nim, two players alternately remove marbles from a pile of marbles. In each turn, a player must remove at least one marble, and at most half the marbles. The player who is left with one marble loses. We will represent the game state by a list of o functors, such as [o,o,o,o,o]. Your task is to write a predicate move(From, To) that checks whether one can legally move from game state From to game state To. For example,
```
move([o,o,o,o,o],Y).
Y = [o,o,o] ;
Y = [o,o,o,o] ;
fail
```
Hint: It is very easy to check whether To is at least one less than F:
```
append(To, [o|_], From)
```
It is also easy to check that To is at least half as long as From. Append it to itself and check that you can append more to get From.

What is your move predicate?
A position is a winning position if the player can force a win, no matter what the opponent does.
```
win(X) :- move(X,Y), not(win(Y)).
```
For example,
```
win([o,o,o,o,o]).
true ;
fail.
```
Try out marble lists of length 1 to 10. Which ones are winning positions?