Download presentation

Presentation is loading. Please wait.

Published byLaurel Tinley Modified over 2 years ago

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

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

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

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

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

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

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

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

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?

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

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

OK

Constraint Satisfaction CSE 473 University of Washington.

Constraint Satisfaction CSE 473 University of Washington.

© 2018 SlidePlayer.com Inc.

All rights reserved.

Ads by Google

Ppt on tropical deciduous forest in india Ppt on unsustainable to sustainable development Ppt on sets for class 11 cbse Ppt on values attitudes and job satisfaction Ppt on satellite orbiting Holographic 3d display ppt on tv Ppt on 60 years of indian parliament videos Ppt on professional development plan Simple ppt on body language Ppt on panel discussion flyer