Ics1019 ics5003

Prof Matthew Montebello
matthew.montebello@um.edu.mt
https://www.um.edu.mt/profile/matthewmontebello
Prolog – Programming in Logic
ICS1019 / ICS5003 – Lecture 1

Course Description
During this course we pursue the theme of logic
programming by offering a comprehensive
introduction to the syntax, semantics and features of
Prolog, a well-known logic programming language that
has been used extensively in a wide variety of AI
application areas. The approach will be highly
practical, being organised around a series of carefully
chosen hands-on exercises.

Course Textbooks
Main Text:
o David Callear
Prolog Programming for Students
DP Publications Ltd., London.
1994
ISBN: 1-85805-093-6
Other:
o W.F.Clocksin and C.S.Mellish
Programming in Prolog
Springer-Verlag, Berlin.
1994
ISBN: 3-54058-350-5

Schedule 1. Introduction
2. Key features of Prolog
3. Further Prolog features
4. More on Rules
5. Evaluation
6. Backtracking
7. Numbers & Maths Operators
8. Basic Lists
9. Advanced Lists
10. Recursion
11. Advanced Recursion with Lists
12. CFG & DFG

o The Prolog language
o stands for PROgramming in LOGic
o developed to implement predicate calculus in a
computer program
o variety of uses
o Uses of Prolog
o AI applications
o Deductive systems
o Databases
o Image analysis
o Prolog Interpreters
o SICStus, SWI-Prolog, Quintus, Poplog,WINProlog,
TurboProlog.
o A simple program
1. Introduction

o PROLOG is a 5th. Generation prog. Language,
standing for PROgramming in LOGic and was
originally developed in Edinburgh University
in the 1970s.
o It is mainly used to program for A.I and is
based on a subset of Predicate Calculus (Horn
Clauses).
o Uses of Prolog
o AI applications
o Deductive / Decision support systems
o Databases
o Image analysis
o Natural Language Processing
o etc...
The Prolog Language

o Comparing Prolog to Pascal
o PASCAL
o is compiled to an executable file.
o Is imperative - sequence of instructions.
o Program flow - conditionals & loops.
o Has built-in functions.
o Expression evaluates to one of many values.
o PROLOG
o is interpreted.
o Is declarative - series of definitions.
o The HOW of solving the problem is NOT defined, only
what is TRUE or NOT of a certain state of affairs is
described.
o A statement can either be TRUE or FALSE.
o A few built-in rules, and a few fundamental
operations.
The Prolog Language

Comparing Prolog to Pascal
o PASCAL
These programs contain a series of
INSTRUCTIONS given to a computer as
PRCOEDURES to perform. The order of
doing things is SPECIFIED and a number of
ACTIONS performed as a consequence.
o PROLOG
On the other hand, these kind of programs
contain a set of FACTS and RULES. Aspects
of the problem which are TRUE or FALSE are
described (defined), rather than the method
to achieve a RESULT.
The Prolog Language

o Prolog interpreters
o SICStus (available @ CSAI).
o SWI-Prolog (downloadable).
o Quintus.
o Poplog.
o WinProlog.
o TurboProlog.
o LPA MacProlog.
o Recommended Texts
o L. Sterling and E. Shapiro, The Art of Prolog,
2nd Edition, MIT Press, 1994.
o I. Bratko, Prolog Programming for Artificial
Intelligence, Addison Wesley, 1990, ISBN 0-
201-41606-9
o W. Clocksin and C. Mellish, Programming in
Prolog, Berlin: Springer-Verlag 87.
The Prolog Language

o A simple program (program1.pl)
The Prolog Language
student(mark).
student(steve).
student(helen).
student(sylvia).
student(pauline).
student(frank).
female(helen).
female(sylvia).
female(pauline).
male(mark).
male(steve).
male(frank).
clever(helen).
clever(steve).
clever(pauline).
works_hard(helen).
works_hard(mark).
works_hard(frank).
| ?- male(mark).
yes
| ?- male(matthew).
no
| ?- clever(frank).
no
| ?- works_hard(frank).
yes
| ?-

o Another simple program(program2.pl)
The Prolog Language
student(marku).
student(pawlu).
student(maria).
student(sylvia).
student(pauline).
student(pietru).
mara(maria).
mara(sylvia).
mara(pauline).
ragel(marku).
ragel(pawlu).
ragel(pietru).
bravu(maria).
bravu(pawlu).
bravu(pauline).
biezel(maria).
biezel(marku).
biezel(pietru).
| ?- ragel(marku).
yes
| ?- ragel(mattew).
no
| ?- bravu(pietru).
no
| ?- biezel(pietru).
yes
| ?-

o Yet another simple prog.(program3.pl)
The Prolog Language
parent_of(mary,peter). parent_of(james,peter).
parent_of(mary,helen). parent_of(james,helen).
parent_of(mary,lydia). parent_of(james,lydia).
parent_of(marion,mary). parent_of(tony,mary).
parent_of(marion,mark). parent_of(tony,mark).
female(mary). female(helen).
female(lydia). female(marion).
male(peter). male(james).
male(tony). male(mark).
| ?- parent_of(mary,lydia).
yes
| ?- parent_of(mary,mary).
no
| ?-

o Relations
o facts
o rules
o example
o Queries - Goals
o simple
o with variables
o example
o Variables
o within goals
o anonymous
o Binding
o pattern matching
o backtracking
2. Key features of Prolog

In everyday life we often express facts about
properties of objects and relations between
objects.
e.g. Blood is red. red(blood).
Summer is hot. hot(summer).
Alison is nice.nice(alison).
similarly facts about relations:-
e.g. James is Peter’s parent
parent_of(james,peter).
Joe was born in Libja
born_in(john,libja).
5 is between 3 and 7
between(5,3,7).
These are called Predicates.
Relations - Facts

To express more complex relations as well as
define new relations in terms of existing
ones, rules are used.
e.g. A person is a son of another if the person
is a male and the other is a parent of this
same person.
son_of(Son,Parent):- male(Son),
parent_of(Parent,Son).
e.g. A person is older than another if he/she
was born before the other.
older_than(X,Y):- born(X,Year1),
born(Y,Year2),
Year1<Year2.
Relations - Rules

Worth noting:
Lower case letters are used to represent values
and are called atoms.
Higher case letters are used to represent
variables - discussed later.
Rules express properties or relations that hold
(true) if certain conditions are satisfied - these
are called goals.
The operator “ :- ” is used instead of the English
“if”.
The operator “ , ” is used as an ‘and’ in between
goals of a rule, while a “ ; ” is used as an ‘or’.
All properties, relations and rules must terminate
with a period (“.”).
Relations - Rules

program4.pl
student(mark).
student(steve).
student(helen).
student(sylvia).
student(pauline).
student(frank).
female(helen).
female(sylvia).
female(pauline).
male(mark).
male(steve).
male(frank).
clever(helen).
clever(steve).
clever(pauline).
works_hard(helen).
works_hard(mark).
works_hard(frank).
Relations - Example
clever_girl(Girl):-
student(Girl),
female(Girl),
clever(Girl).
get_first(Student):-
student(Student),
clever(Student),
works_hard(Student).
pass(Student):-
student(Student),
clever(Student).
pass(Student):-
student(Student),
pass(Student):-
student(Student),
clever(Student);
student(Student),

| ?- [program4].
{consulting program4.pl…}
{program4.pl consulted, 0 msec 10848bytes}
yes
| ?- student(frank).
yes
| ?- female(frank).
no
| ?-male(frank).
yes
| ?- clever(sylvia).
no
| ?- clever_girl(sylvia).
no
| ?- clever_girl(mark).
no.
| ?- clever_girl(Who).
Who = helen ;
Who = pauline ;
no
Relations - Example
| ?- get_first(Who).
Who = helen ;
no
| ?- pass(steve).
yes
| ?- clever(frank).
no
| ?- pass(frank).
yes

After that a program has been consulted we can
ask and query the information within the
program by issuing queries or questions called
goals. The goals will result true or false once
that the interpreter goes through predicates.
e.g. Is Pauline a female? (program1)
female(pauline).
e.g. Is Tony Peter’s parent? (program3)
parent_of(tony,peter).
These are simple goals as the questions are
specific queries on program facts.
To note that the interpreter scans all the
consulted program from top to bottom until
the goal is achieved (yes), or else if not true or
absent, a no is returned.
Queries - Goals

More general questions or queries can be
issued to the consulted program by placing
variables within the goal.
e.g. Who are all the female? (program1)
female(Who).
e.g. Who are Peter’s parents? (program3)
parent_of(WHO,peter).
Again in this case the interpreter scans all the
consulted program from top to bottom until
it binds a value to the variable and returns a
‘yes’. If we issue a ‘ ; ’ the interpreter will try
to satisfy the goal again by resuming the
scan. If no bindings are possible a ‘no’ will be
returned. Variables and binding will be
expanded later on.
Queries - Goals

Interesting to trace through a complex query with
variables within the goal.
e.g. Who will pass? (program3)
| ?- pass(Which_Student).
Which_Student = steve ;
Which_Student = helen ;
Which_Student = pauline ;
Which_Student = mark ;
Which_Student = helen ;
Which_Student = frank
| ?-
Why was Helen bound twice?
What is backtracking?
Backtracking is the process the interpreter engages in when one of
the predicates on the right hand side goals is not satisfied, and
so it attempts to satisfy again a previous goal in order to satisfy
the current one. Backtracking will be dealt in more detail in
lectures 5 and 6.
Queries - Example

Variables have already been defined as one or
more lettered strings with an initial capital
letter. The use of some variables within goals
have also been covered. But what about the
question
Who is a parent? (program3). Basically we don’t
care who the children are.
The Anonymous variable “_ ” is used.
| ?- parent_of(Parent,_).
Parent = mary ;
Parent = james ;
Parent = mary ;
Parent = james ;
Parent = mary ;
Parent = james ;
Parent = marion ;
Parent = tony ;
Parent = marion ;
Parent = tony
| ?-
Variables

The process of finding values for the variable
given in a goal involves a search of the
program. Starting from the top it looks for a
fact to match the goal and binds the goal
variable to the name that is argument to the
fact. This bound value is then returned to the
user as a solution to the goal.
If further values are requested, the program
returns to the point at which it last found a
successful match and resumes the program
search from there. The goal variable is at this
point unbound.
The methods that Prolog uses to achieve goals is
called pattern matching of goal to fact.
Sometimes the interpreter has to backtrack in
order to find other solutions which will satisfy
all the goals in the body of a rule.
Binding

When Prolog attempts to achieve a goal it checks
every fact and rule head to see if any of them
matches the form of the goal exactly in
spelling and also the number of arguments in
the clause. When the exact pattern of the goal
matches a clause, Prolog equates the
arguments of both sides.
e.g. parent_of(mary,Child). program3
Child = peter;
Child = helen;
Child = lydia
e.g. get_first(Student). program4
Student = helen
because student(helen) is TRUE
and clever(helen) is TRUE
and works_hard(helen) is TRUE too.
Binding - Pattern Matching

Backtracking is responsible for what has been called Prolog’s
“relentless search for solutions”; backtracking ensures
that if a solution exists to a goal it is found, and if more
than one solution exists then they are all found.
e.g. get_first(Student). program4
Student=mark binds but clever(mark) is false.
Prolog backtracks to satisfy student(Student)
Student=steve binds and clever(steve) is true, but
works_hard(steve) is false.
Bactracking again to clever(Student) and back to
student(Student) to try again.
Student = helen binds and is TRUE
clever(helen) is TRUE, and
works_hard(helen) is also TRUE.
Goal succeeds for Student = helen. YES.
Binding - Backtracking

o Cut
o description
o example
o Not
o possibilities
o example
o Goals
o arity
o conjoined
o multiple occurences
o examples
o Tutorial
o questions and queries
o handout
3. Further Prolog features

It is sometimes difficult to stop Prolog from
backtracking and continously searching for
further answers to a question (with repetitive
results). There is in fact a mechanism for
stopping Prolog searching called ‘cut’, which is
represented by the symbol ‘ ! ’. It is, however,
not the easiest of programming constructs to
use in Prolog and it’s not good practice to use a
cut to control your program - so try and avoid
it.
e.g. A rule to return 1 daughter only.
daughter_of(Daughter,Parent):-
parent_of(Parent,Daughter),
female(Daughter),!.
Prolog cannot backtrack past a cut.
Further features - Cut

Another operator that is best avoided if
possible is the not. If a clause can be
written in a positive form (i.e. intended to
succeed) than it is easier to read and
understand the rule concerned than if the
clause is intended to fail and is negated to
achieve success.
e.g. Which student will fail in program4.pl
fail(Student):- student(Student),
not(pass(Student)).
Special attention must be taken when using
not or cut.
The most significant problem is that free
variables are not allowed within a not on its
own in a rule, but should be the last of the
goals in a rule as the arguments will by then
usually be bound.
Further features - Not

We have already seen that goals on the
right side of a rule (its body) together
with fact and rules are unique depending
on the name and the number of
arguments - arity.
A number of goals conjoined with an ‘and’ (
, ) have to be all satisfied in order for the
rule to succeed.
Instead of using an ‘or’ ( ; ) in between
goals, it is better practice to write
additional rules with the same name and
arity. This is very similar to overloading
functions in C++ and Java.
Further features - Goals

A simple addition program (program5)
sum(Sum,X,Y):- Sum is X+Y.
sum(Sum,X,Y,Z):- sum(Sum1,Y,Z),Sum is X+Sum1.
sum(Sum,X,Y,Z,Zz):-sum(Sum1,X,Y),
sum(Sum2,Z,Zz),Sum is Sum1+Sum2.
mmont@zeus>sicstus
SICStus 3 #6: Mon Nov 3 18:32:08 MET 1997
| ?- [program5].
{consulting program5.pl…}
{program5.pl consulted, 0 msec 10848bytes}
yes
| ?- sum(S,2,3).
S = 5
| ?- sum(S,2,3,5).
S = 10
| ?- sum(S,2,3,5,10).
S = 20
| ?-
Lecture 7 will deal fully with numbers and
mathematical operators, whereas the rule
‘sum’ will be written much more efficiently
with lists (lects.8&9)
Further features - Example

Tutorial/Lab I page 1
After consulting program3.pl
o Issue the following queries and analyse the output obtained. Try using the “;” to get
alternate output.
| ?- parent_of(ParentOfMary, mary). (Who are Mary’s parents?)
| ?- parent_of(mary,_). (Is Mary a parent?)
| ?- parent_of(Parent,_). (Who is a parent?)
o Edit the file program3.pl in a text editor and add this rule at the end, save and re-consult in
Prolog:
daughter_of(Daughter,Parent):- parent_of(Parent,Daughter),
female(Daughter).
o Query the new rule to find out:
1. Who are the daughters of James?
2. Whose daughter is Mary? Same as who are Mary’s parents?
3. Who are all the daughters?
4. Who are the parents that have daughters?
o Write rules and query them appropriately for:
1. Son of a person using son_of(Son,Parent).
2. Mother of a person mother_of(Mother,Child).
3. Brother of a person brother_of(Brother,Person).
4. Grandfather of a person grand_father(Grandad,Grandchild).
5. Granddaughter of a person grand_daughter(Grandchild,Grandma).
6. Uncle of a person uncle_of(Uncle,NephewNiece).

Tutorial/Lab I page 2
After consulting program4.pl
o Issue the following queries and analyse the output
obtained. Try using the “;” to get alternate output.
| ?- get_first(mark). (Will Mark get a first?)
| ?- pass(Who). (Who will pass?)
o Edit the file program4.pl in a text editor and add
this rule at the end, save and re-consult in Prolog:
fail(Student):- student(Student),
not(pass(Student)).
o Query the new rule to find out:
Who will not pass? _____________
o Write a rule and query it appropriately for:
1. Clever boys using clever_boy(Boy).
2. Students who are clever but do not work hard
using the predicate pity_student(Student)

o Structure
o head
o body
o variables
o placeholders
o anonymous
o syntax
o semantics
o logical operators
IF :-
AND ,
OR ;
NOT ~
4. More on Rules

A rule is a convenient way of creating a
handle for an often used complex query,
just as a subroutine is a handle for a
complex set of instructions in a
procedural programming language
Rule syntax: Note that a rule as pointed
out in lecture 2 consists of:
o a left hand side or “head”, which has the
same shape as a fact.
o a right hand side which is identical to a
number of conjoined queries. It
comprises a list of queries or subgoals.
o the symbol :- which seperates both.
More on Rules

Rule semantics: The semantics of a rule
must be seen in the context of what
happens when a single query is
processed. The first step is to search the
database for a set of matching clauses,
which might be facts or rules.
NOTE:
1. A rule matches whenever the head of
the rule matches the query in just the
sense explained for a fact, i.e.
o matching predicate name
o matching arguments
o same number of arguments (arity)
More on Rules

More on Rules
2. The head of a rule contains variables that
will bind and will be used within the
goals.
3. The rule might succeed and be TRUE,
while also some of the variables in the
head are meant to be placeholders for the
values to be returned. e.g.
sum(Sum,X,Y).
4. Unlike a fact a rule has a right hand side
which specifies a list of subgoals that
must be achieved for the original query to
hold. e.g. sum(S,2,3).
X and Y bind with 2 and 3
respectively, while S with (2+3).

/* make(make reference, car make) */
car_make(01,ford).
car_make(02,rangerover).
car_make(03,toyota).
car_make(04,mazda).
car_make(05,daihatsu).
car_make(06,volkswagen).
car_make(07,fiat).
/* type(type reference, type of car) */
car_type(01,hatchback).
car_type(02,van).
car_type(03,off_road).
More on Rules - example6.pl
/* car(make ref, type ref, model, reg no, colour, year) */
car(01,01,escort,fsd127,blue,1990).
car(07,01,uno,tre333,blue,1996).
car(02,03,discovery,uje777,red,1995).
car(03,01,starlet,uij236,green,1991).
car(01,02,transit,ski432,green,1991).
car(07,01,bravo,juy677,red,1998).
car(03,03,hilux,kil989,blue,1991).
car(04,01,three2threeF,kul101,blue,1995).
car(05,01,charade,ill666,white,1991).
car(06,01,polo,ass001,blue,1997).
car(02,03,freelander,hyt456,blue,1998).
car(06,01,beetle,our127,yellow,1985).
car(03,02,hiace,far626,white,1992).
car(07,01,punto,jdu736,white,1996).

Consult this program to find out:
o the full details of all the blue cars,
o the registration numbers of the white cars,
o the 1995 models
Write a rule to find out:
o the year of all the off-roads
o the colour of all the fiats
o the model of the 1991 cars which are not white
o the make, registration number and model of all the blue
hatchbacks after 1991
To note:
o pattern matching
o binding
o backtracking
o negation
o variables arity
o use of anonymous variable
o what about a cut?
o any other queries we can make?
o similarity of example to SQL, INGRES in DB.
More on Rules - example6.pl

The logical operators are the only expression-level
connectives used in Prolog. These operators are used to
link facts together in the body of a rule, and to link the
body to the head of a rule. The body of the rule is
evaluated in execution by determining the truth of the
constituent expressions, then evaluating the truth of the
whole body using the logical operator rules on the
individual truth values returned. The Prolog operators
are: IFF :-
AND ,
OR ;
NOT not
Note:
o the ‘iff’ is used exclusively in the linking head to body.
o good practice to avoid ‘or’, if necessary write two or more
seperate clauses with same name and arity.
o different interpreters use different operators.
Logical Operators

Fancy Stuff
Prolog can also be used to improve the human-computer interaction as demonstrated
in this simple program:
go:- write(‘What is your name? ’),
read(Yourname),
write(‘Hello ’),
write(Yourname),
nl.
go:- write(‘Integers 2 Months’),
nl, write(‘enter month’),
read(Month),
write(‘The Month is ’),
month(Month), nl.
month(1):- write(‘January.’).
month(2):- write(‘February.’).
month(12):- write(‘December.’).
month( _ ):- write(‘…? Incorrect Input.’).

More Fancy Stuff
/* ARITHMETIC PROGRAM */
run:- write(‘Enter a number: ’), read(Num1),
write(‘Another number: ’), read(Num2),
write(‘What operation do you desire?’),
write(‘a. Add’),nl,
write(‘s. Subtract’),nl,
write(‘m. Multiply’),nl,
write(‘d. Divide’),nl,
write(‘e. Exit’),nl,
write(‘Enter a,s,m,d,e:’), read(Option),
choice(Option,Num1,Num2).
choice(a,N1,N2):- X is N1+N2, write(X),nl.
choice(s,N1,N2):- X is N1-N2, write(X),nl.
choice(m,N1,N2):- X is N1*N2, write(X),nl.
choice(d,N1,N2):- X is N1/N2, write(X),nl.
choice(e, _ , _ ).
choice( _ , _ , _ ):- write(‘Wrong Option’),nl.

o Think Prolog
o program interpretation
o process execution
o Rules & Goals
o evaluating rules
o satisfying goals
o Executing a Goal
o pattern matching
o backtracking
o Pattern Matching
o fact or Rule head
o Backtracking
o Examples
5. Evaluation

In order to be able to program in Prolog it is very
important to understand how Prolog
interpreters execute rules and goals. This
understanding allows the programmer to
make sure not only that they achieve the
result they want from a rule, but also that
they get only what they want, and no more.
Understanding the process of execution in
Prolog is vital for understanding how to
program correctly
Most importantly, a programmer must be able
to:
o mentally trace through the steps taken by an
interpreter,
o keep backtracking in mind,
o attempt to terminate the program gracefully
always - i.e. a positive outcome is achieved
with all kind of input.
Think Prolog

Rules and Goals
It is important to realise that rules and goals are
evaluated in exactly the same way:
A goal that consists of a rule name and argument is
an interactive request for evaluation.
The same request could be issued within a program
from a rule that is being executed.
Note:
• The declarative meaning of Prolog programs is
concerned with what relations are defined in the
program. The procedural meaning determines
how the result is obtained.
• A Prolog programmer can concentrate on the
declarative way of thinking and may leave most
of the procedural details to the Prolog interpreter.

Questions or queries force the execution of
Prolog programs. Prolog tries to satisfy a
goals in a question from left to right.
It does this by matching it with the head of
a clause and further by trying to satisfy
goals in the body of that clause. In order
to find a matching clause, Prolog
searches a program in top-down
manner.
If a goal can not be satisfied, Prolog
automatically backtracks to the last goal
that was successfully matched and tries
to match it with the head of some other
clause.
Executing a Goal

When searching for a clause, Prolog continues
searching from the clause with which the goal
was previously matched. When backtracking,
variables are uninstantiated, i.e. loose the
values they acquired in the last match.
Prolog assumes that everything is stated in the
program or can be derived from the program.
This property is referred to as the ‘closed
world assumption’.
Negation in Prolog succeeds if the negated goal
fails. This is referred to as negation as failure.
Negation in Prolog can not instantiate any
variable in the negated goal.
Executing a Goal

/* student(student no. , name, dob, sex) */
student(s01,liam_gallagher,01/05/76,m).
student(s02,brandy,15/08/79,f).
student(s03,mariah_carey,28/11/78,f).
student(s04,mark_morison,06/05/77,m).
student(s05,celine_dion,01/04/76,f).
student(s06,marco_masini,18/04/74,m).
student(s07,bjork,17/01/77,f).
student(s08,cher,30/20/48,f).
student(s09,mike_tyson,09/02/74,m).
student(s10,damon_hill,05/12/75,m).
Example - program7.pl
/* crs(crs no. , title, hours, price) */
course(c01,prolog,70,200).
course(c02,java,100,400).
course(c03,cobol,120,250).
course(c04,pascal,60,200).
course(c05,c,90,250).
course(c06,html,20,100).
course(c07,logic,50,150).
course(c08,graphics,65,180).
/* option(crs no. , student no. , marks) */
option(c03,s02,45).
option(c02,s04,35).
option(c05,s03,65).
option(c01,s07,55).
option(c02,s05,50).
option(c01,s09,65).
option(c07,s10,55).
option(c03,s04,40).
option(c08,s07,45).
option(c04,s05,55).
option(c05,s02,65).
option(c06,s03,60).
option(c07,s05,80).
option(c08,s06,65).
option(c04,s04,85).
option(c04,s01,75).

student_options(Student_Name,Option_Name):-
student(Sno,Student_Name,_,_),
option(Cno,Sno,_),
course(Cno,Option_Name,_,_).
students_in_course(Course):- course(Cno,Course,_,_),
option(Cno,Sno,_),
student(Sno,Name,_,_),
write(Name),nl,
fail.
students_in_course(_).
student_marks(Student):- write('Marks for student '),
write(Student),nl,
student(Sno,Student,_,_),
option(Cno,Sno,Mark),
course(Cno,Cname,_,_),
write(Cname),
write(' --> '),
write(Mark),nl,
fail.
student_marks(_).

mmont@zeus>prolog
Welcome to SWI-Prolog (Version 3.1.2)
Copyright (c) 1993-1998 University of Amsterdam. All rights reserved.
For help, use ?- help(Topic). or ?- apropos(Word).
?- [program7].
program7 compiled, 0.01 sec, 5,860 bytes.
Yes
?- student_options(Who,Which).
Who = liam_gallagher
Which = pascal ;
Who = brandy
Which = cobol ;
Yes
?- student_options(celine_dion,CC).
CC = java ;
CC = pascal ;
CC = logic ;
No
?-

?- student_options(Who,prolog).
Who = bjork ;
Who = mike_tyson ;
No
?-
?- students_in_course(prolog).
bjork
mike_tyson
Yes
?- student_marks(mark_morison).
Marks for student mark_morison
java --> 35
cobol --> 40
pascal --> 85
Yes
?-

o Complex Goals
o Graceful termination
o debugging
o tracing
o stepping
o Examples employing several features
like:
o multiple pattern matching
o nested backtracking
o cut and not
o Tutorial
o handout
6.Backtracking

Complex Goals
In the same way that a rule can consist of a number of
clauses to be evaluated, so can a goal. This is less often
used in practice, but is still possible.
For example, suppose we want to know which parents have
at least two children in program3. To do this we can
enter a complex goal:
?- parent_of(Child1,SomeParent),
?- parent_of(Child2,SomeParent),
?- Child1 == Child2.
This goal ensures we get the data we want by using the same
variable for the parent’s name, different variables for the
children’s names, and a check that the two child
variables are not bound to the same value.
A rule with same goals yields same results.

Complex Goals
If we end the first clause in the goal with a comma, the
interpreter realises that we wish to AND a second clause
on to the goal, and so provides a second line for input.
The same is true for the second line, the interpreter does
not try to evaluate the goal until it reads a full stop, at the
end of the third clause in our case.
When this goal is executed, the interpreter has to repeatedly
search the entire list of parent_of clauses. It starts by
binding values to Child1 and SomeParent, then goes on
to try and satisfy the second parent_of. To do this it
starts again at the top of the clause list. This means that
Child2 binds to the same value as Child1. However,
returning a result is prevented here by the test Child1
== Child2.

Complex Goals
The interpreter than backtracks, freeing the most
recent binding (Child2) and searching for
alternate solutions until it succeeds.
A goal that is used frequently is expressed in the
form of a rule and its’ head used as a goal or
query obtaining the same outcome every time.
So, the previous goal can easily be re-written as :
two_child_parent(Who) :-
parent_of(Child1,Who),
parent_of(Child2,Who),
Child1 == Child2.

Graceful Termination
As in any other programming language it is desirable that
execution of a program does not terminate with some
kind of error. So, its of utmost importance to test all the
rules that have been written to perform as intended - the
interpreter could have other ideas.
Debugging a prolog program can be efficiently performed
by following every single step the interpreter is making.
This could be done by switching the tracing facility on
before execution initialises.
Every rule invoked will be displayed and every variable
bound to some value will be displayed too. If some rule
fails then an appropriate message will be issued and
backtracking will take place. Tracing can be switched
off at any time.

Graceful Termination
Some Prolog interpreters (e.g. LPA Prolog) also
allows the stepping through the execution with
watch windows to help the user through the
debugging session.
Now that the program is bug free we would like that
it terminates gracefully exectly when we have
finished with it, and not when the execution of
some rule results negatively. The programmer
must take into consideration all possible outcomes
and ensures beforehand that every situation has
been taken care of - positive or negative.
To do this, multiple versions of the same rule with
the same head but different terminating body have
to be written.
e.g. program8.pl

go:- consult(program7),
continue.
continue:- write('---------------------'),nl,
write('---------------------'),nl,
write('-- --'),nl,
write('-- --'),nl,
write('-- The --'),nl,
write('-- Program --'),nl,
write('-- --'),nl,
write('-- --'),nl,
write('---------------------'),nl,
write('---------------------'),nl,nl,
write('1. Student marks'),nl,
write('2. Students in course'),nl,
write('3. To EXIT'),nl,nl,
write('Select an option'),
read(Option),
option(Option).

option(1):- write('Enter Student name: '),
read(Student),
student(_,Student,_,_),
student_marks(Student),
continue.
option(1):- write('NO OUTPUT'),
continue.
option(2):- write('Enter Course name: '),
read(Course),
course(_,Course,_,_),
students_in_course(Course),
continue.
option(2):- write('NO OUTPUT'),
continue.
option(3):-
write('Program terminating - thanks you.'),nl.
option(_):- write('*****************'),nl,
write('* WRONG INPUT *'),nl,
write('*****************'),nl,
continue.

| ?- go.
# 0.11 seconds to consult file PROGRAM7.PL [C:PRO386W]
---------------
---------------
-- --
-- --
-- The --
--Program --
-- --
-- --
---------------
---------------
1. Student marks
2. Students in course
3. To EXIT
Select an option|: 5.
*****************
* WRONG INPUT *
*****************

Select an option: 1.
Enter Student name: mark_morison.
Marks for student mark_morison
java --> 35
cobol --> 40
pascal --> 85
Enter Course name: prolog.
bjork
mike_tyson
*****************
* WRONG INPUT *
*****************
Program terminating - thank you.
yes
| ?-

o Numeric computing
o Prolog characteristic
o True or False
o Operators
o arithmetic operators
o bound vaiables
o integer or float
o assignment
o comparison operators
o Examples
7. Numbers+Maths Operators

The great strength of Prolog is also its weakness in the case
of arithmetic.
Expressions ALWAYS evaluate to True or False, any other
action they perform, for instance producing an output, is
simply a side effect. Thus consider the expression:
in Pascal: X:=X+1;
or C: X=X+1;
This increments the value of the X variable by one by
assigning the new value to the variable. The problem
with some versions of Prolog is that there is no
assignment operator, in Prolog variables get a value
primarily by binding, not by assignment. Thus there is
no equivalent of “:=”, but we’re able to use the reserved
word “is” as already seen in program5.pl
Numeric Computing

Numeric Computing - “is”
When programming in Prolog, we are mainly concerned
with logical reasoning and symbolic computations. Still,
we sometimes need to do numerical computing. Prolog
enables us to evaluate arithmetic expressions by using
built-in procedure “is” which is an infix operator. For
example we can ask Prolog to compute the sum of two
numbers (program5.pl), such as:
? - X is 2+3.
and the answer will be
X=5
yes
The following dialogue with the Prolog interpreter illustrates
some Prolog features when doing arithmetic
computations:

?- X is 17div3.
X=5
yes
?- X is 2+3*(17div3). /*Integer division*/
X=13.4
yes
?- X is 17mod3. /*Remainder*/
X=2
yes
?- 5 is 2+3.
yes
?- 4 is 2+3.
no
?- 2+3 is 2+3.
no

The operator “is” evaluates the expression at the right-hand
side. If the left-hand side of the “is” operator is a
variable then its value is set to the computer value. If the
left-hand side is a number or a variable that already has a
value, the result is compared with this number. The
answer is ‘yes’ if both numbers are identical and ‘no’
otherwise.
e.g. program9.pl
rect(Length,Width) :-
Area is Length*Width,
Perimeter is (Length+Width)*2,
write(‘Area of rectangle is ’),
write(Area),nl,
write(‘Perimeter is ’),
write(Perimeter),nl.

Arithmetic Operators
Arithmetic expressions are Prolog structures that use
arithmetic operators. They are written in a special
notation which improves readability. For example, the
expression 2 + 3 * ( 17 div 3 ) can be used in place of
the expression in the standard Prolog notation:
+ ( 2 , * ( 3 , div ( 17 , 3 ) ) )
The arithmetic expressions in the above example make use
of functors like ‘+’, ‘-’, ‘*’, ‘/’, ‘mod’, ‘div’, each with
two arguments. These functors are built-in operators and
are usually written in the infix notation (i.e. between two
arguments) in order to improve readability.
The usual order of precedence that defines the strength of
the operator binding is the same as for other
programming languages.

Comparison Operators
There are also several built-in procedures for comparing
values of arithmetic expressions illustrated by the
following dialogue:
?- 17-1 > 5*3.
yes
?- 17+1 > 6*3.
no
?- 5>=5.
yes
?- 6+7 =:= 1+3*4.
yes
?- 7 =:= 5+3.
no
An overview of the built-in operators follows

Built-in Operators
Besides the operator “is” there are also several built-in
operators for comparing numbers.
X > Y the value of X is greater than Y
X < Y the value of X is less than Y
X >= Y X is greater than or equal to Y
X =< Y X is less than or equal to Y
X =:= YX andY are equal
X == YX is not equal to Y
X + Y sum of X and Y
X - Y difference of X and Y
X * Y product of X and Y
X / Y quotient of X and Y (real)
X div Y quotient of X and Y (integer)
X mod Y remainder of integer division

These operators can be used to define Euclid’s algorithm for
finding the greatest common divisor of two numbers.
/* gcd(positive no , positive no , answer) */
gcd(X,Y,D) :- X=:=Y,
D is X.
gcd(X,Y,D) :- X<Y,
Y1 is Y-X,
gcd(X,Y1,D).
gcd(X,Y,D) :- X>Y,
X1 is X-Y,
gcd(X1,Y,D).

go:- consult(program7),
continue.
continue:- assert(totals(-1,-1)),
write('1. Student total'),nl,
write('2. Student average'),nl,
write('3. Student bill'),nl,
write('4. To EXIT'),nl,nl,
write('Select an option'),
read(Option),
Option<4,
introductions(Stud),
option(Option,Stud).
continue:- nl,nl,
write('Program terminating - thank you.'),
nl,nl.
introductions(Student):- write('Enter Student name: '),
read(Student),
student(_,Student,_,_),
retract(totals(_,_)),
assert(totals(0,0)).
introductions(_):- nl,nl,
write('*** INCORRECT INPUT ***'),
nl,nl,continue.

find_total(M):- retract(totals(Marks,Num)),
Total is M+Marks,
No is Num+1,
assert(totals(Total,No)),
!,
fail.
option(1,Stud):- student(Sno,Stud,_,_),
option(_,Sno,Mark),
find_total(Mark).
option(1,Stud):- retract(totals(T,_)),
T >= 0,
write('Total Mark for student '),
write(Stud),
write(' is '),
write(T),nl,
continue.

option(_,Sno,Mark),
find_total(Mark).
option(2,Stud):- retract(totals(T,N)),
T >= 0,
Aver is T/N,
write('Average Mark for student '),
write(Stud),
write(' is '),
write(Aver),nl,
continue.
option(Cno,Sno,Mark),
course(Cno,_,_,Cost),
find_total(Cost).
option(3,Stud):- retract(totals(T,N)),
T >= 0,
write('Total Cost for student '),
write(Stud),
write(' attending '),
write(N),
write(' course is '),
write(T),nl,
continue.
option(_,_):- nl,nl,write('*** NO OUTPUT ***'),nl,nl,
continue.

o Intoduction
o data types / data structures
o definition
o properties
o List Structure
o empty list
o single element manipulation
o bar notation [Head|Rest]
o List manipulation
o Head and Tail
o Recursion
o Pattern Matching
o Examples
8. Basic Lists

So far in our discussion of Prolog we have hardly mentioned data
types or data structures at all. The reason for this omission is that
data types are not extensively used in Prolog, the majority of data is
either string (symbol) or number and is represented in simple facts.
Prolog has no equivalent of the arrays, records, queues or other data
storage devices of procedural languages. Prolog makes use of one
proper data structure, the LIST.
What is a List? A list is:
• A data structure for representing sequences of elements.
• A sequence of of zero or more terms.
• A single term itself.
e.g. a list of vowels [a,e,i,o,u]
e.g. a list of fruit [pear,apple,orange,kiwi]
Lists - Introduction

The principal data structure used in Prolog is the list. Lists are not a
data structure provided as standard with many languages, but those
languages that are designed to work primarily with symbols use lists
more than any other data structure. This is because lists are highly
flexible; the following are some of their more useful properties:
 Lists are composed of elements that can be of any type; constants,
variables, structures or other lists. Any one list can contain different
types of element, although for most applications a list will usually
contain elements of a constant type.
 The elements of a list are held in an ordered sequence (unlike a
set). This ordering can be used to reflect some underlying organisation
in the data being stored. For example, lists are used to store trees,
which are a hierarchical data storage structure.
Lists - Properties

 A list can be of any size (it does not have to be declared to be a
certain fixed size) and can grow or shrink dynamically as required by
a program during execution.
 Lists are especially suited to recursive access methods; one part of
a list is operated on, with the remainder being passed to a recursive call
where one part of a list is operated on ... etc.
Effective programming in Prolog relies heavily on the use of
lists, and very often specifically on the recursive processing
of lists. Familiarity with these structures and techniques is
thus vital for you to succeed in better understanding Prolog.
Further examples of lists:
» [] empty list
» [X] list with one element - variable X
» [1,2,3] list with three elements-values 1,2,3
» [a,[b,c]] two elements-’a’ and a list[b,c].
Lists - Examples

Lists - Components
A Prolog list can be created very easily. A list is simply a comma
seperated sequence of values enclosed in square brackets.
The empty list, [] is a particularly useful object because of its unique
characteristics that can be used in a number of roles. Any list which is
not empty has one or more elements - basically all the remaining lists.
So, a list is either empty, or it is composite, having a head and a tail.
The HEAD of a non-empty list is its first element, while the rest of the
elements (a sub list) is the TAIL -the whole list minus the first.
[1,2,3] Head is ‘1’ Tail is [2,3]
[a,b] Head is ‘a’ Tail is [b]
[one] Head is ‘one’Tail is [ ]
[[1,2],3] Head is [1,2] Tail is [3]
[a,[b,c],d,e] Head is ‘a’ Tail is [[b,c],d,e]

To access the components of lists, we employ a special
notation which makes the head and the tail explicit. Apart
from the square brackets Prolog provides one operator
specifically for use in list handling, but it is a very useful
one. The vertical bar, “|”, is used to divide a list into the two
parts, head & tail.
This may not seem to be very useful at first, but this operator
allows us to sequentially split each of the elements off a list,
one by one in order from the front of the list, to perform
some operation with them. This process of sequential
extraction is almost always performed recursively; we split
the head off the list and pass the tail in a recursive call where
we split the head off the list ... etc.
All along, pattern matching is still occuring.
Lists - Bar Notation

days_of_wk([sun,mon,tue,wed,thur,fri,sat]).
sentence([[prolog,is,elegant],[c,is,tough]]).
pets( usual([cat,dog,rabbit,gerbil,budgie]),
unusual([snake,buzzard,panther])).
Which is the third day of the week?
days_of_wk([ _ , _ , Third_day, _ , _ , _ , _ ]).
Third_day = tue
OR
days_of_wk([ _ | [ _ | [Third_day| _ ]]]).
Third_day = tue
List the languages mentioned in both sentences.
sentence([[Lang1, _ , _ ] , [Lang2, _ , _ ]]).
Lang1 = prolog ,
Lang2 = c
OR
sentence([[Lang1| _ ] , [Lang2| _ ]]).
List all the unusual pets after each other.
pets(_, unusual(L)).
L = [snake,buzzard,panther]
First usual pet?
pets(usual([X|_]),_).
X = cat
Lists - program12.pl

Now we have seen how to pattern match particular elements in a list,
we can move on to techniques for iteratively manipulating lists. The
majority of lists have elements of the same type that often need to be
assessed in an iterative, element-by-element way. Any such iterative
process will have to be programmed recursively in Prolog as this is the
only appropriate mechanism available.
To start with a simple example, the print_list rule defined in
program13.pl
print_list(List):- consult(prog12),
List(X),
printout(X).
printout([ ]).
printout([H|T]):- write(H),nl,
printout(T).
Lists - Recursion

The main clause uses two variables (that are often named H and T by
convention) which bind to the head and tail of the input list. The head
is then printed out using the write predicate (standard built-in, just like
consult) and the rule is then called recursively with just the tail as
argument. At each stage the stopping clause is tested, but only
succeeds when the tail is the empty list (when all the elements have
been processed). At this point the recursion is halted by the stopping
rule.
Other examples:
print_list([hello, how, are, you]).
hello
how
are
you
Lists - Stopping Clause

find_total(0,[]).
find_total(Total,[H|T]):- find_total(SubT,T),
Total is H + SubT.
find_average(0,[]).
find_average(Average,List):-
find_total(Total,List),
find_number(Number,List),
Average is Total/Number.
find_number(0,[]).
find_number(N,[ _ | T ]):-
find_number(Nn,T),
N is Nn + 1.
find_max(X,[X]).
find_max(H,[H|T]):- find_max(Max,T),
H > Max.
find_max(Max,[H|T]):- find_max(Max,T),
H =< Max.

o Complex List manipulation
o Pattern Matching
o Recursive List handling
o Provided operations
o append
o delete
o last
o member
o sum_list
o Examples
o Tutorial
o handout
9. Advanced Lists

Lists are used very widely in Prolog, and there are some
specific list relations that are worth getting to know and
understand very well. If nothing else, defining them is
something that often comes up in Prolog exams!? More
importantly though, understanding them will make it easier
to write new list relations, because the recursive way the
standard ones work is also used very widely. Pattern
matching is still occurring all throughout the list handling
and recursion.
Because we can only get access at first to the head
of the list - the first element, we almost always write
recursive relations to process the remaining elements in the
list held in the tail. A stooping clause needs always to be
written in order to terminate the recursion, otherwise you get
into a continuous loop.
Advanced Lists - Introduction

Considering checking for membership of an element within a list. That is, we
want to define a rule called is_a_member_of(X,L) that succeeds if the element
‘X’ is present within the list ‘L’. The way to code such recursive rules is to
state out the basic facts in English, as simple as possible.
1. If the element X is actually the head element of the list, then we’re
sorted.
So: is_a_member_of(X,[X| _ ]). succeeds
2. If X is not the head, then X might be present within the tail. We
accomplish this by chopping the list head off and call the same rule using the
tail only.
So: is_a_member_of(X,[_|Tail]):-
is_a_member_of(X,Tail).
3. Finally, graceful termination. No element is a member of an empty
set. (could do without it)
So: is_a_member_of(_,[]):-
write('Not a member'),nl.
Advanced Lists - Membership program15.pl

Another widely used procedure is to concatenate or append one or
more elements (a list basically), to another list to form a longer list.
e.g. | ? - append_to([a,b,c],[d,e,f],Whole).
Whole = [a,b,c,d,e,f].
Reasoning this out:
1. If you append an empty list to anything, you still have the
same ‘anything’.
So: append_to([ ],X,X). simple!!???!!
2. If the list being appended is not empty, then we’ll chop its
head off and append it to the second list, while we call the same
function again to append the remaining part of the first list (the tail) the
newly formed list.
So: append_to([A|B],Second,[A|C]):-
append_to(B,Second,C).
Advanced Lists - Concatenation program15.pl

Deleting a particular element from a list seems simple, but what if
more than one occurence of the same element are present within the
list. Two seperate rules, single_del and multiple_del will perform
these operations.
single_del(X,[X|Final],Final).
single_del(X,[_|Tail],Result):- single_del(X,Tail,Result).
e.g. | ? - single_del(2,[1,2,3,2,5],R).
R = [1,3,2,5]
multiple_del(_,[],[]).
multiple_del(X,[X|Tail],Final):-
multiple_del(X,Tail,Final).
multiple_del(X,[H|Tail],[H|Result]):-
multiple_del(X,Tail,Result).
e.g. | ? - multiple_del(2,[1,2,3,2,5],R).
R = [1,3,5]
Advanced Lists - Deleting program15.pl

It is sometimes necessary to reverse the elements within in a list. This kind of
procedure has to be written recursively because we do not know beforehand
how many elements are within the list.
reverse_it([ ],[ ]).
reverse_it([A|B],C):- reverse_it(B,D),
append_to(D,[A],C).
e.g.
| ? - reverse_it([1,2,3,4,5],Rev).
Rev = [5,4,3,,2,1]
| ?- reverse_it([1,[a,b,c],2,3],R).
R = [3,2,[a,b,c],1]
| ?- reverse_it([1],R).
R = [1]
| ?- reverse_it([ ],R).
R = [ ]
Advanced Lists - Reversing program15.pl

To determine the biggest or smallest valued item within a list we will have to
go through the list till the last item, assume that it is the value we are looking
for and backtrack back to the first item checking the value of the items each
time.
biggest([X],X).
biggest([H|T],H):- biggest(T,Tbig),
H >= Tbig.
biggest([H|T],Tbig):- biggest(T,Tbig),
H < Tbig.
e.g. | ?- biggest([2,4,1,3,5,2],Big).
Big = 5
| ?- biggest([2],Big).
Big = 2
| ?- biggest([],Big).
no
Advanced Lists - MinMax program15.pl

The final example of provided procedures is the rule
sublist_of(SubList,List) which succeeds if the ‘SubList’ is contained
within the ‘List’. That is, all the elements within the SubList appear
consecutively and without interruption in List, not necessarily at the
begining or at the end.
sublist_of(A,B):- append_to(_,A,C),
append_to(C,_,B).
e.g. | ?- sublist_of([1,2,3],[1,2,4,1,2,3,5]).
yes
| ?- sublist_of([],[1,2,3]).
yes
| ?- sublist_of([1],[1]).
yes
Not a particular efficient rule as the “_” being appended can overflow
the memory heap.
Advanced Lists - Sublist program15.pl

All examples in lecture 9 are in program15.pl
Write a rule to print out the nth. element within a given list.
/*n_th_element(item_number,list,the_item */
n_th_element(1,[H| _ ],H).
n_th_element(N,[ _ |Tail],Item):-
NewN is N -1,
n_th_element(NewN,Tail,Item).
| ?- n_th_element(3,[a,b,c,d,e],H).
H = c
| ?- n_th_element(4,[a,b,c,d,e],d).
yes
no
no
| ?- n_th_element(3,[],H).
no
Advanced Lists - Final list example

After going through a number of list examples and different list
manipulations it can be noticed that repeatedly we were employing:
1. Pattern matching
2. Backtracking
3. Recursion
We will be covering recursion further without the use of lists in the next
lecture.
Lists are very common data structures in non-numeric programming.
They are extensively used in Prolog especially to represent parse trees,
grammars, city maps, computer programs, and mathematical entities
such as graphs, formulae, & functions.
Finally, there is another programming language called LISP
(LISt Programming) whose only data structures available are the
constant and the list.
Advanced Lists - Conclusion

o Definition
o Mechanism of recursion
o starting recursion
o stopping condition
o more than one clause
o simple example
o Recursive Mathematical Operations
o factorial of an integer
o fibbonacci of an integer
o greatest common divisor of an integer
o Examples
10. Recursion

The Oxford English Dictionary defines the word
“recursion” in the following way:
RECURSION.[Now rare or obs.1626].
A backward movement,return.
This definition is cryptic and perhaps outdated.
Recursion is now a very popular and powerful
technique in the world of non-numerical programming.
It is used in two ways. It can be used to describe
structures that have other structures as components. It
can also be used to describe programs that need to
satisfy a copy of themselves before they themselves
can succeed. Sometimes, beginners view recursion
with some suspicion, because, how is it possible for
some relationship to be defined in terms of itself? In
Prolog, recursion is the normal way of viewing data
structures and programs.
Recursion - Introduction

We have already encountered recursion in several examples
when dealing with lists (look at program15.pl). We have
also pointed out earlier that Prolog has no iterative control
structures like the FOR, WHILE, or DO loops of other
languages. This is initially surprising, but is less so when
you realise that Prolog has very few built-in predicates at all.
Prolog allows iterative action through the construction of
recursive rules (rules which call themselves), and no built-
in predicate is required for this.
Any recursive operation in Prolog must be defined
as part of a particular rule. A recursive rule is one that calls
itself at some point in the body of the rule. When writing
recursive operations, a programmer has to abide with
specific requirements.
Recursion in Prolog

In general there are two functions which need to be
performed in any recursive Prolog rule.
The first is to make recursion start, and the second is to
make it stop once started. Starting the recursive process
involves a rule clause that calls its own head, stopping it
requires a rule clause that defines a condition to prevent
further backtracking in the rule.
These two required mechanisms mean that a
recursive rule must always have at least two clauses, one to
perform each function. We have seen this two-clause
structure when performing list manipulation in
program15.pl. A recursive rule can have more than two
clauses if this is required, but two is the absolute minimum.
Recursion - Properties

Probably the most common example of a recursive operation
in computer science is the calculation of the factorial of an
integer. This is often used because the factorial operation is
relatively simple and is not included as a built-in function in
most languages. The factorial is the product of an integer
and every integer less than it. Thus the factorial of 4 is 4! =
4 x 3 x 2 x 1 = 24.
To implement this operation we require two functions. The
stopping condition is also called the base step and can be
defined in terms of the simplest factorial, i.e. 1! = 1
So, factorial(1,1). /* factorial(num,ans) */
Now, the recursive call:
factorial(N,Ans):- F is N - 1,
factorial(F,FactF),
program16.pl Ans is N * FactF.
Recursion - Simple example

To proceed any further we need to understand the
mechanism of Prolog recursion. At each recursive
call the variables in the current iteration are saved
(on stack) as the call is made. Thus each stage in the
process of the factorial example has its own F and
FactF variables saved. When we get to the stopping
clause these variables are then used one-by-one in
reverse order to work out the FactF value to be
returned. The last line of the recursive clause
performs this calculation on the stored variables.
In effect this recursive rule counts down through the
values below the input N, saves each in a different F
variable, then once halted (N = 1), it “unwinds” the
process and multiplies each FactF by its particular F
value to return the “Ans” value.
Recursion - Mechanism

This unwinding process is not very evident from the
code, but it is implicit in the last line. If any clause
exists after the recursive call then the clause variables
are saved for use in the “unwinding” process when
they may be used.
If the recursive call in the recursive clause is not the
last line of that clause then any lines following after
the recursive call are not executed whilst the
recursive calls are being made. The recursion must
proceed to its end (as defined by the stopping clause)
before these lines can be executed. Since these later
clauses may well use the variables from the previous
clauses these variables must be saved. In effect each
set of variables from each loop in the recursive
process must be saved for later use.

This appears odd at first because the variables in
each recursive loop will have the same names.
This in out factorial example we will end up saving
the F and FactF variables for every iteration of the
recursion. This odd state of affairs, with duplicate
variables saved at every iteration, is resolved by the
Prolog interpreter creating a series of what are
called stack frames. A frame in this sense is a
copy of all the variables local to the rule, and at
each recursive step the current set of variables are
pushed on to the stack. When the recursion is
complete and needs to “unwind” the stack frames
are popped off the stack one by one to be dealt with
by the remaining rule clauses in turn.

Another standard example of a recursive operation used in
computer science is the calculation of the fibbonacci series.
Each number in this series is the sum of the fibbonacci value
of the two previous numbers. So, fib(N) = fib(N-1) + fib(N-
2).
Unlike the factorial example the fibbonacci series is actually
defined in maths recursively, and is only given an actual
value on the basis of its stopping conditions where the value
of the initial two values, F(1) and F(2) are both defined to be
1. All other fibbonacci values are built up on the basis of
these two values.
The full fibbonacci series is as follows:
1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377,...
The calculation of this series is ideally suited to a recursive
technique due to the definition of the operation in terms of
itself.
Recursion - fibbonacci program15.pl

/* fib(term number, term value) */
/* e.g. 6th. term is 8 is equal to fib(6,8) */
fib(1,1).
fib(2,1).
fib(N, Result) :- N1 is N - 1,
N2 is N - 2,
fib(N1, Result1),
fib(N2, Result2),
Result is Result1 + Result2.
This rule is built on three seperate clauses because we require two stopping
clauses since the fibbonacci of both the 1st. and 2nd. terms are defined to be 1.
The most important part of the rule is the last line of the third clause which is
evaluated after that the previous two recursive calls have been satisfied -
“unwinding”
Recursion - fibbonacci program15.pl

Recursion - gcd program10.pl
The greatest common dvisor using Euclid’s algorithm was
introduced in Lecture 7 when mathematical operators
were introduced. It is worth having a look at this
program again to appreciate the recursive calls done to
work out the GCD of two numbers.
/* gcd(positive no , positive no , answer) */
gcd(X,Y,D) :- X=:=Y,
D is X.
gcd(X,Y,D) :- X<Y,
Y1 is Y-X,
gcd(X,Y1,D).
gcd(X,Y,D) :- X>Y,
X1 is X-Y,
gcd(X1,Y,D).

Recursion is a very important method in Prolog because of the lack of
iterative capabilities inherent in Prolog itself.
Writing recursive rules is not an easy task and is frequently at the
center of a number of questions in an exam.
To effectively and efficiently write recursive clauses it is best to:
1. Understand the task to be done exactly.
2. Figure out what the stopping condition is and how best to represent
it.
3. Write the starting clause of the recursion.
Pay attention to:
• place the stopping condition before the other clauses in order to check
it out every time a recursive call is performed
• place the recursive call in the correct position within the clause itself.
Recursion - Conclusion

Write recursive rules to manipulate the following lists:
Exclude the items of one list from another list.
e.g. exclude([1,2,3], [2,3,4], X) binds X with [4] while
exclude([a,b,c],[1,2,3],Y) binds Y with [1,2,3]
Identify and Remove an item from a list.
e.g. idRem(3,[a,b,c,d,e], FinalList, Item) would remove the 3rd item from
the list to bind FinalList with [a,b,d,e] and Item with c
Differentiate between two list.
e.g. diff([a,b,c,d,e], [a,b,d,e],DiffList) would bind DiffList with [c] while
diff([1,2,3],[a,b,c],DL) would bind DL with [1,2,3]
Subdivide a list into two sublist from a specified position.
e.g. subD([a,b,c,d,e],2,FL,SL) binds FL to [a,b] and SL to [c,d,e] while
subD([p,q,r],3,A,B) binds A to [p,q,r] and B to []
Drown a specified element from a list to the end of the list.
e.g. drown(4,[a,b,c,d,e],Ans) binds Ans to [a,b,c,e,d] while
drown(2,[p,q,r],FinalL) binds FinalL to [p,r,q]
11. Advanced Recursion with Lists

Sets can be represented in Prolog using Lists. Write the following sets handling rules:
member_of(Element,Set) which returns TRUE if Element is an element within the list Set.
E.g. member_of(3, [1,2,3,4]) returns TRUE.
intersection(SetA, SetB, Int) which binds Int to the list containing those elements that are in list SetA as well as in list SetB.
E.g. intersection([1,2,3], [2,3,4], Ans) binds Ans to [2,3].
union(SetA, SetB, Uni) which binds Uni to the list containing those elements that are either in sets A or B or in both.
E.g. union([1,2,3], [2,3,4], Ans) binds Ans to [1,2,3,4].
xor(SetA, SetB, XOR) which binds XOR to the list containing those elements that are in list SetA, or in list SetB, but not in both.
E.g. xor([1,2,3], [2,3,4], Ans) binds Ans to [1, 4].
complement(SetA, SetB, Comp) which binds Comp to the list containing those elements that are not in list SetA but in SetB only.
E.g. complement([1,2,3], [2,3,4], Ans) binds Ans to [4].
11. More Advanced Recursion with Lists

A Stack is data structure capable of storing data in a particular way. Items are pushed on top of each other in a sequential way and
retrieved by accessing the item at the top. In this way the First item In is the Last one Out (FILO) and the Last one In will be the First
one Out (LIFO). You are asked to write three clauses to manage and display the data within a stack, which in this case will be
represented in form of a list. The required predicates are:
push(Item, OldStack, NewStack) which binds NewStack to OldStack with the Item pushed on top
e.g. push(a, [b,c], NewStack) binds NewStack to [a,b,c].
pull(Item, OldStack, NewStack) which binds NewStack to OldStack with the head removed from the top and bound to Item
e.g. pull(Item, [3,5,6,2,7], Fresh) binds Item to 3 and Fresh to [5,6,2,7].
display_Stack(Stack) which displays the contents of the Stack starting from the top.
e.g. display_stack([b,w,a,r,f]) displays bwarf
empty_Stack(Stack) which return TRUE if the Stack is empty, otherwise return FALSE.
e.g. empth_stack([w,a,r]) return FALSE
11. Another Advanced Recursion with Lists

What is a CFG?
o A way to deal with grammars in a formal
way;
o It’s what computational linguists do;
o A finite collection of rules which tell
us that a certain sentences is
grammatically correct or valid;
o Important to distinguish between a
natural language and formal
language.
o Formal language is simply a set of
strings that have no real meaning.
12. CFG - Context Free Grammar

Consider this small English fragment that
contains 9 context free rules…
s -> np vp
np -> det n
vp -> v np
vp -> v
det -> a
det -> the
n -> woman
n -> man
v -> shoots
12. CFG – Simple example
Rules
‘defined by’
‘consists of’
‘built by’
Non-terminal symbols
Terminal symbols
Consider the string of words
“a woman shoots a man”
This is it’s Parse Tree.

Turn the rules into Prolog…
s(S):- np(X), vp(Y), app(X,Y,S).
np(NP):- det(X), n(Y), app(X,Y,NP).
vp(VP):- v(X), np(Y), app(X,Y,VP).
vp(VP):- v(VP).
det([a]).
det([the]).
n([woman]).
n([man]).
v([shoots]).
------------------------------------------------------------
?-s([a, woman, shoots, a, man]).
?-s(AllPossibleSentences).
12. CFG – Using Append

o The key idea underlying
difference lists is to
represent the information
about grammatical
categories not as a single
list, but as the difference
between two lists.
o E.g.
[a,woman,shoots,a,man] [].
12. CFG – Using Difference Lists
What about ...
?- s([s(X,Z):- np(X,Y),
vp(Y,Z).
np(X,Z):- det(X,Y), n(Y,Z).
vp(X,Z):- v(X,Y), np(Y,Z).
vp(X,Z):- v(X,Z).
det([the|W],W).
det([a|W],W).
n([woman|W],W).
n([man|W],W).
v([shoots|W],W).a,woman,shoo
ts,a,man],[]).
?- s(All, []).

Consider using ‘and’, ‘or’, and ‘but’ as part
of our language, then we can have
composite sentences.
s -> s conj s
conj -> and
conj -> or
conj -> but
And in Prolog …
s(A,B):- s(A, C),
s(A,B):- np(A, C),
conj(C, D),
vp(C, B).
s(D, B).
12. CFG – Adding Recursion

s --> simple_s.
s --> simple_s, conj, s.
simple_s --> np,vp.
np --> det,n.
vp --> v,np.
vp --> v.
det --> [the].
det --> [a].
n --> [woman].
n --> [man].
v --> [shoots].
conj --> [and].
conj --> [or].
conj --> [but].
12. CFG – Avoiding Left Recursion
And in Prolog ...
s(A,B):- simple(A,B).
s(A,B):- simple(A,X), conj(X,Y),
s(Y,B).
simple(X,Z):- np(X,Y), vp(Y,Z).
np(X,Z):- det(X,Y), n(Y,Z).
vp(X,Z):- v(X,Y), np(Y,Z).
vp(X,Z):- v(X,Z).
det([the|W],W).
det([a|W],W).
n([woman|W],W).
n([man|W],W).
v([shoots|W],W).
conj([and|W],W).
conj([or|W],W).
conj([but|W],W).

o A DCG is a nice notation for writing
grammars that hides the underlying
difference list variables.
s -> np,vp.
np -> det,n.
vp -> v,np.
vp -> v.
det -> [the].
det -> [a].
n -> [woman].
n -> [man].
v -> [shoots].
12. DCG – Definite Clause Grammar

Consider anbn ... What is this language?
e.g.s. ab, aabb, aaabbb, aaaaaabbbbbb, ϵ .
Another e.g. Consider the formal language anb2n
12. DCG – for a simple formal lang.
CFG
s -> ϵ
s -> l s r
l -> a
r -> b
DCG
s -> [].
s -> l,s,r.
l -> [a].
r -> [b].
Prolog
s([], []).
s(A,B):-ss(A,B).
ss(A,B):- l(A,P),
r(P,B).
ss(A,B):- l(A,P),
s(P,Q),
r(Q,B).
l([a|X],X).
r([b|X],X).

Ics1019 ics5003

More Related Content

What's hot (20)

Similar to Ics1019 ics5003 (20)

Recently uploaded (20)

Ics1019 ics5003