Constraint satisfaction and propagation

• Constraints are arbitrary relations: "≠", "all different", "this table of allowed tuples", "count of 3s equals $x_3$". No linearity and no convexity.
• Often no objective at all. With one, minimise by adding "objective < best" after each solution and continuing.
• Deciding satisfiability is NP-complete: 3-colouring is a CSP.

	MIP (Part II)	CP (Part IV)
core move	relax, then bound	prune domains
strength from	tight LP relaxations	strong propagators
proves optimality by	dual bound meets incumbent	exhausting the tree
easy for it	weighted sums, flows, covering	alldifferent, scheduling, puzzles
hard for it	big-M disjunctions, permutations	weak bounds on sums

Neither dominates, which is why unit 21's hybrid exists.

• Node: every value satisfies the unary constraints.
• Arc (AC): for each binary constraint on $(x, y)$, every $a \in D_x$ has a support $b \in D_y$.
• Path: every consistent pair extends to any third variable.
• $k$-consistency: every consistent assignment to $k - 1$ variables extends to any $k$-th. Strong $n$-consistency means backtrack-free search.

Higher levels prune more and cost exponentially more: $k$-consistency takes $O(n^k d^k)$ time.

algorithm	time	idea
AC-3 (Mackworth 1977)	$O(e d^3)$	queue of arcs; revise
AC-4 (Mohr & Henderson 1986)	$O(e d^2)$	support counters
AC-2001 (Bessière & Régin)	$O(e d^2)$	AC-3 plus "last support" pointers
path consistency	$O(n^3 d^3)$	rarely used

$x, y, z \in \{1, 2, 3\}$ with $x < y$ and $y < z$. Four arcs, one per direction: $(x,y)$, $(y,x)$, $(y,z)$, $(z,y)$. The queue starts with all four.

#	revise	domain before → after	push
1	$x$ against $y$	$x$: 123 → 12
2	$y$ against $x$	$y$: 123 → 23	$(x,y)$
3	$y$ against $z$	$y$: 23 → 2
4	$z$ against $y$	$z$: 123 → 3	$(y,z)$
5	$x$ against $y$	$x$: 12 → 1	$(y,x)$
6	$y$ against $z$	$y$: 2 → 2
7	$y$ against $x$	$y$: 2 → 2

This constraint graph is a path, a tree, so Freuder's theorem already promised no search would be needed.

On a linear constraint $\sum a_i x_i \le b$, reasoning from bounds costs $O(n)$. Domain consistency on an equality $\sum a_i x_i = b$ is NP-hard: it contains subset sum.

Lab step 3's LinearLe removes every value $a$ of $x_i$ with

$$a_i\, a > b - \sum_{j \ne i} \min_{v \in D_j} a_j v$$

For a single inequality this is exactly domain consistency, since the others' best values are always available. The test checks it against brute-force supports. LinearEq, as two inequalities, is only bounds-like, and the test only asks it to be sound.

The general design question of Part IV: how strong a propagator, for what cost per call?

$x + y = 6$, with $D_x = \{1, 2, 3, 4, 5\}$ and $D_y = \{1, 2, 4, 5\}$: $y$ has a hole at 3.

For the equation, checking every value means solving "is there $y$ with $a + y = 6$?"; with many variables that question is subset sum, hence NP-hard.

A propagator for constraint $C$ is a function $p : D \to D$ with

• contracting: $p(D) \subseteq D$;
• monotone: $D \subseteq D'$ implies $p(D) \subseteq p(D')$;
• sound: it never removes a solution of $C$, and it rejects any fully fixed assignment that violates $C$.

Run all propagators until none changes anything. The result is the greatest common fixpoint, independent of the order (Apt 1999).

Real engines add priorities (cheap propagators first), events (fixed / bounds changed / any change), and idempotence flags (Schulte & Stuckey 2008).

Search needs the domains of the parent node back when a branch fails. Three options (Schulte 1999):

• Trailing: log each change on a trail and undo back to a mark. Cheap when few domains change per node. Used by most CP systems, and by the lab's imperative engine.
• Copying: snapshot the whole store at each node. Simple, and it suits parallel search. Used by Gecode.
• Recomputation: store only the decisions and replay them. It trades time for memory.

Trailing is what in-place mutation costs you: every write must be undoable. Copying is what immutability costs you: every write allocates.

$x, y, z \in \{1,2,3\}$ with $x \ne y$ and $y \ne z$. The trail stores (variable, old domain) before every change.

event	trail after it	domains $x, y, z$
mark $m_0$ = 0	empty	123, 123, 123
decide $x = 1$	$(x, 123)$	1, 123, 123
propagate $x \ne y$	$\dots, (y, 123)$	1, 23, 123
mark $m_1$ = 2
decide $y = 2$	$\dots, (y, 23)$	1, 2, 123
propagate $y \ne z$	$\dots, (z, 123)$	1, 2, 13

Undo pops in reverse order, so $y$ is restored to 23 before being restored to 123. Search needs only the marks: "the branch $y = 2$ failed" is undo(m₁), then try $y \ne 2$.

The CP search loop:

1. Propagate to a fixpoint. If a domain is empty: failure, backtrack.
2. If every variable is fixed: a solution.
3. Choose a variable (first-fail: smallest domain) and a value $a$. Branch $x = a$, then $x \ne a$.

"Fail first": pick the variable most likely to fail, so dead ends are found near the root, where they cut the most.

Lab then, same models in both solvers:

model	nodes	your s	CP-SAT branches	CP-SAT s
queens 11, all 2 680	48 950	7.52	226 330	8.60
queens 60, one	862	1.61	38 681	2.37
sudoku (Inkala), all	3 598	1.30	6 538	0.12
3-colour G(200, 4.4/n), unsat	120 334	26.5	3 106	0.16
3-colour G(300, 4.4/n), unsat	limit	67.7	17 937	0.27

On queens the Python engine keeps pace. On unsatisfiable colouring CP-SAT needs 40× fewer branches, because it learns from each failure (units 20–21).

Reading

Rossi, van Beek & Walsh (eds.), Handbook of CP, ch. 3–4.
Mackworth, Artificial Intelligence 8 (1977).
Freuder, JACM 29 (1982): backtrack-free search.
Schulte & Stuckey, TOPLAS 31 (2008).

Next

18 global constraints: alldifferent by matching, cumulative · 19 search heuristics, restarts, LNS · 20 SAT and CDCL.