cs774 (Prasad)L4ListProcessing1 List processing in Prolog

List Structures List containing elements a, b, and c (in that order): [a, b, c] [a | [b, c]] [a, b | [c] ] cs774 (Prasad)L4ListProcessing2 element separator cons operator

(cont’d) List containing elements a, b, and c (in that order):.(a,.(b,.(c, []))) cs774 (Prasad)L4ListProcessing3 special list functor for cons empty list

Membership Test: Scheme vs Prolog (define (member e lis) (cond ((null? lis) #f) ((eq? e (car lis)) #t ) (else (member e (cdr lis))))) > (member 'a '(1 21 2)) #f member(E, [E|_]). member(E, [_|L]) :- member(E,L). ?- member(1,[12,1,3]). true ; cs774 (Prasad)L4ListProcessing4

Cartesian Product cs774 (Prasad)L4ListProcessing5 cart([],_,[]). cart([HA|TA],B,AB) :- pair(HA,B,C), cart(TA,B,D), append(C,D,AB). pair(_,[],[]). pair(HA,[HB|TB],[(HA,HB)|R]) :- pair(HA,TB,R).

Permutations [a,b] ->permute-> [[a,b], [b,a]] [a,b,c] ->permute-> [[c,a,b],[a,c,b],[a,b,c]] [[c,b,a],[b,c,a],[b,a,c]] cs774 (Prasad)L4ListProcessing6

cs774 (Prasad)L4ListProcessing7 permutation([],[]). permutation([H|T],P) :- permutation(T,Q), insert(H,Q,P). insert(H,Q,[H|Q]). insert(H,[S|R],[S|T]) :- insert(H,R,T). /*Generate all permutations through backtracking */ ?-setof(X,permutation([1,2,3],X),R). R = [[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]].

Collection Predicates p(a,b). p(b,b). p(c,b). p(e,d). p(a,d). p(a,a). /* collect all values of X for each Y */ ?-setof(X,p(X,Y),S). Y = a, S = [a] ; Y = b, S = [a, b, c] ; Y = d, S = [a, e]. cs774 (Prasad)L4ListProcessing8

(cont’d) p(a,b). p(b,b). p(c,b). p(e,d). p(a,d). p(a,a). /* collect all values of Y for which an X exists */ ?-setof(Y,X^p(X,Y),S). S = [a, b, d] ; cs774 (Prasad)L4ListProcessing9 ordered, no dups

(cont’d) p(a,b). p(b,b). p(c,b). p(e,d). p(a,d). p(a,a). /* collect all values of X for each Y */ ?-bagof(X,p(X,Y),S). Y = a, S = [a] ; Y = b, S = [a, b, c] ; Y = d, S = [e, a]. cs774 (Prasad)L4ListProcessing10

(cont’d) p(a,b). p(b,b). p(c,b). p(e,d). p(a,d). p(a,a). /* collect all values of Y for which an X exists */ ?-bagof(Y,X^p(X,Y),S). S = [b, b, b, d, d, a]. cs774 (Prasad)L4ListProcessing11 unordered, dups present

(cont’d) p(a,b). p(b,b). p(c,b). p(e,d). p(a,d). p(a,a). /* collect all values of X for which a Y exists, in order*/ ?-findall(X,p(X,Y),S). S = [a, b, c, e, a, a]. /* Free variables existentially quantified by default. */ ?-findall(Y,X^p(X,Y),S). S = [b, b, b, d, d, a]. cs774 (Prasad)L4ListProcessing12

Operators Normal syntax of a term : prefix form f(g(x,Y),5) Normal syntax of an expression with operators : infix form x * Y + 5 Besides operator name and arity, the following information is necessary to disambiguate expressions containing operators. Associativity Precedence Fixity (prefix/infix/postfix) cs774 (Prasad)L4ListProcessing13

INFIX x f y : Right-associative y f x : Left-associative x f x : Non-associative PREFIX f x : Non-associative f y : Right-associative POSTFIX x f : Non-associative y f : Left-associative Operator Declaration :- op(precedence, type, name). Examples: :- op( 1200, xfx, [ :-, --> ]). :- op(500, yfx, [ +, - ]). :- op( 500, fx, [ +, - ]). :- op(900, fy, [ \+ ]). Higher precedence class => Lower binding strength cs774 (Prasad)L4ListProcessing14

| 1200 |xfx |-->, :- | | 1200 | fx |:-, ?- | | 1150 | fx |dynamic, discontiguous, initialization, mod- | | | |ule_transparent, multifile, thread_local,| | | |volatile | | 1100 |xfy |;, | | | 1050 |xfy |->, op*-> | | 1000 |xfy |, | | 900 | fy |\+ | | 900 | fx |~ | | 700 |xfx |, | | \=, \==, is | | 600 |xfy |: | | 500 | yfx |+, -, /\, \/, xor | | 500 | fx |? | | 400 | yfx |*, /, //, rdiv, >, mod, rem | | 200 |xfx |** | | 200 |xfy |^ | |__200_|_fy__|+,_-,_\________________________________________|_ Table 4.1: Predefined system operators cs774 (Prasad)L4ListProcessing15

Examples : “Term Disambiguation” p; q; r p :- q :- r :- :- p \+ \+ p a + b + c a ^ b ^ c a – b / c p;(q;r) Illegal \+ (\+ p) (a + b) + c a ^ ( b ^ c) a – ( b / c ) cs774 (Prasad)L4ListProcessing16

Exercise p :- a, b -> c ; d. p :- (a, (b -> c ; d)). vs p :- (((a, b) -> c) ; d). q :- b -> c ; d, a. q :-(b -> (c ; (d, a))). vs q :-((b -> c) ; (d, a)). cs774 (Prasad)L4ListProcessing17