- 46 Views
- Uploaded on
- Presentation posted in: General

I am Patrick Prosser I am a senior lecturer at Glasgow I teach AF2 & CP4 I am a member of

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.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

(baby) Bio

- I am Patrick Prosser
- I am a senior lecturer at Glasgow
- I teach AF2 & CP4
- I am a member of
- the algorithms group
- the apes (distributed, not disbanded)

- I am a Glaswegian

This is all that I am allowed to tell you

10 years of conflict-directed backjumping

Patrick Prosser

- Still using that old greasy stuff?
- Who cares?
- So?

Plan of the talk

- What’s a csp?
- The simplest algorithm (BT) and its behaviour
- Some improvements (BJ, GBJ)
- A better way (CBJ)
- Improvements to CBJ
- Strange things about CBJ
- k-inconsistencies
- the bridge and the long jump
- value ordering and insolubility

- So, what about CBJ?
- some say its good
- some say it’s a waste of time
- who’s using it
- who’s not using

- Where’s it going
- QBF?

What’s a csp?

<V,D,C>

- a set of variables
- each with a domain of values
- a collection of constraints (I’m going to assume binary)
- assign each variable a value from its domain to satisfy the constraint

Example of a csp

A

B

E

C

D

H

F

G

3 colour me!

Example of a csp

A

B

E

C

D

H

F

G

A

B

E

C

D

H

F

G

Example of a csp

Variables and Instantiation Order

Checking back

Va

Vb

Vc

Vd

Ve

Vf

Vg

Vh

1 = red

2 = blue

3 = green

Example of a csp

Variables and Instantiation Order

Checking back

A

B

Va

Vb

Vc

Vd

Ve

Vf

Vg

Vh

E

C

D

H

F

G

1 = red

2 = blue

3 = green

Example of a csp

Variables and Instantiation Order

Checking back

A

B

Va

Vb

Vc

Vd

Ve

Vf

Vg

Vh

E

C

D

H

F

G

1 = red

2 = blue

3 = green

Example of a csp

Variables and Instantiation Order

Checking back

A

B

Va

Vb

Vc

Vd

Ve

Vf

Vg

Vh

E

C

D

H

F

G

1 = red

2 = blue

3 = green

Example of a csp

Variables and Instantiation Order

Checking back

A

B

Va

Vb

Vc

Vd

Ve

Vf

Vg

Vh

E

C

D

H

F

G

1 = red

2 = blue

3 = green

Example of a csp

Variables and Instantiation Order

Checking back

A

B

Va

Vb

Vc

Vd

Ve

Vf

Vg

Vh

E

C

D

H

F

G

1 = red

2 = blue

3 = green

Example of a csp

Variables and Instantiation Order

Checking back

A

B

Va

Vb

Vc

Vd

Ve

Vf

Vg

Vh

E

C

D

H

F

G

1 = red

2 = blue

3 = green

Example of a csp

Variables and Instantiation Order

Checking back

A

B

Va

Vb

Vc

Vd

Ve

Vf

Vg

Vh

E

C

D

H

F

G

1 = red

2 = blue

3 = green

Example of a csp

Variables and Instantiation Order

Checking back

A

B

Va

Vb

Vc

Vd

Ve

Vf

Vg

Vh

E

C

D

H

F

G

1 = red

2 = blue

3 = green

Example of a csp

Variables and Instantiation Order

Checking back

A

B

Va

Vb

Vc

Vd

Ve

Vf

Vg

Vh

E

C

D

H

F

G

1 = red

2 = blue

3 = green

Example of a csp

Variables and Instantiation Order

Checking back

A

B

Va

Vb

Vc

Vd

Ve

Vf

Vg

Vh

E

C

D

H

F

G

1 = red

2 = blue

3 = green

Example of a csp

Variables and Instantiation Order

Checking back

A

B

Va

Vb

Vc

Vd

Ve

Vf

Vg

Vh

E

C

D

H

F

G

1 = red

2 = blue

3 = green

Example of a csp

Variables and Instantiation Order

Checking back

A

B

Va

Vb

Vc

Vd

Ve

Vf

Vg

Vh

E

C

D

H

F

G

1 = red

2 = blue

3 = green

Example of a csp

Variables and Instantiation Order

Checking back

A

B

Va

Vb

Vc

Vd

Ve

Vf

Vg

Vh

E

C

D

H

F

G

1 = red

2 = blue

3 = green

Example of a csp

Variables and Instantiation Order

Checking back

A

B

Va

Vb

Vc

Vd

Ve

Vf

Vg

Vh

E

C

D

H

F

G

1 = red

2 = blue

3 = green

Example of a csp

Variables and Instantiation Order

Checking back

A

B

Va

Vb

Vc

Vd

Ve

Vf

Vg

Vh

E

C

D

H

F

G

Why did it do that?

That was dumb!

1 = red

2 = blue

3 = green

Example of a csp

Variables and Instantiation Order

Checking back

A

B

Va

Vb

Vc

Vd

Ve

Vf

Vg

Vh

E

C

D

H

F

G

1 = red

2 = blue

3 = green

Example of a csp

Variables and Instantiation Order

Checking back

A

B

Va

Vb

Vc

Vd

Ve

Vf

Vg

Vh

E

C

D

H

F

G

1 = red

2 = blue

3 = green

Example of a csp

Variables and Instantiation Order

Checking back

A

B

Va

Vb

Vc

Vd

Ve

Vf

Vg

Vh

E

C

D

H

F

G

1 = red

2 = blue

3 = green

Example of a csp

Variables and Instantiation Order

Checking back

A

B

Va

Vb

Vc

Vd

Ve

Vf

Vg

Vh

E

C

D

H

F

G

1 = red

2 = blue

3 = green

Example of a csp

Variables and Instantiation Order

Checking back

A

B

Va

Vb

Vc

Vd

Ve

Vf

Vg

Vh

E

C

D

H

F

G

1 = red

2 = blue

3 = green

Example of a csp

Variables and Instantiation Order

Checking back

A

B

Va

Vb

Vc

Vd

Ve

Vf

Vg

Vh

E

C

D

H

F

G

1 = red

2 = blue

3 = green

Example of a csp

Variables and Instantiation Order

Checking back

A

B

Va

Vb

Vc

Vd

Ve

Vf

Vg

Vh

E

C

D

H

F

G

1 = red

2 = blue

3 = green

Example of a csp

Variables and Instantiation Order

Checking back

A

B

Va

Vb

Vc

Vd

Ve

Vf

Vg

Vh

E

C

D

H

F

G

1 = red

2 = blue

3 = green

That was good old fashioned chronological backtracking

- instantiate a variable
- check current against past variables to see if okay
- current? past? Future?

- If not okay try another value
- If no values left go back to previous variable

Example of a csp

What would have happened if we had

the E* intermediate variables?

i.e. it falls back on E4, then E3, towards E?

A

B

E

C

D

E1

H

E2

F

G

E3

1 = red

2 = blue

3 = green

E4

It’s all just depth first search, right?

BT Thrashes!

past variable v[h]

past

conflict with v[h]

current variable v[i]

future

future variable v[j]

BT

Assume that when we instantiate the current variable

v[i] we check against all past variables from v[1] to v[i-1]

to check if consistent

consistent := false

for x in domain[i] while not(consistent) // find a consistent value

begin

consistent := true

v[i] := x

for h in (1 .. i-1) while consistent // check backwards

begin

consistent := (check(v[i],v[h])

end

if not(consistent)

then delete(x,domain[i])

end // did we find a good value?

John Gaschnig’s BJ

Make a small modification to BT. Remember the last variable we check against

consistent := false

maxCheck[i] := 0

for x in domain[i] while not(consistent) // find a consistent value

begin

consistent := true

v[i] := x

for h in (1 .. i-1) while consistent // check backwards

begin

consistent := (check(v[i],v[h])

maxCheck := max(h,maxCheck[i])

end

if not(consistent)

then delete(x,domain[i])

end // did we find a good value?

If the loop terminates with consistent false

then jump back to v[h], where h := lastCheck[i]

This is then the deepest variable we failed against

John Gaschnig’s BJ

consistent := false

maxCheck[i] := 0

for x in domain[i] while not(consistent) // find a consistent value

begin

consistent := true

v[i] := x

for h in (1 .. i-1) while consistent // check backwards

begin

consistent := (check(v[i],v[h])

maxCheck := max(h,maxCheck[i])

end

if not(consistent)

then delete(x,domain[i])

end // did we find a good value?

If the loop terminates with consistent true ...

lastCheck[i] = i-1

we then step back!

BJ jumps then steps back. It can only jump after it has moved forwards!

BJ reduces thrashing

maxCheck[i]

0

1

2

3

4

1

2

3

4

5

4

6

Jump back to v[4]

then step back

Rina Dechter’s GBJ

Graph-based backjumping, exploits topology of constraint graph

If there are no values remaining for v[i]

Jump back to v[h], where v[h] is the deepest variable

connected to v[i] in the constraint graph

If there are no values remaining for v[h]

Jump back to v[g], where v[g] is the deepest variable

connected to v[h] or v[i] in the constraint graph

If there are no values remaining for v[g]

Jump back to v[f], where v[f] is the deepest variable

connected to v[g] or v[h] or v[i] in the constraint graph

What happens if constraint graph is a clique?

We want something that can jump and jump again,

something that takes into consideration what caused

a dead-end, not something that just looks at the

topology of the constraint graph

Combine BJ and GBJ

CBJ

Remember your conflicts, and when you have used them forget them.

- When we instantiate v[i] := x and
- check(v[i],v[h]) and
- it fails
- v[i] is in conflict with v[h]
- add h to the set confSet[i]

confSet[i] is then the set of past variables that conflict

with values in the domain of v[i]

CBJ

Conflict-directed backjumping, exploits failures within the search process

If there are no values remaining for v[i]

Jump back to v[h], where v[h] is the deepest variable in conflict with v[i]

The hope: re-instantiate v[h] will allow us to find a good value for v[i]

If there are no values remaining for v[h]

Jump back to v[g], where v[g] is the deepest variable in conflict with v[i] or v[h]

The hope: re-instantiate v[g] will allow us to find a good value for v[i] or a

good value for v[h] that will be good for v[i]

If there are no values remaining for v[g]

Jump back to v[f], where v[f] is the deepest variable in conflict with v[i] or v[h] or v[g]

The hope: re-instantiate v[f] will allow us to find a good value for v[i] or a

good value for v[h] that will be good for v[i] or a

good value for v[g] that will be good for v[h] and v[i]

What happens if: constraint graph is dense, tight, or highly consistent?

CBJ

consistent := false

confSet[i] := {0}

for x in domain[i] while not(consistent) // find a consistent value

begin

consistent := true

v[i] := x

for h in (1 .. i-1) while consistent // check backwards

begin

consistent := (check(v[i],v[h])

if not(consistent) then confSet[i] := confSet[i] {h}

end

if not(consistent)

then delete(x,domain[i])

end

CBJ

When jumping back from v[i] to v[h] update conflict sets

confSet[h] := confSet[h] confSet[i] \ {h}

confSet[i] := {0}

That is, when we jump back from v[h] jump back to a

variable that is in conflict with v[h] or with v[i]

Throw away everything you new on v[i]

Reset all variables from v[h+1] to v[i] (i.e. domain and confSet)

CBJ

1

2

conflict set

3

4

{2,0}

5

{4,1,0}

6

CBJ

1

2

conflict set

3

4

{2,1,0}

5

6

CBJ (reduce thrashing)

1

2

3

4

{2,1,0}

5

6

Jump back to deepest past variable

in confSet (call it h) and then

combine confSet[i] with confSet[h]

- History:
- Konkrat and V Beek,
- Gent and Underwood

Forward Checking

1

2

3

NOTE: arrows go forward!

4

5

6

7

8

9

1

2

3

4

5

Forward Checking Can Thrash

6

7

8

9

Check Forwards, Jump Back!

1

2

- There are no values in cd[6] compatible with v[9]
- get more values into cd[9] (undo v[1]?) OR
- get more values into cd[6] (undo v[4])

- … and if that doesn’t work?
- undo v[3] so cd[4] gets value compatible with
- cd[6] that is then compatible with cd[9]

3

4

5

6

7

8

9

CBJ Variants

BM-CBJ, FC-CBJ, MAC-CBJ

CBJ DkC

If we jump from v[i] to v[h] and confSet[i] = {0,h}

then remove value(v[h]) from domain(h)

value(v[h]) is 2-inconsistent wrt v[i]

If we jump from v[h] to v[g] and confSet[h] = {0,g}

then remove value(v[g]) from domain(g)

value(v[g]) is 3-inconsistent wrt v[i] and v[h]

If we jump from v[g] to v[f] and confSet[g] = {0,f}

then remove value(v[f]) from domain(f)

value(v[f]) is 4-inconsistent wrt v[i] and v[h] and v[g]

What happens if the problem is highly consistent?

See JAIR 14 2001, Xinguang Chen & Peter van Beek

CBJ ATMS

If we jump from v[i] to v[g] and confSet[h] {0 .. g-1}

then do NOT reset domain(h) and

do NOT reset confSet(h)

Consider the past variables as assumptions and confSet[i]

as an explanation

Down side, we have more work to do.

This is a kind of learning (what kind?)

CBJ ~ DB

confSet[x,i] gives the past variable in conflict with v[i] := x

Finer grained:

on jumping back we can deduce better what values to return to domains

Down side, we have more work to do.

This is an algorithm between CBJ and DB

Funny things about cbj

The bridge and the long jump

Funny things about cbj

Value ordering on insoluble problems can have an effect

Problem: V1 to V7, each with domain {A,B}

nogoods {(1A,7A),(3A,7B),(5A,7B),(6A,7A),(6A,7B),(6B,7A),(6B,7B)}

Var Val confSet

V1 A

V2 A

V3 A

V4 A

V5 A

V6 A

V7 A/B {1,3}

Var Val confSet

V1 A

V2 A

V3 B

V4 A

V5 A

V6 A

V7 A/B {1,5}

Var Val confSet

V1 A

V2 A

V3 B

V4 A

V5 B

V6 A

V7 A/B {6}

Var Val confSet

V1 A

V2 A

V3 B

V4 A

V5 B

V6 B

V7 A/B {6}

Finally V6 has no values and cbj jumps to V0

Funny things about cbj

Value ordering on insoluble problems can have an effect

Problem: V1 to V7, each with domain {A,B}

nogoods {(1A,7A),(3A,7B),(5A,7B),(6A,7A),(6A,7B),(6B,7A),(6B,7B)}

We now order domains and choose B then A!

Var Val confSet

V1 B

V2 B

V3 B

V4 B

V5 B

V6 B

V7 A/B {6}

Var Val confSet

V1 B

V2 B

V3 B

V4 B

V5 B

V6 A

V7 A/B {6}

Finally V6 has no values and cbj jumps to V0

Value ordering made a difference to an insoluble problem!

Conflicting claims

Smith & Grant IJCAI95:

CBJ helps minimise occurrence of EHP’s

random problems as evidence

Bessier & Regin CP96:

CBJ is nothing but an overhead

random problems as evidence

Chen & van Beek JAIR 2001:

CBJ is a tiny overhead

When it makes a difference it is a HUGE difference

random & real problems as evidence

New CBJ

I believe all state of the art sat solvers are using cbj

(or have rediscovered cbj but don’t know it)

CBJ for QSAT: see recent AIJ

conflict and solution directed!

Who is not using cbj?

Constraint programming!

We don’t jump and we don’t learn

Is speed everything?

No

How about explanations and retraction?

Why is cbj not in CP?

Need to propagate laterally (see MAC-CBJ tech report)

but this is no big deal

Need to get explanations out of constraints!

Not just writing a good constraint propagator

but a good constraint explainer!

Maybe there is not yet the demand for retraction and explanation

(but I don’t believe that)

So?

- Paper rejected from IJCAI91 (written in 1990)
- I was a Lisp programmer at the time (it shows)
- I think the experiments were very good (so there!)
- Nice study of influence of topological parameter on search cost.
- In conclusion I forgot to say CBJ was new … why?
- I like BMJ, it is cool (I was smart for 1 day)
- I think CBJ is pretty (natural, discovered, not invented)
- I like FC-CBJ (I can understand it)
- I identify work to be done (researchers love that (why?))
- … and I make errors re-dvo’s (researchers love that (why?))
- I put my results in perspective (trash them :)
- I got encouragement (Nadel) and help (Ole and Peter)
- I got a whole load of background (Rina)
- But it hurt … why did it take 3 years to get somebody to read it?
- It is still alive! We are not done yet.