1. Controlling Backtracking : Cuts
cs7120 (Prasad)
L19-Backtracking

2. Motivation Efficiency by preventing needless backtracking
Cf. CFL Parsing
Lookaheads vs Backtracking vs Dynamic programming
Avoiding duplicates or resatisfaction
Prolog as programming language
Tailoring control strategy
Production language parser : linear
General parser : cubic
cs7120 (Prasad)
L19-Backtracking

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

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).
cs7120 (Prasad)
L19-Backtracking

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.
cs7120 (Prasad)
L19-Backtracking

6. p(f(_),_,_) :- q1(…), …, qn(…).
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(…).
Program : index on pred sym and first arg
choose order of args to exploit this
MetaProgram: index o n pred sym
cs7120 (Prasad)
L19-Backtracking

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.
cs7120 (Prasad)
L19-Backtracking

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.
cs7120 (Prasad)
L19-Backtracking

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.
Important to specify the way calls should be made
Expected: Min(?in,?in,^out)  Answer extraction
Trouble: Min(?in,?in,?in)  verification
MODE DECLARATION
cs7120 (Prasad)
L19-Backtracking

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.
cs7120 (Prasad)
L19-Backtracking

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
p(X) vs p(a) /\ p(d)
Declarative meaning essentially same answer all through
Procedural meaning keeps changing depending on whether cut is executed or not
cs7120 (Prasad)
L19-Backtracking

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
p(X) vs p(a) /\ p(d)
cs7120 (Prasad)
L19-Backtracking

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(b) > no
?- p(d) > yes
p(X) vs p(a) /\ p(d)
cs7120 (Prasad)
L19-Backtracking

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
p(X) vs p(a) /\ p(d)
cs7120 (Prasad)
L19-Backtracking

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)}
p(X) vs p(a) /\ p(d)
cs7120 (Prasad)
L19-Backtracking

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.
cuts useful in programming specialized reasoners
cs7120 (Prasad)
L19-Backtracking

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).
p(X) vs p(a) /\ p(d)
cs7120 (Prasad)
L19-Backtracking

18. (cont’d) ?- tp(X,Y). ?- sp(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.
cs7120 (Prasad)
L19-Backtracking

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.
cs7120 (Prasad)
L19-Backtracking