1 / 36

Backward Checking Search BT, BM, BJ, CBJ

Backward Checking Search BT, BM, BJ, CBJ. An example problem. 1. 2. 3. 4. 5. Colour each of the 5 nodes, such that if they are adjacent, they take different colours. Representation (csp1). 1. 2. 3. 4. 5. variables v1, v2, v3, v4, and v5 domains d1, d2, d3, d4, and d5

tress
Download Presentation

Backward Checking Search BT, BM, BJ, CBJ

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. Backward Checking Search BT, BM, BJ, CBJ

  2. An example problem 1 2 3 4 5 Colour each of the 5 nodes, such that if they are adjacent, they take different colours

  3. Representation (csp1) 1 2 3 4 5 • 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)

  4. Chronological Backtracking (BT) 1 2 3 4 5 As a pair of mutually recursive functions bt-label 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)

  5. Chronological Backtracking (BT) 1 2 3 4 5 bt-label 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]

  6. Chronological Backtracking (BT) 1 2 3 4 5 bt-label 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

  7. Chronological Backtracking (BT) 1 2 3 4 5 bt-label 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

  8. Chronological Backtracking (BT) 1 2 3 4 5 bt-unlabel 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 end

  9. Chronological Backtracking (BT) 1 2 3 4 5 bt-unlabel 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 end Past variable

  10. Chronological Backtracking (BT) 1 2 3 4 5 bt-unlabel 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 end Reset domain (bactrackable/reversible variable)

  11. Chronological Backtracking (BT) 1 2 3 4 5 bt-unlabel 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 end recurse

  12. Iterative implementation of BT 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 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 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 This is more realistic. Why?

  13. Chronological Backtracking (BT) 1 2 3 4 5

  14. Three Different Views of Search a trace a tree past, current, future

  15. A Trace of BT (assume domain ordered {R,B,G}) 1 2 3 4 1 1 2 2 5 5 3 3 5 4 4 • 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 16 checks and 12 nodes

  16. A Tree Trace of BT (assume domain ordered {R,B,G}) 1 2 3 v1 v2 v3 v4 v5 4 5

  17. A Tree Trace of BT (assume domain ordered {R,B,G}) 1 2 3 v1 v2 v3 v4 v5 4 5

  18. A Tree Trace of BT (assume domain ordered {R,B,G}) 1 2 3 v1 v2 v3 v4 v5 4 5

  19. A Tree Trace of BT (assume domain ordered {R,B,G}) 1 2 3 v1 v2 v3 v4 v5 4 5

  20. A Tree Trace of BT (assume domain ordered {R,B,G}) 1 2 3 v1 v2 v3 v4 v5 4 5

  21. A Tree Trace of BT (assume domain ordered {R,B,G}) 1 2 3 v1 v2 v3 v4 v5 4 5

  22. A Tree Trace of BT (assume domain ordered {R,B,G}) 1 2 3 5 4 v1 v2 v3 v4 v5

  23. A Tree Trace of BT (assume domain ordered {R,B,G}) 1 2 3 5 4 v1 v2 v3 v4 v5

  24. A Tree Trace of BT (assume domain ordered {R,B,G}) 1 2 3 5 4 v1 v2 v3 v4 v5

  25. A Tree Trace of BT (assume domain ordered {R,B,G}) 1 2 3 5 4 v1 v2 v3 v4 v5

  26. A Tree Trace of BT (assume domain ordered {R,B,G}) 1 2 3 5 4 v1 v2 v3 v4 v5

  27. A Tree Trace of BT (assume domain ordered {R,B,G}) 1 2 3 5 4 v1 v2 v3 v4 v5

  28. A Tree Trace of BT (assume domain ordered {R,B,G}) 1 2 3 5 4 v1 v2 v3 v4 v5

  29. 1 v1 2 v2 v3 3 v4 4 v5 5 Another view past variables check back current variable future variables

  30. 1 2 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

  31. 1 2 3 9 4 7 8 5 6 Thrashing? (csp3c)

  32. 1 2 3 9 4 7 8 5 6 Thrashing? (csp3c) 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

  33. Where’s the code? See clairExamples/bt*.cl and clairExample/csp*.cl

  34. 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 1st reference to BT? • Golomb & Baumert JACM 12, 1965?

More Related