Problem Solving with Constraints Intelligent Backtracking Algorithms 1 Problem Solving with...

Problem Solving with Constraints

Intelligent Backtracking Algorithms 1

Problem Solving with ConstraintsCSCE496/896, Fall2011:

www.cse.unl.edu/~choueiry/F11-496-896

Berthe Y. Choueiry (Shu-we-ri)Avery Hall, Room 360choueiry@cse.unl.edu

Intelligent Backtracking Algorithms

Reading• Required reading

– Hybrid Algorithms for the Constraint Satisfaction Problem [Prosser, CI 93]

• Recommended reading– Chapters 5 and 6 of Dechter’s textbook– Tsang, Chapter 5

• Available upon request– Notes of Fahiem Bacchus: Chapter 2, Section 2.4

Outline• Review of terminology of search • Hybrid backtracking algorithms

Backtrack search (BT)

Var 1 v1 v2

• Variable/value ordering

• Variable instantiation

• (Current) path

• Current variable

• Past variables

• Future variables

• Shallow/deep levels /nodes

• Search space / search tree

• Back-checking

• Backtracking

– Vanilla: BT– Improving back steps: {BJ, CBJ} – Improving forward step: {BM, FC}

Two main mechanisms in BT1. Backtracking:

• To recover from dead-ends • To go back

2. Consistency checking: • To expand consistent paths• To move forward

BacktrackingTo recover from dead-ends

1. Chronological (BT)2. Intelligent

• Backjumping (BJ)• Conflict directed backjumping (CBJ)• With learning algorithms (Dechter Chapt 6.4)• Etc.

Consistency checkingTo expand consistent paths1. Back-checking: against past variables

• Backmarking (BM)2. Look-ahead: against future variables

• Forward checking (FC) (partial look-ahead)• Directional Arc-Consistency (DAC) (partial

look-ahead)• Maintaining Arc-Consistency (MAC) (full

look-ahead)

Hybrid algorithmsBacktracking + checking = new hybrids

BT BJ CBJBM BMJ BM-CBJFC FC-BJ FC-CBJ

Evaluation:

• Empirical: Prosser 93. 450 instances of Zebra

• Theoretical: Kondrak & Van Beek 95

Notations (in Prosser’s paper)

• Variables: Vi, i in [1, n]• Domain: Di = {vi1, vi2, …,viMi}• Constraint between Vi and Vj: Ci,j

• Constraint graph: G• Arcs of G: Arc(G)• Instantiation order (static or dynamic)• Language primitives: list, push, pushnew,

remove, set-difference, union, max-list

Main data structures• v: a (1xn) array to store assignments

– v[i] gives the value assigned to ith variable – v[0]: pseudo variable (root of tree), backtracking to

v[0] indicates insolvability• domain[i]: a (1xn) array to store the original

domains of variables• current-domain[i]: a (1xn) array to store the

current domains of variables– Upon backtracking, current-domain[i] of future

variables must be refreshed• check(i,j): a function that checks whether the

values assigned to v[i] and v[j] are consistent

Generic search: bcssp1. Procedure bcssp (n, status)2. Begin3. consistent true4. status unknown5. i 16. While status = unknown

7. Do Begin8. If consistent

9. Then i label (i, consistent)10. Else i unlabel (i, consistent)

11. If i > n12. Then status “solution”13. Else If i=0 then status “impossible”14. End

15. End

• Forward move: x-label

• Backward move: x-unlabel

• Parameters: i: current variable,consistent: Boolean

• Return: i: new current variable

Chronological backtracking (BT)• Uses bt-label and bt-unlabel• bt-label:

– When v[i] is assigned a value from current-domain[i], we perform back-checking against past variables (check(i,k))

– If back-checking succeeds, bt-label returns i+1– If back-checking fails, we remove the assigned value from

current-domain[i], assign the next value in current-domain[i], etc.– If no other value exists, consistent nil (bt-unlabel will be called)

• bt-unlabel– Current level is set to i-1 (notation for current variable: v[h])– For all future variables j: current-domain[j] domain[j]– If domain[h] is not empty, consistent true (bt-label will be called)– Note: for all past variables g, current-domain[g] domain[g]

BT-label1. Function bt-label(i,consistent): INTEGER2. BEGIN3. consistent false4. For v[i] each element of current-domain[i] while not consistent

5. Do Begin6. consistent true7. For h 1 to (i-1) While consistent8. Do consistent check(i,h)9. If not consistent10. Then current-domain[i] remove(v[i], current-domain[i])11. End

12. If consistent then return(i+1) ELSE return(i)13. END

Terminates:

• consistent=true, return i+1

• consistent=false, current-domain[i]=nil, returns i

BT-unlabel1. FUNCTION bt-unlabel(i,consistent):INTEGER2. BEGIN

3. h i -14. current-domain[i] domain[i]5. current-domain[h] remove(v[h],current-domain[h])6. consistent current-domain[h] nil7. return(h)

8. END • Is called when consistent=false and current-domain[i]=nil

• Selects vh to backtrack to

• (Uninstantiates all variables between vh and vi)

• Uninstantiates v[h]: removes v[h] from current-domain [h]:

• Sets consistent to true if current-domain[h] 0

• Returns h

Example: BT (the dumbest example ever)

{1,2,3,4,5}

CV3,V4={(V3=1,V4=3)}

CV2,V5={(V2=5,V5=1),(V2=5,V5=4)}

21 3 4

2 3 4 5

etc…

– Vanilla: BT– Improving back steps: BJ, CBJ – Improving forward step: BM, FC

Danger of BT: thrashing• BT assumes that the instantiation of v[i]

was prevented by a bad choice at (i-1). • It tries to change the assignment of v[i-1]• When this assumption is wrong, we suffer

from thrashing (exploring ‘barren’ parts of solution space)

• Backjumping (BT) tries to avoid that– Jumps to the reason of failure – Then proceeds as BT

Backjumping (BJ)• Tries to reduce thrashing by saving some

backtracking effort• When v[i] is instantiated, BJ remembers

v[h], the deepest node of past variables that v[i] has checked against.

• Uses: max-check[i], global, initialized to 0• At level i, when check(i,h) succeeds

max-check[i] max(max-check[i], h)• If current-domain[h] is getting empty,

simple chronological backtracking is performed from h– BJ jumps then steps!

h-1h-1

Current variablePast variable

BJ: label/unlabel• bj-label: same as bt-label, but updates max-

check[i]• bj-unlabel, same as bt-unlabel but

– Backtracks to h = max-check[i]– Resets max-check[j] 0 for j in [h+1,i]

Important: max-check is the deepest level we checked against, could have been success or could have been failure

h-1h-1

Example: BJ

{1,2,3,4,5}

CV2,V4={(V2=1,V4=3)}

CV1,V5={(V1=1,V5=2)}

CV2,V5={(V2=5,V5=1)}

v[0] = 0

21 3 4

2 3 4 5

Max-check[1] = 0

Max-check[2] = 1

max-check[4] = 3

max-check[5] = 2

V4=1, fails for V2, mc=2V4=2, fails for V2, mc=2 V4=3, succeeds

V5=1, fails for V1, mc=1V5=2, fails for V2, mc=2V5=3, fails for V1V5=4, fails for V1V5=5, fails for V1

Intelligent Backtracking AlgorithmsBacktracking 22

Conflict-directed backjumping (CBJ)

• Backjumping– jumps from v[i] to v[h], – but then, it steps back from v[h] to v[h-1]

• CBJ improves on BJ– Jumps from v[i] to v[h]– And jumps back again, across conflicts

involving both v[i] and v[h]– To maintain completeness, we jump back to

the level of deepest conflict

CBJ: data structure

• Maintains a conflict set: conf-set• conf-set[i] are first initialized to {0}• At any point, conf-set[i] is a subset of

past variables that are in conflict with i

{0}{0}{0}

conf-set[g]

conf-set[h]

conf-set[i]

conf-set

CBJ: conflict-set

{1, g, h}

{0}{0}{0}

conf-set[g]

conf-set[h]

conf-set[i]

Current variable i

{3,1, g}

{x, 3,1}

• When a check(i,h) failsconf-set[i] conf-set[i] {h}

• When current-domain[i] empty

1. Jumps to deepest past variable h in conf-set[i]

2. Updates conf-set[h] conf-set[h] (conf-set[i] \{h})

• Primitive form of learning (while searching)

Example CBJ{1,2,3,4,5}

{1,2,3,4,5}

{(V1=1, V6=3)}

v[0] = 0

2 3 4 5

conf-set[1] = {0}

conf-set[2] = {0}

conf-set[3] = {0}

{(V4=5, V6=3)}

{(V2=1, V4=3), (V2=4, V4=5)}

conf-set[6] = {1}

{1,2,3,4,5}V6

{(V1=1, V5=3)}

conf-set[4] = {2}

v[5] 21 3

conf-set[6] = {1}conf-set[6] = {1,4}

conf-set[6] = {1,4}conf-set[6] = {1,4}

conf-set[4] = {1, 2}

conf-set[5] = {1}

CBJ for finding all solutions• After finding a solution, if we jump from this last

variable, then we may miss some solutions and lose completeness

• Two solutions, proposed by Chris Thiel (S08)1. Using conflict sets2. Using cbf of Kondrak, a clear pseudo-code

• Rationale by Rahul Purandare (S08)– We cannot skip any variable without chronologically

backtracking to it at least once – In fact, exactly once

CBJ/All solutions without cbf• When a solution is found, force the last variable,

N, to conflict with everything before it– conf-set[N] {1, 2, ..., N-1}.

• This operation, in turn, forces some chronological backtracking as the conf-sets are propagated backward

CBJ/All solutions with cbf• Kondrak proposed to fix the problem using

cbf (flag), a 1xn vector i, cbf[i] 0– When you find a solution, i, cbf[i] 1

• In unlabel – if (cbf[i]=1)

• Then h i-1; cbf[i] 0• Else h max-list (conf-set[i])

Backtracking: summary• Chronological backtracking

– Steps back to previous level– No extra data structures required

• Backjumping– Jumps to deepest checked-against variable, then

steps back– Uses array of integers: max-check[i]

• Conflict-directed backjumping– Jumps across deepest conflicting variables– Uses array of sets: conf-set[i]

– Vanilla: BT– Improving back steps: BJ, CBJ – Improving forward step: BM, FC

Backmarking: goal• Tries to reduce amount of consistency

checking• Situation:

– v[i] about to be re-assigned k– v[i]k was checked against v[h]g– v[h] has not been modified

v[h] = g

v[i] kk

BM: motivation• Two situations

1. Either (v[i]=k,v[h]=g) has failed it will fail again2. Or, (v[i]=k,v[h]=g) was founded consistent it will remain consistent

v[h] = g

v[i] kk

v[h] = g

v[i] kk

• In either case, back-checking effort against v[h] can be saved!

Data structures for BM: 2 arrays

0 0 0 0 0 0 0 0 0

max domain size m

• maximum checking level: mcl (n x m)• Minimum backup level: mbl (n x 1)

Maximum checking level

0 0 0 0 0 0 0 0 0000

nmax domain size m

• mcl[i,k] stores the deepest variable that v[i]k checked against

• mcl[i,k] is a finer version of max-check[i]

Minimum backup level

• mbl[i] gives the shallowest past variable whose value has changed since v[i] was the current variable

• BM (and all its hybrid) do not allow dynamic variable ordering

When mcl[i,k]=mbl[i]=j

v[i] kk

mbl[i] = j

BM is aware that• The deepest variable that (v[i] k)

checked against is v[j]• Values of variables in the past of

v[j] (h<j) have not changed

So• We do need to check (v[i] k)

against the values of the variables between v[j] and v[i]

• We do not need to check (v[i] k) against the values of the variables in the past of v[j]

Type a savings

v[i] kk

mcl[i,k]=h mcl[i,k] < mbl[i]=j

When mcl[i,k] < mbl[i], do not check v[i] k because it will fail

Type b savings

v[i] kk

mcl[i,k]=g

mbl[i] = j

mcl[i,k]mbl[i]

When mcl[i,k] mbl[i], do not check (i,h<j) because they will succeed

Hybrids of BM• mcl can be used to allow backjumping in

BJ• Mixing BJ & BM yields BMJ

– avoids redundant consistency checking (types a+b savings) and

– reduces the number of nodes visited during search (by jumping)

• Mixing BM & CBJ yields BM-CBJ

Problem of BM and its hybrids: warning

v[m]v[m]

• Backjumping from v[i]:– v[i] backjumps up to v[g]

• Backmarking of v[h]:– When reconsidering v[h], v[h] will

be checked against all f [m,g) – effort could be saved

• Phenomenon will worsen with CBJ

• Problem fixed by Kondrak & van Beek 95

BMJ enjoys only some of the advantages of BMAssume: mbl[h] = m and max-check[i]=max(mcl[i,x])=g

Forward checking (FC)• Looking ahead: from current variable, consider all future

variables and clear from their domains the values that are not consistent with current partial solution

• FC makes more work at every instantiation, but will expand fewer nodes

• When FC moves forward, the values in current-domain of future variables are all compatible with past assignment, thus saving backchecking

• FC may “wipe out” the domain of a future variable (aka, domain annihilation) and thus discover conflicts early on. FC then backtracks chronologically

• Goal of FC is to fail early (avoid expanding fruitless subtrees)

FC: data structures

• When v[i] is instantiated, current-domain[j] are filtered for all j connected to i and I < j n

• reduction[j] store sets of values remove from current-domain[j] by some variable before v[j]

reductions[j] = {{a, b}, {c, d, e}, {f, g, h}}

• future-fc[i]: subset of the future variables that v[i] checks against (redundant)

future-fc[i] = {k, j, n}• past-fc[i]: past variables that checked against v[i]

• All these sets are treated like stacks

Forward Checking: functions• check-forward• undo-reductions• update-current-domain• fc-label• fc-unlabel

FC: functions• check-forward(i,j) is called when instantiating v[i]

– It performs Revise(j,i)– Returns false if current-domain[j] is empty, true

otherwise– Values removed from current-domain[j] are pushed,

as a set, into reductions[j]• These values will be popped back if we have to

backtrack over v[i] (undo-reductions)

FC: functions• update-current-domain

– current-domain[i] domain[i] \ reductions[i] – actually, we have to iterate over reductions, which is a

set of sets• fc-label

– Attempts to instantiate current-variable– Then filters domains of all future variables (push into

reductions)– Whenever current-domain of a future variable is wiped-

out: • v[i] is un-instantiated and • domain filtering is undone (pop reductions)

Hybrids of FC• FC suffers from thrashing: it is based on BT• FC-BJ:

– max-check is integrated in fc-bj-label and fc-bj-unlabel– Enjoys advantages of FC and BJ… but suffers

malady of BJ (first jumps, then steps back)• FC-CBJ:

– Best algorithm so far– fc-cbj-label and fc-cbj-unlabel

Consistency checking: summary• Chronological backtracking

– Uses back-checking– No extra data structures

• Backmarking– Uses mcl and mbl– Two types of consistency-checking savings

• Forward-checking– Works more at every instantiation, but expands fewer

subtrees– Uses: reductions[i], future-fc[i], past-fc[i]

Experiments• Empirical evaluations on Zebra

– Representative of design/scheduling problems– 25 variables, 122 binary constraints– Permutation of variable ordering yields new search

spaces– Variable ordering: different bandwidth/induced width

of graph• 450 problem instances were generated• Each algorithm was applied to each instance

Experiments were carried out under static variable ordering

Analysis of experimentsAlgorithms compared with respect to:1. Number of consistency checks (average)

FC-CBJ FC-BJ BM-CBJ FC CBJ BMJ BM BJ BT≼ ≼ ≼ ≼ ≼ ≼ ≼ ≼• Number of nodes visited (average)

FC-CBJ FC-BJ FC BM-CBJ BMJ=BJ BM=BT≼ ≼ ≼ ≼ ≼• CPU time (average)

FC-CBJ FC-BJ FC BM-CBJ CBJ BMJ BJ BT BM≼ ≼ ≼ ≼ ≼ ≼ ≼ ≼

FC-CBJ apparently the champion

Additional developments• Other backtracking algorithms exist:

– Graph-based backjumping (GBJ), etc. [Dechter]

– Pseudo-trees [Freuder 85]

• Other look-ahead techniques exist– DAC, MAC, etc.

• More empirical evaluations– over randomly generated problems

• Theoretical comparisons [Kondrak & van Beek IJCAI’95]

Implementing BT-based algorithms

• Preprocessing– Enforce NC, do not include in #CC (e.g., Zebra)– Normalize all constraints (fapp01-0200-0)– Check for empty relations (bqwh-15-106-0_ext)

• Interrupt as soon as you detect domain wipe out• Dynamic variable ordering

– Apply domino effect

Problem Solving with Constraints Intelligent Backtracking Algorithms 1 Problem Solving with...

Documents

Solving Sparse Linear Constraintsdifference constraints,albeit few, are presentin the input. In practice, this makes it hard to exploit the efficiency of difference constraints in

Modelling & Solving with Constraints Prof. Toby Walsh University College Cork/Uppsala University

The Cassowary Linear Arithmetic Constraint Solving AlgorithmThe Cassowary Linear Arithmetic Constraint Solving Algorithm 3 Fig. 2. Screen shot from the Scheme Constraints Window Manager

Solving Mathematical Programs with Equilibrium · PDF fileSolving Mathematical Programs with Equilibrium ... solving mathematical programs with equilibrium constraints. ... is to solve

Solving Partial Order Constraints for LPO termination

SOLVING GEOMETRIC CONSTRAINTS IN A PARALLEL NETWORK · works solving particular problems can be built by connecting instances of the compiled constraint modules, according to the

Modeling and Solving Nontraditional Optimization Problems · Robert Fourer, Modeling & Solving Nontraditional Optimization Problems Session 2a: Conic Constraints — Chiang Mai, 4-5

Solving Optimal Power Flow with Voltage Constraints using ...researchrepository.murdoch.edu.au/21660/1/Aaron_Mijatovic_Thesis.pdf · Voltage Constraints using MATLAB Optimization

Anderson R 896-2137 V.V ' !: Kw · 2018-11-01 · Dziwenko Brian 896-2133 Dziwenko H Mrs 896-2124 Fediow Peter 896-2350 Fediow Peter M Box496Andrew 896-2459 Fedun Anton RRl 896-2147

On Solving Boolean Combinations of UTVPI Constraintssseshia/pubdir/JSAT_3_2_3_Seshia.… · On Solving Boolean Combinations of UTVPI Constraints ... Unit two variable per inequality

Problem Solving Solving...Engineering Design Process “Analyzing the Problem and Brainstorming” • Design constraints –Technology, economic (pricing vs. market demand), human

Combining Stereovision Matching Constraints for Solving ...cdn.intechopen.com/pdfs/12968/InTech-Combining... · Combining Stereovision Matching Constraints for Solving the Correspondence

Solving Optimal Power Flow with Voltage Constraints using ...researchrepository.murdoch.edu.au/id/eprint/21660/1/Aaron... · Constraints using MATLAB ... point of a set of generators

Decidable fragments of FOL ~ solving polynomial constraints by …mizuhito/jss12/ART-CAD.pdf · 2012-03-05 · Decidable fragments of FOL ~ solving polynomial constraints by QE-CAD

Solving the problem of constraints due to Dirichlet

decreto 896

Physical problem solving: Joint planning with … problem solving: Joint planning with symbolic, geometric, and dynamic constraints ... (i.e. we remove parts of

Solving Optimal Power Flow with Voltage Constraints using ... · Solving Optimal Power Flow with Voltage Constraints using MATLAB Optimization Toolbox A report submitted to the School

Solving Large Extensive-Form Games with Strategy Constraints · 2019-02-07 · Solving Large Extensive-Form Games with Strategy Constraints Trevor Davis,1 Kevin Waugh,2 Michael Bowling,2,1

Problem Solving with Constraints Ordering heuristics1 Foundations of Constraint Processing CSCE496/896, Fall 2011 choueiry/F11-496-896