1 / 19

Controlling Backtracking : Cuts

Controlling Backtracking : Cuts. t.k.prasad@wright.edu http://www.knoesis.org/tkprasad/. Motivation. Efficiency by preventing needless backtracking Cf. CFL Parsing Lookaheads vs Backtracking vs Dynamic programming Avoiding duplicates or resatisfaction Prolog as programming language

varden
Télécharger la présentation

Controlling Backtracking : Cuts

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

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

More Related