B219 Intelligent Systems

Prolog Programming - Input/Output in Prolog

write(term) and read(term)

§ Predicate write(term) causes a term to be written to the
current output stream (the monitor screen by default)
§ If term is uninstantiated, an underscore followed by a
number unique to the variable will be output, eg, _64
§ Predicate read(term) is used to read a term from the
current input stream (the keyboard by default)
Input can be redirected using predicates
see(filename) to open a file for input, and
seen to close file and read from keyboard again

Output can be redirected using predicates

tell(filename) to open a file for output, and
told to close file and write to the keyboard again

Week 9 Lecture Notes page 1 of 1

B219 Intelligent Systems

I/O in Prolog - Example:

/* The following program contains a database of

positions and employees in a company. It specifies
the position of an employee, given the name */

position(‘Spielberg’, director).

position(‘Allen’, manager).

position(‘Lee’, supervisor).

find_position:-

write(‘Whose position do you wish to know?’),

read(Input), position(Input, Output),

write(‘The position of ‘), write(Input),

write(‘ is ‘), write(Output), write(‘.’).

?- find_position.
Whose position do you wish to know?
‘Spielberg’.
The position of Spielberg is director

Week 9 Lecture Notes page 2 of 2

B219 Intelligent Systems

List application - Sorting

Insertion sort algorithm is based on the following:
If all items in a list of size N-1 are already
sorted, then we insert the Nth item in the list by
searching along the list and finding the correct
location.

We assume the sorting is to be in ascending order.

The main part of the algorithm can now be expressed in
Prolog:

isort([],[]).

isort([X|Tail],SList):-
isort(Tail,STail),
insert(X,STail,SList).

The isort predicate strips off the head of the list, sorts the
tail recursively, then finally inserts the head item (X) into
the correct location.

The recursion stops when the list to be sorted become

empty.

We must now define the insert predicate.

Week 9 Lecture Notes page 3 of 3

B219 Intelligent Systems

The insert predicate

Compares the value of the item to be inserted with the

head of the list.
If it is less than this value, then the new item must be
inserted just before this head,
otherwise the item is inserted into the new tail.

insert(X,[],[X]).

insert(X,[H|Tail],[X,H|Tail]):-
X =< H.

insert(X,[H|Tail],[H|NewTail]):-
X > H,
insert(X,Tail,NewTail).

The first clause terminates the search process when the item (X)
is to be inserted into an empty list, it creates a new list with a
single item (X) in it.

The second clause is where the value of X is less than, or equal

to, the value of the head (H). In this case the new list is created
by adding X to the front of the list with the construct [X,H|Tail].

The final clause matches for the case when the item (X) is
greater than the head of the list (H). In this case the item is
inserted into the current Tail.

Week 9 Lecture Notes page 4 of 4

B219 Intelligent Systems

We now have a complete program which can be used as

follows:

?- isort([10, 9, 8, 7, 6, 5, 4, 3, 2, 1], S)

S = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Week 9 Lecture Notes page 5 of 5

B219 Intelligent Systems

A program to change a sentence into another

A program that responds with an altered version of an
input sentence, eg,
You: you are a computer
Prolog: i am not a computer
You: do you speak french
Prolog: no i speak german

Steps involved:
- Change each you to i
- Change are to am not
- Change french to german
- Change do to no

We can represent a sentence as a list of words

[like, this, sentence]
and define a predicate alter(X,Y) to alter sentence X into
sentence Y

Week 9 Lecture Notes page 6 of 6

B219 Intelligent Systems

Predicate alter
?- alter([do you know french], Y].
Y = [no i know german]

Main functions:
• change head of input list into another word, let this
word become head of output list
• alter tail of input list and let it become the tail of output
list
• if we have reached the end of the input list, then
terminate the output list with an empty list [ ]

Summarising in Prolog terminology:

altering a list with head H and tail T gives a list
with head X and tail Y if changing word H gives
word X, and altering list T gives list Y.
alter([], []).
alter([H|T], [X|Y]) :- change(H,X), alter(T,Y).

Week 9 Lecture Notes page 7 of 7

B219 Intelligent Systems

Defining change

change(X,Y) means word X is to be changed into word Y

change(you, i).
change(are, [am, not]).
change(french, german).
change(do, no).
/* if there is no match, don’t change */
change(X, X)

Week 9 Lecture Notes page 8 of 8

B219 Intelligent Systems

Getting more out of predicates

Joining two lists (Concatenating/Appending)

append( L1, L2, L3)

where L3 = L1 + L2, eg,

? - append([a,b], [c,d], NewList).

NewList = [a,b,c,d]

Two cases
1. First argument an empty list
append( [ ], L, L)

2. First argument has a head and a tail

append( [ X | L1], L2, [X | L3] ) :-
append( L1, L2, L3).

[X | L1]

X L1 L2

L3

X L3

[X | L3]

Week 9 Lecture Notes page 9 of 9

B219 Intelligent Systems

?- append([a,b], [c,d], Newlist).

Newlist = [a,b,c,d]

Predicate append can be used in a different way -

/* Which list, when appended to list [a], gives list
[a,b,c] */
?- append([a], X, [a,b,c]).
X = [b,c]

/* What are the different ways list [a,b,c] can be

decomposed? */
?- append(X, Y, [a,b,c]).
X = []
Y = [a,b,c]
More (y/n)? y
X = [a]
Y = [b,c]

Week 9 Lecture Notes page 10 of 10

B219 Intelligent Systems

More (y/n)? y
X = [a,b]
Y = [c]
More (y/n)? y
X = [a,b,c]
Y = []

Predicate myinsert

/* Inserts item X at position P in list L to give list

NewList */
myinsert(X, P, L, Newlist)

myinsert can be used to implement a predicate mydelete

to delete an item at position P
mydelete(P, L, List)
Eg,
?- mydelete(2,[a,b,c,d],X).
X = [a,b,d]

Week 9 Lecture Notes page 11 of 11

B219 Intelligent Systems

MORE ON RECURSION

Example 2 : A simple family tree.

peter
(margaret)

john christine jennifer

(barbara) (frank) (simon)

sally andrew sarah carol

(rachel) (david)

trevor nicholas

Week 9 Lecture Notes page 12 of 12

B219 Intelligent Systems

We can represent the information contained in the family

tree via two predicates married(X,Y) and
child_of(X,Y).

Thus our prolog database would contain facts of the

following form

married(peter,margaret).
married(john,barbara).

child_of(john,peter).
child_of(christine,peter).
child_of(jennifer,peter).

child_of(john,margaret).
child_of(christine,margaret).
child_of(jennifer,margaret).
.
.
etc.

Week 9 Lecture Notes page 13 of 13

B219 Intelligent Systems

SOME SIMPLE PREDICATES

parent_of(X,Y) :- child_of(Y,X).

grandchild_of(X,Y) :- child_of(X,A) , child_of(A,Y).

siblings(X,Y) :- child_of(X,A) , child_of(Y,A) , not(X = Y).

sister_of(X,Y) :- siblings(X,Y) , female(X).

brother_of(X,Y) :- siblings(X,Y) , male(X).

Week 9 Lecture Notes page 14 of 14

B219 Intelligent Systems

Consider the query:

Is nicholas a descendent of peter ?

A descendent is anyone that is a child, grandchild, great-

grandchild, great-great-grandchild, ... , and so on.
How might we define a general predicate
descendent_of(X,Y) ?

We make use of the following simple observation

X is a descendent of Y if one of X's parents is also a
descendent of Y.
This translates directly into the (recursive) Prolog clause
descendent_of(X,Y) :- child_of(X,A) ,
descendent_of(A,Y).

Week 9 Lecture Notes page 15 of 15

B219 Intelligent Systems

What is the appropriate TERMINATING CONDITION ?

The recursion stops when we reach a direct descendent.

Our final definition is thus

descendent_of(X,Y) :- child_of(X,Y).
descendent_of(X,Y) :- child_of(X,A) ,
descendent_of(A,Y).

Week 9 Lecture Notes page 16 of 16

B219 Intelligent Systems

Searching

Problems are solved by searching among alternative

choices

Examples:
- Find a route to get to the city from Murdoch (the
freeway is closed!)

- Decide on the next move in a game of chess

Typically, we have an initial scenario (state) and a goal

(solution state)

We consider a number of alternative steps (strategies) and

select one

This process is repeated until (hopefully) the solution is

arrived at

In AI, this aspect of intelligent behaviour is known as

problem solving by state space search

Week 9 Lecture Notes page 17 of 17

B219 Intelligent Systems

Problem Solving by State Space Search

The states in a problem domain consist of the initial state,

the goal state and all possible intermediate states

Together, they form the state space for a particular

problem
Examples:
In a game of chess, each legal configuration of the board is
a state and the players move around in the state space

Success in solving a problem depends on coming up with

an appropriate representation scheme for the states

Week 9 Lecture Notes page 18 of 18

B219 Intelligent Systems

State space graph

In computer science, a graph is a collection of nodes

connected by links (arcs)

Graphs are used to represent state spaces for problem

solving

Consider the game of noughts and crosses

Given any board situation (configuration), a player can

only make a finite number of moves

Week 9 Lecture Notes page 19 of 19

B219 Intelligent Systems

Starting with an empty board, each board configuration

can be represented as a node

The links of the graph represent legal moves from one

board configuration to another

These nodes thus correspond to different states of the

game board - known as a state space graph

Think of a representation scheme (a data structure)

for this state space
How many nodes will the state space graph consist
of? (answers at the end of lecture notes)

Week 9 Lecture Notes page 20 of 20

B219 Intelligent Systems

As another example, consider diagnosing a mechanical

fault in a car

It is possible to construct a state-space graph for this more

complicated problem

Let each node represent a state of partial knowledge about

the car’s mechanical problems

The process of examining the symptoms of the fault and

inducing its cause may be thought of as searching through
states of increasing knowledge

A problem solver can diagnose car trouble by searching for

a path through this graph that is consistent with the
symptoms of a particular defective car

State space search may be used to approach practically

any problem

Week 9 Lecture Notes page 21 of 21

B219 Intelligent Systems

How intelligent is searching?

Search provides a framework for automating problem

solving

Simple exhaustive search of a large space is impractical

It fails to capture the substance of intelligent activity

Humans do not use exhaustive search

Eg,
The chess player only examines moves that experience has
shown to be effective

The doctor does not require tests that are not somehow
indicated by the symptoms at hand

Human problem solving seems to be based on some

judgemental rules

Week 9 Lecture Notes page 22 of 22

B219 Intelligent Systems

Heuristics - “rules of thumb”

Rules based on experience often guide our search to those

portions of the state space that somehow seem promising

These are known as heuristics (rules of thumb).

heuristics comes from heuriskein (Greek - to discover)

A heuristic is a strategy for selectively searching a problem

space or reducing the size of the problem space

What common heristics can you think of in a game

of noughts and crosses?

heuristics are not fool-proof - but should be effective

“most of the time”

The greatest contribution of AI in problem solving is the

introduction of heristics in searching

State space search gives us a means of formalising the

problem-solving process

Heuristics allow us to infuse that formalism with

intelligence

Week 9 Lecture Notes page 23 of 23

B219 Intelligent Systems

Putting things in perspective -

So far we’ve been introduced to predicate calculus and

Prolog.

They provide a means of describing objects and relations

in a problem domain

Inference rule modus ponens

P→Q
P
----------
Q

allows us to infer new knowledge from these descriptions.

These inferences define a space that is searched to find a

problem solution

Week 9 Lecture Notes page 24 of 24