Global Constraints Toby Walsh National ICT Australia and University of New South Wales

Course outline ● Introduction ● All Different ● Lex ordering ● Value precedence ● Complexity ● GAC-Schema ● Soft Global Constraints ● Global Grammar Constraints ● Roots Constraint ● Range Constraint ● Slide Constraint ● Global Constraints on Sets

SLIDE meta-constraint ● Even hotter off the press than the value PRECEDENCE constraint ● Under review for IJCAI 07!

SLIDE meta-constraint ● A constructor for generating many sequencing and related global constraints – REGULAR – CONTIGUITY – LEX – CARD PATH – … ● 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 ● AMONG SEQ constraint – Used by ILOG for assembly line car sequencing at Renault – At most 1 in 3 cars have a sun roof – SLIDE(C,[X1,..Xn]) where C(X1,X2,X3) holds iff AMONG([X1,X2,X3],0,1,D) where D is set of cars ordered with sunroofs

GSC ● Global sequence constraint in ILOG Solver – Combines AMONG SEQ with GCC – Regin and Puget give partial propagator – We can show why!

GSC ● Global sequence constraint in ILOG Solver – Combines AMONG SEQ with GCC – Regin and Puget give 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 – 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]) – 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, and 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, and 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=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, and 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=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]) – 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(Q,[X1,..Xn]) – X1.. Xn is a string accepted by FDA Q – Encodes into simple SLIDE – Introduce Yi to represent state of the automaton after i symbols

SLIDE down multiple sequences ● REGULAR(Q,[X1,..Xn]) – X1.. Xn is a string accepted by FDA Q – Introduce Yi to represent state of the automaton after i symbols – SLIDE(C,[X1,..Xn],[Y1,..Yn+1]) where ● Y1 is starting state of Q ● Yn+1 is limited to accepting states of Q ● C(Xi,Yi,Yi+1) holds iff Q moves from state Yi to state Yi+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 ● Y1 is starting state of A ● Yn+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!

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 ● 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))

SLIDE with parameters ● Slide constraints may share parameters ● LINKSET2BOOLEANS(S,[X1,..Xn]) – Converts set variable into characteristic function ● Encodes as SLIDE(C,[X1,..Xn]) where – C(S,Xi) holds iff Xi in S – S is parameter common to each slide constraint

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 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 ● 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(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