Hans Hüttel LOGIC PROGRAMMING IN PROLOG. (original slides by Claus Brabrand, IT University of Copenhagen)

Transcription

1 "Programming Paradigms", Dept. of Computer Science, Aalborg Uni. (Autumn 2010) LOGIC PROGRAMMING IN PROLOG Hans Hüttel (original slides by Claus Brabrand, IT University of Copenhagen) Hans Hüttel/ Claus Brabrand PROGRAMMING PARADIGMS Autumn 2010

2 Plan for Today Lecture: "Lists and Arithmetic" (9:00 9:45) Exercise 1, 2, and 3 (10:00 11:00) Lecture: "Reversibility, Cut, Negation, and Language Interpretation" (11:00 12:00) Lunch break (12:00 13:00) Lecture: "Non-termination and Undecidability (13:00 13:45) Exercises 4, 5, and 6 (14:00 15:00)

3 Outline Part 1: Lists Part 2: Part 3: Arithmetic Reversibility Cut and Negation Language Interpretation Non-termination Undecidability

4 Resolution: PROLOG's Search Order f(a). f(b). g(a). g(b). h(b). k(x) :- f(x),g(x),h(x). axioms (5x) rule (1x) rule head 1. Search knowledge base (from top to bottom) for (axiom or rule head) matching with (first) goal: Axiom match: remove goal and process next goal [ 1] Rule match: (as in this case): k(x) :- f(x),g(x),h(x). [ 2] No match: backtrack (= undo; try next choice in 1.) [ 1] 2. "α-convert" variables (to avoid name clashes, later): Goal α : (record Y = _G225 ) k(_g225) Match α : [ 3] 3. Replace goal with rule body: rule body Now resolve new goals (from left to right); [ 1] k(y) k(_g225) :- f(_g225),g(_g225),h(_g225). f(_g225),g(_g225),h(_g225). Possible outcomes: - success: no more goals to match (all matched w/ axioms and removed) - failure: unmatched goal (tried all possibilities: exhaustive backtracking) - non-termination: inherent risk (same- / bigger-and-bigger- / more-and-more -goals)

5 LISTS Keywords: (Encoded) lists, (built-in) lists, efficiency issues,... Hans Hüttel/ Claus Brabrand PROGRAMMING PARADIGMS Autumn 2010

6 Lists (home-made) Lists are easily represented: nil cons(e,l) Example: // empty list // construct new list from element and list ~Haskell The list [1,2,3] may be represented as: cons(1, cons(2, cons(3, nil))) i.e., "representation of information" Now, let's look at: "Transformation of representation of information" (= programming)

7 Lists (example "functions") T Length: len(0, nil). len(succ(n), cons(e, cons(_, L)) :- len(n, L). Member: member(x, cons(x, L)). member(x, cons(e, L)) :- member(x, L). Using underscore '_' (anonymous "ignore" variable) may improve readability PROLOG also has built-in lists

8 Lists (built-in) Constant lists: [] [ X, Y, Z ] // the empty list // constant list ~Haskell Lists are (also) untyped; = finite sequence of (any) terms: [] [ [] ] [ vincent, jules, marcellus ] [ [], mia, 42, 'The Gimp', dead(zed), Z ] [ [], [], [ [] ], [ [ x, X, [] ] ] ] Q: What is the length of the lists?

9 The Head-Tail Constructor PROLOG (like many other languages) has: [ H T ] // "head-tail constructor" H head (element) of list, T tail of list (rest) for construction and deconstruction: (bigger) list viewed as element and (smaller) list ~Haskell h:t Example: construction :?- [ a [b,c] ] = L. L = [a,b,c] Example: deconstruction :?- [a,b,c] = [ H T ]. H = a T = [b,c]

10 Examples: [ H T ] Empty list example:?- [] = [ H T ]. No Splitting a non-homogeneous list:?- [ [], mia, 42, 'The Gimp', dead(zed), Z ] = [ X Y ]. X = [] Y = [ mia, 42, 'The Gimp', dead(zed), Z ] A slightly tricky one?- [ [], [] ] = [ X Y ]. X = [] Y = [ [] ]

11 Length and Member (revisited) Length/2: ~ Haskell len(0, []). len(succ(n), [ _ L ]) :- len(n, L). Member/2: member(x, [ X _ ]). member(x, [ _ L ]) :- member(x, L). Usage:?- member(2, [1,2,3]). Yes?- member(x, [1,2,3]). // gimme elements from list X=1 ; // next... X=2 ; X=3 ; No

12 Append T Append/3: Search tree for: append([], L, L). append([x L 1 ], L 2, [X L 3 ]) :- append(l 1,L 2,L 3 ).?- append([a,b,c], [d,e,f], R) R = [a,b,c,d,e,f] append([a,b,c],[d,e,f],_g1) append([a,b,c],[d,e,f],[a,b,c,d,e,f]) _G1 = [a _G2] rule append([b,c],[d,e,f],_g2) append([b,c],[d,e,f],[b,c,d,e,f]) _G2 = [b _G3] rule append([c],[d,e,f],_g3) append([c],[d,e,f],[c,d,e,f]) _G3 = [c _G4] rule append([],[d,e,f],_g4) append([],[d,e,f],[d,e,f]) _G4 = [d,e,f] axiom

13 Using Append Prefix/2: Suffix/2: prefix(p, L) :- append(p, _, L). suffix(s, L) :- append(_, S, L). SubList/2: sublist(l sub, L) :- suffix(s, L), prefix(l sub, S)....or, alternatively...: sublist(l sub, L) :- prefix(p, L), suffix(l sub, P).

14 Reverse (and efficiency issues) Reverse/2: Idea; exploit property: (x L) R = L R x rev([], []). rev([x L], R) :- rev(l, L_rev), [L_rev X] = R. Problem: [X L] is asymmetrically left-to-right biased we cannot put the list in front and write: [ L X ] Let's use append: rev([x L], R) :- rev(l, L_rev), append(l_rev, [X], R). Q: What about efficiency? 1) of append? ; 2) of reverse?

15 Efficiency Efficiency(append): app([], L, L). app([x L 1 ], L 2, [X L 3 ]) :- app(l 1,L 2,L 3 ). Recall ("big-o definition"): Efficiency(reverse): arg 1 +1 O( arg 1 ) f O(g) def n,k>0: N>n => f(n) k g(n) "f is dominated by g for large values (larger than n)" rev([], []). rev([h T], R) :- rev(t,t R ), app(t R,[H],R). Q: Efficiency(reverse)...?

16 Search Tree: rev rev([], []). rev([h T], R) :- rev(t,t R ), app(t R,[H],R). rev([1, 2, 3], _G1) rev rule rev([2, 3], _G2), app(_g2, [1], _G1) rev rule rev([3], _G3), app(_g3, [2], _G2), app(_g2, [1], _G1) L +1 invocations (of rev) O( L ) rev rule rev([], _G4), app(_g4, [3], _G3), app(_g3, [2], _G2), app(_g2, [1], _G1) _G4 = [] rev axiom app([], [3], _G3), app(_g3, [2], _G2), app(_g2, [1], _G1) + _G3 = [3] (1 step of append) app([3], [2], _G2), app(_g2, [1], _G1) _G2 = [3,2] (2 steps of append) app([3,2], [1], _G1) invocations (of append) O( L 2 ) _G1 = [3,2,1] (3' append)

17 Accumulator T Let's use an accumulator: ~ Haskell accrev([h T], A, R) :- accrev(t, [H A], R). accrev([], A, A). rev(l, R) :- accrev(l, [], R). rev([1,2,3], _G1) rev rule accrev([1,2,3], [], _G1) accrev rule accrev([2,3], [1], _G1) accrev rule accrev([3], [2,1], _G1) accrev rule accrev([], [3,2,1], _G1) 1 step (of rev) oldrev vs. newrev: + L steps (of accrev) O( L ) steps O(n 2 ) oldrev O(n) newrev L

18 ARITHMETIC Keywords: Evaluation,... Hans Hüttel/ Claus Brabrand PROGRAMMING PARADIGMS Autumn 2010

19 Binary Infix Functors: {+,-,*,/} Consider:?- 2+2 = 4 false?- 2*2 = 4 false?- 2-2 = 0 false?- 2/2 = 1 false What is going on...?!? The symbols {+,-,*,/} are just: (Binary) infix functors: i.e., "2+2" is just a short-hand for "+(2,2)"; in fact:?- 2+2 = +(2,2) true ~ Haskell

20 Binary Infix Functors (cont'd) The symbols {+,-,*,/} just (conveniently) represent structured information: is understood as 1-2/3+4*5*6 (1-(2/3))+((4*5)*6) precedence: {*,/} stronger-than {+,-} associativity: {+,-,*,/} left-associative...and is thus just a short-hand for: "standard" precedence/ associativity rules +(-(1,/(2,3)),*(*(4,5),6)...which is, structurally, no different than: a(b(1,c(2,3)),d(d(4,5),6) However, their interpretation may be very different; e.g., "represents" an expression that may be evaluated ~ Haskell

21 The "is/2" Predicate is/2 TERM TERM: Evaluates its right argument (as arithmetic expression)...provided all variables are instantiated!?- 4 is 2+2 true?- X is 2+2 X=4?- 2+2 is 4 false Example (in predicate definition):?- 2+2 is X X=2+2 % 2+2 is not evaluated! sq(x,y) :- Y is X*X.?- sq(5,y). Y=25?- sq(x,25). ERROR: is/2: Arguments are not sufficiently instantiated

22 Careful with Arithmetic Evaluation!! T Recall "len/2": Arithmetic version(s): len([], 0)....with unary encoding of numerals: len([_ L], succ(n)) :- len(l, N). len 1 ([], 0). len 1 ([_ L], N_succ) :- len 1 (L, N), N is N_succ-1.?- len 1 ([1,2,3], R). *** ERROR: is/2: uninstantiated argument len 2 ([], 0). len 2 ([_ L], N) :- len 2 (L, N_pred), N is N_pred+1.?- len 2 ([1,2,3], R). R=3 len 3 ([], 0). len 3 ([_ L], N) :- N is N_pred+1, len 3 (L, N_pred). -? len 3 ([1,2,3], R). *** ERROR: is/2: uninstantiated argument

23 Accumulators (revisited) "len/2": Version with accumulator: len([], 0). len([_ T], N) :- len(t, X), N is X+1. acclen([], A, A). acclen([_ T], A, N) :- A new is A+1, acclen(t, A new,n) N) len(list, Length) :- acclen(list, 0, Length). len([1,2,3], _G1) len rule len([2,3], _G2), _G1 is _G2+1 len rule Same #steps (both 7x) However; NOT tail recursive: "calculation after recursion" acclen([1,2,3], 0, _G1) acclen rule; then "is" acclen([2,3], 1, _G1) acclen rule; then "is" len([3], _G3), _G2 is _G3+1, _G1 is _G2+1 len rule O(n) wide! acclen([3], 2, _G1) acclen rule; then "is" len([], _G4), _G3 is _G4+1, _G2 is _G3+1, _G1 is _G2+1 acclen([], 3, _G1) len axiom _G3 is 0+1, _G2 is _G3+1, _G1 is _G2+1 is is is acclen axiom Tail recursive! "calculation during recursion" ~ Haskell

24 Comparison Operators More integer comparison operators (with arithmetic evaluation side-effects): "<" "less than" "<=" "less than or equal to" ">" "greater than" ">=" "greater than or equal to" "=:=" "equal to" "=\=" "not equal to" Evaluate both arguments Again, all variables have to be instantiated Otherwise no surprises...

25 Exercise 1, 2, and 3: 10:00 11:00 Hans Hüttel/ Claus Brabrand PROGRAMMING PARADIGMS Autumn 2010

26 1.... Purpose: Learn how to...

29 REVERSIBILITY Hans Hüttel/ Claus Brabrand PROGRAMMING PARADIGMS Autumn 2010

30 Ex: Symbolic Differentiation d dx (k) = 0 d dx (x) = 1 d d (f + g) = dx dx (f)+ d dx (g) d d (f g) = dx dx (f) d dx (g) d dx (f g) = g d dx (f)+f d dx (g) d dx (f g ) = g d dx f f d g 2 dx g d dx (xn ) = n x n 1 d dx (ex ) = e x d dx (ln x) = 1 x d sin x dx = cos x d cos x = sin x dx d d (f g) = dx dx f d df (x) g(f(x))

31 ...in PROLOG e x In PROLOG: dx(k, 0) :- number(k). dx(x, 1). dx(f+g, Df+Dg) :- dx(f,df), dx(g,dg). dx(f-g, Df-Dg) :- dx(f,df), dx(g,dg). dx(f*g, Df*G+F*Dg) :- dx(f, Df), dx(g, Dg). // constant // variable // add // sub // mul dx(f/g, (Df*G-F*Dg)/(G*G)) :- dx(f, Df), dx(g, Dg). // div [...] dx(cos(x), 0-sin(x)). dx(f;g, (F;Dg)*Df) :- dx(f,df), dx(g,dg). // cos // compose

32 Differentiation Interaction:?- dx(x/exp(x), Df). Df = (1*exp(x)-x*exp(x)) / (exp(x)*exp(x)) Reverse:?- dx(f,(1*exp(x)-x*exp(x)) / (exp(x)*exp(x))). F = x/exp(x) Does this mean we can do integration? ANF f' No, just certain functions in "anti - normal form" (ANF); i.e., functions that are in the image of the differentiation f

33 CUT AND NEGATION Keywords (chapter 10): Side-effect, Backtracking, Cut, Fail, Cut-Fail, Negation,... Hans Hüttel/ Claus Brabrand PROGRAMMING PARADIGMS Autumn 2010

34 The Cut Operator: '!' Consider max/3: max(x,y,y) :- X =< Y. max(x,y,x) :- X > Y. Note: mutually exclusive conditions?- max(3,4,m). M = 4?- ; % backtracking now causes futile re-evaluation of max Cut, "!", (locally) is a goal that always succeeds and disables backtracking Cut version: max(x,y,y) :- X =< Y,!. % commit (throw away max-backtracking) max(x,y,x) :- X > Y. Note: this cut changes only efficiency properties = "Green Cut"

35 "Green Cuts" vs. "Red Cuts" "Green cut" version: max(x,y,y) :- X =< Y,!. max(x,y,x) :- X > Y. Alternative "Red cut" version (= relying on cut): max(x,y,y) :- X =< Y,!. max(x,y,x). % only succeeds if above fails (...or?) Seems okay...:?- max(99,100,x). X = 100?- max(100,99,x). X = 100 % ok! % ok! Advice: "cut down on cut"...but:?- max(1,100,1). true % Oops! (evaluation never made it to the cut)

36 Fail and exception predicating Consider: enjoys(vincent, X) :- burger(x)....but maybe Vincent likes all burgers, except "Big Kahuna burgers". PROLOG features a built-in "fail/0"-predicate: Syntax: fail Semantics: "always fails (and forces backtracking)" enjoys(vincent, X) :- big_kahuna_burger(x),!, fail enjoys(vincent, X) :- burger(x). big_mac(b 0 ). big_kahuna_burger(b 1 ). the rule relies (operationally) on the cut = red cut?- enjoys(vincent, b 0 ). true?- enjoys(vincent, b 1 ). false

37 The Cut-Fail Combination The "cut-fail combination"... enjoys(vincent, X) :- big_kahuna_burger(x),!, fail enjoys(vincent, X) :- burger(x)....expresses negation...and is so common that it is built-in: not/1; equivalent to: not(goal) :- Goal,!, fail. not(goal). It's better to use "not" it is a higher level abstraction (than cut-fail); However...: Isn't always "well-defined": _ P(x) _ P(x) Cut has operationally which relation Inf. Sys. vs. PROLOG (well-)defined semantics?! p(x) :- not(p(x)).

38 If-then-else: "( A -> B ; C )" PROLOG has an if-then-else construction: Syntax: ( A -> B ; C ) Semantics: "if A; then B, else C" Alternative version of max/3:...using if-then-else: max(x,y,z) :- ( X =< Y -> Z = Y ; Z = X ).

39 LANGUAGE INTERPRETATION Keywords: Interpretation, Evaluation, Syntax, Semantics,... Hans Hüttel/ Claus Brabrand PROGRAMMING PARADIGMS Autumn 2010

40 Expressions (and syntax vs. semantics) Expressions: Syntax: Exp : N [const] : +(Exp,Exp) [add] : *(Exp,Exp) [mul] Big-step semantics (via transition relation: " - eval Exp N "): here in prefix notation just to emphasize difference between syntax and semantics [const] _ eval N N [add] _ eval E 1 N 1 _ eval E 2 N 2 _ eval +(E 1,E 2 ) N N = N 1 N 2 syntactic "+" semantic [mul] _ eval E 1 N 1 _ eval E 2 N 2 _ eval *(E 1,E 2 ) N N = N 1 N 2 multiple levels of abstraction...!

41 Expressions (in PROLOG) Syntax: exp(con(n)) :- number(n). exp(add(e 1,E 2 )) :- exp(e 1 ), exp(e 2 ). exp(mul(e 1,E 2 )) :- exp(e 1 ), exp(e 2 ). Semantics:?- exp(mul(add(con(2),con(4)),con(7))). Yes eval(con(n), N). eval(add(e 1,E 2 ),N) :- eval(e 1,N 1 ), eval(e 2,N 2 ), N is N 1 + N 2. eval(mul(e 1,E 2 ),N) :- eval(e 1,N 1 ), eval(e 2,N 2 ), N is N 1 * N 2.?- eval(mul(add(con(2),con(4)),con(7)),x). X = 42 eval(n, N) :- number(n). binary infix syntax eval(e 1 +E 2,N) :- eval(e 1,N 1 ), eval(e 2,N 2 ), N is N 1 + N 2. eval(e 1 *E 2,N) :- eval(e 1,N 1 ), eval(e 2,N 2 ), N is N 1 * N 2.?- eval((2+4)*7,x). X = 42 binary infix syntax

42 The Bims Language Bims is a language of simple imperative constructs: Syntax: Semantics: A ::= N // const X // var A A, {+,-,*,/} // binop S ::= skip // skip X := A // assign if ( A ) then S else S // if while ( A = A ) do S // while S ; S // sequence Similar techniques (albeit somewhat more complicated)...

43 The Lambda Calculus Syntax e ::= x λx.e e 1 e 2 Semantics (call-by-value) You only have to understand here that The Lambda Calculus can be encoded in PROLOG (Var) env x v where env(x) =v (Apply) env e 2 v 2 env e 1 v 1 env[x v 2 ] e v env e 1 e 2 v

44 The Lambda Calculus (in PROLOG) Syntax: << Exercise 4 >> Semantics: Similar techniques (as with the expression language)?- eval(apply(lambda(x,variable(x)), lambda(y,variable(y)), Res). Res = lambda(y,variable(y))

45 NON-TERMINATION Keywords: Turing-Completeness, Reduction, Self-referentiality, Undecidability,... Hans Hüttel/ Claus Brabrand PROGRAMMING PARADIGMS Autumn 2010

46 Turing machines in Prolog It is straightforward to represent a Turing machine (Q, Σ,δ,q 0,q accept,q reject ) The tape is represented by two lists: a b b b b b a b a a L1 (reversed!) L2 So here L1 = [b,b,b,b,a,b,b] and L2 = [B,b,b,a,b,a,a] The transition function is implemented by a predicate move that describes how L1 and L2 should be updated. We can use this to implement a predicate accept to check if M accepts input w.

47 Undecidability (of failure in Prolog) Assume failure was decidable (in Java); i.e. some Java program, fails: PROLOG BOOL, can answer if a Prolog query will fail. But then the acceptance problem is decidable; encode a Turing machine M in Prolog and pose the query accepts(m,w). This query fails if and only if M does not accept w. Hence: Failure is undecidable A TM

48 Exercise 4, 5, and (6): 14:00 15:15 Hans Hüttel/ Claus Brabrand PROGRAMMING PARADIGMS Autumn 2010

50 5....

51 (6).... Purpose: Learn how to...

52 The End Questions? Good luck at the exam (!) Hans Hüttel/ Claus Brabrand PROGRAMMING PARADIGMS Autumn 2010

53 Terminology Predicates vs. Structured data: vertical(line(point(x,y),point(x,z)). odd(succ(0)). Predicate/relation (being defined) structured data predicate structured data (being defined) Arities and Signatures: "Arity" "Signature" #arguments of a function/relation: (unary, binary, ternary,..., N-ary,...) type of a function/relation: (e.g.: "+ fun ": Z Z Z ; "= rel " Z Z )