# CSP presets, measured

> One constraint-propagation engine, run under a dozen ordering and propagator presets, on the same ten corner-pinned variants as the leaderboard. A study of what each knob buys, kept off the headline board because the best preset reaches less than half a contender's score.

- Canonical page (with interactive figures/demos): https://eternity2.dev/research/lab/experiments/single-core-benchmark/csp-presets/
- Updated: 2026-07-15
- Topics: backtracking, search-space
- Reproduce: `just experiments single-core-benchmark`
- Source: Runnable engine + committed results + scripts (this experiment's backing directory) — https://github.com/raphael-anjou/eternity2/tree/main/research/experiments/single-core-benchmark

---
The [single-core benchmark](/research/lab/experiments/single-core-benchmark)
leaderboard shows the methods that compete on score. This page shows the rest:
a dozen presets of one constraint-satisfaction engine, plus the naive DFS in its
weaker visit order. They are not a dozen solvers. They are one arc-consistency
core wearing different heads, kept so the exact cost of each classic technique
can be read off a number instead of argued about.

> **[Figure]** CSP presets: mean score over ten corner variants, single core, 60 s — interactive: BenchmarkLeaderboard. Rendered on the canonical page (link above); not shown in this markdown export.

## What each knob buys

The presets vary two things: the order the engine assigns cells, and how hard it
propagates before committing. Holding the puzzle and the budget fixed, the score
gap between two presets is the value of that one knob.

- **Least-constraining-value ordering helps.** `anjou-gacolor_ac3_lcv` reaches a
  mean of 114 against the plain `anjou-gacolor_ac3` at 76: choosing the value
  that rules out the fewest neighbours is worth about 38 points here.
- **Some knobs are inert at this depth.** Three presets (`anjou-gacolor_ac3`,
  `anjou-gacolor_ac3_ns1`, `anjou-verhaard_preferred`) produced byte-identical
  boards on this puzzle. NS-1 and preferred ordering add nothing at 60 seconds:
  the engine never searches deep enough for them to bite.
- **Border-first ordering is the strongest preset.** `anjou-border_first_lcv` and
  `anjou-rare_color_first` top the sweep at about 183, by committing the
  over-constrained frame before the free interior. It is still less than half a
  contender's score.

## Why none of them competes

Every preset is bimodal. On a friendly corner arrangement the arc-consistency
search reaches 340 to 349; on a hostile one it collapses to about 55, pinned in a
bad basin it cannot escape inside 60 seconds. The mean sits low because the bad
corners drag it down, and no ordering knob fixes the basin problem. That is the
real story of this family: propagation makes each node well-pruned but expensive,
so the search is strong where the instance is forgiving and helpless where it is
not. The constructive engines on the leaderboard never enter that trap, which is
why a preset at 183 sits on a different page from the leaderboard's contenders,
which top out at 451.

## The naive DFS is here too, for one reason

Naive depth-first search with every break allowed is not a CSP preset, but its
visit order belongs to the same lesson. In row-major order
(`anjou-naive_rowmajor`, on the leaderboard as the baseline) it reaches 365; the
same DFS in spiral visit order (`anjou-naive_spiral`) collapses to a mean of 78.
The visit-order choice alone costs the naive search nearly 290 points, the same
kind of ordering sensitivity the CSP presets show, at a larger scale.

## Method and reproducibility

These presets ran in the same grid as the leaderboard: ten official-puzzle
variants, each with three pinned corner cells, single core, 60 seconds, fixed
seed, one run per variant. Every board is re-scored by the one canonical
matched-edge scorer, never the engine's self-report. The engine, the ten
variants, the committed per-run results and the scripts live under the
experiment's
[backing directory](https://github.com/raphael-anjou/eternity2/tree/main/research/experiments/single-core-benchmark),
and `just experiments single-core-benchmark` reruns the whole grid, contenders
and presets together.

## Related

- [Single-core benchmark](https://eternity2.dev/research/lab/experiments/single-core-benchmark) — Fifteen solvers, ours and our implementations of the community's two record backtrackers, each run once on ten corner-pinned variants of the official puzzle, single core, 60 seconds per run. The finding: node count is not score.
- [Arc consistency, from AC-3 up](https://eternity2.dev/research/build/reduce/arc-consistency) — Forward checking looks one move ahead; arc consistency makes every cell's candidate list defend itself against every neighbour's, to a fixed point. Mackworth's AC-3, the optimal refinements that followed, and what the whole family actually measured on this puzzle, including where it is unsound.
- [Fill orders](https://eternity2.dev/research/build/backtracking/fill-order) — The order in which a backtracker visits the 256 cells is its one free choice: it costs nothing at runtime and moves the size of the search tree by orders of magnitude. Twenty years of community science, from the fixed-vs-dynamic wars and the strategy races to the magic 10×16 square and Verhaard's comb search, all answer the same question: which path through the board is cheapest?