P ROLOG.

Lists in P ROLOG. Operations and Predicates.

Lists as Sequences, Sets, Bags. Meta Predicates.

Antoni Ligeza

Katedra Automatyki, AGH w Krakowie

2011

Antoni Ligeza Prolog 1/17

References

[1] Ulf Nilsson, Jan Maluszynski: Logic, Programming and Prolog, John Wiley &
Sons Ltd., pdf, http://www.ida.liu.se/ ulfni/lpp

[2] Dennis Merritt: Adventure in Prolog, Amzi, 2004

http://www.amzi.com/AdventureInProlog

[3] Quick Prolog:

http://www.dai.ed.ac.uk/groups/ssp/bookpages/quickprolog/quickprolog.html

[4] W. F. Clocksin, C. S. Mellish: Prolog. Programowanie. Helion, 2003

[5] SWI-Prologs home: http://www.swi-prolog.org

[6] Learn Prolog Now!: http://www.learnprolognow.org

[7] http://home.agh.edu.pl/ ligeza/wiki/prolog

[8] http://www.im.pwr.wroc.pl/ przemko/prolog

Antoni Ligeza Prolog 2/17

Introduction to Lists in Prolog

Lists - basic concepts

z Lists are one of the most important structures in symbolic languages.
z In most of the implementations of P ROLOG lists are standard, build-in structures
and there are numerous operations on them provided as routine predicates.
z Lists can be used to represent
1 sets,
2 sequences,
3 multi-sets (bags), and
4 more complex structures, such as trees, records, nested lists, etc.

Lists - basic notation

A list in P ROLOG is a structure of the form

[t1 , t2 , . . . , tn ]

The order of elements of a list is important; the direct access is only to the first
element called the Head, while the rest forms the list called the Tail.

[Head|Tail]

where Head is a single element, while Tail is a list.

Antoni Ligeza Prolog 3/17

Definition of Lists. Lists as Terms

Lists as Terms
Lists in fact are also terms. A list:

[t1 , t2 , . . . , tn ]

is equivalent to a term defined as follows:

l(t1 , l(t2 , . . . l(tn , nil) . . .))

l/2 is the list constructor symbol and nil is symbolic denotation of empty list.

Lists: Head and Tail

In practical programming it is convenient to use the bracket notation. In order to
distinguish the head and the tail of a list the following notation is used

[H|T].

An example of list matching

1 [H|T] = [a,b,c,d,e]
2 H=a, T = [b,c,d,e]

Antoni Ligeza Prolog 4/17

Some Notes on lists. Unification Variants

List properties
z A list can have as many elements as necessary.
z A list can be empty; an empty list is denoted as [ ].
z A list can have arguments being of:
1 mixed types,
2 complex structures, i.e. terms, lists, etc., and as a consequence
3 a list can have nested lists (to an arbitrary depth)
z a list of k elements can be matched directly against these elements, i.e.
1 [X,Y,Z,U,V] = [a,b,c,d,e]
2 X=a, Y=b, Z=c, U=d, V=e

z first k elements of any list can be matched directly

1 [X,Y,Z|T] = [a,b,c,d,e]
2 X=a, Y=b, Z=c, T=[d,e]

Single-element list
A single-element list is different from its content-element!

foo 6= [foo]

Antoni Ligeza Prolog 5/17

First k elements. The n-th element. Propagation of Substitutions

First k-elements: k = 1, 2, 3

1 [X|_] = [a,b,c,d,e].
2 X=a
3
4 [_,X|_] = [a,b,c,d,e].
5 X=b
6
7 [_,_,X|_] = [a,b,c,d,e].
8 X=c

Take the n-th element

1 take(1,[H|_],H):- !.
2 take(N,[_|T],X):- N1 is N-1, take(N1,T,X).

Propagation of substitutions

1 [X,Y,Z,U] = [a,b,c,d] ?
2 [X,Y,Z,X] = [a,b,c,d] ?
3 [X,Y,Y,X] = [a,U,Q,U] ?

Antoni Ligeza Prolog 6/17

Applications of Lists: Examples

List understanding: three basic possibilities

z as sequences,
z as sets,
z as sets with repeated elements,
When thinking of lists as sets, the order of elements is (read: must be made)
unimportant.

Lists as sets

1 [a,b,c,d,e]
2 [1,2,3,4,5,6,7,8,9]
3 [1,a,2,b,f(a),g(b,c)]

Lists as multi-sets (bags, collections) or sequences

1 [a,b,c,d,e,a,c,e]
2 [1,1,2,3,4,5,6,7,8,9,2,7,1]
3 [1,a,2,b,f(a),g(b,c),b,1,f(a)]

Repeated elements can occur.

Antoni Ligeza Prolog 7/17

Member/2 and Select/3 Predicates

Member/2
Checking if an item occurs within a list; deterministic version.
1 member(Element,[Element|_):- !.
2 member(Element,[_|Tail]):-
3 member(Element,Tail).

Member/2
Checking if an item occurs within a list; indeterministic version.
1 member(Element,[Element|_).
2 member(Element,[_|Tail]):-
3 member(Element,Tail).

Select/3
Selecting and item from a list indeterministic.
1 select(Element,[Element|Tail],Tail).
2 select(Element,[Head|Tail],[Head|TaiE]):-
3 select(Element,Tail,TaiE).

Antoni Ligeza Prolog 8/17

Lists as Sequences: the Beauty of the Append/3 Predicate

Append/3
The basic use of the append/3 predicate is to concatenate two lists.
1 append([],L,L).
2 append([H|T],L,[H|TL]) :- append(T,L,TL).

Concatenation Test

1 append([a,b],[c,d,e],[a,b,c,d,e]).

Finding Front List

1 append(FL,[c,d,e],[a,b,c,d,e]).
2 FL = [a,b]

Finding Back List

1 append([a,b],BL,[a,b,c,d,e]).
2 BL = [c,d,e]

Antoni Ligeza Prolog 9/17

Append/3 Indeterministic List Decomposition

Indeterministic List Decomposition

1 append(FL,BL,[a,b,c,d,e])
2
3 FL = [],
4 BL = [a,b,c,d,e];
5
6 FL = [a],
7 BL = [b,c,d,e];
8
9 FL = [a,b],
10 BL = [c,d,e];
11
12 FL = [a,b,c],
13 BL = [d,e];
14
15 FL = [a,b,c,d],
16 BL = [e];
17
18 FL = [a,b,c,d,e],
19 BL = [];
20 false.

Antoni Ligeza Prolog 10/17

Basic Recurrent Operations: length, sum, writing a list

Length of a list

1 len([],0).
2 len([_|T],L):-
3 len(T,LT),
4 L is LT+1.

Sum of a list

1 sum([],0).
2 sum([H|T],S):-
3 sum(T,ST),
4 S is ST+H.

Write a list

1 writelist([]):- nl.
2 writelist([H|T]):-
3 write(H),nl,
4 writelist(T).

Antoni Ligeza Prolog 11/17

Putting and Deleting Elements to/form a List

Put X as the first element to L

1 XL = [X|L].

Put X as the k-th element to L

1 putk(X,1,L,[X|L]):- !.
2 putk(X,K,[F|L],[F|LX]):- K1 is K-1, putk(X,K1,L,LX).

Delete one X from L (indeterministic!)

1 del(X,[X|L],L).
2 del(X,[Y|L],[Y|L1]):-
3 del(X,L,L1).

Delete all X from L

1 delall(_,[],[]):- !.
2 delall(X,[H|L],[H|LL]):- X \= H,!, delall(X,L,LL).
3 delall(X,[X|L],LL):- delall(X,L,LL).

Antoni Ligeza Prolog 12/17

Lists and sublists. Nested Lists. Flatten List

A list and a sublist

[1,2,3,4,5,6,7,8,9]
[3,4,5,6]

Checking for a sublist

1 sublist(S,FSL,F,L):- append(F,SL,FSL),append(S,L,SL).

A list and a subsequence

[1,2,3,4,5,6,7,8,9]
[3,5,8]

Checking for subsequence

1 subseq([],_):- !.
2 subseq([H|S],L):- append(_,[H|SL],L),!, subseq(S,SL).

Nested lists. Flatten a list

[1,[2,3],4,[5,[6,7],8],9] [1,2,3,4,5,6,7,8,9]
Antoni Ligeza Prolog 13/17
Lists: some small challenges

Think!
1 N [1,2,3,...,N-1,N],
2 List: [1,2,3,4,5,6,7] all permutations,
3 K, [1,2,3,4,5,6,7] K-element comobinations,
4 Set: [1,2,3,4,5,6,7] all subsets,
5 ExchangeFL: [1,2,3,4,5,6,7] [7,2,3,4,5,6,1],
6 ShiftLCircular: [1,2,3,4,5,6,7] [2,3,4,5,6,7,1],
7 ShiftRCircular: [1,2,3,4,5,6,7] [7,1,2,3,4,5,6,7],
8 Split: [1,2,3,4,5,6,7] [1,3,5,7], [2,4,6],
9 Merge: [1,3,5,7], [2,4,6] [1,2,3,4,5,6,7],
10 Split C=4: [1,2,3,4,5,6,7] [1,2,3],[4],[5,6,7],
11 p1. p2. ... pK. [p1,p2,...,pK].

Think!
z Recursion Iterations,
z Recursion repeat-fail.

Antoni Ligeza Prolog 14/17

Inserting List Element. Permutations.

Insert (indeterministic!). Permutations: insert

1 insert(X,L,LX):- del(X,LX,L).
2
3 perm([],[]).
4 perm([H|T],P):-
5 perm(T,T1),
6 insert(H,T1,P).

Sorted List Definition

1 sorted([]):- !. sorted([_]):- !.
2 sorted([X,Y|T]) :- X =< Y, sorted([Y|T]).

Slow Sort

1 slowsort(L,S):-
2 perm(L,S),
3 sorted(S).

Antoni Ligeza Prolog 15/17

Reverse List. Inverse List

Naive List Reverse

1 reverse([],[]).
2 reverse([X|L],R):-
3 reverse(L,RL),
4 append(RL,[X],R).

Iterative List Inverting: Accumulator

1 inverse(L,R):-
2 do([],L,R).
3 do(L,[],L):-!.
4 do(L,[X|T],S):-
5 do([X|L],T,S).

Accumulator
[a,b,c], [d,e,f,g] [d,c,b,a], [e,f,g]

Antoni Ligeza Prolog 16/17

Lists as Sets: Basic Operations

Set Algebra Operations

1 subset([],_).
2 subset([X|L],Set):-
3 member(X,Set),
4 subset(L,Set).
5 intersect([],_,[]).
6 intersect([X|L],Set,[X|Z]):-
7 member(X,Set),!,
8 intersect(L,Set,Z).
9 intersect([X|L],Set,Z):-
10 not(member(X,Set)),
11 intersect(L,Set,Z).
12 union([],Set,Set).
13 union([X|L],Set,Z):-
14 member(X,Set),!,
15 union(L,Set,Z).
16 union([X|L],Set,[X|Z]):-
17 not(member(X,Set)),!,
18 union(L,Set,Z).
19 difference([],_,[]).
20 difference([X|L],Set,[X|Z]):-
21 not(member(X,Set)),!,
22 difference(L,Set,Z).
23 difference([_|L],Set,Z):- difference(L,Set,Z).

Antoni Ligeza Prolog 17/17