CSC324 Logic & Relational Programming Illustrated in Prolog

Transcription

1 CSC324 Logic & Relational Programming Illustrated in Prolog Afsaneh Fazly 1 Winter with many thanks to Anya Tafliovich, Gerald Penn and Sheila McIlraith. 1

2 2 admin notes Please check your marks for A1, A2, Midterm on CDF. me if any of the marks is recorded incorrectly. Remember that there will be a lecture/tutorial on Friday March 8, 2 3pm, BA 1190 (by the instructor).

3 Execution of Prolog Programs Unification: variable bindings. Backward Chaining/ Top-Down Reasoning/ Goal-Directed Reasoning: Reduces a goal to one or more subgoals. Backtracking: Systematically searches for all possible solutions that can be obtained via unification and backchaining.

4 Unification: Overview A number/atom unifies only with itself. An uninstantiated variable unifies with any value the variable gets instantiated to that value. Two uninstantiated variables unify the two variables share or co-refer, i.e., as soon as one gets instantiated, so is the other one (to the same value). A term unifies with another term with the same functor, if they have the same number of arguments and all corresponding arguments unify.

5 5 Backward Chaining This is how Prolog satisfies a goal (query): 1. Search the database for a unifying clause. 2. If not found, search fails. 3. Otherwise, mark the place in the database where the unifying clause is found. 4. If unifying clause is a fact instantiate variables (if any). 5. If unifying clause is a rule, instantiate variables, and try to satisfy the subgoals, in order, from left to right.

6 Given the database: male(charlie). male(bob). female(alice). female(eve). Example parent(charlie, bob). parent(eve,bob). parent(charlie,alice). parent(eve,alice). and the query:?- male(charlie). The unifying clause is a fact; no variables returns true. with the query?- male(x). The unifying clause is a fact, with variable X instantiates X to charlie.

7 Given the database & rules: male(charlie). male(bob). female(alice). female(eve). Example parent(charlie, bob). parent(eve,bob). parent(charlie,alice). parent(eve,alice). sibling(x, Y) :- parent(p, X), parent(p, Y). with the query?- sibling(s, bob). The unifying clause is a rule (1) instantiate Y to bob, and X to S (i.e., X and S co-refer), (2) try to satisfy parent(p, S), and then parent(p, bob).

8 8 Backtracking If an attempt to satisfy a goal fails, or if we ask for more answers, Prolog tries to re-satisfy the goal by backtracking, as follows: 1. Move back along the search path to where the unifying clause was found. 2. Un-instantiate any variables that have been instantiated during the search process. 3. Start another search for another unifying clause from where the current unifying clause was found (the place marked in the database).

9 Example male(charlie). parent(charlie, bob). male(bob). parent(eve,bob). female(alice). parent(charlie,alice). female(eve). parent(eve,alice). female(nikki). parent(alice,nikki). grandparent(x, Z) :- parent(x, Y), parent(y, Z).?- grandparent(g, nikki).

10 10?- grandparent(g, nikki). 1. X = G, Z = nikki. Example 2. satisfy parent(g, Y) (2.1) G = charlie, Y = bob. 3. satisfy parent(y=bob, nikki) (3.1) bob = alice. fail 4. uninstantiate G and Y. 5. re-satisfy parent(g, Y) (5.1) G = eve, Y = bob. 6. re-satisfy parent(y=bob, nikki) (6.1) bob = alice. fail 7. re-satisfy parent(g, Y) (7.1) G = charlie, Y = alice. 8. re-satisfy parent(y=alice, nikki) (8.1) alice = alice. success

11 Prolog Search Trees Encapsulate unification, backward chaining, and backtracking. Internal nodes are ordered list of subgoals. Leaves are success nodes or failures, where computation can proceed no further. Edges are labeled with variable bindings that occur by unification. Describe all possible computation paths. There can be many success nodes. There can be infinite branches.

12 Prolog Search Trees 1) male(charlie). 5) parent(charlie,bob). 2) male(bob). 6) parent(eve,bob). 3) female(alice). 7) parent(charlie,alice). 4) female(eve). 8) parent(eve,alice). 9) sibling(x, Y) :- parent(p, X), parent(p, Y).?- sibling(alice, Who). Who = bob ; Who = alice ; Who = bob ; Who = alice.

13 13 Trace it by hand Prolog Search Trees

14 Prolog Search Trees?- trace. Unknown message: query(yes) [trace]?- sibling(alice, Who). Call: (8) sibling(alice, _G306)? Call: (9) parent(_l195, alice)? Exit: (9) parent(charlie, alice)? Call: (9) parent(charlie, _G306)? Exit: (9) parent(charlie, bob)? Exit: (8) sibling(alice, bob)? Who = bob ; Redo: (9) parent(charlie, _G306)? Exit: (9) parent(charlie, alice)? Exit: (8) sibling(alice, alice)? Who = alice ;

15 Prolog Search Trees Redo: (9) parent(_l195, alice)? Exit: (9) parent(eve, alice)? Call: (9) parent(eve, _G306)? Exit: (9) parent(eve, bob)? Exit: (8) sibling(alice, bob)? Who = bob ; Redo: (9) parent(eve, _G306)? Exit: (9) parent(eve, alice)? Exit: (8) sibling(alice, alice)? Who = alice. Notice the recursion in this algorithm: find calls find. This reasoning is recursively applied until we reach rules that are facts.

16 16 Logic Programming vs. Prolog Logic Programming: nondeterministic: Arbitrarily choose rule to expand first. Arbitrarily choose subgoal to explore first. Results don t depend on rule and subgoal ordering. Prolog: deterministic: Expand first rule first. Explore first subgoal first. Results may depend on rule and subgoal ordering.

17 An n-element list in Prolog is: Egs: [a, b, c] [] [a, [b, c], d, [], e] [a, X, c, d] Lists in Prolog [ e 1, e 2,..., e n ] or, equivalently, [ e 1 [ e 2 [... e n ]]] Egs: [a Rest] [a [b, c]] stands for [a, b, c] Remember cons in Scheme, and :: in ML.

18 Lists in Prolog List Unification: two lists unify iff they have the same structure and the corresponding elements unify.?- [X, Y, Z] = [john, likes, fish].?- [cat] = [X Y].?- [1,2] = [X Y].

19 Lists in Prolog?- [a,b,c] = [X Y].?- [a,b Z]=[X Y].?- [X,abc,Y]=[X,abc Y].?- [[the Y] Z] = [[X,there] [is,here]].

20 Some Notation We write mem/2 to specify a predicate mem with 2 arguments. We specify preconditions on arguments using the following notation: +ArgName means ArgName must be instantiated -ArgName means ArgName must be not instantiated?argname means ArgName may or may not be instantiated. E.g., mem(?x,?list) is a predicate with 2 arguments, both may or may not be instantiated when called. Note: the notation is for documentation / clarification purposes, and not a part of Prolog syntax.

21 21 Lists in Prolog % mem(?x,?list) iff X is an element of List In English: mem(x,list) holds iff X is the first element of List, or X is a member of the rest of List. In Prolog: mem(x,[x _]). mem(x,[_ Rest]) :- mem(x,rest).

22 Lists in Prolog % mem(?x,?list) iff X is an element of List mem(x,[x _]). mem(x,[_ Rest]) :- mem(x,rest).?- mem(a, [a,b,c]). true.?- mem(b, [a,c]). false.?- mem(x, [a,b,c]). X = a ; X = b ; X = c ; false.

23 Lists in Prolog?- mem(a, X). X = [a _G236] ; X = [_G235, a _G239] ; X = [_G235, _G238, a _G242] ; X = [_G235, _G238, _G241, a _G245] ; X = [_G235, _G238, _G241, _G244, a _G248].

24 Lists in Prolog?- trace. [trace]?- mem(c,[a,b,c,d]). Call: (7) mem(c, [a, b, c, d])? Call: (8) mem(c, [b, c, d])? Call: (9) mem(c, [c, d])? Exit: (9) mem(c, [c, d])? Exit: (8) mem(c, [b, c, d])? Exit: (7) mem(c, [a, b, c, d])? true

25 Lists in Prolog [trace]?- mem(x,[a,b,c,d]). Call: (7) mem(_g314, [a, b, c, d])? Exit: (7) mem(a, [a, b, c, d])? X = a ; Redo: (7) mem(_g314, [a, b, c, d])? Call: (8) mem(_g314, [b, c, d])? Exit: (8) mem(b, [b, c, d])? Exit: (7) mem(b, [a, b, c, d])? X = b ; Redo: (8) mem(_g314, [b, c, d])? Call: (9) mem(_g314, [c, d])? Exit: (9) mem(c, [c, d])? Exit: (8) mem(c, [b, c, d])? Exit: (7) mem(c, [a, b, c, d])?

26 Lists in Prolog X = c ; Redo: (9) mem(_g314, [c, d])? Call: (10) mem(_g314, [d])? Exit: (10) mem(d, [d])? Exit: (9) mem(d, [c, d])? Exit: (8) mem(d, [b, c, d])? Exit: (7) mem(d, [a, b, c, d])? X = d ; Redo: (10) mem(_g314, [d])? Call: (11) mem(_g314, [])? Fail: (11) mem(_g314, [])? false.

27 27 Lists in Prolog % myappend(?x,?y,?z) iff Z is the result of % appending list Y to list X myappend(x,y,z) holds iff: X is empty list ([]), and Z = Y, or Z is a list containing the first element of X, followed by the result of appending Y to the rest of X.

28 Lists in Prolog % myappend(?x,?y,?z) iff Z is the result of... myappend([],y,y). myappend([h T],Y,[H Z]) :- myappend(t,y,z).?- myappend([a],[b,c],y). Y = [a, b, c].?- myappend(x,[b,c],[a,b,c]). X = [a] ; false?- myappend(x,y,[a,b,c]). X = [], Y = [a, b, c] ; X = [a], Y = [b, c] ; X = [a, b], Y = [c] ; X = [a, b, c], Y = [] ; false

29 Lists in Prolog [trace]?- myappend([a,b,c],[d,e],z). Call: (7) myappend([a, b, c], [d, e], _G319)? Call: (8) myappend([b, c], [d, e], _G385)? Call: (9) myappend([c], [d, e], _G388)? Call: (10) myappend([], [d, e], _G391)? Exit: (10) myappend([], [d, e], [d, e])? Exit: (9) myappend([c], [d, e], [c, d, e])? Exit: (8) myappend([b, c], [d, e], [b, c, d, e])? Exit: (7) myappend([a, b, c], [d, e], [a, b, c, d, e])? Z = [a, b, c, d, e].

30 30 Lists in Prolog % mylength(?l,?n) iff N is the length of list L mylength(l,n) holds iff: L = [] and N = 0, or length of rest of L = N - 1.

31 Lists in Prolog % mylength(?l,?n) iff N is the length of list L mylength([],0). mylength([_ T],N) :- mylength(t,n-1).?- mylength([a,b,c],3). false. Why doesn t this work? Let s trace it.

32 Lists in Prolog [trace]?- mylength([a,b,c],3). Call: (7) mylength([a, b, c], 3)? Call: (8) mylength([b, c], 3-1)? Call: (9) mylength([c], 3-1-1)? Call: (10) mylength([], )? Fail: (10) mylength([], )? Fail: (9) mylength([c], 3-1-1)? Fail: (8) mylength([b, c], 3-1)? Fail: (7) mylength([a, b, c], 3)? false. Do you see what s happening here?

33 Lists in Prolog [trace]?- mylength([a,b,c],3). Call: (7) mylength([a, b, c], 3)? Call: (8) mylength([b, c], 3-1)? Call: (9) mylength([c], 3-1-1)? Call: (10) mylength([], )? Fail: (10) mylength([], )? Fail: (9) mylength([c], 3-1-1)? Fail: (8) mylength([b, c], 3-1)? Fail: (7) mylength([a, b, c], 3)? false. Do you see what s happening here? Prolog looks for a unifying clause for , which is equivalent to the term -(-(-(3,1),1),1). need to explicitly tell Prolog to evaluate this term as an arithmetic expression.

34 34 Arithmetic in Prolog What is the result of these queries:?- X = ?- X = 97-65, Y = 32-0, X = Y.?- X = 97-65, Y = 67, Z = 95-Y, X = Z.

35 35 Arithmetic in Prolog What is the result of these queries:?- X = ?- X = 97-65, Y = 32-0, X = Y.?- X = 97-65, Y = 67, Z = 95-Y, X = Z. Notes: Recall that the symbol = stands for unification: X = Y holds iff X and Y unify. Another useful symbol in Prolog is \=: X \= Y holds iff X cannot unify with Y.

36 36 Arithmetic in Prolog To evaluate arithmetic expressions in Prolog, use: expr 1 is expr 2, where expr 2 is fully instantiated. if expr 1 is instantiated, Prolog evaluates the term returns true or false. if expr1 is a variable, it is bound to the result of evaluating expr 2. expr1 < expr2, expr1 > expr2, expr1 =< expr2, or expr1 => expr2, where both expr1 and expr2 are instantiated. note the symbols =< and => for greater/less than or equal.

37 Arithmetic in Prolog?- 5 is 2+3. true.?- X is 2+3. X = 5.?- 5 < 6. true.?- 2+3 < 3+3. true.

38 38 Arithmetic in Prolog % mylength(?l,?n) iff N is the length of list L mylength([],0). mylength([_ T],N) :- N is NT+1, mylength(t,nt).

39 Arithmetic in Prolog % mylength(?l,?n) iff N is the length of list L mylength([],0). mylength([_ T],N) :- N is NT+1, mylength(t,nt).?- mylength([a,b,c],3). ERROR: is/2: Arguments are not sufficiently instantiated Why? [trace]?- mylength([a,b,c],3). Call: (7) mylength([a, b, c], 3)? ^ Call: (8) 3 is _G358+1? ERROR: is/2: Arguments are not sufficiently instantiated ^ Exception: (8) 3 is _G358+1? Exception: (7) mylength([a, b, c], 3)?

40 Arithmetic in Prolog % mylength(?l,?n) iff N is the length of list L mylength([],0). mylength([_ T],N) :- mylength(t,nt), N is NT+1.?- mylength([a,b,c],3). true Notes: This ordering ensures that NT+1 is instantiated when Prolog tries to assign it to N (in N is NT+1). In general, the ordering of subgoals in a rule may matter!

41 How? Lists in Prolog [trace]?- mylength([a,b,c],3). Call: (8) mylength([a, b, c], 3)? Call: (9) mylength([b, c], _L193)? Call: (10) mylength([c], _L212)? Call: (11) mylength([], _L231)? Exit: (11) mylength([], 0)? ^ Call: (11) _L212 is 0+1? ^ Exit: (11) 1 is 0+1? Exit: (10) mylength([c], 1)? ^ Call: (10) _L193 is 1+1? ^ Exit: (10) 2 is 1+1? Exit: (9) mylength([b, c], 2)? ^ Call: (9) 3 is 2+1? ^ Exit: (9) 3 is 2+1? Exit: (8) mylength([a, b, c], 3)? true

42 Lists in Prolog % mylength(?l,?n) iff N is the length of list L mylength([],0). mylength([_ T],N) :- mylength(t,nt), N is NT+1.?- mylength([a,b,c], L). L = 3.?- mylength([x,y], L). L = 2.?- mylength(x, 1). X = [_G226] ; <-- infinite run

43 Lists in Prolog [trace]?- mylength(x, 1).... X = [_G373] ; Redo: (9) mylength(_g374, _L196)? Call: (10) mylength(_g377, _L215)? Exit: (10) mylength([], 0)? ^ Call: (10) _L196 is 0+1? ^ Exit: (10) 1 is 0+1? Exit: (9) mylength([_g376], 1)? ^ Call: (9) 1 is 1+1? ^ Fail: (9) 1 is 1+1?

44 Lists in Prolog Redo: (10) mylength(_g377, _L215)? Call: (11) mylength(_g380, _L227)? Exit: (11) mylength([], 0)? ^ Call: (11) _L215 is 0+1? ^ Exit: (11) 1 is 0+1? Exit: (10) mylength([_g379], 1)? ^ Call: (10) _L196 is 1+1? ^ Exit: (10) 2 is 1+1? Exit: (9) mylength([_g376, _G379], 2)? ^ Call: (9) 1 is 2+1? ^ Fail: (9) 1 is 2+1? Redo: (11) mylength(_g380, _L227)?...

45 45 Logic Programming vs. Prolog What happens if we change the order of rules: % mylength(?l,?n) iff N is the length of list L mylength([_ T],N) :- mylength(t,nt), N is NT+1. mylength([],0).?- mylength([a,b,c], 3). true.?- mylength([a,b,c], N). N = 3.?- mylength(x, 2). ERROR: Out of local stack

46 46 Classifying Terms in Prolog We may wish to enforce some preconditions on the arguments of a predicate, e.g., to prevent mylength from running forever. Here are a few predicates we can use to classify terms: var(x) succeeds if X is an uninstantiated variable. atom(x) succeeds if X stands for a Prolog atom. number(x) succeeds if X stands for a number. Exercise: use var or nonvar(x) to fix mylength. mylength([],0). mylength(l,n) :- \+ var(l), L=[_ T], mylength(t,nt), N is NT+1.

47 Example: Trip Planning A database of facts to deal with trips: plane(x,y) boat(x,y) % there is a direct flight from X to Y % there is a direct boat trip from X to Y Predicates to compute certain things about the trips: a) cruise(x,y) -- there s a possible boat journey from X to Y. b) trip(x,y) -- there s a possible journey (using plane or boat) from X to Y. c) stopover(x,y,s) -- there s a trip from X to Y with stop in S. d) plane_cruise(x,y) -- there s a trip from X to Y that has at least one plane leg, and at least one boat leg. e) cost(x,y,c) -- there s a trip from X to Y with cost < C.

48 An example database: Example: Trip Planning plane(toronto, rochester). plane(toronto, montreal).... boat(toronto, rochester). boat(montreal, rochester). Predicates: a) cruise(x,y) :- boat(x,y). cruise(x,y) :- boat(x,z), cruise(z,y). b) leg(x,y) :- plane(x,y). leg(x,y) :- boat(x,y). trip(x,y) :- leg(x,y). trip(x,y) :- leg(x,z), trip(z,y).

49 49 c) stopover(x,y,s). Example: Trip Planning First, assume that neither X nor Y can equal S. stopover(x,y,s) :- trip(x,s), trip(s,y). Now, assume S could be X or Y (or even both): hop(x,x). hop(x,y) :- trip(x,y). stopover(x,y,s) :- hop(x,s), hop(s,y). d) plane_cruise(x,y) :- plane(x,z), boat(z,y). plane_cruise(x,y) :- boat(x,z), plane(z,y). plane_cruise(x,y) :- leg(x,z), plane_cruise(z,y). plane_cruise(x,y) :- leg(z,y), plane_cruise(x,z).

50 50 Example: Trip Planning Why do we need to have the second rule of plane cruise be plane_cruise(x,y) :- leg(z,y), plane_cruise(x,z). Instead of: plane_cruise(x,y) :- plane_cruise(x,z), leg(z,y).? The latter, while may be more intuitive, gives an infinite recursion! You must avoid left-recursion because of the way Prolog searches through a database.

51 Example: Trip Planning d) cost(x,y,c) We need to add costs to each of the plane and boat predicates, e.g., plane(toronto, rochester, 300), and redefine trip: leg(x,y,c) :- plane(x,y,c). leg(x,y,c) :- boat(x,y,c). trip(x,y,c) :- leg(x,y,c). trip(x,y,c) :- leg(x,z,c1), trip(z,y,c2), C is C1 + C2. Now cost is simple, because trip is doing the addition for us: cost(x,y,c) :- trip(x,y,c_trip), C_trip < C.

52 52 Let s Write Some Predicates with Arithmetic & Lists 1. factorial(n, Ans). 2. sumlist(list, Total). 3. prefix(pre, N, List).

53 Factorial factorial(0,1). factorial(n,f) :- N1 is N-1, factorial(n1,f1), F is N*F1.?- factorial(3,f). F = 6 ; ERROR: user://3:62: Out of local stack Question: What is the problem? Any preconditions? Exercise: Write a more efficient factorial using an accumulator.

54 Sum of List sumlist([],0). sumlist([x Rest],Ans) :- sumlist(rest,partial), Ans is Partial + X. Question: Why is left-recursion not problematic here?

55 Arithmetic Predicates may not be Invertible We may not be able to invert a predicate that involves arithmetic, e.g., compare:?- sumlist([1,2,3,4], A). A = 10.?- sumlist(l, 10). ERROR: user://1:24: is/2: Arguments are not sufficiently instantiated Tip: Every time you use is, you must be sure that the expression on the right will be fully instantiated before is is executed. If necessary, put a precondition on your predicate.

56 Prefix of a List prefix(pre, N, List) :- append(pre, _, List), length(pre, N).?- prefix(pre, 3, [1,2,3,4,5,6]). Pre = [1, 2, 3] ; false.?- prefix([1,2], 3, [1,2,3,4,5]). false.?- prefix([1,2,3], 3, L). L = [1, 2, 3 _G599].

57 57 Negation as Failure No equivalent of logical negation in Prolog: Prolog can only assert that something is true. Prolog cannot assert that something is false. Prolog can assert that the given facts and rules do not allow something to be proven true. Assuming that something unprovable is false is called negation as failure. (Based on a closed world assumption.)

58 Negation as Failure The goal \+(G) (or not G) succeeds whenever the goal G fails.?- member(b, [a,b,c]). true?- \+ member(b, [a,b,c]). false.?- not(member(b, [a,b,c])). false.?- not(member(b, [a,c])). true.

59 Negation as Failure: Disjoint Sets overlap(s1,s2) :- member(x,s1),member(x,s2). disjoint(s1,s2) :- \+(overlap(s1,s2)).?- overlap([a,b,c],[c,d,e]). true?- overlap([a,b,c],[d,e,f]). false?- disjoint([a,b,c],[c,d,e]). false?- disjoint([a,b,c],[d,e,f]). true?- disjoint([a,b,c],x). false %< Not what we wanted

60 Negation as Failure overlap(s1,s2) :- member(x,s1),member(x,s2). disjoint(s1,s2) :- \+(overlap(s1,s2)). [trace]?- disjoint([a,b,c],x). Call: (7) disjoint([a, b, c], _G293)? creep Call: (8) overlap([a, b, c], _G293)? creep Call: (9) lists:member(_l230, [a, b, c])? creep Exit: (9) lists:member(a, [a, b, c])? creep Call: (9) lists:member(a, _G293)? creep Exit: (9) lists:member(a, [a _G352])? creep Exit: (8) overlap([a, b, c], [a _G352])? creep Fail: (7) disjoint([a, b, c], _G293)? creep false

61 61 Proper Use of Negation as Failure not(g) works properly only in the following cases: 1. When G is fully instantiated at the time prolog processes the goal not(g). (In this case, not(g) is interpreted to mean goal G does not succeed.) 2. When all variables in G are unique to G, i.e., they don t appear elsewhere in the same clause. (In this case, not(g(x,y)) is interpreted to mean There is no values of X, Y that will make G(X,Y) succeed.)

62 Negation as Failure woman(jane). woman(marilyn). famous(marilyn). loves(john,x) :- woman(x), famous(x). hates(john,x) :- \+ loves(john,x). There are infinitely many women that John hates, not just Jane:?- hates(john,jane). true?- hates(john,susan). true?- hates(john,betty). true...

63 63 Negation as Failure woman(jane). woman(marilyn). famous(marilyn). loves(john,x) :- woman(x), famous(x). hates(john,x) :- \+ loves(john,x). Plus John hates many things:?- hates(john,pizza).?- hates(john,john). We say that the rule hates is not safe. Solution: hates(john,x) :- woman(x), \+ loves(john,x). woman(x) is called a guard it protects from making unwanted inferences.