Tree A: the Ledger. Plan

Status 2026-09-30: closed. Experiments 0.1, 0.1b, 0.1c and 0.3 complete; gate A2 failed; operator closed the tree (direction-questions.md Q8). Write-up in writeup.md. Entry point of the programme; Tree G runs in parallel. Context: ../../research-plan.md section 2 (Tree A) and ../../Review.md section 9.

Goal

Make "competency not paid for by training, design or selection" a number, or show that it cannot be one. The number is the residual

residual = competency_out - competency_predicted(effort_in, substrate_bias)

Every term needs an operational definition that gives the known answer on systems where the answer is known. That calibration is the first deliverable, and every later tree consumes it.

Definitions, v0.1 (revise in log.md, never silently)

• Effort in is measured in bits, as the compressed description length of rule, substrate parameters and training signal together. For a sorting algorithm that is the source of the rule plus the scheduler. For a trained network it is the architecture spec, training data and optimiser state, or FLOPs and tokens reported alongside where that is intractable.
• Substrate bias is the competency a random instance of the same substrate shows with zero training signal, averaged over seeds. Levin's argument omits this term, and it is why random GRNs "already" learn.
• Competency out is the number of bits of task-relevant behaviour under perturbation. Concretely, it is the reduction in entropy of the outcome distribution attributable to the system, on a pre-registered task family, with barriers and noise applied. A system that reaches the goal from every start under every barrier scores maximal. One that reaches it only from unperturbed starts scores the same as a lookup table.
• The residual is the difference above. Its sign and magnitude are both reported with seeds and confidence intervals, and it is never reported as a single number without the accounting rule that produced it.

Accounting rules are versioned. A change of rule after seeing data is logged as such, and the pre-registered rule's result is reported first.

Calibration set (Experiment 0.3)

The residual of each of these five systems is known by construction. We accept the ledger only when it returns these answers.

A rule that gives a positive residual on any of these is wrong.

Experiment 0.1: the sorting paper, properly

Source: Zhang, Goldstein, Levin 2024, Adaptive Behavior (arXiv 2401.05375). Code exp01_sorting.py in this folder, stdlib only, fixed seeds, --selftest flag.

Steps:

1. Implement classical bubble, insertion and selection with step traces.
2. Implement cell-view bubble, insertion and selection per the authors' code (github.com/Zhangtaining/cell_research), which differs from the paper's prose. Bubble checks one random side per turn. Insertion's prefix check skips frozen cells. Selection walks a pointer from position 0 and swaps in when it is smaller than the occupant. The script header has the exact rules.
3. Put scheduling under control. The original used uncontrolled Python threads. Provide two deterministic schedulers, round-robin and a seeded random permutation per round, and report both. An effect that differs between them is a scheduler artefact and does not count as a competency.
4. Frozen cells come in two kinds. A movable-frozen cell never initiates a move; no swap involving an immovable one succeeds. Use 0, 1, 2, 3 frozen per array.
5. Metrics per step, updated incrementally:
   • sortedness: fraction of adjacent pairs in correct order
   • inversions: adjacent inversion count
   • delayed gratification (DG), two versions. Ours sums the sortedness gains made while sortedness is below its running maximum. Theirs is the authors' avg_wandering_range on the adjacent-descent series (found in their analysis/ code, ported verbatim), the mean over dip events of (recovery - dip) / dip. Report both.
   • local objective: fraction of cells whose own rule is satisfied, which is what the cell-view algorithms actually descend.
6. Pre-registered predictions, written before running:
   • P1: DG > 0 with zero frozen cells, in cell-view and classical variants.
   • P2: DG under the total-inversion (Kendall) metric is exactly 0 for every bubble and insertion variant, classical and cell-view, at every frozen-cell count. Each swap of an out-of-order adjacent pair removes exactly one inversion, so "delayed gratification" exists only under the adjacent-pair metric. Selection variants use non-adjacent swaps and may show non-zero Kendall DG. (Revised 2026-09-30 before any run, from the local-objective form. The aggregate own-rule metric stays as a third column for bubble.)
   • P3: DG under sortedness rises monotonically with frozen-cell count, with an effect size small relative to the zero-barrier baseline.
   • P4: algotype clustering in chimeric arrays tracks the efficiency gap between algotypes and vanishes when efficiencies are matched (duplicate-value condition, and a new matched-efficiency condition).
   • P5: results identical across the two schedulers up to seed noise.
7. Arrays: n = 64 and 100, 100 seeds per condition, confidence intervals by bootstrap over seeds.
8. Output: one CSV per condition under results/, one summary table in log.md.
9. Write-up: a short paper with results first, then the strongest competency reading of the data stated fairly, then the deflation. Send it to Levin (see ../../outreach/levin-email-draft.md).

If P2 fails, meaning the cell-view variants go backwards on their own objective, that is the first real signal in the programme. It goes to direction-questions.md as blocking before any write-up.

Experiment 0.1b: rate-matched chimera

Pre-registered 2026-09-30 before code. It tests the mechanical explanation of algotype clustering (P4). Cells whose rule moves them faster per round reach their neighbourhood first, so same-type cells end up transiently adjacent.

Design: n = 100, 100 seeds, round robin. Every cell runs the bubble rule. Half the cells, chosen at random, carry label B and attempt a move only with probability p per turn, p in {1.0, 0.75, 0.5, 0.25, 0.1}. Label A cells always attempt. The statistic is the mean same-label-neighbour fraction over the run (as in 0.1) with a bootstrap CI, plus the measured swaps per round per label.

Predictions:

• P4a: at p = 1 the chimera mean equals the label-only control from 0.1 (0.244 [0.239, 0.248]) within CI. The two labels are dynamically identical by construction, so a difference means a bug.
• P4b: the mean rises monotonically as p falls.
• P4c: some p in the set reaches the bubble+insertion chimera level from 0.1 (0.319 [0.312, 0.327]) or above.

If P4b fails and clustering does not rise with the rate gap, the rate mechanism is wrong. Clustering then remains a real, unexplained effect, and writeup.md section 3.5 is rewritten to say so. If P4b and P4c hold, clustering is a rate effect and the 0.1 deflation is complete.

Experiment 0.2: the fractal prior, with a proper null

Source: Ertle, Levin, Scheutz, IEEE ICDL 2025. The deep-Q agent needs a GPU, so this cannot run on this box (2 cores, 8 GB, 2.6 GB disk free on 2026-09-30, 9 GB on 2026-10-30). Steps:

1. Obtain code or reimplement the maze agent from the paper's description.
2. Test these inputs, each replacing half the observation: Halley fractal (their condition), human art (their condition), spectrum-matched 1/f noise, shuffled fractal (same pixel histogram, no structure), white noise, constant.
3. Pre-registered prediction: any 1/f-structured input matches the fractal. If the fractal beats spectrum-matched noise, that is a Tree A signal and gets its own follow-up.
4. Report exploration coverage and reward curves with seeds and intervals.

Experiment 0.3: calibration and ledger v0.1

Pre-registered 2026-09-30, before code. The kill rule (gate A2, restated) allows four accounting rules and one two-week box. If none passes calibration, Tree A stops, Trees B and F lose their instrument, and the finding is written up.

Task family: goal-reaching on a ring of 12 cells within 10 steps, actions {-1, 0, +1}, 0 to 2 barrier cells that cannot be entered. A barrier forces the long way round, which is the "delayed gratification" shape. The enumerated state space (position, goal, barrier set) has 6,216 states once unreachable goals are removed.

Systems (all stdlib): a BFS solver as a program; the same solver materialised as a lookup table; a correct greedy controller (shorter arc, detours at a barrier); the same controller with a planted bug (ignores barriers); tabular Q-learning trained to convergence; the same Q-table untrained; an untrained random-feature "reservoir" (random action table); and a uniform random policy as the baseline.

Competency comes in two forms. C_ep = log2(p_success / p_random) over episodes. C_beh = N_states x I(system action; optimal action) over the enumerated states, in bits. Substrate bias B is the competency of the untrained instance of the same class.

Effort terms, all in bits: E_code is the compressed source of the policy, E_params the compressed parameters (table, Q-table, random weights), and E_train the training-signal bits (episodes x bits of feedback per episode). Seeds count as 32 bits.

Rules: R1 artefact, E = E_code + E_params; R2 procedure, E = E_code + seed + E_train; R3 total, E = E_code + E_params + E_train; R4 reference curve, a leave-one-out linear fit of C_beh on R3's E with residual = deviation. For R1 to R3, residual = C_beh - B - E.

A rule passes if the five "zero" systems (table, program, untrained reservoir, trained Q, untrained Q) have |residual| below 10% of the largest E in the set, and the buggy controller scores below the correct one. Expectations, written before running: R1 fails on the program (positive, because the task is compressible) and on the reservoir (negative, because random weights cost bits and buy nothing). R2 fails on the table and program (positive, unpriced design) and on trained Q (negative, training-signal cost exceeds behaviour bits). R3 fails wherever R1 or R2 does. R4 with five points is not expected to discriminate. If those expectations hold, the reason is structural. No rule prices design knowledge, and design and training effort are not commensurable. If any rule passes, that is the surprise, and the ledger proceeds.

1. Implement the five calibration systems as small stdlib Python programs.
2. Implement the effort measure as the zlib/lzma compressed size of the canonical description, reporting both compressors.
3. Implement the competency measure on one task family (goal-reaching on a 1-D line with barriers, later a 2-D grid).
4. Run the ledger and iterate the rule until all five calibration answers hold.
5. Freeze v0.1, tag it and record the rule in log.md. Only then run it on the sorting algorithms and the Tree B zoo.

Decision gates

• Gate A1 (after 0.1): if P2 holds and P3 is small, proceed to 0.3 and write up. If P2 fails, stop and escalate.
• Gate A2 (after 0.3): if a rule passes calibration, freeze it and proceed. If no rule passes after three revisions, write the "effort is not a coherent quantity" note and put the tree on hold.
• Gate A3 (after the ledger runs on sorting and the zoo): report residuals. A positive residual that survives metric substitution and the random-substrate null gets adversarial replication before any claim.

Deliverables

• exp01_sorting.py and results (step 1)
• calibration systems and ledger v0.1 (step 3)
• one write-up per experiment, results first
• pre-registration on OSF before each run (the operator creates the OSF account; see todo-operator.md)

What this tree does not do

• It makes no claim about consciousness. The residual is a competency measure.
• It trains no models. Trained-model residuals fall to Tree C and Tree D once the ledger exists.