Introduction to

Prolog Language
 Chapter 1 – Introduction to Prolog
1.1 Defining relation by facts
1.2 Defining relations by rules
1.3 Recursive rules
1.4 How Prolog answers questions
1.5 Declarative and Procedural Meaning of
Programs
 1.1 Defining Relations by facts
 Prolog (programming in logic) is a programming
language for symbolic, non-numeric
computation
 Specially suite for solving problems that involve
objects and relations between objects.
When we tried to say tom is a parent of bob

tom and bob are objects and parent is a relation between object tom and bob

In prolog, we can write like parent(tom,bob).

 Example: Family Tree
Instances or
parent(pam,bob). relationships
pam tom parent(tom,bob).
parent(tom,liz).
parent(bob, ann).
parent(bob,pat).
bob
parent(pat,jim).
liz

ann pat

A relation is defined as a set

of all its instances

jim
 How to ask Prolog?
• ?- parent(bob,pat).  yes
• ?-parent(liz,pat).  no
• Using Variables – defined as Capital Letter
?-parent(X,liz).
 X=tom
?-parent(bob,X).
 X=ann if more than one answer, press ; to get others or press enter to stop
 X = pat
?-parent(X,Y).
 Using , to make conjunction (and)
 Who grandparent of jim?
 ?- parent(Y,jim), parent(X,Y).
 Using ; to make disjunction (or)
 ?-parent(Y,jim);parent(Y,pat).
 Summary
• Use Prolog to define a relation
• User can ask back the relation defined in Prolog
program
• Prolog consists of Clauses.
• Each clause terminates with a full stop.
• There are concrete object or constants (such as
tom, ann) and are called atom
• General objects (such as X, Y –starting with
capitals) called variable.
• Questions to the system consists of one or more
goals.
 1.2 Defining Relations by rules
 Prolog clauses are three types: facts, rules and
questions
 Facts declares things that are always
unconditionally true e.g male(bob).
 Rules declare things that are true depending on
a give condition
e.g grandparent(X,Z):- parent(X,Y),parent(Y,Z).
Right-hand side is called a condition part or body
Left-hand side is called a conclusion or head
 Questions – The user can ask the question what
things are true.
 1.3 – Recursive rules
• Sometimes, we need to write X

recursive rules in prolog, like

Y

• Predecessor case
– predecessor(X,Z):-parent(X,Z).
– predecessor(X,Z):-
parent(X,Y), predecessor(Y,Z).
………..

Putting Comment: Z
/* */ => between those /* and */ are comment
% => starting from % to end of line is comment
 How prolog answer questions
Informal explanations
• Prolog seeks for the goals provided by the
user as questions
• Progol searches the successful path and
if it reaches unsuccessful branch, it
backtracks to previous one and tries to
apply alternative clauses
• That why, there is some important clues to
write program to run faster in later section.
 Declarative and Procedural
Meaning of Programs
• Declarative Meaning – is concerned only with
how the relations is defined by the program or
what will be the output of the program
• Procedural Meaning – is concerned with how
the relations are evaluated by the prolog system
or how this output is obtained

Suggestion: Write program in declaration way and don’t worry about how does it
compute to obtain the goals. It would be Prolog program development
 Summary
• Prolog programming consists of defining
relations and querying about relations
• A program consists of clauses, and there are
three types: facts, rules and questions.
• A relation can be specified by facts
• A procedure is a set of clauses about the same
relations.
• Two types of prolog meanings: declarative and
procedural meaning
 Chapter 2- Syntax and Meaning of
Prolog Program
• Data Objects – is composed of simple
objects, structures, constants, variables, Data objects
atoms and numbers.
– Atoms and number
• Atoms can create in three ways:
(1) String of letters, digits and the underscore Simple objects structures
character, ‘_’, starting with a lower case letter
(2) String of special characters, e.g <--->
(3) String of characters enclosed in a single
quotes, like ‘Tom’
constants variables
– Variables – can create with string of letter,
digits and the underscore character, but
starting with upper case character or
underscore characters. atoms numbers
• E.g X, _x
• Anonymous variables, used as underscore,
eg. _
– ?-parent(X,_).
– Lexical Scope – all variables are scoped in
one clauses and all atoms are scoped to
the whole program
 Structures
date
• Are objects that have several
components
1 feb 2006
• The components themselves can
be structure.
– e.g date(1,feb, 2006). or
date(Day,feb,2006).

• Also called structure as terms in syntactically and it can

represent as tree
• The root of tree is called funtor and the subtrees are
called arguments
• Each functor is defined with two things
(1)The name, whose syntax is that of atoms;
(2)The arity- the number of arguments
 Matching
• Match – given two terms, they are identical or the
variables in both terms can have same objects after
being instantiated
– E.g date(D,M,2006) = date(D1,feb,Y1) means
• D=D1, M=feb, Y1=2006
• General Rule to decide whether two terms, S and T
match are as follows:
– If S and T are constants, S=T if both are same object
– If S is a variable and T is anything, T=S
– If T is variable and S is anything, S=T
– If S and T are structures, S=T if
• S and T have same funtor
• All their corresponding arguments components have to match
Declarative and Procedural Way
• Prolog programs can be understood two
ways: declaratively and procedurally.
• P:- Q,R
• Declarative Way
– P is true if Q and R are true
• Procedural Way
– To solve problem P, first solve Q and then R
(or) To satisfy P, first satisfy Q and then R
 What is difference?
• Procedural way does not only define
logical relation between the head of the
clause and the goals in the body, but also
the order in which the goal are processed.
 Declarative meaning
• Determine whether a given goal is true, and if so, for
what values of variables it is true.
• An instance of a clause C is the clause C with each of
its variables substituted by some term.
• A variant of a clause C is such an instance of the clause
C where each variable is substituted by another variable.
– E.g hasachild(X):-parent(X,Y).
– Two variants are:
• hasachild(A):- parent(A,B).
• Hasachild(X1):-parent(X1,X2).
– Instance of this clause are:
• hasachild(peter):-parent(peter,Z).
• Hasachild(barry):-parent(barry,small(caroline)).
 Formal Declarative Meaning
• Given a program and a goal G,
• A goal G is true (that is satisfiable, or
logically follows from the program) if and
only if:
– There is a clause C in the program such that
– There is a clause instance I of C such that
• The head of I is identical to G, and
• All the goals in the body of I are true.
Conjunction= , and disjunction = ;
 Procedural Meaning
• Specifies how prolog answer questions
• To answer a question means to try to
satisfy a list of goals
• A procedure for executing (or) satisfying a
list of goals with respect to a given
program.
 Monkey and Banana
• Problem – In the middle of the room, there is a
banana hanging on the ceiling and the monkey
tries to reach by using a box.
• Approach
– Initial states
• Monkey is at the floor
• Money is on the floor
• Box is at window
• Monkey does not have banana
– Four types of move
• Grap banana
• Climb box
• Push box
• Walk around
 Monkey and Banana(Cont’d)
move(state(middle,onbox,middle,hasnot), % before move
grasp, % grap banana
state(middle,onbox,middle,has)). % After move
move(state(P,onfloor,P,H),
climb, % climb box
state(P,onbox,P,H)).
move(state(P1,onfloor,P1,H),
push(P1,P2), % push box from P1 to P2
state(P2,onfloor,P2,H)).
move(state(P1,onfloor,B,H),
walk(P1,P2),
state(P2,onfloor, B,H)).
canget(state(_,_,_,has)). % can 1: Monkey already has it
canget(State1):- % do somework to get it
move(State1,Move,State2), % do something
canget(State2). % Get it now

?- canget(state(atdoor,onfloor,atwindow,hasnot)). => Yes

 Way of Satisfying the goal in
procedural way
• If the goal list is empty -> Success
• If not, scan all clauses from top to bottom to find,
the head to match with the goal. If no match
found and end of program, failure
• If found, generate variant of the goal and
instantiate all variables from that goal to all
reminding goal lists
• Execute recursively the new goal list until it
reaches success or failure.
 Example
• ?-dark(X),big(X)
• big(bear). 1.
2.
Initiate goal list: dark(X),big(X).
Scan to find dark(X)
• big(elephant). 1.
2.
Found dark(Z):-black(Z).
New goal black(X),big(X)
• small(cat). 3.
1.
Scan 2nd goal black(X)
Found black(cat).
• brown(bear). 4.
2. New goal black(cat),big(cat).
Scan black(cat) and not found, so go to
• black(cat). 1.
second goal big(cat)
No found, so go back to black(X), big(X)
and scan -> no found
• gray(elephant). 5. Go back to dark(X), big(X) with dark(X)
again
• dark(Z):-black(Z). 1. Found dark(Z):- brown(Z).
2. New goal brown(X), big(X).
• dark(Z):- 6. Scan and found borwn(bear). So the goal
shrink to big(bear).
brown(Z). 7. Found big(bear)
8. Provide X=bear.
 Orders of Clauses and Goals
• Danger of indefinite looping eg p:- p.
• When happened?.
– Declarative way is correct, but procedural way is
wrong. So, there is actually answer, but cannot reach
from program.
• So how to avoid it -> many special techniques
• Carefully to rearrange
– The order of clauses in the program
– The order of goals in the bodies of the clauses
 So, how to program Prolog
• Do declarative way to program because it
is easier to formulate and understand
• Prolog will help you to get procedural work
• If fails, rearrange the order of clauses and
goals into suitable order from procedural
aspect
 Representation of Lists
• List is a data structure and is either empty
or consists of two parts, called a head and
a tail and can be represented as
– [X,Y,Z].
– [Head | Tail].
– .(Head,Tail). Where Head is atoms and Tail is
in list
– We can write [a,b,c] or .(a,.(b,.(c,[]))).
• List is handled as binary tree in Prolog
 List Operations
• Checking some objects is an element of a list ->
member
• e.g member(b,[a,b,c]). => true
• member(b,[a,[b,c]]). => false
• Concatenation -> conc(L1,L2,L3).
• conc([a,b,c],[1,2,3],L).=> L = [a,b,c,1,2,3]
• Adding item into list => add(X,L,L3).
• add(a.[b,c],L) => L=[a,b,c]
• Deleting Item => del(X,L,L1).
• del(a,[a,b,c],L). => L=[b,c]
• sublist => sublist(S,L).
• Sublist(a,[a,b,c]) => true
• Permuntation => permutation(L,P).
• Permutation([a,b],P). => P = [a,b]; P=[b,a]
 Operator Notation
• Can define new operator by inserting special clauses called directives, e.g :-
op(600,xfx,has).
• :-op(precedence,type of operator, functor).
– Precedence is between 1 to 1200
– Type of operator denoted with f
– Functor -> operator name
• Three group of type of operator
– Infix operator -> xfx , xfy, yfx
– Prefix operator -> fx, fy
– Postfix operator -> xf, yf
– x represents an argument whose precedence must be strictly lower than that of the
operator
– y represents an argument whose precedence is lower or equal to that of the operator
• If an argument is enclosed with parentheses or it is an unstructured objects, then
precedence is 0.
• If argument is structure then, its precedence is equal to the precedence of its
principal functor.
 Operator Notation (Cont’d)
- -
- c
Precedence 0 a
-
Precedence 0

a b b c

Precedence 500 Precedence 500

For a – b – c case, assume that – has precedence of 500

Then, if – is yfx type, the right interpretation is not correct because the
precedence of b – c is not less than the precedence of – . Thus, use (a-
b) –c
 Summary
• Readability of the program can be improved by infix, prefix or postfix
• Operator definition introduces new notation. Operator called functor holds
together components of structures
• A programmer can define his or her own operators. Each operator is
defined by its name, precedence and type
• Precedence is an integer within some range usually from between 1 to
1200.
• The operator with the highest precedence in the expression is the principle
functor of the expression
• Operator with lowest precedence binds strongest
• The type of an operator depends on two things:
– The position of the operator with respect to the argument
– The precedence of the arguments compared to the precedence of the operator
itself.
– xfy -> x indicates an argument whose precedence is strictly lower than that of
operator and y indicates an argument whose precedence is less than or equal to
that of the operator
 Arithmetic
• Basic arithmetic opeartors are
+ = addition
- = substraction
* = Mutiplication
/ = division
** = power
// = integer division
mod = modulo
e.g ?- X=1+2. => X = 1 + 2
?- X is 1 + 2. => X = 3
So, is is operator for arithmetic expression
?- X is 5/2, Y is 5//2, Z is 5 mod 2.
X=2.5
Y=2
Z=1
 Comparison Operator
• X > Y => X is greater than Y
• X < Y => 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 =:= Y => the X and Y values are equal
• X =\= Y => the X and Y values are not equal
 Summary
• List is either empty of consists of a head, presented as
atom and a tail which is also a list.
• membership, conc, add, del
• The operator notation allows the user to tailor the syntax
of programs toward particular needs and also improve
readability
• New operators are defined by the directive op, stating
the name of an operator, its type and precedence.
• Arithmetic is done by built in procedure. Use is
procedure to evaluate and comparison with <, =< etc