Two pre-registered tests of the minimal-system programme in Levin (2026)

Draft 2026-09-30. We sent it to Michael Levin on 2026-10-30 for corrections and are waiting for his reply. His corrections, and any reply he agrees to have quoted, go in before it is submitted anywhere. Experiment 0.1c (section 3.7) was added the same evening. Every number comes from the scripts in this folder, and section 6 lists the commands.

Abstract

Levin (2026) argues that minimal, fully specified systems show competencies that were not paid for by design, selection or training. He offers bubble sort as the clearest case and proposes to quantify such competencies as the delta between effort put in and competency out. We tested both parts.

We replicated the sorting result of Zhang, Goldstein and Levin (2024) with the authors' published code for the cell rules and their own scoring formula, and reproduced their reported numbers within 10%. Scored on total inversions, which is the quantity each swap reduces, the "delayed gratification" is zero for every bubble and insertion variant at every barrier count. The barrier dependence the paper reports comes from the formula's normalisation. For bubble sort the formula's value changes by 78% when the order in which cells take turns is changed, and the original code left that order to the Python thread scheduler. Clustering by "algotype" in chimeric arrays reappears when all cells run the same rule and half of them are given a slower clock. The authors' own simulation code, run unmodified, gives the same picture. Their formula returns 0.196 for bubble sort with no barriers, and the median does not move as barriers are added. The reported rise comes from a few runs in a hundred in which the formula divides by a one-step dip. Delayed gratification on total inversions is zero in all 490 runs.

We also calibrated the effort/competency delta on eight systems whose accounting is known, using four rules. Under none of them do a hand-designed program and a trained network sit on one scale. For designed systems the residual equals task compressibility minus code length. The unpriced term is the programmer, and no rule can price it without circularity. For trained systems the residual equals behaviour bits minus training-signal bits, which is sample efficiency. The proposed delta is two quantities under one name, and Levin's minimal systems fall under the first, which cannot be measured.

1. Claims under test

From Levin (2026), sections 5.5, 6.3 and 7.3:

• C1. Sorting algorithms rewritten as per-cell agents "temporarily de-sort the array in order to move things around the defective point", a capacity "not explicitly anywhere in the algorithm" that "cannot be done by a system that just follows a gradient".
• C2. Chimeric arrays of two algotypes cluster by algotype although "the algorithm does not have any code in it to make decisions based on algotype".
• C3. In minimal systems "it may be possible to quantify the effort put in and the competencies that emerge; the delta between them directly sheds light on what and how much can be obtained from the Platonic space".

Experiments 0.1, 0.1b and 0.1c test C1 and C2. Experiment 0.3 tests C3.

2. Pre-registration and provenance

We wrote the predictions for 0.1 (P1 to P5), the design and predictions for 0.1b, and the rules, pass criterion and expected failure pattern for 0.3 into plan.md before the corresponding code, in the same working session. The repository's first commit (bd5b24d43599) holds the 0.1 plan, script and results together, and the 0.3 material is in 5f6941c3a6f7. So the commit history does not prove the order. The session transcript does. Future runs go on OSF before any code is written (todo-operator.md).

We departed from the pre-registration twice, and both departures are also stated where they arise. P2 was revised before any run, from an aggregate own-rule metric to the total-inversion metric (plan.md). The 0.3 pass criterion was misspecified, and section 4.3 gives both readings of it.

File hashes (sha256, first 16 hex): exp01_sorting.py 9185b4c0b1cec500 (after an optional move-probability parameter was added for 0.1b; the 0.1 code path is unchanged and the 0.1 results were not rerun); exp04_rate_chimera.py e2fa55c88e15b144; exp03_ledger.py 86f93e707836b971; results/exp01-n100/grid.csv 5034e0da1ce4b689; results/exp01-n100/chimera.csv b8f83ee26f3e5350; results/exp04/rate_chimera.csv d1b3ee078ed41701; results/exp03/ledger.csv 3b96d30fba6f2e27. Python 3.11.2, standard library only, fixed seeds.

3. Experiment 0.1: sorting algorithms with controls

3.1 Method

Arrays are permutations of 0..n-1, with n = 64 and n = 100, 100 seeds per condition. We implemented classical bubble, insertion and selection sorts, and the cell-view variant of each from the authors' code (github.com/Zhangtaining/cell_research). The code differs from the paper's prose in three places. A bubble cell checks one randomly chosen side per turn. An insertion cell's "prefix sorted" check skips frozen cells. A selection cell walks a pointer from position 0 and swaps in when it is smaller than the occupant. In the authors' code a frozen cell never initiates a move, though an active cell can swap it. We call this kind "movable" and add the paper's second kind, "immovable", which no swap may touch. The repository has no classical-with-frozen implementation. Ours blocks the initiating element for movable cells and any swap for immovable ones. Runs used zero to three frozen cells.

We added four controls. Two deterministic schedulers, round robin and a seeded random permutation per round, replace Python threads. Three metrics are scored side by side. One is the paper's adjacent-pair sortedness. Another is total inversions (Kendall distance), which each swap of an adjacent out-of-order pair reduces by exactly one. For bubble there is also the fraction of cells whose own rule is satisfied. We report bootstrap intervals over seeds. For chimeras, two label-only controls run one algorithm in all cells with the labels split, and we report the run mean next to the paper's peak statistic, which grows with run length.

Delayed gratification is scored two ways. The authors' formula, found in their analysis/ code and ported verbatim, takes the adjacent-descent count after each swap and drops consecutive duplicates. It then groups the differences into same-sign runs and averages (recovery - dip) / dip over each dip and the recovery that follows it. Our formula sums the gains made while the metric is below its running maximum, so it is zero for any monotone series.

3.2 Results

n = 100, round robin, immovable frozen cells. The "paper" column is Table 2 of Zhang et al.

With the random-permutation scheduler, bubble cell-view scores 0.388, 0.422, 0.467 and 0.499 on the authors' formula for zero to three frozen cells. Classical and cell-view insertion give identical numbers at every setting. When only one cell can move per round, the cell-view rewrite changes nothing. The n = 64 runs show the same pattern (results/exp01-n64/).

Chimeras at n = 100, scored as the mean fraction of cells whose neighbours share their label:

3.3 Predictions

P1 held. It predicted delayed gratification at zero barriers in all six variants under the adjacent-pair metric, and the authors' formula reproduces their numbers within 10%.

P2 predicted that delayed gratification on total inversions is exactly zero for bubble and insertion. It held at every setting, under both schedulers and at both sizes.

P3 predicted that the authors' formula rises with immovable frozen cells. It held, with a slope matching theirs. Under our formula the direction reverses, because frozen cells reduce the number of swaps and so the accumulated gains.

P4 predicted that clustering tracks the efficiency gap between algotypes and vanishes when the gap is closed. It held, through Experiment 0.1b (section 3.6). Bubble and insertion have identical total swap counts, so the efficiency that matters is moves per round.

P5 predicted results invariant to the scheduler. It failed for the authors' formula on bubble, 0.218 against 0.388, a difference larger than the whole frozen-cell effect the paper reports. Insertion is invariant, since only one cell can move at a time.

3.4 The competency reading

These dynamics are non-monotone in adjacent sortedness, and under the authors' formula the non-monotonicity grows with immovable barriers. Clustering in chimeras exceeds the label-only controls. A reader who counts as a competency any regularity an observer can see and the rule does not state can keep both results.

3.5 The deflation

The array never moves backward on the quantity the sort descends. The "delayed gratification" is non-monotonicity in another observable, adjacent sortedness, which none of the variants optimises. It is present in the classical textbook algorithm with no barriers (0.079). Schaeffer, Miranda and Koyejo (2023) described the same artefact for "emergent abilities" in language models, where a metric that does not track what the system optimises produces qualitative behaviour that is not there. The barrier trend comes from the formula. It normalises each dip by its own size, and fewer swaps make each dip smaller. The headline number depends on turn order by 78%, and the original code left turn order to a thread scheduler. Clustering has a mechanical cause, which 0.1b tests.

3.6 Experiment 0.1b: rate-matched chimera

Pre-registered before code. All cells run the bubble rule. A random half carry label B and attempt a move with probability p on each turn, and label A cells always attempt. n = 100, 100 seeds, round robin, statistic as in 3.2.

At p = 1 the chimera equals the label-only control (0.244), as the design requires. The mean rises as p falls, and from p = 0.5 down each value's interval excludes the p = 1 value. The pre-registered set ended at p = 0.1, where the mean (0.294) was still below the bubble+insertion chimera (0.319). We ran two further values afterwards. They reach 0.316 at p = 0.02 and 0.320 at p = 0.01, inside the bubble+insertion interval. At n = 100 insertion moves one cell per round, so its per-cell rate relative to bubble is of that order. Identical cells that differ only in how often they take a turn cluster as much as cells running different algorithms.

3.7 Experiment 0.1c: the authors' code, unmodified

Our reimplementation could have been the source of these results. To rule that out we ran the authors' cell classes from their repository (commit 1fd2bd59, 2024-10-30, vendored unmodified) with their thread-per-cell scheduling, their frozen-cell mechanism and their per-swap snapshots, and copied their delayed-gratification function verbatim. Our driver differs from theirs only in dropping the tkinter and numpy imports. n = 100, with 100 experiments per condition for bubble and 30 for insertion and selection. Their analysis reports the mean. We add the median because a few runs set the mean.

At zero barriers the authors' code agrees with the paper and with our reimplementation (bubble 0.196, 0.24, 0.218; insertion 1.075, 1.10, 1.057). With barriers, its median is flat for bubble and falls for insertion. The means rise because the formula divides each recovery by the dip before it. A few runs per condition contain a one-descent dip followed by a long recovery, which gives a ratio near 80. The series in the paper matches neither the medians nor the means of the published code. Delayed gratification on total inversions is zero in every run.

4. Experiment 0.3: calibrating the delta

4.1 Method

The task is to reach a goal on a ring of 12 cells within 10 steps, with actions {-1, 0, +1} and zero to two barrier cells that cannot be entered. A barrier forces the long way round. There are 6,216 reachable states. A uniform random policy succeeds with probability 0.395, estimated from a seeded sample; the random system's own run in 4.2 is a separate sample and gives 0.384.

There are eight systems. A breadth-first solver runs as a program, and the same solver is also materialised as a lookup table. A greedy controller takes the shorter arc and detours at a barrier, and a copy of it carries a planted bug that ignores barriers. Tabular Q-learning is trained for 100,000 episodes, and the same Q-table is also scored untrained. An untrained random action table stands in for a random-feature reservoir. The last system is the random policy.

Competency C_beh is N_states times the mutual information, in bits, between the system's action and the canonical optimal action over the enumerated states. We also report C_ep = log2(p_success / p_random). Substrate bias B is the C_beh of the untrained instance of the same class.

The effort terms are in bits. E_code is the compressed source of the policy and the helpers it calls. E_params is the compressed canonical parameter encoding, one action byte per state. For the Q system that means the greedy policy it induces, and the 8-bit-quantised value table is reported separately. E_train is episodes times (1 + log2 T) bits of feedback per episode. Each seed costs 32 bits. Compression is the smaller of zlib at level 9 and lzma.

There are four rules. R1, artefact: E = E_code + E_params. R2, procedure: E = E_code + seed + E_train. R3, total: all three terms. R4 is a leave-one-out linear fit of C_beh on R3's effort, and its residual is the deviation from the fit. For R1 to R3 the residual is C_beh - B - E.

The pre-registered pass criterion had two parts. The five systems expected to score zero (table, program, untrained reservoir, trained Q, untrained Q) must have a residual whose absolute value is below 10% of the largest E in the set, and the buggy controller must score below the correct one. We also pre-registered the expected failures. R1 would fail on the program and the reservoir, and R2 on the table, the program and the trained Q. R3 would fail wherever either does, R4 would be uninformative with five points, and the cause would be structural.

4.2 Results

R4 gives +163,893 for the trained Q and values between -5,150 and +5,210 for the rest. The trained Q sets the fit. The buggy controller scores below the correct one under every rule. The 8-bit Q value table costs 113,184 bits, and the greedy policy it induces costs 7,112.

4.3 The pass criterion, two readings

As written, the tolerance is 10% of the largest E. That is the trained Q's 432,193-bit training signal, so the tolerance is 43,219 bits. Under it R1 passes on all five systems, and R2, R3 and R4 fail on the trained Q. Measured against the quantity being compared instead, 10% of the largest C_beh is 887 bits, and no rule passes. We wrote the criterion in the first form and saw the problem only after the run. The tolerance, 43,219 bits, is almost five times the largest competency in the set (8,866 bits), so it absorbs every residual. We give both readings, and the interpretation in 4.4 depends on neither.

4.4 Interpretation

The lookup table pays for every action explicitly, yet its residual under the artefact rule is +4,138. The task has structure, so the table compresses, and its compressed size of 4,104 bits is less than the 8,866 bits of behaviour information it carries. Mutual information counted state by state does not see that information is shared across states. Even here, description bits and behaviour bits are different currencies.

The program solver has a residual of +5,514 under every rule. That number is the compressibility of the task relative to the code that solves it. What would cancel it is the programmer's knowledge of the task, and none of the rules prices that. A rule that set the design cost equal to the behaviour it produces would be circular. Bubble sort, fractal seeds and the other minimal systems in Levin (2026) are all designed systems of this kind.

The trained Q system has a residual of -5,713 under the artefact rule and -430,826 under the procedure rule. Its training signal cost about 75 times the behaviour bits it bought. That ratio is sample efficiency, a coherent quantity with an existing literature.

Both untrained systems come out negative under the artefact rule, because random parameters cost bits and buy nothing. Under the procedure rule they are near zero, because a seed is cheap. Whether random parameters count as effort is a convention. The two rules encode the two answers, and the calibration cannot choose between them.

No accounting in this set puts a designed program and a trained network on one residual scale. For a designed system the residual is task compressibility minus code length, which describes the task and its author. For a trained system it is behaviour bits minus training-signal bits, which describes sample efficiency. The delta proposed in Levin (2026) is two quantities with one name. His own minimal systems fall under the first, and that one has no measurement. Nothing here bears on whether the Platonic space exists.

4.5 The competency reading

A proponent can accept every number and still say that the program solver's positive residual is the free lunch, that its source is the programmer's knowledge, and that pricing the programmer is the next problem. The position is consistent. It does move the claim from the system to its author, whereas the paper set out to study systems "where every component is known" and where "there is nowhere to hide".

5. Limitations

Where the authors' code differs from the paper's prose, Experiment 0.1 follows the code. Their classical-with-frozen implementation is unpublished, and ours is stated in 3.1. Their runs used threads. Ours are deterministic, and 0.1c uses their threads. Their published code does not reproduce the barrier series in their Table 2 under either frozen-cell reading. Which code produced it is a question for the authors.

Experiment 0.3 uses one task family and one definition of competency. Other definitions would change the numbers. The structural finding, that design is unpriced and that description bits and behaviour bits differ, does not depend on the definition, though it has only been shown on one family.

Compressed description length depends on the compressor. We used two and report the smaller.

The pre-registration lives in the repository, and one threshold in it was misspecified. Section 2 and section 4.3 state both facts.

The two largest rate gaps in 0.1b were run after the pre-registered set. They are labelled post hoc wherever they appear.

Nobody outside the group has rerun any of this work.

6. Reproduction

python3 trees/01-a-ledger/exp01_sorting.py --selftest
python3 trees/01-a-ledger/exp01_sorting.py --n 100 --seeds 100 --out results/exp01-n100
python3 trees/01-a-ledger/exp04_rate_chimera.py --n 100 --seeds 100 --out results/exp04
python3 trees/01-a-ledger/exp05_authors_code.py --algo bubble --exps 100 --frozen 0,1,2,3
python3 trees/01-a-ledger/exp03_ledger.py --selftest
python3 trees/01-a-ledger/exp03_ledger.py --out results/exp03

Runtimes on two CPU cores: 0.1 at n = 100 takes about six minutes, 0.1b about four minutes, 0.1c about 75 minutes for all conditions (Python threads), and 0.3 three seconds. Python 3.11 standard library, no dependencies.

7. References

• Levin, M. (2026). Ingressing Minds: Causal, Non-Physical Patterns In-Form Natural, Synthetic, and Hybrid Embodiments. Philosophies 11(5):161.
• Zhang, T., Goldstein, A., Levin, M. (2024). Classical sorting algorithms as a model of morphogenesis. Adaptive Behavior; arXiv 2401.05375; code at github.com/Zhangtaining/cell_research.
• Schaeffer, R., Miranda, B., Koyejo, S. (2023). Are emergent abilities of large language models a mirage? NeurIPS; arXiv 2304.15004.
• Wolpert, D., Macready, W. (1997). No free lunch theorems for optimization. IEEE Trans. Evol. Comput. 1(1):67.
• Chis-Ciure, R., Levin, M. (2025). Cognition all the way down 2.0. Synthese 206:257.

Corrections

2026-10-30: section 4.3 said a term "four times larger than any competency" sets the tolerance. The tolerance is 43,219 bits against a largest competency of 8,866 bits, about 4.9 times; the term it comes from is about 49 times. Section 4.1 now says that 0.395 and 0.384 are two separate samples. The abstract said delayed gratification on total inversions was zero in all 460 runs of the authors' code; the result files hold 490 (4 × 100 bubble, 3 × 30 insertion and selection), and it is zero in all of them.