- By
**pepin** - Follow User

- 111 Views
- Uploaded on

Download Presentation
## Non-binary constraints

**An Image/Link below is provided (as is) to download presentation**

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript

Non-exhaustive catalog

- Order constraints
- Constraints on values
- Partitioning constraints
- Timetabling constraints
- Graph constraints
- Scheduling constraints
- Bin-packing constraints

Global constraints

- It isn’t just all-different!
- Many constraints specialized to application domains
- Scheduling
- Packing
- ..

Order constraints

- min(X,[Y1,..,Yn]) and max(X,[Y1,..Yn])

X <= minimum(Y1,..,Yn)

X >= maximum(Y1,..Yn)

n.b. min is relational not functional

Order constraints

- min(X,[Y1,..,Yn]) and max(X,[Y1,..Yn])

X <= minimum(Y1,..,Yn)

X <= maximum(Y1,..Yn)

n.b. min is relational not functional

- min_mod(X,[Y1,..,Yn],m) and max_mod(X,[Y1,..Yn],m)

X mod m <= minimum(Y1 mod m,..,Yn mod m)

X mod m <= maximum(Y1 mod m,..,Yn mod m)

Order constraints

- min_n(X,n,[Y1,..Ym]) and max_n(X,n,[Y1,..,Ym)

X is nth smallest value in Y1,..Ym

X is nth largest value in Y1,..Ym

Order constraints

- min_n(X,n,[Y1,..Ym]) and max_n(X,n,[Y1,..,Ym)

X is nth smallest value in Y1,..Ym

X is nth largest value in Y1,..Ym

min_n(X,1,[Y1,..,Ym]) => min(X,[Y1,..,Yn])

max_n(X,1,[Y1,..,Ym]) => max(X,[Y1,..,Ym])

n.b. min_n is functional but min is relational (any X smaller than min will do!

Value constraints

- among(N,[Y1,..,Yn],[val1,..,valm])

N vars in [Y1,..,Yn] take values val1,..valm

e.g. among(2,[1,2,1,3,1,5],[3,4,5])

Value constraints

- among(N,[Y1,..,Yn],[val1,..,valm])

N vars in [Y1,..,Yn] take values val1,..valm

e.g. among(2,[1,2,1,3,1,5],[3,4,5])

- count(n,[Y1,..,Ym],op,X) where op is =,<,>,=/,<= or >=

relation “Yi op X” holds n times

E.g. among(n,[Y1,..,Ym],[k]) = count(n,[Y1,..,Ym],=,k)

Value constraints

- balance(N,[Y1,..,Yn])

N = occurrence of more frequent value - occurrence of least frequent value

E.g balance(2,[1,1,1,3,4,2])

Value constraints

- balance(N,[Y1,..,Yn])

N = occurrence of more frequent value - occurrence of least frequent value

E.g balance(2,[1,1,1,3,4,2])

all-different([Y1,..,Yn]) => balance(0,[Y1,..,Yn])

Value constraints

- min_nvalue(N,[Y1,..,Yn]) and max_nvalue(N,[Y1,..,Yn])

least (most) common value in Y1,..,Yn occurs N times

E.g. min_nvalue(2,[1,1,2,2,2,3,3,5,5])

Can replace multiple count or among constraints

Value constraints

- common(X,Y,[X1,..,Xn],[Y1,..,Ym])

X vars in Xi take a value in Yi

Y vars in Yi take a value in Xi

E.g. common(3,4,[1,9,1,5],[2,1,9,9,6,9])

Value constraints

- common(X,Y,[X1,..,Xn],[Y1,..,Ym])

X vars in Xi take a value in Yi

Y vars in Yi take a value in Xi

E.g. common(3,4,[1,9,1,5],[2,1,9,9,6,9])

among(X,[Y1,..,Yn],[val1,..,valm]) = common(X,Y,[X1,..,Yn],[val1,..,valm])

Value constraints

- same([X1,..,Xn],[Y1,..,Yn])

Yi is a permutation of Xi

- used_by([X1,..,Xn],[Y1,..,Ym])

all values in Yi are used by vars in Xi

m>=m

Value constraints

- same([X1,..,Xn],[Y1,..,Yn])

Yi is a permutation of Xi

- used_by([X1,..,Xn],[Y1,..,Ym])

all values in Yi are used by vars in Xi

m>=m

- on n values:

alldifferent([X1,..,Xn])=same([X1,..,Xn],[1,..,n])

=used_by([X1,..,Xn],[1,..,n])

Partitioning constraints

- all-different([X1,..,Xn])

Partitioning constraints

- all-different([X1,..,Xn])
- Other flavours

all-different_except_0([X1,..,Xn])

Xi=/Xj unless Xi=Xj=0

- 0 is often used for modelling purposes as “dummy” value
- Don’t use this slab
- Don’t open this bin ..

Partitioning constraints

- all-different([X1,..,Xn])
- Other flavours

symmetric-all-different([X1,..,Xn])

Xi=/Xj and Xi=j iff Xj=i

- Very common in practice
- Team i plays j iff Team j plays i..

Partitioning constraints

- all-different([X1,..,Xn])
- Other flavours

symmetric-all-different([X1,..,Xn])

Xi=/Xj and Xi=j iff Xj=i

- Very common in practice
- Team i plays j iff Team j plays i..
- Regin has proposed very efficient algorithm

Partitioning constraints

- nvalue(N,[X1,..,Xn])

Xi takes N different values

all-different([X1,..,Xn]) = nvalue(n,[X1,..,Xn)

Partitioning constraints

- nvalue(N,[X1,..,Xn])

Xi takes N different values

all-different([X1,..,Xn]) = nvalue(n,[X1,..,Xn)

- gcc([X1,..,Xn],Lo,Hi)

values in Xi occur between Lo and Hi times

all-different([X1,..,Xn])=gcc([X1,..,Xn],1,1)

Timetabling constraints

- change(N,[X1,..,Xn]),op) where op is {=,<,>,<=,>=,/=}

“Xi op Xi+1” holds N times

E.g. change(3,[4,4,3,4,1],/=)

- You may wish to limit the number of changes of classroom, shifts, …

Timetabling constraints

- longest_changes(N,[X1,..,Xn]),op) where op is {=,<,>,<=,>=,/=}

longest sequence “Xi op Xi+1” is of length N

E.g. longest_changes(2,[4,4,4,3,3,2,4,1,1,1],=)

- You may wish to limit the length of a shift without break, …

Graph constraints

- Tours in graph a often represented by the successors:
- [X1,..,Xn] means from node i we go to node Xi

Graph constraints

- Tours in graph a often represented by the successors:
- [X1,..,Xn] means from node i we go to node Xi
- E.g. [2,1,5,3,4] represents the 2 cycles

(1)->(2)->(1) and (3)->(5)->(4)->(3)

Graph constraints

- cycle(N,[X1,..,Xn])

there are N cycles in Xi

e.g. cycle(2,[2,1,5,3,4]) as we have the 2 cycles

(1)->(2)->(1) and (3)->(5)->(4)->(3)

Useful for TSP like problems (e.g. sending engineers out to repair phones)

Graph constraints

- derangement(N,[X1,..,Xn])

there are no length 1 cycles in Xi

e.g. derangement([2,1,5,3,4]) as the 2 cycles

(1)->(2)->(1) and (3)->(5)->(4)->(3) have length 2

and 3

Graph constraints

- derangement(N,[X1,..,Xn])

there are no length 1 cycles in Xi

e.g. derangement([2,1,5,3,4]) as the 2 cycles

(1)->(2)->(1) and (3)->(5)->(4)->(3) have length 2

and 3

e.g. derangement([3,1,2,4]) as the 2 cycles (1)->(3)->(2)->(1) and (4)->(4) are of length 3 and 1

Graph constraints

- We may also wish to represent predecessors
- For good labelling heuristics
- For ease of statement of constraints
- [X1,..,Xn] means we came to node i from node Xi

Graph constraints

- We may also wish to represent predecessors
- For good labelling heuristics
- For ease of statement of constraints
- [X1,..,Xn] means we came to node i from node Xi
- E.g. [2,1,4,5,3] now represents the 2 cycles

(1)->(2)->(1) and (3)->(5)->(4)->(3)

Graph constraints

- We may also wish to represent predecessors
- For good labelling heuristics
- For ease of statement of constraints
- [X1,..,Xn] means we came to node i from node Xi
- E.g. [2,1,4,5,3] now represents the 2 cycles

(1)->(2)->(1) and (3)->(5)->(4)->(3)

- In successor notation this was [2,1,5,3,4]

Graph constraints

- We may also wish to represent predecessors
- For good labelling heuristics
- For ease of statement of constraints
- [X1,..,Xn] means we came to node i from node Xi
- E.g. [2,1,4,5,3] now represents the 2 cycles

(1)->(2)->(1) and (3)->(5)->(4)->(3)

- In successor notation this was [2,1,5,3,4]
- How do we know they are the same?

Graph constraints

- We may also wish to represent predecessors
- For good labelling heuristics
- For ease of statement of constraints
- [X1,..,Xn] means we came to node i from node Xi
- E.g. [2,1,4,5,3] now represents the 2 cycles

(1)->(2)->(1) and (3)->(5)->(4)->(3)

- In successor notation this was [2,1,5,3,4]
- How do we know they are the same?
- With a channelling constraint!

Graph constraints

- Inverse([X1,..,Xn],[Y1,..,Yn])

Where [X1,..,Xn] is a successor representation of a path, and [Y1,..,Yn] is a predecessor

Thus inverse([2,1,4,5,3],[2,1,5,3,4])

Graph constraints

- Inverse([X1,..,Xn],[Y1,..,Yn])

Where [X1,..,Xn] is a successor representation of a path, and [Y1,..,Yn] is a predecessor

Thus inverse([2,1,4,5,3],[2,1,5,3,4])

And inverse([2,1,5,3,4],[2,1,4,5,3])

Scheduling constraints

- cummulative([S1,..,Sn],[D1,..,Dn],[E1,..,En],[H1,..,Hn],L)
- schedules n (concurrent) jobs, each with a height Hi
- ith job starts at Si, runs for Di and ends at Ei
- Ei=Si+Di
- at any time, accumulated height of running jobs is less than L

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

Scheduling constraints

- coloured_cummulative([S1,..,Sn],[D1,..,Dn],[E1,..,En],[C1,..,Cn],L)
- schedules n (concurrent) each with a colour Ci
- no more than L colours running at any one time

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

Scheduling constraints

- cycle_cummulative(m,[S1,..,Sn],[D1,..,Dn],[E1,..,En],[H1,..,Hn],L)
- schedules n (concurrent) jobs, each with a height Hi onto a cyclic schedule of length m

Scheduling constraints

- cummulatives([M1,,,Mn],[S1,..,Sn],[D1,..,Dn],[E1,..,En],[H1,..,Hn],[L1,..,Lm])
- schedules n (concurrent) jobs, each with a height Hi onto one of m machines
- ith runs on Mi
- accumulated height of running jobs on machine i <= Li

Scheduling constraints

- cummulatives([M1,..Mn],[S1,..,Sn],[D1,..,Dn],[E1,..,En],[H1,..,Hn],[L1,..,Lm])

Machine 1

Machine 2

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

Scheduling constraints

- coloured_cummulatives([M1,,,Mn],[S1,..,Sn],[D1,..,Dn],[E1,..,En],[C1,..,Cn],[L1,..,Lm])
- schedules n (concurrent) jobs, each with a colour i onto one of m machines
- ith runs on Mi
- number of colours of running jobs on machine i <= Li

Bin-packing constraints

- bin_packing(capacity,[B1,..,Bn],[w1,..,wn])

for each bin j, sum_Bi=j wi <= capacity

Bin-packing constraints

- bin_packing(capacity,[B1,..,Bn],[w1,..,wn])

for each bin j, sum_Bi=j wi <= capacity

special case of cummulative with task durations=1

Bin-packing constraints

- bin_packing(capacity,[B1,..,Bn],[w1,..,wn])

for each bin j, sum_Bi=j wi <= capacity

special case of cummulative with task durations=1

unlike normal bin-packing, does not minimize the number of open bins

Bin-packing constraints

- bin_packing(capacity,[B1,..,Bn],[w1,..,wn])

for each bin j, sum_Bi=j wi <= capacity

special case of cummulative with task durations=1!

unlike normal bin-packing, does not minimize the number of open bins

how could we do this?

Bin-packing constraints

- bin_packing(capacity,[B1,..,Bn],[w1,..,wn])

for each bin j, sum_Bi=j wi <= capacity

special case of cummulative with task durations=1!

unlike normal bin-packing, does not minimize the number of open bins

Bi=j implies Open_j=1

Minimize sum_j Open_j

Misc constraints

- element(Index,[a1,..,an],Var)

Var=a_Index

constraint programming’s answer to arrays!

e.g. element(Item,[10,23,12,15],Cost)

GAC-Schema

- A generic framework for achieving AC for any kind of constraint (can be non binary).Bessiere and Regin, IJCAI’97
- You just have to say how to compute a solution.
- Works incrementality (notion of support).

GAC-Schema: instantiation

- List of allowed tuples
- List of forbidden tuples
- Predicates
- Any OR algorithm
- Solver re-entrace

GAC-Schema

- Idea: tuple = solution of the constraintsupport = valid tuple- while the tuple is valid: do nothing - if the tuple is no longer valid, then search for a new support for the values it contains
- a solution (support) can be computed by any algorithm

Example

- X(C)={x1,x2,x3} D(xi)={a,b}
- T(C)={(a,a,a),(a,b,b),(b,b,a),(b,b,b)}

Example

- X(C)={x1,x2,x3} D(xi)={a,b}
- T(C)={(a,a,a),(a,b,b),(b,b,a),(b,b,b)}
- Support for (x1,a): (a,a,a) is computed and (a,a,a) is added to S(x2,a) and S(x3,a), (x1,a) in (a,a,a) is marked as supported.

Example

- X(C)={x1,x2,x3} D(xi)={a,b}
- T(C)={(a,a,a),(a,b,b),(b,b,a),(b,b,b)}
- Support for (x1,a): (a,a,a) is computed and (a,a,a) is added to S(x2,a) and S(x3,a), (x1,a) in (a,a,a) is marked as supported.
- Support for (x2,a): (a,a,a) is in S(x2,a) it is valid, therefore it is a support. (Multidirectionnality). No need to compute a solution

Example

- X(C)={x1,x2,x3} D(xi)={a,b}
- T(C)={(a,a,a),(a,b,b),(b,b,a),(b,b,b)}
- Support for (x1,a): (a,a,a) is computed and (a,a,a) is added to S(x2,a) and S(x3,a), (x1,a) in (a,a,a) is marked as supported.
- Value a is removed from x1, then all the tuples in S(x1,a) are no longer valid: (a,a,a) for instance. The validity of the values supported by this tuple must be reconsidered.

Example

- X(C)={x1,x2,x3} D(xi)={a,b}
- T(C)={(a,a,a),(a,b,b),(b,b,a),(b,b,b)}
- Support for (x1,b): (b,b,a) is computed, and updated ...

GAC-Schema: complexity

- CC complexity to check consistency (seek in table, call to OR algorithm): seek for a Support costs CC
- n variables, d values:for each value: CCfor all values: O(ndCC)
- For any OR algorithm which is able to compute a solution, Arc consistency can be achieved in O(ndCC).

Table Constraint: An example

- Configuration problem:5 types of components: {glass, plastic, steel, wood, copper}3 types of bins: {red, blue, green} whose capacity is red 5, blue 5, green 6Constraints:- red can contain glass, cooper, wood- blue can contain glass, steel, cooper- green can contain plastic, copper, wood- wood require plastic; glass exclusive copper- red contains at most 1 of wood- green contains at most 2 of woodFor all the bins there is either no plastic or at least 2 plasticGiven an initial supply of 12 of glass, 10 of plastic, 8 of steel, 12 of wood and 8 of copper; what is the minimum total number of bins?

Semantics of a constraint

- Speed-up the search for a support (solution which contain a value (x,a))

Exploiting constraint semantics

- Speed-up the search for a support (solution which contain a value (x,a)):x < y, D(x)=[0..10000], D(y)=[0..10000]support for (x,9000): immediate any value greater than 9000 in D(y)

Semantics of a constraint

- Design of ad-hoc filtering algorithm:x < y : (a) max(x) = max(y) -1(b) min(y) = min(x) +1

Exploiting semantics

- Design of ad-hoc filtering algorithm:x < y : (a) max(x) = max(y) -1(b) min(y) = min(x) +1
- Triggering of the filtering algorithm:no possible pruning of D(x) while max(y) is not modifiedno possible pruning of D(y) while min(x) is not modified

Regin’s alldiff algorithm

- Construct the value graph

1

2

3

4

5

6

7

x1

x2

x3

x4

x5

x6

D(x1)={1,2}

D(x2)={2,3}

D(x3)={1,3}

D(x4)={3,4}

D(x5)={2,4,5,6}

D(x6)={5,6,7}

Alldiff constraint

- Construct a flow network

Alldiff constraint

- Construct a flow network
- Compute a feasible flow

Alldiff constraint

- Construct a flow network
- Compute a feasible flow
- Construct the residual graph
- Reverse direction of arcs on feasible flow (that is, of red arcs)

Alldiff constraint

- Construct a flow network
- Compute a feasible flow
- Construct the residual graph
- Compute the strongly connected components
- Strongly connected component = maximal subgraph such that if directed path u to v, also from v to u

Alldiff constraint

- Construct a flow network
- Compute a feasible flow
- Construct the residual graph
- Compute the strongly connected components
- Strongly connected component = maximal subgraph such that if directed path u to v, also from v to u
- Exists O(N) algorithm due to Tarjan (1972) = O(n+d)

Alldiff constraint

- Construct a flow network
- Compute a feasible flow
- Construct the residual graph
- Compute the strongly connected components
- Remove arcs of flow value 0 (i.e. black arcs) with ends belonging to two different components

GAC for all-different

- Theorem

An arc is deleted from residual graph iff the associated value is not GAC

GAC subproblem

The value graph:

1

2

3

4

5

6

7

x1

x2

x3

x4

x5

x6

D(x1)={1,2}

D(x2)={2,3}

D(x3)={1,3}

D(x4)={4}

D(x5)={5,6}

D(x6)={5,6,7}

Before!

The value graph:

1

2

3

4

5

6

7

x1

x2

x3

x4

x5

x6

D(x1)={1,2}

D(x2)={2,3}

D(x3)={1,3}

D(x4)={3,4}

D(x5)={2,4,5,6}

D(x6)={5,6,7}

Conclusions

- Vast range of global constraints
- Cover all the areas that CP cover
- Some very generic (e.g. all-different)
- Some very specific (coloured cummulative ..)
- GAC algorithms
- Generic (GAC-schema)
- Specific (GAC alldifferent)

Download Presentation

Connecting to Server..