Recursion, Structures, and

Lists
Artificial Intelligence Programming in Prolog
Lecturer: Tim Smith
Lecture 4
04/10/04

30/09/04 AIPP Lecture 3: Recursion, Structures, and Lists 1

 The central ideas of Prolog
• SUCCESS/FAILURE
– any computation can “succeed'' or “fail'', and this is used as
a ‘test‘ mechanism.
• MATCHING
– any two data items can be compared for similarity, and values
can be bound to variables in order to allow a match to
succeed.
• SEARCHING
– the whole activity of the Prolog system is to search through
various options to find a combination that succeeds.
• Main search tools are backtracking and recursion

• BACKTRACKING
– when the system fails during its search, it returns to previous
choices to see if making a different choice would allow
success.

30/09/04 AIPP Lecture 3: Recursion, Structures, and Lists 2

 Likes program
1) drinks(alan,beer).
2) likes(alan,coffee).
3) likes(heather,coffee).

4) likes(Person,Drink):-
drinks(Person,Drink).

5) likes(Person,Somebody):-
likes(Person,Drink),

likes(Somebody,Drink).

30/09/04 AIPP Lecture 3: Recursion, Structures, and Lists 3

 Representing Proof using Trees
• To help us understand Prolog’s proof strategy we can
represent its behaviour using AND/OR trees.
1. Query is the top-most point (node) of the tree.
2. Tree grows downwards (looks more like roots!).
3. Each branch denotes a subgoal.
1. The branch is labelled with the number of the matching clause and
2. any variables instantiated when matching the clause head.
4. Each branch ends with either: |?- likes(alan,X).
1. A successful match ,
2. A failed match , or 2 X/coffee
3. Another subgoal. 1st solution
= “Alan likes coffee.”
X = coffee

30/09/04 AIPP Lecture 3: Recursion, Structures, and Lists 4

Representing Proof using Trees (2)
• Using the tree we can see what happens when we ask
for another match ( ; )
|?- likes(alan,X).
2 Backtracking

X/coffee 4
X = coffee

drinks(alan,X).
1st match is failed
and forgotten 1 X/beer

X = beer
2nd solution
= “Alan likes beer because Alan drinks beer.”

30/09/04 AIPP Lecture 3: Recursion, Structures, and Lists 5

 Recursion using Trees
• When a predicate calls itself within its body we say
the clause is recursing
|?- likes(alan,X).
Conjoined subgoals
2
5
X/coffee 4
X = coffee
drinks(alan,X). likes(alan,Drink)
likes(Somebody,Drink)
1 X/beer X/coffee 2

X = beer
X = coffee

30/09/04 AIPP Lecture 3: Recursion, Structures, and Lists 6

 Recursion using Trees (2)
• When a predicate calls itself within its body we say
the clause is recursing
|?- likes(alan,X).
2
5
X/coffee 4
X = coffee
drinks(alan,X). likes(alan,coffee)
likes(Somebody,coffee)
1 X/beer X/coffee 2
Somebody 2
X = beer /alan
X = coffee
Somebody = alan

3rd solution = “Alan likes Alan because Alan likes coffee.”

30/09/04 AIPP Lecture 3: Recursion, Structures, and Lists 7

 Recursion using Trees (3)
• When a predicate calls itself within its body we say
the clause is recursing
|?- likes(alan,X).
2
5
X/coffee 4
X = coffee
drinks(alan,X).

likes(alan,coffee) likes(Somebody,coffee)
1 X/beer
Somebody
X/coffee 2 Somebody 3 / heather
/alan
X = beer 2
X = coffee Somebody
4 solution =
th
Somebody
“Alan likes Heather = heather
= alan
because Heather likes coffee.”

30/09/04 AIPP Lecture 3: Recursion, Structures, and Lists 8

 Infitite Recursive Loop
• If a recursive clause is called with an incorrect goal it will loop
as it can neither prove it
nor disprove it.
likes(Someb,coffee)

Somebody 2 3 5
= alan likes(Someb,coffee)
Somebody 2 likes(coffee,coffee)
= heather Someb = alan

likes/2 is a likes(coffee,X) likes(coffee,X)

left recursive clause.
likes(coffee,X2)
likes(X,X2)

likes(coffee,X3)
likes(X2,X3)

30/09/04 AIPP Lecture 3: Recursion, Structures, and Lists 9

 Why use recursion?
• It allows us to define very clear and elegant code.
– Why repeat code when you can reuse existing code.

• Relationships may be recursive

e.g. “X is my ancestor if X is my Ancestor’s ancestor.”

• Data is represented recursively and best processed

iteratively.
– Grammatical structures can contain themselves
– E.g. NP  (Det) N (PP), PP  P (NP)
– Ordered data: each element requires the same processing

• Allows Prolog to perform complex search of a

problem space without any dedicated algorithms.

30/09/04 AIPP Lecture 3: Recursion, Structures, and Lists 10

 Prolog Data Objects (Terms)
Simple objects Structured Objects

Constants Variables Structures Lists

X date(4,10,04) []
A_var person(bob,48) [a,b,g]
Atoms Integers _Var [[a],[b]]
-6 [bit(a,d),a,’Bob’]
987

Symbols Signs
a Strings <--->
bob ==>
l8r_2day ‘a’
…
‘Bob’
‘L8r 2day’

30/09/04 AIPP Lecture 3: Recursion, Structures, and Lists 11

 Structures
• To create a single data element from a collection of
related terms we use a structure.
• A structure is constructed from a functor (a constant
symbol) and one of more components.
functor
somerelationship(a,b,c,[1,2,3])

• The components can be of any type: atoms,

integers, variables, or structures.
• As functors are treated as data objects just like
constants they can be unified with variables
|?- X = date(04,10,04).
X = date(04,10,04)?
yes
30/09/04 AIPP Lecture 3: Recursion, Structures, and Lists 12
 Structure unification
• 2 structures will unify if
– the functors are the same,
– they have the same number of components,
– and all the components unify.
| ?- person(Nm,london,Age) = person(bob,london,48).
Nm = bob,
Age = 48?
yes
| ?- person(Someone,_,45) = person(harry,dundee,45).
Someone = harry ?
yes

• (A plain underscore ‘_’ is not bound to any value. By using it you

are telling Prolog to ignore this argument and not report it.)

30/09/04 AIPP Lecture 3: Recursion, Structures, and Lists 13

 Structure unification (2)
• A structure may also have another structure as a
component.
|?-addr(flat(4),street(‘Home Str.’),postcode(eh8_9lw))
= addr(flat(Z),Yy,postcode(Xxx)).
Z = 4,
Remember to
Yy = street(‘Home Str.’), close brackets!
Xxx = eh8_9lw ?
Reported variables are
yes
ordered according to
number of characters
• Unification of nested structures in the variable name.
works recursively:
– first it unifies the entire structure,
– then it tries to unify the nested structures.

30/09/04 AIPP Lecture 3: Recursion, Structures, and Lists 14

 Structures = facts?
• The syntax of structures and facts is identical but:
– Structures are not facts as they are not stored in the
database as being true (followed by a period ‘.’);
– Structures are generally just used to group data;
– Functors do not have to match predicate names.

• However predicates can be stored as structures

command(X):-
X. By instantiating a variable with a structure which
is also a predicate you can pass commands.
| ?- X = write(‘Passing a command’), command(X).
Passing a command
X = write('Passing a command') ?
yes

30/09/04 AIPP Lecture 3: Recursion, Structures, and Lists 15

 Lists
• A collection of ordered data.
• Has zero or more elements enclosed by square
brackets (‘[ ]’) and separated by commas (‘,’).
[a]  a list with one element
[]  an empty list
1 2 3
1 2

[34,tom,[2,3]]  a list with 3 elements where

the 3rd element is a list of 2 elements.
• Like any object, a list can be unified with a variable
|?- [Any, list, ‘of elements’] = X.
X = [Any, list, ‘of elements’]?
yes

30/09/04 AIPP Lecture 3: Recursion, Structures, and Lists 16

 List Unification
• Two lists unify if they are the same length and all their
elements unify.
|?-[a,B,c,D]=[A,b,C,d]. |?-[(a+X),(Y+b)]=[(W+c),(d+b)].
A = a, W = a,
B = b, X = c,
C = c, Y = d?
D = d ? yes
yes

|?- [[X,a]]=[b,Y]. |?-[[a],[B,c],[]]=[X,[b,c],Y].

no B = b,
X = [a],
Y = [] ?
Length 1 Length 2 yes

30/09/04 AIPP Lecture 3: Recursion, Structures, and Lists 17

 Definition of a List
• Lists are recursively defined structures.
“An empty list, [], is a list.
A structure of the form [X, …] is a list if X is a term and
[…] is a list, possibly empty.”
• This recursiveness is made explicit by the bar notation
– [Head|Tail] (‘|’ = bottom left PC keyboard character)

• Head must unify with a single term.

• Tail unifies with a list of any length, including an empty
list, [].
– the bar notation turns everything after the Head into a
list and unifies it with Tail.

30/09/04 AIPP Lecture 3: Recursion, Structures, and Lists 18

 Head and Tail
|?-[a,b,c,d]=[Head|Tail]. |?-[a,b,c,d]=[X|[Y|Z]].
Head = a, X = a,
Tail = [b,c,d]? Y = b,
yes Z = [c,d];
yes

|?-[a] = [H|T]. |?-[a,b,c]=[W|[X|[Y|

Z]]].
H = a, W = a,
T = []; X = b,
yes Y = c,
Z = []? yes

|?-[] = [H|T]. |?-[a|[b|[c|[]]]]= List.

no List = [a,b,c]?
yes
30/09/04 AIPP Lecture 3: Recursion, Structures, and Lists 19
 Summary
• Prolog’s proof strategy can be represented using
AND/OR trees.
• Tree representations allow us trace Prolog’s search
for multiple matches to a query.
• They also highlight the strengths and weaknesses of
recursion (e.g. economical code vs. infinite looping).
• Recursive data structures can be represented as
structures or lists.
• Structures can be unified with variables then used
as commands.
• Lists can store ordered data and allow its sequential
processing through recursion.

30/09/04 AIPP Lecture 3: Recursion, Structures, and Lists 20