Download presentation
Presentation is loading. Please wait.
1
Backward Checking Search BT, BM, BJ, CBJ
4
An example problem Colour each of the 5 nodes, such that if they are adjacent, they take different colours 12 3 4 5
5
Representation (csp1) variables v1, v2, v3, v4, and v5 domains d1, d2, d3, d4, and d5 domains are the three colours {R,B,G} constraints v1 v2 v1 v3 v2 v3 v2 v5 v3 v5 v4 v5 Assign a value to each variable, from its domain, such that the constraints are satisfied CSP = (V,D,C) 12 3 4 5
6
Chronological Backtracking (BT) 12 3 4 5 bt-label(i,v,d,cd,n) begin if i > n then return “solution” else begin consistent := false; for v[i] cd[i] while ¬consistent do begin consistent := true; for h := 1 to i-1 while consistent do consistent := check(v,i,h); if ¬consistent then cd[i] := cd[i] \ v[i]; end if consistent then bt-label(i+1,v,d,cd,n) else bt-unlabel(i,v,d,cd,n) end i the index of the current variable h the index of a past variable (local) v an array of variables to be instantiated d an array of domains cd an array of current domains n the number of variables constraints are binary. consistent is boolean (local) bt(v,d,n) = for i := 1 to n cd[i] := d[i]; return bt-label(1,v,d,cd,n) As a pair of mutually recursive functions bt-label
![Chronological Backtracking (BT) bt-label(i,v,d,cd,n) begin if i > n then return solution else begin consistent := false; for v[i] cd[i] while ¬consistent do begin consistent := true; for h := 1 to i-1 while consistent do consistent := check(v,i,h); if ¬consistent then cd[i] := cd[i] \ v[i]; end if consistent then bt-label(i+1,v,d,cd,n) else bt-unlabel(i,v,d,cd,n) end i the index of the current variable h the index of a past variable (local) v an array of variables to be instantiated d an array of domains cd an array of current domains n the number of variables constraints are binary.](http://images.slideplayer.com/11/3188079/slides/slide_6.jpg "consistent is boolean (local) bt(v,d,n) = for i := 1 to n cd[i] := d[i]; return bt-label(1,v,d,cd,n) As a pair of mutually recursive functions bt-label.")
7
Chronological Backtracking (BT) 12 3 4 5 bt-label(i,v,d,cd,n) begin if i > n then return “solution” else begin consistent := false; for v[i] cd[i] while ¬consistent do begin consistent := true; for h := 1 to i-1 while consistent do consistent := check(v,i,h); if ¬consistent then cd[i] := cd[i] \ v[i]; end if consistent then bt-label(i+1,v,d,cd,n) else bt-unlabel(i,v,d,cd,n) end Find a consistent instantiation for v[i] bt-label
![Chronological Backtracking (BT) bt-label(i,v,d,cd,n) begin if i > n then return solution else begin consistent := false; for v[i] cd[i] while ¬consistent do begin consistent := true; for h := 1 to i-1 while consistent do consistent := check(v,i,h); if ¬consistent then cd[i] := cd[i] \ v[i]; end if consistent then bt-label(i+1,v,d,cd,n) else bt-unlabel(i,v,d,cd,n) end Find a consistent instantiation for v[i] bt-label](http://images.slideplayer.com/11/3188079/slides/slide_7.jpg "Chronological Backtracking (BT) bt-label(i,v,d,cd,n) begin if i > n then return solution else begin consistent := false; for v[i] cd[i] while ¬consistent do begin consistent := true; for h := 1 to i-1 while consistent do consistent := check(v,i,h); if ¬consistent then cd[i] := cd[i] \ v[i]; end if consistent then bt-label(i+1,v,d,cd,n) else bt-unlabel(i,v,d,cd,n) end Find a consistent instantiation for v[i] bt-label")
8
Chronological Backtracking (BT) 12 3 4 5 bt-label(i,v,d,cd,n) begin if i > n then return “solution” else begin consistent := false; for v[i] cd[i] while ¬consistent do begin consistent := true; for h := 1 to i-1 while consistent do consistent := check(v,i,h); if ¬consistent then cd[i] := cd[i] \ v[i]; end if consistent then bt-label(i+1,v,d,cd,n) else bt-unlabel(i,v,d,cd,n) end check backwards, from current to past bt-label
![Chronological Backtracking (BT) bt-label(i,v,d,cd,n) begin if i > n then return solution else begin consistent := false; for v[i] cd[i] while ¬consistent do begin consistent := true; for h := 1 to i-1 while consistent do consistent := check(v,i,h); if ¬consistent then cd[i] := cd[i] \ v[i]; end if consistent then bt-label(i+1,v,d,cd,n) else bt-unlabel(i,v,d,cd,n) end check backwards, from current to past bt-label](http://images.slideplayer.com/11/3188079/slides/slide_8.jpg "Chronological Backtracking (BT) bt-label(i,v,d,cd,n) begin if i > n then return solution else begin consistent := false; for v[i] cd[i] while ¬consistent do begin consistent := true; for h := 1 to i-1 while consistent do consistent := check(v,i,h); if ¬consistent then cd[i] := cd[i] \ v[i]; end if consistent then bt-label(i+1,v,d,cd,n) else bt-unlabel(i,v,d,cd,n) end check backwards, from current to past bt-label")
9
Chronological Backtracking (BT) 12 3 4 5 bt-label(i,v,d,cd,n) begin if i > n then return “solution” else begin consistent := false; for v[i] cd[i] while ¬consistent do begin consistent := true; for h := 1 to i-1 while consistent do consistent := check(v,i,h); if ¬consistent then cd[i] := cd[i] \ v[i]; end if consistent then bt-label(i+1,v,d,cd,n) else bt-unlabel(i,v,d,cd,n) end recurse bt-label
![Chronological Backtracking (BT) bt-label(i,v,d,cd,n) begin if i > n then return solution else begin consistent := false; for v[i] cd[i] while ¬consistent do begin consistent := true; for h := 1 to i-1 while consistent do consistent := check(v,i,h); if ¬consistent then cd[i] := cd[i] \ v[i]; end if consistent then bt-label(i+1,v,d,cd,n) else bt-unlabel(i,v,d,cd,n) end recurse bt-label](http://images.slideplayer.com/11/3188079/slides/slide_9.jpg "Chronological Backtracking (BT) bt-label(i,v,d,cd,n) begin if i > n then return solution else begin consistent := false; for v[i] cd[i] while ¬consistent do begin consistent := true; for h := 1 to i-1 while consistent do consistent := check(v,i,h); if ¬consistent then cd[i] := cd[i] \ v[i]; end if consistent then bt-label(i+1,v,d,cd,n) else bt-unlabel(i,v,d,cd,n) end recurse bt-label")
10
Chronological Backtracking (BT) 12 3 4 5 bt-unlabel(i,v,d,cd,n) begin if i > 0 then return “fail” else begin h := i – 1; cd[h] := cd[h] \ v[h]; cd[i] := d[i]; if cd[h] ≠ nil then bt-label(h,v,d,cd,n) else bt-unlabel(h,v,d,cd,n) end bt-unlabel
![Chronological Backtracking (BT) bt-unlabel(i,v,d,cd,n) begin if i > 0 then return fail else begin h := i – 1; cd[h] := cd[h] \ v[h]; cd[i] := d[i]; if cd[h] ≠ nil then bt-label(h,v,d,cd,n) else bt-unlabel(h,v,d,cd,n) end bt-unlabel](http://images.slideplayer.com/11/3188079/slides/slide_10.jpg "Chronological Backtracking (BT) bt-unlabel(i,v,d,cd,n) begin if i > 0 then return fail else begin h := i – 1; cd[h] := cd[h] \ v[h]; cd[i] := d[i]; if cd[h] ≠ nil then bt-label(h,v,d,cd,n) else bt-unlabel(h,v,d,cd,n) end bt-unlabel")
11
Chronological Backtracking (BT) 12 3 4 5 bt-unlabel(i,v,d,cd,n) begin if i > 0 then return “fail” else begin h := i – 1; cd[h] := cd[h] \ v[h]; cd[i] := d[i]; if cd[h] ≠ nil then bt-label(h,v,d,cd,n) else bt-unlabel(h,v,d,cd,n) end Past variable bt-unlabel
![Chronological Backtracking (BT) bt-unlabel(i,v,d,cd,n) begin if i > 0 then return fail else begin h := i – 1; cd[h] := cd[h] \ v[h]; cd[i] := d[i]; if cd[h] ≠ nil then bt-label(h,v,d,cd,n) else bt-unlabel(h,v,d,cd,n) end Past variable bt-unlabel](http://images.slideplayer.com/11/3188079/slides/slide_11.jpg "Chronological Backtracking (BT) bt-unlabel(i,v,d,cd,n) begin if i > 0 then return fail else begin h := i – 1; cd[h] := cd[h] \ v[h]; cd[i] := d[i]; if cd[h] ≠ nil then bt-label(h,v,d,cd,n) else bt-unlabel(h,v,d,cd,n) end Past variable bt-unlabel")
12
Chronological Backtracking (BT) 12 3 4 5 bt-unlabel(i,v,d,cd,n) begin if i > 0 then return “fail” else begin h := i – 1; cd[h] := cd[h] \ v[h]; cd[i] := d[i]; if cd[h] ≠ nil then bt-label(h,v,d,cd,n) else bt-unlabel(h,v,d,cd,n) end Reset domain (bactrackable/reversible variable) bt-unlabel
![Chronological Backtracking (BT) bt-unlabel(i,v,d,cd,n) begin if i > 0 then return fail else begin h := i – 1; cd[h] := cd[h] \ v[h]; cd[i] := d[i]; if cd[h] ≠ nil then bt-label(h,v,d,cd,n) else bt-unlabel(h,v,d,cd,n) end Reset domain (bactrackable/reversible variable) bt-unlabel](http://images.slideplayer.com/11/3188079/slides/slide_12.jpg "Chronological Backtracking (BT) bt-unlabel(i,v,d,cd,n) begin if i > 0 then return fail else begin h := i – 1; cd[h] := cd[h] \ v[h]; cd[i] := d[i]; if cd[h] ≠ nil then bt-label(h,v,d,cd,n) else bt-unlabel(h,v,d,cd,n) end Reset domain (bactrackable/reversible variable) bt-unlabel")
13
Chronological Backtracking (BT) 12 3 4 5 bt-unlabel(i,v,d,cd,n) begin if i > 0 then return “fail” else begin h := i – 1; cd[h] := cd[h] \ v[h]; cd[i] := d[i]; if cd[h] ≠ nil then bt-label(h,v,d,cd,n) else bt-unlabel(h,v,d,cd,n) end recurse bt-unlabel
![Chronological Backtracking (BT) bt-unlabel(i,v,d,cd,n) begin if i > 0 then return fail else begin h := i – 1; cd[h] := cd[h] \ v[h]; cd[i] := d[i]; if cd[h] ≠ nil then bt-label(h,v,d,cd,n) else bt-unlabel(h,v,d,cd,n) end recurse bt-unlabel](http://images.slideplayer.com/11/3188079/slides/slide_13.jpg "Chronological Backtracking (BT) bt-unlabel(i,v,d,cd,n) begin if i > 0 then return fail else begin h := i – 1; cd[h] := cd[h] \ v[h]; cd[i] := d[i]; if cd[h] ≠ nil then bt-label(h,v,d,cd,n) else bt-unlabel(h,v,d,cd,n) end recurse bt-unlabel")
14
search(n,status) begin consistent := true; status := “unknown”; i := 1; while status = “unknown” do begin if consistent then i := label(i,consistent) else i := unlabel(i,consistent); if i > n then status = “solution” else if i = 0 then status := “impossible” end bt-label(i,consistent) begin consistent := false; for v[i] in cd[i] while ¬consitent do begin consistent := true; for h := 1 to i-1 while consistent do consistent := check(v,i,h); if ¬consistent then cd[i] := cd[i] \ v[i]; end; if consistent then return i+1 else return I end bt-unlabel(i,consistent) begin h := i-1; cd[i] := d[i]; cd[h] := cd[h] \ v[h]; consistent := cd[h] ≠ nil return h; end Iterative implementation of BT This is more realistic. Why?
![search(n,status) begin consistent := true; status := unknown ; i := 1; while status = unknown do begin if consistent then i := label(i,consistent) else i := unlabel(i,consistent); if i > n then status = solution else if i = 0 then status := impossible end bt-label(i,consistent) begin consistent := false; for v[i] in cd[i] while ¬consitent do begin consistent := true; for h := 1 to i-1 while consistent do consistent := check(v,i,h); if ¬consistent then cd[i] := cd[i] \ v[i]; end; if consistent then return i+1 else return I end bt-unlabel(i,consistent) begin h := i-1; cd[i] := d[i]; cd[h] := cd[h] \ v[h]; consistent := cd[h] ≠ nil return h; end Iterative implementation of BT This is more realistic.](http://images.slideplayer.com/11/3188079/slides/slide_14.jpg "Why .")
15
Chronological Backtracking (BT) 12 3 4 5
16
Three Different Views of Search a trace a tree past, current, future
17
V[1] := R V[2] := R check(v[1],v[2]) fails V[2] := B check(v[1],v[2]) good V[3] := R check(v[1],v[3]) fails V[3] := B check(v[1],v[3]) good check(v[2],v[3]) fails V[3] := G check(v[1],v[3]) good check(v[2],v[3]) good V[4] := R V[5] := R check(v[2],v[5]) good check(v[3],v[5]) good check(v[4],v[5]) fails V[5] := B check(v[2],v[5]) fails V[5] := G check(v[2],v[5]) good check(v[3],v[5]) fails backtrack! V[4] := B V[5] := R check(v[2],v[5]) good check(v[3],v[5]) good check(v[4],v[5]) good solution found A Trace of BT (assume domain ordered {R,B,G}) 12 3 4 5 3 12 4 5 16 checks and 12 nodes 3 12 4 5
![V[1] := R V[2] := R check(v[1],v[2]) fails V[2] := B check(v[1],v[2]) good V[3] := R check(v[1],v[3]) fails V[3] := B check(v[1],v[3]) good check(v[2],v[3]) fails V[3] := G check(v[1],v[3]) good check(v[2],v[3]) good V[4] := R V[5] := R check(v[2],v[5]) good check(v[3],v[5]) good check(v[4],v[5]) fails V[5] := B check(v[2],v[5]) fails V[5] := G check(v[2],v[5]) good check(v[3],v[5]) fails backtrack.](http://images.slideplayer.com/11/3188079/slides/slide_17.jpg "V[4] := B V[5] := R check(v[2],v[5]) good check(v[3],v[5]) good check(v[4],v[5]) good solution found A Trace of BT (assume domain ordered {R,B,G}) checks and 12 nodes")
18
A Tree Trace of BT (assume domain ordered {R,B,G}) 12 3 4 5 v1 v2 v3 v4 v5
19
A Tree Trace of BT (assume domain ordered {R,B,G}) 1 2 3 4 5 v1 v2 v3 v4 v5
20
A Tree Trace of BT (assume domain ordered {R,B,G}) 12 3 4 5 v1 v2 v3 v4 v5
21
A Tree Trace of BT (assume domain ordered {R,B,G}) 12 3 4 5 v1 v2 v3 v4 v5
22
A Tree Trace of BT (assume domain ordered {R,B,G}) v1 v2 v3 v4 v5 12 3 4 5
23
A Tree Trace of BT (assume domain ordered {R,B,G}) v1 v2 v3 v4 v5 12 3 4 5
24
A Tree Trace of BT (assume domain ordered {R,B,G}) v1 v2 v3 v4 v5 12 3 4 5
25
A Tree Trace of BT (assume domain ordered {R,B,G}) v1 v2 v3 v4 v5 12 3 4 5
26
A Tree Trace of BT (assume domain ordered {R,B,G}) v1 v2 v3 v4 v5 12 3 4 5
27
A Tree Trace of BT (assume domain ordered {R,B,G}) v1 v2 v3 v4 v5 12 3 4 5
28
A Tree Trace of BT (assume domain ordered {R,B,G}) v1 v2 v3 v4 v5 12 3 4 5
29
A Tree Trace of BT (assume domain ordered {R,B,G}) v1 v2 v3 v4 v5 12 3 4 5
30
A Tree Trace of BT (assume domain ordered {R,B,G}) v1 v2 v3 v4 v5 12 3 4 5
31
Another view 12 3 4 5 v1 v2 v3 v4 v5 current variable past variables future variables check back
32
12 3 4 5 Can you solve this (csp2)? Try bt1 and/or bt2 with constraints C2 - load(“bt2”) - bt(V,D,C2) this is csp2
33
Thrashing? (csp3c) 12 3 9 4 5 6 7 8
34
12 3 9 4 5 6 7 8 V1 = R v2 = B v3 = G v4 = R v5 = B v6 = R v7 = B v8 = R v9 = conflict The cause of the conflict with v9 is v4, but what will bt do? Find out how it goes with bt3 and csp4
35
Where’s the code? See clairExamples/bt*.cl and clairExample/csp*.cl
36
questions Why measure checks and nodes? What is a node anyway? Who cares about checks? Why instantiate variables in lex order? Would a different order make a difference? How many nodes could there be? How many checks could there be? Are all csp’s binary? How can we represent constraints? Is it reasonable to separate V from D? Why not have variables with domains What is a constraint graph? How can (V,D,C) be a graph? What is BT “thinking about”? i.e. why is it so dumb? What could we do to make BT smarter? Is BT doing any inferencing/propagation? What’s the 1 st reference to BT? Golomb & Baumert JACM 12, 1965?
Similar presentations
![Fc. Consider the following problem (csp5) variables V[1] to V[10] uniform domains D[1] to D[10] = {1,2,3} constraints V[1] = V[4] V[4] > V[7] V[7] = V[10]](/9/2536224/big_thumb.jpg "Fc. Consider the following problem (csp5) variables V[1] to V[10] uniform domains D[1] to D[10] = {1,2,3} constraints V[1] = V[4] V[4] > V[7] V[7] = V[10]>")
