search - kth.se · id2204, l06, christian schulte, ict, kth . 4 . improving propagation idea:...

Search Lecture 06, 2015-04-16

ID2204: Constraint Programming

Christian Schulte [email protected] Software and Computer Systems School of Information and Communication Technology KTH – Royal Institute of Technology Stockholm, Sweden

mailto:[email protected]

2015-04-16 ID2204, L06, Christian Schulte, ICT, KTH 2

Overview

Reminder improved constraint propagation events realistic constraint propagation improving constraint propagation further

Search branching exploration

Outlook

Reminder


Improving Propagation

Idea: propagator narrows domain of some (few) variables

re-propagate only propagators sharing variables

Maintain a set of “dirty” propagators not known whether fixpoint all other propagators have fixpoint computed


Propagator Variables

Variables var(p) of propagator p variables of interest

No input considered on other variables No output computed on other variables


Improved Propagation

propagate((V,U,P), so)

s := s0; N := P; while N ≠ do

choose p N; s’ := p(s); N := N – {p}; MV := { x V | s(x) ≠ s’(x) }; DP := { q P | exists x var(q): x MV }; N := N DP; s := s’; return s;


Loop Invariant

Loop maintains for all p P-N p(s) = s after termination (N = ): for all p P p(s) = s Obligations

holds initially is actually invariant


What Is Computed

Fixpoint follows from loop invariant

Largest simultaneous fixpoint as for naïve propagation

proofs works exactly as before sequence of stores not strictly decreasing sufficient: store sequence and decreasing and finite (to

prove next)


Termination

Insight: if MV=, then p removed from N if MV≠, then p(s)<s

Consider pairs (si,Ni) with

si the value of s at i-th iteration Ni the value of N at i-th iteration

strictly decreasing wrt well-founded lexicographic order of (S,<) and (2P,)

Improving Propagation

Further


Subsumed Propagators

Propagator p subsumed by store s, iff for all s’ ≤ s : p(s’)=s’

all stronger stores are fixpoints p entailed by s s subsumes p (s entails p)


Weak Idempotence

A function f X X is idempotent on x X if

f(f(x)) = f(x) statement on just one element

For a propagator: if p is idempotent on s, it does not mean that p is idempotent on s’ with s’ ≤ s


Status Messages

Solution: propagator returns status and tells result

propagator p is function p S SM × S with SM := {fix, nofix, subsumed}


Propagator with Status

Assume propagator p and store s if p(s) = (fix, s’), then s’ is fixpoint for p if p(s) = (subsumed, s’), then s’ subsumes p if p(s) = (nofix, s’), then no further knowledge always safe (as before)


Improved Propagation

propagate((V,U,P), so) s := s0; N := P; while N ≠ do choose p N; (ms,s’):= p(s); N := N – {p}; if ms=subsumed then P := P –{p}; end MV := { x V | s(x) ≠ s’(x) }; DP := { q P | exists x var(q): x MV }; if ms=fix then DP := DP –{p}; end N := N DP; s := s’; return (P,s);

Propagation Events


Propagation Events

Many propagators simple to decide whether still at fixpoint for changed

domain based on how domain has changed

How domain changes described by propagation event

or just event


Events

Typical events fix(x) x becomes assigned min(x) minimum of x changes max(x) maximum of x changes any(x) domain of x changes

Clearly overlap fix(x) occurs: min(x) or max(x) occur any(x) occurs min(x) or max(x) occur: any(x) occurs


Events on Store Change

events(s,s') = { any(x) | s'(x) s(x) } { min(x) | min s'(x) > min s(x) } { max(x) | max s'(x) < max s(x) } { fix(x) | |s'(x)|=1 and |s(x)|>1 }

where s' s


Events are Monotonic

If s'' s' and s' s then events(s,s'') = events(s,s') events(s',s'')

Event occurs on change from s to s''

occurs on change from s to s', or occurs on change from s' to s''


Propagator for ≤

Propagator p≤ for x ≤ y p≤ (s) = { x { ns(x) | n ≤ max(s(y)) }, y { ns(y) | n ≥ min(s(x)) }}

good one: es(p≤) = { max(y), min(x) } but also: es(p≤) = { any(y), any(x)}


Propagator for ≠

Propagator p≠ for x ≠ y p≠(s) = { x s(x) - single(s(y)), y s(y) - single(s(x))}

where: single({n}) = {n} single(N) = (otherwise)

good one: es(p≠) = { fix(y), fix(x) } but also: es(p≠) = { any(y), any(x)}


Taking Advantage from Event Sets

Base decision of propagators to re-propagate on event sets rather than on modified variables

DP := { q P | events(s,s’) es(q) ≠};

More Optimizations


Priorities

Choose propagator according to cost: cheapest first according to expected impact general: first-in first-out (queue)


Propagator Rewriting

Another observation: propagator for max(x,y)=z and values for x are smaller than for y Replace by propagator for y=z


Summary: Optimizing Propagation

Fixpoint knowledge avoids useless execution idempotence, subsumption, events knowledge provided by propagator

More details on optimizing propagation and

propagation in systems Finite Domain Constraint Programming Systems, Christian

Schulte, Mats Carlsson. In: Francesca Rossi, Peter van Beek, Toby Walsh, editors,

Handbook of Constraint Programming, Foundations of Artificial Intelligence, pages 495-526. Elsevier Science Publishers, 2006.

http://web.imit.kth.se/~schulte/

http://web.imit.kth.se/~schulte/

http://www.sics.se/~matsc/

Search


Search

Branching defines the search tree what are properties for a branching? what is a search tree?

Exploration how to explore the search tree? first solution search best solution search

Branching


Branching

How to define branching in our model branching suggests new constraints for decomposition operational formulation: new propagators

Branching makes decision based on current

store but also on propagators first-fail: variable with smallest domain most-constrained first


Properties

Search tree constructed by branching finite tree decreasing no solutions lost complete no solutions duplicated non-overlapping


Some Notation

Set of propagators

P := S S

functions from store to store contracting monotonic

Set of constraint models

M


Simplification

In the following we assume that the set of variables V and the universe U is fixed

Propagation is referred to by propagate(P,s) for propagator set P and store s and returns

pair of propagator set and store


Branching

A branching b is a function from propagators and a store to tuples of finite propagator sets

b(P, s) = (P1, …, Pn) where

Pi P and finite called i-th alternative


Branching: Properties

Assume (s not failed) A = sol((V, U, P),s) Ai = sol((V, U, PPi),s) complete: A1 … An = A non-overlapping: AiAj = for i≠j decreasing: if propagate(PPi,s)=(P’,s’) then s’ < s


Extending Models

A constraint model is a quadruple (V, U, P, b)

variables V universe (values) U propagators P branching b


Search Tree

A search tree for a constraint model (V, U, P, b) consists of nodes

(P’,s) with P’ set of propagators, s store Root of tree is propagate(P,sinit) where sinit(x) := U for all xV


Search Tree

For all leaves (P,s): either s failed or b(P,s) = () (“solved”)

For all inner nodes (P,s): s is not failed if b(P,s)= (P1,…, Pn) then node has children propagate(PP1,s), …, propagate(PPn,s)


Search Tree: Properties

Invariant: nodes of search tree (P,s): either s failed or s sim. fixpoint of P

If node (P1,s1) below (P2,s2) on same path: s1 < s2

Search tree is finite due to decreasing


Optimizing

For constraint propagation do not start by assuming all propagators dirty only those added by branching are dirty

remember: we start from simultaneous fixpoint (search tree invariant)

Propagate function takes set of dirty and non-dirty propagators as input


Assignments vs. Solved Nodes

Notice difference a solved node does not mean that for all variables x we have that s(x) is singleton!

Assign and Remove Propagators

Needed for branchings are propagators that assign variable x to a value remove value for a variable x

For smallest possible value

assign-min(s,x)(y) := if y=x then {min(s(x))} else s(y) remove-min(s,x)(y) := if y=x then s(x)-{min(s(x))} else s(y)



First-fail

b(P,s) := if exists x with card(s(x)) > 1 and

card(s(x)) smallest then

({assign-min(s,x)}, {remove-min(s,x)}) else

()


Summary: Branching

Branching defines search tree complete non-overlapping decreasing

Search tree consists of propagators and store after propagation leaves are failed or solved is finite

Exploration


Depth-first Exploration

dfe(P,s) = (P’,s’) := propagate(P,s); if s’ failed then s’ else

case b(P’,s’) of () then s’ [] (P1,P2) then

s’’ := dfe(P’P1,s’); if s’’ failed then dfe(P’P2,s’) else s’’ end

end

end


Search in Gecode

Objects created for models as spaces Spaces provide methods for search

status returns status clone returns copy commit commits to alternative

Straightforward see documentation


State Restoration

Search must restore state backtrack to previous state

Approaches trailing remember changes undo changes recomputation recompute state copying store additional copy


Trailing

Dominating approach Advantages

remembers exactly what has changed

Disadvantages complicated (all operations must be trail aware) requires additional techniques (time-stamping, …) difficult to combine with concurrency


Recomputation

Remember path for nodes path starts at some copy c recompute by redoing branching on c for all nodes compute single fixpoint known as batch recomputation

Advantage memory usage problem independent

Disadvantage efficiency overhead


Copying

Advantages simple allows for concurrency/parallelism

Disadvantages needs way too much memory


State Restoration in Gecode

Hybrid of copying and recomputation Read in “Modeling and Programming with

Gecode” Adaptive recomputation

remember copy in middle of path

Summary: Principles


Summary: Constraint Propagation and

Search Models for

constraint propagation branching sketch for exploration

Most important concepts CSPs constraint models propagators propagation loop


More on Models and Principles…

Excellent book with much more detail, inspired some of the material here

Krzysztof Apt, Principles of Constraint Programming. Cambridge University Press, 2003.

Available in FORUM library

Outlook


Common Constraints

Common constraints reified, arithmetic, element, distinct, regular, … …and other global constraints

How are they used for modeling How are they propagated What makes them global Propagation strength


Linear Equality

Propagator for

where ai, d integers, ai ≠ 0

How to propagate cheaply bounds information? for each variable xi consider how small and how large it

possibly can be restrict us here to ax + by = d

dxa in

i i 1


Element Constraint

Element constraint a[[x]] = y array of integers a variables x and y value of y is value of a at x-th position in particular: 0 ≤ x < elements in a

In Gecode element(this, a, x, y);

also for arrays of variables


Distinct: Basic Question

Propagating in domain-consistent fashion need to consider all solutions naïve: too much memory, too much time

Is there a better way

in general no but for particular constraints: yes! but element is simple, for more difficult?


Golomb Rulers

Find n ticks ti on ruler such that distance between ticks pairwise distinct length of ruler minimal

Extremely hard problem applications in cristalography, …

t0 t1 t2 t3 t4 t5


Cardinality Constraint

Distinct: variables can take a particular value at most once

Generalization: lower and upper bounds on how often a value can be taken by variables

Use: shift assignment worker: variables describe shift to work boss: sets minimum and maximum requirements on

workers per shift


Channeling/Assignment Constraints

Suppose variables xi and yi (0 i < n) channel(xi, yi) holds, iff xi = j yj = i (0 i < n)

Use: dual models (permutation problems)

queen i is in row j row j contains queen i post constraints on both set of variables


Lex Constraints

Suppose variables xi and yi (0 i < n) lex(xi, yi) holds, iff (x0, …, xn-1) lexicographically smaller than (y0, …, yn-1)

Use: symmetry breaking

in particular: matrix models (magic square)


Regular Constraint

Suppose variables xi (0 i < n) regular(xi , r) holds, iff the string x0…xn-1 forms a word from the language of the regular expression r

Use: describe patterns formed by variable

sequences


Goal

Understand and apply modeling abstractions modeling techniques

Understand propagation techniques

search - kth.se · id2204, l06, christian schulte, ict, kth . 4 . improving propagation idea:...

Documents