Você está na página 1de 22

This document is an edited version of a Hypercard Stack written by

Mike Brayshaw as part of Joint Research Council project ``The

Construction and Evaluation of a Prolog Techniques Editor''. It is
adapted with his permission. Adapted by Paul Brna and Tamsin Treasure-
Jones. To report any problems, send mail to tamsin@cbl.leeds.ac.uk.

Introduction to Prolog

Prolog is a logic language that is particularly suited to programs that involve symbolic
or non-numeric computation. For this reason it is a frequently used language in
Artificial Intelligence where manipulation of symbols and inference about them is a
common task.

Prolog consists of a series of rules and facts. A program is run by presenting some query
and seeing if this can be proved against these known rules and facts. In this tutorial we
will attempt to give you a flavour of how all this is achieved and teach you how to write
a simple program for yourself.

In this tutorial we will introduce some of the central concepts of Prolog under a series of
topic headings. Each discussion will be structured as follows. Firstly a concept will be
described in detail, then we shall present a series of worked examples to show how the
concept is applied, then finally present some simple exercises. When you have done the
exercises, we'll either pass on to the next topic to give you some further hints or suggest
you re-browse the current topic before moving on.

Facts with Arguments

More complicated facts consist of a relation and the items that this refers to. These
items are called arguments. Facts can have arbitrary number of arguments from zero
upwards. A general model is shown below:

relation(<argument1>,<argument2>,....,<argumentN> ).

Relation names must begin with a lowercase letter


The above fact says that a relationship likes links john and mary. This fact may be read
as either john likes mary or mary likes john. This reversibility can be very useful to the
programmer, however it can also lead to some pitfalls. Thus you should always be clear
and consistent how you intend to interpret the relation and when.

Finally, remember names of the relations are defined by you. With the exception of a
few relations that the system has built into it, the system only knows about relations that
you tell it about.

Facts with Arguments Examples 1

An example database. It details who eats what in some world model.

eats(fred,oranges). /* "Fred eats oranges" */

eats(fred,t_bone_steaks). /* "Fred eats T-bone steaks" */

eats(tony,apples). /* "Tony eats apples" */

eats(john,apples). /* "John eats apples" */

eats(john,grapefruit). /* "John eats grapefruit" */

If we now ask some queries we would get the following interaction:

?- eats(fred,oranges). /* does this match anything in the database? */

yes /* yes, matches the first clause in the database */

Variables and Unification

How do we say something like "What does Fred eat"? Suppose we had the following
fact in our database:


How do we ask what fred eats. We could type in something like

?- eats(fred,what).

However Prolog will say no. The reason for this is that what does not match with
mangoes. In order to match arguments in this way we must use a Variable. The process
of matching items with variables is known as unification. Variables are distinguished by
starting with a capital letter. Here are some examples:

X /* a capital letter */

VaRiAbLe /* a word - it be made up or either case of letters */

My_name /* we can link words together via '_' (underscore) */

Thus returning to our first question we can find out what fred eats by

?- eats(fred,What).



As a result of this query, the variable What has matched (or unified) with mangoes. We
say that the variable What now has the binding mangoes. When we pose a query, if the
query is successful, Prolog prints both the variable and the variable name, as we see
Variable Examples 1

Let's consider some examples using facts. First consider the following database.



Now let's look at some simple queries using variables

?- loves(john,Who). /* Who does john love? */

Who=mary /* yes , Who gets bound to mary */

yes /* and the query succeeds*/

?- loves(arnold,Who) /* does arnold love anybody */

no /* no, arnold doesn't match john or fred */

?- loves(fred,Who). /* Who does fred love */

Who = hobbies /* Note the to Prolog Who is just the name

of a variable, it */

yes /* semantic connotations are not picked up,

hence Who unifies */

/* with hobbies */

Variable Examples 2

Here are some more difficult object/variable comparisons. Consider the following
database showing a library of cassette tapes. Notice the final argument to tape, which is
the name of a favourite song from the album.






Let's now look at some queries.

?- tape(5,Artist,Album,Fave_Song). /* what are the

contents of tape 5 */




?- tape(4,rolling_stones,sticky_fingers,Song). /* find just song */

Song=brown_sugar /* which you like best from

the album */


?- eats(john,apples). /* do we have a fact that says john

eats apples? */

yes /* yes we do, clause 4 of our eats

database */

?- eats(mike,apples). /* how about this query, does mike eat

apples */

no /* not according to the above database.


?- eats(fred,apples). /* does fred eat apples */

no /* again no, we don't know whether fred

eats apples */

Facts with Arguments Examples 2

Let us consider another database. This time we will use the predicate age to indicate the
ages of various individuals.

age(john,32). /* John is 32 years old */

age(agnes,41). /* Agnes is 41 */

age(george,72). /* George is 72 */

age(ian,2). /* Ian is 2 */

age(thomas,25). /* Thomas is 25 */

If we now ask some queries we would get the following interaction:

?- age(ian,2). /* is Ian 2 years old? */

yes /* yes, matches against the fourth clause of

age */

?- agnes(41). /* for some relation agnes are they 41 */

no /* No. In the database above we only know
about the relation age, not about the relation agnes, so the query
fails */

?- age(ian,two) /* is Ian two years old? */

no /* No. two and 2 are not the same and

therefore don't match */

This is the end of the facts with arguments topic.


So far we have looked at how to represent facts and to query them. Now we move on to
rules. Rules allow us to make conditional statements about our world. Each rule can
have several variations, called clauses. These clauses give us different choices about
how to perform inference about our world. Let's take an example to make things clearer.

Consider the following

'All men are mortal':

We can express this as the following Prolog rule

mortal(X) :- human(X).

The clause can be read in two ways (called either a declarative or a procedural
interpretation). The declarative interpretation is "For a given X, X is mortal if X is
human." The procedural interpretation is "To prove the main goal that X is mortal,
prove the subgoal that X is human."

Rules 2:>

To continue our previous example, lets us define the fact 'Socrates is human' so that our
program now looks as follows:

mortal(X) :- human(X).


If we now pose the question to Prolog

?- mortal(socrates).

The Prolog interpreter would respond as follows: yes

Why was this? Well in order to solve the query ?- mortal(socrates)., we used the rule we
saw previously. This said that in order to prove someone mortal, we had to prove them
to be human. Thus from the goal Prolog generates the subgoal of showing
In the above example we were able to match human(socrates) against the database
described at the top of this card. In Prolog we say that the subgoal succeeded, and as a
result the overall goal succeeded. We know when this happens because Prolog prints

Rules 3

We can also use variables within queries. For example, we might wish to see if there is
somebody who is mortal. This is done by the following line.

?- mortal(P).

The Prolog interpreter responds.

P = socrates


This means that Prolog was able to prove the goal by binding the variable P to socrates.
This was done by again proving someone was mortal by proving the subgoal that they
were human. Prolog thus asked if there was any P that was human. This matches against
the clause human(socrates) thereby binding P to socrates. This binding is then passed
back to the parent goal, and the results in the printout we saw above.

Rules 4

Sometimes we may wish to specify alternative ways of proving a particular thing. This
we can do by using different rules and facts with the same name. For example, we can
represent the sentence 'Something is fun if its a red car or a blue bike or it is ice cream'
as follows:

fun(X) :- /* an item is fun if */

red(X), /* the item is red */

car(X). /* and it is a car */

fun(X) :- /* or an item is fun if */

blue(X), /* the item is blue */

bike(X). /* and it is a bike */

fun(ice_cream). /* and ice cream is also fun. */

This program says that we have three ways of finding out if something is fun.
Something is fun if it is a red and a car or blue and a bike, or if it is ice cream. These
three options are represent in Prolog by three clauses of the predicate fun. Just like we
saw for pure facts, Prolog will start from the first clause (beit a rule or fact) of fun and
try that. If that does not succeed, we try the next clause. We only fail when we run out
of rules or facts to try.
Rules 5

All identically-named variables within a particular rule (e.g. all occurrences of, say, X
in the first fun rule below) are constrained to have one and the same instantiation for
each solution to a particular query. Identical variable names in separate rules are totally
independent, just as if different variable names had been used. Because the
consequences of the preceding two sentences are so fundamental to Prolog (and so often
misunderstood), we recommend that you read them again. To give an example

The program

fun(X) :-


fun(X) :-


Looks to Prolog Like

fun(X_1) :-


fun(X_2) :-


Thus variable name scoping is per-individual rule (often called a clause). The same
variable name may appear in different clauses of a rule, or rules with different names.
Each time it is treated as something specific to its context. A variable X may occur in
the program many times with many different bindings. It will only have the same
bindings when you tell it to.

Examples of Rules 1

Consider the following program:

fun(X) :-


fun(X) :-


Above is both our previous program for finding fun items and facts describing some red
and blue items and some cars and bikes. Let's now use the above program and see if a
harley_davidson is fun. To do this we can ask Prolog the following question.

?- fun(harley_davidson). /* to which Prolog will

reply */

yes /* to show the program

succeeded */

To execute this query, Prolog will first see if harley_davidson is red, however only
vw_beatles and ford_escorts are defined as being red. Hence the query
red(harley_davidson) will fail. This means that the first clause of fun will fail. As a
result, we now try the second clause of fun. This will mean that we will attempt the
subgoals blue(harley_davidson) and bike(harley_davidson). Both these goals match
facts in the database. As a result fun succeeds as we saw above.

Examples of Rules 2

fun(X) :-


fun(X) :-



We can also ask our program to find fun items for us. To do this we can pose the
following question.

?- fun(What).

To which Prolog will reply


Let's see how Prolog deals with this query. Firstly we will try the first clause of fun.
This results in us trying the goal red(What). This succeeds matching the first clause of
red with the binding What=vw_beatle. Now we attempt the goal car(vw_beatle). This
matches the first clause of car, and, as a result, the fun goal succeeds.


Introducing Backtracking

Suppose that we have the following database




So far we have only been able to ask if fred eats specific things. Suppose that I wish to
instead answer the question, "What are all the things that fred eats". To answer this I can
use variables again. Thus I can type in the query

?- eats(fred,FoodItem).

As we have seen earlier, Prolog will answer with

FoodItem = pears

This is because it has found the first clause in the database. At this point Prolog allows
us to ask if there are other possible solutions. When we do so we get the following.

FoodItem = t_bone_steak

if I ask for another solution, Prolog will then give us.

FoodItem = apples

If we ask for further solutions, Prolog will answer no, since there are only three ways to
prove fred eats something. The mechanism for finding multiple solution is called
backtracking. This is an essential mechanism in Prolog and we shall see more of it later.

Backtracking in Rules

We can also have backtracking in rules. For example consider the following program.









If we now pose the query

?- hold_party(Who).

In order to solve the above, Prolog first attempts to find a clause of birthday, it being the
first subgoal of birthday. This binds X to tom. We then attempt the goal happy(tom).
This will fail, since it doesn't match the above database. As a result, Prolog backtracks.
This means that Prolog goes back to its last choice point and sees if there is an
alternative solution. In this case, this means going back and attempting to find another
clause of birthday. This time we can use clause two, binding X to fred. This then causes
us to try the goal happy(fred). Again this will fail to match our database. As a result, we
backtrack again. This time we find clause three of birthday, and bind X to helen, and
attempt the goal happy(helen). This goal matches against clause 3 of our happy
database. As a result, hold_party will succeed with X=helen.
Search Example 1

Consider the following examples.

fun(X) :- /* something is either fun because its .... */

red(X), /* red */

car(X). /* and a car */

fun(X) :- /* or its fun if its.... */

blue(X), /* blue */

bike(X). /* and a bike */

/* database of red items */




/* database of cars */



This program says that red cars or blue bikes are fun. It then goes on to name some
examples of each type of object.

Search Example 2

Let's now ask what is a fun item. To do this we first must enter the following query

?- fun(What).

We first attempt to prove something is fun. To do this we have two clauses of fun that
we can use

/* clause 1 */

fun(X) :-


/* clause 2 */

fun(X) :-



Using the first clause, we can now look to see if we can find some red object

Search Example 3

First let's retrieve a red object from the red database

/* database of red items */

red(apple_1). first choice



The first red item that we find is apple_1. This gives us the instantiation X=apple_1.
Next we have to see if this is a car, so we ask the question car(apple_1). Does this
match with our existing database of facts about cars?

/* database of cars */



The answers is that it will not. apple_1 will not match with desoto_48 or with edsel_57.
So what do we do next? In such cases, Prolog backtracks in order to find another
solution. Thus we go back to the red database, and see if we can find another possible
solution. In this case we can


red(block_1). second choice


We can use the next clause and see if block_1 is a red car.

Search Example 4

Returning to our cars database, again block_1 will not match against desoto_48 or with
edsel_57. In this case we must backtrack a second time to see if there is another red item
that we can find. This time we find the third clause in the database, and use that.


red(car_27). third choice

We now attempt the car goal again, but this time for car_27. Now recall what we said
earlier about the dangers of over estimating the powers of Prolog. Prolog will try to
match the goal car(car_27) against the database



This will fail. car_27 does not match with either desoto_48 or edsel_57. Although the
programmer probably meant car_27 to mean car number 27 to be a car, Prolog has no
way of gleaning this intended semantics, and fails the call based on a simple pattern

Well, what do we do now. The first step is to go back and see if there are any more
possible red items. Well we have now exhausted all three choices, hence there are no
more red items to choose from. Given that there are no more possible ways that we
could satisfy clause 1, we now more on to clause 2, as we see on the next card.

Search Example 5

Let us recall our program. It said that something was fun if it was red and a car or blue
and a bike. Well, we couldn't find something that was both red and a car, so we now see
if something blue and a bike. Let's recap the code:

/* clause 1 */

fun(X) :- we've tried this clause but without luck



/* clause 2 */

fun(X) :- so lets have a go with this clause now



Thus we will now try to prove that something is fun, by trying to find something that is
blue, using the blue database:
/* database of blue items */




In this case we now choose blue(flower_3)

Search Example 6

We now have to prove the goal bike(flower_3) against our bike database:




This again must fail, since flower_3 does not match against iris_8, my_bike, or
honda_81. So as before, we must backtrack and find an alternate blue item. Recall our




We have tried flower_3 without luck, so next we try the second blue fact, blue(glass_9).
We now try goal bike(glass_9). Again this fails to unify. As a result we must go back
yet again and find another blue object. This time we will use the third clause of blue,
blue(honda_81). We will now give us the goal bike(honda_81). This matches clause
three!. So at last we have found something which is blue and a bike. As a result we can
now conclude that it is fun, Prolog then displays the following:

?- fun(What).



Recursion 1

As is commonly the case in many programming tasks, we often wish to repeatedly

perform some operation either over a whole data-structure, or until a certain point is
reached. The way we typically do this in Prolog is by recursion. This simply means a
program calls itself typically until some final point is reached. Frequently in Prolog
what this means is that we have a first fact that acts as some stopping condition
followed up by some rule(s) that performs some operation before reinvoking itself.
Recursion is often found to be a hard concept to grasp. For this reason we will present
two detailed examples of how it works.

Recursion 2





on_route is a recursive predicate. This program sees if it is possible to travel to rome

from a particular place. The first clause sees if we have already reached rome, in which
case we stop. The second clause sees if there is a move from the current place, to
somewhere new, and then recursive sees if the NewPlace is on_route to rome. The
database of moves that we can make is on the right.

Let's now consider what happens when we pose the query ?- on_route(home). This
matches clause two of on_route (it can't match clause one because home and rome don't
unify). The second on_route clause consists of two subgoals. The first asks whether you
can move from home to some new location i.e. move(home,Method,NewPlace). This
succeeds with Method = taxi, NewPlace = halifax. This says that yes we can move from
home by taking a taxi to halifax. Next we recursively see if we can find a route from
halifax to rome by doing the same thing again. This is done by executing the new
subgoal on_route(halifax).

Recursion 3





The goal on_route(halifax) will fail to unify on clause one, so again we'll use the
recursive clause two and find some new place to go to. Hence we try the goal
move(halifax,Method,NewPlace) this succeeds because we can catch a train from
halifax to gatwick airport. Hence Method=train, NewPlace=gatwick. As a result we then
try the recursive call on_route(gatwick), i.e. we see if there is a move from gatwick
which will get us to rome.

We now try on_route(gatwick), again this only unifies with the second clause. As a
result we try the move clause again this time with Place bound to gatwick. This query
will match the third clause of the move database. The results in Method=plane,
NewPlace=rome. Next we try the recursive goal on_route(rome). This now matches
clause one of on_route. This is just a fact and succeeds. As a result all the other
on_route goals in turn succeed. Thus finally our first goal ?- on_route(home) succeeds
and Prolog responds yes

Recursion 4

parent(john,paul). /* paul is john's parent */

parent(paul,tom). /* tom is paul's parent */

parent(tom,mary). /* mary is tom's parent */

ancestor(X,Y):- parent(X,Y). /* someone is your ancestor if there

are your parent */

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

/* or somebody is your ancestor if they are the parent of someone who

is your ancestor */

The above program finds ancestors, by trying to link up people according to the
database of parents at the top to the card. So let's try it out by asking

?- ancestor(john,tom).

The first clause of ancestor looks to see if there exists a clause that could match the goal
parent(john,tom). This fails to match, as a result we try the second clause of ancestor.
We now pose the query parent(john,Z). This results in us choosing clause one of parent
and binding Z=paul. As a result, we now pose the recursive query ancestor(paul,tom).
Applying the ancestor rule again, we first try the first clause. This means we check for
parent(paul,tom). which successfully matches the second clause of parent. As a result
the goal ancestor(paul,tom) succeeds. This in turn leads to the goal ancestor(john,tom)
succeeding and Prolog responding yes


So far we have only considered simple items as arguments to our programs. However in
Prolog a very common data-structure is the list.

Lists themselves have the following syntax. They always start and end with square
brackets, and each of the items they contain is separated by a comma. Here is a simple
list [a,freddie,A_Variable,apple]

Prolog also has a special facility to split the first part of the list (called the head) away
from the rest of the list (known as the tail). We can place a special symbol | (pronounced
'bar') in the list to distinguish between the first item in the list and the remaining list. For
example, consider the following.

[first,second,third] = [A|B] /*where A = first and B=[second,third]*/

The unification here succeeds. A is bound to the first item in the list, and B to the
remaining list.

List Examples 1

Here are some example simple lists



[ ] /* this is a special list, it is called the empty list because

it contains nothing */

Now lets consider some comparisons of lists:

[a,b,c] unifies with [Head|Tail] resulting in Head=a and Tail=[b,c]

[a] unifies with [H|T] resulting in H=a and T=[]

[a,b,c] unifies with [a|T] resulting in T=[b,c]

[a,b,c] doesn't unify with [b|T]

[] doesn't unify with [H|T]

[] unifies with []. Two empty lists always match

List Example 2

Consider the following fact. p([H|T], H, T).

Lets see what happens when we ask some simple queries.

?- p([a,b,c], X, Y).




?- p([a], X, Y).




?- p([], X, Y).

List Searching

We can use lists within facts and rules. One common way of using lists is to store
information within a list and then subsequently search for this information when we run
our programs. In order to search a list, Prolog inspects the first item in a list and then
goes on to repeat the same process on the rest of the list. This is done by using
recursion. The search can either stop when we find a particular item at the start of the
list or when we have searched the whole list, in which case the list to be searched will
be the empty list. In order to do this, we have to be able to selectively pull the list apart.
We have already seen how we can go about doing this. In the previous section we
showed how to take the head and a tail of a list:


This method constitutes the basis of the searching method. We shall use it to pull apart a
list, looking at the first item each time, recursively looking at the tail, until we reach the
empty list [], when we will stop.

List Searching: Example 1

Consider the following problem. How can I see if a particular item is on a particular
list? For example I want to test to see if item apples is on the list [pears, tomatoes,
apples, grapes]. One possible method of doing this is by going through the list, an item
at a time, to see if we can find the item we are looking for. The way we do this in Prolog
is to say that we could definitely prove an item was on a list if we knew that the target
item was the first one on the list. ie.

on(Item,[Item|Rest]). /* is the target item the head of the list


Otherwise we could prove something was on a list if we could prove that although it
didn't match the existing head of the list, it nonetheless would match another head of the
list if we disregarded the first item and just considered the rest of the list i.e.



We now have a program consisting of a fact and a rule for testing if something is on a
rule. To recap, it sees if something is the first item in the list. If it is we succeed. If it is
not, then we throw away the first item in the list and look at the rest.

List Searching: Example 2



Let's go through the last example again in more detail. Suppose we pose the query:

?- on(apples, [pears, tomatoes, apples, grapes]).

The first clause of on requires the first argument of on to match with the list head.
However apples and pears do not match. Thus we must move on to the second clause.
This splits the list up as follows:

DisregardHead = pears

Tail = [tomatoes,apples,grapes]

This now gives us the following goal in the body of our rule:

on(apples, [tomatoes, apples, grapes]).

Again, we see if apples and tomatoes match using our initial facts. Since they don't, we
again use our second clause to strip off the current list head, giving us the new goal:
on(apples,[apples,grapes]). Since apples matches apples our first clause succeeds as
does our query.

List Construction.

The last example showed how we could strip off the front items on a list and recursively
search the rest. We can also use the same method to build lists. For example take one
existing list, say List1. We can make a new list List2 which contains List1 but with the
new head prolog, as follows:

List2 = [prolog|List1]

This again is pure unification. List2 now consists of the head prolog plus whatever List1
was bound to. If List1 were to be bound e.g. List1 = [list,c,pascal,basic], List2 would
now be the list [prolog,lisp,c,pascal,basic]

We can use this construction technique to build lists during recursion. We'll present
three examples of this in the forthcoming cards.

List Construction Example 1.

An example use of list construction is when we wish to create a new list out of two
existing lists. We'll illustrate this by defining a predicate called append that takes three
arguments. The first two are lists. The predicate uses these two lists to produce a third
list which combines the original two. For example,

?- append([a,b,c],[one,two,three],Result).

Result = [a,b,c,one,two,three]
The way we do this in Prolog uses both list construction and list deconstruction. Recall
that on the previous card we saw how we could glue an item onto the front of a list to
produce a new list. Thus we can produce the list [c,one,two,three] from the list [one,two
three] by saying NewList = [c|[one,two,three]. This results in NewList being bound to
the list [c,one,two,three]. This is the clue to how we write append in Prolog. We can
recursively split the first list into single items by the deconstruction techniques
discussed earlier. We can then use the construction method above to glue together a new
list, which we shall illustrate next.

List Construction Example 2

In order to write append we shall first search through the first list, and taking each item
in turn, add it to the second list. This we'll do recursively, by searching for the end of
the first list, and then adding the items in the first list to the items in the second list in
reverse order. Thus the last item in the first list is the first to be added to the second list.
We illustrate this more clearly with an example. First lets see what the code to do this
look like. First we must deal with the case when the first list is an empty list. In this case
the result of appending the two lists will just be the second list. Thus this gives


Now for the rule which does most of the work. This says search through the first list can
each time stick the first thing on the first list onto the resulting list.



Now lets go through in detail how this actual works.

List Construction Example 3

Recall our code and query ?- append([a,b,c],[one,two,three],Result).




Let's now follow the program as it executes. Using the second rule we first reduce the
query to


and then to


and finally to

This final clause can match against the initial fact, giving
append([],[one,two,three],[one,two,three]). Since this is a fact, this terminates the
recursion. As we pop out of each recursive step we then add on (respectively) c,b, and a
to the list, giving the list [a,b,c.one,two,three].

List Construction Example 4

Let's now consider a second example of constructing lists. Taking the list
[1,12,3,14,5,8], lets construct a new list out of the old that contains only numbers
greater than 6. To do this we can search the list as we have seen before. If the item
passes our test, then we can add it to the output list. If it does not, then we can disgard
the item. To make a start, if the list to search is empty, we will return the empty list.
Hence we get the base case of the recursion.


Next we need to say that if the item passes our test, put it in the output list

sift([X|T],[X|Result]):- X > 6, /* is X greater than 6 */

sift(T,Result). /* if so then go find the rest */

Otherwise we are will disgard the head and look for other hits in the

sift([ThrowAway|Tail],Result):- /* disgard the head */

sift(Tail,Result). /* and look in the tail */

List Constructions Example 5

Let us now see how our program respond to the query

?- sift([1,12,3,14,5,8], Result).

To this goal, we first unify with clause 2. The result is to evaluate the subgoal 1 > 6, this
clearly fails, so we move on to the third clause and try the goal
sift([12,3,14,5,8],Result). This again matches on the second clause of sift. We now try
the subgoal 12>6, this succeeds and we now attempt the goal sift([3,14,5,8],Result).
However, notice what also happens. By using this clause we also place 12 on our output

Stepping further through our example, we see that greater than subgoal in clause 2
succeeds for 14 and 8, till finally we get the goal sift([],Result). This matches the first
goal, with Result bound to []. As we come out of the recursion, we see that clause 2
builds up the result for to the list [8], then [14,8], then finally [12,14,8], before the query
finally succeeds.