sandbox/lpn/ch03/notes.md

Recursion

Recursive definitions require that the recursive function isn't the first clause, ex:

is_digesting(X,Y) :- just_ate(X,Y).
is_digesting(X,Y) :-
just_ate(X,Z),
is_digesting(Z,Y).

Recursive definition require a base ("escape") clause in addition to the recursive clause.

Rule ordering, goal ordering, and termination

Underlying vision for Prolog (and logic programming in general): the programmer should be able to describe problems, and the computer derives the solution. The programmer builds a knowledge base, then asks question of the computer.

Prolog's search order:

1. KB from top to bottom
2. Clauses from left to right
3. Backtracks on bad choices

This is somewhat of a procedural approach to declarative programming which may affect the answer. Compare descend1 with descend2:

child(anne,bridget).
child(bridget,caroline).
child(caroline,donna).
child(donna,emily).

descend1(X,Y) :- child(X,Y).
descend1(X,Y) :- child(X,Z),
                 descend1(Z,Y).

descend2(X,Y) :- descend2(Z,Y),
                 child(X,Z).

descend2(X,Y) :- child(X,Y).

Supposedly these give different answers, but swipl exploded on the latter... and continuing reading, that's the point --- a warning to avoid left-recursive rules.

The takeaway is that you can get the overall idea of how to write the program by approaching the problem declaratively. Sensible goal orderings ensure program / query termination: place the recursive definition last.

Exercises

Exercise 3.1

In the text, we discussed the predicate

descend(X,Y)  :-  child(X,Y).
descend(X,Y)  :-  child(X,Z),
                  descend(Z,Y).

Suppose we reformulated this predicate as follows:

descend(X,Y)  :-  child(X,Y).
descend(X,Y)  :-  descend(X,Z),
                  descend(Z,Y).

Would this be problematic?

A: yes: there's no termination clause. See descend3 in descend.pl.

Exercise 3.2

Do you know these wooden Russian dolls (Matryoshka dolls) where the smaller ones are contained in bigger ones?

Ex katarina(olga(natasha(irina))).

First, write a knowledge base using the predicate directlyIn/2 which encodes which doll is directly contained in which other doll. Then, define a recursive predicate in/2, that tells us which doll is (directly or indirectly) contained in which other dolls. For example, the query in(katarina,natasha) should evaluate to true, while in(olga, katarina) should fail.

directlyIn(natasha, irina).
directlyIn(olga, natasha).
directlyIn(katarina, olga).

in(X, Y) :- directlyIn(X, Y).
in(X, Y) :- directlyIn(X, Z),
            in(Z, Y).

Exercise 3.3

We have the following knowledge base:

directTrain(saarbruecken,dudweiler).
directTrain(forbach,saarbruecken).
directTrain(freyming,forbach).
directTrain(stAvold,freyming).
directTrain(fahlquemont,stAvold).
directTrain(metz,fahlquemont).
directTrain(nancy,metz).

That is, this knowledge base holds facts about towns it is possible to travel between by taking a direct train. But of course, we can travel further by chaining together direct train journeys. Write a recursive predicate travelFromTo/2 that tells us when we can travel by train between two towns. For example, when given the query travelFromTo(nancy,saarbruecken) it should reply yes.

travelFromTo(X, Y) :- directTrain(X, Y).
travelFromTo(X, Y) :- directTrain(X, Z),
                      travelFromTo(Z, Y).

Exercise 3.4

Define a predicate greater_than/2 that takes two numerals in the notation that we introduced in the text (that is, 0, succ(0), succ(succ(0)), and so on) as arguments and decides whether the first one is greater than the second one. For example:

?-  greater_than(succ(succ(succ(0))),succ(0)).
yes
?-  greater_than(succ(succ(0)),succ(succ(succ(0)))).
no

Answer (in succ.pl):

greater_than(succ(succ(X)), succ(0)).
greater_than(succ(X), succ(Y)) :-
    greater_than(X, Y).

Exercise 3.5

Binary trees are trees where all internal nodes have exactly two children. The smallest binary trees consist of only one leaf node. We will represent leaf nodes as leaf(Label). For instance, leaf(3) and leaf(7) are leaf nodes, and therefore small binary trees. Given two binary trees B1 and B2 we can combine them into one binary tree using the functor tree/2 as follows: tree(B1,B2). So, from the leaves leaf(1) and leaf(2) we can build the binary tree tree(leaf(1),leaf(2)) . And from the binary trees tree(leaf(1),leaf(2)) and leaf(4) we can build the binary tree tree(tree(leaf(1), leaf(2)),leaf(4)).

Now, define a predicate swap/2, which produces the mirror image of the binary tree that is its first argument. For example:

?-  swap(tree(tree(leaf(1),  leaf(2)),  leaf(4)),T).
T  =  tree(leaf(4),  tree(leaf(2),  leaf(1))).
yes

This one took a lot of thinking, but the solution is in tree.pl.