MB: 5 March 2001 CS360 Lecture 4 1

Programming in Logic: Prolog

Lists and List Operations Readings: Sections 3.1 & 3.2

MB: 5 March 2001 CS360 Lecture 4 2

Review

 Declarative semantics of pure Prolog program defines when a goal is true and for what instantiation of variables.

 Commas between goals mean and, semicolons mean or.

  Procedural semantics are determined by clause and goal ordering.

 Goal failure causes backtracking and unbinding of affected variables.

MB: 5 March 2001 CS360 Lecture 4 3

Programming Patterns

 Today we start actually looking at programs

 We will look at a lot of them!!

 You should look for some underlying patterns of how to program in Prolog

MB: 5 March 2001 CS360 Lecture 4 4

Prolog Lists

 The elements of a list can be anything including other lists.

 Remember that atoms could be made from a sequence of special characters, the empty list is the special atom “[ ]”.

MB: 5 March 2001 CS360 Lecture 4 5

Lists

 A non-empty list always contains two things, a head and the tail. It is a structured data object. The functor name is “.” and its arity is 2.

 The list consisting of the item “3” is: .(3,[ ])

MB: 5 March 2001 CS360 Lecture 4 6

Lists cont’d

 The list consisting of the two items “3” and “x” is: .(3, .(x,[ ]))

 Lists are one of the most pervasive data structures in Prolog, so there is a special notation for them: [3, x]

MB: 5 March 2001 CS360 Lecture 4 7

Lists cont’d

 Often want to describe beginning of list without specifying the rest of it. For example, .(3, .(x, T)) describes a list whose first two items are 3 and x, and whose remaining items could be anything (including empty).

  Prolog provides a special notation for doing this, “|”, e.g., [3,x |T]

MB: 5 March 2001 CS360 Lecture 4 8

Lists   [3, x | T] matches :

–  [3,x], –  [3,x,y(5)], –  and [3,x,56, U, name(mike, barley)] (among others)

 with T = –  [ ], –  [y(5)], –  and [56,U,name(mike, barley)]

MB: 5 March 2001 CS360 Lecture 4 9

Definition of List

 List definition: –  list([ ]). –  list([I|L1]) :- list(L1).

MB: 5 March 2001 CS360 Lecture 4 10

List Operations

  Since lists are an inductively defined data structure, expect operations to be inductively defined.

 One common list operation is checking whether something is a member of the list. –  member(Item, List)

MB: 5 March 2001 CS360 Lecture 4 11

List Membership

  If defining list membership inductively, need to figure out base case for list variable.

  Base case for defn of list is [ ], but not appropriate for base case of membership. Why?

  Need to look elsewhere. What’s the simplest case for deciding membership?

MB: 5 March 2001 CS360 Lecture 4 12

List Membership

  It’s the first item in the list. Maybe this can be our base case. –  member(Item, List) :- List = [Item | _ ].

  Prolog is pattern-directed, i.e., does pattern matching, can use this to simplify base case: –  member( I, [ I | _ ]).

MB: 5 March 2001 CS360 Lecture 4 13

List Membership

 What if item is not the first one in list, then what? Then need to check if it’s in the tail. –  member(I, [ _ | T ]) :- member(I, T).

 Don’t we have to check for empty list case? –  No, because if we hit the empty list, then I is not in

the list, so we should fail.

MB: 5 March 2001 CS360 Lecture 4 14

List Membership KB: 1. member(I, [ I | _ ]). 2. member(I, [_| T] :- member(I, T).

Query: member(x, [ ]).

Response: no Execution Trace: [member(x,[ ])] ×

MB: 5 March 2001 CS360 Lecture 4 15

List Membership KB: 1. member(I, [ I | _ ]). 2. member(I, [_| T] :- member(I, T).

Query: member(x, [ w, x]).

Response:

Partial Execution Trace: [member(x,[ w, x ])] 2. I=x, T=[x] [member(x, [x])]

continue trace

MB: 5 March 2001 CS360 Lecture 4 16

List Membership KB: 1. member(I, [ I | _ ]). 2. member(I, [_| T] :- member(I, T).

Query: member(X, [ w, x]).

Response: X=w ? ;

Partial Execution Trace: [member(X,[ w, x ])] 1. X=I, I=w [ ] continue trace

MB: 5 March 2001 CS360 Lecture 4 17

List Concatenation

 Define relation conc(L1, L2, L3) where L3 is the result of concatenating L1 onto front of L2.

 What is the base case?

 Go back to defn of list, what is base case?

MB: 5 March 2001 CS360 Lecture 4 18

List Concatenation

 List defn base case is [ ], should this be our base case for defining concatenation?

  conc([ ], ?, ?) - what is the result of concatenating [ ] onto anything? Are there special cases?

  conc([ ], L2, L2).

MB: 5 March 2001 CS360 Lecture 4 19

List Concatenation

 What should the inductive step be?  What was the inductive step for list defn?  What should the head look like?   conc([ I | L1], L2, [ I | L3])  What’s the relation between L1, L2, and L3?   conc(L1, L2, L3)

MB: 5 March 2001 CS360 Lecture 4 20

List Concatenation

  Full definition: –  conc([ ], L, L). –  conc([ I | L1], L2, [I|L3]) :- conc(L1, L2, L3).

 Try doing an execution trace for the query: –  conc(L1, L2, [1, 2, 3]).

 What are the bindings for L1 and L2 if keep asking for alternatives?

MB: 5 March 2001 CS360 Lecture 4 21

Multi-Way Uses of Relations

 We have seen that one nice feature of logic programming is its absence of control.

 This means we can define one central relation and use it in a number of different ways. What it means depends upon which arguments are variables, partially variablized and/or constants.

  conc/3 is an example of such a central relation.

MB: 5 March 2001 CS360 Lecture 4 22

Some Uses of Concatenation

 member(I, L) :- conc(_, [ I | _ ], L).

  last( Item, List) :- conc(_ , [Item], List).

  sublist(SubList, List) :- conc(L1, L2, List),

conc(SubList, _, L2).

MB: 5 March 2001 CS360 Lecture 4 23

Clarity

 We don’t really need to write defns for member/2 and last/2, could just use conc/3.

 What have we gained by writing those definitions?

 We write their definitions because we want it to be obvious what we’re trying to do!

MB: 5 March 2001 CS360 Lecture 4 24

List Operations

 Adds item to front of list: –  add(Item, List, [Item | List]).

 Given the following code: add(1,[ ],L1), add(2, L1,L2),

add(3,L2,L3). What would be the binding for L3?

MB: 5 March 2001 CS360 Lecture 4 25

List Operations

 Deletes item from list: –  del(Item, [Item| Tail], Tail). –  del(Item, [Y | Tail], [Y | Tail1]) :-

del(Item, Tail, Tail1).   del/2 is non-deterministic, what would

del(1,[1,2,1,3,1],L). What would be the bindings for L if we repeatedly asked for new alternatives?

MB: 5 March 2001 CS360 Lecture 4 26

  Insert item into list: –  insert(I,List,NewList) :- del(I, NewList, List).

  insert/3 also non-deterministic, what would insert(x, [1,2,3], L)

bind to L if repeatedly ask for alternatives?

MB: 5 March 2001 CS360 Lecture 4 27

Permutation of a List

 Let’s define the “permutation” relation: –  perm(List, Permutation).

 Are we clear about what is a permutation? –  Look at examples.

 What type of definition will we look for?

MB: 5 March 2001 CS360 Lecture 4 28

Defining Permutation Relation

 Where do we look for our cases?

 What should be our base case?

MB: 5 March 2001 CS360 Lecture 4 29

Defining Permutation Relation

 What should be our inductive case?

 What should the head look like?

 What’s the relationship between the different parts?

MB: 5 March 2001 CS360 Lecture 4 30

Permutation Defined

  permutation([ ],[ ]).   permutation([X | L1], Perm) :-

permutation(L1, L2), insert(X, L2, Perm).

MB: 5 March 2001 CS360 Lecture 4 31

Homework Quiz

 Write definitions for the following relations: –  reverse(List, ReverseList)

–  subSet(Set, SubSet)

–  flatten(List, FlatList)

MB: 5 March 2001 CS360 Lecture 4 32

Summary

  If data structure defined inductively then usually operations are defined inductively.

 However, sometimes the data structure base case does not make sense for the operation, then need to find new base case.

  First part of coming up with inductive case is finding what the head should be, often part of head is data structure inductive case.

MB: 5 March 2001 CS360 Lecture 4 33

Summary cont’d

 Defining relations in pure Prolog allows definitions to be used in many ways.

 However, when some uses have common name (e.g., “last”) then should define new relation from old using the common name.