# Constraint Increasing

The constraint Increasing ensures that the values assigned to the variables of a specified list are in increasing order.

Below, we give several illustrations corresponding to representative use cases of the constraint Increasing.

## Case 1: Increasing on Variables

We consider the case where we have just a list of variables. If $r$ is the size of a list $x$ of variables, we have:

$x[i] \leq x[i+1], \forall i \in 0..r-1$

To see how this constraint works, we need first to import the library PyCSP$^3$:

from pycsp3 import *


For our illustration, we introduce an array $x$ of 4 variables, each variable having {0,1,2,3} as domain.

x = VarArray(size=4, dom=range(4))


We can display (the structure of) the array as well as the domain of the first variable.

print("Array of variable x: ", x)
print("Domain of any variable: ", x[0].dom)

Array of variable x:  [x[0], x[1], x[2], x[3]]
Domain of any variable:  0..3


We simply post a single constraint Increasing on $x$ imposing that assigned values must be in increasing order.

satisfy(
Increasing(x)
);


By calling the function solve(), we can check that the problem (actually, the single constraint) is satisfiable (SAT). We can also print the values assigned to the variables in the found solution; we can call the function values() that collects the values assigned to a specified list of variables.

if solve() is SAT:
print("Values of x: ", values(x))

Values of x:  [0, 0, 0, 0]


We can enumerate the 8 first solutions as follows:

if solve(sols=8) is SAT:
for i in range(n_solutions()):
print(f"Solution {i+1}: {values(x, sol=i)}")

Solution 1: [0, 0, 0, 0]
Solution 2: [0, 0, 0, 1]
Solution 3: [0, 0, 0, 2]
Solution 4: [0, 0, 0, 3]
Solution 5: [0, 0, 1, 3]
Solution 6: [0, 0, 2, 3]
Solution 7: [0, 0, 3, 3]
Solution 8: [0, 0, 1, 1]


### Strict Increasing

We now see how to impose a strict ordering.

To start, we remove the last posted constraint by calling the function unpost().

unpost()


We control that there are no more constraints.

print(posted())

[]


We post a single constraint Increasing with a strict ordering imposed on $x$.

satisfy(
Increasing(x, strict=True)
);


We call the solver.

if solve() is SAT:
print("Values of x: ", values(x))

Values of x:  [0, 1, 2, 3]


## Case 2: Increasing with Lengths

Now, we consider the case where some lengths (durations) are associated with the variables of the list (except for the last one). If $r$ is the size of a list $x$ of variables, and $d$ a list of $r-1$ integers, we have:

$x[i] + d[i] \leq x[i+1], \forall i \in 0..r-1$

To start, we remove the last posted constraint by calling the function unpost().

unpost()


We post a single constraint Increasing with some arbitrary lengths associated with the three first variables

satisfy(
Increasing(x, lengths=[1,0,1])
);


We call the solver.

if solve() is SAT:
print("Values of x: ", values(x))

Values of x:  [0, 1, 1, 2]


We can enumerate all solutions:

if solve(sols=ALL) is SAT:
for i in range(n_solutions()):
print(f"Solution {i+1}: {values(x, sol=i)}")

Solution 1: [0, 1, 1, 2]
Solution 2: [0, 1, 1, 3]
Solution 3: [0, 1, 2, 3]
Solution 4: [0, 2, 2, 3]
Solution 5: [1, 2, 2, 3]