The Verification Venue · a theorem about crowds, computed while you drag

Twelve Heads, Until They Talk

Folk wisdom says many heads are wiser than one. Condorcet turned that into arithmetic in 1785: if each juror reads the evidence correctly more than half the time, and judges independently, a majority grows more reliable with every seat. The climb is exact, and it is not free: it stands on independence, and this page lets you pull that beam out and watch the guarantee fall.

One slider below sets how often a single juror gets it right. Another sets the jury size, in odd numbers so a tie is impossible. The curve is not a sketch of the theorem; it is the theorem, summed exactly in integer arithmetic while you move. Then flip the decision rule to unanimity and watch two different mistakes, convicting the innocent and acquitting the guilty, swing apart. After that, take the hammer to independence itself.

Decision rule, priced at the current jury size

Both rules are priced on the same defendant, a guilty one. The innocent-side numbers sit in the table inside the instrument. ↓

odd jury size n →P(convict | guilty) →

P(group convicts | defendant guilty)

The two mistakes, both rules, at this n

mistake	majority	unanimity
convicts the innocent	·	·
acquits the guilty	·	·

One juror's accuracy, p: 0.62

Drag to the floor: jurors only barely better than a coin. Majority keeps climbing anyway. Unanimity does not survive.

Jury size, n (odd): 13

Odd steps only, so a tie can never happen. The readout prints the exact fraction at every stop.

The quantity doing the work is the binomial tail: the chance that at least m = (n+1)/2 of n independent jurors are right. Nothing on this page is sampled; every coefficient is an exact integer and every probability an exact fraction, truncated to six places only when printed. One structural fact before you drag: at p = 0.5 the sum is exactly one half for every odd n, because a fair coin is a fair coin no matter how many times you toss it. The check panel verifies that identity live, along with the climb itself.

Under majority rule, dragging n upward pulls both mistakes down at once: convicting an innocent and acquitting a guilty defendant are both tails of a coin better than fair, so both shrink. Unanimity is a different bargain. It demands every head be right at once, so the chance of ever convicting a guilty defendant is pⁿ, which collapses toward zero with every seat you add, while the guilty walk free. Switch the rule and watch the priced column move; the arithmetic underneath does not.

odd jury size n →dots: simulated · bar: ±1 s.e.

Simulated P(majority correct) at n = 13

First monotonicity breach (larger jury, worse)

Conformity, c: 0.30

At zero the dots sit on the exact curve. Push high and look for a dot below an earlier one: a bigger jury doing worse.

Simulation

Same model, new random stream. The seed is printed in the check panel so any run can be reproduced.

Rule, stated exactly: juror 1 votes their private signal. For juror j > 1: if the earlier votes are split evenly, vote the signal; otherwise, with probability c join the current leader, with probability 1−c vote the signal. Signals are independent, each correct with probability p. Every trial conditions on a guilty defendant; by symmetry that prices one error axis, and the theorem's own quantity, majority correct, is read off the same runs. Estimates are read at odd prefixes only: even jury sizes are not estimated, and the simulation claims nothing about them. This is a reflex, not Bayesian updating, and not a model of discussion.

Independence is the load-bearing beam. Real groups talk, and talking correlates votes. The dial above hands each juror a conformity coin: seeing a lead, a juror abandons private judgement and joins it with probability c. Drag c upward. The simulated dots peel off the exact curve, and past a point you can find something the theorem's independence assumption forbids: a larger jury deciding worse than a smaller one, because the extra heads stop carrying new signals and start carrying copies of the first mistake. The economics literature formalised a stricter, Bayesian version of this as an informational cascade; this page ships the crudest possible version so the mechanism is bare.

This page is not about voting theory proper. Strata that aggregate preferences ask how to combine rankings of many options without paradox; that is Arrow's territory. Here each juror emits one binary judgement, there are no rankings to cycle, and the questions are narrower: how fast accuracy grows with body size, and what correlation among judgements does to that growth. If you came for ranked ballots, this page sits upstream of them.

And keep the courtroom out of this. Real jurors are not identically calibrated, they influence each other in ways richer than one conformity coin, and the empirical record on jury size is far messier than any curve here: the classic observational and archival studies found verdicts surprisingly insensitive to size, for reasons that live in deliberation dynamics rather than signal summation. Nothing on this page argues for twelve heads, or six, or one. The theorem is a statement about a model; the model is a lens, not a recommendation.

The check · every number recomputed in front of you

The grid is the theorem's anchor. Each cell is P(majority correct) for that p and n, computed twice inside this page by two methods that share no code: a direct binomial sum, and a dynamic-programming convolution over individual jurors that never forms a binomial coefficient. The tick prints only when the two agree as exact rationals, not approximately. Decimals are truncated, never rounded.

What is exact: every majority and unanimity figure, in BigInt rational arithmetic, with the two methods required to agree cell by cell. What is modelled: the cascade, a seeded simulation whose sampling error is printed beside it. Run the standalone verifier yourself: node research/twelve-heads-until-they-talk/verify-twelve-heads-until-they-talk.mjs.

What's idealised here, and what's exactly true

Exactly true. Every tail on this page is an exact rational: binomial coefficients are exact integers, products and sums are exact, and reduction is by integer gcd. The two computational methods agreeing cell by cell is an identity check, not a numerical coincidence. The p = 0.5 symmetry, the complement identity tail(p) + tail(1−p) = 1, and the strict-climb monotonicity check over odd n from 1 to 51 are recomputed live each time you move p.

Idealised. Every juror shares one accuracy p. Signals are independent until you corrupt them with the conformity dial. Accuracy is symmetric between guilty and innocent defendants, and no base rates enter: every probability here is conditional on the defendant's true state, which is why the two error rows never add to anything. The cascade rule is a fixed reflex with a single coin, not Bayesian updating, not a model of discussion, persuasion, or straw polls. All cascade figures carry Monte Carlo sampling error, printed beside them; at c = 0 and c = 1 the simulator returns closed forms with zero error. Cascade estimates exist at odd jury sizes only.

Representative, not universal. Real jury accuracies scatter and correlate. The empirical literature around jury size reports small and inconsistent differences between six and twelve, which is itself evidence that the theorem's assumptions are doing the work. What survives transport to reality is the shape of the trade: rules that demand more agreement convict less and acquit more. The magnitudes belong to the model.