The Verification Venue · pointed at a game taught as pure logic
Every Expert Board That Forces a Guess
On the beginner board, Minesweeper is a game of pure logic, and every introduction teaches exactly that. On the expert board, 16 × 30 with 99 mines, it is not. This page plays every board with a solver that propagates every deducible constraint, then enumerates every consistent mine assignment in each ambiguous component, and measures how often the player is forced to guess, how good the best available guess is, and what three guessing policies do with the same boards.
Play the beginner board below. When the solver behind it runs out of logical moves, the panel lights up with the exact probability that each candidate cell is safe, computed by enumerating every consistent assignment of the remaining mines. Take its advice or ignore it. Behind the game, the same solver, compiled to WebAssembly and spread across your cores, is censusing expert boards.
Loading the solver…
The solver knows two things and no more. First, the two local deductions: a satisfied number makes its remaining hidden neighbours safe, and a number whose hidden-neighbour count equals its remaining need makes them all mines. Second, when local logic stalls, it splits the frontier into connected components and enumerates every consistent assignment of each one, weighted by the ways the remaining mines can sit in the unconstrained cells. A cell that is a mine in every consistent assignment is flagged; a cell that is a mine in none is opened. Only when neither produces anything is the position a forced guess, and the probability of every candidate is then exact, not sampled.
The census · expert boards, 16 × 30, 99 mines, safe centre opening
Boards played
0
target 50,000
Elementary steps (counted)
0
elapsed ·
Boards where logic was forced to guess
·
95% interval ·
Workers in use
·
·
Win rate: logic then random guess
·
policy A
Win rate: logic then best local probability
·
gap over A: ·
Win rate: logic then best global probability
·
what the mine count alone adds over B: ·
Mean forced guesses per board
·
waiting for the checks to clear
How bad was the best available guess, at every forced guess (50 equal bins over 0 to 1)
A forced guess is not one number. The histogram above is the full distribution of the best available survival probability at every forced guess the census met. Policies B and C differ in exactly one fact: C also uses how many mines remain, which shifts weight between the possible mine counts of each component. The gap between their win rates is what that one extra fact is worth, measured on the same boards, and it is a measurement this page computes rather than a figure anyone quoted.
The check · every number recomputed in front of you
Before anything is displayed, the compiled engine and a slow, deliberately obvious JavaScript implementation of the same contract are run over a battery of small instances, right here in your browser. If a single fingerprint disagrees, no result is shown.
| battery row | wasm | reference | match |
|---|---|---|---|
| running… | |||
A check that has never failed is a claim about the code, not evidence about it. Press the button and watch the comparison go red on purpose: the reference is handed a deliberately broken twin, and the battery must notice.
Two boards are planted in the data so the unmodified engine has to find them: one whose only proof runs through the enumeration (it must be won with zero guesses), and one whose endgame is an exact 50/50 pair (it must report exactly one guess at one half).
The full-size number rests on a different decomposition: the whole census is recomputed under a second chunking and the totals must be identical, which holds exactly because each board is a deterministic function of its seed. Invariants are checked on every board, not a sample.
The binary this page runs:
What none of this rules out. Two decompositions agreeing rules out a chunk-boundary error and very little else. The battery proves the two implementations share one understanding of the rules, not that the understanding is the game's. The cross-method brute force reaches only small boards. And every rate here is conditional on the stated generation rule, the safe 3×3 opening around a fixed centre click, mines uniform over the other 471 cells, and a myopic guesser who never plans for information. A different rule set earns different numbers.
The heavier checks, including a byte-identical rebuild of the C source and a brute-force cross-method pass, run offline: node research/every-expert-board-that-forces-a-guess/verify-every-expert-board-that-forces-a-guess.mjs. That verifier recensuses 12,000 expert boards under two chunkings, asserts the planted boards, and carries negative controls on itself. This page cannot rebuild the binary in your browser, so it hashes the bytes it actually fetched instead and refuses to run them if the hash does not match.
The cost, measured rather than boasted
Operations performed (engine's own counter)
·
Wall time
·
Speed factor vs main-thread JavaScript
·
·
Workers
·
·
What's exactly true here, and what's a model
Exactly true. The deduction mathematics: the two local rules are sound, the component enumeration is exhaustive over consistent assignments, the global marginals come from exact generating-polynomial convolutions with the binomial kernel, and the accumulator is exact integer arithmetic. One chunk folds its boards into one fixed 552-byte aggregate record of 69 unsigned 64-bit fields, and the page sums those records exactly. The decomposition check demands bitwise equality. The contradiction counters compare the solver against the board's hidden layout, which the solver never reads, and must be zero.
Idealised. The player is myopic: logic first, then a one-step guessing policy, with no lookahead and no information-value reasoning. The forced-guess flag is a property of the canonical policy-C play; a different play order can dodge or meet a guess on the same board. The win rates are properties of the board and the policy together, which is why they are never averaged.
Conditional, not universal. Every rate depends on the stated generation rule: fixed centre first click, its 3×3 neighbourhood guaranteed clear, mines uniform over the remaining 471 cells, drawn by rejection sampling from a splitmix64 stream (a modulo bias below one part in 10^14, identical in both implementations). Component enumeration is capped at 96 cells, 24 components and 2,097,152 search nodes per cycle; a capped cycle is abandoned and degrades that decision to local probabilities. Cycles abandoned at any cap are counted and printed (the boardsHitBound figure in the invariant line above).