Controlling Backtracking : Cuts - PowerPoint PPT Presentation

controlling backtracking cuts n.
Download
Skip this Video
Loading SlideShow in 5 Seconds..
Controlling Backtracking : Cuts PowerPoint Presentation
Download Presentation
Controlling Backtracking : Cuts

play fullscreen
1 / 19
Controlling Backtracking : Cuts
121 Views
Download Presentation
varden
Download Presentation

Controlling Backtracking : Cuts

- - - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript

  1. Controlling Backtracking : Cuts t.k.prasad@wright.edu http://www.knoesis.org/tkprasad/ L6Backtracking

  2. Motivation • Efficiency by preventing needless backtracking • Cf. CFL Parsing • Lookaheadsvs Backtracking vs Dynamic programming • Avoiding duplicates or resatisfaction • Prolog as programming language • Tailoring control strategy L6Backtracking

  3. Efficiency Cut • Preventing backtracking when faced with mutually disjoint cases sign(X, positive) :- X > 0. sign(X, negative) :- X < 0. sign(X, zero). L6Backtracking

  4. (cont’d) • Good use of cut if declarative reading preserved • In general, reordering of clauses may not preserve the declarative meaning. sign(X, positive) :- X > 0, !. sign(X, negative) :- X < 0, !. sign(X, zero). L6Backtracking

  5. Green Cut vs Red Cut • A use of a cut which improves only efficiency of a program, without altering its declarative meaning, is referred to as a green cut. • In practice, prunes away irrelevant proofs, or proofs bound to fail. • In practice, use them when mutually exclusive cases occur, or if non-determinism can be minimized. L6Backtracking

  6. Green Cut vs Red Cut • A use of a cut that alters the declarative meaning of a program is referred to as a red cut. • In practice, eliminates unwanted logical solutions • Note that mature Prolog implementations index clauses for a predicate on the principal functor of the first argument in the head of a clause thereby reducing non-determinism. p(f(_),_,_) :- q1(…), …, qn(…). L6Backtracking

  7. Implementing Conditional • “p(x) :- if c(x) then r(x) else q(x)” p(X) :- c(X), !, r(X). p(X) :- q(X). • In this case, reordering of clauses changes the meaning. L6Backtracking

  8. Avoiding Duplicates member(X,[X|L]) :- !. member(X,[_|L]) :- member(X,L). • Without cut, the goal ?- member(a, [a, a, a]) will succeed thrice. • Note that with cut member-predicate cannot be used to generate/enumerate elements in a list. That is, invertibility is destroyed. L6Backtracking

  9. Bugs with Cuts min(X, Y, X) :- X =< Y, !. min(X, Y, Y). • Flaw: the goal ?- min(3,6,6) does not fail. • Reason: min(3,6,6) does not unify with min(X,Y,X). • Fix : change first rule to: min(X, Y, Z) :- X =< Y,!,Z = X. L6Backtracking

  10. Effect of Cut Matching Rule: H :- B1, B2, …, Bm,!, …, Bn. Goal: ?-G. When “!” is encountered, the bindings for variables in goals B1, …,Bm, and G are frozen. That is, alternate solutions to B1, …, Bm, and remaining alternatives for G are discarded. Note that the ordering of body literals and clauses becomes significant in the presence of cut. L6Backtracking

  11. Effect of Cut p(X) :- q(X), r(X), !, s(X). p(d). Declarative Reading (ignoring cut): { p(d)} Procedural reading (using cut): { p(d)} ?- p(X). -> one solution ?- p(a). -> no ?- p(d). -> yes L6Backtracking

  12. Effect of Cut p(X) :- q(X), r(X), !, s(X). p(d). • Additional Facts: {q(a),r(a),s(a)} Declarative Reading : { p(a), p(d)} Procedural reading : { p(a)} ?- p(X). -> X = a ?- p(a). -> yes ?- p(d). -> yes L6Backtracking

  13. (cont’d) p(X) :- q(X), r(X), !, s(X). p(d). • Additional Facts: {q(b),s(b)} Declarative Reading (ignoring cut): { p(d)} Procedural reading (using cut): { p(d)} ?- p(X). -> X = d ?- p(a). -> no ?- p(d). -> yes L6Backtracking

  14. (cont’d) p(X) :- q(X), r(X), !, s(X). p(d). • Additional Facts: {q(c),r(c)} Declarative Reading : { p(d)} Procedural reading : { } ?- p(X). -> no ?- p(c). -> no ?- p(d). -> yes L6Backtracking

  15. (cont’d) p(X) :- q(X), r(X), !, s(X). p(d). • Additional Facts: {q(a),r(a),s(a), q(b),r(b),s(b)} ?- p(X). Declarative Reading (ignoring cut): { p(a), p(b), p(d)} Procedural reading (using cut): { p(a)} L6Backtracking

  16. Disadvantages of Cut • Destroys the declarative reading : Need to know the behavior of the interpreter to understand the meaning (“side-effects”) p :- a, b. p :- c. p :- a, !, b. p :- c. p :- c. p :- a, !, b. L6Backtracking

  17. Conditional vs Cut tp(X,Y) :- q(X) -> r(Y) ; s(Y). tp(m,m). tp(n,n). is not equivalent to sp(X,Y) :- q(X),!,r(Y). sp(X,Y) :- s(Y). sp(m,m). sp(n,n). q(a). q(c). r(e). r(f). s(g). s(h). L6Backtracking

  18. (cont’d) • ?- tp(X,Y). X = a Y = e X = a Y = f X = m Y = m X = n Y = n • Local cut • ?- sp(X,Y). X = a Y = e X = a Y = f • sp-goal is not resatisfied for sp-facts because of the cut. L6Backtracking

  19. Other uses of Cut • Implementing default or otherwise clause. a(X,Y) :- p1(X), !, q1(X,Y). … a(X,Y) :- pn(X), !, qn(X,Y). a(X,Y) :- r(X,Y). • Cut-Fail combination to formalize conditions under which failure is guaranteed. a(X) :- p(X), !, fail. L6Backtracking