1 / Types and Programming Languages

Transcription

1 1 / Types and Programming Languages

2 2 / 65 Outline Control Flow During Execution Tree Traversal A Detailed Trace Search Space Analysis Modelling Equations and Operations Lists

3 3 / 65 Outline Control Flow During Execution Tree Traversal A Detailed Trace Search Space Analysis Modelling Equations and Operations Lists

4 4 / 65 Aside: Depth-first Traversal Recall that the values contained in the leaf nodes of a complete ordered binary tree can be printed in order by the following algorithm: Definition in_order( tree(value,left,right) ) = { if is_leaf(tree(value,left,right)) then print(value) else { in_order(left); in_order(right) } }

5 5 / 65 Continued... Similarly, the leaves of an unordered complete binary tree can be searched for a particular value by the following algorithm: Definition search( tree, my_value) = { if isnull(tree) then return; // not found else if tree.value = my_value then { print(value); HALT; } else { search(tree.left,my_value); search(tree.right,my_value); } }

6 6 / 65 Relevance to Prolog Prolog uses a depth-first backtracking algorithm in order to search for solutions to queries. In this framework, a node in a tree corresponds to the goal that is currently under consideration, and its children are determined by the clauses in the program (considered in order) that can resolve against this goal.

7 7 / 65 Example F1: edge(v1, v2). F2: edge(v1, v3). F3: edge(v2, v3). F4: edge(v2, v4). R1: can_reach(x, X). R2: can_reach(x,z) :- edge(x,y), can_reach(y,z). Question: What will Prolog output in response to the following query??- can_reach( v1, X ), write(x), fail.

8 8 / 65 A Trace of:?- can_reach( v1, X ), write(x), fail. Step 0: Create Goal List - In this step, Prolog forms the query into a goal list. Here the (initial) goal list is: [can_reach( v1, X ), write(x), fail] Step 1: Goal Selection - In this step, Prolog selects the first goal from the goal list. That is, the goal can_reach(v1, X) is selected. If the goal list is empty, then halt. We will represent the selection of the first goal g1 in a list of goals as follows: [g1 g2, g3, g4,... ]

9 9 / 65 A Trace of:?- can_reach( v1, X ), write(x), fail. Step 2: Clause Selection - Prolog selects a candidate clause from the Prolog program that it will attempt to resolve against can_reach(v1, X). In this case, the first clause selected is the fact can_reach(x, X). Step 3: Variable Renaming - Prolog will rename the variables in the selected clause to ensure that the unique namespace property is preserved. For example, after renaming, the selected clause might be can_reach(x 100, X 100). Step 4: Unification - Next Prolog attempts to unify the clause with the goal. In this case, the clause and goal unify under the substitution σ = [X := v1, X100 := v1]. This substitution is now applied to: (1) the entire goal list as well as the currently selected goal, and (2) the entire selected clause.

10 10 / 65 A Trace of:?- can_reach( v1, X ), write(x), fail. Step 5: Deductive Step - Prolog now performs a deductive step by applying the resolution rule to the goal and clause. In this case the resulting clause is the empty clause. In the general case, the resulting clause is placed on the front of the goal list and the algorithm jumps to step 1. Placing the empty clause on the front of the goal list yields: [write(v 1), fail] Step 6: The next goal selected is write(v1). By definition, this goal succeeds and outputs the value v1.

11 11 / 65 A Trace of:?- can_reach( v1, X ), write(x), fail. Step 7: Next, the fail goal is processed. Again, by definition, this goal fails, and this failure causes Prolog to back up in its search for a solution to the query. Prolog uses a standard depth-first backtracking algorithm when searching for alternate solution candidates. First, Prolog will check to see if the write(v1) goal could have been satisfied in an alternate manner (i.e., by resolving with a different clause). After checking this, Prolog will back up further and check to see if the can_reach(v1, X) goal could have been satisfied differently. This causes Prolog to select the rule R2. Step 8: Clause Selection - Prolog selects the clause R2 as a candidate for resolution.

12 12 / 65 A Trace of:?- can_reach( v1, X ), write(x), fail. Step 9: Variable Renaming - The variables in R2 are renamed: can_reach(x101,z101) :- edge(x101,y101), can_reach(y101,z101). Step 10: Unification - Next Prolog attempts to unify the clause with the goal. In this case, the clause and goal unify under the substitution σ = [X101 := v1, Z 101 := X]. This substitution is now applied to: (1) the entire goal list as well as the currently selected goal, and (2) the entire selected clause. Thus we now have: Goal List: [can_reach(v 1, X) write(x), fail] Clause: can_reach(v1,x) :- edge(v1,y101), can_reach(y101,x).

13 13 / 65 A Trace of:?- can_reach( v1, X ), write(x), fail. Step 11: Deductive Step - Prolog now performs a deductive step by applying the resolution rule to the goal and clause. In this case the resulting clause is edge(v1, Y 101), can_reach(y 101, X) This result is placed on the front of the goal list. The new goal list is now: [edge(v1, Y 101), can_reach(y 101, X), write(x), fail] Step 12: Goal Selection - [edge(v 1, Y 101) can_reach(y 101, X), write(x), fail] Step 13: Clause Selection - The fact F1 is selected. Step 14: Variable Renaming - There are no variables to be renamed in F1.

14 14 / 65 A Trace of:?- can_reach( v1, X ), write(x), fail. Step 15: Unification - Under the substitution σ = [Y 101 := v2] the current goal edge(v1, Y 101) will unify with the fact edge(v1, v2). This substitution is now applied to the goal list yielding: [edge(v1, v2) can_reach(v2, X), write(x), fail] Step 16: Deductive Step - Prolog now performs a deductive step by applying the resolution rule to the goal and clause. In this case the resulting clause is the empty clause. Thus the goal list shrinks to: [can_reach(v 2, X), write(x), fail] Step 17: Goal Selection - [can_reach(v 2, X) write(x), fail]

15 15 / 65 A Trace of:?- can_reach( v1, X ), write(x), fail. Step 18: Clause Selection - The rule R1 is selected. Step 19: Variable Renaming - The variables are renamed yielding can_reach(x 102, X 102). Step 20: Unification - Under the substitution σ = [X := v2, X102 := v2] the current goal can_reach(v2, X) will unify with the fact can_reach(x 102, X 102). This substitution is now applied to the goal list yielding [can_reach(v 2, v 2) write(v 2), fail]. Step 21: Deductive Step - Prolog now performs a deductive step yielding: [write(v 2), fail]

16 A Trace of:?- can_reach( v1, X ), write(x), fail. As usual, the write goal will succeed causing v2 to be output.then the fail goal will fail causing Prolog to backtrack. We now have two very interesting questions: Question1 : Where does Prolog backtrack to? Question2 : Which is the next clause selected? Answer1 : Prolog will back-up to the previous goal list. The goal list that existed prior to the last unification step. Goal List: [can_reach(v 2, X) write(x), fail] Answer2 : With respect to the clause selection in the previous pass, Prolog will continue where it left off searching for another clause which can be a candidate for resolution with the current goal. Thus the next clause selected will be: Clause: can_reach(x, Z ) : edge(x, Y ), can_reach(y, Z ). 16 / 65

17 17 / 65 A Trace of:?- can_reach( v1, X ), write(x), fail. Step 22: Variable Renaming - The variables in the selected clause are renamed yielding: can_reach(x103,x103) :- The current goal list is: edge(x103,y103), can_reach(y103,z103). [can_reach(v 2, X) write(x), fail] Step 23: Unification - Under the substitution σ = [X103 := v2, Z 103 := X] the current goal can_reach(v2, X) will unify with can_reach(x103, Z 103). This substitution is now applied to the goal list leaving it unchanged.

18 18 / 65 A Trace of:?- can_reach( v1, X ), write(x), fail. Step 24: Deductive Step - Prolog now performs a deductive step yielding: edge(v2, X), can_reach(y 103, X) This result is placed on the front of the goal list and the algorithm continues with a goal selection step, etc..

19 19 / 65 A Symbolic Summary of the Trace The program under consideration and a given query: edge(v1,v2). edge(v1,v3). edge(v2,v3). edge(v2,v4). can_reach(x, X). can_reach(x,z) :- edge(x,y), can_reach(y,z).?- can_reach( v1, X ), write(x), fail.

20 20 / 65 A Symbolic Summary of the Trace Search Space and Search Order v1 v1 v1 v2, v2 v2 v1 v2, v2 v3, v3 v3 v1 v2, v2 v3, v3? v1 v2, v2 v4, v4 v4 v1 v2, v2 v4, v4? v1 v2, v2? v1 v3, v3 v3 v1 v3, v3? v1? Output: v1 v2 v3 v4 v3

21 21 / 65 A Graphical Summary of the Trace V1 V1 V2 V3 V3? V2 V3 V4 V3 V4??

22 22 / 65 Discussion A query ending with the fail goal, will cause Prolog to exhaustively search the entire solution space of a program in an effort to satisfy the query. Such an exhaustive search will only terminate if the domain(s) being searched is finite. During an exhaustive search, multiple solutions to a query may be found. Such solutions may even result in the same variable bindings.

23 23 / 65 Continued... In the case of the graph reachability problem the solutions to can_reach(v1, X) can be satisfied as follows: v1 can reach v1 through zero edge traversals v1 can reach v2 via edge(v1, v2) v1 can reach v3 via edge(v1, v3) and edge(v2, v3) v1 can reach v4 via edge(v1, v2) and edge(v2, v4) v1 can reach v3 via edge(v1, v3) Notice that the order of the solutions is relevant and is well-defined in Prolog.

24 24 / 65 Different Implementations of can_reach can_reach1(x,x). can_reach1(x,z) :- edge(x,y), can_reach1(y,z). can_reach2(x,x). can_reach2(x,z) :- can_reach2(y,z), edge(x,y). can_reach3(x,z) :- edge(x,y), can_reach3(y,z). can_reach3(x,x). can_reach4(x,z) :- can_reach4(y,z), edge(x,y). can_reach4(x,x).

25 25 / 65 Question Given: edge(v1,v2). edge(v1,v3). edge(v2,v3). edge(v2,v4). For the following queries, what will be the response from Prolog with respect to each implementation of can_reach??- can_reach( v2, v2 ).?- can_reach( X, v2 ).?- can_reach( v2, Y ).?- can_reach( X, X ).?- can_reach( X, Y ).?- can_reach( v1, v3 ).?- can_reach( X, v2 ), fail.?- can_reach( v2, Y ), fail.?- can_reach( X, X ), fail.?- can_reach( X, Y ), fail.

26 26 / 65 For Example edge(v1,v2). edge(v1,v3). edge(v2,v3). edge(v2,v4). can_reach1(x,x). can_reach1(x,z) :- edge(x,y), can_reach1(y,z).?- can_reach1( v2, v2 ).?- can_reach1( X, v2 ).?- can_reach1(v2, Y ).?- can_reach1( X, X ).?- can_reach1( X, Y ).?- can_reach1( v1, v3 ).?- can_reach1( X, v2 ), fail.?- can_reach1( v2, Y ), fail.?- can_reach1( X, X ), fail.?- can_reach1( X, Y ), fail. Similar instances can be created for can_reach2, can_reach3, and can_reach4.

27 27 / 65 Analysis I can_reach1 can_reach2 can_reach3 can_reach4?- can_reach( v2, v2 ). true true true?- can_reach( X, v2 ). X = v2 X = v2 X = v1?- can_reach( v2, Y ). X = v2 X = v2 X = v3?- can_reach( X, X ). X = _G236 X = _G236 X = _G236?- can_reach( X, Y ). X = _G236 X = _G236 X = v1 Y = _G236 Y = _G236 Y = v3 Question : Do we really want to allow X = _G236 as a valid answer to our query? How can we prevent this?

28 28 / 65 Analysis II can_reach1 can_reach2 can_reach3 can_reach4?- can_reach( v1, v3 ). true true true?- can_reach( X, v2 ), fail. false false?- can_reach( v1, Y ), fail. false false?- can_reach( X, X ), fail. false false?- can_reach( X, Y ), fail. false false Note that a response of false means that the search space is finite. Question : What would happen if the graph contained a cycle?

29 29 / 65 Different Implementations of plus nat_a(0). nat_a(s(x)) :- nat_a(x). nat_b(s(x)) :- nat_b(x). nat_b(0). plus1a(0,y,y) plus1a(s(x),y,s(z)) plus2a(s(x),y,s(z)) plus2a(0,y,y) plus1b(0,y,y) plus1b(s(x),y,s(z)) plus2b(s(x),y,s(z)) plus2b(0,y,y) :- nat_a(y). :- plus1a(x,y,z). :- plus2a(x,y,z). :- nat_a(y). :- nat_b(y). :- plus1b(x,y,z). :- plus2b(x,y,z). :- nat_b(y).

30 30 / 65 Termination and Search Space Analysis plus1a plus2a plus1b plus2b?- plus(x, s(0), s(s(s(0))) ). defined defined defined defined?- plus(s(0), Y, s(s(s(0))) ). defined defined defined defined?- plus(x, Y, s(s(s(0))) ). defined defined defined defined?- plus(x, Y, Z ). unbounded number undefined undefined undefined of solutions

31 31 / 65 Outline Control Flow During Execution Tree Traversal A Detailed Trace Search Space Analysis Modelling Equations and Operations Lists

32 32 / 65 Remark In general, care must be taken when defining computations whose sub-computations can involve an exhaustive search of an infinite domain or involve multiple logical variables that can be instantiated to an infinite number of values. Furthermore, in this context great care should be taken when dealing with queries. Especially queries that require multiple solutions to be found or involve the fail predicate. However, when the above conditions can be contained (e.g., at most one unbound variable per query, and only queries for which solutions exist), then Prolog programs can be easily written from a declarative perspective. That is, one simply writes properties in the form of rules or facts that describe the relationships in which we are interested.

33 33 / 65 The trick is to recognize when such benign conditions exist. In the following examples, we will assume friendly queries That is, queries that do not involve multiple uninstantiated variables and do not require the system to produce multiple solutions either as a result of hitting the enter key or the fail predicate. (The above statement is slightly inaccurate for the upcoming examples, but acceptable for this discussion). In the following examples, we focus on the computational power of logic programming rather than its search idiosyncrasies. That is, we shall predominantly focus on expressing search trees that contain the solution in which we are interested. We will not worry so much about whether or not Prolog s search mechanism will actually be able to find the solution. Nevertheless, the programs presented are correct in the sense that Prolog will find solutions to queries when they exist.

34 Built-in Predicates Operator/Predicate Description Example = Explicit Unification X = Y \= Unification failure X \= Y not Failure to satisfy goal not(x = Y ) (use sparingly) =< Less-than or equal-to X =< Y < Less-than X < Y Many other operators and predicates exist, use help menu to see what is available for a given version of Prolog. Note that ordering operators are not defined on terms. 34 / 65

35 Some Basic Prolog Types Type Description Example integer Standard Integers 234 string Standard Strings hello world constant Constant Terms (lower-case ids) hello 35 / 65

36 36 / 65 Complex Terms as Parameters The idea of having a complex term in the parameter of the head of a rule may seem backwards from other programming paradigms. However, this is just a notational short-cut. % a more standard treatment of formal parameters. natural(0). natural(x) :- natural(y), X = s(y). % denotes unification % versus Prolog s treatment of formal parameters natural(0). natural(s(x)) :- natural(x).

37 37 / 65 Modelling the Equation: (x + 1) y = x y + y Multiplication natural(0). natural(s(x)) :- natural(x). plus(0,y,y) :- natural(y). plus(s(x),y,s(z)) :- plus(x,y,z). times(0,y,0) times(s(x),y,z) :- natural(y). :- times(x,y,xy), plus(xy,y,z).

38 38 / 65 Modelling the Equation: x (n+1) = x n x Issue: 0 0 = 1? or 0 0 = undefined? Exponentiation times(0,y,0) times(s(x),y,z) :- natural(y). :- times(x,y,xy), plus(xy,y,z). exp(s(n), 0, 0) :- natural(n). % Base case: 0 (n+1) = 0 exp(0, X, s(0)) :- natural(x). % Base case: X 0 = 1 exp(s(n),x, Result) :- exp(n,x,temp), times(x,temp,result).

39 39 / 65 Modelling the Equation: fact(n) = n fact(n 1) Factorial times(0,y,0) times(s(x),y,z) :- natural(y). :- times(x,y,xy), plus(xy,y,z). factorial(0, s(0)). factorial(s(n), Result) :- factorial(n,temp), times(s(n), Temp Result).

40 40 / 65 Mod : a y + z = x where z < y Modulus % note that the definition below assumes times(+,-,-). % Note that there is an error in the book wrt % Prologs search algorithm mod(x,y,z) :- times(y,a,ay), lt(z,y), plus(ay,z,x).

41 41 / 65 mod(x, y) = mod(x y, y) Modulus - an alternate definition mod(x,y,x) :- lt(x,y). mod(x,y,z) :- plus(y,mxy,x), mod(mxy,y,z). % or mod(x,y,x) :- lt(x,y). mod(x,y,z) :- plus(mxy,y,x), mod(mxy,y,z).

42 42 / 65 Modelling the Equation: gcd(x, y) = gcd(y, x mod y) Greatest Common Divisor % will this work? Can the rules be rearranged? gcd(x,y,gcd) :- mod(x,y,z), gcd(y,z,gcd). gcd(x, 0,X) :- lt(0,x).

43 43 / 65 Outline Control Flow During Execution Tree Traversal A Detailed Trace Search Space Analysis Modelling Equations and Operations Lists

44 44 / 65 List Notation(s) Definition Formal Object Cons pair syntax Element Syntax [] [] [].(a, []) [a []] [a].(a,.(b, [])) [a [b []]] [a, b].(a,.(b,.(c, []))) [a [b [c []]]] [a, b, c].(a, X) [a X] [a X].(a,.(b, X)) [a [b X]] [a, b X]

45 45 / 65 List Basics list([]). list([x Xs]) :- list(xs). % is this antecedent necessary? natural_list([]). natural_list([x Xs]) :- natural(x),natural_list(xs). length([], 0). length([x Xs], s(n)) :- length(xs,n). member(x,[x Xs]). member(x,[y Ys]) :- member(x,ys). % select(x,hasxs,onelessxs). select(x, [X Ys],Ys). select(x,[y Ys],[Y Zs]) :- select(x,ys,zs).

46 46 / 65 Top-down versus Bottom-up Remark There are two ways to recursively construct a list. In the bottom-up approach one begins with an initial value and adds elements to that value. In the top-down approach one begins with an uninstantiated variable and adds values to that variable and then finally the variable is instantiated to an initial value.

47 Problem Continued... Construct a list containing 10 occurrences of the constant b. top_down([],0). top_down([b Xs], N) :- N1 is N 1, top_down(xs,n1).?- top_down(xs,10), write(xs),nl. bottom_up(acc,acc,0). bottom_up(xs,acc,n) :- N1 is N 1, bottom_up(xs, [b Acc], N1).?- bottom_up(xs, [], 10), write(xs),nl. 47 / 65

48 48 / 65 The Accumulator An accumulator is a parameter that is used to accumulate the result of a recursive computation as it progresses towards its base case. When the base case is reached, the accumulated value generally will hold the result of the entire computation. In the base case, this result is then transferred via unification to the argument corresponding to the return value. The general functionality of an accumulator can be described as follows: accumulator( [], Acc, Acc). accumulator( [X Xs], Acc, Result) :-..., accumulator(xs, f(acc,x),result).

49 49 / 65 Tail Recursion Definition In the body of a function/predicate, a recursive call is tail recursive if no computations need to be performed after the recursive call. Operationally, what this means is that when the base case is reached the computation is completed (i.e., the answer that you have at the base case is the answer for the original function/predicate call). In other words, you are computing your answer on the way to the base case, and when the base case is reached the computation is completed. There is a strong correspondence between tail recursive definitions and iterative loops. This enables optimizing compilers to efficiently compile tail recursive function/predicate definitions.

50 50 / 65 Summing a List of Integers % bottom-up and tail-recursive sum1([],sum,sum). sum1([x Xs],Sum,Result) :- Sum1 is Sum + X, sum1(xs,sum1,result). % tail recursive?- sum1([1,2,3],0,s), write(s),nl. % top-down sum2([],0). sum2([x Xs],Sum) :- sum2(xs,sum1), Sum is Sum1 + X. % non-tail recursive?- sum2([1,2,3],s), write(s),nl.

51 51 / 65 Counting the Even Numbers in a List % top-down count_even1([],0). count_even1([x XS],Count) :- count_even1(xs,count1), 0 =:= X mod 2, Count is Count count_even1([x XS],Count1) :- count_even1(xs,count1), 1 =:= X mod 2.?- count_even1([1,2,3,4,5,6,7,8,9,0],x). Remark The symbol =:= is used to denote arithmetic equivalence.

52 52 / 65 Continued... % tail-recursive and bottom-up count_even2([],acc,acc). count_even2([x XS],Acc,Count) :- 0 =:= X mod 2, Acc1 is Acc + 1, count_even2(xs,acc1,count). count_even2([x XS],Acc,Count) :- 1 =:= X mod 2, count_even2(xs,acc,count).?- count_even2([1,2,3,4,5,6,7,8,9,0],0,x).

53 53 / 65 More List Predicates % Top-down construction % Rule of thumb: arguments in head should % be more complex than in the body. append([],ys,ys). append([x Xs],Ys,[X Zs]) :- append(xs,ys,zs). prefix([],ys). prefix([x Xs],[X Ys]) :- prefix(xs,ys). suffix(xs,xs). suffix(xs,[y Ys]) :- suffix(xs,ys).

54 54 / 65 Prefixes and Suffixes prefix suffix sublist(xs,ys) :- prefix(ps,ys), suffix(xs,ps). prefix suffix sublist(xs,ys) :- suffix(ps,ys), prefix(xs,ps).

55 55 / 65 A Recursive Definition of Sublist sublist(xs,ys) :- prefix(xs,ys). sublist(xs,[y Ys]) :- sublist(xs,ys). As Bs Xs % prefix of suffix in terms of append sublist(xs,asxsbs) :- append(as,xsbs,asxsbs), append(xs,bs,xsbs). % suffix of prefix in terms of append sublist(xs,asxsbs) :- append(asxs,bs,asxsbs), append(as,xs,asxs).

56 56 / 65 Reversing the Element Order in a List reverse([],[]). reverse([x Xs],Zs) :- reverse(xs,ys),append(ys,[x],zs). % using an accumulator and tail-recursion. reverse(xs,ys) :- aux_reverse(xs,[],ys). aux_reverse([],acc,acc). aux_reverse([x Xs],Acc,Zs) :- aux_reverse(xs,[x Acc],Zs).?- reverse([1,2,3],ys).?- reverse(xs,[3,2,1]).

57 Problem An Experiment Write a predicate that makes a copy of a list one element at a time. % Notice that the elements in the copied list will have % their order reversed. copy1(xs,ys) :- aux_copy1(xs,[],ys). aux_copy1([],acc,acc). aux_copy1([x Xs],Acc,Zs) :- aux_copy1(xs,[x Acc],Zs). copy2([],[]). copy2([x Xs],[X Ys]) :- copy2(xs,ys). 57 / 65

58 58 / 65 Analysis of copy1 In copy1 the elements are added to an accumulator whose initial value is a ground term that corresponds to the base case. With every recursive call to copy 1, the accumulator acquires more values until finally, when the base case is reached, the value of the accumulator is transferred (through unification) to the result variable. Notice that the accumulator term is more complex in the body of the rule than it is in the head of the rule (i.e., [X Acc] versus Acc). Conceptually, this can be understood as building up the result value in a bottom-up fashion. That is, one begins with the base value and successively adds elements to this value.

59 59 / 65 Analysis of copy2 In copy2 the elements are added to the head of a list whose tail is an uninstantiated variable whose value finally becomes the ground term [] in the base case. Notice that the result term is more complex in the head of the rule than it is in the body of the rule (i.e., [X Ys] versus Ys). Conceptually this can be understood as building up the value in a top-down fashion. That is, one adds values to an uninstantiated variable and then finally instantiates the variable to the base value.

60 60 / 65 Element Deletion % deleting all occurrences of X from a list % Note that the rule order between the second and % third rule is crucial here. How can this be fixed? delete([],x, []). delete([x Xs],X,Ys) :- delete(xs,x,ys). delete([y Xs],X,[Y Ys]) :- delete(xs,x,ys).

61 61 / 65 Continued... % a solution using the predicate not delete([],x, []). delete([x Xs],X,Ys) :- delete(xs,x,ys). delete([y Xs],X,[Y Ys]) :- not(y = X), delete(xs,x,ys). % a solution using the not-unifiable symbol delete([],x, []). delete([x Xs],X,Ys) :- delete(xs,x,ys). delete([y Xs],X,[Y Ys]) :- Y \= X, delete(xs,x,ys).

62 62 / 65 Accumulator-based List Reversal % Using an accumulator - and reversing the list order. delete(xs,x,ys) :- aux_delete(xs,x,ys,[]). % base case, transfer accumulated value to result argument. aux_delete([],x, Acc,Acc). aux_delete([x Xs], X, Ys, Acc) :- aux_delete(xs,x,ys,acc). aux_delete([y Xs], X, Ys, Acc) :- not(y = X), aux_delete(xs,x,ys,[y Acc]).

63 63 / 65 A Sorting Specification sort(xs,ys) :- permutation(xs,ys), ordered(ys). select(x,[x Ys],Ys). select(x,[y Ys],[Y Zs]) :- select(x,ys,zs). permutation([],[]). permutation(xs,[z Ys]) :- select(z,xs,zs), permutation(zs,ys). % the =< operator denotes the less-than-or-equal-to operator. ordered([]). ordered([x]). ordered([x1, X2 Xs]) :- X1 =< X2, ordered([x2 Xs]).

64 64 / 65 Insertion Sort sort([x Xs],Zs) :- sort(xs,ys), insert(x,ys,zs). sort([],[]). insert(x,[],[x]). insert(x,[y Ys],[Y Zs]) :- X > Y, insert(x,ys,zs). insert(x,[y Ys],[X, Y Ys]) :- X =< Y.

65 65 / 65 Quicksort quicksort([x Xs],Ys) :- partition(xs,x,littles,bigs), quicksort(littles,ls), quicksort(bigs,bs), append(ls,[x Bs],Ys). quicksort([],[]). partition([],y,[],[]). partition([x Xs],Y,[X Ls],Bs) :- X =< Y, partition(xs,y,ls,bs). partition([x Xs],Y,Ls,[X Bs]) :- X > Y, partition(xs,y,ls,bs).