Declarative Programming Lists in PROLOG Autumn 2014.

Presentation on theme: "Declarative Programming Lists in PROLOG Autumn 2014."— Presentation transcript:

Declarative Programming Lists in PROLOG Autumn 2014

Example - Fibonacci numbers Fibonacci numbers are defined as follows: 0, if i = 0 F(i) = 1,if i = 1 F(i–1) + F(i – 2), if i > 1

Example - Fibonacci numbers Fibonacci numbers are defined as follows: 0, if i = 0 F(i) = 1,if i = 1 F(i–1) + F(i – 2), if i > 1 fibonacci(0,0). fibonacci(1,1). fibonacci(X,R) :- X1 is X – 1, X2 is X – 2, fibonacci(X1,R1), fibonacci(X2,R2),R is R1+R2.

Example - Fibonacci numbers We can try to write a predicate that computes both values F(i) and F(i – 1) fibonacci(1,1,0). fibonacci(X,R1,R2) :- X1 is X – 1,fibonacci(X1,R2,R3),R1 is R2+R3.

Example - Fibonacci numbers If we want, we can now add a predicate just for computing of F(i) fibonacci(1,1,0). fibonacci(X,R1,R2) :- X1 is X – 1,fibonacci(X1,R2,R3),R1 is R2+R3. fibonacci(0,0). fibonacci(X,R) :- fibonacci(X,R,R1).

Example - Fibonacci numbers What, if we want something like this: 0, if i = 0 S(i) = 1,if i = 1 i*S(0)+ (i–1)*S(1)+...+2S(i–1), if i > 1

Example - Fibonacci numbers What, if we want something like this: 0, if i = 0 S(i) = 1,if i = 1 i*S(0)+ (i–1)*S(1)+...+2S(i–1), if i > 1 A predicate that computes all the values S(0)...S(i) at once could be useful...

Lists - the idea nilrepresents the empty list list(a,nil)represents list a list(a,list(b,nil)) represents list a,b list(a,list(b,list(c,nil))) represents list a,b,c...

Example - list of Fibonacci numbers fibonacci(0,list(0,nil)). fibonacci(1,list(1,list(0,nil))). fibonacci(X,list(R, list(R1,list(R2,Z)))) :- X1 is X – 1, fibonacci(X1,list(R1,list(R2,Z))), R is R1+R2.

Lists - predefined notation []represents the empty list.(a,[])represents list a.(a,.(b,[])) represents list a,b.(a,.(b,.(c,[]))) represents list a,b,c...

Lists - predefined notation There is also a special shortcut notation for lists in PROLOG.(a,.(b,.(c,[]))) can also be written as [a,b,c]

Lists - useful operations Often it is useful to divide non-empty list into the first element (head) and the remaining list (tail) head(.(H,_),H). tail(.(_,T),T).

Lists - useful operations There are special predicate “|” that does not require the use of “.” notation head([H|_],H). tail([_|T],T).

Lists - useful operations Any fixed number of initial elements can be accessed first_7([F1,F2,F3,F4,F5,F6,F7|_],F1,F2,F3,F4,F5,F6,F7).

Lists (from Clocksin) Lists are the same as in other languages (such as ML) in that a list of terms of any length is composed of list cells that are ‘consed’ together. The list of length 0 is called nil, written []. The list of length n is.(head,tail), where tail is a list of length n-1. So a list cell is a functor ‘.’ of arity 2. Its first component is the head, and the second component is the tail.

Lists - examples (from Clocksin) nil.(a, nil).(a,.(b, nil).(a,.(b,.(c,.(d,.(e. nil))))).(a,b) (note this is a pair, not a proper list).(a, X) (this might be a list, or might not!).(a,.(b, nil)),.(c, nil))

Lists can be written as trees anil a b a b c d e ab aX a b a

Lists - PROLOG syntax Nil is written []. The list consisting of n elements t 1, t 2, …,t n is written [t 1, t 2, …,t n ]..(X,Y) is written [X|Y] [X|[]] is written [X] The term.(a,.(b,.(c,Y))) is written [a,b,c|Y]. If Y is instantiated to [], then the term is a list, and can be written [a,b,c|[]] or simply [a,b,c].

Lists - Exercise 1 Identify the heads and tails of these lists (if any): [a, b, c] [a] [] [[the, cat], sat] [[the, cardinal], [pulled, [off]], [each, [plum, coloured], shoe]

Lists - Exercise 1 Identify the heads and tails of these lists (if any): a[b, c] [a] [] [[the, cat], sat] [[the, cardinal], [pulled, [off]], [each, [plum, coloured], shoe]

Lists - Exercise 1 Identify the heads and tails of these lists (if any): [a, b, c] a[] [] [[the, cat], sat] [[the, cardinal], [pulled, [off]], [each, [plum, coloured], shoe]

Lists - Exercise 1 Identify the heads and tails of these lists (if any): [a, b, c] [a] [] (not a list, so doesn’t have head and tail. nil is a constant) [[the, cat], sat] [[the, cardinal], [pulled, [off]], [each, [plum, coloured], shoe]

Lists - Exercise 1 Identify the heads and tails of these lists (if any): [a, b, c] [a] [] [the, cat] [sat] [[the, cardinal], [pulled, [off]], [each, [plum, coloured], shoe]

Lists - Exercise 1 Identify the heads and tails of these lists (if any): [a, b, c] [a] [] [[the, cat], sat] [the, cardinal] [pulled, [off]], [each, [plum, coloured], shoe]

Lists - Exercise 2 For each pair of terms, determine whether they unify, and if so, to which terms are the variables instantiated? [X, Y, Z][john, likes, fish] [cat][X|Y] [X,Y|Z][mary, likes, wine] [[the,Y]|Z][[X,answer], [is, here]] [X, Y, X][a, Z, Z] [[X], [Y], [X]][[a], [X], [X]]

Lists - Exercise 2 A variable may be instantiated to any term. X YZ mary likes wine[] [mary, likes, wine][X,Y|Z]

“member” predicate member(X, [X|T]). member(X, [H|T]) :- member(X, T). Examples: ?- member(john, [paul, john]). ?- member(X, [paul, john]). ?- member(joe, [marx, darwin, freud]). ?- member(foo, X).

“member” predicate member(X, [X|T]). member(X, [H|T]) :- member(X, T). member(X, [X|_]). member(X, [_|T]) :- member(X, T). Notice T isn’t ‘used’ Notice H isn’t ‘used’

Exercise 3 Here is a mystery predicate. What does it do? mystery(X, A, B) :- member(X, A), member(X, B). ?- mystery(a, [b, c, a], [p, a, l]). ?- mystery(b, [b, l, u, e], [y, e, l, l, o, w]). ?- mystery(X, [r, a, p, i, d], [a, c, t, i, o, n]). ?- mystery(X, [w, a, l, n, u, t], [c, h, e, r, r, y]).

Length of a list - Exercise 4 Naïve method: length([], 0). length([H|T], N) :- length(T, NT), N is NT + 1.

Length of a list - Tail recursion Procedures such as length/2: length([], 0). length([H|T], N) :- length(T, NT), N is NT + 1. often crash when processing large lists, even with a few thousand elements. This happens because in the recursive rule, the recursive call is not the last goal on the rhs and so may need to be backtracked into. For each call, Prolog must store the choice points in a memory stack of fixed size.

Length of a list - Tail recursion No matter how large this memory stack is, it will overflow if the list is long enough. This is less likely to happen if the recursive call is the last goal on the rhs - because within each call there is no choice point for it. Procedures in which recursive calls appear as the last goal in the rule(s) are known as tail recursive. There is a way of re-writing procedures such as length/2 to make them tail recursive.

Length of a list - Tail recursion The accumulator algorithm for the length of a list is: Initialise the current sub-total, LengthSoFar, to 0. To find the length of L while L is non-empty do for each element of L remove the element and add 1 to LengthSoFar when L is empty set Length = LengthSoFar.

Length of a list - Exercise 4 Tail-recursive method: length(L, N) :- acc(L, 0, N). /* acc(List, LengthSoFar, Length) */ acc([], A, A). acc([H|T], A, N) :- A1 is A + 1, acc(T, A1, N).

Length of a list - Exercise 4 ?- length([apple, pear], N). ?- length([alpha], 2). ?- length(L, 3). Modify length to give a procedure sum such that sum(L,N) succeeds if L is a list of integers and N is their sum.

“concat” predicate - Exercise 5 Write a predicate for concatenating 2 lists, i.e. ?-concat([a,b,c,d],[1,2,3],Result). Result = [a,b,c,d,1,2,3] ? Yes

“reverse” predicate - Exercise 6 Write a predicate for reversing a list, i.e. ?-reverse([a,b,c,d],Result). Result = [d,c,b,a] ? Yes

“sublist” predicate - Exercise 7 Write a predicate that checks whether a given list is a sublist (in the same order) of another, i.e. ?-sublist([a,b,c,d],[a,c]). Yes ?-sublist([a,b,c,d],[c,a]). No

“setify” predicate - Exercise 8 Write a predicate that removes duplicate elements from a given list, i.e. ?-setify([a,b,a,a,c,b,a,d],Result). Result = [a,b,c,d] ? Yes

“split” predicate - Exercise 9 Write a predicate that splits a given list of numbers into lists of odd and even numbers, i.e. ?-split([1,2,3,4,5,5,6,8,7,9,2,3],R1,R2). R1 = [1,3,5,5,7,9,3], R2 = [2,4,6,8,2] ? Yes

Similar presentations