PROLOG. First simple Prolog Program. Basic elements of Prolog. Clause. NSSICT/CH/Nov., 2012.

Transcription

1 PROLOG Prolog is a programming language for symbolic, n-numeric computations. It is specially well suited for solving problems that involve objects and relation between objects. First simple Prolog Program Use an editor to input the following program named family: parent( pam, bob ). parent( tom, bob ). parent( tom, liz ). parent( bob, ann ). parent( bob, pat ). parent( pat, jim ). The program developed a relation as the family tree in fig. 1. pam bob tom liz Enter the IF-Prolog environment, where you can see the prompt?-, get the Prolog program by enter consult(family). ann pat Then you can have query on the family relation as follows: Answer from Prolog:?- parent ( bob, pat ). yes?- Study the following I-O carefully: jim figure 1 A family tree. Input parent ( liz, pat ). parent ( tom, ben ). parent ( X, liz). parent ( bob, X ). parent ( X, Y). Output X = tom X = ann; X = pat X = pam Y = bob; X = tom Y = bob; X = tom Y = liz; parent(y, jim), parent(x, Y)... X = bob Y = pat Basic elements of Prolog Clause. i. A Prolog program consists of clauses. Each clause terminates with a period (.). Each of these clauses declares one fact, e.g. the parent-child relation. i In general, a relation is defined as the set of all its instances. PROLOG page 1

2 Rules. i. It specifies things that are true if the same condition is satisfied. e.g. To formulate the logical statement, X and Y, Y is an offspring of X if X is a parent of Y. The following Prolog clause is used. i Each rule have : ( means for all ) offspring (Y, X) :- parent (X, Y). a) condition part (on RHS as body ). b) conclusion part (on LHS as head ). Two more examples i. X and Y, X is the mother of Y if X is a parent of Y and X is a female. Formulate the statement by the following PROLOG statements, mother(x, Y) :- parent(x, Y), female(x). X and Y, X is a sister of Y if (1) both X and Y have the same parent, and (2) X is a female. Formulate the statement by the following PROLOG statements, sister( X, Y) :- parent ( Z, X), parent ( Z, Y), female ( X). Recursive rule definition. Defining a rule based on a definition of itself defined before. e.g. X and Z, X is a predecessor of Z if X is a parent of Z or Y (1) X is a parent of Y, and (2) Y is a predecessor of Z. ( means there exists, means such that ) Formulate the logical statement as predecessor ( X, Z) :- parent ( X, Z). predecessor ( X, Z) :- parent ( X, Y), predecessor ( Y, Z). PROLOG page 2

3 Here is a complete program family: parent( pam, bob). parent( tom, bob). parent( tom, liz). parent( bob, ann). parent( bob, pat). parent( pat, jim). female( pam). male( tom). male( bob). female( liz). female( ann). female( pat). male( jim). offspring( Y, X) :- parent( X, Y). mother( X, Y) :- parent( X, Y), female( X). grandparent( X, Z) :- parent( X, Y), parent( Y, Z). sister( X, Y) :- parent( Z, X), parent( Z, Y), female(x), different( X, Y). predecessor( X, Z) :- parent( X, Z). predecessor( X, Z) :- parent( X, Y), predecessor( Y, Z). % Pam is a parent of Bob % Pam is female % Tom is male % Y is an offspring of X if % X is a parent of Y % X is the mother of Y if % X is a parent of Y and % X is female % X is a grandparent of Z if % X is a parent of Y and % Y is a parent of Z % X is a sister of Y if % X and Y have the same parent and % X is female and % X and Y are different % Rule pr1 : X is predecessor of Z % Rule pr2 : X is predecessor of Z How does Prolog answer questions? --- Backtracking To answer a question, Prolog tries to satisfy all the goals. ( To satisfy a goal means to demonstrate the goal logically follows from the facts and rules in the program.) Prolog backtracks to the original goal in order to try an alternative way to derive the top goal. e.g. Given the question for the program family:?- predecessor ( tom, pat). 1st : X = tom, Z = pat 2nd : Rule 1 t true. Backtrack rule 2. 3rd : Match with parent (tom, bob). 4th : Recursive search for predecessor ( bob, pat). 5th : match with rule 1, i.e. parent ( bob, pat). ** Answer found ----> yes. PROLOG page 3

4 The complete execution trace is shown in fig. 2. by rule pr1 parent(tom, pat) predecessor(tom, pat) figure 2 Execution trace Declarative and Procedural meaning of programs by rule pr2 parent(tom, Y) predecessor(y, pat) The declarative meaning is concerned with the relations defined by the program, i.e. determining WHAT the output of the program is. The procedural meaning is concerned with the relations actually evaluated by the Prolog system, i.e. determining HOW the output is obtained. SYNTAX AND MEANING Data objects Constants (i.e. atoms and number) data objects i. Strings can consist of the following characters: simple objects structure upper-case letters A, B,..., Z lower-case letters a, b,..., z digits 0, 1, 2,..., 9 special characters such as + - * / < > = :. & _ ~ atoms constants numbers variables Atoms can be constructed in 3 ways: Strings of letters. starting with a lower-case letter. e.g. x y, miss_jones Figure 3 Data objects in Prolog Strings of special characters. without predefined meaning e.g. the string :- cant be used. Strings of characters. enclosed in single quotes. e.g. 'Mom', 'Sarah Jones' i Numbers in Prolog Integer: to Real: t used very much, only decimal point form is used Variables i. Starting with an upper-case letter or an underscored character. e.g. X, Result, _x23 PROLOG page 4

5 i The lexical scope of variable name is one clause, i.e. if the same name occurs in two clauses, it signifies two different variables. Structures i. Structured objects are objects that have several components. The components themselves can, in turn, be structures. i e.g. date( Day, may, 1983). iv. The figure in fig. 4 shows the relations of points, segments and triangles. v. To formulate in Prolog: P1 = point( 1, 1) P2 = point( 2, 3) S = seg( point( 1, 1), point( 2, 3)) T = triangle( point( 4, 2), point( 6, 4), point( 7, 1)) vi. The corresponding tree representation is shown in fig P2 = (2,3) (4, 2) (6, 4) P1 = (1,1) (7, 1) Figure 4 Some simple geometric objects T P1 = point S = seg 1 1 point point T = triangle point point point Figure 5. Tree representation of the objects in Figure 4. MATCHING Given 2 terms, we say that they match if : i. they are identical, or the variables in both terms can be instantiated to objects in such a way that after the substitution of variables by these objects the terms become identical. Thus, matching is a process that takes as input two terms and checks whether they match. PROLOG page 5

6 The general rules to decide whether two terms, S and T, match are as follows: i. If S and T are constants, then S and T match only if they are the same object. If S is a variable and T is anything, then they match, and S is instantiated to T. Conversely, if T is a variable then T is instantiated to S. i If S and T are structures then they match only if a) S and T have the same principal functor, and b) all their corresponding components match. The resulting instantiation is determined by the matching of the components. e.g. Defining structures for recognizing horizontal and vertical line segments. vetical( seg( point( X, Y1), point( X, Y2))). horizontal( seg( point( X1, Y), point( X2, Y))). Conjunction and Disjunction In general, a question to the Prolog system is a list of goals separated by commas. A comma between goals thus detes the conjunction of goals (AND) Prolog also accepts the disjunction of goals (OR). It is lower in order of precedence, and deted by separated with the semicolon. e.g. translate( Number, Word) :- Number = 1, Word = one; Number = 2, Word = two; Number = 3, Word = three. *** Example: monkey and banana A Monkey is at the door and the banana is hang on from the ceiling the room. The state of the world is determined by The position of monkey in the room. Is the monkey on the box or on the floor? The position of the box. Does the monkey have the banana? Four types of movement by the monkey: grasp banana, climb box, push box, walk around Sample Prolog program to find the solution. % move( State1, Move State2): making Move in State1 results in State2; % a state is represented by a term: % state( MonkeyHorizontal, MonkeyVertical, BoxPosition, HasBanana) move( state( middle, onbox, middle, hast), % Before move grasp, % Grasp banana state( middle, onbox, middle, has) ). % After move move( state( P, onfloor, P, H), climb, state( P, onbox, P, H) ). % Climb box PROLOG page 6

7 move( state( P1, onfloor, P1, H), push( P1, P2), state( P2, onfloor, P2, H) ). move( state( P1, onfloor, B, H), walk( P1, P2), state( P2, onfloor, B, H) ). % Push box from P1 to P2 % Walk from P1 to P2 % canget( State): monkey can get banana in State canget( state( _, _, _, has) ). % can 1 : Monkey already has it canget( State1) :- % can 2 : Do some work to get it move( State1, Move, State2), % Do something canget( State2). % Get it w Given the initial state to see if there is a solution as follows,?- canget( state( atdoor, onfloor, atwindow, hast)). state( atdoor, onfloor, atwindow, hast) walk( atdoor, P2) state( P2, onfloor, atwindow, hast) climb backtrack push( P2, P2 ) P2 = atwindow state( atwindow, onbox, atwindow, hast) No move possible state( P2, onfloor, P2, hast) climb state( P2, onbox, P2, hast) grasp P2 = middle state( middle, onbox, middle, has) Figure 6 The monkey s search for the banana. The search starts at the top de and proceeds downwards, as indicated. Alternative moves are tried in the left-to-right order. Backtracking occurred once only. Danger of indefinite looping Considering the following clause in a program: p :- p. The question?- p. will cause Prolog entering an indefinite loop. Ather example of indefinite looping i. Reorder the Monkey and Banana thus the walk clause appears first. PROLOG page 7

8 Then the execution of our original goal of the previous section,?- canget( state( atdoor, onfloor, atwindow, hast)). would cause an indefinite looping. (Why? The monkey will only walk around.) Program variations through reordering of clauses and goals. Consider the four versions of the predecessor program. pred1( X, Z) :- pred2( X, Z) :- parent( X, Z). parent( X, Y), pred1( X, Z) :- pred2( Y, Z). parent( X, Y), pred2( X, Z) :- pred1( Y, Z). parent( X, Z). pred3( X, Z) :- pred4( X, Z) :- parent( X, Z). pred4( X, Y), pred3( X, Z) :- parent( Y, Z). pred3( X, Y), pred4( X, Z) :- parent( Y, Z). parent( X, Z). All pred1, pred2 and pred3 can reach a solution. The pred4 is hopeless. LIST The list is a simple data structure widely used in n-numeric programming. e.g. [ann, tennis, tom, skiing] A list consists of two things i. the first term, called the head of the list. the remaining part of the list, called the tail. The head can be any Prolog object; the tail has to be a list. In If-Prolog, a list can be regarded as an empty list or a structure whose functor is dot., and that has two arguments: the head and the tail. Thus, the general principle for structuring data objects in Prolog also applies to lists of any length. It can be illustrated by the following example. e.g.?- List1 = [a,b,c], List2 = '.'(a, '.'(b, '.'(c, []))). List1 = [a,b,c] List2 = [a,b,c]?- Hobbies = '.'( tennis, '.'( music, [])), Hobbies = [ skiing, food], L = [ ann, [ tennis, music], tom, [skiing, food]]. Hobbies = [ tennis, music] Hobbies = [ skiing, food] L = [ ann, [ tennis, music], tom, [skiing, food]] PROLOG page 8

9 Prolog provides ather tational extension, the vertical bar, which separates the head and the tail. The tation is L = [a Tail] Operations on lists include i. checking whether an object is an element of a list, i.e. membership. concatenation of two lists, (Unions of sets) i adding or deleting an object to or from a list. iv. checking whether a list is a sublist of ather. v. generate permutate of a list Membership member( X, L). where X is an object and L is a list. The goal member( X, L) is true if X occurs in L. Example Truth value member( b, [ a, b, c]) member( b, [ a, [b, c]]) member( [b, c], [a, [b, c]]) The relationship of member would be, X is a member of L if either (1) X is the head of L, or (2) X is the member of the tail of L Thus to formulate the statement in Prolog, member( X, [X Tail]). member( X, [Head Tail]) :- member( X, Tail). Concatenation True False True conc( L1, L2, L3). where L1 and L2 are two lists and L3 is their concatenation. Example Truth value conc( [a,b], [c,d], [a,b,c,d]) conc( [a,b], [c,d], [a,b,a,c,d]) True False Defining in Prolog conc( [], L, L). conc( [X L1], L2, [X L3]) :- conc( L1, L2, L3). e.g.?- conc( [a, [b, c], d], [a, [], b], L). L = [a, [b, c], d, a, [], b]?- conc( L1, L2, [a, b, c]). L1 = [] L2 = [a, b, c]; L1 = [a] L2 = [b, c]; PROLOG page 9

10 L1 = [a, b] L2 = [c]; L1 = [a, b, c] L2 = [];?- Redefine member1 using conc as member1( X, L) :- conc(_, [X, _], L). Adding an item To add an item to a list, it is easiest to put the new item in front of the list so that resulting list becomes. Thus it is defined as, [X L] where X is the new object and L is original list. add( X, L, [X L]). Deleting an item del( X, L, L1). where L is the original list, X is the object to be deleted, L1 is the resulting list. There are two cases, i. X is the head of the list. The result is simply the tail. X is in the tail. The result is deleted from the tail (recursive), add the present head. Definition in Prolog. del( X, [X Tail], Tail). del( X, [Y Tail], [Y Tail1]) :- del( X, Tail, Tail1). e.g.?- del( a, [a, b, a, a], L). L = [b, a, a]; L = [a, b, a]; L = [a, b, a];?- del( a, L, [1, 2, 3]). L = [a, 1, 2, 3]; L = [1, a, 2, 3]; L = [1, 2, a, 3]; L = [1, 2, 3, a];?- PROLOG page 10

11 In general, the operation of inserting X at any place in some list List giving BiggerList can be defined by the clause: insert( X, List, BiggerList) :- del( X, BiggerList, List). Sublist sublist( L1, L2). where L1 is the sublist of L2. Example Truth value sublist( [c,d,e], [a,b,c,d,e]) sublist( [c,e], [a,b,c,d,e]) The relation can be formulated as: S is a sublist of L if (1) L can be decomposed into 2 lists, L1 and L2, and (2) L2 can be decomposed into 2 lists, S and L3. Thus, in Prolog sublist( S, L) :- conc( L1, L2, L), conc( S, L3, L2). True False e.g.?- sublist( S, [a,b,c]). Permutation S = []; S = [a]; S = [a, b]; S = [a, b, c]; S = [b];... permutation( L1, L2). where L2 is a permutation of L1 and vice versa. To formulate the relation, depending on the first list, there are two cases: i. The first list is empty. The second list must also be empty. The first list is t empty. The first list has the form [X L], and a permutation of such a list can be constructed: first premute L obtaining L1 and then insert X at any position into L1. To formulate in Prolog, permutation( [], []). permutation( [X L], P) :- permutation( L, L1), insert( X, L1, P). Operator tation For arithmetic operations, say 2 * a + b * c. PROLOG page 11

12 Prolog handles it as ordinary clause +( *( 2, a), *( b, c)). Nevertheless, Prolog allows both tations. Prolog program can define new operators as infix ones in special kinds of clauses, sometimes called directives. In IF-PROLOG, the operator has can be defined by the directive: :- op( 600, xfy, has). It tells Prolog that we want to use has as an operator, whose precedence is 600 and its type is xfy, i.e. infix. e.g. Program can define has and supports which allows clauses like which are equivalent to peter has information. floor supports table. has( peter, information). supports( floor, table). REM. Three operator types: Infix. e.g. a + b. Prefix. e.g. +( a, b). Postfix. e.g. (a, b)+. Notation of x, y and f in the operator definition, f indicates the position of the operator. x represents an argument whose precedence must be strictly lower than that of the operator. y represents an argument whose precedence is lower or equal to that of the operator Arithmetic Prolog has the following basic arithmetic operation. +, -, *, /, div and mod (integer division and modulo) The evaluation of an arithmetic operation is forced by the predefined operator, is. e.g.?- X = X = yes?- X is X = 3. yes.?- Relational operators: >, <, >=, =<, =:=, =\= PROLOG page 12

13 The set of predefined operators are follows :- op( 1200, xfx, ':-'). :- op( 1200, fx, [:-,?-]). :- op( 1100, xfy, ';'). :- op( 1000, xfy, ','). :- op( 700, xfx, [=, is, <, >, =<, >=, =\=, =:=]). :- op( 500, yfx, [+, -]). :- op( 500, fx, [+, -, t]). :- op( 400, yfx, [*, /, div]). :- op( 300, xfx, mod). Example Result 2277*37 > yes =:= yes = A = B + 2 A = 2 B = 2 born( Name, Year), Year > = 1950, The names of people born between 1950 & 1960 Year < = e.g. Given two positive integers, X and Y, their greatest common divisor D, can be found according to 3 cases: i. if X = Y, D = X, if X < Y, D = the greatest common divisor of X and Y-X. i if Y < X, D = the greatest common divisor of Y and X-Y. To formulate in Prolog: gcd( X, X, X). gcd( X, Y, D) :- X < Y, Y1 is Y - X, gcd( X, Y1, D). gcd( X, Y, D) :- Y < X, X1 is X - Y, gcd(x1, Y, D). e.g. Finding the length of a list, length( [], 0). length( [_ Tail], N) :- length( Tail, N1), N is 1 + N1. Example : Example programs using structures The family in fig. 7 can be stored in the database by the clause. e.g. family( person( tom, fox, date( 7, may, 1950), works(bbc,15520)), person( ann, fox, date( 9, may, 1951), unemployed), [ person( pat, fox, date( 5, may, 1973), unemployed), person( jim, fox, date( 5, may, 1973), unemployed)]). PROLOG page 13

14 family( person( david, brown, date( 7, may, 1950), works(bbc,15520)), person( mary, brown, date( 9, may, 1951), unemployed), [ person( may, brown, date( 5, may, 1973), unemployed), person( john, brown, date( 5, may, 1973), unemployed)]). husband( X) :- family( X, _, _). wife( X) :- family( _, X, _). child( X) :- family( _, _, Children), member( X, Children). % X is a husband % X is a wife % X is a child member( X, [X L]). member( X, [Y L]):- member( X, L). exists( Person) :- husband( Person); wife( Person); child( Person). % Any person in the database dateofbirth( person( _, _, Date, _), Date). salary( person( _, _, _, works( _, S)), S). % Salary of working person salary( person( _, _, _, unemployed), 0). % Salary of unemployed total( [], 0). % Empty list of people total( [Person List], Sum) :- salary( Person, S), % S : salary of first person total( List, Rest), % Rest : sum of salaries of others Sum is S + Rest. Write down the answer to the following queries: Query exists( person( Name, Surname, _, _) ). Answer child(x), dateofbirth( X, date( _, _, 1981) ). wife( person( Name, Surname, _, works( _, _) ) ). exists( person( Name, Surname, date( _, _, Year), unemployed) ), Year < exists( Person), dateofbirth( Person, date( _, _, Year)), Year < 1950, salary( Person, Salary), Salary < PROLOG page 14

15 family( Husband, Wife, Children), total(husband, Wife Children], Income). CONTROLLING BACKTRACKING ~ CUT Studying the following sample program, f( X, 0) :- X < 3. % Rule 1 f( X, 2) :- 3 =< X, X < 6. % Rule 2 f( X, 4) :- 6 =< X. % Rule 3 When the following question is posed,?- f(1,y), 2 < Y. Y becomes instantiated to 0 and violate the second condition input in question, However, Prolog tries through backtracking two useless alternatives X Figure 7 A double-step function Preventing useless backtracking, the technique of cut is used, with the symbol! indicating it. For the previous example, the program can be changed to, f( X, 0) :- X < 3,!. f( X, 2) :- X < 6,!. f( X, 4). For the question f( 1, Y), 2 < Y after finding the second condition does t hold at the first rule, it tries backtracking and then the backtracking is cut. rule 1 Y = 0 f(1, Y), 2 < Y rule 2 Y = 2 rule 3 Y = 4 1 < 3, 2< 0 3 1, 1 < 6, 2 < 2 6 1, 2 < 4 CUT 2 < 0 e.g. Computing maximum max( X, Y, X) :- X >= Y. max( X, Y, Y) :- X < Y. Figure 8 At the point marked CUT we already kw that the rules 2 and 3 are bound to fail. These two rules are mutually exclusive, thus formulate in a more ecomic way, max( X, Y, X) :- X >= Y,!. max( X, Y, Y). PROLOG page 15

16 e.g. Single-solution membership member( X, [X L]). member( X, [Y L]) :- member( X, L). This is n-deterministic : if X occurs several times then any occurrence can be found. The following is a deterministic one, member( X, [X L]) :-! member( X, [Y L]) :- member( X, L). To clarify this definition, consider a clause of the form: H :- B 1, B 2,..., B m,!,..., B n. Let us assume that this clause was invoked by a goal G that matches H. i. At the moment that the cut is encountered, the system has already found some solution of the goals B 1,..., B m becomes frozen and all possible remaining alternatives are discarded. The parent goal G w becomes committed to this clause: any attempt to match G with the head of some other clause is precluded. i Backtracking will still be possible within the goal list after!. Negation as Failure That something is t true can be said in Prolog by using a special goal, fail, which always fails, thus forcing the parent goal to fail. e.g. To formulate Mary likes all animals but snakes. likes( mary, X) :- snake( X),!, fail. likes( mary, X) :- animal(x). e.g. Defining the difference relation. If Goal succeeds then t (Goal) fails otherwise t (Goal) succeeds. t( P) :- P,!, fail; true. Problems with cut and negation Advantages of using cut: i. With cut we can often improve the efficiency of the program. The idea is to explicitly tell Prolog t to try other alternatives because they are bound to fail. Using cut we can specify mutually exclusive rules; so we can express rules of the form: a) if condition P then conclusion Q, b) otherwise conclusion R Disadvantage of using cut: Lose the valuable correspondence between the declarative and procedural meaning of programs. PROLOG page 16

17 Remark: If there is cut in the program, we can change the order of clauses and goals, and this will only affect the efficiency or termination of the program, t the declarative meaning. On the other hand, with using cut, a change in order of clause will change the declarative meaning. 1. p :- a, b p :- c % means p <==> (a & b) v c 2. p :- a,!, b p :- c % means p <==> (a & b) v (~a & c) Predefined IF/PROLOG procedures Sample Program: :- op(100, xfy, reports_to). iptool :- write('to finish, type in: stop.\n'), write('type in terms like: X reports_to Y.\n'), repeat, write(:),tab(1), read(term), interpreter(term). interpreter(stop) :-!. interpreter(x reports_to Y) :-!, asserta(x reports_to Y), fail. interpreter(_) :-!, write('"x reports_to Y." expected, try again:\n'), fail. read - It reads the next term from the CURRENT input stream. write - It writes term(s) to the current output streaming according to current operator declarations, with quotes ( ) omitted. repeat i. It always succeeds. Remember that IF/Prolog returns to the last successful solved clause and attempts to find ather solution. i If repeat was the last successful clause in a procedure in effect it has an infinite number of solutions and an infinite sequence of backtracking choices is generated. iv. To exit from a loop caused by repeat, the following clauses must either succeed, or a cut must be executed to that the backtrack point at repeat is removed. PROLOG page 17