Programming in Logic: Prolog

MB: 5 March 2001 CS360 Lecture 4 1

Programming in Logic: Prolog

Lists and List OperationsReadings: Sections 3.1 & 3.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 “[ ]”.


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 MembershipKB:1. member(I, [ I | _ ]). 2. member(I, [_| T] :- member(I, T).

Query: member(x, [ ]).

Response: noExecution 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.

Documents

Programming in Logic: Prolog