Introduction to Prolog Programming - Universiteit van Amsterdam

80 Pages·2016·0.76 MB·English

by  Ulle Endriss (

Institute for Logic,
Language and Computation
Lecture Notes
An Introduction to Prolog Programming
Ulle Endriss
Universiteit van Amsterdam
(cid:13)c by Ulle Endriss, University of Amsterdam (Email: [email protected])
Version: 20 October 2021
Preface
These lecture notes introduce the declarative programming language Prolog. The em-
phasis is on learning how to program, rather than on the theory of logic programming.
Nevertheless, a short chapter on the logic foundations of Prolog is included as well.
All examples have been tested using SWI-Prolog (www.swi-prolog.org) and can be ex-
pected to work equally well with most other Prolog systems. These notes have originally
been developed for a course I taught at King’s College London in 1999 and 2000.
Amsterdam, August 2005 U.E.
The present version corrects a number of minor errors in the text, most of which
have been pointed out to me by students following a number of courses I have given at
the University of Amsterdam since 2005.
Amsterdam, September 2014 U.E.
For this latest version of the lecture notes, I have added 15 new exercises. This
includes somewhat more complex exercises, several of which can easily be turned into
small programming projects, on topics such as working with unary numbers, simple
databases, robot navigation, verifying Goldbach’s conjecture in number theory for
small instances, competing in the game show Countdown, text-based graph plotting,
computing prime factorisations of integers, translating logic formulas into various
normal forms, and analysing the voting power of countries in the European Union.
Amsterdam, August 2015 U.E.
iii

Contents
1 The Basics 1
1.1 Getting Started: An Example . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.2 Prolog Syntax . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.2.1 Terms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.2.2 Clauses, Programs and Queries . . . . . . . . . . . . . . . . . . . . 5
1.2.3 Some Built-in Predicates . . . . . . . . . . . . . . . . . . . . . . . 6
1.3 Answering Queries . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.3.1 Matching . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.3.2 Goal Execution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.4 A Matter of Style . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.5 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2 Working with Lists 15
2.1 Notation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.2 Head and Tail . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.3 Some Built-in Predicates for List Manipulation . . . . . . . . . . . . . . . 18
2.4 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
3 Working with Numbers 23
3.1 The is-Operator for Arithmetic Evaluation . . . . . . . . . . . . . . . . . 23
3.2 Predefined Arithmetic Functions and Relations . . . . . . . . . . . . . . . 24
3.3 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
4 Working with Operators 37
4.1 Precedence and Associativity . . . . . . . . . . . . . . . . . . . . . . . . . 37
4.2 Declaring Operators with op/3 . . . . . . . . . . . . . . . . . . . . . . . . 40
4.3 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
5 Backtracking, Cuts and Negation 47
5.1 Backtracking and Cuts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
5.1.1 Backtracking Revisited. . . . . . . . . . . . . . . . . . . . . . . . . 47
5.1.2 Problems with Backtracking . . . . . . . . . . . . . . . . . . . . . . 48
5.1.3 Introducing Cuts . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
v
vi Contents
5.1.4 Problems with Cuts . . . . . . . . . . . . . . . . . . . . . . . . . . 52
5.2 Negation as Failure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
5.2.1 The Closed World Assumption . . . . . . . . . . . . . . . . . . . . 53
5.2.2 The \+-Operator . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
5.3 Disjunction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
5.4 Example: Evaluating Logic Formulas . . . . . . . . . . . . . . . . . . . . . 56
5.5 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
6 Logic Foundations of Prolog 63
6.1 Translation of Prolog Clauses into Formulas . . . . . . . . . . . . . . . . . 63
6.2 Horn Formulas and Resolution . . . . . . . . . . . . . . . . . . . . . . . . 65
6.3 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
A Recursive Programming 69
A.1 Induction in Mathematics . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
A.2 The Recursion Principle . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
A.3 What Problems to Solve . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
A.4 Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
Index 73
Chapter 1
The Basics
Prolog (programming in logic) is one of the classical programming languages developed
specifically for applications in AI. As opposed to imperative languages such as C or Java
(the latter of which also happens to be object-oriented) it is a declarative programming
language. This means that, when you implement the solution to a problem, instead
of specifying how to achieve a certain goal in a certain situation, you specify what the
situation (rules and facts) and the goal (query) are and let the Prolog interpreter derive
the solution for you. Prolog is particularly useful for certain problem solving tasks in
AI, in domains such as search, planning, and knowledge representation.
In working through these lecture notes, you will learn how to use Prolog as a pro-
gramming language to solve practical problems in computer science and AI. You will
also learn how the Prolog interpreter actually works. The latter will include a very brief
introduction to the logical foundations of the Prolog language.
These notes cover the most important Prolog concepts you need to know about, but
it is certainly worthwhile to also have a look at the literature. The following three are
well-known titles, but you may also consult any other textbook on Prolog.
• I. Bratko. Prolog Programming for Artificial Intelligence. 4th edition, Addison-
Wesley Publishers, 2012.
• F. W. Clocksin and C. S. Mellish. Programming in Prolog. 5th edition, Springer-
Verlag, 2003.
• L. Sterling and E. Shapiro. The Art of Prolog. 2nd edition, MIT Press, 1994.
1.1 Getting Started: An Example
IntheintroductionithasbeensaidthatPrologisadeclarative(ordescriptive)language.
Programming in Prolog means describing the world. Using such programs means asking
Prolog questions about the previously described world. The simplest way of describing
the world is by stating facts, like this one:
1
2 Chapter 1. The Basics
bigger(elephant, horse).
This states, quite intuitively, the fact that an elephant is bigger than a horse. (Whether
the world described by a Prolog program has anything to do with our real world is, of
course, entirely up to the programmer.) Let’s add a few more facts to our little program:
bigger(elephant, horse).
bigger(horse, donkey).
bigger(donkey, dog).
bigger(donkey, monkey).
Thisisasyntacticallycorrectprogram,andafterhavingcompileditwecanasktheProlog
system questions (or queries in proper Prolog jargon) about it. Here’s an example:
?- bigger(donkey, dog).
Yes
The query bigger(donkey, dog) (i.e., the question “Is a donkey bigger than a dog?”)
succeeds, because the fact bigger(donkey, dog) has previously been communicated to
the Prolog system. Now, is a monkey bigger than an elephant?
?- bigger(monkey, elephant).
No
No, it’s not. We get exactly the answer we expected: the corresponding query, namely
bigger(monkey, elephant)fails. Butwhathappenswhenweasktheotherwayround?
?- bigger(elephant, monkey).
No
According to this, elephants are not bigger than monkeys. This is clearly wrong as far as
our real world is concerned, but if you check our little program again, you will find that
it says nothing about the relationship between elephants and monkeys. Still, we know
that if elephants are bigger than horses, which in turn are bigger than donkeys, which in
turn are bigger than monkeys, then elephants also have to be bigger than monkeys. In
mathematical terms: the bigger-relation is transitive. But this also has not been defined
inourprogram. ThecorrectinterpretationofthenegativeanswerProloghasgivenisthe
following: from the information communicated to the system it cannot be proved that
an elephant is bigger than a monkey.
If, however, we would like to receive a positive reply for a query such as
bigger(elephant, monkey), then we have to provide a more accurate description of
the world. One way of doing this would be to add the remaining facts, such as
bigger(elephant, monkey), to our program. For our little example this would mean
adding another 5 facts. Clearly too much work and probably not too smart anyway.
The far better solution would be to define a new relation, which we will call
is_bigger, as the transitive closure (don’t worry if you don’t know what that means)
Ulle Endriss. An Introduction to Prolog Programming 3
of bigger. Animal X is bigger than animal Y either if this has been stated as a fact or if
there is an animal Z for which it has been stated as a fact that animal X is bigger than
animal Z and it can be shown that animal Z is bigger than animal Y. In Prolog such
statements are called rules and are implemented like this:
is_bigger(X, Y) :- bigger(X, Y).
is_bigger(X, Y) :- bigger(X, Z), is_bigger(Z, Y).
In these rules :- means something like “if” and the comma between the two terms
bigger(X, Z) and is_bigger(Z, Y) stands for “and”. X, Y, and Z are variables, which
in Prolog is indicated by using capital letters.
You can think of the the bigger-facts as data someone has collected by browsing
throughthelocalzooandcomparingpairsofanimals. Theimplementationofis_bigger,
on the other hand, could have been provided by a knowledge engineer who may not
know anything at all about animals, but understands the general concept of something
being bigger than something else and thereby has the ability to formulate general rules
regarding this relation. If from now on we use is_bigger instead of bigger in our
queries, the program will work as intended:
?- is_bigger(elephant, monkey).
Yes
Prolog still cannot find the fact bigger(elephant, monkey) in its database, so it tries
to use the second rule instead. This is done by matching the query with the head of the
rule, which is is_bigger(X, Y). When doing so the two variables get instantiated: X =
elephant and Y = monkey. The rule says that in order to prove the goal is_bigger(X,
Y)(withthevariableinstantiationsthat’sequivalenttois_bigger(elephant, monkey))
Prolog has to prove the two subgoals bigger(X, Z) and is_bigger(Z, Y), again with
the same variable instantiations. This process is repeated recursively until the facts
that make up the chain between elephant and monkey are found and the query finally
succeeds. How this goal execution as well as term matching and variable instantiation
really work will be examined in more detail in Section 1.3.
Of course, we can do slightly more exiting stuff than just asking yes/no-questions.
Suppose we want to know which animals are bigger than a donkey. The corresponding
query would be:
?- is_bigger(X, donkey).
Again, X is a variable. We could also have chosen any other name for it, as long as it
starts with a capital letter. The Prolog interpreter replies as follows:
?- is_bigger(X, donkey).
X = horse
Horses are bigger than donkeys. The query has succeeded, but in order to allow it to
succeed Prolog had to instantiate the variable X with the value horse. If this makes us
4 Chapter 1. The Basics
happy already, we can press Return now and that’s it. In case we want to find out if
there are more animals that are bigger than the donkey, we can press the semicolon key,
which will cause Prolog to search for alternative solutions to our query. If we do this
once, we get the next solution X = elephant: elephants are also bigger than donkeys.
Pressing semicolon again will return a No, because there are no more solutions:
?- is_bigger(X, donkey).
X = horse ;
X = elephant ;
No
There are many more ways of querying the Prolog system about the contents of its
database. As a final example we ask whether there is an animal X that is both smaller
than a donkey and bigger than a monkey:
?- is_bigger(donkey, X), is_bigger(X, monkey).
No
The (correct) answer is No. Even though the two single queries is_bigger(donkey, X)
and is_bigger(X, monkey) would both succeed when submitted on their own, their
conjunction (represented by the comma) does not.
This section was intended to give you a first impression of what Prolog programming
is like. The next section provides a more systematic overview of the basic syntax.
There are a number of Prolog systems around that you can use. How to start a
Prolog session may differ slightly from one system to the next, but it should not be too
difficult to find out by consulting the user manual of your system. The examples in these
notes have all been generated using SWI-Prolog (in its 1999 incarnation, with only a few
minor adjustments made later on).1
1.2 Prolog Syntax
This section describes the most basic features of the Prolog programming language.
1.2.1 Terms
The central data structure in Prolog is that of a term. There are terms of four kinds:
atoms, numbers, variables, and compound terms. Atoms and numbers are sometimes
grouped together and called atomic terms.
1One difference between “classical” Prolog and more recent versions of SWI-Prolog is that the latter
reportstrueratherthanYeswhenaquerysucceedsandfalseratherthanNowhenaqueryfails. There
also are a few other very minor differences in how modern SWI-Prolog responds to queries. If you are
interested in the finer subtleties of this matter, search the Internet for “Prolog toplevel”.