Programming in Logic: Prolog

1. Programming in Logic: Prolog Lists and List Operations Readings: Sections 3.1 & 3.2 CS360 Lecture 4

2. 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 “[ ]”. CS360 Lecture 4

3. 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,[ ]) CS360 Lecture 4

4. 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] CS360 Lecture 4

5. 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] CS360 Lecture 4

6. 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)] CS360 Lecture 4

7. Definition of List • List definition: • list([ ]). • list([I|L1]) :- list(L1). CS360 Lecture 4

8. 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) CS360 Lecture 4

9. 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? CS360 Lecture 4

10. 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 | _ ]). CS360 Lecture 4

11. 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. CS360 Lecture 4

12. List Membership KB: 1. member(I, [ I | _ ]). 2. member(I, [_| T] :- member(I, T). Query: member(x, [ ]). Response: no Execution Trace: [member(x,[ ])]  CS360 Lecture 4

13. 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 CS360 Lecture 4

14. 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 CS360 Lecture 4

15. 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? CS360 Lecture 4

16. 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). CS360 Lecture 4

17. 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) CS360 Lecture 4

18. 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? CS360 Lecture 4

19. 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. CS360 Lecture 4

20. 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). CS360 Lecture 4

21. 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! CS360 Lecture 4

22. 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? CS360 Lecture 4

23. 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? CS360 Lecture 4

24. 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? CS360 Lecture 4

25. 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? CS360 Lecture 4

26. Defining Permutation Relation • Where do we look for our cases? • What should be our base case? CS360 Lecture 4

27. Defining Permutation Relation • What should be our inductive case? • What should the head look like? • What’s the relationship between the different parts? CS360 Lecture 4

28. Permutation Defined • permutation([ ],[ ]). • permutation([X | L1], Perm) :- permutation(L1, L2), insert(X, L2, Perm). CS360 Lecture 4

29. Homework Quiz • Write definitions for the following relations: • reverse(List, ReverseList) • subSet(Set, SubSet) • flatten(List, FlatList) CS360 Lecture 4

30. 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. CS360 Lecture 4

31. 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. CS360 Lecture 4