Prolog Programming - Input/Output in Prolog

Transcription

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 Week 9 Lecture Notes page 1 of 1

2 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

3 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

4 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

5 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

6 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

7 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

8 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

9 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

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

11 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

12 MORE ON RECURSION Example 2 : A simple family tree. peter (margaret) john (barbara) christine (frank) jennifer (simon) sally andrew (rachel) sarah (david) carol trevor nicholas Week 9 Lecture Notes page 12 of 12

13 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

14 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

15 Consider the query: Is nicholas a descendent of peter? A descendent is anyone that is a child, grandchild, greatgrandchild, 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

16 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

17 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

18 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

19 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

20 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

21 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

22 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

23 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

24 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 fi 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