Logic Programming Using Prolog List Operations

Lecture 5
Logic Programming Using Prolog
List Operations
Prolog: Lists
• The Lists are data structures that can be used in different
cases for non-numeric programming.
• Lists are used to store the atoms as a collection.
We will discuss the following topics:

• Representation of lists in Prolog
• Basic operations on prolog such as Insert, delete, update,
append.
• Repositioning operators such as permutation, combination,
etc. Set operations like set union, set intersection, etc.
Fall 2023 Logic Programming 2

Prolog: Lists
• for example, red, green, blue, white, dark. It will be
represented as, [red, green, blue, white, dark].
• The list of elements will be enclosed with square
brackets.
A list can be either empty or non-empty.
• In the first case, the list is simply written as a Prolog
atom, [].
• In the second case, the list consists of two things as given
below:
– The first item, called the head of the list;
– The remaining part of the list, called the tail.

Prolog: Lists
• Now, let us consider we have a list, L = [a, b, c].
• If we write Tail = [b, c] then we can also write the list
L as L = [ a | Tail].
• Here the vertical bar (|) separates the head and tail
parts.
• Valid lists

Basic Operations on Lists
• various operations on prolog lists
list_member(X,L)
list_length(L,N)
Fall 2023
list_insert(X, L, R)Logic Programming 5
List: Membership Operation

List: Length Calculation
• Suppose the predicate name is list_length(L,N).
• If list is empty, then length is 0.
• If the list is not empty, then L = [Head|Tail], then its
length is 1 + length of Tail.
| ?- list_length([a,b,c,d,e,f,g,h,i,j],Len).
Len = 10
List: Delete from List
• Suppose we have a list L and an element X, we have to delete
X from L.
So there are three cases:

• If X is the only element, then after deleting it, it will return
empty list.
• If X is head of L, the resultant list will be the Tail part.
• If X is present in the Tail part, then delete from there
recursively.

• Example
| ?- list_delete(a,[a,e,i,o,u],NewList).
NewList = [e,i,o,u] ?

[mylist_delete].
list_delete(X, [X], []).
list_delete(X,[X|L1], L1).
List_delete(X, [Y|L2], [Y|L1]) :- list_delete(X,L2,L1).
?- list_delete(a,[a,e,i,o,u],NewList).
NewList = [e,i,o,u] ?
| ?- list_delete(a,[a],NewList).
NewList = [] ?
List: Append into List
• Appending two lists means adding two lists together, or
adding one list as an item. Now if the item is present in the
list, then the append function will not work. So we will create
one predicate namely, list_append(L1, L2, L3).
The following are some observations:

• Let A is an element, L1 is a list, the output will be L1 also,
when L1 has A already.
• Otherwise new list will be L2 = [A|L1].

List: Append into List
• Example

List: Insert into List
• This method is used to insert an item X into list L, and the
resultant list will be R. So the predicate will be in this form
list_insert(X, L, R). So this can insert X into L in all possible
positions.
If we see closer, then there are some observations.
• If we perform list_insert(X,L,R), we can use list_delete(X,R,L),

so delete X from R and make new list L.

List: Insert into List
• Example

Repositioning operations of list items

List: Max Item Operation

List Sum Operation

Concatenation: List
• Concatenation of two lists means adding the
list items of the second list after the first one.
So if two lists are [a,b,c] and [1,2], then the
final list will be [a,b,c,1,2].
• we will create one predicate called
list_concat(), that will take first list L1, second
list L2, and the L3 as resultant list.

Concatenation: List
%[list_basics].
list_concat([],L,L).
list_concat([X1|L1],L2,[X1|L3]) :-
list_concat(L1,L2,L3).
?- list_concat([1,2],[a,b,c],NewList).
NewList = [1,2,a,b,c]
| ?- list_concat([],[a,b,c],NewList). NewList = [a,b,c]
| ?- list_concat([[1,2,3],[p,q,r]],[a,b,c],NewList).
NewList = [[1,2,3],[p,q,r],a,b,c]
Repositioning operations of list items
Repositioning
Definition
Operations
This operation will change the list item

Permutation
positions and generate all possible outcomes.
This operation arranges the items of a list in

Reverse Items
reverse order.
This operation will shift one element of a list
Shift Items
to the left rotationally.
This operation verifies whether the given list is
Order Items
ordered or not.
Set operations on lists
We will try to write a clause that will get all possible
subsets of a given set. So if the set is [a,b], then the
result will be [], [a], [b], [a,b]. To do so, we will create
one clause, list_subset(L, X). It will take L and return
each subsets into X.
• If list is empty, the subset is also empty.

• Find the subset recursively by retaining the Head,
and
• Make another recursive call where we will remove
Head.
% [mylist_subset].
list_subset([],[]).
list_subset([Head|Tail],[Head|Subset]) :-
list_subset(Tail,Subset).
list_subset([Head|Tail],Subset) :-
list_subset(Tail,Subset).

• | ?- list_subset([a,b],X).
• X = [a,b] ? ;
• X = [a] ? ;
• X = [b] ? ;
• X = []

List Union Operation
Let us define a clause called list_union(L1,L2,L3),
So this will take L1 and L2, and perform Union
on them, and store the result into L3. As you
know if two lists have the same element twice,
then after union, there will be only one.

list_member(X,[X|_]).
list_member(X,[_|TAIL]) :- list_member(X,TAIL).
list_union([X|Y],Z,W) :-
list_member(X,Z),list_union(Y,Z,W).
List_union([X|Y],Z,[X|W]) :- \+
list_member(X,Z),list_union(Y,Z,W).
list_union([],Z,Z).

| ?- list_union([a,b,c,d,e],[a,e,i,o,u],L3).
L3 = [b,c,d,a,e,i,o,u] ? (16 ms)
yes
| ?- list_union([a,b,c,d,e],[1,2],L3).
L3 = [a,b,c,d,e,1,2]
yes

List Intersection Operation
Let us define a clause called
list_intersection(L1,L2,L3), So this will take L1
and L2, and perform Intersection operation, and
store the result into L3. Intersection will return
those elements that are present in both lists. So
L1 = [a,b,c,d,e], L2 = [a,e,i,o,u], then L3 = [a,e].
Here, we will use the list_member() clause to
check if one element is present in a list or not.

%[mylist_intersect].
list_member(X,[X|_]).
list_member(X,[_|TAIL]) :- list_member(X,TAIL).
list_intersect([X|Y],Z,[X|W]) :- list_member(X,Z),
list_intersect(Y,Z,W).
list_intersect([X|Y],Z,W) :- \+ list_member(X,Z),
list_intersect(Y,Z,W).
list_intersect([],Z,[]).
%[mylist_intersect].
| ?- list_intersect([a,b,c,d,e],[a,e,i,o,u],L3).
L3 = [a,e] ?
yes
| ?- list_intersect([a,b,c,d,e],[],L3).
L3 = []
yes

Misc Operations on Lists
Misc
Definition
Operations
Even and Odd Verifies whether the list has odd number or even
Length Finding number of elements.
Divides a list into two lists, and these lists are of
Divide
approximately same length.
Retrieves the element with maximum value from
Max
the given list.
Sum Returns the sum of elements of the given list.
Arranges the elements of a given list in order

Merge Sort
(using Merge Sort algorithm).

Logic Programming Using Prolog List Operations

Uploaded by

Copyright:

Available Formats

Logic Programming Using Prolog List Operations

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Logic Programming Using Prolog List Operations

Uploaded by

Copyright:

Available Formats

Lecture 5

Logic Programming Using Prolog

We will discuss the following topics:

Fall 2023 Logic Programming 2

Fall 2023 Logic Programming 3

Fall 2023 Logic Programming 4

Fall 2023 Logic Programming 6

So there are three cases:

Fall 2023 Logic Programming 8

Fall 2023 Logic Programming 9

The following are some observations:

Fall 2023 Logic Programming 11

Fall 2023 Logic Programming 12

If we see closer, then there are some observations.

• If we perform list_insert(X,L,R), we can use list_delete(X,R,L),

Fall 2023 Logic Programming 13

Fall 2023 Logic Programming 14

Fall 2023 Logic Programming 15

Fall 2023 Logic Programming 16

Fall 2023 Logic Programming 17

Fall 2023 Logic Programming 18

| ?- list_concat([],[a,b,c],NewList). NewList = [a,b,c]

This operation will change the list item

This operation arranges the items of a list in

• If list is empty, the subset is also empty.

Fall 2023 Logic Programming 22

Fall 2023 Logic Programming 23

Fall 2023 Logic Programming 24

Fall 2023 Logic Programming 25

Fall 2023 Logic Programming 26

Fall 2023 Logic Programming 27

Fall 2023 Logic Programming 29

Arranges the elements of a given list in order

You might also like