# TinyChess research log

Status vocabulary, used strictly:

| tag | meaning |
|---|---|
| **IMPLEMENTED** | code exists and runs |
| **TESTED** | covered by an automated correctness test |
| **MEASURED** | a number was produced by an actual run recorded in `runs/` |
| **HYPOTHESISED** | believed, not yet measured |

Nothing in this document is estimated or extrapolated. Every number has a
corresponding `runs/*/metrics.jsonl` or `runs/*.json` artifact.

---

## Phase 0 — environment audit (MEASURED)

Two environments were inspected, and the brief's assumption turned out to be
wrong in an important way.

| | intended research machine | reality |
|---|---|---|
| HF Space `cazyundee/training` | 16 cores, 104 GB, ZeroGPU | **unavailable** |
| sandbox | dev only, 2 vCPU / 2 GB | **the actual research machine** |

Sandbox, measured:

* CPU: Intel Xeon @ 2.60 GHz, **2 logical / 1 physical core** (SMT), KVM guest
* SIMD: AVX-512 (`avx512f/dq/cd/bw/vl/vnni/vbmi2`), `sha_ni`, `vaes`
* RAM: ~2 GB total; disk 25 GB (20 GB free)
* PyTorch 2.14.0+cpu, **CPU capability AVX512**, BLAS = MKL 2024.2,
  MKL-DNN v3.12, ATen parallel backend = OpenMP, `hardware_concurrency=2`

### UPDATE — the Space is now RUNNING (root cause: the 2-Space limit)

The 402 was **not** a billing problem. The account had hit its **limit of 2
Spaces**, so HF refused every hardware request *and* new-Space creation with
`402 Payment Required` — a misleading error. Deleting an unused Space
(`tiny_shakespeare`) freed the slot, after which `request_space_hardware(
'zero-a10g')` succeeded immediately.

A second fix was required: ZeroGPU Spaces must `import spaces` **before** torch
and expose at least one `@spaces.GPU` function, or the scheduler never attaches
hardware. After adding both, the Space reports `stage=RUNNING hw=zero-a10g`.

### The real research machine (MEASURED, far larger than the brief stated)

Audited from inside the running Space:

| | brief said | **actually measured** |
|---|---|---|
| CPU | 16 cores | **192 logical / 96 physical** (2x Xeon Platinum 8559C) |
| RAM | 104 GB | **2,000 GB** |
| disk | — | 1,991 GB free (no persistent `/data`) |
| GPU | ~5 min cap | CUDA available (torch 2.13.0+cu130) |
| BLAS / SIMD | — | MKL, AVX-512, L3 640 MiB |

Python 3.10.13. All 12 correctness gates re-run **on the Space: 12/12 pass**.

### CPU scaling benchmark on the real machine (MEASURED)

`scripts/bench_threads.py`, 64-core budget, self-play throughput:

| processes x threads | moves/s |
|---|---:|
| 1 x 64 | 123.0 |
| 2 x 32 | 240.3 |
| 4 x 16 | 498.5 |
| 8 x 8 | 1,025.1 |
| 16 x 4 | 1,730.7 |
| **32 x 2** | **2,258.0** |
| 64 x 1 | 1,485.8 |

**18x better to run many small processes than one wide one.** The model is far
too small to fill 64 threads — intra-op parallelism is pure overhead, while
process-level parallelism scales nearly linearly to 32 procs. All subsequent
experiments use `--threads 2` and parallelise across arms/seeds.

Throughput vs the old 2-vCPU sandbox: **531 -> 2,258 moves/s (4.3x)**, and the
grid now runs 27 arms *simultaneously* instead of sequentially.

### The Space was previously blocked at the account level

The Space was deployed successfully (code uploads fine, Gradio boots), but it
cannot be scheduled:

```
runtime: stage=RUNTIME_ERROR, hardware=None, requested_hardware='zero-a10g'
request_space_hardware('cpu-upgrade') -> 402 Payment Required
request_space_hardware('cpu-basic')   -> 402 Payment Required
create_repo(<new space>)              -> 402 Payment Required
```

Two Gradio faults were found and fixed along the way (both real bugs):

1. `gradio==4.44` + preinstalled `huggingface_hub>=1.0` →
   `ImportError: cannot import name 'HfFolder'`. Fixed by moving to Gradio 5.
2. Gradio 5 experimental SSR spawns a Node server that crashed the container.
   Fixed with `ssr_mode=False`.

After both fixes the app logs `Running on local URL: http://0.0.0.0:7860`
cleanly and *then* the Space is killed for lack of allocated hardware. The
blocker is billing, not code. **Consequence: all experiments below ran on
2 vCPU.** The code is unchanged for the 16-core case — `--threads` and
`scripts/bench_threads.py` exist for it.

---

## Phase 1 — correctness gate (TESTED)

`python tests/test_phase1.py` — **12/12 pass**. No training was started before
this was green.

| test | result |
|---|---|
| candidate set == `python-chess` legal moves | 120 boards, exact match |
| canonicalisation lossless (mirror ⇒ same legal set) | 200 boards |
| move packing round-trip | 4,551 moves, 0 mismatches |
| policy masking | illegal probability mass **exactly 0.0**; rows sum to 1 |
| sampling never selects a padded slot | 50 rounds |
| value side-to-move invariance | max Δ = **0.00e+00** |
| outcome→z perspective (W win / B win / draw / inversion) | exact |
| parameter budget ≤ 100K | **99,923** |
| depth costs no parameters | +28 steps = +1,792 params (step embedding only) |
| baseline config really disables features | no halt/router/mem/refine tensors |
| termination: mate, stalemate, insufficient, 50-move, threefold | all detected |
| checkpoint/resume | **bit-exact** weights, optimizer and RNG |

### Parameter accounting (MEASURED)

Full architecture, `d_model=64`, `d_ff=128`, `d_move=32`, `n_mem=8`:

| component | params | note |
|---|---:|---|
| `core` | 56,417 | **shared, reused every recurrent step** |
| `encoder` | 24,192 | factorised file×rank square embedding |
| `refine` | 6,336 | GRUCell in move space |
| `move_emb` | 5,696 | compositional (7 field tables) |
| `value` | 3,121 | |
| `readout` | 2,048 | |
| `sq_to_move` | 2,048 | |
| `norm_out` + `move_scale` | 65 | |
| **total** | **99,923** | trainable = persistent = 99,923 |

Baseline config (no memory/router/halting/refine): **79,630**.

The central constraint is satisfied *and* the key property holds: **recurrent
depth is nearly free in parameters**. 1 step vs 24 steps differs by 512
parameters (a step-embedding row), while compute scales linearly:

| steps | params | forward (B=8) |
|---:|---:|---:|
| 1 | 99,219 | 16.4 ms |
| 4 | 99,411 | 47.9 ms |
| 8 | 99,667 | 82.3 ms |
| 16 | 100,179 | 176.3 ms |
| 24 | 100,691 | 238.5 ms |

---

## Phase 2 — self-play environment (TESTED + MEASURED)

`tinychess/selfplay.py`. Games are batched across boards so one NN call serves
many games. Full rule coverage; **0 illegal move attempts** in every run so far.

### Reward sparsity: the first real research problem (MEASURED)

A randomly initialised policy almost never mates, so the outcome signal is
nearly empty:

| max plies | decisive rate | terminations |
|---:|---:|---|
| 120 | 0.06 | 15 ply-cap, 1 mate |
| 300 | 0.06 | 12 ply-cap, 3 stalemate, 1 mate |
| 600 | 0.19 | 9 insufficient material, 3 mate, 3 fifty-move |

At the ply caps affordable on 2 vCPU this is ~0–6% — effectively no gradient.

Two mitigations were implemented and measured (16 games, random net):

| setting | decisive rate |
|---|---:|
| pure outcome, standard start | **0.00** |
| **+ material adjudication at ply cap** | **0.69** |
| endgame curriculum, pure outcome | 0.00 |
| mixed curriculum + adjudication | 0.31 |

**Material adjudication** (verdict to whoever is ≥3 pawns up when the cap is
hit) raises the decisive rate from 0% to 69%. This is honestly labelled:
it **injects the prior "material is valuable"** and is *environment shaping*,
not learned knowledge. It is a flag (`--adjudicate none|material`) so the
shaped-vs-pure comparison is a first-class experiment, not a hidden default.

The endgame curriculum **failed** (0.00 decisive): random kings simply shed the
extra piece and reach insufficient material. Recorded as a negative result;
deprioritised.

---

## Phase 3/4 — baseline + does it learn? (MEASURED, in progress)

`runs/p4_baseline` — baseline config, **79,630 params**, random init, seed 0,
4 recurrent steps, 48 games/iter, 20 grad steps/iter, 2 threads.
Algorithm: REINFORCE + learned value baseline, entropy bonus 0.01.

First 11 iterations (~528 games):

| iter | decisive | mean plies | entropy | value MAE | loss |
|---:|---:|---:|---:|---:|---:|
| 0 | 0.83 | 100.0 | 3.33 | 0.836 | +0.832 |
| 3 | 0.83 | 97.6 | 3.01 | 0.662 | +0.524 |
| 5 | 0.77 | 92.8 | 2.45 | 0.640 | +0.474 |
| 8 | 0.54 | 92.9 | 1.81 | 0.611 | +0.417 |
| 10 | 0.33 | 86.0 | 1.49 | **0.566** | +0.353 |

**Head-to-head vs its own frozen random initialisation** (40 games, colours
balanced, same architecture/seed — only the weights differ):

> **iter 9: score 0.662, +117 Elo**

This is the Phase 4 gate. Learning is real and measurable: the value head is
fitting outcomes (MAE 0.836→0.566) and the policy is sharpening away from
uniform (entropy 3.33→1.49; uniform over ~30 legal moves ≈ 3.4).

Entropy is falling fast, which is the risk to watch — if it collapses the model
stops exploring. The entropy bonus and temperature schedule are the controls.

---

### Run 1 collapsed at iteration ~40 (MEASURED — negative result, retained)

`runs/p4_baseline` (plain REINFORCE) improved strongly and then destroyed
itself. Evaluation vs its own frozen random init, 40 games each:

| iter | score | Elo |
|---:|---:|---:|
| 9 | 0.662 | **+117** |
| 19 | 0.800 | **+241** |
| 29 | 0.875 | **+338** |
| 39 | 0.487 | **−9** |

The failure cascade, read off `metrics.jsonl`:

| iter | entropy | decisive | plies | grad norm | L_pi |
|---:|---:|---:|---:|---:|---:|
| 0 | 3.33 | 0.83 | 100.0 | 1.0 | +0.04 |
| 20 | 1.06 | 0.71 | 92.5 | 5.5 | −1.04 |
| 28 | 0.51 | 0.06 | 52.7 | 30.8 | −3.87 |
| 36 | 0.43 | 0.08 | 53.9 | 84.1 | −29.5 |
| 48 | **0.07** | **0.00** | 24.6 | **108.6** | −26.7 |

Mechanism (diagnosed, not guessed):

1. The entropy bonus was a **fixed** 0.01 — far too weak once the policy sharpened.
2. Entropy → 0.07 makes play deterministic, so both sides repeat moves:
   the final iteration ended **48/48 games by repetition**, i.e. all draws.
3. All-draw batches ⇒ advantage ≈ 0 with tiny spread, but advantage
   normalisation divided by that near-zero std, **amplifying pure noise**.
4. Unclipped REINFORCE then took huge steps: gradient norm 1 → 108.

Three fixes, all implemented and smoke-tested:

* **PPO-style ratio clipping** (`--ppo-clip 0.2`) using the stored behaviour
  log-probs, so one batch cannot move the policy far.
* **Skip advantage normalisation when the spread is degenerate** (std < 1e-3);
  only centre it.
* **Adaptive entropy coefficient**: a feedback controller targeting
  `entropy ≈ 0.45 · log(mean legal moves)` instead of a fixed constant.

MEASURED after the fix (`runs/p4_ppo`, first iterations): gradient norm stays
**1.0–1.3** (was 108), approx-KL ~0.005, entropy held at ~3.3.

This is exactly the "if exploration collapses, diagnose it" case from the
brief — the cause was the RL objective, not model capacity.

### Run 2 with the fixes: stable (MEASURED)

`runs/p4_ppo` — identical budget and seed, only the RL objective changed
(PPO clip 0.2, adaptive entropy target 0.45, safe advantage normalisation).

Score vs its own frozen random init (40 games, colours balanced):

| iter | plain REINFORCE (run 1) | **PPO + entropy control (run 2)** |
|---:|---:|---:|
| 9 | 0.662 (+117 Elo) | **0.850 (+301 Elo)** |
| 19 | 0.800 (+241) | **0.975 (+636)** |
| 29 | 0.875 (+338) | **0.950 (+512)** |
| 39 | **0.487 (−9)** ← collapsed | **0.950 (+512)** |

At iteration 39 run 2 shows entropy 3.11 (vs 0.07), decisive rate 0.75
(vs 0.00), mean game length 99.5 plies (vs 24.6), gradient norm 0.98 (vs 108).

**Conclusion (MEASURED):** the collapse was an artefact of the optimiser, not of
the 79.6K parameter budget. The same architecture reaches ~+500–640 Elo over its
initialisation and stays there. Run 1 is retained as a negative result.

## Performance engineering (MEASURED)

Profiling self-play showed `_local` (structured chess mixing) was **70% of
total compute** — 0.93 s of 1.55 s, far more than attention (0.11 s), because
the sliding-ray op materialised a `[B,64,4,7,d]` tensor (28× memory traffic).

Two rewrites were attempted:

1. **flat `index_select` + einsum** — numerically identical (diff 0.0) but
   **0.77–0.84× i.e. SLOWER** at every batch size. *Negative result, reverted.*
2. **fold the rays into 4 precomputed `[64,64]` mixing matrices** and apply as
   batched matmuls (the decay weight depends on square/axis/slot but not on
   channels, so it folds into the matrix; the per-channel gate applies after):

| batch | gather (ms) | matrix (ms) | speedup |
|---:|---:|---:|---:|
| 16 | 7.10 | 2.87 | **2.48×** |
| 32 | 15.57 | 6.59 | **2.36×** |
| 64 | 33.87 | 18.88 | 1.79× |
| 128 | 70.86 | 30.33 | **2.34×** |

Numerically identical (max diff **0.0**) and `ray_decay` stays differentiable —
both locked in by `test_local_mixing_matches_reference`.

End-to-end self-play throughput: **234 → 531 moves/s** (2.3×) on 2 vCPU.

---

---

## Phase 5 — does persistent memory help? (MEASURED, 2 seeds)

`runs/abl_memory` — arms differ ONLY in `use_memory`. Identical budget:
30 iterations x 32 games, 16 updates/iter, 4 recurrent steps, PPO + entropy
control, seeds 0 and 1. Evaluation: 50 games per match, colours balanced.

| arm | params | vs own random init | vs random-legal | vs material heuristic |
|---|---:|---:|---:|---:|
| baseline | 79,630 | 1.000 / 1.000 | 0.990 / 0.940 | 0.150 / 0.060 |
| **memory (8 slots)** | 92,430 | 0.990 / 0.980 | 0.980 / 0.960 | 0.140 / 0.120 |

**Direct head-to-head, baseline vs memory (score for baseline):**

| seed | score | 95% CI | Elo |
|---|---:|---|---:|
| 0 | 0.320 | [0.21, 0.46] | **−131** |
| 1 | 0.320 | [0.21, 0.46] | **−131** |

> **Memory wins, identically in both seeds: +131 Elo.** The CI excludes 0.5 in
> both cases, so this is a real effect, not seed noise.

Two honest caveats:

1. `vs own random init` is **saturated** (baseline already scores 1.000), so it
   cannot rank the arms — the head-to-head is the informative measurement. This
   is why the ablation harness plays arms against each other directly.
2. Memory costs 12,800 parameters (79.6K → 92.4K). The comparison is therefore
   *not* parameter-matched; part of the gain may be capacity, not the memory
   mechanism. **The parameter-matched control was run — see below, and it
   overturns the conclusion.**

### Parameter-matched control: the memory effect does NOT survive (MEASURED)

`runs/abl_parammatch` — `memory` (92,430 params, 8 slots) vs `wide`
(92,530 params, `d_ff=228`, no memory). Parameter counts differ by **0.1%**.
Same budget, seeds 0 and 1, 50-game matches.

| seed | memory vs wide | 95% CI | Elo |
|---|---:|---|---:|
| 0 | 0.470 | [0.34, 0.61] | **−21** |
| 1 | 0.730 | [0.59, 0.83] | **+173** |

> **The seeds disagree in direction and both CIs contain 0.5.**
> Against a parameter-matched control, memory shows **no reliable benefit**.

Reconciling this with Phase 5: the earlier `baseline vs memory` result
(+131 Elo, identical in both seeds) is best explained as a **capacity effect**,
not a memory-mechanism effect. Spending the same 12,800 parameters on a wider
MLP does just as well.

Per the brief — *"do not claim an architectural feature works unless its
ablation demonstrates a measurable effect"* — the claim "persistent memory
helps" is **NOT SUPPORTED** at this scale and training budget. Two seeds is
also too few; the honest statement is "no reliable effect detected", not
"memory does not work".

**This is why parameter-matched controls matter: the unmatched ablation would
have produced a confident and wrong conclusion.**

### Both models are far weaker than a one-ply material heuristic

Every arm loses heavily to `MaterialAgent` (0.06–0.15). After ~1,000 self-play
games on 2 vCPU, the models beat random play and their own initialisation but
have **not** learned material value. This is the honest strength ceiling of the
current compute budget and is not disguised by the self-play-relative numbers.

---

## Phase 9 — internal-state transcription (MEASURED, with a negative headline)

`tinychess/thought.py`. A read-only decoder over the trajectory. Two properties
are enforced in code rather than asserted in prose:

**Gradient isolation is PROVEN, not claimed.** `assert_no_gradient_leak()` runs a
transcription loss backward and inspects every chess parameter:

```
leaked chess params: 0        (decoder params with gradient: 8 tensors)
decoder size: 27,036 params  -- reported SEPARATELY, outside the chess budget
```

**The transcript describes computational events, not chess concepts.** Labels are
measured from the model's own trajectory (|Δh| behaviour, router argmax,
confidence), never from human commentary.

### The event vocabulary was broken, and measurement caught it

First version used absolute thresholds. Measured base rates showed
**7 of 12 events never fired**, so a decoder scored 99.1% by predicting
constants (majority baseline **94.5%**). Rewritten to use per-trajectory
*relative* definitions (median splits). After the fix the majority baseline
falls to **79.9%** and 7/12 events are informative for a baseline-config model
(the 5 still constant are `local_dominant`, `mlp_dominant`, `memory_active`,
`reorganising`, `late_shift` — correct, since this checkpoint has no
memory/router and its routing is uniform).

### Trajectory access does NOT help (MEASURED)

The decisive control, both decoders predicting the *same* full event sequence
with the same architecture and parameter count (the final-state decoder is fed
`h_n` repeated T times):

| decoder | all-event acc | informative-event acc | BCE |
|---|---:|---:|---:|
| trajectory (h0..hn, Δh) | 0.9768 | 0.9603 | 0.0752 |
| **final state only (h_n)** | **0.9956** | **0.9924** | **0.0271** |
| majority-class baseline | — | 0.7992 | — |

> **Trajectory advantage: −0.032.** The final-state decoder is *better*.

Both clear the majority baseline, so the events are genuinely being read from
the state. But for this model, **h_n alone suffices to reconstruct the event
sequence** — trajectory access exposes nothing extra. Plausible cause: with
uniform routing and monotone |h| growth, the trajectory is highly predictable,
so h_n implicitly encodes its own history. This is exactly the control the
brief demanded, and it argues *against* the trajectory-transcription hypothesis
in the current regime. It should be re-tested on a router-enabled model whose
per-step behaviour actually varies.

### Interventions (MEASURED)

| test | result |
|---|---|
| ablate latent channel (0/7/23/41) | event distribution shifts (0.028–0.033 mean change) |
| board counterfactual (remove a piece) | trajectory L2 = 23.1, events change |
| forced early halt | event sequence truncates 5 → 4 steps |
| memory mask | n/a for baseline config (no memory) |

---

## Phase 10 — structural plasticity (TESTED)

`tinychess/plasticity.py`. Fixed tensors + binary active/inactive masks, so
topology changes never reallocate and maximum capacity is a hard ceiling.

Pruning is **not** magnitude-based. A composite utility combines gradient
sensitivity (weighted 1.5x), activation magnitude, diversity and firing
frequency; candidates then need **intervention evidence** — the unit is
temporarily deactivated and only stays pruned if measured loss does not degrade.

Measured on a trained baseline checkpoint (128 hidden units, 48 positions):

```
step 1000
pruned units: 10
spawned units: 6
kept after intervention: 0
active units: 124/128
active parameters: 79,114 (max 79,630)
```

Every mutation is logged with its reason, e.g.
`prune unit 2 | redundant: loss 3.2048->3.2053`. Spawning re-activates a dead
slot from a high-utility donor plus perturbation, halving the donor's outgoing
weight so the function is approximately preserved.

Active-parameter accounting is exact: a dead MLP unit removes
`2*d_model + 1 = 129` parameters; 10 pruned − 6 spawned = 4 net → 516 fewer
active parameters, matching 79,630 → 79,114.

**Not yet measured:** whether plasticity improves *self-play strength*. It is a
working mechanism with correct accounting, nothing more.

---

## Phase 11 — adaptive precision (MEASURED)

`experiments/exp_precision.py`. All four regimes the brief distinguishes, each
validated numerically against the FP32 reference (memory-config checkpoint,
48 positions, 6 steps).

**A. Static activation precision** (one level everywhere):

| level | top-1 agreement | KL from FP32 | max logit error |
|---|---:|---:|---:|
| bf16 | 1.000 | 0.00000 | 0.0003 |
| fp16 | 1.000 | 0.00000 | 0.0000 |
| int8 | 1.000 | 0.00000 | 0.0011 |
| int4 | 1.000 | 0.00001 | 0.0253 |
| int3 | 0.979 | 0.00011 | 0.0694 |
| int2 | 0.812 | 0.00217 | 0.3584 |

**A2. Static weight quantisation** — much less forgiving than activations:

| level | top-1 | mean weight rel. error |
|---|---:|---:|
| int8 | 1.000 | 0.005 |
| int4 | 0.938 | 0.086 |
| int3 | 0.688 | 0.200 |
| int2 | **0.062** | 0.594 |

**B. Operation-dependent:** int3/int4 on local+MLP with FP32 attention keeps
top-1 at 1.000 — i.e. precision can be spent unevenly across operations for free.

**C. Step-dependent:** int3 for steps < 3 then FP32 keeps top-1 at 1.000
(KL 0.00007). Early recurrent steps tolerate very low precision.

**D. Position-dependent:** positions split at the median policy entropy.
int3 on *easy* positions → top-1 **1.000**; the same int3 on *hard* positions →
top-1 **0.958**. **Cheap precision demonstrably costs more on hard positions**,
which is the empirical justification for making precision adaptive rather than
static.

### Honest caveat on speed

This is *fake* quantisation (quantise→dequantise in FP32), so it measures
**numerical** behaviour, not throughput. Wall-clock was measured anyway and
confirms there is no speedup: bf16 144 ms, int3 156 ms, fp32 168 ms, int4
175 ms per forward — differences are noise, not arithmetic savings. Real gains
would need INT kernels (fbgemm/oneDNN). **Claiming a speed benefit here would be
fabrication; none is claimed.**

---

## THE CENTRAL EXPERIMENT — does inference-time compute buy strength? (MEASURED)

`experiments/exp_compute_scaling.py`. One checkpoint (memory config, **92,430
params**, trained at 4 recurrent steps). **No weight is changed.** Only the
number of recurrent steps at inference varies. 30 games per match, colours
balanced.

### Deeper vs shallower, identical weights

| match | score for deeper | 95% CI | Elo |
|---|---:|---|---:|
| 2 vs 1 | 0.700 | [0.52, 0.83] | **+147** |
| 4 vs 1 | 0.800 | [0.63, 0.90] | **+241** |
| **8 vs 1** | **0.967** | [0.83, 0.99] | **+585** |
| 8 vs 2 | 0.633 | [0.46, 0.78] | +95 |
| 8 vs 4 | 0.583 | [0.41, 0.74] | +58 |
| 16 vs 8 | **0.300** | [0.17, 0.48] | **−147** |
| 16 vs 1 | 0.533 | [0.36, 0.70] | +23 |

Latency scales as expected: 6.17 ms/position at 8 steps, 12.76 ms at 16 steps.
Illegal probability mass is **exactly 0.0** at every depth.

### Verdict

> **Supported, with a ceiling.** The same 92,430 parameters play ~585 Elo
> stronger purely by thinking 8 steps instead of 1. This is the core claim of
> the project and it is measured, not asserted.
>
> **But depth does not extrapolate indefinitely.** Strength peaks at 8 steps
> and *degrades* at 16 (−147 Elo vs 8 steps). The model was trained at 4 steps;
> it generalises to roughly 2x its training depth and then drifts out of
> distribution — consistent with the monotonically growing |h| seen in the
> traces (no normalisation pins the state's scale across unrolled depth).

This makes the honest version of the headline: *inference-time computation is a
real and large source of capability for a fixed tiny parameter set, within a
band around the trained depth* — not an unbounded substitute for parameters.

### The strength ceiling is still low

At every depth the model scores 0.98–1.00 vs random-legal but only
**0.08–0.18 vs the one-ply material heuristic**. Extra thinking does not
rescue a policy that has not yet learned material value on ~1,000 self-play
games. Depth amplifies what was learned; it does not replace training.

## Component status

| component | status |
|---|---|
| board encoding, canonicalisation, move packing | **TESTED** |
| legal-move masking, sampling | **TESTED** — illegal prob mass exactly 0.0 in every run |
| self-play env + all termination rules | **TESTED** |
| replay buffer (FEN-based, ~60 B/position) | **TESTED** (used in all runs) |
| REINFORCE + value baseline | **MEASURED** — learns, then collapses (run 1) |
| PPO clip + adaptive entropy control | **MEASURED** — stable, +512 Elo (run 2) |
| checkpoint / resume / HF push | **TESTED** (bit-exact incl. RNG) |
| shared recurrent core | **MEASURED** — depth is ~free in params, +585 Elo at inference |
| compositional move embeddings | IMPLEMENTED; ablation **NOT RUN** |
| persistent memory (8 slots) | **MEASURED — no reliable effect** vs param-matched control |
| move-latent refinement | IMPLEMENTED; ablation **NOT RUN** |
| adaptive halting (ACT) | IMPLEMENTED, gradient flow verified; self-play ablation **NOT RUN** |
| learned routing | IMPLEMENTED, traces recorded; ablation **NOT RUN** |
| trajectory observability | **TESTED** via `inspect_trace.py` |
| thought transcription | **MEASURED — trajectory access gives no advantage** |
| adaptive precision | **MEASURED** (numerics); no speedup, and none claimed |
| structural plasticity | **TESTED** (prune/spawn with intervention evidence); strength effect **NOT MEASURED** |
| diffusion refinement | **NOT IMPLEMENTED** |
| Gradio console | IMPLEMENTED; blocked by Space billing |

---

## Summary of measured findings

**Positive, reproducible:**

1. A 79.6K-parameter recurrent net trained purely by self-play from random init
   reaches **+512 Elo** over its own frozen initialisation (`runs/p4_ppo`),
   with entropy stable and zero illegal moves.
2. **Inference-time computation is a large, real source of strength**:
   the same weights play **+585 Elo** stronger at 8 recurrent steps than at 1.
   This is the project's central hypothesis and it is supported.
3. Depth costs almost nothing in parameters (+512 params for 1→24 steps).

**Negative / corrective — kept because they are the actual findings:**

4. Plain REINFORCE **collapses** (entropy → 0.07, all games repetition-draws,
   gradient norm → 108, +338 Elo → −9). Cause diagnosed; PPO + adaptive entropy
   fixes it.
5. **Memory shows no reliable benefit** against a parameter-matched control
   (seeds disagree: −21 and +173 Elo). The unmatched ablation would have given
   a confident wrong answer.
6. **Trajectory access gives the thought decoder no advantage** over seeing only
   the final state (−0.032 accuracy). Argues against the transcription premise
   in this regime.
7. **Depth does not extrapolate**: strength peaks at 8 steps and degrades at 16.
8. Fake quantisation gives **no CPU speedup** (measured, not assumed).

**The honest ceiling:** every model beats random-legal (0.94–1.00) but loses
badly to a one-ply material heuristic (0.06–0.18). On ~1,000 self-play games at
2 vCPU the system has not learned material value. Nothing here should be read
as "a strong chess engine"; it is a correct, measured research substrate.

## Reproducing

```bash
python tests/test_phase1.py                      # 12 correctness gates
python train_selfplay.py --config baseline --iters 200 --games 48 --threads 2 \
    --eval-every 10 --out runs/mine
python experiments/exp_ablation.py --arms memory,wide --seeds 0,1 --iters 30
python experiments/exp_compute_scaling.py --checkpoint runs/mine/latest.pt
python experiments/exp_faithfulness.py --checkpoint runs/mine/latest.pt
python experiments/exp_precision.py --checkpoint runs/mine/latest.pt
python inspect_trace.py --checkpoint runs/mine/latest.pt --steps 8
```


---

## Conversion failure: why the "material heuristic ceiling" was partly an artifact

**Status: MEASURED.** Artifacts: `runs/material_recheck.json`,
`runs/conversion_failure.json`.

### Finding 1 — the ceiling moved, and the old number was adjudication-dependent

Earlier the project reported that every checkpoint "loses badly to a one-ply
material heuristic" (0.083-0.183). Re-measured on a grid-trained baseline
(85 iters, 96 games/iter) with 40 colour-balanced games:

| checkpoint | opponent | adjudicate | score | CI95 | W-D-L |
|---|---|---|---|---|---|
| grid baseline_s0 | material | material | **0.825** | [0.68, 0.91] | 27-12-1 |
| grid baseline_s0 | material | none | **0.512** | [0.36, 0.66] | 1-39-0 |
| grid baseline_s0 | random | material | 0.812 | [0.67, 0.90] | 25-15-0 |
| grid baseline_s0 | random | none | 0.525 | [0.37, 0.67] | 2-38-0 |
| old abl_memory_s0 | material | material | 0.212 | [0.11, 0.36] | 1-15-24 |
| old abl_memory_s0 | material | none | 0.463 | [0.32, 0.61] | 0-37-3 |

Two distinct conclusions, both important:

1. **More self-play genuinely helped.** Under the *same* `adjudicate=material`
   protocol the old checkpoint scored 0.212 and the grid checkpoint scores
   **0.825** against the same opponent. That is a real improvement.
2. **But the headline number is protocol-dependent.** Switch off material
   adjudication and the same grid checkpoint drops to **0.512** — statistically
   indistinguishable from a draw. The model wins on *adjudicated material*, not
   by actually winning games.

**Any future strength claim must state its adjudication mode.** Reporting only
the `adjudicate=material` figure would have overstated capability.

### Finding 2 — the real deficiency is conversion, not material

Games were run to 400 plies with `adjudicate=none` to rule out truncation.
Mean game length settles at ~200 plies even with a 600-ply cap, so these are
genuine rule-draws, not unfinished games. Termination breakdown, 30 games each:

| checkpoint | opponent | model mates | stalemates | dominant terminations |
|---|---|---:|---:|---|
| grid baseline_s0 | random | 1 | 6 | repetition 13, max_plies 9 |
| grid baseline_s0 | material | 1 | 1 | repetition 14, insufficient_material 8 |
| grid mlp_s0 | random | 4 | **15** | stalemate 15 |
| grid mlp_s0 | material | 0 | 2 | **insufficient_material 19** |
| old memory_s0 | random | 3 | **11** | stalemate 11 |
| old memory_s0 | material | 0 | **10** | insufficient_material 17 |

**In every case the stalemate count meets or exceeds the checkmate count.**
Against the material opponent the models trade down into
`insufficient_material` (8/30, 19/30, 17/30).

**Interpretation (MEASURED for the symptom, HYPOTHESISED for the cause):** the
models learn to *win material* but not to *convert it into mate*. They stalemate
the opponent king or liquidate into dead-drawn endings. This is consistent with
outcome-only rewards plus material adjudication: if a run is scored on material,
there is no gradient pressure to find mate, and stalemate is not penalised
relative to a draw.

**This reframes the central research question.** The earlier "model loses to a
one-ply heuristic" ceiling is better described as: *the model reaches material
superiority and then cannot finish.* Whether additional inference-time compute
helps conversion is a separate question from whether it helps move selection.

**NEGATIVE RESULT retained:** the `adjudicate=material` protocol used throughout
the earlier ablations (including Phase 5) inflates apparent strength relative to
playing games out. The Phase 5 conclusion (memory unsupported under a
param-matched control) is unaffected, because both arms used the same protocol,
but absolute numbers from those runs should not be read as playing strength.


---

## Inference-depth clamp: a bug that invalidates naive depth sweeps

**Status: MEASURED (bug), artifact `runs/fixed_point_probe.json`.**

`TinyChess.forward` contains:

```python
n = steps if steps is not None else cfg.max_steps
n = max(cfg.min_steps, min(n, cfg.max_steps))   # <-- hard clamp
```

**Any request for more steps than `cfg.max_steps` is silently reduced.** A
checkpoint trained with `max_steps=4` asked for 8, 16 or 32 steps runs exactly 4.

Evidence — mean legal-move logit by requested depth, weights fixed:

| depth | memory_s0 | delta vs prev | grid baseline_s0 | delta vs prev |
|---|---|---|---|---|
| 1 | -0.33759 | -- | -0.46984 | -- |
| 2 | -0.36971 | 5.16e-02 | -0.53486 | 1.03e-01 |
| 4 | -0.38203 | 4.41e-02 | -0.52344 | 5.22e-02 |
| 8 | -0.38203 | **0.00e+00** | -0.52344 | **0.00e+00** |
| 16 | -0.38203 | **0.00e+00** | -0.52344 | **0.00e+00** |
| 32 | -0.38203 | **0.00e+00** | -0.52344 | **0.00e+00** |

Output beyond depth 4 is **bit-identical**. Additionally `step_emb` row 4 — the
row the clamp would reuse for all deeper steps — is **exactly zero** (never
trained); the trained rows have norms of only ~0.03-0.08.

### Does this invalidate the central compute-scaling result? NO.

`experiments/exp_compute_scaling.py` already lifts the cap before evaluating:
it grows `step_emb` to `max(steps)+1`, copies the last trained row into the new
rows, and raises `model.cfg.max_steps`. With the cap lifted the output does keep
changing with depth (delta 2.0e-01 at d=8, 5.7e-01 at d=16), so the
**+585 Elo at 8 steps result was measured on a model genuinely running 8 steps**
and stands.

### What it did invalidate

1. **My first run of `exp_step_embedding.py` was meaningless** — it lacked the
   cap lift, so `clamped`, `zeroed` and `frozen` produced identical entropy,
   top-1 probability and depth-1 agreement at every depth >= 4, because all three
   were running exactly 4 steps. The apparent "no difference between conditions"
   was an artifact. Fixed by lifting the cap; experiment re-running.
2. **A reporting bug:** `exp_compute_scaling.py` mutates `model.cfg` in place and
   `cfg` is the same object, so it recorded `"trained_steps": 16` when the
   checkpoint was actually trained at `max_steps=4`. The session notes and the
   status report inherited this error. **The correct trained depth for
   `runs/compute_scaling_memory.json` is 4, not 16.** The measured scores are
   unaffected; only the "trained at" label was wrong.

**Consequence for interpretation — this makes the headline result stronger, not
weaker.** The +585 Elo at 8 steps was obtained from a model trained at only
**4** steps, i.e. it is genuine extrapolation beyond the training depth, and the
degradation at 16 occurs at 4x the trained depth rather than at the trained depth.

**Lesson recorded:** any depth sweep must assert that the model actually ran the
requested number of steps. A cheap invariant — consecutive-depth output delta
must be non-zero — would have caught this immediately.

### Blast radius of the clamp bug across existing results

Audited every script in `experiments/` for "requests depth > trained max_steps
without lifting the cap":

| script | depth sweep | lifts cap | affected result |
|---|---|---|---|
| `exp_compute_scaling.py` | yes | **yes** | none — central result is valid |
| `exp_step_embedding.py` | yes | **yes** (after fix) | first run invalid, re-run |
| `exp_faithfulness.py` | `steps=6` on `max_steps=4` | no | ran 4 steps, not 6 |
| `exp_precision.py` | `steps=6` on `max_steps=4` | no | ran 4 steps, not 6 |
| `exp_ablation.py` | `--steps 4` | no | unaffected (4 <= 4) |
| `exp_learning.py` | `--steps 4` | no | unaffected |
| `analyse_grid.py` | `--steps 4` | no | unaffected |

**Phase 9 (faithfulness) and Phase 11 (precision) each requested 6 steps and
silently got 4.** Their conclusions are not necessarily wrong, but they describe
a 4-step model while claiming 6. Specifically:

- Phase 9's finding (gradient isolation proven; trajectory advantage -0.032) was
  computed over a 4-step trajectory h0..h4, not h0..h6. The gradient-isolation
  result (0 leaked chess params) is structural and unaffected. The trajectory
  advantage number should be relabelled as 4-step.
- Phase 11's precision conclusions were measured at 4 steps. The
  *step-dependent* schedule result ("int3 early then fp32 late -> 1.000") is
  therefore over 4 steps, and the "step-dependent" claim is weaker than it
  appeared because there were fewer steps to vary over than reported.

**Neither is being deleted or quietly corrected — both are relabelled here.**
Re-running them at a genuinely lifted depth is on the outstanding list.


---

## Phase 7 — adaptive halting: MEASURED, and it is a NEGATIVE RESULT

Artifact: `runs/halting_routing.json`. Checkpoint `runs/grid/halting_s0/latest.pt`
(85 iters self-play), `use_halting=True`, `max_steps=4`, `min_steps=1`,
`halt_threshold=0.95`, 128 held-out positions.

### Step distribution — degenerate

| statistic | value |
|---|---|
| mean steps | **2.000** |
| median | 2.0 |
| p90 | 2.0 |
| p95 | 2.0 |
| min / max | 2 / 2 |
| std | **0.000** |
| histogram | `{2: 128}` |
| allowed max | 4 |

**Every single position halts at exactly 2 steps.** Correlation between halting
depth and all four difficulty proxies (`n_legal`, `abs_material`, `n_pieces`,
`in_check`) is **exactly +0.000** — necessarily, since the output is constant.

The ACT mechanism is IMPLEMENTED and runs, but it **has not learned
position-dependent computation**. It collapsed to a constant depth.

### Strength — adaptive is WORSE than a fixed depth

Same weights, 30 colour-balanced games, `adjudicate=material`:

| opponent | adaptive | fixed 1 | fixed 2 | fixed 4 |
|---|---|---|---|---|
| random_legal | 0.900 [0.74,0.97] | 0.900 [0.74,0.97] | 0.800 [0.63,0.90] | 0.883 [0.72,0.96] |
| material_greedy | **0.333** [0.19,0.51] | 0.283 [0.15,0.46] | 0.450 [0.29,0.62] | **0.567** [0.39,0.73] |

Against the material opponent, adaptive halting (0.333) is beaten by simply
running a fixed 4 steps (0.567). The CIs overlap, so this is suggestive rather
than conclusive, but there is **no evidence that halting helps**, and the point
estimate is worse than the fixed control it is supposed to improve on.

**Conclusion (MEASURED): adaptive halting did not learn to allocate computation
and costs strength relative to fixed-depth inference. Retained as a negative
result.** Note the interaction with the clamp bug: `max_steps=4` gives ACT very
little room to vary. Whether halting behaves differently with a genuinely larger
budget is HYPOTHESISED, not tested.

---

## Phase 8 — learned routing: MEASURED, and it WORKED

Artifact: `runs/halting_routing.json`. Checkpoint `runs/grid/router_s0/latest.pt`,
`use_router=True`, `router_temp=1.0`, `topk=0`, ops = `[attn, local, mlp]`,
128 positions.

### The router specialised

| op | mean weight | uniform would be |
|---|---|---|
| attn | 0.2708 | 0.3333 |
| local | 0.2413 | 0.3333 |
| **mlp** | **0.4878** | 0.3333 |

max deviation from uniform **0.1545**; routing entropy **1.0470** vs max 1.0986.
This is a real departure from uniform, not noise: across-position std is
attn 0.0583, mlp 0.0640 (local 0.0305), so weights genuinely vary by position.

### Routing is position-dependent in an interpretable way

Correlation of each op's weight with difficulty proxies:

| op | n_legal | abs_material | **n_pieces** | in_check |
|---|---:|---:|---:|---:|
| attn | +0.178 | +0.570 | **-0.894** | +0.135 |
| local | -0.032 | +0.059 | +0.051 | -0.150 |
| mlp | -0.147 | -0.548 | **+0.791** | -0.052 |

**The router uses global attention more as the board empties (-0.894 with piece
count) and the MLP more when the board is crowded (+0.791).** It also leans on
attention when material is imbalanced (+0.570).

This was **not hard-coded** — no chess semantics were given to the router; the
op set is generic (`attn`/`local`/`mlp`) and the correlation is a post-hoc
measurement against proxies the model never saw. This satisfies the brief's
requirement to let the model discover routing roles rather than assigning them.

### Drift across recurrent steps

| step | attn | local | mlp |
|---|---:|---:|---:|
| 0 | 0.304 | 0.208 | 0.488 |
| 1 | 0.273 | 0.237 | 0.490 |
| 2 | 0.257 | 0.255 | 0.487 |
| 3 | 0.249 | 0.266 | 0.485 |

Attention usage falls and local mixing rises monotonically with depth while the
MLP stays flat — an early-global / late-local pattern.

**Status: MEASURED.** Routing decisions are now recorded and analysed, not merely
implemented. **Playing-strength impact of routing is NOT established here** — that
requires the cross-arm head-to-head (router vs baseline), which is pending.


---

## Step-embedding extrapolation vs genuine saturation: HYPOTHESIS REFUTED

Artifact: `runs/step_embedding_memory.json`. Script
`experiments/exp_step_embedding.py`. Checkpoint `runs/abl_memory/memory_s0`
(92,430 params, **trained at max_steps=4**), weights FIXED and identical in every
condition, 30 colour-balanced games per cell, temperature 0.3,
`adjudicate=material`, same seed and opponent throughout. Only inference depth
and the step-embedding policy vary.

### The hypothesis under test

The core applies `step_emb[min(step, max_steps)]`, so every step beyond the
trained depth reuses the last trained row. **Hypothesis B:** the degradation at
depth 16 is caused by this out-of-distribution step signal, not by the recurrence
itself. **Hypothesis A:** the recurrence genuinely saturates and then degrades.

### Conditions (all at identical weights)

| condition | step embedding |
|---|---|
| `clamped` | stock: `step_emb[min(step, max_steps)]` |
| `zeroed` | all rows zeroed -> genuinely step-invariant core |
| `frozen` | every step uses one fixed in-distribution row (k = trained max) |

If B were true, `zeroed` and `frozen` should keep improving where `clamped`
degrades.

### Result vs one-ply material heuristic

| depth | clamped | zeroed | frozen |
|---|---|---|---|
| 1 | 0.150 | 0.100 | 0.067 |
| 2 | 0.217 | 0.150 | 0.133 |
| 4 | 0.200 | 0.217 | 0.217 |
| **8** | **0.267** | **0.317** | **0.300** |
| 16 | 0.167 | 0.117 | 0.150 |
| 32 | 0.083 | 0.150 | 0.167 |

Pooled across the three embedding modes (90 games per depth), which is the
statistically meaningful view:

| depth | score | CI95 | W-D-L |
|---|---|---|---|
| 1 | 0.106 | [0.057, 0.186] | 0-19-71 |
| 2 | 0.167 | [0.104, 0.257] | 2-26-62 |
| 4 | 0.211 | [0.140, 0.306] | 2-34-54 |
| **8** | **0.294** | **[0.210, 0.395]** | 5-43-42 |
| 16 | 0.144 | [0.086, 0.232] | 0-26-64 |
| 32 | 0.133 | [0.078, 0.219] | 1-22-67 |

### Conclusion: HYPOTHESIS B IS REFUTED (MEASURED)

**All three conditions show the same inverted-U with a peak at depth 8 and
degradation at 16 and 32.** Removing the step embedding entirely (`zeroed`) does
not rescue deep inference — it peaks at 8 (0.317) and collapses at 16 (0.117)
exactly like the stock model. `frozen`, which supplies a purely in-distribution
step signal at every depth, behaves the same way (0.300 at 8, 0.150 at 16).

Therefore the degradation is **NOT** caused by out-of-distribution step
embeddings. This is consistent with Hypothesis A: the recurrent core genuinely
saturates around 8 iterations and then drifts away from a useful state. It is
also consistent with the measured magnitudes of the step embedding itself — the
trained rows have norms of only ~0.03 and the row used for all deep steps is
**exactly zero**, so the embedding was never a strong enough signal to explain
the effect.

**The earlier "extrapolated step_emb is a likely cause" note in this log is
withdrawn and replaced by this measurement.**

### Secondary confirmation of the central hypothesis

The depth-8 pooled score (0.294, CI [0.210, 0.395]) does not overlap the depth-1
pooled score (0.106, CI [0.057, 0.186]). At **identical weights**, running the
recurrent core 8 times instead of once produces a statistically separated
improvement against a fixed external opponent. This reproduces the central
compute-scaling result on a different opponent and a different protocol, and it
does so on a model trained at only 4 steps — i.e. genuine extrapolation beyond
training depth.

**Remaining open question (HYPOTHESISED):** the saturation point may itself be a
function of training depth. A model trained with a larger step budget might peak
later than 8. Testing that requires training a checkpoint at higher `max_steps`,
which is a training experiment, not an inference-time one.


---

## Phase 9 re-run on a router-enabled checkpoint, at a genuinely lifted depth

Artifact: `runs/faith_router_s0.json`. Checkpoint `runs/grid/router_s0/latest.pt`
(85 iters), `--steps 8` with the step cap explicitly lifted 4 -> 8 (the original
Phase 9 run asked for 6 steps and silently got 4; see the clamp-bug section).

| measurement | original (baseline_s0, effective 4 steps) | re-run (router_s0, true 8 steps) |
|---|---|---|
| leaked chess params | **0** | **0** |
| decoder params | 27,036 | 27,036 |
| majority baseline | 0.7992 | 0.7758 |
| informative events | -- | 9/12 |
| trajectory decoder (informative) | 0.9603 | 0.9248 |
| final-state-only (informative) | 0.9924 | 0.9338 |
| **trajectory advantage** | **-0.032** | **-0.009** |

**Both conclusions replicate (MEASURED):**

1. **Gradient isolation holds.** `leaked=0` on a different architecture (router
   enabled) at a different depth. The thought channel provably cannot influence
   chess play — this satisfies the brief's stop-gradient requirement and is now
   verified twice, independently.
2. **The trajectory still provides no decoding advantage** (-0.009). Reading the
   full h0..h8 sequence is no better than reading the final state h_n alone. The
   effect is smaller than before but still negative, i.e. in the same direction.

Supporting intervention evidence on the router checkpoint: ablating individual
latent channels changes decoded events by 3.7-5.4%; a board counterfactual moves
the trajectory by L2 62.28; forcing an early halt shortens the event sequence
9 -> 5 steps. So the decoder is genuinely reading the model's state, not
confabulating — it simply gains nothing from the history.

**NEGATIVE RESULT retained and now replicated across two checkpoints and two
depths.**


---

## Phase 10 — plasticity: mechanism vs structure vs STRENGTH, finally separated

Artifact: `runs/plasticity_strength.json`, script
`experiments/exp_plasticity_strength.py`. Checkpoint `runs/grid/baseline_s0`
(85 iters). Prune-only (`--max-spawn 0`) so any strength delta is attributable to
pruning alone. Pruning used **intervention evidence** (temporarily deactivate the
unit, re-measure, keep the prune only if loss does not worsen beyond tolerance),
never average activation.

### Claim 1 — mechanism runs: CONFIRMED

`{pruned: 8, spawned: 0, kept_after_intervention: 0, active_units: 120/128,
active_parameters: 78,598, max_parameters: 79,630}`

### Claim 2 — structure changes: CONFIRMED

| | before | after |
|---|---|---|
| active units | 128/128 | **120/128** |
| active params | 79,630 | **78,598** |
| max (structural capacity) | 79,630 | 79,630 |

8 units removed, 1,032 parameters deactivated, fixed capacity respected.

### Claim 3 — playing strength changes: NO EVIDENCE (the new result)

60 colour-balanced games per cell, `adjudicate=material`, same seed:

| opponent | control | treatment (pruned) | delta |
|---|---|---|---|
| random_legal | 0.842 [0.73,0.91] | 0.850 [0.74,0.92] | +0.008 |
| material_greedy | 0.708 [0.58,0.81] | 0.642 [0.52,0.75] | -0.066 |

Direct head-to-head, pruned model vs its own unpruned self:

**0.533 for the pruned model, CI95 [0.41, 0.65] — NOT SIGNIFICANT.**

**Conclusion (MEASURED): removing 8 of 128 hidden units (1.3% of parameters)
produces no detectable change in playing strength.** The CI comfortably contains
0.5 and the two reference-opponent deltas point in opposite directions.

**This is the honest reading:** the plasticity mechanism works and provably
changes the network's structure, but there is **no evidence it improves play**,
and equally no evidence it harms play. The correct summary is *"the model has
~6% redundant capacity that can be removed for free"*, not *"plasticity helps"*.

Mechanical success has NOT been converted into a strength claim, per the brief.


### Phase 7/8 replication on the `full` arm

Artifact: `runs/halting_routing_full.json`. Checkpoint `runs/grid/full_s0`
(all features enabled: memory + refine + halting + router), 128 positions.

**Halting is degenerate again — and in a different place.** Every one of 128
positions halts at exactly **4** steps (mean 4.0, median 4.0, p90 4.0, p95 4.0,
std **0.000**, histogram `{4: 128}`). On `halting_s0` the constant was 2; here it
is 4 (the maximum). Correlation with all difficulty proxies is exactly +0.000.

So across two independent checkpoints, ACT collapses to a constant depth — once
to the floor-ish value 2, once to the ceiling value 4. **It never learned
position-dependent computation.** Strength is again not improved by adaptivity:
vs material, adaptive 0.667 [0.49,0.81] vs fixed-1 0.650 [0.47,0.79] — overlapping.

**The router on the `full` arm essentially switched the memory op OFF.**

| op | mean weight | uniform |
|---|---:|---:|
| mlp | **0.8278** | 0.25 |
| attn | 0.1103 | 0.25 |
| local | 0.0593 | 0.25 |
| **mem** | **0.0026** | 0.25 |

Routing entropy 0.5825 of a possible 1.3863 — strongly specialised. The memory
read/write operation receives **0.26% of the routing weight, ~100x below
uniform**.

**This is independent corroboration of the Phase 5 negative result.** Phase 5
showed that memory slots give no strength benefit once parameters are matched.
Here a *learned* router, given free choice over four operations and no
supervision about their roles, converges to almost never using memory. Two
different methods, same conclusion: **the memory mechanism is not earning its
place in this model.**


---

## Grid results part 1: strength vs fixed references (MEASURED)

Artifact: `runs/grid_analysis.json` (in progress), script
`experiments/analyse_grid.py`. 9 arms x 3 seeds, each trained ~85 iterations of
self-play from random init (96 games/iter). 60 colour-balanced games per arm-seed
per opponent = **180 games per cell**, `adjudicate=material`, steps=4.

| arm | vs random-legal | vs one-ply material | per-seed (material) |
|---|---:|---:|---|
| router | 0.856 | **0.706** | [0.63, 0.71, 0.78] |
| memory | 0.847 | **0.681** | [0.68, 0.68, 0.68] |
| baseline | 0.861 | 0.664 | [0.65, 0.61, 0.73] |
| full | 0.839 | 0.664 | [0.61, 0.72, 0.66] |
| refine | 0.900 | 0.661 | [0.66, 0.62, 0.71] |
| transformer | 0.906 | 0.644 | [0.66, 0.68, 0.59] |
| wide | 0.864 | 0.636 | [0.68, 0.59, 0.64] |
| mlp | 0.881 | 0.619 | [0.48, 0.69, 0.68] |
| halting | 0.878 | 0.603 | [0.49, 0.60, 0.72] |

### The headline: the material ceiling is broken

Every arm now **beats** the one-ply material heuristic (0.603-0.706), where the
earlier ~1,000-game checkpoints scored 0.083-0.212 against the same opponent
under the same protocol. More self-play was the binding constraint for that
particular ceiling, and the project's earlier "cannot learn material value"
statement is now **superseded**.

### But the ranking is not trustworthy, and I am not claiming a winner

1. **The two reference opponents disagree.** `transformer` is 1st vs random
   (0.906) but 6th vs material (0.644); `router` is 7th vs random (0.856) but
   1st vs material (0.706). A single-opponent ranking would be an artifact.
2. **All CIs overlap heavily.** The vs-material spread is 0.603-0.706 with CIs
   roughly +/-0.07 -- top and bottom are ~1.5 CI widths apart at best.
3. **Seeds are noisy within arms.** `mlp` ranges 0.48-0.69, `halting` 0.49-0.72
   across seeds -- wider than the entire between-arm spread.

**No arm is declared superior on this evidence.** The cross-arm head-to-head with
the seed-consistency filter (`experiments/summarise_grid.py`) is the deciding
test, and only differences that are both pooled-significant *and* consistent in
direction across all three seeds will be reported as credible.


---

## CENTRAL QUESTION RE-TESTED: does compute scaling get stronger once the model has learned chess?

**Answer: NO. It gets WEAKER. (MEASURED, and this is a negative result for the
project's most attractive hypothesis.)**

Artifacts: `runs/compute_scaling_router_s0.json`,
`runs/compute_scaling_memory_grid.json`. Both on grid checkpoints trained ~85
iterations (96 games/iter) that **do** beat the one-ply material heuristic,
unlike the original ~1,000-game checkpoint. 60 games per match, weights fixed,
only inference depth varies.

### Deeper-vs-1-step score, three checkpoints of increasing skill

| match | weak ckpt (old, loses to material) | router_s0 (0.706 vs material) | memory_s0 grid (0.681) |
|---|---:|---:|---:|
| 2 vs 1 | 0.700 | 0.542 | 0.600 |
| 4 vs 1 | 0.800 | **0.700** | 0.592 |
| 8 vs 1 | **0.967** | 0.683 | 0.533 |
| 16 vs 1 | 0.533 | 0.467 | 0.375 |
| 32 vs 1 | -- | 0.400 | 0.258 |

| checkpoint | peak gain over 1 step | peak depth |
|---|---|---|
| weak (~1,000 games) | **+0.467** | 8 |
| router_s0 (85 iters) | +0.200 | 4 |
| memory_s0 (85 iters) | +0.100 | 2 |

**The better the model plays, the less extra inference-time computation helps,
and the earlier the peak arrives.**

### Absolute strength still shows the effect, and it is still real

router_s0 vs one-ply material by depth (identical weights):

| steps | 1 | 2 | 4 | 8 | 16 | 32 |
|---|---|---|---|---|---|---|
| score | 0.508 | 0.625 | **0.675** | 0.658 | 0.558 | 0.350 |

memory_s0 grid vs material: 0.783 / 0.633 / 0.700 / **0.833** / 0.592 / 0.217.

So extra depth still buys real strength (router: 0.508 -> 0.675, CIs
[0.39,0.63] vs [0.55,0.78]), and deep inference still collapses at 32 steps in
both checkpoints. The inverted-U is reproduced a third and fourth time, now on
well-trained models, with the same qualitative shape and an earlier peak.

### Interpretation

**MEASURED:** inference-time compute scaling is real but its magnitude is
*inversely* related to how much the weights already know. On a weak policy, extra
recurrence acts as a substitute for missing knowledge (+0.467). Once the policy
has learned material value, the same mechanism adds much less (+0.100 to +0.200).

**HYPOTHESISED (not tested):** extra recurrent steps mostly sharpen an
under-trained policy toward a decision it would eventually have made anyway, so
the headroom shrinks as training reduces that gap. Distinguishing this from
"the fixed point is reached sooner in a better-trained net" would need a
per-position analysis of how many steps the output takes to stabilise, across
checkpoints of different skill.

**This substantially qualifies the project's headline result.** The +585 Elo at
8 steps is genuine, but it was measured on a model that could not beat a one-ply
heuristic. Presenting that number as the project's main finding without this
caveat would overstate the case for inference-time compute.


---

## Grid results part 2: cross-arm head-to-head with a seed-consistency filter (MEASURED)

Artifacts: `runs/grid_analysis.json`, `runs/grid_verdict.json`,
`docs/GRID_RESULTS.md`. Script `experiments/summarise_grid.py`.

36 arm pairs, 60 games per arm-pair-seed x 3 seeds = **180 games per pair**.
A difference is called **credible** only if (a) the pooled 95% Wilson CI excludes
0.5 **and** (b) all three seeds point the same direction. Criterion (b) exists
because of the Phase 5 failure, where pooling two disagreeing seeds would have
implied an effect that does not exist.

- credible differences: **8**
- pooled-significant but seeds disagree (**rejected**): **3**
- not significant: **25**

### The filter earned its keep

Three pairs would have been reported as real effects by a naive pooled test:

| pair | pooled | CI95 | per-seed |
|---|---|---|---|
| full vs halting | 0.589 | [0.516, 0.658] | [0.667, 0.683, **0.417**] |
| baseline vs full | 0.417 | [0.347, 0.490] | [**0.525**, 0.308, 0.417] |
| full vs refine | 0.581 | [0.508, 0.650] | [**0.500**, 0.625, 0.617] |

Each has one seed on the wrong side of parity. **Rejected.**

### Credible differences (8)

| pair | score for first | CI95 | per-seed |
|---|---:|---|---|
| full vs mlp | 0.633 | [0.561, 0.700] | [0.675, 0.600, 0.625] |
| full vs wide | 0.622 | [0.550, 0.690] | [0.517, 0.717, 0.633] |
| memory vs mlp | 0.608 | [0.535, 0.677] | [0.767, 0.550, 0.508] |
| full vs transformer | 0.589 | [0.516, 0.658] | [0.533, 0.683, 0.550] |
| router vs wide | 0.589 | [0.516, 0.658] | [0.525, 0.608, 0.633] |
| mlp vs router | 0.381 | [0.313, 0.453] | [0.283, 0.450, 0.408] |
| refine vs router | 0.414 | [0.344, 0.487] | [0.433, 0.342, 0.467] |
| baseline vs router | 0.425 | [0.355, 0.498] | [0.492, 0.375, 0.408] |

### Credible win-loss record

| arm | params | credible wins | credible losses | beats |
|---|---:|---:|---:|---|
| **router** | **80,017** | **4** | **0** | baseline, mlp, refine, wide |
| full | 99,411 | 3 | 0 | mlp, transformer, wide |
| memory | 92,430 | 1 | 0 | mlp |
| baseline | 79,630 | 0 | 1 | -- |
| refine | 85,966 | 0 | 1 | -- |
| transformer | 207,010 | 0 | 1 | -- |
| wide | 92,530 | 0 | 2 | -- |
| mlp | 103,730 | 0 | 3 | -- |
| halting | 79,759 | 0 | 0 | -- |

### Conclusions I am willing to defend

1. **Learned routing is the only research feature with credible, seed-consistent
   evidence of benefit.** `router` wins 4 credible matchups and loses none, and
   it is the *second-smallest* arm at 80,017 params — only 387 more than the
   baseline. It also ranks first vs the material heuristic (0.706). Combined with
   the Phase 8 measurement that the router genuinely specialises and its choices
   correlate with position sparsity (attn vs n_pieces = -0.894), this is the
   project's strongest positive mechanism result.
2. **Parameters are not the explanation.** `transformer` has 207,010 params —
   2.6x the baseline and well over the 100K budget — and still loses a credible
   matchup to `full` (99,411) while ranking 6th vs material. `wide` (92,530)
   loses two. Capacity did not buy strength here.
3. **The non-recurrent `mlp` control is the worst arm** (3 credible losses, last
   vs material at 0.619). This is the clearest evidence in the project that the
   **recurrent core matters**, which is the architectural premise of the whole
   design.
4. **Adaptive halting is not merely unhelpful, it is the weakest scoring arm**
   (0.603 vs material) — consistent with the Phase 7 finding that it collapsed to
   a constant depth.
5. **Memory remains unsupported as a mechanism.** It wins only against `mlp`,
   loses to nothing, but never beats its own param-matched control `wide`
   (memory vs wide: not significant). This is the third independent line of
   evidence against memory, after Phase 5 and the `full`-arm router assigning it
   0.26% weight.

### What this does NOT show

25 of 36 pairs are statistically indistinguishable. The arms are separated by at
most ~0.10 in score against a fixed opponent, with CIs of +/-0.07. **The grid
establishes a weak ordering, not a decisive one**, and nothing here should be
read as "feature X is worth N Elo".


---

## Main long run: strongest model so far, same conversion failure (MEASURED)

Artifact: `runs/main_eval.json`. `runs/main_baseline` = baseline config, **79,630
params**, 105 iterations x 256 games = **~26,880 self-play games** from random
init, PPO + adaptive entropy, league opponents every 25 iters. This is ~3x the
games of any grid arm (85 x 96 = 8,160).

60 colour-balanced games per cell, steps=4:

| opponent | adjudicate=material | adjudicate=none |
|---|---|---|
| random_legal | 0.858 [0.75,0.92] (44-15-1) | 0.508 [0.39,0.63] (1-59-0) |
| material_greedy | **0.817** [0.70,0.89] (40-18-2) | 0.500 [0.38,0.62] (1-58-1) |

Head-to-head against the best grid checkpoints (adjudicate=material):

| match | score | CI95 | Elo |
|---|---|---|---|
| main vs grid router_s0 | **0.758** | [0.64, 0.85] | **+199** |
| main vs grid baseline_s0 | **0.792** | [0.67, 0.88] | **+232** |

### Two conclusions, pulling in opposite directions

**Positive (MEASURED): self-play scale is the dominant factor.** The main run
beats every grid arm decisively — +199 Elo over `router_s0`, which was the
grid's best. 3x more games produced a larger, cleaner improvement than any
architectural feature in the 9-arm grid, where the entire credible spread was
~0.10 in score. **Games >> features, at this scale.**

**Negative (MEASURED): more training did not fix conversion.** Played out with
`adjudicate=none`, the strongest model in the project scores **0.500 against the
one-ply material heuristic with 58 of 60 games drawn**, and 0.508 vs random-legal
with 59 of 60 drawn. It wins on adjudicated material and then cannot finish.

This is the same failure documented earlier on weaker checkpoints, now confirmed
at ~27,000 games. **Scaling self-play from ~8,000 to ~27,000 games improved
material acquisition but produced no measurable improvement in checkmate
conversion.** The limitation is therefore unlikely to be "insufficient self-play"
alone.

**HYPOTHESISED causes, none yet tested:** (a) outcome-only reward with material
adjudication never pays for mate, so there is no gradient toward converting;
(b) 4 recurrent steps may be too little to represent a mating net; (c) the
value head learns material, and the policy follows the value head. Distinguishing
these is the single most valuable next experiment, and the `adjudicate=none`
reward ablation is the cheapest probe.


### Does extra inference depth fix conversion? Partly, but it also causes more stalemates

Artifact: `runs/conversion_vs_depth.json`. Main checkpoint (105 iters), weights
fixed, step cap lifted, `adjudicate=none`, 30 games vs random-legal, 400-ply cap.

| steps | model mates | stalemates | score | dominant terminations |
|---:|---:|---:|---:|---|
| 1 | 0 | 6 | 0.500 | repetition 18 |
| 2 | 2 | 5 | 0.500 | repetition 18 |
| 4 | 1 | 12 | 0.517 | stalemate 12, repetition 12 |
| **8** | **6** | 11 | **0.583** | checkmate 7, stalemate 11 |
| 16 | 3 | **18** | 0.550 | **stalemate 18** |

**MEASURED:** deeper inference does improve conversion — 0 mates at depth 1 vs 6
at depth 8, and the best playing-out score is also at depth 8 (0.583). This is
the inverted-U again, now visible in a *termination-level* metric rather than an
adjudicated score, which is stronger evidence that the depth effect is real.

**But the failure mode is not cured, it is transformed.** Stalemates rise
monotonically with depth (6 -> 5 -> 12 -> 11 -> **18**), and at depth 16 the
model stalemates its opponent in 60% of games. The model uses extra computation
to press its material advantage into the opponent's king, and then traps it
without check.

**Conclusion (MEASURED): inference-time compute improves conversion but cannot
substitute for the missing training signal.** Even at its best depth the model
converts only 6 of 30 winnable positions. This supports the reward-shaping
hypothesis over the pure-compute hypothesis, and motivates the `adjudicate=none`
training ablation now running.


### Reward-shaping ablation (RUNNING): `adjudicate=none` vs `adjudicate=material`

4 jobs: baseline config, 60 iters x 96 games, max 200 plies, seeds 0/1, arms
`none` and `material`, outputs `runs/adj/{arm}_s{seed}`.

**Iteration-0 contrast already shows the mechanism under test (MEASURED):**

| arm | decisive rate | adjudicated games | max_plies games | mates |
|---|---:|---:|---:|---:|
| `adjudicate=none` | **0.07** | 0 | 88/96 | 7 |
| `adjudicate=material` | **0.84** | 74/96 | 14 | 7 |

With material adjudication the model receives a decisive outcome in 84% of games;
without it, only 7% — a **12x sparser reward signal**, with 88 of 96 games hitting
the ply cap as draws.

This quantifies the suspected cause of the conversion failure: under the default
protocol, nearly all training signal comes from *material adjudication*, so the
policy is rewarded for acquiring material and essentially never for delivering
mate. The ablation tests whether removing that crutch forces conversion to be
learned, or simply starves the run of gradient. **Both outcomes are informative
and both will be reported.** Prediction is deliberately not recorded as a result.


### Early ablation result: low value-MAE can be a DEGENERATE solution (MEASURED)

Two iterations in, the two arms look like this:

| arm | draw rate | decisive rate | **value MAE** | mean plies | move diversity |
|---|---:|---:|---:|---:|---:|
| `adjudicate=none` | **0.969** | 0.031 | **0.0439** | 196 | 0.086 |
| `adjudicate=material` | 0.177 | 0.823 | 0.7145 | 193 | 0.093 |

**The `none` arm has a 16x lower value-head error than the `material` arm — and
this is worthless.** 96.9% of its games are draws, so a value head that outputs
"draw" for every position is almost always right. The low MAE measures the
degeneracy of the outcome distribution, not the quality of the value function.

**This is a concrete vindication of the standing rule that strength claims must
come from playing results, never from training metrics.** Had the arms been
ranked by value MAE — a natural-looking choice — `adjudicate=none` would have
been declared a massive improvement when it is in fact a reward-signal collapse.

The earlier grid observation that all nine arms had near-identical value MAE
(0.450-0.537) should be read the same way: that spread carried essentially no
information about playing strength, and the head-to-head results confirmed it.

**Status: the ablation continues.** Whether the `none` arm eventually escapes the
all-draw regime and learns conversion, or stays starved of gradient, is not yet
known and is not being predicted here.


### Phase 11 re-run at a genuinely lifted depth (8 steps, router_s0)

Artifact: `runs/precision_router_s8.json`. The original Phase 11 run requested 6
steps and silently got 4 (clamp bug). This re-run lifts the cap to a true 8 steps
on a well-trained grid checkpoint.

| quantity | original (effective 4 steps) | re-run (true 8 steps, router_s0) |
|---|---|---|
| activations int4 | top1 **1.000** | top1 **0.969** |
| activations int3 | 0.979 | 0.906 |
| activations int2 | 0.813 | 0.625 |
| weights int8 | 1.000 | **1.000** |
| weights int4 | 0.938 | 0.844 |
| weights int3 | 0.688 | 0.828 |
| weights int2 | 0.062 | 0.359 |
| step-dependent (int3 early -> fp32 late) | 1.000 | 0.922 |
| position-dependent easy vs hard @int3 | 1.000 vs 0.958 | **0.938 vs 0.875** |

**Qualitative conclusions all replicate (MEASURED):**

1. **Activations tolerate low precision better than weights.** int8 weights are
   lossless (1.000) while int4 weights lose 16 points; activations survive int4
   at 0.969.
2. **Position-dependent precision is justified:** cheap precision hurts hard
   positions more than easy ones (0.938 easy vs 0.875 hard at int3), reproducing
   the original direction on a different checkpoint and a different depth.
3. **Operation-dependent precision is viable:** keeping attention precise while
   quantising local mixing gives top1 **1.000**.

**Quantitative values are all lower at 8 steps than at 4** — quantisation error
compounds across recurrent iterations, which is expected for a weight-shared core
and is a new observation enabled by fixing the clamp. **The original Phase 11
numbers should be read as 4-step figures**, as noted in the blast-radius audit.

**NEGATIVE RESULT retained:** fake quantisation still yields no CPU speedup
(336-345 ms across all activation precisions vs fp32 reference). Any throughput
claim would require real INT kernels.


---

## Reward-shaping ablation COMPLETE: `adjudicate=none` does NOT fix conversion (NEGATIVE, FALSIFIED)

**Hypothesis (H-conv-1):** the conversion failure is caused by material
adjudication. Under `adjudicate=material` the policy is paid for acquiring
material and essentially never for delivering mate, so removing adjudication
should force conversion to be learned.

**Design:** baseline config, 60 iters x 96 games, max 200 plies, seeds 0 and 1,
two arms (`adjudicate=none` vs `adjudicate=material`), everything else identical.
Artifacts `runs/adj/*`, evaluation `runs/adj_conversion.json`. Evaluation always
with `adjudicate=none`, 400-ply cap, 40 games per cell, so only *real* results count.

### Result: no effect on conversion

Pooled over 2 seeds (80 games per cell):

| training reward | opponent | score | CI95 | **mates** | stalemates |
|---|---|---:|---|---:|---:|
| `none` | random | 0.581 | [0.472, 0.683] | 14/80 | 17 |
| `material` | random | 0.550 | [0.441, 0.654] | 9/80 | 16 |
| `none` | material | 0.444 | [0.340, 0.553] | **1/80** | 33 |
| `material` | material | 0.463 | [0.357, 0.571] | **1/80** | 7 |

**Every CI overlaps its control.** Against the material heuristic both arms
convert **1 game in 80**. Removing material adjudication did not teach conversion.

### The seed dominates the treatment

| | seed 0 | seed 1 |
|---|---:|---:|
| trained `none` | 4 mates | **11 mates** |
| trained `material` | 2 mates | **8 mates** |

Seed 1 produces ~3x the mates of seed 0 *in both arms*. The between-seed
difference is larger than the between-treatment difference, so a 2-seed design
cannot resolve this effect even if one existed. **H-conv-1 is falsified.**

### Side effect worth recording

Training without adjudication **increased** stalemates against the material
opponent (33 vs 7 per 80). Starving the reward did not produce cleaner wins; it
produced more botched endings. Combined with the 12x sparser decisive signal
(0.07 vs 0.84 decisive rate at iteration 0) and the degenerate value head
(MAE 0.035-0.051 from a ~94% draw rate), `adjudicate=none` is **worse as a
training signal**, not better.

### Revised interpretation

The conversion failure is **not** primarily a reward-shaping artifact. Remaining
candidate explanations, now the active hypotheses:

- **H-conv-2 (representation/credit assignment):** outcome-only returns spread
  over ~200-ply games give almost no credit to the specific mating sequence.
  A mate is 1-2 plies of a 200-ply trajectory.
- **H-conv-3 (capability):** delivering mate requires coordinating multiple
  pieces against an evading king — plausibly beyond a 4-step, ~80K-param policy.
- **H-conv-4 (exploration):** mating nets are rare under temperature sampling, so
  the policy may never sample enough of them to learn from.

H-conv-2 and H-conv-4 are testable cheaply with a mate-position curriculum: if
the model *can* learn mate when positions start near-mate, capability (H-conv-3)
is ruled out and credit assignment/exploration is implicated.


---

## Conversion investigation: the VALUE head is fine; the failure is in the POLICY

**Hypothesis (H-conv-5):** the model cannot convert because its value head does
not recognise winning positions, leaving the policy with no signal to steer
toward mate.

**Design:** bucket random positions by material from the side-to-move's view
(crushing >= +6, even |m| <= 1, lost <= -6), 40 positions each, and read the
value head directly. Two checkpoints.

| bucket | main (170 iters) | router_s0 (85 iters) |
|---|---|---|
| crushing (+6 or more) | **+0.5148** (std 0.149) | **+0.5091** (std 0.132) |
| even | +0.0580 (std 0.125) | -0.0296 (std 0.096) |
| lost (-6 or worse) | **-0.3900** (std 0.179) | -0.3813 (std 0.191) |

**H-conv-5 is FALSIFIED (MEASURED).** The value head separates the three buckets
cleanly and in the correct order, on both checkpoints, with a ~0.9 spread between
crushing and lost and non-overlapping means at these sample sizes.

**This substantially narrows the diagnosis.** The model:

- correctly *evaluates* that it is winning (value +0.51 when up 6+ material), and
- reliably *acquires* material (0.817 vs the material heuristic under adjudication),
- yet converts ~1 game in 80 into checkmate when games are played out.

So the deficit is not evaluation and not material acquisition. It is the
**policy's ability to execute a mating sequence**, which is exactly the
capability-vs-credit-assignment question now being tested by
`experiments/exp_mate_capability.py`.

**Note on why this matters methodologically:** the value head is *well
calibrated on material* — which is also what it is trained on, given that
material adjudication supplies ~84% of decisive outcomes. A value head that has
learned "material = winning" will happily report +0.5 in a position the policy
cannot actually win. **Value calibration against material is not evidence of
value calibration against game outcome**, and the two have been conflated in
earlier readings of `tr_value_mae`.


---

## MATE BLINDNESS: the strongest model cannot see mate-in-1 (MEASURED, and it inverts the strength ranking)

**Hypothesis (H-conv-3):** the conversion failure is a capability limit — the
policy cannot execute a mating net.

**Design:** generate 150 positions with a verified mate-in-1 available to the
side to move (exhaustive legal-move search used ONLY to label test positions —
never as a training target and never to pick the model's move). Ask each
checkpoint for its top legal move and check whether it delivers mate. Evaluate at
recurrent depths 1/2/4/8/16, weights fixed. **Control: a uniformly random legal
move**, which is the chance rate for this suite.

Suite: 150 positions from 180,585 random walks, mean **27.1 legal moves**.
**Random-legal control: 7/150 = 0.047.**

| model | params | d=1 | d=2 | d=4 | d=8 | d=16 |
|---|---:|---:|---:|---:|---:|---:|
| **main** (170 iters, strongest) | 80,398 | 0.040 | 0.047 | 0.060 | 0.073 | 0.067 |
| router_s0 | 80,785 | 0.107 | 0.100 | 0.113 | 0.133 | **0.153** |
| baseline_s0 | 80,398 | 0.060 | 0.073 | 0.080 | 0.127 | 0.127 |
| mlp_s0 | 103,730 | 0.147 | 0.147 | 0.147 | 0.147 | 0.147 |

Two-proportion z-test against the random control:

| model | depth | acc | z | significant |
|---|---|---:|---:|---|
| main | 1 | 0.040 | **-0.28** | no |
| main | 4 | 0.060 | +0.51 | no |
| main | 16 | 0.067 | +0.75 | **no** |
| router_s0 | 4 | 0.113 | +2.13 | yes |
| router_s0 | 16 | 0.153 | +3.08 | yes |
| baseline_s0 | 16 | 0.127 | +2.46 | yes |
| mlp_s0 | any | 0.147 | +2.93 | yes |

### Findings

1. **The best-playing model is indistinguishable from random at mate-in-1.**
   `main` — which beats the material heuristic 0.817 and beats the best grid arm
   by +199 Elo — never separates from chance at any depth (max z = +0.75).
   **H-conv-3 is SUPPORTED for the strongest model: it is mate-blind.**

2. **The ranking INVERTS relative to playing strength.** `mlp_s0` is the *worst*
   arm in head-to-head play (3 credible losses, last vs material) yet has the
   best mate-in-1 accuracy (0.147). `main` is the strongest player and the worst
   mate-solver. Playing strength in this system is **anti-correlated** with
   tactical mate detection.

3. **Depth helps mate detection where the model has any signal at all.**
   `router_s0` improves 0.107 -> 0.153 from d=1 to d=16 and `baseline_s0`
   0.060 -> 0.127, but `main` stays flat. Extra computation can only amplify a
   capability that exists.

4. **`mlp_s0` is perfectly flat across depth (0.147 at every depth)** — exactly
   as expected for a non-recurrent architecture. This is a clean internal
   validity check that the depth axis is being applied correctly.

### Revised interpretation (this changes the project's model of what is happening)

Extended self-play did not make the model better at chess in a general sense. It
made it better at **the adjudicated-material game it was actually trained on**,
and in doing so it appears to have *lost* whatever weak mate-detection the
shorter runs had. This is consistent with the reward analysis: ~84% of decisive
training outcomes come from material adjudication, so the gradient overwhelmingly
rewards material acquisition, and mate is a rare, low-credit event.

**This reframes the conversion failure.** It is not that the model wins material
and then fails to find the mating move under pressure — it is that the model has
**no mate-detection capability to deploy**, and more of the current training
signal makes this worse, not better.

**Active hypotheses now:**
- **H-conv-6 (reward dilution):** mate-blindness is caused by material
  adjudication dominating the return. Note this is *not* the same as the
  falsified H-conv-1: removing adjudication starved the signal entirely
  (96.9% draws), whereas the right test is a reward that keeps dense material
  feedback but *adds* an explicit terminal bonus for mate.
- **H-conv-7 (horizon):** a 4-step recurrent core with no search cannot
  represent "this move ends the game" because the mate condition is a property
  of the *resulting* position, which the model never encodes.

H-conv-7 is directly testable and cheap: the encoder sees only the current
board, so mate-in-1 detection requires simulating each candidate move internally.

---

## H-conv-7: is mate blindness caused by the move representation? (MEASURED — PARTIALLY FALSIFIED)

`pack_move` encodes from_sq/to_sq/promo/piece/capture/castle/ep and has **no
`gives_check` bit**. Hypothesis: mate-in-1 is undetectable because the move
representation lacks any "what does this do to the enemy king" information.

Test (`experiments/exp_check_feature.py`, artifact `runs/check_feature_probe.json`):
train a small probe to predict `is_checkmate` for each legal move, using only
mechanical features the rules engine already computes. No model weights involved
— this measures the **representation**, not the trained policy. 400 train / 200
test positions per seed, 3 seeds, 50% of positions contain a mate-in-1
(enrichment needed: uniform random positions gave only 1–4 positives per test
set and unusable variance). `top1` = per-position, over positions that contain a
mate, does the probe's highest-scoring legal move deliver mate. Directly
comparable to the model's mate-in-1 solve rate. **Random-legal control = 0.047.**

| probe level | features | AUC | top-1 |
|---|---|---:|---:|
| A `current_encoding` | what the model already sees (+ file/rank deltas) | 0.8007 ± 0.0261 | **0.2300 ± 0.0283** |
| B `plus_gives_check` | A + `gives_check` | 0.9750 ± 0.0012 | 0.4300 ± 0.0294 |
| C `plus_check_and_replycount` | B + opponent reply count after the move | **0.9993 ± 0.0004** | **0.9767 ± 0.0205** |

**Findings:**

1. **H-conv-7 is PARTIALLY FALSIFIED.** The current move encoding is *not*
   information-free about mate: probe A reaches top-1 **0.23**, ~5× the random
   control (0.047) and ~3–6× what the trained models actually achieve
   (main 0.040–0.073, best arm router_s0 0.153). **The representation already
   supports several times more mate detection than any trained model extracts.**
   Adding a `gives_check` bit would therefore be treating a symptom.
2. **A single `gives_check` bit is worth a lot but is not sufficient** (0.23 →
   0.43 top-1). Mate is "check **and** no legal reply"; check alone cannot
   distinguish mate from an ordinary check.
3. **The decisive feature is the opponent's reply count** (0.43 → 0.98). This is
   exactly the one-ply lookahead quantity the model has no access to: it is a
   property of the *resulting* position, and the encoder only ever sees the
   *current* board.
4. Consequently the failure decomposes into two independent deficits:
   a **readout deficit** (0.047 achieved vs 0.23 available from current
   features) and a **lookahead deficit** (0.23 available now vs 0.98 with a
   one-ply reply count).

**This reframes the fix.** Adding a `gives_check` field to `pack_move` is *not*
the highest-value change, and it edges toward hard-coding chess knowledge into
the representation. The prior question is why the trained policy extracts only
0.047 when 0.23 is linearly available. Successor hypotheses:

- **H-conv-8** — the model's internal features *do* encode "this move mates",
  but the trained readout (`z · cand`) does not weight that direction, because
  self-play reward never paid for mate (adjudication ends games first).
  => a **training-signal** problem, no architecture change needed.
- **H-conv-9** — the internal features do not encode it at all => a capacity or
  architecture problem.

Discriminated by `experiments/exp_mate_readout.py`: freeze the model, extract its
own `z` and per-candidate `cand` vectors, and refit (a) a bilinear form — the
same function class as the model's own readout — and (b) an MLP, to predict
mate. If the refit bilinear probe greatly exceeds the model's own logits, the
representation is adequate and the *learned weighting* is the fault (H-conv-8).

Status: `exp_check_feature.py` MEASURED; `exp_mate_readout.py` RUNNING.

---

## H-conv-8 CONFIRMED: mate blindness is a READOUT/TRAINING-SIGNAL failure, not a representation failure (MEASURED)

`experiments/exp_mate_readout.py` → `runs/mate_readout.json`. The model is
**frozen**. We extract its own internal vectors for each legal candidate — the
global move-intent vector `z` and the per-candidate vector `cand` (=
`move_emb(fields) + sq_to_move[from] + sq_to_move[to]`) — i.e. exactly the two
things the model's own scorer consumes, since its policy is the bilinear form
`logits = z · cand`. We then compare the model's *own* logits against a refit
bilinear form (same function class, retrained for mate) and an MLP. 400 train /
200 test positions per seed, 3 seeds, labels from the rules engine only.

| model | readout | AUC | top-1 |
|---|---|---:|---:|
| main | **its own logits** | **0.449 ± 0.014** | 0.050 ± 0.008 |
| main | refit bilinear on its own frozen features | **0.810 ± 0.018** | 0.177 ± 0.013 |
| main | refit MLP on its own frozen features | 0.771 ± 0.019 | 0.180 ± 0.000 |
| router_s0 | its own logits | 0.620 ± 0.033 | 0.100 ± 0.008 |
| router_s0 | refit bilinear | 0.793 ± 0.033 | 0.160 ± 0.042 |
| router_s0 | refit MLP | 0.778 ± 0.035 | 0.213 ± 0.053 |

(random-legal control top-1 = 0.047; raw-feature probe A = 0.230)

**Findings:**

1. **H-conv-8 CONFIRMED, H-conv-9 falsified.** `main`'s own logits score
   **AUC 0.449 — statistically *below* chance (0.5)**, while a bilinear form
   over its *own frozen features* reaches **0.810**. The information needed to
   rank mating moves first is already present inside the trained network. The
   network simply does not use it. **The deficit is in the learned weighting,
   not in the features and not in the capacity.**
2. **The refit MLP does not beat the refit bilinear** (0.771 vs 0.810 for main).
   The model's existing bilinear readout is a sufficiently expressive function
   class. Nothing is gained by a richer scorer head.
3. Refit performance (0.81 AUC / ~0.18 top-1) lands close to the raw-feature
   ceiling of probe A (0.80 AUC / 0.23 top-1). The encoder preserves roughly all
   the mate-relevant signal that was available in the input; it neither adds
   lookahead nor destroys much.

### Mechanism: the policy has learned an anti-check prior

Per-move policy percentile on the same 200-position suite
(`runs/move_class_bias.json`, 7,297 legal moves, 110 mating moves):

| model | capture | non-capture | **check** | non-check | mate | **quiet mate** |
|---|---:|---:|---:|---:|---:|---:|
| main | 0.858 | 0.440 | **0.389** | 0.510 | 0.462 | **0.234** |
| router_s0 | 0.925 | 0.429 | 0.539 | 0.497 | 0.651 | 0.480 |
| adj_material_s0 | 0.877 | 0.437 | 0.448 | 0.504 | 0.512 | 0.295 |
| adj_none_s0 | 0.781 | 0.453 | 0.539 | 0.497 | 0.607 | 0.446 |
| adj_material_s1 | 0.770 | 0.455 | 0.609 | 0.491 | 0.685 | 0.571 |
| adj_none_s1 | 0.751 | 0.458 | 0.573 | 0.494 | 0.549 | 0.467 |

- `main`, the strongest player, ranks **checking moves at the 0.389 percentile —
  actively *below* the average legal move**, and **quiet (non-capturing) mates at
  0.234**, i.e. in the bottom quartile of its own move ordering. It is not
  failing to find mates; it is **ranking them down**.
- Mating moves only survive at all when they happen to be captures: `main` scores
  mating-captures at 0.846 but quiet mates at 0.234. 37.3% of mates are captures
  vs 14.4% of all moves, so the apparent near-chance mate rate is almost entirely
  carried by the capture prior, not by any mate detection.
- Across the 6 checkpoints, **r(check_bias, mate percentile) = +0.855**, while
  **r(capture_bias, mate percentile) = −0.172**. What predicts mate ability is
  whether the model likes giving check — not how much it likes material.

**Why this happens, and why it explains the inverted ranking.** Under material
adjudication, a long game that is stopped and scored on material rewards
accumulating material and punishes speculative checks, which usually give away
tempo/material when they do not mate. Self-play therefore trains an explicitly
*anti-check* prior, and the more training a model receives the stronger that
prior becomes. This resolves the paradox recorded in the MATE BLINDNESS section:
playing strength is anti-correlated with mate detection because **the very
gradient that produces playing strength also suppresses checks.** `main`
(most training) has the most negative check bias (−0.121) and the worst mate
rate; the lightly-trained 60-iteration `adj_*` arms all have less negative or
positive check bias and detect mates better.

**Consistency with the falsified H-conv-1.** Removing material adjudication
(`adjudicate=none`) *does* move the check bias in the predicted direction
(s0: −0.057 → +0.043) — the mechanism is real — but at 60 iterations this did
not translate into more converted wins, because the 12× sparser reward left the
arm too weak overall and it produced *more* stalemates. The reward change
addresses the right variable but is not sufficient on its own.

**Implication for the fix.** Do **not** add a `gives_check` bit to `pack_move`
(H-conv-6/7): probe A shows the information is already there, the refit-bilinear
result shows the readout can already express it, and hard-coding it would inject
chess knowledge the project's constraints forbid. The binding constraint is that
**terminal outcomes are too rare in the training signal for the policy to learn
that check-with-no-reply is terminal**. Candidate interventions, to be tested as
controlled ablations:
- **H-conv-10** — keep material adjudication for the *value* target but make the
  *policy* loss see true terminal states (train longer with `adjudicate=none`
  rather than 60 iterations, or adjudicate only after a much longer ply cap).
- **H-conv-11** — the terminal-state credit is diluted because a mate at ply 150
  is one sample among ~150; test a terminal-proximity weighting of the policy
  loss (no chess knowledge: weight by distance to game end, not by "is check").

Status: `exp_mate_readout.py` MEASURED; move-class bias MEASURED; H-conv-8
CONFIRMED; H-conv-9 FALSIFIED; H-conv-6/H-conv-7 fix path REJECTED on evidence.

---

## Causal intervention on the check prior (MEASURED — mechanism CONFIRMED, fix NOT sufficient)

The +0.855 correlation between check bias and mate ability is observational.
`experiments/exp_check_intervention.py` is the intervention: freeze the model and
add one scalar to the logit of every checking move at inference,
`logits' = logits + alpha * 1[gives check]`. Nothing is trained; no chess
knowledge enters the weights or `pack_move`. 150 rules-engine-verified mate-in-1
positions; games vs MaterialAgent at `adjudicate=none`, 400-ply cap, 60 games.
Artifacts: `runs/check_intervention.json`, `runs/check_intervention_control.json`.

| alpha | mate-in-1 top-1 (`main`) | score vs material | W/D/L | mates for | stalemates |
|---:|---:|---:|---|---:|---:|
| 0 | 0.040 | 0.392 | 3/41/16 | 3 | 4 |
| 0.5 | 0.067 | — | | | |
| 1 | 0.080 | 0.467 | 8/40/12 | **8** | 2 |
| 2 | 0.100 | 0.467 | 4/48/8 | 4 | 2 |
| 4 | 0.207 | 0.467 | 2/52/6 | 2 | 1 |
| 8 | 0.413 | 0.408 | 2/45/13 | 2 | 0 |
| 16 | **0.473** | — | | | |

**Required control.** A uniform bonus on *all* checks does not require the model
to know which check mates, so the headline 0.040 → 0.473 must be compared
against simply playing a **uniformly random checking move**:

| condition | mate-in-1 top-1 |
|---|---:|
| random legal move | 0.047 |
| `main`, unmodified | **0.040** |
| **uniformly random *checking* move** | **0.380** |
| `main`, checks forced (alpha→inf, model ranks within checks) | 0.473 |
| `router_s0`, unmodified | 0.100 |
| `router_s0`, checks forced | 0.453 |

(mean 4.5 checking moves available per position)

**Findings:**

1. **The mechanism is causally confirmed, and it is worse than "blindness".**
   The unmodified strongest model scores **0.040 — below the 0.047 random-legal
   control and a full 0.34 below the trivial random-check policy (0.380)**. A
   model that picked checks at random would be ~9× better at mate-in-1. The
   anti-check prior is not a missing capability, it is an **actively harmful
   learned bias**, and it alone accounts for essentially the entire mate-in-1
   deficit.
2. **But the model has almost no discrimination *within* checks.** Forcing
   checks and letting the model rank among them gives 0.473 vs 0.380 for
   choosing a check at random: **z = +1.63, not significant** (`router_s0`
   z = +1.29, ns). So the model cannot meaningfully tell a mating check from a
   harmless one. Correcting the prior recovers the easy part of the gap; the
   remaining "which check actually mates" capability is genuinely absent, which
   is consistent with the probe result that the decisive feature is the
   opponent's reply count — a property of the *resulting* position the model
   never sees.
3. **Fixing the check prior does NOT fix conversion.** This is the important
   negative. Despite mate-in-1 improving 12×, score vs MaterialAgent stays flat
   at ~0.39–0.47 across every alpha, and converted mates peak at 8/60 (alpha=1)
   then *fall* to 2/60 as alpha rises and the model starts throwing material at
   spite checks. Stalemates drop monotonically (4 → 0), so the intervention is
   doing something real, but **mate-in-1 ability is not the bottleneck for
   converting won games.** A tactic solved in a constructed position does not
   transfer to steering a full game into that position.

**Conclusion.** H-conv-8 is confirmed as the explanation of *mate blindness*
(the anti-check prior, learned from material adjudication, is the cause), and it
is simultaneously shown to be **insufficient as an explanation of the conversion
failure**. These are two different problems. Conversion requires reaching mating
positions, not only recognising them. The conversion failure therefore remains
open, and the reward-signal hypotheses (H-conv-10 terminal-state training,
H-conv-11 terminal-proximity credit weighting) remain the live candidates —
now with the added constraint that any fix must be validated on *game outcomes*,
not on tactic suites, because this experiment demonstrates the two dissociate.

Status: MEASURED. Mechanism CONFIRMED; proposed fix REJECTED as insufficient on
its own evidence. The alpha-biased model is a diagnostic only and is never
reported as a strength result.

### H-conv-11 implemented (IMPLEMENTED — not yet run)

`train_selfplay.py` gains `--terminal-weight G` / `--terminal-tau TAU`
(default 0 = off, behaviour bit-identical to all previous runs). Samples are
up-weighted in the **policy loss only** by
`w = 1 + G * exp(-(n_plies - 1 - ply) / TAU)`, renormalised to mean 1 so the loss
scale is unchanged. `Sample` gained `n_plies` to make distance-to-termination
available. Rationale: a mate at ply 150 is one sample among ~150, so the moves
that actually caused the terminal state get the same credit as opening moves.
The weight depends only on distance to game end — **no chess knowledge, no
check/mate feature** — which is what distinguishes it from the rejected
H-conv-6/7 fix path.

Verified: value loss and entropy are computed on the unweighted mask, so this is
a policy-only intervention (asserted in a unit test); `--terminal-weight 0`
reproduces the old `l_pi` exactly; a 2-iteration run logs `tr_terminal_w_max`
≈ 3.5–3.7 at G=4, TAU=10. Phase-1 gate **12/12**.

Incidental fix: `tests/test_phase1.py::test_local_mixing_matches_reference` was
failing because `ray_gate` initialises to exactly 0 and ray terms are scaled by
`tanh(ray_gate)`, so `d(out)/d(ray_decay)` is legitimately 0 *at the init point*.
Not a broken graph: perturbing the gate restores a gradient of 5.56, and trained
checkpoints show `ray_decay` has moved well off its 0 init (`main`: |ray_gate|
sum 6.52, |ray_decay| sum 1.53). The test now perturbs off that measure-zero
point before asserting. This was a pre-existing false alarm, not a regression.

Next: run H-conv-10 (`adjudicate=none`, long) and H-conv-11 (terminal weighting)
as a controlled 2×2 against the material/G=0 control, and judge them on
**converted mates in real games**, not on mate-in-1 suites — the intervention
experiment above showed those two dissociate.

---

## CONVERSION ISOLATED: the model cannot win K+Q vs K (MEASURED — headline negative)

`experiments/exp_endgame_conversion.py` → `runs/endgame_conversion.json`.
Everything else is stripped away: the model is handed positions that are already
trivially won, with a lone enemy king and zero counterplay, and asked only
whether it can deliver mate. 50 random legal positions per suite, 160-ply cap,
defender = lone king playing the reply that **maximises its own mobility**
(hardest case). Controls: random-legal mover and MaterialAgent on identical
positions. "edge" = mean distance of the defending king from the board edge
(0 = on the edge/mate-able, 3 = centre); progress > 0 means the king is being
driven outward.

| suite | agent | mated | stalemate | rep/50-move | edge start→end | progress |
|---|---|---:|---:|---:|---|---:|
| KQvK | random | 0.00 | 0.02 | 0.78 | 0.96→0.68 | +0.28 |
| KQvK | material | 0.10 | 0.10 | 0.64 | 0.96→0.62 | +0.34 |
| KQvK | **main** | **0.00** | 0.00 | **1.00** | 0.96→0.96 | **+0.00** |
| KQvK | router_s0 | 0.00 | 0.00 | 1.00 | 0.96→0.88 | +0.08 |
| KRvK | random | 0.00 | 0.00 | 0.98 | 1.14→0.96 | +0.18 |
| KRvK | material | 0.04 | 0.00 | 0.96 | 1.14→1.04 | +0.10 |
| KRvK | **main** | 0.00 | 0.00 | 1.00 | 1.14→0.78 | +0.36 |
| KRRvK | random | 0.04 | 0.04 | 0.86 | 1.00→0.92 | +0.08 |
| KRRvK | **material** | **0.74** | 0.00 | 0.22 | 1.00→0.30 | **+0.70** |
| KRRvK | **main** | **0.00** | 0.02 | 0.98 | 1.00→1.18 | **−0.18** |
| KRRvK | router_s0 | 0.00 | 0.00 | 1.00 | 1.00→1.06 | −0.06 |
| KQRvK | random | 0.10 | 0.28 | 0.46 | 0.82→0.56 | +0.26 |
| KQRvK | **material** | **0.86** | 0.02 | 0.10 | 0.82→0.16 | **+0.66** |
| KQRvK | **main** | **0.02** | 0.02 | 0.96 | 0.82→1.08 | **−0.26** |
| KQRvK | router_s0 | 0.00 | 0.02 | 0.98 | 0.82→0.96 | −0.14 |

**Required control — is 100% repetition just argmax determinism?** No.
Re-run with temperature sampling (`runs/endgame_temperature_control.json`):

| suite | T=0 | T=0.3 | T=0.7 | T=1.0 |
|---|---|---|---|---|
| KQvK mated | 0.00 | 0.00 | 0.02 | 0.00 |
| KQvK rep/50 | 1.00 | 1.00 | 0.96 | 0.98 |
| KQRvK mated | 0.00 | 0.04 | 0.00 | 0.04 |
| KQRvK stalemate | 0.04 | 0.08 | 0.18 | **0.24** |

Stochasticity does not rescue conversion; it converts repetitions into
**stalemates** (KQRvK 0.04 → 0.24). The draw is a property of the policy, not of
tie-breaking.

**Findings:**

1. **The strongest model converts K+Q vs K at a rate of 0.00, and K+Q+R vs K at
   0.02 — worse than a random legal mover (0.00 / 0.10) and ~40× worse than the
   trivial material heuristic (0.10 / 0.86).** This is the clearest negative
   result in the project.
2. **With more material it gets actively worse.** On KRRvK and KQRvK, `main`'s
   edge-progress is **negative** (−0.18, −0.26): it drives the enemy king *back
   toward the centre*. MaterialAgent, with no search and no learning, scores
   +0.70/+0.66 and mates 74–86% of the time. The deficit is not subtle.
3. **The failure mode is repetition, at 0.96–1.00 across every suite.** The model
   shuffles. Combined with the earlier value-head probe (which reports +0.51,
   "I am winning", in exactly these positions), the picture is: **the model knows
   it is winning, and has no policy for making progress.**
4. This **rules out the remaining innocent explanations** for the conversion
   failure. It is not an inability to reach winning positions (they were handed
   over), not mate-in-1 blindness (confirmed separately to dissociate), and not
   miscalibrated evaluation (H-conv-5 falsified). It is an inability to make
   progress in a won position.

**Why self-play + material adjudication produces exactly this.** A game stopped
at the ply cap and scored on material gives an identical reward for mating on
move 20 and for shuffling a queen for 160 plies. Shuffling is strictly safer: it
never hangs material and never stalemates. The training signal therefore has
**no gradient toward termination at all**, and the optimal policy under it is
precisely the one observed — hold material, avoid risk, never finish. The
anti-check prior (r = +0.855 with mate blindness) is one visible symptom of the
same root cause.

This makes H-conv-10/11 the correct and now well-motivated next test, and it
supplies the metric they must be judged on: **KQvK/KQRvK conversion rate and
edge-progress**, which are fast, unambiguous, and have a known-good reference
(MaterialAgent 0.86) and a floor (random 0.10). Note the target to beat is the
*heuristic*, not zero.

Status: MEASURED. Suites, controls and temperature control all recorded.

---

## H-conv-10/11/12 tested: reward-signal fixes do NOT fix conversion (MEASURED — NEGATIVE)

The endgame result above showed the reward contains **no gradient toward
termination**: `outcome_to_z` returns ±1 with **no ply discounting anywhere in
the codebase** (verified by grep: the only `gamma`/`discount` hit is the new
code), so mating on move 20 and an adjudicated material win at ply 200 earn
*identical* reward, while shuffling is strictly safer. Two interventions were
implemented and tested against a matched control.

**H-conv-12 `--win-discount GAMMA`** (new, `tinychess/replay.py`):
`z_t = outcome * gamma^(plies_remaining)`. Standard RL discounting on the game
outcome — encodes "win sooner", contains no chess knowledge, says nothing about
checks, mates or material. Unit-verified: `gamma=1.0` is bit-identical to all
previous runs, draws stay exactly 0, and a 10-ply win is worth 0.914 at ply 0
versus 0.370 for a 100-ply win.

**H-conv-11 `--terminal-weight`**: policy-loss-only credit weighting by distance
to game end (value loss and entropy use the unweighted mask).

Controlled 3-arm run, `config=baseline`, 50 iters, 24 games/iter, seed 0,
identical in every other respect. Evaluated on the isolated conversion suites
(50 positions, 160-ply cap, mobility-maximising lone king):

| arm | gamma | term-w | KQvK mated | KQvK progress | KQRvK mated | KQRvK progress |
|---|---:|---:|---:|---:|---:|---:|
| ctrl | 1.0 | 0 | 0.00 | −0.24 | 0.00 | −0.02 |
| disc | 0.99 | 0 | 0.00 | −0.16 | 0.00 | +0.06 |
| both | 0.99 | 4 | 0.00 | −0.20 | 0.00 | −0.10 |
| *random* | — | — | *0.02* | *+0.26* | *0.08* | *+0.12* |
| *material* | — | — | *0.06* | *−0.02* | **0.74** | **+0.60** |

**All three arms convert 0.00 on both suites — still below the random-legal
control.** Self-play training metrics are also indistinguishable (mates/game
0.029 / 0.042 / 0.040; mean plies 191.5 / 190.3 / 189.7; decisive 0.525 / 0.535
/ 0.550). **H-conv-10/11/12 FALSIFIED at this scale.**

**Why — and this is the useful part.** The discount *was* binding
(0.99^190 ≈ 0.15, so it was not a no-op), and it creates a large differential:
sampling 64 self-play games from the `disc` checkpoint gives mate at a mean of
53 plies (z = 0.587) versus adjudication at 200 plies (z = 0.134), a **+0.453
advantage for mating**. The incentive is real and large. But the same sample
shows the mate rate is **1/64 = 0.016**, with the rest split across repetition
(25), adjudication (20) and the ply cap (17).

**A discount can only reward faster wins if fast wins occur in the data.** At a
1.6% mate rate the policy gradient almost never sees the reinforced event, so a
correctly-specified reward produces no measurable learning. This is an
*exploration* failure, not a reward-specification failure — and it explains why
H-conv-1 (removing adjudication) also failed: both fix the reward while leaving
the terminal state unreachable.

**Revised diagnosis of the conversion failure.** Three hypotheses are now
falsified (H-conv-1 reward shaping, H-conv-5 value head, H-conv-10/11/12 reward
signal) and one confirmed but insufficient (H-conv-8 anti-check prior). What
survives: **the model never experiences enough checkmates to learn how to cause
one.** Terminal states are too rare under self-play from random init at this
scale for outcome-based RL to acquire mating technique, regardless of how the
outcome is scored.

Successors, in priority order:
- **H-conv-13 (exploration/curriculum)** — train *from* won endgames (KQvK,
  KRvK) where mate is reachable by chance, so the terminal event actually enters
  the buffer. Note the earlier endgame curriculum gave a 0.00 decisive rate and
  was deprioritised; that result should be revisited, because it was measured
  before the discount existed and a 0.00 decisive rate is exactly the symptom
  now understood.
- **H-conv-14 (ply cap)** — 200 plies with ~0.5 adjudication means half of all
  games are truncated before any endgame is reached; the model may simply never
  see the phase of the game where mating happens.

Status: MEASURED, NEGATIVE, retained. `--win-discount` and `--terminal-weight`
are correct, unit-tested, default-off, and kept in the codebase as tools; they
are not beneficial on their own evidence and are not enabled in any reported run.

---

## H-conv-13 (reachability curriculum) — MEASURED, NEGATIVE (with one positive signal)

If the conversion failure is an *exploration* failure (terminal states too rare
to reinforce), then starting games from positions where mate is reachable should
fix it. First, why the existing endgame curriculum failed:

**Diagnosis of the old `endgame` curriculum.** `_random_endgame` gives ONE extra
queen/rook to a **random** colour. Measured at random init (48 games, 120-ply
cap): **0.0% checkmates, 56.2% insufficient material.** The lone piece is hung
almost immediately and K-v-K is a draw, so the buffer receives no terminal wins.
This explains the previously-recorded "endgame curriculum gave 0.00 decisive
rate" — it was not that endgames are useless, it was that the generator produced
positions that stop being won after one blunder.

**Fix (`won_endgame` / `mixed_won`, `tinychess/selfplay.py`).** Give the winning
side TWO heavy pieces, so a single blunder still leaves a won K+heavy-vs-K.
Only the starting material changes; no technique is supplied. Checkmate rate at
random init, 48 games:

| curriculum | mate% | stalemate% | insufficient% |
|---|---:|---:|---:|
| `endgame` (old) | **0.0** | 6.2 | 56.2 |
| `won_endgame` | 6.2 | 22.9 | 35.4 |
| `mixed_won` | **16.7** | 10.4 | 20.8 |

Terminal states now enter the buffer, which is the precondition H-conv-12 lacked.

**Training result** (`mixed_won`, 50 iters, 24 games, seed 0, ± `--win-discount
0.99`), evaluated on the isolated suites:

| arm | KQvK mated | KQvK progress | KQRvK mated | KQRvK progress |
|---|---:|---:|---:|---:|
| curric | 0.00 | **+0.38** | 0.00 | −0.04 |
| curric_disc | 0.00 | +0.18 | 0.00 | +0.14 |
| *random* | *0.00* | *+0.08* | *0.14* | *+0.18* |
| *material* | *0.08* | *+0.14* | **0.78** | *+0.48* |

**H-conv-13 FALSIFIED for conversion.** Both arms still mate 0.00 on both
suites, and in-training mate rate stays ~0.046–0.062/game. Making the terminal
event reachable is **necessary but not sufficient**: the buffer now contains
mates, and the policy still does not learn to produce them at 50 iterations.

**One genuinely positive signal, reported because it is the only movement seen
on this metric.** `curric` achieves KQvK edge-progress **+0.38**, the best of
any model measured (main +0.00, router_s0 +0.08, material +0.14, random +0.08).
It drives the defending king toward the edge better than the material heuristic
— then draws by repetition 100% of the time. So the curriculum *did* teach the
first half of mating technique (restrict the king) and none of the second half
(deliver mate). This is consistent with the mate-blindness result: it can make
progress but cannot recognise or execute the terminal move. Caveat: n=50 on one
suite, one seed — suggestive, not established.

**Cumulative status of the conversion investigation.** Falsified: H-conv-1
(reward shaping), H-conv-5 (value head), H-conv-7 (representation, partially),
H-conv-10/11/12 (reward signal), H-conv-13 (reachability curriculum). Confirmed
but insufficient: H-conv-8 (anti-check prior). The failure is robust to every
reward-level and data-level intervention tried. The remaining explanation is
**scale**: at 50-230 iterations with ~100K params, the policy learns material
and king-restriction but not termination. That is a legitimate finding about
what this budget buys, not a bug — and it should be reported as such rather than
patched with hand-written mating heuristics, which the project constraints
forbid and which would not answer the research question.

### Scale does not fix conversion either (MEASURED)

Direct test of the remaining "it's just scale" explanation, using the main run at
two training depths (identical architecture, same run, 100 iterations apart):

| model | KQvK mated | KQvK progress | KQRvK mated | KQRvK progress |
|---|---:|---:|---:|---:|
| main @170 iters | 0.00 | −0.10 | 0.00 | −0.04 |
| main @269 iters | 0.00 | −0.26 | 0.02 | +0.10 |
| *random* | *0.02* | *+0.24* | *0.04* | *+0.50* |
| *material* | *0.10* | *+0.06* | **0.74** | *+0.62* |

**100 additional iterations of the strongest model produce no conversion
improvement** (0.00 → 0.00 on KQvK; 0.00 → 0.02 on KQRvK, within noise at n=50).
The scale explanation is therefore *also* unsupported over the range tested:
more self-play at this parameter budget buys playing strength (main beats
grid_router_s0 by +199 Elo) **without buying any ability to finish a won game**.

This is the sharpest statement of the project's central negative result:
**under self-play from random init with outcome-based RL, ~100K persistent
parameters learn material and positional play but do not learn termination, and
this is invariant to reward shaping, reward discounting, credit weighting,
curriculum reachability, and 100+ extra iterations of training.** Every
intervention tried is recorded above with its artifact, including the ones that
made things worse.

---

## INFRASTRUCTURE + PPO CORRECTNESS (MEASURED)

Prompted by the observation that the research machine (192 cores, 2 TB) was
being used at ~1 core: the main run was launched with `threads: 2` and a
single-process self-play loop.

### 1. Parallel self-play (`tinychess/parallel.py`)

`play_games` batches NN calls but runs in one process. Added process-level
sharding plus a persistent pool (`SelfPlayPool`) that spawns workers once and
re-broadcasts weights per iteration.

Two real bugs found while building it, both recorded because they will recur:
- **fork + libgomp deadlock.** With `fork`, workers inherit the parent's already
  initialised OpenMP pool and hang. Observed exactly: the `1w x 1t` bench row
  completed, then the first multi-worker row hung **17+ minutes**. Fixed by
  using the `spawn` start method. `spawn` then requires (a) a `if __name__ ==
  "__main__"` guard in any script that creates a pool, and (b) payloads passed
  via a temp file, not `initargs` (a multi-MB state_dict raced the pipe buffer
  → `BrokenPipeError`).
- **Sandbox OOM.** 4 spawn workers exceed the 2 GB sandbox (exit 137). This is a
  sandbox limit only; the Space has 2 TB. Local smoke tests must use ≤2 workers.

Measured on the Space (`runs/bench_parallel3/4.json`), baseline config:

| games | 1w×1t | 16w×2t | 32w×2t | 48w×2t | 64w×2t | 96w×2t |
|---|---:|---:|---:|---:|---:|---:|
| 256 | 1166 | **2715** | 1052 | 1271 | 899 | 539 |
| 1024 | — | **4345** | 3330 | 2668 | 2152 | — |

**Best = 16 workers × 2 threads = 4345 moves/s, 3.7× the single-process rate.**
More workers *hurt*: each worker gets fewer games, so the per-call batch shrinks
and per-process overhead dominates. In the real loop self-play went from 53 s
for 256 games to **33 s for 1024 games (~6× throughput)**, and learn time fell
from 105 s to 19 s once `--threads 32` was actually used.

### 2. Three genuine PPO bugs (pre-existing, not introduced by the above)

The main run had `approx_kl` ≈ 200–300 and `grad_norm` ≈ 5,500 with `l_pi` ≈
+60…+130 — i.e. **it had been training with a broken objective for 400
iterations**. Three independent causes:

1. **`logp_old` was the raw policy, not the behaviour policy.** Moves are sampled
   from a temperature-scaled distribution mixed with Dirichlet root noise, but
   `selfplay.py` stored `log_softmax(logits)`. Measured consequence: 0.9% of
   samples had `logp_old ≈ −114`, **all at ply 3–19**, i.e. inside
   `dirichlet_plies=20` — noise forced moves the policy assigned ~e^−114. The
   PPO ratio then explodes. Fixed to store `log(probs)` of the actual behaviour
   distribution: `logp_old` min went **−124 → −7.77**, fraction below −20 went
   **1.5% → 0.0%**.
2. **Opponent positions were trained on as if they were ours.** `rec.player` was
   recorded but never used, so when playing a league opponent **half** the
   buffer carried the *opponent's* `logp_old`, making the importance ratio
   compare two different networks. Fixed via `only_player` (verified: exactly
   50% of positions dropped in a two-model game).
3. **The `approx_kl` metric itself was wrong** — it mixed the *clamped* ratio
   with the *unclamped* log-difference, reporting 307 while `l_pi` was 0.03.
   Fixed to Schulman's k3 estimator on the same clamped `logdiff`.

Also added: `--max-gen-age` (PPO staleness bound on replay sampling) and
`--target-kl` with a `--min-updates` floor (standard PPO early stopping; without
the floor it fired on the first update and froze learning at `loss 0.000`).

**Result:** `l_pi` **+59 → +0.27**, `approx_kl` **307 → 0.02–0.09**. Phase-1
gate 12/12 throughout.

### 3. NEGATIVE: the fixed objective did not immediately yield a stronger model

Resuming the healthy iter-269 checkpoint with the corrected objective and a
raised entropy target (0.5) **degraded** strength within 5 iterations:

| checkpoint | vs random | vs material | W/D/L vs material |
|---|---:|---:|---|
| iter 269 (pre-fix) | 0.537 | **0.588** | 7/33/0 |
| +5 iters (post-fix, ent-target 0.5) | 0.475 | **0.438** | **0/35/5** |

Repetition terminations grew 102 → 384 per 1024 games over those iterations, and
entropy was held artificially high (2.05 vs 0.39 in the collapsed run). Holding
entropy up prevents the all-draw collapse but also prevents the policy from
committing, producing 0 wins. An earlier attempt at the *old* entropy settings
collapsed the other way (ent 1.68 → 0.42, decisive 0.37 → 0.01, games 130 → 42
plies within 5 iterations).

**Conclusion: fixing the PPO objective is necessary but exposes an unresolved
exploration/exploitation trade-off.** The entropy controller is a blunt
instrument — too low collapses to forced draws, too high prevents committal
play. `main_baseline/latest.pt` has been restored to the best measured
checkpoint (iter 269, 0.588 vs material). The infrastructure work stands on its
own (3.7× self-play throughput, correct PPO), but **no stronger model has been
produced yet**; the entropy schedule needs to be tuned as a proper sweep rather
than guessed, which is the immediate next step.

### 4. The repetition collapse: diagnosed, partially fixed, strength NOT recovered

With the PPO objective corrected, every resumed run collapsed the same way:
**511/512 games ending in threefold repetition within 3 iterations**, mean game
length falling 195 → 27 plies.

**Hypothesis A (draw penalty) — FALSIFIED.** Reasoning: a draw scores z=0 while
a loss scores −1, so a policy that can force repetition banks a guaranteed 0.
Added `--draw-penalty`. Swept 0.05 / 0.15 / 0.30 (+ a win-discount arm), 512
games × 4 arms. **All four still collapsed to 511/512 repetitions.** The metrics
show why: `mean_z` moved to −0.16 as intended, but `tr_value_mean` tracked it to
−0.246 and `tr_adv_abs` fell 0.86 → 0.47. **A constant shift applied to every
draw is absorbed by the value baseline, so the advantage — and hence the policy
gradient — is unchanged.** Recorded as a negative result: this is a general
lesson about outcome-shifting in actor-critic, not a chess fact.

**Hypothesis B (claimed draws bypass adjudication) — CONFIRMED and fixed.**
`game_result` auto-claims threefold repetition and the 50-move rule the instant
they occur, and `adjudicate_result` was only consulted **at the ply cap**. So a
side that is up a queen gets 0 the moment the position repeats. Repetition was a
*free escape for the losing side* and cost the winning side its win. Added
`--adjudicate-claimed`, applying the same material verdict to claimed draws.

Effect over 20 iterations, 512 games/iter:

| arm | decisive rate | terminations |
|---|---:|---|
| `ac0` (control, off) | **0.004** | repetition 510 |
| `ac1` (on) | **0.137** | repetition 442, adjudicated_repetition 70 |
| `ac1dp` (on + draw-penalty) | **0.154** | repetition 433, adj_rep 77 |
| `ac1wd` (on + win-discount) | 0.109 | repetition 456, adj_rep 54 |

**A 38× increase in decisive rate** (0.004 → 0.154) confirms the mechanism was
real and was silently nullifying the training signal.

**But strength did NOT improve — it regressed.** Head-to-head, 40 games,
`adjudicate=none`:

| checkpoint | vs random | vs material |
|---|---|---|
| **iter 269 (pre-existing best)** | **0.613** (W9/D31/L0) | **0.550** (W4/D36/L0) |
| ac1 (+20 iters) | 0.412 (W0/D33/L7) | 0.425 (W0/D34/L6) |
| ac1dp (+20 iters) | 0.475 (W0/D38/L2) | 0.400 (W0/D32/L8) |

Mean game length stayed ~27 plies in all arms. The model still shuffles into a
repetition immediately; adjudication now *scores* those games correctly, but the
policy has not yet learned to avoid them, and 20 iterations of a corrected but
very different objective was enough to undo the strength of a 269-iteration run.

**Honest status.** `main_baseline/latest.pt` remains the **iter-269 checkpoint
(0.550 vs material)** — the strongest model measured, and it predates all of
today's fixes. The infrastructure and correctness work is real and verified
(3.7× self-play throughput; three genuine PPO bugs fixed; a 38× decisive-rate
recovery), but **it has not yet produced a stronger model.** Two of four
hypotheses tested today were falsified by their own ablations. What the evidence
now says is that the short 20–30 iteration probes are far too short to re-converge
after an objective change: the next step is a single long run (≥300 iterations)
on the corrected objective with `--adjudicate-claimed 1`, judged against the
iter-269 baseline, rather than more short parallel sweeps.

### 5. SELF-CORRECTION: the `logp_old` "fix" was wrong and CAUSED the collapse

Section 2 above reported storing the *behaviour* log-prob (temperature +
Dirichlet) instead of the raw policy log-prob as a PPO correctness fix. **A
direct ablation falsified it.** Identical config, 60 iters, 512 games/iter, only
`--logp-raw` differing:

| iter | `logp_raw=1` (raw policy) | `logp_raw=0` (behaviour) |
|---|---|---|
| 0 | 193 plies, decisive 0.801 | 193 plies, decisive 0.797 |
| 4 | 194 plies, decisive 0.666 | 106 plies, decisive 0.133 |
| 9 | **185 plies, decisive 0.432** | **58 plies, decisive 0.014** |

**Storing the behaviour log-prob is what produced the repetition collapse.**
Mechanism: Dirichlet root noise and temperature inflate the sampling probability
of moves the policy dislikes. With `logp_old = log pi_behav`, the PPO ratio
becomes `pi_theta / pi_behav`; for a noise-forced move `pi_behav` is large and
`pi_theta` tiny, so whenever the advantage is positive PPO pushes the policy
*toward its own exploration noise*. The policy flattens toward uniform shuffling
and every game ends in threefold repetition. Textbook PPO's behaviour/target
distinction assumes the behaviour policy is the thing you want to improve;
**Dirichlet root noise is exploration scaffolding, not the target policy.**

This also explains the `approx_kl` "floor" of 0.265 measured on an *unchanged*
policy: that number was never drift, it was the exploration noise itself
(0.014 with no Dirichlet and temp 1.0, rising to 0.265 at temp 1.1 + Dirichlet
0.3). Chasing it with `--target-kl` was chasing an artifact.

Default reverted to `logp_raw=True`; the flag is retained for ablation. The
original `logp_old ≈ −114` samples are a real but *benign* artifact — they are
noise-forced moves, and PPO's ratio clamp already handles them.

**Corrected status of section 2:** of the three "PPO bugs", the opponent-position
leak (`only_player`) and the `approx_kl` estimator are genuine fixes; the
`logp_old` change was **wrong and has been reverted**. The lesson is the one the
project already mandates: no claim without an ablation. This one was reported as
a fix before it was ablated, and the ablation overturned it.

### 6. `main_v4`: stable training restored, strength NOT yet recovered (IN PROGRESS)

With `logp_raw=1` (reverted default) plus the two genuine fixes (`only_player`,
corrected `approx_kl`) and `--adjudicate-claimed 1`, training is stable again —
no repetition collapse:

| iter | mean plies | decisive | entropy |
|---|---:|---:|---:|
| 0 | 195 | 0.794 | 3.22 |
| 9 | 189 | 0.520 | 2.76 |
| 19 | 168 | 0.408 | 2.47 |
| 34 | 158 | 0.604 | 2.33 |
| 44 | **148** | **0.771** | 2.29 |

Games stay long, the decisive rate dips then recovers to 0.77, entropy declines
smoothly. This is the healthy trajectory that every earlier attempt today failed
to produce.

**But it is still not stronger than the pre-existing checkpoint.** Head-to-head,
80 games, `adjudicate=none`:

| comparison | score | W/D/L | Elo |
|---|---:|---|---:|
| v4 @20 iters vs iter269 | 0.438 | 1/68/11 | −44 |
| v4 @45 iters vs iter269 | 0.456 | 0/73/7 | **−30** |

The gap is closing (−44 → −30) but has not crossed zero. Note the very high draw
rate in these matches (73/80): the two models are close and both draw-prone, so
±30 Elo at n=80 is near the resolution limit of this test.

**Canonical model remains `main_baseline/latest.pt` = iter 269** (0.558 vs
material, 0.617 vs random). `main_v4` continues training; it should be promoted
only if it crosses the head-to-head baseline, not because it is newer.

### 7. `main_v4` final verdict + the games/updates ratio error

`main_v4` ran to 75 iterations, stable throughout (156 plies, decisive 0.778).
Under `adjudicate=none` the head-to-head gap against iter269 appeared to close
steadily: −44 → −30 → **−9** Elo. That was misleading. Those matches were
78/80 draws, i.e. below the resolution of the test.

Re-measured with material adjudication (mode stated, per project rule), which
separates draw-prone models:

| model | vs MaterialAgent (ADJ=material) | W/D/L |
|---|---:|---|
| **iter269** | **0.731** | 38/41/1 |
| v4 @75 | 0.550 | 8/72/0 |

Head-to-head v4 vs iter269 (ADJ=material, 120 games): **0.429, W2/D99/L19,
−50 Elo.** v4 is clearly weaker; the `adjudicate=none` "convergence" was
draw-masking. **This is a reusable lesson: for two draw-prone models,
`adjudicate=none` cannot resolve strength — it compresses everything to 0.5.**

**Probable cause identified — a scaling error of mine.** iter269 was trained with
256 games/iter and 48 updates; v4 used **1024 games/iter with the same 48
updates**, i.e. 4× more data per gradient step and therefore ~4× *fewer*
gradient steps per game played. Scaling games without scaling updates reduced
the learning applied per unit of experience.

`main_v5` launched with `--updates 192` (48 × 4), restoring the gradient-steps-
per-game ratio of the iter269 recipe while keeping the 4× throughput. Early
iterations are stable (194 plies, decisive 0.79). Note the bottleneck has now
flipped: learn 390 s vs self-play 45 s per iteration, so the next throughput
work belongs in the update loop, not self-play.

**Canonical model is still iter269** (`main_baseline/latest.pt`, 0.731 vs
material adjudicated / 0.558 unadjudicated). No run today has beaten it.

---

## Analysis of `main_v4` (75 iters) — what the existing data supports

No new training was run for this section; it analyses the 75 iterations already
on the hub plus the two local checkpoints.

### Training trajectory (15-iteration block means)

| iters | plies | decisive | entropy | mates/iter | repetitions/iter | value MAE |
|---|---:|---:|---:|---:|---:|---:|
| 0–14 | 189 | 0.568 | 2.86 | 44.3 | 27 | 0.549 |
| 15–29 | 168 | 0.466 | 2.45 | 27.4 | 79 | 0.423 |
| 30–44 | 156 | 0.637 | 2.32 | 25.1 | 86 | 0.461 |
| 45–59 | 151 | 0.748 | 2.19 | 21.7 | 58 | 0.455 |
| 60–74 | 152 | 0.782 | 2.10 | 24.3 | 38 | 0.486 |

Training is stable (no repetition collapse). But over iters 55–74 the decisive
rate slope is **+0.0018/iter** and mean plies **+0.11/iter** — i.e. **flat**.
The run had plateaued; continuing it unchanged was unlikely to help, which
retrospectively justifies stopping it.

### Strength verdict at n=100 with CIs (both adjudication modes)

| model | opponent | adj | score | W/D/L | CI95 |
|---|---|---|---:|---|---|
| iter269 | random | none | 0.570 | 14/86/0 | [0.472, 0.663] |
| iter269 | random | material | 0.655 | 32/67/1 | [0.558, 0.741] |
| iter269 | material | none | 0.550 | 10/90/0 | [0.452, 0.644] |
| **iter269** | **material** | **material** | **0.705** | 41/59/0 | **[0.609, 0.785]** |
| v4_75 | random | none | 0.510 | 3/96/1 | [0.413, 0.606] |
| v4_75 | random | material | 0.515 | 5/93/2 | [0.418, 0.611] |
| v4_75 | material | none | 0.505 | 1/99/0 | [0.409, 0.601] |
| **v4_75** | **material** | **material** | **0.565** | 13/87/0 | **[0.467, 0.658]** |

**iter269 > v4_75 is credible** under material adjudication (0.705 vs 0.565,
CIs barely overlap at the bounds and the win counts differ 41 vs 13). Under
`adjudicate=none` both compress toward 0.5 and nothing is resolvable —
re-confirming that mode cannot rank draw-prone models.

### NEW FINDING: the "strongest" model also repeats 100% under greedy play

Measured over 30 games of pure self-play from randomised openings:

| model | temp 0.0 | temp 0.5 | temp 1.0 |
|---|---|---|---|
| iter269 | **33 plies, repetition 30/30** | 128 plies, rep 15, mate 4 | 153 plies, rep 6, mate 1 |
| v4_75 | **23 plies, repetition 30/30** | 128 plies, rep 28 | 182 plies, rep 22, mate 1 |

**Both models repeat in 100% of greedy games.** The repetition pathology I
attributed to specific training configurations is a property of *every*
checkpoint in this project, including the canonical one; sampling temperature
is what has been hiding it. All reported "strength" numbers come from
temperature-0 arena play, which is exactly the regime where both models shuffle
— they score above 0.5 only because the opponent blunders material first, and
the material adjudicator then awards the win.

Policy sharpness differs, and explains the strength gap: iter269 top-1 prob
**0.801** (entropy 0.494) vs v4_75 **0.561** (entropy 1.154). v4 is *less
committed*, so it converts fewer won positions before the ply cap. The
`--entropy-target 0.45` controller held v4's entropy up and that cost it
decisiveness.

### v4 is not uniformly worse

On the isolated endgame suites v4 is **better** at making progress:

| suite | model | mated | edge progress |
|---|---|---:|---:|
| KQvK | iter269 | 0.00 | **−0.10** |
| KQvK | v4_75 | 0.00 | **+0.28** |
| KQRvK | iter269 | 0.00 | −0.18 |
| KQRvK | v4_75 | 0.00 | −0.10 |

Neither mates; v4 drives the enemy king toward the edge better on KQvK. So the
two checkpoints differ along a **commitment/exploration axis**, not a simple
strength axis, and "iter269 is stronger" holds only for adjudicated material
outcomes.

### Bug fixed: in-loop eval never ran on resumed runs

`--eval-every` requires `<out>/init.pt`, which is only written by a fresh run.
Every `--resume` run therefore skipped evaluation **silently**: `main_v4` ran 75
iterations with `--eval-every 25` and produced **0 eval rows**, which is why the
plateau was not visible from inside the run. Fixed: a resumed run now seeds
`init.pt` from the `--resume` checkpoint (so progress is measured against where
the run started) and prints an explicit SKIPPED warning otherwise. The eval line
now also states the adjudication mode. Gate 12/12.

**Implication for the next run:** the target is not "more iterations" but
**commitment without collapse** — the entropy controller currently trades one
for the other. And because greedy play repeats for every checkpoint, repetition
avoidance must be measured at temperature 0, not inferred from self-play stats
collected at temperature 1.2.

## Train/inference mismatch: the repetition feature was zeroed during training (MEASURED, FIXED)

**Status: MEASURED (bug reproduced), IMPLEMENTED (fix), learning effect NOT YET MEASURED.**

The encoder has always carried a global feature `repetition_n`
(`GLOBAL_FEATS[7]`, value `min(rep,3)/3`). It is populated in `encode_batch` via
`board.is_repetition(2)`.

`board.is_repetition()` is a function of the board's **move stack**, not of the
position. The replay buffer stores each sample as a bare **FEN**, and a FEN
cannot represent repetition history. Reproduction:

    live board (8 shuffle moves)   is_repetition(2)=True   feature = 0.667
    chess.Board(same_fen)          is_repetition(2)=False  feature = 0.000

Consequence: during **self-play** the model saw `repetition_n = 0.667` and could
in principle react to it; during **training** the identical position was
re-encoded from its FEN with `repetition_n = 0.0`. Every gradient step the
project has ever taken was computed with the one input that says *"you are
repeating"* set to zero. The feature was effectively dead weight, and the policy
could never learn a repetition-avoiding response, no matter what the reward did.

This is a plausible mechanism for a standing negative result: `--draw-penalty`
was FALSIFIED (511/512 repetitions persisted at 0.05/0.15/0.30). A penalty on
repetition is unlearnable if the state the policy conditions on cannot
distinguish a repetition from a first visit.

**Fix (implemented):** `GameRecord.reps` records the repetition count at each
position during self-play; `ReplaySample.rep` carries it into the buffer;
`encode_batch(..., reps=[...])` accepts explicit values so FEN-restored boards
are encoded with the value observed at play time.

Verified on iter269 greedy self-play (16 games, temp 0):

    samples with rep>0 stored : 83 / 1343
    train-time feature for those samples : 0.667 (was 0.000)

Sensitivity check on iter269 (same position, rep 0 -> 2): value moves by
-0.015/-0.013/+0.003 and max |logit| change 0.87 — the feature is wired into the
forward pass, but iter269 never learned to use it, which is expected given it was
zero in every training batch that model ever saw.

**Caveat:** this fix is a *necessary* condition for learning repetition
avoidance, not evidence that it works. Whether it changes temp-0 behaviour is an
open question for `main_v6`. Do not claim it fixed the repetition pathology
without a temp-0 measurement against the iter269 baseline below.

## Greedy (temperature-0) health baseline

`experiments/exp_greedy_health.py`, 12 games, randomised openings, 200-ply cap:

| model | temp | plies | rep rate | mate | unique-pos ratio | top-1 |
|---|---:|---:|---:|---:|---:|---:|
| iter269 | 0.0 | 27.6 | 1.00 | 0.00 | 0.72 | 0.378 |
| iter269 | 0.3 | 47.7 | 0.92 | 0.00 | 0.84 | 0.341 |
| v4_75   | 0.0 | 22.1 | 1.00 | 0.00 | 0.66 | 0.219 |
| v4_75   | 0.3 | 48.2 | 1.00 | 0.00 | 0.81 | 0.254 |

This is the acceptance target for any future checkpoint: **rep rate < 1.00 at
temp 0** would be the first genuine improvement on this axis.

## Learn-phase thread benchmark (MEASURED, on the 192-core Space)

`scripts/bench_learn.py`, batch 1024, buffer 39,568 samples, 3 reps:

| torch threads | ms/update |
|---:|---:|
| 8 | 2018.5 |
| 16 | **1244.1** |
| 32 | 1570.7 |
| 48 | 2340.2 |
| 96 | 7196.8 |

**16 threads is optimal.** `main_v5` used `--threads 48`, which is **1.9x
slower** per update, and 96 threads is 5.8x slower — the update step is small
enough that thread-synchronisation overhead dominates past 16. More cores do not
help this workload; the 192-core machine is best used for parallel self-play
(16 workers x 2 threads) rather than for wider intra-op parallelism.

## `main_v6` is INVALID: `--resume` silently fell back to random init (MEASURED, FIXED)

**Status: MEASURED. `main_v6` must not be cited as a result.**

`main_v6` was launched with `--resume main_baseline/latest.pt`, a path inside the
**hub model repo**, not a local file. The container-rebuild recovery block only
knew how to pull `<basename(--out)>/latest.pt` — i.e. `main_v6/latest.pt`, which
did not exist yet on a first launch. Both lookups failed, the `if args.resume and
os.path.exists(...)` guard was simply false, and training **started from random
init with no warning**. The metrics file confirms it: an `init` event is present
and the first iteration is `iter 0`, not `iter 270`.

The damage was not merely a wasted run. `--eval-every` evaluates the current model
against `<out>/init.pt`, and `init.pt` was now a **random network**. The loop
therefore reported, at iter 9:

    EVAL vs init (adj=material): score=0.850 W42/D18/L0 elo+301

which reads as a large improvement and is really "a 10-iteration model beats a
random one". Direct head-to-head against the real baseline says the opposite:

| comparison | opening plies | T | score | W/D/L | Wilson CI |
|---|---:|---:|---:|---|---|
| v6 vs iter269 | 6 | 0.0 | 0.500 | 0/120/0 | [0.412,0.588] |
| v6 vs iter269 | 6 | 0.3 | **0.317** | 5/66/49 | [0.240,0.404] |
| v6 vs iter269 | 10 | 0.0 | 0.500 | 0/120/0 | [0.412,0.588] |
| v6 vs iter269 | 10 | 0.3 | **0.325** | 3/72/45 | [0.248,0.413] |
| exact in-loop repro (seed 99, n=60) | 2 | 0.3 | 0.325 | 1/37/22 | — |

Reproducing the in-loop call exactly but with iter269 as the opponent yields
0.325, not 0.850 — confirming the opponent, not the protocol, was the difference.
v6 (10 iterations from scratch) is **clearly weaker** than iter269, as expected.

Two lessons, both now enforced in code:
1. **An in-loop "EVAL vs init" number is only meaningful if `init.pt` is the
   intended reference.** It silently redefines itself on a fresh run.
2. **A missing `--resume` target must be fatal.** `train_selfplay.py` now resolves
   a hub-style path by downloading it, and raises
   `FATAL: --resume ... Refusing to start from random init silently` otherwise.
   Verified both branches: bad path -> exit 1; `main_baseline/latest.pt` ->
   `[recover] pulled ckpt` then `[resume] iter=270`.

Note the temp-0 rows: 120/120 identical draws. At temperature 0 with only 2-10
random opening plies, two deterministic policies replay **the same game**, so a
temp-0 arena of any size carries almost no information. Comparisons must use
T>0 or heavily randomised openings.

### `main_v7` (relaunch, correct resume)
Genuinely continues from iter269 (`[resume] iter=270`), 1024 games/192 updates,
`--threads 16`. Learn phase **197-220 s vs v6's 359-381 s** — the thread
benchmark transferred to the real loop (~1.75x faster per iteration).
Early iterations: plies ~144, decisive 0.58-0.67, entropy 1.90 -> 1.76.
**No strength claim yet** — pending an eval against iter269 at iter 280.

### `main_v7` @ iter 292 — independent verification (MEASURED, NOT SIGNIFICANT)

In-loop eval vs iter269 (n=60): iter 280 **0.542** (+29 Elo), iter 290 **0.558**
(+41 Elo). Independent arena, larger n, several conditions:

| condition | score | W/D/L | Wilson CI |
|---|---:|---|---|
| T=0.3, open 6  | 0.506 | 13/136/11 | [0.430,0.583] |
| T=0.3, open 10 | 0.491 | 10/137/13 | [0.414,0.567] |
| T=0.5, open 6  | 0.591 | 41/107/12 | [0.513,0.664] |
| **POOLED n=480** | **0.529** | — | **[0.484,0.573]** |

**The pooled CI contains 0.5: `main_v7` is NOT yet measurably stronger than
iter269.** Only the T=0.5 condition is nominally above 0.5, and selecting it
alone would be cherry-picking across three conditions. The in-loop n=60 numbers
(+29/+41 Elo) are inside their own noise and must not be quoted as progress.

`runs/mainval269/latest.pt` and hub `main_baseline/latest.pt` remain canonical.
Self-play trend so far is favourable (decisive 0.61 -> 0.77, entropy 1.90 -> 1.46
over iters 270-292) but self-play statistics are not strength.

## Optimisation-stability campaign v7-v12: three real bugs fixed, NO strength gain (MEASURED)

All runs resume from iter269 (`main_baseline/latest.pt`), 1024 games/iter.

### Bugs found and fixed (all verified in isolation)
1. **`--resume` silently fell back to random init** for hub-style paths. `main_v6`
   is invalid; its "+301 Elo" was against a random `init.pt`. Now FATAL. Verified.
2. **Repetition feature destroyed by the FEN round-trip.** Fired at play time
   (0.667), always 0.0 at train time. Now recorded per position. Verified: 83/1343
   samples restored.
3. **Last-move feature destroyed by the same round-trip.** Play time encodes with
   the last move, training encoded with `None`. Now recorded. Verified: mean
   |logp_old - logp_recomputed| on an UNCHANGED model drops **0.0222 -> 0.0080
   (2.8x)** — that residual was pure spurious PPO ratio error.
4. **Entropy-controller windup.** `ent_coef *= 1.5` every iteration while the
   target was unreachable (0.01 -> 0.17) as approx_kl went 1.3 -> 59.8 and
   grad_norm 6 -> 1918. Added `--ent-kl-ceiling` (back off when KL diverges).
5. **`--updates 192` was the dominant divergence driver.** `main_v4` (48 updates)
   held approx_kl at 0.01 for 75 iterations; v7/v8 (192 updates) reached 70.

### Config search over the KL controls (MEASURED)

| run | updates | KL controls | outcome |
|---|---:|---|---|
| v7  | 192 | none | KL 1.9 -> 70, grad 1918, decisive 0.77 -> 0.53 |
| v8  | 192 | ent-kl-ceiling 6 | ent_coef pinned to min, KL still 63 -> entropy was NOT the cause |
| v9  | 48 | ent-kl-ceiling 6 | learn 47 s/iter (8x faster), KL ~6-8, then drift to 33 |
| v10 | 48 | + target-kl 1.0, min-updates 8 | KL **0.03-0.13, loss 0.4** for ~30 iters, then collapse (plies 144->78, ent 1.60->0.55) |
| v11 | 48 | + kl-hard 3.0, min-updates 4 | **nup=0 on most iterations** — silent no-ops, the known failure mode |
| v12 | 48 | kl-hard 3.0, min-updates 8 | no no-ops, but the 8 forced updates keep KL at 18-25; entropy 1.14 -> 0.94 |

### Strength: flat throughout
In-loop eval vs iter269 (n=60) across v7, v9, v10, v11, v12:
+29, +41, +17, -41, +12, -0, -12, +17, -23, +6, -35, -6, +12, -12, +17, -0 Elo.
**Every value is inside n=60 noise and the sequence has no trend.**

Independent arena, `main_v7` @292 vs iter269, n=480 pooled over three conditions:
**0.529, Wilson CI [0.484, 0.573]** — contains 0.5.

**Conclusion (MEASURED, negative): the three encoding/optimisation bugs were real
and are fixed, but fixing them did not make the model stronger.** `main_v10`
demonstrates that the loop *can* be held in a well-conditioned regime
(KL ~0.05, loss ~0.4) — and in that regime the model simply does not improve; it
holds until the entropy controller lets it collapse again. This reproduces, with
clean optimisation, the standing result that ~100K params plateau at this level.

`runs/mainval269/latest.pt` (iter 269) REMAINS THE CANONICAL BEST MODEL.
No checkpoint from v6-v12 beats it. `main_baseline/latest.pt` was not overwritten.

### Did the repetition fix cure temp-0 shuffling? NO (MEASURED, negative)

`experiments/exp_greedy_health.py`, 30 games, randomised openings
(`runs/greedy_v12.json`):

| model | temp | plies | rep rate | mate | uniq | top-1 |
|---|---:|---:|---:|---:|---:|---:|
| iter269 | 0.0 | 33.1 | **1.00** | 0.00 | 0.75 | 0.381 |
| iter269 | 0.3 | 75.0 | 0.87 | 0.00 | 0.87 | 0.328 |
| v12_314 | 0.0 | 33.2 | **1.00** | 0.00 | 0.75 | 0.843 |
| v12_314 | 0.3 | 41.3 | **1.00** | 0.00 | 0.78 | 0.807 |

Restoring the repetition feature at training time was **necessary but not
sufficient**: 45 iterations of training with a working signal did not reduce the
temp-0 repetition rate at all (still 30/30). v12 is far more *committed* than
iter269 (top-1 0.381 -> 0.843) and is actually **worse at T=0.3** (rep 0.87 ->
1.00, plies 75 -> 41) — the same commitment/collapse trade-off seen in v4, now
running in the opposite direction.

So the hypothesis "the policy cannot learn to avoid repetition because the input
never told it that it was repeating" is **FALSIFIED as a sufficient explanation**.
The model can see the repetition flag and still shuffles.

## RETRACTION + root cause: the approx_kl "divergence" of v7-v12 was a metric artifact

**Status: MEASURED. This retracts the central claim of the v7-v12 section above.**

That section concluded "`--updates 192` was the dominant divergence driver" and
that v9-v12 "diverged". **That conclusion was wrong.** The reported `approx_kl`
was a corrupted statistic, and the whole v7-v12 config search was tuning against it.

### The artifact
`train_step` reported the batch **MEAN** of the Schulman k3 estimator
`(ratio-1) - logdiff`, computed on `logdiff` clamped to +/-10. k3 is
exp-tailed, so a single saturated sample contributes `(e^10-1-10)/batch`:

    batch 128 -> 172.0 from ONE sample.   Observed max was 172.07. Exact match.

Per-update distribution over 160 real updates (iter269, temp 1.2, dirichlet 0.3):

| statistic | value |
|---|---:|
| median | **0.0308** |
| p75 | 0.0583 |
| p90 | 0.1175 |
| p99 | 172.0 |
| max | 172.07 |
| fraction of updates with kl > 1.0 | **3.1%** |
| mean **with** outliers | 2.4257 |
| mean **excluding** kl>1 | **0.0476** |

**97% of updates were perfectly healthy.** `l_pi` was never affected: PPO clips
the ratio to `[1-eps, 1+eps]`, so those samples' gradients are bounded. This was
a **diagnostic** bug, not a training bug.

### The source of the saturated samples
Not staleness. Of 2048 sampled positions only 1 had |logdiff| > 5, it came from
gen 0, and its `logp_old` was **-200.16** against a median of **-2.02**.

With `--logp-raw 1` (the measured-correct default) `logp_old` is the **raw**
policy log-prob, but Dirichlet root noise sometimes forces a move the raw policy
gives ~0 probability:

| setting | median logp_old | min | frac < -10 | frac < -50 |
|---|---:|---:|---:|---:|
| `logp_raw=1` | -2.021 | **-229.44** | 0.942% | 0.899% |
| `logp_raw=0` | -1.959 | -7.74 | 0.000% | 0.000% |

This is the same 0.9% already noted in `selfplay.py`. Flipping `--logp-raw` is
NOT the fix (measured previously: `logp_raw=0` collapses play, 58 vs 185 plies
at iter 9). The fix is to exclude the forced samples from the ratio term.

### Fixes (both verified)
1. **Robust reporting.** `approx_kl` is now the batch **median**; the mean, max
   and `kl_tail_frac` are logged alongside. Max reported value over a run fell
   from **172.0** to **0.0070**, so `--target-kl` / `--kl-hard` finally control
   something real.
2. **`--logp-floor` (default -20)** drops samples with `logp_old` below the floor
   from the PPO ratio. Controlled A/B, identical seeds, 90 updates:

| | median kl | worst-sample kl | grad_norm p95 | grad_norm max |
|---|---:|---:|---:|---:|
| floor OFF (old) | 0.0018 | **22015.5** | 2.3 | 254.3 |
| `--logp-floor -20` | 0.0019 | **34.7** | 2.1 | **44.5** |

Worst-sample kl **635x lower**, max grad_norm **5.7x lower**, median unchanged —
healthy samples are untouched. 22015.5 = e^10-1-10 exactly, i.e. the clamp bound.

### What this means for the earlier conclusions
- The v7-v12 "KL divergence" ranking is **void**; those runs were compared on a
  metric dominated by a 3% tail.
- `--updates 192` vs 48 is **unresolved**, not settled. v4's KL 0.006 vs v9-v12's
  3.4-10.4 is largely the artifact plus v4's `steps=4`/`max_gen_age=2` config.
- **Still standing and unaffected:** the flat strength results. Every eval across
  v7-v12 sat inside n=60 noise, and `main_v7` @292 measured 0.529 CI [0.484,0.573]
  over n=480. Fixing the metric does not make the model stronger; it only means
  the loop was never as sick as the logs implied.
- The genuine encoding bugs (repetition, last-move, silent random init) remain
  real and fixed.