PROLOG AS AI PROGRAMMING
LANGUAGE
PRINCIPLE OF LOGICAL
PROGRAMMING
Logic programming is a programming paradigm based
on mathematical logic.
In this paradigm the programmer specifies relationships
among data values (this constitutes a logic program) and
then poses queries to the execution environment (usually
an interactive interpreter) in order to see whether certain
relationships hold.
2
PRINCIPLE…
The Prolog execution environment, on the other hand,
doesn’t so much “compute” an answer, it “deduces” an
answer from the relation definitions at hand.
Though the basic elements of Prolog are type-less, most
implementations have been enhanced to include
character, integer values and operations.
3
FACTS AND RULES
Prolog is referred to as a declarative language because
all program statements are definitional.
In particular, a Prolog program consists of facts and rules
which serve to define relations (in the mathematical
sense) on sets of values.
4
FACTS…
Everything in Prolog is defined in terms of two
constructs: the fact and the rule.
Fact: is a Prolog statement consisting simply of an identifier
followed by an n-tuple of constants.
The identifier is interpreted as the name of a (mathematical)
relation and the fact states that the specified n-tuple is in the
relation.
5
FACTS…
A fact states that a certain tuple of values satisfies a
predicate unconditionally .
A rule , on the other hand, is a Prolog statement which
gives conditions under which tuples satisfy a predicate.
Hence, a fact is just a special case of a rule, where the
condition is always satisfied
6
THE SWI-PROLOG ENVIRONMENT
SWI-Prolog, developed at the Swedish Institute of
Computer Science.
It can be executed in two different forms: from the
command line or via an Emacs interface
Prolog file has the extension .pl
7
THE SWI-PROLOG…
SWI-Prolog interpreter reads a program and then allows
the user to compute a query based on the definitions
(facts and rules).
A query “asks” the system if there are any data values
which satisfy a particular predicate (or combination).
8
STARTING PROLOG AND LOADING A
PROGRAM
This file can be opened in Prolog from the Start Menu,
by opening .pl files in the Windows explorer or using the
following command in the Prolog application.
?- [swi('demo/likes')].
Or if you have the absolute address we can use the
following
?- ['C:/Users/Documents/Prolog/parents'].
9
EXECUTING A QUERY
After loading a program, one can ask Prolog queries
about the program. The system responds with X =
<value> if it can prove the goal for a certain X.
The user can type the semi-colon (;) if (s)he wants
another solution, or RETURN if (s)he is satisfied, after
which Prolog will say True. If Prolog answers False, it
indicates it cannot find any (more) answers to the query.
Finally, Prolog can answer using an error message to
indicate the query or program contains an error.
10
SYNTAX OF PROLOG
What exactly are facts, rules and queries built out of?
Prolog Terms
11
PROLOG TERMS
Terms
Simple Terms Complex Terms
Constants Variables
Atoms Numbers
12
ATOMS
A sequence of characters of upper-case letters, lower-case
letters, digits, or underscore, starting with a lowercase
letter
Examples: butch, big_bang_theory, playGuitar
An arbitrary sequence of characters enclosed in single
quotes
Examples: 'Vincent', 'Five dollar shake', '@$%'
A sequence of special characters
Examples: : , ; . :-
13
NUMBERS
Integers:
12, -34, 22342
Floats:
34573.3234, 0.3435
14
VARIABLES
A sequence of characters of uppercase letters,
lower-case letters, digits, or underscore, starting
with either an uppercase letter or an underscore
Examples: X, Y, Variable, Vincent, _tag
15
COMPLEX TERMS
Atoms, numbers and variables are building blocks
for complex terms
Complex terms are built out of a functor
(identifier) directly followed by a sequence of
arguments (tuple).
Arguments are put in round brackets, separated by
commas
The functor must be an atom 16
EXAMPLES OF COMPLEX TERMS
Examples re
parent (pam, bob).
female(pam).
male(tom).
Complex terms inside complex terms:
hide(X,father(father(father(jon))))
17
ARITY
The number of arguments a complex term has is
called its arity.
Examples:
female(pam). is a term with arity 1
parent (pam, bob). has arity 2
father(father(joy)) arity 1
In prolog documentation the arity can be described as
female/1
parent/2
father/1
18
PROLOG
Defining relations by facts
It is especially well suited for solving problems that
involves objects and relations between objects.
19
Example : The Family Tree
Pam Tom
Bob Liz
Ann
Pat
Jim 20
The fact that Tom is a parent of Bob can be written in Prolog as:
parents (tom, bob).
21
The whole family tree of the above figure is defined by the
following Prolog program:
parent (pam, bob).
parent (tom, bob).
parent (tom, liz).
parent (bob, ann).
parent (bob, pat).
parent (pat, jim).
22
When this program has been communicated to the Prolog system,
prolog can be posed some questions about the parent relation.
For example: is Bob a parent of Pat? This questions can be
communicated to the Prolog system by typing into the terminal:
?-parent (bob, pat).
Having found this as an asserted fact in the program, Prolog will
answer: yes/true.
If it doesn’t find a clause that satisfies the relation, Prolog will
answer: no/false.
23
Who is Liz’s parent?
?-parent (X, liz).
The Prolog will tell us what the value of X is such that the above
statement is true. So the answer is: X=tom.
The question who are Bob’s children? Can be communicated to
Prolog as:
?-parent (bob, X).
24
We can ask other complicated questions like who is a grandparent
of jim? Our program don’t have a grandparent relation so the
query has to be broken down into two steps,
Who is a parent of jim? Assume that this is some Y.
Who is a parent of Y? Assume that this is some X.
Such a composed query is written in Prolog as a sequence of two
simple ones:
?-parent (Y, jim), parent (X,Y).
The answer will be:
X=bob
25
Y=pat
Defining relations by rules
We could define offspring in a similar way as the parent relation;
that is, by simply providing a list of simple facts about the
offspring relations
offspring (liz, tom).
However, the offspring relation can be defined much more
elegantly by making use of the fact that it is the inverse of
parent, and that parent has already been defined. This alternative
way can be based on the following logical statement:
26
For all X and Y,
Y is an offspring of X if
X is a parent of Y.
This formulation is already close to the formalism of Prolog. The
corresponding Prolog clause which has the same meaning is:
27
Before defining this relationship we define the female relation
female(pam).
male(tom).
male(bob).
female(liz).
female(pat).
female(ann).
male(jim).
Let us now add more family relation to our example program. The
specification of the mother relation can be based on the following logical
statement:
For all X and Y,
X is the mother of Y if
X is a parent of Y and
X is a female.
This is translated into Prolog as the following rule:
mother (X,Y):- parent (X,Y), female(X).
28
A comma between two conditions indicates the conjunction of the
conditions meaning that both conditions have to be true.
Exercise
1. Who are Tom’s grandchildren?
2. Do Ann and Pat have a common parent?
3. Who is pat’s grandparents?
4. Write a father relation in prolog ?
5. Write a grandparent relation in prolog ?
6. Write a sister relation in prolog?
7. Write a brother relation in prolog?
8. Write a aunt relation in prolog?
9. Write a married relation in prolog? 29
ANSWER
THE ANSWER IS IN THE PARENT.PL
FILE WHICH ACCOMPANIES THIS SLIDE.
30
WRITING FACTS ABOUT DIRECTED
GRAPH
b e
c g
a
d f
31
ANSWER
THE ANSWER IS IN THE GRAPH.PL
FILE WHICH ACCOMPANIES THIS SLIDE.
32
NEGATION AS FAILURE
No equivalent of logical not in Prolog:
Prolog can only assert that something is true.
Prolog cannot assert that something is false.
Prolog can assert that the given facts and rules do not allow
something to be proven true
33
PROPER USE OF NEGATION AS FAILURE
loves(bill,X) :- pretty(X), female(X), not(loves(tom,X)).
loves(tom,X):- famous(X), female(X), not(dead(X)).
female(marilym_monroe).
female(cindy_crawford).
female(martha_stewart). ?-loves(tom,X).
female(girl_next_door). X=cindy_crawford;
X=martha_stewart;
famous(marilym_monroe). ?-loves(bill,X).
famous(cindy_crawford). X=marilyn_monroe;
X=girl_next_door;
famous(martha_stewart).
pretty(marilym_monroe).
pretty(cindy_crawford).
pretty(girl_next_door).
34
dead(marilym_monroe).
PROLOG: FAIL & TRUE PREDICATES
How to represent “Mary likes all animals but snakes”?
If X is a snake then Mary likes X is not true
otherwise if X is an animal then Mary likes X
snake(cobra).
cat(persian).
animal(X):-snake(X);cat(X).
likes(mary,X):-snake(X),!,fail.
likes(mary,X):-animal(X).
?- likes(mary,cobra).
no
rule 1 failed because of fail and the ! told the interpreter not to try
rule 2 because since we have reached there(aka to the !), it must
35
be a snake
UNIFICATION
Working definition – two terms unify:
if they are the same term, or
if they contain variables that can be uniformly
instantiated with terms in such a way that the
resulting terms are equal
When Prolog unifies two terms, it performs
all the necessary instantiations, so that the
36
terms are equal afterwards
UNIFICATION
If T1 and T2 are constants, then T1 and T2 unify if
they are the same atom, or the same number
If T1 is a variable and T2 is any type of term, then T1
and T2 unify, and T1 is instantiated to T2 (and vice
versa)
If T1 and T2 are complex terms then they unify if:
They have the same functor and arity, and
all their corresponding arguments unify, and
37
the variable instantiations are compatible
EXERCISE ON UNIFICATION
?- mia=mia. ?-K(s(g),Y)=K(X,t(k)).
True X=s(g)
Y=t(k)
?-mia=joy. ?- k(s(g),t(k)) = k(X,t(Y)).
X=s(g)
False Y=k
?- loves(X,X) = loves(marsellus,mia).
?- mia=X. no
X=mia
?- X=mia,X=joy.
38
False
