B219 Intelligent Systems Prolog Programming -...

B219 Intelligent Systems

Week 9 Lecture Notes page 1 of 1

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



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



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.



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.



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]



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



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).



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)



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]



?- 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]



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]



MORE ON RECURSION

Example 2 : A simple family tree.

peter (margaret)

john (barbara)

carolandrew (rachel)

sally

trevor nicholas

christine (frank)

jennifer (simon)

sarah (david)



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.



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).



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).



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).



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



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



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



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)



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



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



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



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

B219 Intelligent Systems Prolog Programming -...

Documents

Transcript of B219 Intelligent Systems Prolog Programming -...