1. Global Constraints Toby Walsh National ICT Australia and University of New South Wales www.cse.unsw.edu.au/~tw

2. 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

3. Global grammar constraints ● Often easy to specify a global constraint – ALLDIFFERENT([X1,..Xn]) iff Xi=/=Xj for i<j ● Difficult to build an efficient and effective propagator – Especially if we want global reasoning

4. Global grammar constraints ● Promising direction initiated is to specify constraints via automata/grammar – Sequence of variables = string in some formal language – Satisfying assignment = string accepted by the grammar/automata Global constraints meets formal language theory

5. REGULAR constraint ● REGULAR(A,[X1,..Xn]) holds iff – X1.. Xn is a string accepted by the deterministic finite automaton A – Proposed by Pesant at CP 2004 – GAC algorithm using dynamic programming – However, DP is not needed since simple ternary encoding is just as efficient and effective

6. REGULAR constraint ● Deterministic finite automaton (DFA) – – Q is finite set of states – Sigma is alphabet (from which strings formed) – T is transition function: Q x Sigma -> Q – q0 is starting state – F subseteq Q are accepting states ● DFAs accept precisely regular languages – Regular language can be specified by rules of the form: NonTerminal -> Terminal | Terminal NonTerminal

7. REGULAR constraint ● DFAs accept precisely regular languages – Regular language can be specified by rules of the form: NonTerminal -> Terminal NonTerminal -> Terminal NonTerminal - Alternatively given by regular expressions - More limited than BNF which can express context-free grammars

8. REGULAR constraint ● Deterministic finite automation (DFA) 5 tuple where – Q is finite set of states – Sigma is alphabet (from which strings formed) – T is transition function: Q x Sigma -> Q – q0 is starting state – F subseteq Q are accepting states

9. REGULAR constraint ● Regular language – S -> 0 | 0A| AB | 1B | 1 – A -> 0 | 0A – B -> 1 | 1B ● DFA – Q={q0,q1,q2,q3} – Sigma={0.1} – T(q0,0)=q0. T(q0,1)=q1 – T(q1,0)=q2, T(q1,1)=q1 – T(q2,0)=q2, T(q2,1)=q3 – T(q3,0)=T(q3,1)=q3 – F={q0,q1,q2}

10. REGULAR constraint ● Regular language – S -> A | AB | ABA | BA | B – A -> 0 | 0A – B -> 1 | 1B ● DFA – Q={q0,q1,q2,q3} – Sigma={0.1} – T(q0,0)=q0. T(q0,1)=q1 – T(q1,0)=q2, T(q1,1)=q1 – T(q2,0)=q2, T(q2,1)=q3 – T(q3,0)=T(q3,1)=q3 – F={q0,q1,q2} This is the CONTIGUITY global constraint

11. REGULAR constraint ● Many global constraints are instances of REGULAR – AMONG – CONTIGUITY – LEX – PRECEDENCE – STRETCH –.. ● Domain consistency can be enforced in O(ndQ) time using dynamic programming

12. REGULAR constraint ● REGULAR constraint can be encoded into ternary constraints ● Introduce Qi+1 – state of the DFA after the ith transition ● Then post sequence of constraints – C(Xi,Qi,Qi+1) iff DFA goes from state Qi to Qi+1 on symbol Xi

13. REGULAR constraint ● REGULAR constraint can be encoded into ternary constraints ● Constraint graph is Berge-acyclic – Constraints only overlap on one variable – Enforcing GAC on ternary constraints achieves GAC on REGULAR in O(ndQ) time

14. REGULAR 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 ● DFA has one state for each value plus a single non-accepting state, fail – State represents largest value so far used ● T(Si,vj)=Si if j<=i ● T(Si,vj)=Sj if j=i+1 ● T(Si,vj)=fail if j>i+1 ● T(fail,v)=fail

15. REGULAR 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 ● DFA has one state for each value plus a single non-accepting state, fail – State represents largest value so far used ● T(Si,vj)=Si if j<i ● T(Si,vj)=Sj if j=i+1 ● T(Si,vj)=fail if j>i+1 ● T(fail,v)=fail ● REGULAR encoding of this is just these transition constraints (can ignore fail)

16. REGULAR constraint ● STRETCH([X1,..Xn]) holds iff – Any stretch of consecutive values is between shortest(v) and longest(v) length – Any change (v1,v2) is in some permitted set, P – For example, you can only have 3 consecutive night shifts and a night shift must be followed by a day off

17. REGULAR constraint ● STRETCH([X1,..Xn]) holds iff – Any stretch of consecutive values is between shortest(v) and longest(v) length – Any change (v1,v2) is in some permitted set, P ● DFA – Qi is – Q0= – T(,a)= if q+1<=longest(a) – T(,b)= if (a,b) in P and q>=shortest(a) – All states are accepting

18. NFA constraint ● Automaton does not need to be deterministic ● Non-deterministic finite automaton (NFA) still only accept regular languages – But may require exponentially fewer states – Important as O(ndQ) running time for propagator – E.g. 0* (1|2)* 2 (1|2)^k 0* – Where 0=closed, 1=production, 2=maintenance ● Can use the same ternary encoding

19. Soft REGULAR constraint ● May wish to be “near” to a regular string ● Near could be – Hamming distance – Edit distance ● SoftREGULAR(A,[X1,..Xn],N) holds iff – X1..Xn is at distance N from a string accepted by the finite automaton A – Can encode this into a sequence of 5-ary constraints

20. Soft REGULAR constraint ● SoftREGULAR(A,[X1,..Xn],N) – Consider Hamming distance (edit distance similar though a little more complex) – Qi+1 is state of automaton after the ith transition – Di+1 is Hamming distance up to the ith variable – Post sequence of constraints ● C(Xi,Qi,Qi+1,Di,Di+1) where ● Di+1=Di if T(Xi,Qi)=Qi+1 else Di+1=1+Di

21. Soft REGULAR constraint ● SoftREGULAR(A,[X1,..Xn],N) – To propagate – Dynamic programming ● Pass support along sequence – Just post the 5-ary constraints ● Accept less than GAC – Tuple up the variables

22. Cyclic forms of REGULAR ● REGULAR+(A,[X1,..,Xn]) – X1.. XnX1 is accepted by A – Can convert into REGULAR by increasing states by factor of d where d is number of initial symbols – qi => (qi,d) – T(qi,a)=qj => T((qi,d),a)=(qj,d) – T(q0,d)=qk => T(q0,d)=(qk,d) – Thereby pass along value taken by X1 so it can be checked on last transition

23. Cyclic forms of REGULAR ● REGULARo(A,[X1,..,Xn]) – Xi.. X1+(i+n-1)mod n is accepted by A for each 1<=i<=n – Can decompose into n instances of the REGULAR constraint – However, this hinders propagation ● Suppose A accepts just alternating sequences of 0 and 1 ● Xi in {0,1} and REGULARo(A,[X1,X2.X3]) – Unfortunately enforcing GAC on REGULARo is NP- hard

24. Cyclic forms of REGULAR ● REGULARo(A,[X1,..,Xn]) – Reduction from Hamiltonian cycle – Consider polynomial sized automaton A1 that accepts any sequence in which the 1st character is never repeated – Consider polynomial sized automaton A2 that accepts any walk in a graph ● T(a,b)=b iff (a,b) in edges of graph – Consider polynomial sized automaton A1 intersect A2 – This accepts only those strings corresponding to Hamiltonian cycles

25. Other generalizations of REGULAR ● REGULAR FIX(A,[X1,..Xn],[B1,..Bm]) iff – REGULAR(A,[X1,..Xn]) and Bi=1 iff exists j. Xj=I – Certain values must occur within the sequence – For example, there must be a maintenance shift – Unfortunately NP-hard to enforce GAC on this

26. Other generalizations of REGULAR ● REGULAR FIX(A,[X1,..Xn],[B1,..Bm]) – Simple reduction from Hamiltonian path – Automaton A accepts any walk on a graph – n=m and Bi=1 for all i

27. Chomsky hierarchy ● Regular languages ● Context-free languages ● Context-sensitive languages ●..

28. Chomsky hierarchy ● Regular languages – GAC propagator in O(ndQ) time ● Conext-free languages – GAC propagator in O(n^3) time and O(n^2) space – Asymptotically optimal as same as parsing! ● Conext-sensitive languages – Checking if a string is in the language PSPACE- complete – Undecidable to know if empty string in grammar and thus to detect domain wipeout and enforce GAC!

29. Context-free grammars ● Possible applications – Hierarchy configuration – Bioinformatics – Natual language parsing – … ● CFG(G,[X1,…Xn]) holds iff – X1.. Xn is a string accepted by the context free grammar G

30. Context-free grammars ● CFG(G,[X1,…Xn]) – Consider a block stacking example – S -> NP | P | PN | NPN – N -> n | nN – P -> aa | bb | aPa | bPb – These rules give n* w rev(w) n* where w is (a|b)* – Not expressible using a regular language ● Chomsky normal form – Non-terminal -> Terminal – Non-terminal -> Non-terminal Non-terminal

31. Context-free grammars ● CFG(G,[X1,…Xn]) – Example with X1 in {n,a}, X2 in {b}, X3 in {a,b} and X4 in {n,a} – Enforcing GAC on CFG prunes X3=a – Only supports are nbbn and abba

32. CFG propagator ● Adapt CYK parser ● Works on Chomsky normal form – Non-terminal -> Terminal – Non-terminal -> Non-terminal Non-terminal ● Using dynamic programming – Computes V[i,j], set of possible parsings for the ith to the jth symbols

33. CFG propagator ● Adapt CYK parser which uses dynamic programming – For i=1 to n do – V[i,1]:={A | A->a in G, a in dom(Xi) – For j=2 to n do – For i=1 to n-j+1 do – V[i,j]:={} – For k=1 to j-1 do – V[i,j]:=V[i,j] u {A|A->BC in G, – B in V[i,k], C in V[i+k,j-k]} – If not(S in V[1,n]) then “unsat”

34. Conclusions ● Global grammar constraints – Specify wide range of global constraints – Provide efficient and effective propagators automatically – Nice marriage of formal language theory and constraint programming!