1 / 17

List processing in Prolog

List processing in Prolog. t.k.prasad@wright.edu http://www.knoesis.org/tkprasad/. List Structures. List containing elements a, b, and c (in that order): [a, b , c] [a | [b, c]] [a, b | [c] ]. element separator. cons operator. (cont’d).

bethan
Download Presentation

List processing in Prolog

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. List processing in Prolog t.k.prasad@wright.edu http://www.knoesis.org/tkprasad/ L4ListProcessing

  2. List Structures • List containing elements a, b, and c (in that order): [a, b, c] [a | [b, c]] [a, b | [c] ] element separator cons operator L4ListProcessing

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

  4. 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 ; L4ListProcessing

  5. Cartesian Product • 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). L4ListProcessing

  6. 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]] L4ListProcessing

  7. 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]]. L4ListProcessing

  8. 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]. L4ListProcessing

  9. (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] ; ordered, no dups L4ListProcessing

  10. (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]. L4ListProcessing

  11. (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]. unordered, dups present L4ListProcessing

  12. (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]. L4ListProcessing

  13. 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) L4ListProcessing

  14. 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 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 L4ListProcessing

  15. | 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 L4ListProcessing

  16. Examples : “Term Disambiguation” • p; q; r • p :- q :- r • :- :- p • \+ \+ p • a + b + c • a ^ b ^ c • a – b / c • p;(q;r) • Illegal • Illegal • \+ (\+ p) • (a + b) + c • a ^ ( b ^ c) • a – ( b / c ) L4ListProcessing

  17. 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)). L4ListProcessing

More Related