What s the problem? fib(1,1). fib(2,1). fib(n,x) :- N>2, N1 is N-1, N2 is N-2, fib(n1,x2), fib(n2,x2).

Transcription

1 39 What s the problem? A Fibonacci Implementation fib(1,1). fib(2,1). fib(n,x) :- N>2, N1 is N-1, N2 is N-2, fib(n1,x2), fib(n2,x2). List Concatenation conc([],l,l). conc([x L1], L2, [X L3]) :- conc(l1,l2,l3).

2 40 The problem is... Fibonacci re-computation of results solution (in Haskell): dynamic programming solution in Prolog: self-modifying code Concatenation whole first list is traversed solution (in C): pointer to last element solution (in Prolog): difference lists

3 Agenda application: data bases query add: assert delete: retract change: substitution Fibonacci revisited exercise difference lists concatenation revisited

4 Facts as data/knowledge-base We can use facts to represent knowledge. For instance: an almanac. country (spain, capital(madrid, ), languages([spanish]), cities([barcelone, valencia, bilbao]), success([football(ec,2008)])).

5 43 Queries Define the following predicates! country/1 yields country names capital/1 yields capitals bigcapital/1 yields capitals with population > 10 6 sport(x,y) yields countries with at least one success in sport Y huge(x) yields countries with more than one language, success, and city define a predicate to find all countries (challenge, later)

6 44 Adding/deleting information add and remove a country assert/1: add a clause to the program can be done in the interpreter and in programs asserta/1 adds clause at beginning assertz/1 adds clause at end retract/1: removes matching clause from program

7 45 Changing information assume Germany wins football WC 2010 need to replace the success subterm of country(germany,..). this is a special case of substitution (known from type inference) in general, replace each occurrence subterm S1 by subterm S2 in term T1 to obtain T2 subst(s1,s2,t1,t2)

8 46 Term manipulations In order to do this, we need some ways of manipulating terms. =.. is a binary predicate (in infix notation) that decomposes terms in functor and arguments X =.. [F Args] succeeds, if X = f(t 1,..., t k ) and F = f and Args = [t 1,..., t k ] examples:?- f(a,b) =.. [F Args].?- X+a =.. [F Args].?- [1,2,3] =.. [F Args].

9 47 Types Terms can be tested for their types by predicates. atom(x) succeeds if X is bound to an atom. integer(x) succeeds if X is bound to an integer. atomic(x) :- atom(x) ; integer(x). var(x) succeeds if X is bound to a variable. nonvar(x) analogously.

10 48 Substitution subst(s1,s2,t1,t2) replace S1 by S2 in T1 to obtain T2 solution in program file on web site observation 1: what if T1=S1? observation 2: what if T1=T2? observation 3: what if T1=f(A1,..,Ak), T2=f(B1,..,Bk)? how do we make Germany WC 2010 winner?

11 49 What about Fibonacci then? We can store intermediate results using assert! fib(1,1). fib(2,1). fib(n,x) :- N>2, N1 is N-1, N2 is N-2, fib(n1,x2), fib(n2,x2), assert( fib(n,x) ). This is indeed the most common use of assert.

12 50 Caution! Self-modifying code is error-prone! assert and retract are impure Prolog just like cuts, negation by failure, arithmetic

13 51 Agenda application: data bases query add: assert delete: retract change: substitution Fibonacci revisited exercise difference lists concatenation revisited

14 52 Exercise What does the following code do? find(x,g, ) :- call( G ), assertz( stack(x) ), fail. find(,,xs) :- assertz( stack(end) ), c(xs). collect(l) :- retract( stack(x) ),!, ( X == end,!, L=[] ; L = [X Rest], collect(rest) ).

15 53 Hints call( G ) calls goal G, succeeds if G succeeds, fails otherwise example call:?- f(x, conc(x,,[1,2,3]), Xs). call yields a solution, binding it to X solution is saved on a stack fail makes find fail: backtracking! the second clause for find is only called, when call( G ) fails then the end of the stack is written to the program collect(l) collects everything stored on stack find/3 implements findall! so we can find all countries

16 54 Agenda application: data bases query add: assert delete: retract change: substitution Fibonacci revisited exercise difference lists concatenation revisited

17 55 Difference Lists Prolog folklore represent lists as pairs of lists as in L-X - is just a (infix) functor constructing terms X is removed from L L is represented as [L X]-X [1,2,3] = [1,2,3,4,5,6]-[4,5,6] [1,2,3] = [1,2,3 X]-X for a logical variable X another intuition: list with X as a hole empty list: X-X

18 56 Difference list concatenation example: concatenate [1,2,3 L1]-L1 and [4,5,6 L2]-L2 expected result: [1,2,3,4,5,6 L2]-L2 the hole at the end of the first argument is filled with the second keep the second hole unification L1 and [4,5,6 L2]

19 57 Solution is very concise dl conc(a-b,b-c,a-c) Uses unifications instead of a list traversal!

20 58 Add an element to the end hard in functional languages (linear in size of list) enables to encode queues easy with difference list add at end(l-[x T],X,L-T)

21 59 List reverse rev(a-b,l-l) :- A==B,!. rev([x L]-T, A-B) :- rev(l-t,a-[x B]).

22 60 Next time parsing with Prolog based on difference list definite-clause grammars games Sudoku constraint logic programming chess

23 61 Conclusion difference lists L as [L X]-X list concatenation with three unifications useful for queues databases term manipulations with =.., atomic,... self-modifying code assert retract useful track to store intermediate results (Fibonacci!)