Chapter 7 · Section 12
The Control and the Verdict
The BPT law
BPT Part 4.10, The Rule's Grammar and a Universe's Own Words. "The Cell Rule has a grammar of its own. Whatever data it fills, it writes the same short words, 01, 10, 101, 1010, the rings of each wave of births as it spreads. Structure in the drive therefore shows the rule at work, not yet a universe saying anything." The test that separates them "runs the rule twice more on a window of the universe's starting field: once as it was, and six to sixteen times with its blocks shuffled at the grain of its own data (rounded to a power of two, so the window splits into whole blocks)". "The rule settles any such window into one of two states, its structure near 0.04 or near 0.35 and never between, so the universe is compared only with the scrambles that settled in its own state; the shuffling runs until at least four have." The scrambles' words are the rule's Core Vocabulary; "a word the scrambles would have written at least three times and never did is the universe's own."
The Speaking Condition is
S_own − S_scr ≥ ε
"A universe speaks when its own arrangement says more than the best of its scrambles that settled like it, by more than message-free fields do." ε = 0.05 is "measured rather than chosen: run on 160 fields that carry no message … the same test gave a median edge of −0.011, positive in 35%, and 0.05 or more in only 5%". Four verdicts follow: speaking, grammar only, unmatched and noise. The game adds two more: silent, and patterned when the control did not run.
The established physics
None: a game method. It is a permutation control in the ordinary statistical sense: keep the parts, destroy the arrangement, and compare.
The game's math
control(step, seed) (language.js:160) runs once per universe, and its result is cached in controlled. The call comes from computeLanguage() (app.js:2265) with the field rule stepField and the genesis seed.
Grain (language.js:163–166). Along every row of the starting window, count the runs of identical (lit, pulser) pairs. Then:
mean run = cells / runs
g = 2^clamp(⌊log₂ max(1, round(mean run))⌋, 0, 4) (g is 1, 2, 4, 8 or 16)
T = ⌊W / g⌋ tiles a side
The comment explains why the grain is a power of two (2026-10-29): "a grain of 9, 10 or 15 left edge rows unscrambled and cut the field's own blocks, which alone made null fields 'speak'".
Scramble. A Fisher–Yates shuffle of the T² tiles of g × g cells, drawn from mulberry32(seed XOR 0xc0ffee).
One run (language.js:174–179). Copy the window, make a fresh 128 × 128 reader, and step the rule for up to 8W = 1,024 pulses, reading each pulse. Stop at the first pause after a drive is taken. If no pause comes, snapshot at 8W. Its summary gives S, its Zipf slope, the words written and the counts.
Like with like (2026-10-29, the author: "yes, go ahead and implement that"). Each run is put in a band: high if S ≥ LISTEN_BAND = 0.12, low otherwise. Then:
own = run(window as it was)
scramble until: at least LISTEN_SCRAMBLES = 6 runs, and either LISTEN_MATCH = 4 runs share own's band
or LISTEN_SCRAMBLES_MAX = 16 runs have been made
same = the scrambles in own's band; best = max S over same (or over all, if none matched)
mean, sd = mean and sample deviation (n − 1) of S over same
core vocabulary = the summed word counts of every scramble
Verdict (language.js:240–250):
silent if fewer than 50 words were written
noise else if not patterned (Part 7.11)
patterned else if the control did not run
unmatched else if fewer than 4 scrambles matched own's band, or own has no S
speaking else if beyond = S_own − S_best ≥ LISTEN_MARGIN = 0.05
grammar only otherwise
z = (S_own − mean) / max(sd, 0.005) printed beside it; decides nothing
Whose word (language.js:232–233). With scale = (words the scrambles wrote) / (words the universe wrote), a word is marked rule if the scrambles wrote it. It is marked own if c · scale ≥ 3, meaning the scrambles should have written it at least three times and never did. Otherwise it is left blank.
Worked cost. A run is up to 1,024 pulses of 16,384 cells, and up to 17 runs are made (own plus 16 scrambles). That is at most 17 · 1,024 · 16,384 ≈ 285 million cell steps, done once, when the language is first asked for.
The method, in plain steps:
once a universe: take the starting window, cut it into tiles of its own grain (a power of two)
run the same rule on it as it was, and on scrambles of its tiles, up to 1,024 pulses each
compare like with like: only scrambles that settle in the same band of structure
verdict: silent (under 50 words) · noise · patterned · unmatched · speaking (beats the best matched scramble) · grammar
The code:
// public/game-v8.4/language.js:160 control()
control(step, seed = 1) {
if (!this.start || this.controlled) return this.controlled || null;
const { lit, pulser, W } = this.start, rand = mulberry32(seed ^ 0xc0ffee);
let runs = 0, cells = 0; for (let r = 0; r < W; r++) { let run = 1; for (let c = 1; c < W; c++) { if (lit[r][c] === lit[r][c - 1] && pulser[r][c] === pulser[r][c - 1]) run++; else { runs++; cells += run; run = 1; } } runs++; cells += run; }
/* the grain as a power of two, so the window splits into whole blocks with no unscrambled margin (2026-10-29: a grain of
9, 10 or 15 left edge rows unscrambled and cut the field's own blocks, which alone made null fields "speak") */
const g = 2 ** Math.max(0, Math.min(4, Math.floor(Math.log2(Math.max(1, Math.round(cells / runs)))))), T = Math.floor(W / g);
const scramble = () => {
const tiles = []; for (let i = 0; i < T; i++) for (let j = 0; j < T; j++) tiles.push([i, j]);
for (let i = tiles.length - 1; i > 0; i--) { const j = Math.floor(rand() * (i + 1)); [tiles[i], tiles[j]] = [tiles[j], tiles[i]]; }
const sL = lit.map(r => r.slice()), sP = pulser.map(r => r.slice());
tiles.forEach(([ti, tj], k) => { const di = Math.floor(k / T), dj = k % T; for (let a = 0; a < g; a++) for (let b = 0; b < g; b++) { sL[di * g + a][dj * g + b] = lit[ti * g + a][tj * g + b]; sP[di * g + a][dj * g + b] = pulser[ti * g + a][tj * g + b]; } });
return [sL, sP];
};
const run = (L0, P0) => {
let l = L0.map(r => r.slice()), p = P0.map(r => r.slice()); const e = L0.map(r => r.map(() => 0)), rd = new LanguageReader({ rows: W, cols: W });
for (let t = 1; t <= 8 * W; t++) { const s = step({ lit: l, pulser: p, exposure: e, rows: W, cols: W }); l = s.lit; p = s.pulser; rd.read(t, l, p, s.born.length, s.folded.length); if (rd.drive && !rd.writing) break; }
if (!rd.drive) rd.snapshot(8 * W, l, p);
const sm = rd.summary({ seed }); return { structure: sm.structure, zipf: sm.zipf, written: sm.written, words: new Set(sm.top.map(e => e[0])), counts: rd.counts };
};
/* scrambles until LISTEN_MATCH of them settle in the universe's own state (LISTEN_BAND), between LISTEN_SCRAMBLES and
LISTEN_SCRAMBLES_MAX; the universe is compared with those alone, like with like */
const band = (v) => (v === null || v === undefined ? null : v >= LISTEN_BAND ? 'high' : 'low');
const own = run(lit, pulser), ownBand = band(own.structure), scrs = [];
const matched = () => scrs.filter(x => x.structure !== null && band(x.structure) === ownBand);
while (scrs.length < LISTEN_SCRAMBLES || (matched().length < LISTEN_MATCH && scrs.length < LISTEN_SCRAMBLES_MAX)) scrs.push(run(...scramble()));
const same = ownBand ? matched() : [], pool = same.length ? same : scrs.filter(x => x.structure !== null);
const best = pool.length ? pool.reduce((a, b) => (b.structure > a.structure ? b : a)) : { structure: null, zipf: null };
const vals = same.map(x => x.structure), n = vals.length;
const mean = n ? vals.reduce((a, v) => a + v, 0) / n : null;
const sd = n > 1 ? Math.sqrt(vals.reduce((a, v) => a + (v - mean) ** 2, 0) / (n - 1)) : null;
const counts = new Map(); let written = 0; for (const x of scrs) { written += x.written; for (const [w, c] of x.counts) counts.set(w, (counts.get(w) || 0) + c); }
this.controlled = { grain: g, window: W, own, ownBand, scrambles: scrs.length, low: scrs.filter(x => band(x.structure) === 'low').length,
scrambled: { structure: best.structure, zipf: best.zipf, written, counts, matched: n, mean, sd, spread: n ? Math.max(...vals) - Math.min(...vals) : null } };
return this.controlled;
}
// public/game-v8.4/language.js:240
const gap = zr && zm ? Math.abs(zr.s - zm.s) : null;
const patterned = (structure !== null && structure >= LISTEN_STRUCTURE) || (gap !== null && gap >= LISTEN_ZIPF_GAP);
const beyond = C && C.own.structure !== null && C.scrambled.structure !== null ? +(C.own.structure - C.scrambled.structure).toFixed(4) : null;
const zBeyond = C && C.own.zipf !== null && C.scrambled.zipf !== null ? +(C.own.zipf - C.scrambled.zipf).toFixed(3) : null;
/* speaking: compared only with the scrambles that settled in its own state, the universe beats the best of them by
LISTEN_MARGIN, the edge 95% of message-free fields do not reach; with fewer than LISTEN_MATCH such scrambles it is
unmatched (no fair comparison); z and the Zipf gap are printed beside it, as support */
const M = C ? C.scrambled : null, matchedOK = M && M.matched >= LISTEN_MATCH && C.own.structure !== null;
const z = matchedOK ? +((C.own.structure - M.mean) / Math.max(M.sd || 0, LISTEN_SD_FLOOR)).toFixed(2) : null;
const speaks = matchedOK && beyond >= LISTEN_MARGIN;
const verdict = this.written < 50 ? 'silent' : !patterned ? 'noise' : !C ? 'patterned' : !matchedOK ? 'unmatched' : speaks ? 'speaking' : 'grammar only';
In the game
The control runs once, at the end of a life, the first time the run summary, the Language Block or the record needs the language. It replays the rule on the starting window up to 17 times, so the run summary may take a moment to open on a large field.
Its result leads the Language Block. Under the title "Level L #N" comes the verdict box, a name and a reason (VERDICT_SHORT app.js:2340): "Speaking: its own arrangement beats the best scramble of the same data that settled like it, by more than 95% of message-free fields do"; "Grammar only: the rule's own patterns, nothing beyond the scrambles that settled like it"; "Unmatched: too few scrambles settled in its state for a fair comparison"; "Patterned: ordered beyond chance; the control did not run"; "Noise: no more order than its own shuffle"; "Silent: too few words written to read". The tile "own vs scrambled" shows "S_own% vs S_scr%" with "best of M like it (of K) · grain g · zσ" beneath, or "the control did not run" (app.js:2355). It is highlighted when the verdict is speaking. The run summary's language chip takes a green hue (150) for speaking and blue (210) otherwise (app.js:2834).
The Vocabulary section marks each word with a pill: "rule", any data writes it, or "own", only this universe (app.js:2367).
The scale model
The control reads one 128 × 128 window at the field's center, at most, and not the whole field. It is a sample of the drawn starting field.
Where the game and the theory differ
- BPT gives four verdicts. The game adds "silent", for fewer than 50 words, and "patterned", for an ordered text whose control did not run.
- The header comment of language.js (language.js:27) names
LISTEN_STRUCTUREas "the margin over the scrambled control that counts as speaking (the verdict)". In the code that role isLISTEN_MARGIN= 0.05;LISTEN_STRUCTURE= 0.02 only decides "patterned", before the control is read. - BPT says the shuffling runs "six to sixteen times … until at least four have" settled like the universe. The game stops at sixteen whether or not four have; with fewer than four the verdict is "unmatched".
Fixed numbers
| Number | Where | What it is | Kind |
|---|---|---|---|
128 (LISTEN_WINDOW) |
language.js:32, 106 | Control window. At most 128 × 128 of the starting field is tested | CAP |
| 0, 4 (clamp of log₂ grain) | language.js:166 | Grain from 1 to 16 cells. A field with coarser texture is still cut at 16 | CAP |
| 2 (power of two) | language.js:166 | Whole blocks, no unscrambled margin (2026-10-29) | METHOD |
| 8 (8W) | language.js:176–177 | Longest control run: 1,024 pulses at W = 128 | CAP |
| 0xc0ffee | language.js:162 | Seed offset of the scrambles | METHOD |
0.12 (LISTEN_BAND) |
language.js:38 | Line between the low and high settling states (measured) | METHOD |
6 (LISTEN_SCRAMBLES) |
language.js:39 | At least six scrambles | BPT |
16 (LISTEN_SCRAMBLES_MAX) |
language.js:40 | At most sixteen: a compute budget that BPT Part 4.10 repeats | CAP |
4 (LISTEN_MATCH) |
language.js:41 | Scrambles in the same state needed | BPT |
0.05 (LISTEN_MARGIN) |
language.js:47 | ε of the Speaking Condition, calibrated (BPT Part 4.10) | BPT |
0.005 (LISTEN_SD_FLOOR) |
language.js:48 | Floor on sd for the printed z | METHOD |
| 50 | language.js:250 | Fewest words for any verdict ("silent") | METHOD |
| 3 (c · scale ≥ 3) | language.js:233 | "At least three times" | BPT |
| 1 (n − 1) | language.js:190 | Sample deviation | METHOD |
Measured
The comments record these as measured or calibrated:
- 2026-10-29, 36 saved 8.3 languages (language.js:33–37). The rule settles a window into structure near 0.35 (0.30–0.71 for inherited fields) or near 0.04 (0.02–0.07), never between. In all 18 fair comparisons the universe beat its best scramble: median +0.036 (about 12%), 18 of 18, p ≈ 4 × 10⁻⁶.
- 2026-10-29, 160 message-free fields (language.js:42–46). These were independent cells, random tiles of 4, 8 and 16, and smooth random fields at four scales. Of the 122 that settled like their scrambles, the median edge was −0.011, 35% were positive, the 95th percentile was +0.050, the 99th +0.062 and the maximum +0.073. Two of the scrambles' own deviations were passed by 20% of these fields, which is why z decides nothing.
- LISTEN_BAND sits "above the low settling state (measured 0.02–0.07), below every other (0.17 and up)" (language.js:38).
- Earlier test versions. The readings quoted in BPT Part 3.16 (a child that "led the best of three scrambles by 18.5 points", a level-13 child that "led its single control by 14 points") were taken with the earlier control of one or three scrambles and no settling-state match, before the like-with-like test of 2026-10-29 above; their margins are not to be read against the six-to-sixteen-scramble matched-state verdicts of this Part.