130.243.105.49130.243.105.49/.../presentations/SchulteSweConsNet11.pdf · 2011. 6. 9. · Yes, It...

Christian Schulte

KTH – Royal Institute of Technology

Sweden

[email protected]

Peter J. Stuckey

NICTA, Victoria Lab, U Melbourne

Australia

[email protected]

mailto:[email protected]

mailto:[email protected]

Variable Domain

Maps variables to sets of possible values

5/31/2011 PPDP 2008, Christian Schulte 2

x{3,4,5} y{3,4,5}

Finite domains (integers)

Propagators Implement constraints (relations)

alldifferent(x1, …, xn)

x + 2y = z

x y = z


Constraint Propagation

Computes stronger domains propagators remove impossible values

licensed by constraint propagator implements


x{3,4,5} y{3,4,5}

x y y>3




x{3,4,5} y{4,5}

x y y>3




x{4,5} y{4,5}

x y y>3

Propagators

Compute stronger domains remove impossible values

Deleted when redundant


x{4,5} y{4,5}

x y

The Beauty… Simple model: propagators

are independent

communicate via variables as monotonic channels

Advantages compositional setup

propagators can incorporate variety of inference techniques


The Curse… Simple model: propagators

are independent

communicate via variables as monotonic channels

Disadvantages how to reason about and take advantage from global

properties


Delete Them… So far (local beauty):

delete propagator when itself decides to be redundant…

Our goal here (global curse):

propagators can be redundant even though they cannot decide themselves…

find out and delete them…


Placing Rectangles

Two rectangles of dimensions w1 h1 and w2 h2 and left corners (x1,y1) and (x2,y2) do not overlap, iff

left right

below above


(x1,y1)

(x2,y2)

h1h2

w1 w2

Placing Rectangles

Two rectangles of dimensions w1 h1 and w2 h2 and left corners (x1,y1) and (x2,y2) do not overlap, iff

x1 + w1 x2 x2 + w2 x1

y1 + h1 h2 y2 + h2 y1


(x1,y1)

(x2,y2)

h1h2

w1 w2

Placing Rectangles

Model with reification asb1. b2. b3. b4.

b1 x1 + w1 x2 b2 x2 + w2 x1

b3 y1 + h1 h2 b4 y2 + h2 y1

b1 b2 b3 b4


(x1,y1)

(x2,y2)

h1h2

w1 w2

Placing Rectangles

After some search h1=3, h2=5, y1[0 … 4], y2[8 … 10]. Then b3 y1 + h1 y2 sets b3=1 and disappears

b4 y2 + h2 y1 sets b4=0 and disappears

b1 b2 b3 b4 detects redundancy and disappears

But: b1 x1 + w1 x2 and b2 x2 + w2 x1 continue never change anything yet waste time and memory


(x1,y1)

(x2,y2)

h1h2

w1 w2

Placing Rectangles

After some search h1=3, h2=5, y1[0 … 4], y2[8 … 10]. Then b3 y1 + h1 h2 sets b3=1 and disappears

b4 y2 + h2 y1 sets b4=0 and disappears

b1 b2 b3 b4 detects redundancy and disappears

But: b1 x1 + w1 x2 and b2 x2 + w2 x1 continue never change anything yet waste time and memory


(x1,y1)

(x2,y2)

h1h2

w1 w2

typical problem for disjunction and reification

Euclidian Distance

Two points (x1,y1) and (x2,y2) at least distance d apart(x1 - x2)

2 + (y1 - y2)2 d2

As not directly available, decompose into (d constant)dxx. dx. dyy. dy.

dx = x1 – x2 dxx = dx dx dy = y1 – y2 dyy = dy dy

dxx + dyy d2

Assume dxx + dyy d2 becomes redundant…

... the other propagators might stay on!


(x1,y1)

(x2,y2)d

Euclidian Distance

Two points (x1,y1) and (x2,y2) at least distance d apart(x1 - x2)

2 + (y1 - y2)2 d2

As not directly available, decompose into (d constant)dxx. dx. dyy. dy.

dx = x1 – x2 dxx = dx dx dy = y1 – y2 dyy = dy dy

dxx + dyy d2

Assume dxx + dyy d2 becomes redundant…

... the other propagators might stay on!


(x1,y1)

(x2,y2)d

typical problem for decomposition

Lexicographic Order

Model as (n i 1)oi = (xi < yi) ((xi = yi) oi-1)

on = 1 o0 = 0


(x1, …, xn) < (y1, …, yn)

Lexicographic Order

Decompose into individual propagators (n i 1)oi = li ri ri = ei oi-1

li xi < yi ei xi = yi

on = 1 o0 = 0

If l1 becomes true, most propagators might remain up to 4(n – 1) propagators

worst case: search branches in order x1, …, xn or y1, …, yn


(x1, …, xn) < (y1, …, yn)

Lexicographic Order

Decompose into individual propagators (n i 1)oi = li ri ri = ei oi-1

li xi < yi ei xi = yi

on = 1 o0 = 0

If l1 becomes true, most propagators might remain up to 4(n – 1) propagators

worst case: search branches in order x1, …, xn or y1, …, yn


(x1, …, xn) < (y1, …, yn)

typical problem for decomposition

Recurring Theme Situation

variable occurs in one propagator only

propagator does not modify other variables

variable and propagator should be eliminated

Eliminating one propagator might make more variables eliminable…

…and hence more propagators … and more variables … … …


Overview Dynamic, linear time analysis to find variables that can

be eliminated and hence, propagators that can be eliminated

Content constraint propagation [gentle reminder]

variable elimination

dynamic analysis for variable elimination

implementation [paper]

short evaluation [paper]

summary


5/31/2011 25PPDP 2008, Christian Schulte

Variables and Domains Domain D complete mapping from variables V to

finite sets of integers

Domain D1 stronger than D2, D1 D2, if

D1 obtained by value removal from D2

D1(x) D2(x) for all xV


Valuations and Constraints Integer valuation maps variables to integer values

{x1 d1, …, xn dn}

Constraint c over variables vars(c)={x1, …, xn} set of valuations

for all c, vars()={x1, …, xn}

is an element of domain D, D, if

(x)D(x) for all xV


Propagators Propagator f monotonically decreasing function from

domains to domains decreasing: only value removal (f(D) D)

monotonic: stronger input, stronger output (D1 D2 f(D1) f(D2))

Variables vars(f) of a propagator f output: variables that can change by application of f

input: variables that can modify result of f

Dependent propagators props(x) for variable x all propagators f with xvars(f)


Propagators Constraints Propagator f correct for constraint c, if

no solution of c is ever removed by f { | D } c = { | f(D) } c

Set of propagators F checking for constraint c, if

solution domains can be identified c iff domain() fixpoint of all f F

Set of propagators F implements constraint c, if

all f F are correct for c and F is checking for c


Propagators Correct propagators for constraint c x y + 1

f(D)(x) = { dD(x) | d max D(y) + 1 }

f(D)(z) = D(z) z x

var(f)={x,y} (y input, x output)

g(D)(y) = { dD(y) | d min D(x) - 1 }

g(D)(z) = D(z) z y

var(g)={x,y} (x input, y output)

{f,g} implements c

{f,g} checking for c

props(x) {f,g} and props(y) {f,g} and


Propagation Solving Propagation solver solv(F,D) for propagators F and

domain D computes greatest (weakest) simultaneous fixpoint D' of all fF

for all fF f(D') = D'

if f(D'')=D'' for all fF with D'' D, then D'' D'

Implementation and interleaving with search [paper] repeat application of propagators until simultaneous fixpoint

create new propagators corresponding to choice during search


Key Idea Assume

variable y occurs in single propagator f

f never changes any variable but y

then: eliminate f (as it is redundant) and hence y

Road map when are constraints and propagators redundant

correctness of elimination

how to detect redundancy (common cases)


Existential Redundancy Constraint c existentially redundant for y at D, if

D implies y. c for valuations D of variables vars(c) – {y}, exists dD(y)

where {yd}c

Propagator f existentially redundant for y at D, if

any future propagation of f can only change y solv({f}, D') =-{y} D'

where D' D and D'(y)=D(y)


Existential Redundancy If propagator f correct for constraint c and c is

existentially redundant for y at D, then

f existentially redundant for y at D proof: just use definitions

Significance: reason about semantics (constraint c) and not about implementation (propagator f)


Yes, It Works! (Key Lemma) Let f be existentially redundant for y at D, F be set of

propagators where yvars(g) for all gF

solv(F{f}, D') =-{y} solv(F, D') deleting f and y does not change propagation

Proof: take execution sequence of propagators including f

reorder: move occurrences of f to end

due to existential redundancy: domains the same wrt –{y}

as result is fixpoint for all propagators in F: same result


Elimination Opportunities Initial model

not likely unless very poor

maybe, if model has been generated automatically

More likely, due to (as in motivating examples) elimination of redundant propagators

removal of independent variables, leading to variables occurring once

We can detect propagator to be existentially redundant…

…but how frequent is it and how costly?


Binary Domain Propagators For constraint c domain propagator dom(c)

dom(c)(D)(x) = {(x) | D c } xvars(c)

dom(c)(D)(x) = D(x) otherwise keep only values occurring in possible solutions

strongest possible propagator

A domain propagator f with vars(f)={x,y} is existentially redundant for x and y at D with f(D)=D

that is, existentially redundant at fixpoint

no check required


Boolean Functional Constraints A propagator f for the total functional constraint

y=e(x) with y Boolean and

D(y)={0,1}

is existentially redundant for y at D some expression e over variables x

examples: conjunction, disjunction, reification, etc…

check: y not yet fixed


Integer Functional Constraints A bounds(Z) or bounds(R) propagator f for the total

functional constraint y=e(x) with

D(y) [infD e(x) … supD e(x)]

is existentially redundant for y at D some expression e over variables x

examples: linear constraints, etc…

check: D(y) [infD e(x) … supD e(x)] (typically available in f)


Key Idea Linear time analysis

find variables to eliminate

delete existentially redundant propagators

Traverse variables through propagators from x through fprops(x) to yvars(f)

start from output variables OV and search variables SV

mark whether a variable is interesting: if not, eliminate

delete propagators existentially redundant for non-interesting variable


Search and Output Variables Output variables: contain solution

Search variables: will be assigned during search search creates propagators on search variables

Of course, we are interested in both!


Interesting Visits… A variable x can be interesting or not: interesting[x]

= yes cannot not be eliminated

= no can be eliminated

= maybe traversal determines whether x is interesting

encountered again = yes

A variable x is visited at most once: visited[x] if visited again, previously computed value of interesting[x]

All search and output variables are interestingfor (x OVSV)

interesting[x] := yes;


Traverse: Visit and Interesttraverse(x, g)

if (visited[x])return interesting[x];

visited[x] := true;if (interesting[x] = no)

interesting[x] = maybe;for (f props(x) – {g})

…if (interesting[x] = maybe)

interesting[x] := no;return interesting[x];


Traverse: Visit and Interesttraverse(x, g)

if (visited[x])return interesting[x];

visited[x] := true;if (interesting[x] = no)

interesting[x] = maybe;for (f props(x) – {g})

…if (interesting[x] = maybe)

interesting[x] := no;return interesting[x];


avoid self cycles though g

Traverse: Not Redundant…

for (f props(x) – {g})

if (f existentially redundant for y x at D)

…

else


for (z vars(f) – {x})

traverse(z, f);

…

…


Traverse: Not Redundant…

for (f props(x) – {g})

if (f existentially redundant for y x at D)

…

else

interesting[x] := true;

for (z vars(f) – {x})

traverse(z, f);

…

…


avoid self cycles though f

Traverse: Redundant?…for (f props(x) – {g})

if (f existentially redundant for y x at D)if (traverse(y, f) = no)

delete f;else

interesting[x] := yes;for (z vars(f) – {x,y})

traverse(z, f);else

……


Traverse: Redundant?…for (f props(x) – {g})

if (f existentially redundant for y x at D)if (traverse(y, f) = no)

delete f;else

interesting[x] := yes;for (z vars(f) – {x,y})

traverse(z, f);else

……


y could be interesting (yes or maybe)

Analyseanalyse(D, OV, SV)

for (x V)

interesting[x] := no;

visited[x] := false;

for (x OVSV)


for (x SV)

traverse(x, );


Analyseanalyse(D, OV, SV)

for (x V)

interesting[x] := no;

visited[x] := false;

for (x OVSV)


for (x SV)

traverse(x, );


new propagators by search on SV

Yes, It Works! Let F be propagator set, D domain, and SV and OV sets

of variables. Suppose after analyse(D, OV, SV) propagators G remain. Then

solv(F, D') =OV solv(G, D')

for all D' D where D' =-OVSV D

Important: efficient to find some y for which f is existentially redundant

typically, only one y is a candidate

otherwise, only very few [paper]


Catching Modeling Errors Suppose analysis finds that x is never traversed even

though propagator f with x in vars(f)… f will never be executed

after search terminates: possibly not a solution

Why not check after search terminates whether propagators are left?

search might not terminate (propagation missing)

use analysis to find error as soon as possible


Experiments Problems

bibd-v-k-l: balanced incomplete block design

lexicographic order and Boolean sums

circle-n-s: circle packing

decomposition for Euclidian distance

s-p-n-s: simple square packing

reification and Boolean constraints for no-overlap

p-s-p-n-s: square packing with capacity reasoning

many additional small constraints

Setup implemented using Gecode 2.1.1 as starting point

ambitious: Gecode (one of) the most efficient system(s)


Overhead Accuracy Infeasible to run analysis every computation of solv

can increase runtime by up to 70%

run only every n-th computation

Accuracy: percentage of saved propagator executions 100% every computation of solv (all possible useless

propagator executions avoided)

Run analysis directly before search [paper] beneficial for Gecode


Average Accuracy


Best Performance: Gains


Best Performance: Accuracy


How Often To Run The Analysis User can make safe bet by choosing the analysis

frequency between 10 and 15 still substantial improvements possible

feasible compromise between accuracy and overhead

Analysis has naïve implementation uses C++ recursion (mutual, very deep)

More detailed evaluation [paper]


Related Work Unique: general and dynamic method for finite domain

propagators

Well known: detection and removal of redundant propagators

Earlier work on variable elimination: CLP over reals Gauss-Jordan elimination[Macdonald et al. 1993]beneficial at compile

time

Fourier elimination [Fordan & Yap 1998] beneficial only in certain circumstances

eliminate variables in linear real constraints

"don't care" propagation in non-clausal SAT solvers exploit "don't care" propagation for disjunctive nodes, avoiding

propagation in some sub-nodes [Thiffault et al. 2004]

also generalization by propagation control [Brand & Yap 2006]

restricted to Boolean variables


Conclusion Useful optimization

automatic modeling, modeling errors, optimizing propagation

Simple and efficient linear time analysis, can be beneficial

Future work automatically finding out when to run the analysis

how to integrate into production quality system


130.243.105.49130.243.105.49/.../presentations/SchulteSweConsNet11.pdf · 2011. 6. 9. · Yes, It...

Documents

Transcript of 130.243.105.49130.243.105.49/.../presentations/SchulteSweConsNet11.pdf · 2011. 6. 9. · Yes, It...