Prolog

Programming for Artificial Intelligence

Third edition 2001

Ivan Bratko

Addision Wesley

1
Part 1 The Prolog Language

Chapter 1
Introduction to Prolog
(Programming in Logic)

2
Introduction to PROLOG
 In PROLOG, predicate expressions consist of the
predicate name, followed by zero or more
arguments enclosed in parentheses, separated by
commas.
 Example: father(Ali, Ahmad) means that Ali is
the father of Ahmad

3
General Organization of a PROLOG
System

4
PROLOG Continued
 Programs consist of facts and rules in the
general form of goals.
 General form: p:- p1, p2, …, pN
p is called the rule’s head and the pi
represents the subgoals
 Example:
parent(X,Y) :- father(X,Y)
X is the parent of Y if X is the father of Y

5
PROLOG Continued
• Examples of PROLOG predicates and
comments preceded by semicolons:

6
Defining relations by facts
 Given
The tree
a whole
defined
family
by the
tree
Prolog program:

parent( pam,tombob). % Pam is a parent of Bob

pam
parent( tom, bob).
parent( tom, liz).
parent(bob
bob, ann). liz
parent( bob, pat).
parent( pat, jim).
ann pat

jim

7
Defining relations by facts
 Questions (Queries):
 Is Bob a parent of Pat? pam tom

 ?- parent( bob, pat).

 ?- parent( liz, pat). bob liz

 ?- parent( tom, ben).

ann pat
 Who is Liz’s parent?
 ?- parent( X, liz).
jim

 Who are Bob’s children?

 ?- parent( bob, X).

8
 Defining relations by facts
pam tom
 Questions:
 Who is a parent of whom?
bob liz
 Find X and Y such that X

is a parent of Y.
ann pat
 ?- parent( X, Y).

 Who is a grandparent of jim

Jim? X

 ?- parent( Y, jim),
parent
parent( X, Y). Y grandparent

parent
jim
9
Defining relations by facts
tom
 Questions: pam

 Who are Tom’s grandchildren?

 ?- parent( tom, X), bob liz

parent( X, Y).
ann pat
 Do Ann and Pat have a
common parent?
jim
 ?- parent( X, ann),

parent( X, pat).

10
Defining relations by facts
 It is easy in Prolog to define a relation.
 The user can easily query the Prolog system about
relations defined in the program.
 A Prolog program consists of clauses. Each clause
terminates with a full stop.
 The arguments of relations can be
 Atoms: concrete objects or constants such as tom, pat
 Variables: general objects such as X and Y
 Questions to the system consist of one or more goals.
 An answer to a question can be either positive
(succeeded) or negative (failed).
 If several answers satisfy the question then Prolog will find
as many of them as desired by the user.

11
 Defining relations by rules
 Facts:
 female( pam). % Pam is female
 female( liz).
 female( ann).
 female( pat). pam tom
 male( tom). % Tom is male
 male( bob).
 male( jim). bob liz

 Define the “offspring()” relation: ann pat

 Fact: offspring( liz, tom).
 Rule: offspring( Y, X) :- parent( X, Y).
 For all X and Y, jim
Y is an offspring of X if
X is a parent of Y.
12
 Defining relations by rules
 Rules have:
 A condition part (body)
 the right-hand side of the rule
 A conclusion part (head)
 the left-hand side of the rule

 Example:
 offspring( Y, X) :- parent( X, Y).
 The rule is general in the sense that it is
applicable to any objects X and Y.
 A special case of the general rule:
 offspring( liz, tom) :- parent( tom, liz).
X
 ?- offspring( liz, tom).
 ?- offspring( X, Y). parent offspring

Y
13
Defining relations by rules
 Define the “mother” relation:
 mother( X, Y) :- parent( X, Y), female( X).
 For all X and Y,
X is the mother of Y if
X is a parent of Y and
X is a female.

female
X

parent mother

14
Defining relations by rules
 Define the “grandparent” relation:
 grandparent( X, Z) :-
parent( X, Y), parent( Y, Z).

parent

Y grandparent

parent

15
Defining relations by rules
 Define the “sister” relation:
 sister( X, Y) :-
parent( Z, X), parent( Z, Y),
female(X).
 For any X and Y,
X is a sister of Y if
(1) both X and Y have the same parent, and
(2) X is female.
 ?- sister( ann, pat). Z
 ?- sister( X, pat). parent
parent
 ?- sister( pat, pat).
 Pat is a sister to herself?!
X Y
female
sister

16
Defining relations by rules
 To correct the “sister” relation:
 sister( X, Y) :-
parent( Z, X), parent( Z, Y),
female(X),
different( X, Y).
 different (X, Y) is satisfied if and only if X and Y
are not equal. (Please try to define this function)

parent parent

X Y
female
sister

17
Defining relations by rules
 Prolog clauses consist of
 Head
 Body: a list of goal separated by commas (,)

 Prolog clauses are of three types:

 Facts:
 declare things that are always (logically) true
 facts are clauses that have a head and the empty
body
 Rules:
 declare things that are true depending on a given
condition
 rules have the head and the (non-empty) body
 Questions (Queries):
 the user can ask the program what things are true
 questions only have the body

18
Defining relations by rules
 A variable can be substituted by another object.

 Variables are assumed to be universally quantified

and are read as “for all”.
 For example:

hasachild( X) :- parent( X, Y).

can be read in two ways:
(a) For all X and Y,
if X is a parent of Y then X has a child.
(b) For all X,
X has a child if there is some Y such that X
is a parent of Y.

19
Recursive rules
 Define the “predecessor()” relation

X X

parent predecessor parent

Y
Y1

parent predecessor
X
Y2
parent
Y predecessor parent
Z
parent
Z
20
 Recursive rules
 Define the “predecessor” relation
predecessor( X, Z):- parent( X, Z).
predecessor( X, Z):-
parent( X, Y), predecessor( Y, Z).
X

 For all X and Z, parent

X is a predecessor of Z if Y1
there is a Y such that
(1) X is a parent of Y and predecessor

(2) Y is a predecessor of Z.
predecessor
:
 ?- predecessor( pam, X).

21
Recursive rules
mother(
% FigureX,1.8
Y) The
:- family program.
parent( X, Y),
parent(
female(pam,
X). bob).
parent( tom, bob).
parent( tom, liz).
grandparent( X, Z) :-
parent(
parent(bob,
X, Y),
ann).
parent(
parent(bob,
Y, Z).
pat).
parent( pat, jim).
sister( X, Y) :-
female(
parent(pam).
Z, X),
female(
parent(liz).
Z, Y),
female(
female(ann).
X),
female(
X \= Y.pat).
male( tom).
male( bob). X, Z) :- % Rule pr1
predecessor(
male(
parent(
jim).
X, Z).

predecessor(
offspring( Y, X)
X, :-
Z) :- % Rule pr2
parent( X, Y),
Y).
predecessor( Y, Z).

22
Recursive rules
 Procedure:
 In figure 1.8, there are two “predecessor relation”
clauses.
predecessor( X, Z) :- parent( X, Z).
predecessor( X, Z) :- parent( X, Y), predecessor( Y, Z).
 Such a set of clauses is called a procedure.

 Comments:
/* This is a comment */
% This is also a comment

23
 Trace and Notrace
| ?- trace.
The debugger will first creep -- showing everything
(trace) …
(15 ms) yes X = bob
{trace} Z = jim
1 1 Redo: predecessor(bob,jim) ?
| ?- predecessor( X, Z). 3 2 Redo: predecessor(pat,jim) ?
1 1 Call: predecessor(_16,_17) ? 4 3 Call: parent(pat,_144) ?
2 2 Call: parent(_16,_17) ? 4 3 Exit: parent(pat,jim) ?
2 2 Exit: parent(pam,bob) ? …
1 1 Exit: predecessor(pam,bob) ? 4 3 Fail: parent(jim,_17) ?
4 3 Call: parent(jim,_144) ?
X = pam 4 3 Fail: parent(jim,_132) ?
Z = bob ? ; 3 2 Fail: predecessor(jim,_17) ?
1 1 Redo: predecessor(pam,bob) ? 1 1 Fail: predecessor(_16,_17) ?
2 2 Redo: parent(pam,bob) ?
2 2 Exit: parent(tom,bob) ? (266 ms) no
1 1 Exit: predecessor(tom,bob) ? {trace}
X = tom | ?- notrace.
Z = bob ? ; The debugger is switched off

yes

24
How Prolog answers questions
 To answer a question, Prolog tries to satisfy all the goals.
 To satisfy a goal means to demonstrate that the goal is true,
assuming that the relations in the program is true.
 Prolog accepts facts and rules as a set of axioms, and the
user’s question as a proved theorem.
 Example:
 Axioms: All men are fallible.
john is a man.
 Theorem: john is fallible.
 For all X, if X is a man then X is fallible.
fallible( X) :- man( X).
man( john).
 ?- fallible( john).

25
 How Prolog answers questions
predecessor( X, Z) :- parent( X, Z). % Rule pr1
predecessor( X, Z) :- parent( X, Y), % Rule pr2
predecessor( Y, Z).
parent( pam, bob).
parent( tom, bob).
 ?- predecessor( tom, pat). parent( tom, liz).
 How does the Prolog system actually parent( bob, ann).
parent( bob, pat).
find a proof sequence? parent( pat, jim).
 Prolog first tries that clause which appears first in the

program. (rule pr1)

pam tom  Now, X= tom, Z = pat.

 The goal predecessor( tom, pat) is then replaced by

bob liz
parent( tom, pat).
 There is no clause in the program whose head matches

the goal parent( tom, pat).

ann pat  Prolog backtracks to the original goal in order to try an

alternative way (rule pr2).

jim
26
 How Prolog answers questions
predecessor( X, Z) :- parent( X, Z). % Rule pr1
predecessor( X, Z) :- parent( X, Y), % Rule pr2
predecessor( Y, Z).
parent( pam, bob).
parent( tom, bob).
 ?- predecessor( tom, pat). parent( tom, liz).
 Apply rule pr2, X = tom, Z = pat, parent( bob, ann).
parent( bob, pat).
but Y is not instantiated yet. parent( pat, jim).
 The top goal predecessor( tom, pat) is replaced by two

goals:
pam tom  parent( tom, Y)
 predecessor( Y, pat)

bob liz  The first goal matches one of the facts. (Y = bob)

 The remaining goal has become

ann pat predecessor( bob, pat)

 Using rule pr1, this goal can be satisfied.

 predecessor( bob, pat) :- parent( bob, pat)

jim
27
 How Prolog answers questions
predecessor( tom, pat)

By rule pr1 By rule pr2

parent( tom, Y)
parent( tom, pat)
predecessor( Y, pat)

no By fact
Y = bob parent( tom, bob)
 The top goal is
satisfied when a path predecessor( bob, pat)
is found from the root
node to a leaf node By rule pr1
parent( pam, bob). labeled ‘yes’.
parent( tom, bob).  The execution of
parent( tom, liz). parent( bob, pat)
parent( bob, ann). Prolog is the searching
parent( bob, pat). for such path.
parent( pat, jim). yes
predecessor( X, Z) :- parent( X, Z). % Rule pr1
predecessor( X, Z) :- parent( X, Y), % Rule pr2
predecessor( Y, Z).
derivation diagrams
28
 predecessor( X, Z) :- parent( X, Z). % Rule pr1

Trace predecessor( X, Z) :- parent( X, Y), % Rule pr2

predecessor( Y, Z).

parent( pam, bob). predecessor( tom, pat)

parent( tom, bob).
parent( tom, liz).
parent( bob, ann). By rule pr1 By rule pr2
parent( bob, pat).
parent( pat, jim). parent( tom, Y)
parent( tom, pat)
predecessor( Y, pat)

no By fact
Y = bob
parent( tom, bob)
| ?- predecessor( tom, pat).
1 1 Call: predecessor(tom,pat) ? predecessor( bob, pat)
2 2 Call: parent(tom,pat) ?
2 2 Fail: parent(tom,pat) ?
2 2 Call: parent(tom,_79) ? By rule pr1
2 2 Exit: parent(tom,bob) ?
3 2 Call: predecessor(bob,pat) ? parent( bob, pat)
4 3 Call: parent(bob,pat) ?
4 3 Exit: parent(bob,pat) ?
yes
3 2 Exit: predecessor(bob,pat) ?
1 1 Exit: predecessor(tom,pat) ?
derivation diagrams
true ?

29
Goal Searching in PROLOG
• Example Rules:

• PROLOG is queried to determine whether

Ann is the ancestor of John:
:- ancestor(ann, john)
30
Declarative and Procedural meaning of
programs
 Two levels of meaning of Prolog programs:
 The declarative meaning
 concerned only with the relations defined by the program

 determines what will be the output of the program

 The programmer should concentrate mainly on the

declarative meaning and avoid being distracted by the

executional details.
 The procedural meaning
 determines how this output is obtained

 determines how the relations are actually evaluated by

the Prolog system

 The procedural aspects cannot be completely ignored by

the programmer for practical reasons of executional

efficiency.

31