Recursion
Prof. Geraint A. Wiggins
Centre for Cognition, Computation and Culture
Goldsmiths College, University of London
Contents
• Recursion in general
• Recursion in Prolog
• Recursion on explicit structures
• Recursion on implicit structures
• Building recursive structures
Recursion in general
• Recursion is the idea of defining something in
terms of itself
• It is very closely bound up with the idea of
mathematical induction
• It allows us to make very clear statements of
algorithms. . .
• . . . because it is a very natural way to think
• Optimisations mean that programming recursively
can be efficient, too
“Recursion”, CIS335: Logic Programming,
Goldsmiths’ College, London 2
Some Recursive Definitions
• In Prolog, a list is either an empty list or a term
connected by ‘.’ to another list
• Someone’s ancestor can be one of their parents or
an ancestor of one of their parents
• We can sort a list of numbers into order by picking
out the smallest, and then sorting the rest
• We can sort a list of numbers into order by picking
one, say X, dividing the rest into two groups,
bigger and smaller than X, and sorting the two
groups
• We can reverse a list of terms by taking the first
element off, reversing the rest, and putting the first
element on the end
“Recursion”, CIS335: Logic Programming,
Goldsmiths’ College, London 3
Some Recursive Predicates
• Test if a term is a list
list( [] ).
list( [ |Tail] ) :- list( Tail ).
• Find an ancestor
ancestor( Old, Young ) :-
parent( Old, Young ).
ancestor( Old, Young ) :-
parent( Old, Middle ),
ancestor( Middle, Young ).
• Sort a list of numbers
sort( [], [] ).
sort( List, [Smallest|Sorted] ) :-
\+ List = [],
smallest( List, Smallest, Rest ),
sort( Rest, Sorted ).
“Recursion”, CIS335: Logic Programming,
Goldsmiths’ College, London 4
Some Recursive Predicates
• Sort a list of numbers
sort( [], [] ).
sort( [First|Rest], Ans ) :-
split( First, Rest, Small, Big ),
sort( Small, Front ),
sort( Big, Back ),
append( Front, [First|Back], Ans ).
• Reverse a list
reverse( [], [] ).
reverse( [Head|Tail], Answer ) :-
reverse( Tail, RevTail ),
append( RevTail, [Head], Answer ).
“Recursion”, CIS335: Logic Programming,
Goldsmiths’ College, London 5
Recursion in Prolog
• When we want to write recursive programs, we
need to think about two things:
1. How will the program terminate?
2. How will the program break up the data it
works on?
• Recursion is an example of a divide-and-conquer
strategy
“Recursion”, CIS335: Logic Programming,
Goldsmiths’ College, London 6
Recursion in Prolog (2)
• To ensure that a program terminates, we must have
at least one base case – a non-recursive clause
• We must also ensure that something gets (in some
sense) ”reduced” each time a recursive step
happens, so that we can say when we have got to
the end
• Example – testing if a term is a list:
– The base case is when we have an empty list –
the smallest list possible
– The recursive case breaks down a non-empty
list into a head and a tail. . .
– . . . and then tests the tail, so the thing being
tested gets smaller each time.
“Recursion”, CIS335: Logic Programming,
Goldsmiths’ College, London 7
Recursion on explicit structures
• Testing if a term is a list
list( [] ).
list( [ |Tail] ) :- list( Tail ).
?- list( [a,b,c] ).
Call: list( [a,b,c] ).
Unify: [ |Tail] = [a,b,c]
Call: list( [b,c] ).
Unify: [ |Tail’] = [b,c]
Call: list( [c] ).
Unify: [ |Tail’’] = [c]
Call: list( [] ).
“Recursion”, CIS335: Logic Programming,
Goldsmiths’ College, London 8
Recursion on explicit structures (2)
• Example: a binary tree datatype:
– Leaves are of form leaf( value )
– Branches are of form
branch( Left, Right )
• Testing if a term is a binary tree
tree( leaf( X )).
tree( branch( X, Y )) :-
tree( X ),
tree( Y ).
• Note that we normally put the base case first, so
that Prolog tests it first!
“Recursion”, CIS335: Logic Programming,
Goldsmiths’ College, London 9
Recursion on implicit structures
• An implicit datatype is one where there is no
visible term structure to control recursion
• Instead, the step along the datatype is defined by a
predicate, eg parent/2
• Example: parent/2
parent( john, mary ).
parent( anne, mary ).
parent( mary, dave ).
parent( tim, dave ).
• This forms an implicit binary tree, and we can use
it to control recursion just like an explicit one
“Recursion”, CIS335: Logic Programming,
Goldsmiths’ College, London 10
Recursion on implicit structures (2)
• Example: ancestor/2
parent( john, mary ).
parent( anne, mary ).
parent( mary, dave ).
parent( tim, dave ).
ancestor( Old, Young ) :-
parent( Old, Young ).
ancestor( Old, Young ) :-
parent( Old, Middle ),
ancestor( Middle, Young ).
“Recursion”, CIS335: Logic Programming,
Goldsmiths’ College, London 11
Recursion on implicit structures (3)
• Example run:
?- ancestor( john, dave ).
Call: ancestor( john, dave ).
Call: parent( john, dave ).
Fail.
Retry: ancestor( john, dave ).
Call: parent( john, Middle ).
Unify: Middle = mary.
Succeed: parent( john, mary ).
Call: ancestor( mary, dave ).
Call: parent( mary, dave ).
Succeed: parent( mary, dave ).
Succeed: ancestor( mary, dave ).
Succeed: ancestor( john, dave ).
“Recursion”, CIS335: Logic Programming,
Goldsmiths’ College, London 12
Building recursive structures
• In Prolog, taking terms apart and building them
are nearly always the same thing.
• For example, in append/3:
append( [], List, List ).
append( [H|T], List, [H|BigList] ) :-
append( T, List, BigList ).
• Arguments 1 and 3 are both “broken down” or
“built up” by unification; we don’t usually use
both as inputs
• Exercise 2 shows how append/3 can be used
both to split up a list and to join lists together
• This is one reason why it is better not to think of
predicates as having “outputs” at all
“Recursion”, CIS335: Logic Programming,
Goldsmiths’ College, London 13
Building recursive structures (2)
• In the examples so far, the answer has been built
up in reverse of the breakdown of the input (no
matter which way round they are)
• Alternatively, we can use an accumulator
argument to build up an answer as we break down
the input
• Example, reverse/3:
reverse( [], Answer, Answer ).
reverse( [H|T], SoFar, Answer ) :-
reverse( T, [H|SoFar], Answer ).
?- reverse( List, [], Answer ).
(This is an example of tail-recursive optimisation.)
“Recursion”, CIS335: Logic Programming,
Goldsmiths’ College, London 14
Building recursive structures (3)
• Example run of reverse/3:
?- reverse( [a,b,c], [], Ans ).
Call: reverse( [a,b,c], [], Ans ).
Unify: [a,b,c] = [H|T], SoFar = []
Call: reverse( [b,c], [a], Ans ).
Unify: [b,c] = [H’|T’], SoFar’ = [a]
Call: reverse( [c], [b,a], Ans ).
Unify: [c] = [H’’|T’’], SoFar’’ = [b,a]
Call: reverse( [], [c,b,a], Ans ).
Unify: Ans = Answer, Answer = [c,b,a]
“Recursion”, CIS335: Logic Programming,
Goldsmiths’ College, London 15
