Programming in Logic: Prolog - University of Auckland€¦ · MB: 5 March 2001 CS360 Lecture 4 3...

MB: 5 March 2001 CS360 Lecture 4 1

Programming in Logic: Prolog

Lists and List Operations Readings: Sections 3.1 & 3.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.


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


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 “[ ]”.


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,[ ])


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]


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]


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)]


Definition of List

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


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)


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?


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 | _ ]).


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.


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

Query: member(x, [ ]).

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



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

Response:

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

continue trace



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

Response: X=w ? ;

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


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?


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


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)


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?


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.


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


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!


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?


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?


  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?


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?


Defining Permutation Relation

 Where do we look for our cases?

 What should be our base case?


Defining Permutation Relation

 What should be our inductive case?

 What should the head look like?

 What’s the relationship between the different parts?


Permutation Defined

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

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


Homework Quiz

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

–  subSet(Set, SubSet)

–  flatten(List, FlatList)


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.


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.

Programming in Logic: Prolog - University of Auckland€¦ · MB: 5 March 2001 CS360 Lecture 4 3...

Documents

Transcript of Programming in Logic: Prolog - University of Auckland€¦ · MB: 5 March 2001 CS360 Lecture 4 3...