Global constraints

• alldifferent(Vars):
• all_different(Vars): The elements in Vars are mutually different, where Vars is a list of terms.

• alldistinct(Vars):
• all_distinct(Vars): This is equivalent to alldifferent(Vars), but it uses a stronger consistency checking algorithm to exclude inconsistent values from domains of variables.

• post_neqs(L) L is a list of inequality constraints of the form X #\= Y, where X and Y are variables. This constraint is equivalent to the conjunction of the inequality constraints in L, but it extracts all_distinct constraints from the inequality constraints.

• assignment(Xs,Ys): Let Xs=[X1,...,Xn] and Ys=[Y1,...,Yn]. Then the following are true:

     Xs in 1..n,
     Ys in 1..n,
     for each i,j in 1..n, Xi#=j #<=> Yj#=i
  

  where #<=> is a Boolean constraint. The variables in Ys are called dual variables.

• assignment0(Xs,Ys): Let Xs=[X0,...,Xn] and Ys=[Y0,...,Yn]. Then the following are true:

     Xs in 0..n,
     Ys in 0..n,
     for each i,j in 0..n, Xi#=j #<=> Yj#=i
  

  The variables in Ys are called dual variables.

• fd_element(I,L,V):
• element(I,L,V): Succeeds if the Ith element of L is V, where I must be an integer or an integer domain variable, V a term, and L a list of terms.

• fd_atmost(N,L,V):
• atmost(N,L,V): Succeeds if there are at most N elements in L that are equal to V, where N must be an integer or an integer domain variable, V a term, and L a list of terms.

• fd_atleast(N,L,V):
• atleast(N,L,V): Succeeds if there are at least N elements in L that are equal to V, where N must be an integer or an integer domain variable, V a term, and L a list of terms.

• fd_exactly(N,L,V):
• exactly(N,L,V): Succeeds if there are exactly N elements in L that are equal to V, where N must be an integer or an integer domain variable, V a term, and L a list of terms.

• global_cardinality(L,Vals): Let L be a list of integers or domain variables [$X_1$, $\ldots$, $X_d$] and Vals be a list of pairs [$K_1$-$V_1$, $\ldots$, $K_n$-$V_n$] where each key $K_i$ is a unique integer and $V_i$ is a domain variable or an integer. The constraint is true if every element of L is equal to some key and for each pair $K_i$-$V_i$, exactly $V_i$ elements of L are equal to $K_i$. This constraint is a generalization of the fd_exactly constraint.

• cumulative(Starts,Durations,Resources,Limit): This constraint is useful for describing and solving scheduling problems. The arguments Starts, Durations, and Resources are lists of integer domain variables of the same length and Limit is an integer domain variable. Let Starts be [$S_1$, $S_2$, $\ldots$, $S_n$], Durations be [$D_1$, $D_2$, $\ldots$, $D_n$] and Resources be [$R_1$, $R_2$, $\ldots$, $R_n$]. For each job i, $S_i$ represents the start time, $D_i$ the duration, and $R_i$ the units of resources needed. Limit is the units of resources available at any time.

• serialized(Starts,Durations): This constraint describes a set of non-overlapping tasks, where Starts and Durations must be lists of integer domain variables of the same length. Let Os be a list of 1's of the same length as Starts. This constraint is equivalent to cumulative(Starts,Durations,Os,1).

• post_disjunctive_tasks(Disjs): Disjs is a list of terms each in the form disj_tasks($S_1$,$D_1$,$S_2$,$D_2$) where $S_1$ and $S_2$ are two integer domain variables and $D_1$ and $D_2$ are two positive integers. This constraint is equivalent to posting the disjunctive constraint $S_1$+$D_1$ #=< $S_2$ #\/ $S_2$+$D_2$ #=< $S_1$ for each term disj_tasks($S_1$,$D_1$,$S_2$,$D_2$) in Disjs, but it may be more efficient since it converts the disjunctive tasks into global constraints.

• diffn(L): This constraint ensures that no two rectangles in L overlap with each other. A rectangle in an n-dimensional space is represented by a list of $2\times n$ elements [$X_1$, $X_2$, $\ldots$, $X_n$, $S_1$, $S_2$, $\ldots$, $S_n$] where $X_i$ is the starting coordinate of the edge in the ith dimension and $S_i$ is the size of the edge.

• count(Val,List,RelOp,N): Let Count be the number of elements in List that are equal to Val. Then the constraint is equivalent to Count RelOp N. RelOp can be any arithmetic constraint symbol.

• circuit(L): Let L be a list of variables [ $X_1,X_2,\ldots,X_n$] where each $X_i$ has the domain 1..n. A valuation $X_1=v_1$, $X_2=v_2$, $\ldots$, $X_n=v_n$ satisfies the constraint if 1->$v_1$, 2->$v_2$, ..., n->$v_n$ forms a Hamilton cycle. To be more specific, each variable has a different value and no sub-cycles can be formed. For example, for the constraint circuit([X1,X2,X3,X4]), [3,4,2,1] is a solution, but [2,1,4,3] is not because it contains sub-cycles.

• path_from_to(From,To,L): Let L be a list of domain variables [$V_1$, $V_2$, $\ldots$, $V_n$] representing a directed graph, this constraint ensures that there always is a path from From to To. For each domain variable $V_i$, let $v_i$ be a value in the domain of $V_i$. It is assumed that there is an arc from vertex $i$ to vertex $v_i$ in the directed graph and $v_i$ is in 1..n. It is also assumed that From and To are two integers in 1..n.

• path_from_to(From,To,L,Lab): Let L be a list of terms

  
  		 [node($LabV_1$,$V_1$), $\ldots$, node($LabV_n$,$V_n$)]
  

  where $LabV_i$ is a domain variable representing the label to be assigned to node $i$ and $V_i$ is a domain variable representing the set of neighboring vertices directly reachable from node $i$. This constraint ensures that there exists a path of vertices all labeled with Lab from From to To, and that all the vertices labeled with Lab are reachable from vertex From.

• paths_from_to(Connections,L): This constraint is a generalization of the previous constraint for multiple paths, where Connections gives a list of connections in the form [($Start_1$,$End_1$,$LabC_1$),$\ldots$,($Start_k$,$End_k$,$LabC_k$)] and L gives a directed graph in the form [node($LabV_1$,$V_1$), $\ldots$, node($LabV_n$,$V_n$)]. This constraint ensures that for each connection ($Start_i$,$End_i$,$LabC_i$) there is a path of vertices all labeled with $LabC_i$ from $Start_i$ to $End_i$ in the directed graph such that no two different paths intersect at any vertex and all the vertices labeled with $LabC_i$ can be reached from $Start_i$.