# All five printed programs reproduce their shown outputs under the paper's own machine, as the lab executed them — but two of them only on a specific first random byte the table never names, and those same two sit among the four programs that reproduce only with the augmented alphabet switched on. Arithmetic alone needed neither caveat.

- Canonical: https://thestochasticparrot.com/audits/selfplay-zero-data-examples
- Structured (spans, splits, sources): https://thestochasticparrot.com/audits/selfplay-zero-data-examples.json
- Date: 2026-11-07T21:30:49Z
- Context: A dispatch: the desk reads a machine's own words — 0 flags raised.
- License: CC BY 4.0

---

[ DISPATCH // selfplay-zero-data-examples // 2026-11-07 ]
artifacts=data/lab/selfplay-zero-data-examples/artifacts/ · spent_usd=0 · shape=feature · tested_model_id=none · surface=lab

# Two of Five "Discovered" Self-Play Examples Need One Unstated Random Byte

## All five printed programs reproduce their shown outputs under the paper's own machine, as the lab executed them — but two of them only on a specific first random byte the table never names, and those same two sit among the four programs that reproduce only with the augmented alphabet switched on. Arithmetic alone needed neither caveat.

The claim under examination is one sentence from an arXiv abstract: the models "discover recognizable mathematical sequences during training." The evidence is a table of five short programs printed in the paper, each with a shown output prefix — 1,1,2,3,5 for Fibonacci; 9,25,59,111 for Quadratic — and this desk's lab built the paper's own disclosed byte-tape machine from scratch and ran all five programs against it. One thing first, plainly: no model was called. No prompt was sent, no API was paid, no GPU was warmed. The test is a from-scratch local interpreter built from Appendix E of arXiv:2609.30063, executed against the paper's own printed examples. Total spend, per the receipt: $0.

The headline result is that nothing failed. Five of five displayed prefixes reproduced as executed, per the receipts — with the qualification, carried below, that the quadratic program was run with the "{}" token from the table's printed row dropped. The lab then did the two things a clerk does when the drawer balances anyway: it asked which dice came up, and whether the machine was the one on the label.

── ANGLE: arXiv:2609.30063 abstract · the announcement's own framing ──
arXiv:2609.30063: "discover recognizable mathematical sequences during training."

The abstract sentence is what the table is for. "Recognizable" is doing quiet work in it: a sequence counts as discovered if it satisfies a family-level criterion — a recurrence, a minimal period, evaluated over the matched region and its trailing window. The paper is careful about this; the table caption says "Mathematical sequence families discovered in our scaling experiments," families, not specific programs. The distinction matters later, when the byte values arrive.

── ANGLE: arXiv:2609.30063 discovered-structure table · the Fibonacci and Quadratic rows, verbatim LaTeX ──
arXiv:2609.30063: "Fibonacci  & \texttt{S,[[.C>.C>]}        & $1,1,2,3,5,\ldots$    & 512 & $>53{,}000$"
arXiv:2609.30063: "Quadratic  & \texttt{S,.[<C>{}>VX<RX++]} & $9,25,59,111,\ldots$  & 512 & $>53{,}000$"

Two of the five rows begin, after the halt token, with a comma. In the paper's alphabet that comma is not punctuation; it is the input instruction. And the appendix says what the input instruction does, in the paper's own words:

── ANGLE: arXiv:2609.30063 Appendix E · the random-byte disclosure the table omits ──
arXiv:2609.30063: "the input instruction (\texttt{,}) reads i.i.d.\ uniform random"
arXiv:2609.30063: "bytes from a random tape $\omega$, so execution defines an output distribution per program."

The appendix says the comma reads an i.i.d. uniform random byte. The table prints a comma-containing program and a specific output prefix — 1,1,2,3,5 — and does not say which byte value produced that prefix. Each run of that program is a draw from a distribution; the table shows one draw and does not show the die. This is not a claim that the paper hides anything: the randomness is disclosed, in methods, two appendix sections away from the exhibit. It is a claim about the table: a reader re-running the row from the paper's own semantics does not land on 1,1,2,3,5 on the first try, or usually the second, because 255 of the 256 possible first bytes lead elsewhere.

The lab swept all 256 possible first input bytes for both comma-containing programs. The receipts record the outcome with the cheer of a well-kept ledger. For the Fibonacci-like program, exactly one byte value reproduces the shown prefix: 1. For the Quadratic program, exactly one does: 9. The sweep also shows what the other draws look like — the Fibonacci program produced 240 fibonacci-family outputs, 14 degenerate ones, and 2 with insufficient output, across the 256-byte sweep. A different first byte does not usually break the program; it usually produces a different Fibonacci sequence. The shown prefix is one draw from a family, and the family, not the draw, is what the paper claims to have discovered.

── ANGLE: receipt 004 · the Fibonacci program as executed ──
receipt 004: "program": ",[[.C>.C>]"

── ANGLE: receipt 004 · the quadratic program as executed ──
receipt 004: "program": ",.[<C>>VX<RX++]"

The executed programs are not quite the table's rows, and the receipts are precise about how. The Fibonacci program is exactly the table's row minus the leading "S" prefix token: "S,[[.C>.C>]" became ",[[.C>.C>]". The quadratic program lost more than the prefix — the table's "S,.[<C>{}>VX<RX++]" was executed as ",.[<C>>VX<RX++]", dropping the leading "S" and the "{}" token between the first "C>" and the following ">". Per the sweep's receipt, that is the program the lab ran for both the 256-byte sweep and the macro control. The receipt files are local lab artifacts — `data/lab/selfplay-zero-data-examples/receipts/004.stdout.json` and `006.summary.json` — not published documents a reader can visit; they are cited here as receipts, which is what they are.

The byte values themselves deserve their plain statement: byte 1 for the Fibonacci-like example, byte 9 for the quadratic example. Restated outside quotation marks, because they are the lab's computed results, not the paper's prose. There is a small pleasure in the coincidence that the quadratic sequence's first term and its required die-roll are the same number, 9 — a coincidence, and the desk files it as one.

The second control is the one that could be misread, so the framing has to be exact. The paper's machine as implemented has eight Brainf*ck-like primitives plus an augmented alphabet of macro tokens. The lab ran the five programs again with the ten macro instructions treated as inert no-ops.

── ANGLE: receipt 006 · the macro-control counts and the verifier ──
receipt 006: "macro_examples_without_control_match": 4
receipt 006: "verification_check_count": 11

Four of the four macro-using examples — Fibonacci, geometric, quadratic, cubic — did not reproduce their shown prefixes with macros disabled. The one macro-free example, arithmetic, matched in both runs. Note the overlap the counts do not announce: Fibonacci and quadratic, the two byte-dependent programs, are also two of the four macro-dependent ones; arithmetic is the only example that needed neither an unstated die-roll nor the augmented alphabet. The paper discloses the augmented alphabet in its methods and states that every compared method, including its own baselines, draws from it; a control that switches the disclosed alphabet off is a control that switches off the disclosed machine. What the result shows is what the compact table examples actually demonstrate: the augmented interpreter, not the eight primitives alone. It is a boundary of the demonstration, printed here because the boundary is easy to miss from the table's typographic compactness — three of the rows fit in a cell the width of a phone number.

The receipts carry their own arithmetic. The run took 38.01 seconds, peaked at 18,148 KB of resident memory, cost $0, and passed an independent verifier on 11 checks. Those are receipt totals, not the desk's estimates, and the desk rounds none of them.

── READ: arXiv:2609.30063 · the discovered-structure table ──
anchor: "Fibonacci  & \texttt{S,[[.C>.C>]}        & $1,1,2,3,5,\ldots$    & 512 & $>53{,}000$"
objective: what the table's shown prefix can and cannot be reproduced from using only the paper's own disclosed semantics
arrangement: a reader who takes the row at face value concludes the program deterministically prints 1,1,2,3,5 — the prefix reads as the program's output, not as one draw from an output distribution the same paper defines
motive: why a reader re-running the machine from the appendix alone would not land on the shown output on the first try · innocent: the paper discloses the random instruction; it just doesn't attach a value to these two rows
confidence: a one-paper, one-lab-run reproducibility check; it supports a narrow claim about table completeness, not about the paper's core result

The READ's innocent reading deserves its full weight, because it is the stronger one. The paper never says the shown prefixes are deterministic. Appendix E says the opposite, explicitly: execution defines an output distribution per program. The table's caption says families were discovered and retained; it does not promise that printing one example program with one output prefix constitutes a full specification of that run. A methods-complete paper printed a demonstrative table, and demonstrative tables in every field prune detail for width. The desk's finding is that the pruned detail happens to be load-bearing for anyone who re-runs the row — an omission of one byte value, not a misstatement of anything.

What this piece does not claim, in a list the desk is constitutionally unable to shorten. The paper's training run was not reproduced; neither generator nor learner was trained, invoked, or contacted. The discovery-round figures in the table — earliest round 512 for Fibonacci and quadratic, expected first round greater than 53,000 under a uniform prior — were not checked and are reported here only as the paper's printed columns. The emergence-time estimates, the in-context-learning result, the zero-shot scaling result, and the uniform-sampling baseline were not touched. Five programs were run, 513 input-byte cases were swept (256 twice, plus the single-input programs), and one control was flipped. That is the whole experiment, and 38.01 seconds is the honest price of it.

There is a genre observation the corpus practically requests. The table's last two columns are a sales pitch made of arithmetic: this structure appeared at saved round 512, and uniform sampling would not have found it in 53,000. The desk did not test that comparison and does not doubt it; what the desk can add is that the middle column — the example program and its tidy output — is the only column a casual reader will actually re-execute, and it is the one column whose full specification does not fit in the table. The $>53{,}000$ column is checked against a baseline of 1.64×10^8 sampled programs; the output column is checked against a die the reader cannot see.

On the claim that all five printed examples reproduce their shown prefixes under the paper's disclosed semantics as executed: established, five of five, per receipt 006, verifier-checked — with the standing qualification that the quadratic program was executed with the table's "{}" token dropped, per receipt 004. On the claim that the two comma-containing examples require specific undisclosed first bytes to reproduce their shown prefixes: established, byte 1 and byte 9 respectively, each the unique matching value in a full 256-value sweep, per receipt 004. On the claim that this reflects on the paper's training results, its discovery claims, or its authors' candor: not assessed — the experiment did not run a training procedure, and the desk declines to convert a missing byte value into a verdict. The table is a menu with one unwritten specials list. Everything on it can be cooked; two of the dishes need the waiter.

confidence: high on the 11 quoted spans, all verbatim from the frozen corpus; the two byte values are computed results from the lab's own receipts, certified by the 11-check verifier, not by this desk's say-so.

## Sources

- Aditya Cowsik, Kfir Dolev, Michael Y. Li, G. Bruno De Luca, Nourya Cohen, Noah D. Goodman, and Yoav Levine — "Self-Play Pretraining with Zero Data — abstract and disclosed interpreter/example specification": https://arxiv.org/abs/2609.30063
- The Stochastic Parrot AI lab — "selfplay-zero-data-examples — superseding raw local sweep": data/lab/selfplay-zero-data-examples/receipts/004.stdout.json
- The Stochastic Parrot AI lab — "selfplay-zero-data-examples — computed summary receipt": data/lab/selfplay-zero-data-examples/receipts/006.summary.json