815338A Principles of Programming Languages. Exercise 7 answers

Transcription

1 815338A Principles of Programming Languages. Exercise 7 answers The topic of this exercise is logic programming in Prolog. Prolog programs can be executed at or Task 1. At first we explore making queries in Prolog. We model the following graph consisting of nodes a,b,c,d,e,f,g a f b e c d g by inputting the following facts that define the edges of the graph: edge(a,b). edge(a,e). edge(b,c). edge(b,e). edge(a,f). edge(c,d). edge(d,g). edge(e,f). Write and perform thereafter the queries edge(a,x),write(x),write(' '),fail. edge(x,f),write(x),write(' '),fail. edge(x,y),write(x),write(' '),write(y),nl,fail. The first query prints the nodes that are end nodes of the edges starting from the node a. The second query prints the nodes that are the start nodes of the edges that end to the node f and the third query prints all the edges of the graph. Write a rule path(x,y) to check, whether there is a path from the node X to the node Y in the graph. Test your rule by making queries path(a,x),write(x),write(' '),fail. path(x,f),write(x),write(' '),fail.

2 Answer. When the three first-mentioned queries are made, the following outputs are obtained: b e f // odes that are end nodes of edges from a a e // odes that are start nodes of edges to f a b a e b c b e a f e f c d d g // All the edges We can start determining a rule for path, when we observe that the simplest path is an edge. Thereafter the rule can be defined such that a path consists of an edge and a path from the end node of this edge to the goal node. Hence we get path(x,y):-edge(x,y). path(x,y):-edge(x,z),path(z,y). When we apply this rule by making a query path(a,x), write(x), fail. we get as an answer the nodes b e f c e d g f f. The same node can thus occur several times in the result. Lists are an important part of Prolog programming; the following tasks concern list processing on Prolog. A list is represented with square brackets, the elements separated with commas, as [1,2,3,4], for instance. List can be processed by separating its head and tail as in Haskell denoting [H T]. A couple of examples follow. Prolog contains a built-in function append that appends two lists. A corresponding function could be written as follows: catenate([],x,x). catenate([h T],X,[H L]):- catenate(t,x,l). Appending an empty list to another list does not change the list; this is represented as a fact. The other line defines a rule, according to which the head of the first list is inserted to the result list after the tail has been appended. We could print the result of an example by making a query catenate([1,2,3],[4,5],x),write(x). The next predicate finds out, whether a term is a member of list or not

3 mmber(x,[x T]). mmber(x,[h T]):- mmber(x,t). A negation of a predicate can be produced by using the operator \+ : not_mmber(x,l):- \+ mmber(x,l). Prolog s unification can be used when processing lists; for example the following predicate returns true if the first parameter list is a sublist of the second parameter list and false otherwise: sub_list(s,l):-append(l1,l2,l),append(s,l3,l2). The previous predicate uses Prolog s a built-in function append. Task 2. The following Prolog function partitions2 prints all partitions into two sublists of its parameter list: partition2(x):-append(a,b,x),write(a),write(' '),write(b),nl. partitions2(x):-partition2(x),fail. Test the function and write a function partitions3 that prints all the partitions into three sublists. Answer. In a similar fashion as with partition to two sub lists, we can write a function that partitions a list into three sub lists partition3(x):-append(a,z,x),append(b,c,z),write(a), write(' '),write(b),write(c),nl. partitions3(x):-partition3(x),fail. At first we find two lists A and Z, whose combination results to X. Thereafter, we find two lists B and C, whose combinations results to Z. Hence the lists A,B, and C combined give the list X. If the function partitions3 would be given in the form partitions3(x):-partition3(x). the interpreter would give the first correct triple. When the rule ends with fail, the interpreter is forced to continue applying the rule and we obtain all the possible triples.

4 Task 3. Write a Prolog predicate palindrome that tests if a given list is a palindrome, i.e. the same list when it is read from beginning to end or from end to beginning. (For example [1,2,3,2,1] is a palindrome.) Hint: It might be easiest to write a helper operation to reverse the list and a helper predicate that compares whether two lists are identical. Answer. A list can be reversed with the rule ( käännä is revert in Finnish) kaanna([],[]). kaanna([x Y],Rev):-kaanna(Y,Z),append(Z,[X],Rev). Empty list remains empty when reversed and otherwise a list can be reversed by adding its head to the tail of the reversed list without the head. The unification of Prolog makes the list Rev original list reversed. Following predicate checks, whether two lists contain the same elements ( samat is the same in plural in Finnish): samat([],[]). samat([h T],[H U]):-samat(T,U). Two empty lists are the sama and if the heads of the lists are the same, we compare the tails of the lists. ow we finally can write a predicate to check if a list is a palindrome: palindromi(x):-kaanna(x,y),samat(x,y). Task 4. This task considers lists as sets; hence you can assume that an element appears only once in the list. Write a function intersection(x,y,z) after whose call, the set Z will contain the common elements of lists X and Y. Hint: You can use as a fact that an intersection between any list and an empty list is an empty list. Then you can use the previously presented function mmber to check if the head of the first list is in the second list. According to its result, you obtain two cases to consider. Answer. This task is somewhat more challenging than the previous ones. First we write a predicate to check if X is a member in a list: mmber(x,[x T]). mmber(x,[_ T]):- mmber(x,t). If X is the head of the list, the predicate is true. Otherwise we check the tail of the list. This predicate can be used to form the intersection function: intersection([],x,[]). intersection([x T],Y,[X C]):-mmber(X,Y), intersection(t,y,c). intersection([x T],Y,C):- \+ mmber(x,y), intersection(t,y,c). The first fact tells that the intersection of an empty list with any list is empty. Thereafter, we divide the situation into two cases: If the head of the first list is a member of the

5 second list, the head remains in the result list, and the tail of the result list is attached to the intersection of the tail of the first parameter list and the second parameter list. If, on the other hand, the head of the first parameter list is not a member of the second list, the head does not remain in the result list, and the tail of the result list is attached to the intersection of the tail of the first parameter list and the second parameter list. Task 5. Write Quicksort algorithm q_sort(x,sorted) in Prolog to sort a list. After calling the function, the list Sorted will be the list X sorted. One way to implement the algorithm is to write helper functions to fetch elements smaller than the pivot element from X to one list and elements greater (and equal) than the pivot element from X to another list. These lists can be sorted and appended such that the pivot element comes in between them. Answer. At first we construct the mentioned helper functions: bigger(x,[],[]). bigger(x,[h T],[H T2]):- X<H, bigger(x,t,t2). bigger(x,[h T],T2):- X>=H, bigger(x,t,t2). smaller(x,[],[]). smaller(x,[h T],[H T2]):- X>=H, smaller(x,t,t2). smaller(x,[h T],T2):- X<H, smaller(x,t,t2). The functions take three parameters: the first parameter is the pivot element, the second parameter is the list to be sorted. The third parameter is the result list. The function bigger finds the elements greater or equal to pivot from the list. The head of the parameter list is included if it is greater or equal to the pivot; otherwise it is excluded. The function smaller similarly finds the elements that are smaller than the pivot. When previous operations have been performed, Quicksort can be implemented by the rule: q_sort([],[]). q_sort([h T],Sorted):- smaller(h,t,pieni), bigger(h,t,suuri),q_sort(pieni,vp), q_sort(suuri,op),append(vp,[h],vpp),append(vpp,op,sorted). Empty list is automatically sorted. Otherwise we use the head of the list as the pivot. First, the elements smaller than pivot are gathered into the list Pieni, the elements greater or equal to pivot are gathered into the ist Suuri. The lists are sorted, the pivot is appended to the list of smaller elements, and the lists are combined. The unification mechanism ensures that the sorted list is associated with the result list. You can also find other implementations of Quicksort in Prolog from the Internet.

6 Task 6. Finally we will investigate arithmetic in Prolog by implementing Euclid s algorithm to find the greatest common factor of two positive integers. The algorithm is following: euclid(x,y) 1. if X==Y return X 2. else if X > Y return euclid(x-y,y) 3. else return euclid(y,x) Write a function euclid(x,y,z), after whose call Z is the greatest common factor of X and Y. ote that to bind a result of an arithmetic operation to a variable, one writes X is 5+6. Test your function to compute the greatest common factor of integers and Answer. Algorithm can be implemented in a straight-forward fashion. Write a rule for each alternative case of the algorithm: euclid(x,x,x). euclid(x,y,z):-x>y,x1 is X-Y, euclid(x1,y,z). euclid(x,y,z):-x<y, euclid(y,x,z). When we write the query euclid( , ,x), write(x). we find out that the greatest common factor of the mentioned integers is 22. The linked file H7_Prolog.pl contains the code for the answers.