Raphaël Anjou's experiments

The shared engines under Raphaël Anjou's experiments. The named experiments are studies that run on these; this is the apparatus they share. The CSP presets and the Verhaard reimplementation are documented in full, alongside the reference engine, the JIT backtracker, a field guide to speed, and the scaling-ladder harness; the constructive engines are not yet published.

The Rust-to-WebAssembly backtracker that runs every live demo and checks every number on this wiki. Not a record machine but a reference engine, ported four times and parity-tested byte-for-byte, built so the claims here can be re-run.

Seven named search experiments that chase score, each a pipeline rather than a single algorithm: it builds a board with one engine, then lifts or finishes it with another. Alongside them, two findings take apart the machinery the pipelines lean on. Each page records its idea, its board, and the questions it left open.

One question, asked carefully: among depth-first backtrackers for Eternity II, what does each fill order, each heuristic, and the break mechanism actually buy? A family of from-scratch backtrackers, each one change apart, run on the same ten corner-pinned variants, single core, sixty seconds.

Give a backtracker five correct pieces for free, in the puzzle's own clue geometry. It turns out not to help, and depending on the fill order it can hurt badly, because a pinned piece is a hard constraint a fixed fill order must satisfy on arrival. A family of fill paths, run on the same hinted boards, single core, measured against no hints at all.

The sibling of the DFS study, for the other way people attack Eternity II: destroy part of a board, rebuild it, keep the change if it helps. One question, asked carefully. What does each decision in that loop buy: which region to destroy, how to rebuild it, when to keep a move, when to restart, and what board to start from?

A study in five experiments of one idea: instead of searching Eternity II from first principles, mine the corpus of strong boards already found for structure and feed it back into a search. A position prior, a learned move-vote, a scarce-demand compass, an anti-pattern miner, and a record decode, ordered from the simplest signal to the subtlest, and the one wall all five reach.

Exact endgame experiments that meet in the middle: enumerate a region from two ends and join on the seam, to find the true best completion with a proof rather than a heuristic's best guess. These measure a small region exactly instead of chasing the whole-board score.

Some Eternity II engines pour their effort into walking the search tree as fast as possible; others spend it on judgement about where to walk. This is the case for the first kind - what raw throughput buys, the three different things people mean by "fast", and why the fastest engine ever built still cannot solve the puzzle.

A safe, portable Rust depth-first backtracker, specialised at runtime by emitting and compiling per-puzzle Rust, taken from 43 to 123 million search-nodes per second on one core. Measured fairly against Peter McGavin's C on the same machine: a tie on hard, deep boards like the real Eternity II, and about 44% of its speed on easy ones. Every rung searches the identical tree; the whole gain is code, not algorithm.

Track per-colour half-edge supply against frontier demand inside a break-budget DFS, and prune whenever the colour deficit or its parity exceeds the breaks that remain. Sound by construction; the savings compound with depth.

A belief-propagation free energy computed over a board's last-row leftover pieces rank-predicts how well that row can still finish. The signal is not a raw-score proxy, survives a change of producer, and dies past one row.

A harness that runs any solver unchanged on planted, fully solvable boards at N = 8, 10, 12, 14, each with a proven ceiling of 2N(N-1), so a method's collapse size is measured before weeks are spent on the real 16×16.