Sliding Constraints Toby Walsh National ICT Australia and University of New South Wales Joint work with Christian Bessiere, Emmanuel Hebrard, Brahim Hnich, Zeynep Kiziltan

SLIDE meta-constraint ● Hot off the press ● Some of this is to appear at ECAI 06 ● Some is even under review for IJCAI 07!

SLIDE meta-constraint ● A constructor for generating many sequencing and related global constraints – REGULAR [Pesant 04] – AMONG SEQ [Beldiceanu and Contegjean 94] – CARD PATH [Beldiceanu and Carlsson 01] – VALUE PRECEDENCE [Lee and Law 04] – … ● Slides a constraint down one or more sequences of variables – Ensuring constraint holds at every point – Fixed parameter tractable

Basic SLIDE ● SLIDE(C,[X1,..Xn]) holds iff – C(Xi,..Xi+k) holds for every I ● INCREASING([X1,..Xn]) – SLIDE(<=,[X1,..Xn]) – Unfolds into X1 <= X2, X2 <= X3, … Xn-1 <= Xn

Basic SLIDE ● SLIDE(C,[X1,..Xn]) holds iff – C(Xi,..Xi+k) holds for every I ● ALWAYS_CHANGE([X1,..Xn]) – SLIDE(=/=,[X1,..Xn]) – Unfolds into X1 =/= X2, X2 =/= X3, … Xn-1 =/= Xn

Basic SLIDE ● AMONG SEQ constraint [Beldiceanu and Contegjean 94] – Car sequencing, staff rostering, … ● E.g. at most 1 in 3 cars have a sun roof, at most 3 in 7 night shifts, … – SLIDE(C,[X1,..Xn]) where C(X1..,Xk) holds iff AMONG([X1,..,Xk],l,u,v)

Basic SLIDE ● AMONG SEQ constraint [Beldiceanu and Contegjean 94] – Car sequencing, staff rostering, … ● E.g. at most 1 in 3 cars have a sun roof, at most 3 in 7 night shifts, … – SLIDE(C,[X1,..Xn]) where C(X1..,Xk) holds iff AMONG([X1,..,Xk],l,u,v) – E.g. l=u=2, k=3 and v={a} – SLIDE(C,[X1,..X5]) where X1=a, X2,.. X5 in {a,b}

Basic SLIDE ● AMONG SEQ constraint [Beldiceanu and Contegjean 94] – Car sequencing, staff rostering, … ● E.g. at most 1 in 3 cars have a sun roof, at most 3 in 7 night shifts, … – SLIDE(C,[X1,..Xn]) where C(X1..,Xk) holds iff AMONG([X1,..,Xk],l,u,v) – E.g. l=u=2, k=3 and v={a} – SLIDE(C,[X1,..X5]) where X1=a, X2,.. X5 in {a,b} – Enforcing GAC sets X4=a since only satisfying tuples are a,a,b,a,a and a,b,a,a,b. Enforcing GAC on decomposition does nothing!

GSC ● Global sequence constraint in ILOG Solver – Combines AMONG SEQ with GCC – Regin and Puget have given partial propagator

GSC ● Global sequence constraint in ILOG Solver – Combines AMONG SEQ with GCC – Regin and Puget have given partial propagator – We can show why! ● It is NP-hard to enforce GAC on GSC ● Can actually prove this when GSC is AMONG SEQ plus an ALL DIFFERENT ● ALL DIFFERENT is a special case of GCC

GSC ● Reduction from 1in3 SAT on positive clauses – The jth block of 2N clauses will ensure jth clause satisfied – Even numbered CSP vars represent truth assignment – Odd numbered CSP vars “junk” to ensure N odd values in each block – X_2jN+2i odd iff xi true – AMONG SEQ([X1,…],N,N,2N,{1,3,..}) ● This ensures truth assignment repeated along variables!

GSC ● Reduction from 1in3 SAT on positive clauses – Suppose jth clause is (x or y or z) ● X_2jN+2x, X_2jN+2y, X_2jN+2z in {4NM+4j, 4NM+4j+1, 4NM+4j+2} ● As ALL DIFFERENT, only one of these odd – For i other than x, y or z, X_2jN+2i in {4jN+4i, 4jN+4i+1} and X_2jN+2i+1 in {4jN+4i+2, 4jn+4i+3}

SLIDE down multiple sequences ● Can SLIDE down more than one sequence at a time – LEX([X1,..Xn],[Y1,..Yn]) [Frisch et al CP 02] – Introduce sequence of Boolean vars [B1,..Bn+1] – Play role of alpha in LEX propagator

SLIDE down multiple sequences ● Can SLIDE down more than one sequence at a time – LEX([X1,..Xn],[Y1,..Yn]) – Set B1=0 – Bn+1=1 (strict lex), Bn+1 in {0,1} (lex) – SLIDE(C,[X1..Xn],[Y1,..Yn],[B1,..Bn+1]) holds iff C(Xi,Yi,Bi,Bi+1) holds for each i

SLIDE down multiple sequences ● Can SLIDE down more than one sequence at a time – LEX([X1,..Xn],[Y1,..Yn]) – Set B1=0 – Bn+1=1 (strict lex), Bn+1 in {0,1} (lex) – SLIDE(C,[X1..Xn],[Y1,..Yn],[B1,..Bn+1]) – C(Xi,Yi,Bi,Bi+1) holds iff Bi=Bi+1=1 or (Bi=Bi+1=0 and Xi=Yi) or (Bi=0, Bi+1=1 and Xi<Yi)

SLIDE down multiple sequences ● Can SLIDE down more than one sequence at a time – LEX([X1,..Xn],[Y1,..Yn]) – Set B1=0 – Bn+1=1 (strict lex), Bn+1 in {0,1} (lex) – SLIDE(C,[X1..Xn],[Y1,..Yn],[B1,..Bn+1]) – C(Xi,Yi,Bi,Bi+1) holds iff Bi=Bi+1=1 or (Bi=Bi+1=0 and Xi=Yi) or (Bi=0, Bi+1=1 and Xi<Yi) – {2} {1,3,4} {2,3,4} {1} {3,4,5} – {0,1,2} {1} {1,2,3} {0} {0,1,2}

SLIDE down multiple sequences ● Can SLIDE down more than one sequence at a time – LEX([X1,..Xn],[Y1,..Yn]) – Set B1=0 – Bn+1=1 (strict lex), Bn+1 in {0,1} (lex) – SLIDE(C,[X1..Xn],[Y1,..Yn],[B1,..Bn+1]) – C(Xi,Yi,Bi,Bi+1) holds iff Bi=Bi+1=1 or (Bi=Bi+1=0 and Xi=Yi) or (Bi=0, Bi+1=1 and Xi<Yi) – {2} {1,3,4}{2,3,4} {1} {3,4,5} – {2} {1} {1,2,3} {0} {0,1,2}

SLIDE down multiple sequences ● Can SLIDE down more than one sequence at a time – LEX([X1,..Xn],[Y1,..Yn]) – Set B1=0 – Bn+1=1 (strict lex), Bn+1 in {0,1} (lex) – SLIDE(C,[X1..Xn],[Y1,..Yn],[B1,..Bn+1]) – C(Xi,Yi,Bi,Bi+1) holds iff Bi=Bi+1=1 or (Bi=Bi+1=0 and Xi=Yi) or (Bi=0, Bi+1=1 and Xi<Yi) – {2} {1} {2,3,4} {1} {3,4,5} – {2} {1} {1,2,3} {0} {0,1,2}

SLIDE down multiple sequences ● Can SLIDE down more than one sequence at a time – LEX([X1,..Xn],[Y1,..Yn]) – Set B1=0 – Bn+1=1 (strict lex), Bn+1 in {0,1} (lex) – SLIDE(C,[X1..Xn],[Y1,..Yn],[B1,..Bn+1]) – C(Xi,Yi,Bi,Bi+1) holds iff Bi=Bi+1=1 or (Bi=Bi+1=0 and Xi=Yi) or (Bi=0, Bi+1=1 and Xi<Yi) – {2} {1} {2} {1} {3,4,5} – {2} {1} {3} {0} {0,1,2}

SLIDE down multiple sequences ● Can SLIDE down more than one sequence at a time – LEX([X1,..Xn],[Y1,..Yn]) – Set B1=0 – Bn+1=1 (strict lex), Bn+1 in {0,1} (lex) – SLIDE(C,[X1..Xn],[Y1,..Yn],[B1,..Bn+1]) – C(Xi,Yi,Bi,Bi+1) holds iff Bi=Bi+1=1 or (Bi=Bi+1=0 and Xi=Yi) or (Bi=0, Bi+1=1 and Xi<Yi) – Highly efficient, incremental,..

SLIDE down multiple sequences ● CONTIGUITY([X1,..Xn]) [Maher 02] – 0…01…10…0 – Two simple SLIDEs

SLIDE down multiple sequences ● CONTIGUITY([X1,..Xn]) – 0…01…10…0 – Two simple SLIDEs – Introduce Yi in {0,1,2} – SLIDE(<=,[Y1,..Yn])

SLIDE down multiple sequences ● CONTIGUITY([X1,..Xn]) – 0…01…10…0 – Two simple SLIDEs – Introduce Yi in {0,1,2} – SLIDE(<=,[Y1,..Yn]) – SLIDE(C,[X1,..Xn],[Y1,..Yn]) where C(Xi,Yi) holds iff Xi=1 Yi=1

SLIDE down multiple sequences ● REGULAR(A,[X1,..Xn]) [Pesant 04] – X1.. Xn is a string accepted by FDA A – Can encode many useful constraints including LEX, AMONG, STRETCH, CONTIGUITY …

SLIDE down multiple sequences ● REGULAR(A,[X1,..Xn]) [Pesant 04] – X1.. Xn is a string accepted by FDA A – Encodes into simple SLIDE – Introduce Qi to represent state of the automaton after i symbols

SLIDE down multiple sequences ● REGULAR(A,[X1,..Xn]) – X1.. Xn is a string accepted by FDA A – Introduce Qi to represent state of the automaton after i symbols – SLIDE(C,[X1,..Xn],[Q1,..Qn+1]) where ● Q1 is starting state of A ● Qn+1 is limited to accepting states of A ● C(Xi,Qi,Qi+1) holds iff A moves from state Qi to state Qi+1 on seeing Xi

SLIDE down multiple sequences ● REGULAR(A,[X1,..Xn]) – X1.. Xn is a string accepted by FDA A – Introduce Qi to represent state of the automaton after i symbols – SLIDE(C,[X1,..Xn],[Q1,..Qn+1]) where ● Q1 is starting state of A ● Qn+1 is limited to accepting states of A ● C(Xi,Qi,Qi+1) holds iff A moves from state Qi to state Qi+1 on seeing Xi – Gives highly efficient and effective propagator! – Introducing Qi also gives modelling access to state variables

SLIDE with counters ● AMONG([X1,..Xn],v,N) ● Introduce sequence of counts, Yi ● SLIDE(C,[X1,..Xn],[Y1,..Yn+1]) where ● Y1=0, Yn+1=N ● C(Xi,Yi,Yi+1) holds iff (Xi in v and Yi+1=1+Yi) or (Xi not in v and Yi+1=Yi)

SLIDE with counters ● CARD PATH [Beldiceanu and Carlsson 01] ● SLIDE is a special case of CARD PATH – SLIDE(C,[X1,..Xn]) iff CARD PATH(C,[X1,..Xn],n- k+1)

SLIDE with counters ● CARD PATH ● SLIDE is a special case of CARD PATH – SLIDE(C,[X1,..Xn]) iff CARD PATH(C,[X1,..Xn],n- k+1) ● CARD PATH is a special case of SLIDE – SLIDE(D,[X1,..Xn],[Y1,..Yn+1]) where Y1=0, Yn+1=N, and D(Xi,..Xi+k,Yi,Yi+1) holds iff (Yi+1=1+Yi and C(Xi,..Xi+k)) or (Yi+1=Yi and not C(Xi,..Xi+k))

Global constraints for symmetry breaking ● Decision variables: – Col[Italy], Col[France], Col[Austria]... ● Domain of values: – red, yellow, green,... ● Constraints – binary relations like Col[Italy]=/=Col[France] Col[Italy]=/=Col[Austria] …

Value symmetry ● Solution: – Col[Italy]=green Col[France]=red Col[Spain]=green … ● Values (colours) are interchangeable: – Swap red with green everywhere will still give us a solution

Value symmetry ● Solution: – Col[Italy]=green Col[France]=red Col[Spain]=green … ● Values (colours) are interchangeable: – Col[Italy]=red Col[France]=green Col[Spain]=red …

Value precedence ● Old idea – Used in bin-packing and graph colouring algorithms – Only open the next new bin – Only use one new colour ● Applied now to constraint satisfaction [Law and Lee 04]

Value precedence ● Suppose all values from 1 to m are interchangeable – Might as well let X1=1

Value precedence ● Suppose all values from 1 to m are interchangeable – Might as well let X1=1 – For X2, we need only consider two choices ● X2=1 or X2=2

Value precedence ● Suppose all values from 1 to m are interchangeable – Might as well let X1=1 – For X2, we need only consider two choices – Suppose we try X2=2

Value precedence ● Suppose all values from 1 to m are interchangeable – Might as well let X1=1 – For X2, we need only consider two choices – Suppose we try X2=2 – For X3, we need only consider three choices ● X3=1, X3=2, X3=3

Value precedence ● Suppose all values from 1 to m are interchangeable – Might as well let X1=1 – For X2, we need only consider two choices – Suppose we try X2=2 – For X3, we need only consider three choices – Suppose we try X3=2

Value precedence ● Suppose all values from 1 to m are interchangeable – Might as well let X1=1 – For X2, we need only consider two choices – Suppose we try X2=2 – For X3, we need only consider three choices – Suppose we try X3=2 – For X4, we need only consider three choices ● X4=1, X4=2, X4=3

Value precedence ● Global constraint – Precedence([X1,..Xn]) iff min({i | Xi=j or i=n+1}) < min({i | Xi=k or i=n+2}) for all j<k – In other words ● The first time we use j is before the first time we use k

Value precedence ● Global constraint – Precedence([X1,..Xn]) iff min({i | Xi=j or i=n+1}) < min({i | Xi=k or i=n+2}) for all j<k – In other words ● The first time we use j is before the first time we use k – E.g ● Precedence([1,1,2,1,3,2,4,2,3]) ● But not Precedence([1,1,2,1,4])

Value precedence ● Global constraint – Precedence([X1,..Xn]) iff min({i | Xi=j or i=n+1}) < min({i | Xi=k or i=n+2}) for all j<k – In other words ● The first time we use j is before the first time we use k – E.g ● Precedence([1,1,2,1,3,2,4,2,3]) ● But not Precedence([1,1,2,1,4]) – Proposed by [Law and Lee 2004] ● Pointer based propagator (alpha, beta, gamma) but only for two interchangeable values at a time

Value precedence ● Precedence([i,j],[X1,..Xn]) iff min({i | Xi=j or i=n+1}) < min({i | Xi=k or i=n+2}) ● Of course – Precedence([X1,..Xn]) iff Precedence([i,j],[X1,..Xn]) for all i<j

Value precedence ● Precedence([i,j],[X1,..Xn]) iff min({i | Xi=j or i=n+1}) < min({i | Xi=k or i=n+2}) ● Of course – Precedence([X1,..Xn]) iff Precedence([i,j],[X1,..Xn]) for all i<j – Precedence([X1,..Xn]) iff Precedence([i,i+1],[X1,..Xn]) for all i

Value precedence ● Precedence([i,j],[X1,..Xn]) iff min({i | Xi=j or i=n+1}) < min({i | Xi=k or i=n+2}) ● Of course – Precedence([X1,..Xn]) iff Precedence([i,j],[X1,..Xn]) for all i<j ● But this hinders propagation – GAC(Precedence([X1,..Xn])) does strictly more pruning than GAC(Precedence([i,j],[X1,..Xn])) for all i<j – Consider X1=1, X2 in {1,2}, X3 in {1,3} and X4 in {3,4}

Puget’s method ● Introduce Zj to record first time we use j ● Add constraints – Xi=j implies Zj <= i – Zj=i implies Xi=j – Zi < Zi+1

Puget’s method ● Introduce Zj to record first time we use j ● Add constraints – Xi=j implies Zj < I – Zj=i implies Xi=j – Zi < Zi+1 ● Binary constraints – easy to implement

Puget’s method ● Introduce Zj to record first time we use j ● Add constraints – Xi=j implies Zj < I – Zj=i implies Xi=j – Zi < Zi+1 ● Unfortunately hinders propagation – AC on encoding may not give GAC on Precedence([X1,..Xn]) – Consider X1=1, X2 in {1,2}, X3 in {1,3}, X4 in {3,4}, X5=2, X6=3, X7=4

Propagating Precedence ● Simple SLIDE encoding ● Introduce sequence of variables, Yi – Record largest value used so far – Y1=0

Propagating Precedence ● Simple SLIDE encoding ● SLIDE(C,[X1,..Xn],[Y1,..Yn+1]) where C(Xi,Yi,Yi+1) holds iff Xi<=1+Yi and Yi+1=max(Yi,Xi)

Propagating Precedence ● Simple SLIDE encoding ● SLIDE(C,[X1,..Xn],[Y1,..Yn+1]) where C(Xi,Yi,Yi+1) holds iff Xi<=1+Yi and Yi+1=max(Yi,Xi) – Consider Y1=0, X1 in {1,2,3}, X2 in {1,2,3} and X3=3

Precedence and matrix symmetry ● Alternatively, could map into 2d matrix – Xij=1 iff Xi=j ● Value precedence now becomes column symmetry – Can lex order columns to break all such symmetry – Alternatively view value precedence as ordering the columns of a matrix model

Precedence and matrix symmetry ● Alternatively, could map into 2d matrix – Xij=1 iff Xi=j ● Value precedence now becomes column symmetry ● However, we get less pruning this way – Additional constraint that rows have sum of 1 – Consider, X1=1, X2 in {1,2,3} and X3=1

Precedence for set variables ● Social golfers problem – Each foursome can be represented by a set of cardinality 4 – Values (golfers) within this set are interchangeable ● Value precedence can be applied to such set variables – But idea is now conceptually more complex!

Precedence for set variables ● We might as well start with X1={1,2,3}

Precedence for set variables ● We might as well start with X1={1,2,3,4} ● Now 1, 2, 3 and 4 are still symmetric

Precedence for set variables ● We might as well start with X1={1,2,3,4} ● Let’s try X2={2,5,6,7}

Precedence for set variables ● We might as well start with X1={1,2,3,4} ● Let’s try X2={2,5,6,7} ● But if we permute 1 with 2 we get – X1’={1,2,3,4} and X2’={1,5,6,7} – And X2’ is lower than X2 in the multiset ordering

Precedence for set variables ● We might as well start with X1={1,2,3,4} ● Let’s try X2={1,5,6,7}

Precedence for set variables ● We might as well start with X1={1,2,3,4} ● Let’s try X2={1,5,6,7} ● Let’s try X3={1,2,4,5}

Precedence for set variables ● We might as well start with X1={1,2,3,4} ● Let’s try X2={1,5,6,7} ● Let’s try X3={1,2,4,5} ● But if we permute 3 with 4 we get – X1’={1,2,3,4}, X2’={1,5,6,7} and X3’={1,2,3,5} – This is again lower in the multiset ordering

Precedence for set variables ● We might as well start with X1={1,2,3,4} ● Let’s try X2={1,5,6,7} ● Let’s try X3={1,2,3,5} ● …

Precedence for set variables ● Precedence([S1,..Sn]) iff min(i, {i | j in Si & not(k in Si) or i=n+1}) < min(i, {i | k in Si & not(j in Si) or i=n+2}) for all j<k ● In other words – The first time we distinguish apart j and k (by one appearing on its own), j appears and k does not

SLIDE over sets ● Value precedence for set vars ● PRECENDCE([vj,vk],[S1,..Sn]) holds iff ● min(i,{i | vj in Si and vk not in Si or i=n+1}) < ● min(i,{i | vk in Si and vj not in Si or i=n+2}) ● Introduce sequence of Booleans to indicate whether vars have been distinguished apart yet or not

SLIDE over sets ● Value precedence for set vars ● PRECENDCE([vj,vk],[S1,..Sn]) holds iff ● min(i,{i | vj in Si and vk not in Si or i=n+1}) < ● min(i,{i | vk in Si and vj not in Si or i=n+2}) ● SLIDE(C,[S1,..Sn],[B1,..Bn+1]) where ● B1=0 and ● C(Si,Bi,Bi+1) holds iff Bi=Bi+1=1, or Bi=Bi+1=0 and (vj, vk in Si or vj, vk not in Si), or Bi=0, Bi+1=1, vj in Si and vk not in Si

SLIDE over sets ● Open stacks problem – IJCAI 05 modelling challenge ● Three SLIDEs and one ALL DIFFERENT – First SLIDE: Si+1 = Si u customer(Xi) – Second SLIDE: Ti-1= Ti u customer(Xi) – Third SLIDE: |Si intersect Ti| < OpenStacks

Circular SLIDE ● STRETCH used in shift rostering [Hellsten et al 04] ● Given sequence of vars X1,.. Xn – Each stretch of identical values a occurs at least shortest(a) and at most longest(a) time – For example, at least 0 and at most 3 night shifts in a row – Each transition Xi=/=Xi+1 is limited to given patterns – For example, only Xi=night, Xi+1=off is permitted

Circular SLIDE ● STRETCH can be efficiently encoded using SLIDE ● SLIDE(C,[X1,..Xn],[Y1,..Yn+1]) where – Y1=1 – C(Xi,Xi+1,Yi,Yi+1) holds iff Xi=Xi+1, Yi+1=1+Yi, Yi+1<=longest(Xi), or Xi=/=Xi+1, Yi>=shortest(Xi) and (Xi,Xi+1) in set of permitted changes

Circular SLIDE ● Circular forms of STRETCH are needed for repeating shift patterns ● Circular form of SLIDE useful in such situations ● SLIDEo(C,[X1,..Xn]) holds iff – C(Xi,..X1+(i+k-1)mod n) holds for 1<=i<=n

SLIDE algebra ● SLIDEOR(C,[X1..Xn]) holds iff – C(Xi,..Xi+k) holds for some I ● Encodes as CARD PATH (and thus as SLIDE) ● Other more complex combinations – NOT(SLIDE(C,[X1,..Xn])) iff SLIDEOR(NOT(C),[X1,..Xn]) – SLIDE(C1,[X1,..Xn]) and SLIDE(C2,[X1,..Xn]) iff SLIDE(C1 and C2,[X1,..Xn]) –..

Propagating SLIDE ● But how do we propagate global constraints expressed using SLIDE?

Propagating SLIDE ● SLIDE(C,[X1,..Xn]) – Just post sequence of constraints, C(Xi,..Xi+k) – If constraint graph is Berge acyclic, then we will achieve GAC – Gives efficient GAC propagators for CONTIGUITY, DOMAIN, ELEMENT, LEX, PRECEDENCE, REGULAR, …

Propagating SLIDE ● SLIDE(C,[X1,..Xn]) – Just post sequence of constraints, C(Xi,..Xi+k) – If constraint graph is Berge acyclic, then we will achieve GAC – Gives efficient GAC propagators for CONTIGUITY, DOMAIN, ELEMENT, LEX, PRECEDENCE, REGULAR, … – But what about case constraint graph is not Berge- acyclic? ● Slide constraints overlap on more than one variable

Propagating SLIDE ● SLIDE(C,[X1,..Xn]) – Slide constraints overlap on more than one variable – Enforce GAC using dynamic programming ● pass support down sequence

Propagating SLIDE ● SLIDE(C,[X1,..Xn]) – Equivalently a “dual” encoding – Consider AMONG SEQ(2,2,3,[X1,..X5],{a}) where ● X1=a, X2,X3,X4,X5 in {a,b} ● AMONG([X1,X2,X3],2,{a}) ● AMONG([X2,X3,X4],2,{a}) ● AMONG([X3,X4,X5],2,{a}) ● Enforcing GAC sets X4=a – GAC can be enforced in O(nd^k+1) time and O(nd^k) space where constraints overlap on k variables – Fixed parameter tractable

Conclusions ● SLIDE is a very useful meta-constraint – Many global constraints for sequencing and other problems can be encoded as SLIDE ● SLIDE can be propagated easily – Constraints overlap on just one variable => simply post slide constraints – Constraints overlap on more than one variable => use dynamic programming or equivalently a simple dual encoding