11 January 2007 Constraints - Finite Domains 1 Constraints – Finite Domains Advanced Constraints Cardinality Constraints Propositional Constraints Constructive

11 January 2007 Constraints - Finite Domains 1

Constraints – Finite Domains

Advanced Constraints

• Cardinality Constraints

• Propositional Constraints

• Constructive Disjunction

Global Constraints

• Generalised Arc Consistency

• All-Different, Element, Circuit


Cardinality (Meta-) Constraint

Many problems, impose various types of precedence betwen tasks, have the

requirement that among a list of constraints

Lr = [C1, C2, ... , Cn]

The number of constraints to satisfy must lie between a lower bound L and an

upper bound U, both inclusive. Syntactically, this meta-constraints may be

specified as

#(L,U, [C1, C2, ... , Cn])

In particular, such constraints are quite common in resource management and

in scheduling problems, where resources (machines, materials, tasks or even

people) must be allocated in a “flexible” way.


Cardinality Constraint: Example

Example (Nurse Scheduling):

From the 7 nurses available at some hospital ward, at least 4 must be on duty

in the first shift.

This constraint may be modelled by considering boolean variables Xij to

represent that nurse i is on duty in shift j. The intended allocation may be

modelled by specification, to each shift j, of the cardinality meta-constraint

#(4,7, [X1j=1, X2j=1, ... , X7j=1])

In alternative, 7 variables Nij are considered for each shift j, whose domain are

the nurses 0 to 7 (0 meaning no nurse) leading to the formulation

#(4, 7, [N1j0, N2j 0, ... , N7j 0])


Cardinality Constraint: Operational Semantics

The operational semantics of this meta-constraint may be specified by

rewriting rules, using the Ask & Tell primitives just presented. The first two

rules rewrite the constraint into a simplified form

Rule 1: If one constraint is satisfied, it may be removed, and the number of

constraints to satisfy is decreased by one.

#(L,U, [C1, C2, ... , Ci, ... , Cn]), ask(Ci)

#(L-1,U-1, [C1, C2,...,Ci-1,Ci+1,..., Cn])

Rule 2: If one constraint is not satisfied, it is simply removed from the list.

#(L,U, [C1, C2, ... , Ci, ... , Cn]), ask(~Ci)

#(L,U, [C1, C2,...,Ci-1,Ci+1,..., Cn])



The two following rules refer to situations where the satisfaction or

“dissatisfaction” of the constraints must be imposed.

Rule 3: If the number of constraints in the list is the same as the lower limit,

then all constraints must be satisfied.

#(L,U, [C1, C2, ... , Ci, ... , Cn]), L = n

tell(C1), tell(C2), ..., tell(Cn)

Rule 4: If the upper limit becomes 0, all the constraints in the list must be

dissatisfied.

#(L,U, [C1, C2, ... , Ci, ... , Cn]), U = 0

tell(~C1), tell(~C2), ..., tell(~Cn)



Finally, the meta-constraint is trivially verified after certain transitions of rules 1

and 2 that decrease the constraints in the list and the lower and upper limits.

Rule 5: If no more constraints must be satisfied, and the constraints in the list

are not more than the upper limit, the meta-constraint succeeds.

#(L,U, [C1, C2, ... , Cn]), L = 0, U >= n

true

Rule 6: If there are less constraints in the list than the lower bound, the meta-

constraint fails

#(L,U, [C1, C2, ... , Cn]), L > n

false


Cardinality Constraint through Reified Constraints

Although this constraint may be specified directly from the rules presented, the

Ask&Tell mechanisms of SICStus based in the reified constraints allow a more

efficient form of specification, by counting the satisfied constraints and setting

the intended limits, by means of a typical recursive “Prolog-like” definition.

cardinal(L,U,Cs):- sats(Cs,N), N #=< U, L #=< N.

sats([],0).sats([C1|Cs],N1):- C1 #<=> B, N1 #= N2 + B, sats(Cs,N2).



The cardinality (meta-)constraint is genericaly applicable to combinations of

constraints requiring some form of counting.

Other combinations of constraints are possible to specify through the use of

reified constraints.

Among others, it is worth mentioning the case of conditional constraints, i.e.

those that should only be imposed if others are satisfied.

In scheduling, for example, it may be the case that only one of tasks T1 and T2

must finish before some time limit Z.

If this is task T2, then task T3 must start after some delay interval, I, starting

from the end of task T2.


Conditional Constraints through Reification

The guarantee that only one of the tasks T1 or T2 terminates before Z, may be

specified with cardinality

card( 1, 1, [S1+D1 #< Z, S2+D2 #< Z] )

However, the conditional constraint between T2 e T3 is not easily expressed by

means of countings, since the number of constraints to be satisfied on tasks

T2 / T3 may be 0, 1 or 2.

Conditional constraints may be modelled directly on the variables associated

with the reified constraints. In this case, we would have the following

reifications

S1+D1 #< Z #<=> B1

S2+D2 #< Z #<=> B2

S3 #> S2+D2+I #<=> B3


Conditional Constraints through Reification

Now, using directly boolean variables from the reified constraints, we may

specify both the cardinality constraint on tasks T1 and T2

B1 + B2 #= 1

as well as the conditional constraint on tasks T2 and T3, through the inequality

B3 #>= B2

Such inequality expresses the intended condition. If constraint C2 is not

satisfied (B2=0) the conditional constraint is not effectively posted or “told” (C3

may be satisfied or not).

When constraint C2 is satisfied (B2=1), then B3 is set to 1, and constraint C3 is

“told”.


Propositional Constraints

For convenience, rather than working with the boolean variables associated to

reified constraints, SICStus allows its direct use in propositional constraints.

For instance, the constraints on tasks T1, T2 and T3 could be directly specified

by means of the following propositional constraints

Cardinality (one and only one of constraints C1 and C2)

(S1+D1 #< Z) #\ ( S2+D2 #< Z)

equivalent to B1 + B2 #= 1

Conditional (if C2 then C3)

(S3 #> S2+D2+I ) #<= ( S2+D2 #< Z)

equivalent to B3 #>= B2



The following propositional constraints are defined

#\ C1 B1 #= 0 C1 must be dissatisfied

C1 #/\ C2 B1+B2 #= 2 C1 and C2 must both be satisfied

C1 #\ C2 B1+B2 #= 1 One and only one of C1 and C2 must be satisfied

C1 #\/ C2 B1+B2 #>=1 At least one of C1 and C2 must be satisfied

C1 #=> C2 B2 #>= B1 It C1 (C2) is satisfied, then C2 (C1) must also be

C2 #<= C1

C1 #<=>C2 B1 #= B2 C1 e C2 must both be either satisfied or

dissatisfied.


Constructive Disjunction

The combinations of constraints through propositional constraints follow the

general heuristic of least commitment

However, simply suspending the commitement of constraints might not be

sufficiently useful, as the variables concerned have not their domains pruned.

In some circumstances, one may infer conditions on the domains of the

variables, even before commiting to some of the constraints. This is the case

with Constructive Disjunction

Delay commitement to a constraint until, following the enumeration

of variables, make the variables domains to be sufficiently reduced

to make such commitment safe.



Example:

Let us consider two constraints C1 and C2 on variable X, whose domain is 1 to

100, of which we want that at least one of them stands (disjunction)

C1 : X #>= 50 C2 : X #=< 20

The previous propositional constraints would suspend until the domain of X be

pruned to either above 20 or below 50, in which case, one of the disjuncts

would be committed to.

For example, if X is reduced to 3 .. 40, C2 could be posted safely, further

pruning the domain to 3 .. 20.

However, the interval 21 .. 49 could have been immediately pruned from the

the domain of X, since it does not satisfy either of the disjuncts.



Such antecipation of domain pruning is the goal of constructive disjunction. Its

modelling may be specified through adequate indexical constraints.

disjunction1(X, S1, S2) :-

X in S2 .. Sup \/ inf .. S1.

?- X in 1..100, disjunction1(X,20,50).

X in(1..20)\/(50..100)

and compared with the least commitment implementation

disjunction2(X, S1, S2) :-

X #>= S2 #\/ X #=< S1.

?- X in 1..100, disjunction2(X,20,50).

X in 1..100


Global Constraints: Generalised Arc Consistency

It is often important to define n-ary “global” constraints, for at least two reasons

• Ease the modelling of a problem

• Exploitation of specialised algorithms that take the semantics of the

constraint for efficient propagation, achieving generalised arc

consistency.

The generalised arc consistency (GAC) criterion sees that no value remains

in the domain of a variable with no support in values of each of the other

variables participating in the “global” constraint.

Example: all_diff ([A1, A2, ..., An]

Constrain a set of n variables to be all different among themselves


Global Constraints: all_diff

The constraint definition based on binary difference constraints () does not

pose any problems as much as modelling is concerned. For example, it may

be being defined recursively in CLP.

However, constraint propagation based on binary constraints alone does not

provide in general much propagation.

As seen before, arc consistency is not any better than node consistency, and

higher levels of consistency are in general too costly and do not take into

account the semantics of the all_different constraint.

one_diff(_,[]).one_diff(X,[H|T]):-

X #\= H, one_diff(X,T).

all_diff([]).all_diff([H|T]):-

one_diff(H,T),all_diff(T).



Example:

X1: 1,2,3 X6: 1,2,3,4,5,6,7,8,9

X2: 1,2,3,4,5,6 X7: 1,2,3,4,5,6,7,8,9

X3: 1,2,3,4,5,6,7,8,9 X8: 1,2,3

X4: 1,2,3,4,5,6 X9: 1,2,3,4,5,6

X5: 1,2,3

It is clear that constraint propagation based on maintenance of node-, arc- or

even path-consistency would not eliminate any redundant label.

Yet, it is very easy to infer such elimination with a global view of the constraint!



Variables X1, X5 and X8 may only take values 1, 2 and 3. Since there are 3

values for 3 variables, these must be assigned these values which must then

be removed from the domain of the other variables.

Now, variables X2, X4 and X9 may only take values 4, 5 e 6, that must be

removed from the other variables domains.

X1: 1,2,3 X2: 1,2,3,4,5,6 X3: 1,2,3,4,5,6,7,8,9

X4: 1,2,3,4,5,6 X5: 1,2,3 X6: 1,2,3,4,5,6,7,8,9

X7: 1,2,3,4,5,6,7,8,9 X8: 1,2,3 X9: 1,2,3,4,5,6

X1: 1,2,3 X2: 1,2,3,4,5,6 X3: 1,2,3,4,5,6,7,8,9

X4: 1,2,3,4,5,6 X5: 1,2,3 X6: 1,2,3,4,5,6,7,8,9

X7: 1,2,3,4,5,6,7,8,9 X8: 1,2,3 X9: 1,2,3,4,5,6



In this case, these prunings could be obtained, by maintaining (strong) 4-

consistency.

For example, analysing variables X1, X2, X5 and X8, it would be “easy” to verify

that from the d4 potential assignments of values to them, no assignment would

include X2 = 1, X2 = 2, nor X2 = 3, thus leading to the prunning of X2 domain.

However, such maintenance is usually very expensive, computationally. For

each combination of 4 variables, d4 tuples whould be checked, with complexity

O(d4).

In fact, in some cases, n-strong consistency would be required, so its naïf

maintenance would be exponential on the number of variables, exactly what

one would like to avoid in search!



However, taking the semantics of this constraint into account, an algorithm

based on quite a different approach allows the prunings to be made at a much

lesser cost, achieving generalised arc consistency.

Such algorithm (see [Regi94]), is grounded on graph theory, and uses the

notion of graph matching.

To begin with, a bipartite graph is associated to an all_diff constraints. The

nodes of the graphs are the variables and all the values in their domains, and

the arcs associate each variable with the values in its domain.

In polinomial time, it is possible to eliminate, from the graph, all arcs that do not

correspond to possible assignments of the variables.



Key Ideas:

For each variable-value pair, there is an arc in the bipartite graph.

A matching, corresponds to a subset of arcs that link some variable nodes to

value nodes, different variables being connected to different values.

A maximal matching is a matching that includes all the variable nodes.

For any solution of the all_diff constraint there is one and only one maximal

matching.



Example: A,B:: 1..2, C:: 1..3, D:: 2..5, E:: 3..6,

all_diff([A,B,C,D,E]).

A

B

C

D

E

1

2

3

4

5

6

A = 1

B = 2

C = 3

D = 4

E = 5

Maximal Matching



The propagation (domain filtering) is done according to the following principles:

1. If an arc does not belong to any maximal matching, then it does not

belong to any all_diff solution.

2. Once determined some maximal matching, it is possible to determine

whether an arc belongs or not to any maximal matching.

3. This is because, given a maximal matching, an arc belongs to any

maximal matching iff it belongs:

a) To an alternating cycle; or

b) To an even alternating path, starting at a free node.



Example: For the maximal matching (MM) shown

• 6 is a free node;

• 6-E-5-D-4 is an even alternating path, alternating

arcs from the MM (E-5, D-4) with arcs not in the MM

(D-5, E-6);

• A-1-B-2-A is an alternating cycle;

• E-3 does not belong to any alternating cycle

• E-3 does not belong to any even alternating path

starting in a free node (6)

• E-3 may be filtered out!

A

B

C

D

E

1

2

3

4

5

6



Compaction

Before this analysis, the graph may be “compacted”, aggregating, into a

single node, “equivalent nodes”, i.e. those belonging to alternating cycles.

Intuitively, for any solution involving these variables and values, a different

solution may be obtained by permutation of the corresponding

assignments.

Hence, the filtering analysis may be made based on any of these

solutions, hence the set of nodes can be grouped in a single one.



A-1-B-2-A is an alternating cycle;

By permutation of variables A and B, the solution

<A,B,C,D,E> = <1,2,3,4,5> becomes <A,B,C,D,E>

= <2,1,3,4,5>

Hence, nodes A e B, as well as nodes 1 and 2

may be grouped together (as may the nodes D/E

and 4/5).

A/B

C

4/5

3

6

D/E

1/2

A

B

C

D

E

1

2

3

4

5

6

With these grouping the graph

becomes much more compact



Analysis of the compacted graph shows that

A/B

C

4/5

3

6

D/E

1/2

A/B

C

4/5

3

6

D/E

1/2

• Arc D/E - 3 may be filtered out (notice

that despite belonging to cycle

D/E - 3 - C - 1/2 - D/E,

• this cycle is not alternating.

• Arcs D/E - 1/2 and C - 1/2 may also be

filtered.

The compact graph may thus be

further simplified to



By expanding back the simplified compact graph, one gets the graph on the right

that

A/B

C

4/5

3

6

D/E

1/2

Which immediately sets C=3 and, more generaly, filters the initial domains to

A,B :: 1..2, C:: 1,2,3, D:: 2,3,4,5, E:: 3,4,5,6

A

B

C

D

E

1

2

3

4

5

6



Upon elimination of some labels (arcs), possibly due to other constraints, the

all_diff constraint propagates such prunings, incrementally.

There are 3 situations to consider:

1. Elimination of a vital arc (the only arc connecting a variable node with a

value node): The constraint cannot be satisfied.

A

B

C

D

E

1

2

3

4

5

6

A

B

C

D

E

1

2

3

4

5

6

?



2. Elimination of a non-vital arc which is a member to the maximal matching

Determine a new maximal matching and restart from there.

A

B

C

D

E

1

2

3

4

5

6

A

B

C

D

E

1

2

3

4

5

6

Arc A-4 does not belong to the even alternating path started in node 6. D-5 also

leaves this path, but it still belongs to an alternating cycle.



3. Elimination of a non-vital arc which is not a member to the maximal

matching

Eliminate the arcs that do not belong any more to an alternating cycle or

path.

A new maximal matching includes arcs D-5 and E-6. In this matching, arcs E-4 and

E-5 do not belong to even alternating paths or alternating cycles.

A

B

C

D

E

1

2

3

4

5

6

A

B

C

D

E

1

2

3

4

5

6



Time Complexity:

Assuming n variables, each of which with d values, and where D is the

cardinality of the union of all domains,

1. It is possible to obtain a maximal matching with an algorithm of time

complexity O(dnn).

2. Arcs that do not belong to any maximal matching may be removed with

time complexity O( dn+n+D).

3. Taking into account these results, we obtain complexity of

O(dn+n+D+dnn). Since D < dn, the total time complexity of the

algorithm is dominated by the last term, thus becoming

O(dnn).

which is much better than the poor result with a naïf analysis.



Availability:

1. The all_diff constraint first appeared in the CHIP system (algorithm?).

2. The described implementation is incorporated into the ILOG system, and

avalable as primitive IlcAllDiff.

3. This algorithm is also implemented in SICStus, through buit-in constraint

all_distinct/1.

4. Other versions of the constraint, namely all _different/2, are also available,

possibly using a faster algorithm but with less pruning, where the 2nd argument

controls the available pruning options.



Example: Sudoku

• Cuts in green are all that are found by maïve all_diff.

• Global all_diff finds all values without backtracking.

• The first cuts are illustrated in the figure.

(where the indices show a possible order in which the cuts are made)

sudoku_cp.pl

Files vh_1 e vh_2

8 4 6 4 3 5

6 12 37 7 1 8

3 9 8 6

2 1 12 258 6 9 347 5 7

9 4 2 258 6 6 347 5 1

5 258 6 1 347 5 3

6 7 1 1 378 9 2 4

4 2 11 6 378 9 9 3

13 10 8 9 37 7 4 8 5 6 237 10127 10


Global Constraints: circuit

The previous global constraints may be regarded as imposing a certain

“permutation” on the variables.

In many problems, such permutation is not a sufficient constraint. It is

necessary to impose a certain “ordering” of the variables.

A typical situation occurs when there is a sequencing of tasks, with

precedences between tasks, possibly with non-adjacency constraints between

some of them.

In these situations, in addition to the permutation of the variables, one must

ensure that the ordering of the tasks makes a single cycle, i.e. there must be

no sub-cycles.



These problems may be described by means of directed graphs, whose nodes

represent tasks and the directed arcs represent precedences.

The arcs may even be labelled by “features” of the precedences, namely

transition times.

This is a situation typical of several problems of the travelling salesman type.

A B

C D

A B

C D

2

3

4 5 6

9

8

7

2

2

2



Filtering: For these type of problems, the arcs that do not belong to any

hamiltonian circuit should be eliminated.

In the graph, it is easy to check that the only possible circuits are

A -> B -> D -> C -> A and A -> C-> D-> B-> A.

Certain arcs (e.g. B -> C, B -> B, ...), may not belong to any hamiltonian

circuit and can be safely pruned.

A B

C D

A B

C D



The pruning of the arcs that do not belong to any circuit is the goal of the

global constraint circuit/1, available in SICStus.

This constraint is applicable to a list of domain variables, where the domain of

each corresponds to the arcs connecting that variable to other variables,

denoted by the order in which they appear in the list.

For example:

A in 2..3, B in 1..4,

C in 1..4, D in 2..3,

circuit([A,B,C,D]).

A/1 B/2

C/3 D/4

A=2

A=3



Global constraint circuit/1 incrementally achieves the pruning of the arcs not in

any hamiltonian circuit. For example, posing

A, D in 2..3, B in 1,2,3,4, C in 1,2,3,4,circuit([A,B,C,D]).

The following prunning is achieved

A in 2..3, B in 1,2,3,4, C in 1,2,3,4, D in 2..3,

since the possible solutions are

[A,B,C,D] = [2,4,1,3] and [A,B,C,D] = [3,1,4,2]

... but not [A,B,C,D] = [3,4,1,2] . Why?

A B

C D

A B

C D


Global Constraints: element

For example, the value X from the arc that leaves

node A, depends on the arc chosen:

if A = 2 then X = 3,

if A = 3 then X = 4;

otherwise X = undefined

A/1 B/2

C/3 D/4

2

3

4 5 6

9

8

7

2

2

2

The disjunction implicit in this definition raises, as well known, problems of

efficiency to constraint propagation.

Often a variable not only has its values constrained by the values of other

variables, but it is actually defined conditionally in function of these values.



In fact, the value of X may only be known upon labelling of variable A. Until then,

a naïf handling of this type of conditional constraint would infer very little from it.

A/1 B/2

C/3 D/4

2

3

4 5 6

9

8

7

2

2

2

However, if other problem constraints impose, for example, X < 4, an efficient

handling of this constraint would impose

not only X = 3 but also A = 2.

if A = 2 then X = 3,

if A = 3 then X = 4;

otherwise X = undefined



The efficient handling of this type of disjunctions is the goal of global constraint

element/3, available in SICStus and CHIP.

element(X, [V1,V2,...,Vn], V)

In this constraint, X is a variable with domain 1..n, and both V and the Vis are

either finite domain constraints or constants. The semantics of the constraint

can be expressed as the equivalence

X = i V = Vi

From a propagation viewpoint, this constraint imposes arc consistency in X

and bounds consistency in V. It is particularly optimised for when all Vis are

ground.



A possible implementation of it, based in SICStus reified constraints is shown

below.

elem_4(I, [A,B,C,D], X):- I in 1..4, x_dom_4(X,A,B,C,D), I #= 1 #=> X #= A, I #= 2 #=> X #= B, I #= 3 #=> X #= C, I #= 4 #=> X #= D.

x_dom_4(X,A,B,C,D)+: X in dom(A) \/ dom(B) \/ dom(C) \/ dom(D).

Notice that the above example requires a fixed number of variables in the list

(4 in the example) since fd_predicates do not take lists as arguments .



A more general implementation is shown below, but it is less efficient than the

SICStus implementation, since it generates a number of additional variables.

elem(I, Xlist, X):- length(Xlist,N), I in 1..N, W in 0..0, x_dom(W,I,1,Xlist,X).

x_dom(X,_,_,[],X).x_dom(X,I,K,[H|T],Z):-

add_dom(X,H,Y), I #= K #=> Z #= H, K1 is K +1, x_dom(Y,I,K1,T,Z).

add_dom(X,A,Z)+: Z in dom(X) \/ dom(A).



The previous global constraints may be regarded as imposing a certain

“permutation” on the variables.

In many problems, such permutation is not a sufficient constraint. It is

necessary to impose a certain “ordering” of the variables.

A typical situation occurs when there is a sequencing of tasks, with

precedences between tasks, possibly with non-adjacency constraints between

some of them.

In these situations, in addition to the permutation of the variables, one must

ensure that the ordering of the tasks makes a single cycle, i.e. there must be

no sub-cycles.



Global constraints may be used together. In particular, constraints element

and circuit may implement the travelling salesman (satisfaction problem

(travelling.pl): For some graph, determine an hamiltonian circuits whose

length does not exceed Max (say 20).

circ([A,B,C,D], Max, Cost):- A in 2..3, B in 1..4, C in {1}\/{3,4}, D in 2..3, circuit([A,B,C,D]), element(A,[_,3,4,_],Ca), element(B,[2,2,5,6],Cb), element(C,[2,_,2,9],Cc), element(D,[_,8,7,_],Cd), Cost #= Ca+Cb+Cc+Cd, Cost #=< Max, labeling([],[A,B,C,D]).

A/1 B/2

C/3 D/4

2

3

4 5 6

9

8

7

2

2

2



The circuit constraint can be implemented through several element constraints, as

shown below (for a circuit with 3 nodes). It requires another list S that guarantees

that all nodes are visited at some order Sith.

If X2 = 1, then circuit includes arc 2 1. But this means that if some Sj = 2 (node

2 is the jth node to be visited) then Sj+1 = 1 (node 1 will be the J+1th to be visited).

circ([X1,X2,X3]):- X = [X1,X2,X3], S = [S1,S2,S3], domain(S,1,3), S1 #= 1, % to avoid simmetries

all_distinct(S), all_distinct(X),

element(S1,[X1,X2,X3],S2), element(S2,[X1,X2,X3],S3), % Sj = I, Xi = K => Sj+1 = K element(S3,[X1,X2,X3],S1).


Global Constraints: cycle

Sometimes, the goal is to form more than one (1) circuit connecting all the

nodes.

This situation corresponds to the classical problem of the Multiple Traveling

Salesman, that is highly suitable to model several practical applications.

For example, the case where a number of petrol stations has to be serviced by

a number N of tankers.

For such type of applications, CHIP extended the global constraint circuit/1,

to another cycle/2, where the first argument is a domain variable of an integer

to account for the number of cycles.

Note: Constraint circuit(L) is implemented in CHIP as cycle(1,L).


Global Constraints: cycle

Example:

X1::[1,3,4], X2::[1,3] , X3::[2,5,6]

X4::[2,5] , X5::[6] , X6::[4,5]

?- N::[1,2,3], X = [X1,X2,X3,X4,X5,X6], cycle(N,X).

N = 1 N = 2 N = 3

X =[3,1,5,2,6,4] X=[3,2,1,5,6,4] X=[3,1,5,2,6,4]

2 4 6

1 3 5

2 4 6

1 3 5

2 4 6

1 3 5

2 4 6

1 3 5

Documents

11 January 2007 Constraints - Finite Domains 1 Constraints – Finite Domains Advanced Constraints Cardinality Constraints Propositional Constraints Constructive