# CS 231 - Introduction to Artificial Intelligence

```CS 231 - Introduction to Artificial Intelligence
LAB 2 (Sec 1&amp;2): Basics of PROLOG 
Instructions for Submission:



Make sure, your .pl file is well documented i.e. there should be as many comments as possible. A comment
in PROLOG starts with /* and end with */. For example:
/* This line is a comment */
When you submit your file, it should be saved as: “your_roll_number.pl”. For example, some one with the roll
number 03030053, will save the file as “03030053.pl”.
No late submissions will be accepted. So, make sure you finish your work atleast 5 minutes before the
session ends.
Today in this tutorial, we will cover the basics of PROLOG, in which most of you face difficulties.
We will cover the following topics:
1. What is PROLOG?
2. Facts &amp; Rules.
3. Constants and Variables.
4. Conditional operators.
5. Arithmetic in PROLOG.
So, lets start. Open up SWI-PROLOG. Type and test as you read this document. YOU HAVE TO
What is PROLOG?
Prolog stands for PROgramming in LOGic. The Prolog language originated at the University of
Marseille in about 1970; its chief architect was Alain Colmerauer. It became popular when efficient
implementations became available from Edinburgh University. The basic idea behind Prolog is that
of `logic as programming', which sees computation as controlled logical inference. Prolog provides
a mechanism for symbolic reasoning. According to Kowalski:
algorithm = logic + control
which expresses the separation of problem description (in terms of a `logic' program) and the
method for solving it (the program `control' or inference method). The logic program component is
specified by the programmer and entered into the Prolog database (TEXT EDITOR). The control
Facts and Rules
Prolog is based on assertion and query. By `assertion', we mean the provision of facts and rules
to the database. `Query' describes the mode of operation whereby the Prolog interpreter is posed
some question - and determines whether or not this can be proved from the facts and rules in the
database.
Hence, Prolog operates as a theorem prover. Facts and rules are represented in the clausal form
of logic, a restricted form of first-order predicate logic. The inference method is based on
resolution. Prolog is:



Declarative (as opposed to imperative) - rather than specifying a step-by-step algorithm
for problem solutions, queries are posed.
Non-procedural - Prolog does not distinguish between data and procedures that operate
on those data.
(Very!) Weakly-typed - Prolog does not enforce strong constraints on data objects, in the
way that Pascal does for example. (So beware misspellings!)
A Prolog program consists of a set of clauses - facts, rules or questions - each terminated by a full
stop `.'.
Constants &amp; Variables
A Prolog constant may be an integer (real numbers are allowed in some, but not all,
implementations) or an atom. An atom is symbolic rather than numeric. It can be:



a character string beginning with a lower case character, e.g. freddie, socks
a string of symbols, e.g. +a string enclosed in quotes, e.g. `this is a quote'
A Prolog variable begins with an upper-case letter or the underline character, e.g. X, Randolph,
_something. The scope of a variable is a single clause; X appearing in different clauses is a different
variable. This is in contrast to a constant, whose scope is the entire program. The underline
character in isolation (_) represents the anonymous variable, or don't care. Although there is only
one anonymous variable (hence the use of the definite article the) it can, of course, mean different
things in different clauses.
Conditional Operators
The conditional operators of predicate calculus when written in PROLOG, are given in the following
table:
NOTE:


English
Predicate Calculus
Prolog
And
^
,
Or
v
;
If

:-
Not
&not;
not
Facts cannot contain these operators.
The right side of the implication ( :- ) contains these operators. The left side CANNOT as it’s the conclusion.
Arithmetic in PROLOG
Prolog provides a number of basic arithmetic tools for manipulating integers (that is, numbers of
the form ...-3, -2, -1, 0, 1, 2, 3, 4...). Most Prolog implementation also provide tools for handling
real numbers (or floating point numbers) such as 1.53 or
, but we're not going to
discuss these, for they are not particularly useful for the symbolic processing tasks discussed in
this course. Integers, on the other hand, are useful for various tasks (such as finding the length
of a list), so it is important to understand how to work with them. We'll start by looking at how
Prolog handles the four basic operations of addition, multiplication, subtraction, and division.
Arithmetic examples
1 is the remainder when 7 is divided by 2
Prolog Notation
8 is 6+2.
12 is 6*2.
4 is 6-2.
-2 is 6-8.
3 is 6/2.
3 is 7/2.
1 is mod(7,2).
(Note that as we are working with integers, division gives us back an integer answer. Thus
gives 3 as an answer, leaving a reminder of 1.)
Posing the following queries yields the following responses:
?- 8 is 6+2.
yes
?- 12 is 6*2.
yes
?- -2 is 6-8.
yes
?- 3 is 6/2.
yes
?- 1 is mod(7,2).
yes
More importantly, we can work out the answers to arithmetic questions by using variables. For
example:
?- X is 6+2.
X=8
?- X is 6*2.
X = 12
?- R is mod(7,2).
R=1
Moreover, we can use arithmetic operations when we define predicates. Here's a simple
example. Let's define a predicate add_3_and_double2/ whose arguments are both integers. This
predicate takes its first argument, adds three to it, doubles the result, and returns the number
obtained as the second argument. We define this predicate as follows:
And indeed, this works:
X=8
X = 10
One other thing. Prolog understands the usual conventions we use for disambiguating
arithmetical expressions. For example, when we write
we mean
and not
, and Prolog knows this convention:
?- X is 3+2*4.
X = 11
The most important to grasp is this: +, *, -, and mod do not carry out any arithmetic. In fact,
expressions such as 3+2, 3-2 and 3*2 are simply terms. The functors of these terms are +, - and *
respectively, and the arguments are 3 and 2. Apart from the fact that the functors go between
their arguments (instead of in front of them) these are ordinary Prolog terms, and unless we do
something special, Prolog will not actually do any arithmetic. In particular, if we pose the query
?- X = 3+2
X = 3+2
yes
That is, Prolog has simply bound the variable X to the complex term 3+2. It has not carried out
any arithmetic. It has simply done what it usually does: performed unification Similarly, if we pose
the query
?- 3+2*5 = X
we get the response
X = 3+2*5
yes
Again, Prolog has simply bound the variable X to the complex term 3+2*5. It did not evaluate this
expression to 13. To force Prolog to actually evaluate arithmetic expressions we have to use
is
just as we did in our in our earlier examples. In fact, is does something very special: it sends a
signal to Prolog that says `Hey! Don't treat this expression as an ordinary complex term! Call up
your inbuilt arithmetic capabilities and carry out the calculations!'
In short, is forces Prolog to act in an unusual way. Normally Prolog is quite happy just unifying
variables to structures: that's its job, after all. Arithmetic is something extra that has been bolted
on to the basic Prolog engine because it is useful. Unsurprisingly, there are some restrictions on
this extra ability, and we need to know what they are.
For a start, the arithmetic expressions to be evaluated must be on the right hand side of is. In our
earlier examples we carefully posed the query
?- X is 6+2.
X=8
6+2 is X.
we would have got an error message saying instantiation_error, or something similar.
Moreover, although we are free to use variables on the right hand side of is, when we actually
carry out evaluation, the variable must already have been instantiated to an integer. If the
variable is uninstantiated, or if it is instantiated to something other than an integer, we will get
some sort of instantiation_error message. And this makes perfect sense. Arithmetic isn't performed
using Prolog usual unification and knowledge base search mechanisms: it's done by calling up a
special `black box' which knows about integer arithmetic. If we hand the black box the wrong
kind of data, naturally its going to complain.
Here's an example. Recall our `add 3 and double it' predicate.
When we described this predicate, we carefully said that it added 3 to its first argument, doubled
the result, and returned the answer in its second argument. For example, add_3_and_double(3,X)
returns X = 12. We didn't say anything about using this predicate in the reverse direction. For
example, we might hope that posing the query
would return the answer X=3. But it doesn't! Instead we get the instantiation_error message. Why?
Well, when we pose the query this way round, we are asking Prolog to evaluate 12 is (X+3)*2,
which it can't do as X is not instantiated.
Two final remarks. As we've already mentioned, for Prolog 3 + 2 is just a term. In fact, for Prolog,
it really is the term +(3,2). The expression 3 + 2 is just a user-friendly notation that's nicer for us to
use. This means that if you really want to, you can give Prolog queries like
X is +(3,2)
X=5
Actually, you can even given Prolog the query
is(X,+(3,2))
and Prolog will respond
X=5
This is because, for Prolog, the expression X is +(3,2) is the term is(X,+(3,2)). The expression
X is +(3,2) is just user friendly notation. Underneath, as always, Prolog is just working away with
terms. Summing up, arithmetic in Prolog is easy to use. Pretty much all you have to remember is
to use is to force evaluation, that stuff to be evaluated must goes to the right of is, and to take
care that any variables are correctly instantiated. But there is a deeper lesson that is worth
reflecting on. By `bolting on' the extra capability to do arithmetic we have further widened the
distance between the procedural and declarative interpretation of Prolog processing. Some
Prolog arithmetic predicates actually do carry out arithmetic all by themselves (that is, without the
assistance of is). These are the operators that compare integers.
Arithmetic examples
These operators have the obvious meaning:
2 &lt; 4.
yes
2 =&lt; 4.
yes
4 =&lt; 4.
yes
4=:=4.
yes
4=\=5.
yes
Prolog Notation
X &lt; Y.
X =&lt; Y.
X =:= Y.
X =\= Y.
X &gt;= Y
X&gt;Y
4=\=4.
no
4 &gt;= 4.
yes
4 &gt; 2.
yes
Moreover, they force both their right-hand and left-hand arguments to be evaluated:
2 &lt; 4+1.
yes
2+1 &lt; 4.
yes
2+1 &lt; 3+2.
yes
Note that =:= really is different from =, as the following examples show:
4=4.
yes
2+2 =4.
no
2+2 =:= 4.
yes
That is, = tries to unify its arguments; it does not force arithmetic evaluation. That's =:='s job.
Whenever we use these operators, we have to take care that any variables are instantiated. For
example, all the following queries lead to instantiation errors.
X &lt; 3.
3 &lt; Y.
X =:= X.
Moreover, variables have to be instantiated to integers. The query
X = 3, X &lt; 4.
succeeds. But the query
X = b, X &lt; 4.
fails.
```