The Verification Venue · pointed at a tournament nobody could run
Sixty-Five Thousand Contestants, One Crown
Every famous account of the iterated prisoner's dilemma is built on a tournament of a dozen or so submitted strategies, and a famous tournament like that exists in the literature. This page is not it, and cites nothing from it. Instead it does what nobody could: it enters every strategy of the same memory class, all 65,536 of them, and plays every pair, 2,147,516,416 matches of 100 rounds at T=5, R=3, P=1, S=0, live, in your browser, across every core you have.
A ranking is a fact about a field. The small tournaments answered a question about who entered. This page answers the question the format was always reaching for: what wins when nobody curates the field? Press the button below the instrument and find out; while the tournament decides itself, you can play matches of your own choosing on the strip above it.
The instrument · two strategies, one hundred rounds, editable
A · Tit-for-Tat
B · Always Defect
Score A
0
CC 0 · split 0 · DD 0
Score B
0
·
Each small button is one history: the last round's outcome over the round before (CC, CD, DC, DD, own move first). Click to flip that response between cooperate and defect. The opening move is the CC-over-CC entry, because the pre-game history is defined as (CC, CC).
The classic format · seven named strategies, round robin, computed live
This is the shape of the traditional result: a handful of named strategies, everyone against everyone. Their tables are derived above from stated rules; the ranking below is computed from those tables right now, not recalled from anywhere.
Keep this little crown in mind. The full field is about to overturn the moral it suggests: whatever wins here wins because of who else was in the room.
The full tournament · 65,536 strategies · 2,147,516,416 matches · 100 rounds
Every match played out, round by round, by a WebAssembly engine compiled from the C committed beside this page, split across a pool of web workers. This takes a few minutes on a typical machine. You can stop it; a stopped run is reported as partial, never as the answer.
idle
Chunks done
0 / 0
Inner-loop iterations (counted)
0
Elapsed
0 ms
Workers
·
The crown
·
This crown belongs to this field, these payoffs (T=5, R=3, P=1, S=0), this horizon (100 rounds), self-play counted once, and no noise. Change any of those and the crown can change heads:
Layer two · the crown is a fact about the field
Re-run the whole tournament restricted to a subfield and watch the crown change heads. Then run replicator dynamics over the same payoff matrix: round-robin score and evolutionary survival are different questions, and the page shows both answers side by side.
Or pick a stated subfield:
About a minute on an 8-core machine. A model: symmetrized payoffs, a stated deterministic perturbation of uniform as the start, capped generations.
Round-robin crown
·
Evolutionary crown
·
The check · run in front of you, or the page refuses to speak
Before any headline appears, both implementations (the compiled engine and a slow, deliberately obvious JavaScript reference written from the same contract) run a battery of small instances right here, and their fingerprints must agree on every row. The rows must then stand in a stated pattern against the forward baseline: the rows that change the semantics (horizon, payoffs, field size, planted or flat field) must each disagree with it, while the reversed-order row and the cycle-method row must each reproduce it exactly, because order is traversal, not semantics, and the cycle method is the same contract computed by a different algorithm. An engine that ignored its parameters fails the first half; a cycle method that drifted from round-by-round play fails the second.
| battery row | engine fingerprint | reference fingerprint | verdict |
|---|
The control: press to break the reference on purpose (it swaps the T and R payoffs) and watch the comparison go red. A check that has never failed is a claim about the code, not evidence about it.
The full-size checks, run automatically after the tournament completes:
The binary this page ran:
The reproducible-build check is offline, not in your browser: a browser has no compiler. node research/sixty-five-thousand-contestants/verify-sixty-five-thousand-contestants.mjs rebuilds engine.c with the pinned clang and asserts the bytes are identical, runs the same battery and control, and re-runs every full-size check above for real.
What none of this rules out: the engine and the reference share the field construction, the record layout and the state-transition rule, so a misreading of the encoding shared by both would pass every check here. Two decompositions agreeing rules out boundary and accumulation errors and very little else. The planted and flat fields are the strongest guard, because their answers are known by arithmetic alone.
The cost · measured, not estimated
Inner-loop iterations (engine's own counter)
·
Wall time
·
Workers
·
vs main-thread JavaScript
·
The speed factor is measured on a slice of the work and extrapolated; the slice fraction is printed beside it, because an extrapolation said quietly is a boast.
What's exactly true here, what's a model, and what the field excludes
Exactly true. The enumeration is complete by construction: a strategy of this class is a 16-bit integer, so the field is every integer from 0 to 65,535. The match count 65,536 × 65,537 / 2 = 2,147,516,416 is arithmetic. A deterministic match in a 16-state space must repeat a state within 17 rounds, so the cycle-scoring method is exact, and the page's cross-method check makes it agree with round-by-round play on every match. The identity grand total = 2R·nCC + (T+S)·nSplit + 2P·nDD, less the self-play correction R·sCC + P·sDD, is a theorem about the three outcome classes, checked against counts accumulated separately from the scores. The correction is forced by the stated convention that self-play is counted once: a self-play round pays one player, not two. In self-play both players run the same table on mirror-image histories, so they always move together, a self-play round is never a split, and the page checks that corollary (sSplit = 0) rather than assuming it.
Idealised. Deterministic strategies only: no noise, no mixed moves, no reputation, no population structure. Self-play counted once. The replicator layer is a model: symmetrized payoffs, a stated deterministic perturbation of uniform as the start, capped at 14 generations, floating-point fitness whose low bits depend on chunk completion order.
Excluded by the memory class. Strategies that need unlimited memory, like the grim trigger, are not in this field no matter how famous they are; neither are strategies that react to longer patterns, or to anything but the last two rounds. Nothing on this page supports any conclusion about human cooperation, or about any tournament anyone ever submitted to.