# E6 -- The Lookahead Ladder: RESULTS

Registered analysis of the Paper 3 Part A ladder, 2026-07-20. All registered
endpoints run. Prereg: `e6-ladder/PREREG.md` (v1 plus three dated amendments,
each made before the affected numbers existed). Analysis of record:
`e6-ladder/results/analysis_ladder.json`, produced by
`e6-ladder/src/analyze_ladder.py` from the fp32 rows in
`e6-ladder/results/outcome_ladder.json`. Artifact hashes:
`e6-ladder/results/MANIFEST_SHA256.txt`.

## Verdict

A ledger built with ZERO access to B-side gradients beats crowding decisively,
but lookahead does not buy protection value in the way the ladder was designed
to test. Primary (b) PASSES: ladL0, the zero-lookahead block-coherence ledger
computed from A-side reservoir contexts alone, is better than the weights
(crowding) selector on 6/6 seeds, mean paired difference -0.1667 NLL, 96.7%
bootstrap CI [-0.1715, -0.1613], exact one-sided p = 0.0156 <= alpha_per =
0.0167. Primary (a) PASSES as the registered TREND: per-seed Spearman rho =
+0.400 on all 6 of 6 seeds, exact p = 0.0156. It is NOT monotone -- the
registered descriptive all-adjacent-differences check fails at the very first
step, with ladL0 -> ladL1 NEGATIVE on 6/6 seeds (range -0.0488 to -0.0676):
one microbatch of lookahead is strictly WORSE than no lookahead at all. The
+0.400 trend is carried by the curvK2 endpoint, whose adjacent step
(ladL16 -> curvK2, mean 0.262) is an order of magnitude larger than any
rung-to-rung step (0.003 to 0.068). Primary (c) is a NEGATIVE result: there is
NO saturation rung. The first and only test in the fixed descending sequence,
ladL16 vs curvK2, gives mean diff 0.2623 with 96.7% CI [0.2571, 0.2674], far
outside the frozen band +/- epsilon = 0.09, so the sequence stopped there.
Reading these together: the gap between every ladder rung and the full
sacrificial-run K2 is large and unclosed by 1, 4, or 16 microbatches of
lookahead, while the cheapest rung of all already outperforms crowding. What
separates K2 from the ladder is not a little more lookahead.

## 1. Primaries

### (a) Ladder trend -- PASS (trend, not monotonicity)

Per-seed Spearman rho over the registered rung order (ladL0 < ladL1 < ladL4 <
ladL16 < curvK2) against retention benefit is +0.400 on every one of seeds 1-6.
Strictly positive on 6/6 satisfies the registered pass rule (rho = 0 would have
counted against); exact one-sided sign test p = 1/64 = 0.0156 <= 0.0167.
Bootstrap CI on mean rho is [0.400, 0.400] -- degenerate because every seed
returns the identical rank pattern, which is itself the finding: the ordering
is stable, and it is stably the wrong ordering in the interior.

Registered descriptive adjacent-difference check (positive = the later rung is
better; values are NLL degradation of the earlier rung minus the later rung):

| adjacent step | 6 per-seed diffs | sign |
|---|---|---|
| ladL0 -> ladL1 | -0.0524, -0.0676, -0.0639, -0.0553, -0.0488, -0.0497 | 0/6 positive |
| ladL1 -> ladL4 | +0.0143, +0.0333, +0.0210, +0.0212, +0.0096, +0.0087 | 6/6 positive |
| ladL4 -> ladL16 | +0.0072, +0.0083, +0.0114, +0.0178, +0.0031, +0.0135 | 6/6 positive |
| ladL16 -> curvK2 | +0.2673, +0.2637, +0.2713, +0.2525, +0.2593, +0.2595 | 6/6 positive |

The word "monotone" is reserved for this check, and this check fails. Within
the lookahead arms proper, value rises from L1 to L16 as expected, but L0 sits
above all three of them, and the whole L0-L16 span (0.922 to 0.978) is small
next to the K2 gap.

The pass rule itself is a sign test on rho > 0, and by construction it is
insensitive to interior transpositions: a ladder with ladL1 and ladL16
literally swapped in value would still pass, at rho = +0.6 on every seed --
higher than the +0.400 observed here. So the pass rule alone carries no claim
about the interior ordering; it is the adjacent-difference check above, not
the pass rule, that does that work, and that check is what shows the interior
is not monotone.

### (b) ladL0 vs crowding -- PASS

| seed | ladL0 - weights (NLL) |
|---|---|
| 1 | -0.16098 |
| 2 | -0.17309 |
| 3 | -0.16366 |
| 4 | -0.15777 |
| 5 | -0.17310 |
| 6 | -0.17187 |

Wins 6/6, exact one-sided p = 0.015625 <= alpha_per = 0.0167. Mean paired diff
-0.1667, 96.7% percentile bootstrap CI [-0.17152, -0.16125]. Seeds 5 and 6 of
the weights arm are new runs registered for this comparison, so all six pairs
are seed-matched.

### (c) Saturation -- NO SATURATION RUNG

Fixed-sequence descending equivalence against curvK2, TOST via 96.7% bootstrap
CI within the prereg-frozen epsilon = 0.09 NLL:

| rung | mean diff vs curvK2 | 96.7% CI | tested? | equivalent? |
|---|---|---|---|---|
| ladL16 | 0.26229 | [0.25710, 0.26743] | yes | NO |
| ladL4 | 0.27248 | [0.26711, 0.27788] | no (sequence stopped) | -- |
| ladL1 | 0.29048 | [0.28054, 0.30011] | no (sequence stopped) | -- |
| ladL0 | 0.23421 | [0.22905, 0.23805] | no (sequence stopped) | -- |

`saturation_rung: null`. Because the fixed sequence stops at the first
failure, the ladL4, ladL1 and ladL0 rows are DESCRIPTIVE ONLY and carry no
inferential status. In particular, ladL0's smaller raw gap of 0.234 must NOT
be read as equivalence or as a partial pass -- it was never tested, and 0.234
is in any case 2.6x outside the band.

## 2. Outcome table

Outcome-half NLL degradation relative to ckpt_A (nll_outcome 1.47850), fresh
fp32 evaluation for every row per Amendment 3. Rungs, curvK2 and weights are
the 6-seed seed-paired arms that carry the primaries. The remaining rows are
4-seed CONTEXT rows from the existing program: they are NOT seed-paired with
the primaries and no test above uses them (the section 3 transfer tau-b does
use the anchor `random` row, over its own seeds 1-4, as one of the five arms
in the ordering comparison).

| arm | mean degradation | sd | n | role |
|---|---|---|---|---|
| curvK2 | 0.6881 | 0.0127 | 6 | anchor, seed-paired |
| ladL0 | 0.9223 | 0.0088 | 6 | rung, seed-paired |
| ladL16 | 0.9503 | 0.0090 | 6 | rung, seed-paired |
| ladL4 | 0.9605 | 0.0088 | 6 | rung, seed-paired |
| ladL1 | 0.9785 | 0.0062 | 6 | rung, seed-paired |
| weights (crowding) | 1.0890 | 0.0117 | 6 | anchor, seed-paired |
| fisher | 0.8589 | 0.0100 | 4 | context, not seed-paired |
| footprint | 1.0242 | 0.0125 | 4 | context, not seed-paired |
| join | 1.0262 | 0.0027 | 4 | context, not seed-paired |
| baseline | 1.2342 | 0.0280 | 4 | context, not seed-paired |
| random | 1.2384 | 0.0507 | 4 | context, not seed-paired |

For orientation only: ladL0 lands between fisher and the crowding/footprint/join
cluster, and every rung is far above curvK2.

## 3. Transfer (B2 fiction) -- estimation only

Registered as ESTIMATION, n = 3 transfer seeds, no hypothesis test. Kendall
tau-b between the 5-arm transfer mean ordering (seeds 1-3) and the same-5-arm
anchor mean ordering over common anchor seeds 1-4, bootstrapped independently
on each seed set (B = 10000, seed 20260718): tau-b = 1.000, CI [1.000, 1.000].
The arm ordering on B2 fiction is identical to the ordering on the anchor code
task.

Of the five transfer arms, only ladL4b2 and ladK2b2 are re-derived on B2;
ladL0b2, weightsb2 and randomb2 reuse the anchor's own masks
(mask_ladL0.npz, mask_weights.npz, mask_random_s<seed>.npz respectively) by
design, since those estimators are B-agnostic. So tau-b here is a test of
whether the ordering survives a new task, not of whether five independently
re-derived estimators re-rank identically on it.

| arm | anchor mean (seeds 1-4) | transfer arm | transfer mean (seeds 1-3) |
|---|---|---|---|
| curvK2 | 0.6814 | ladK2b2 | 0.7744 |
| ladL0 | 0.9189 | ladL0b2 | 1.0476 |
| ladL4 | 0.9563 | ladL4b2 | 1.0846 |
| weights | 1.0828 | weightsb2 | 1.1643 |
| random | 1.2384 | randomb2 | 1.6824 |

Two facts, both plainly: concordance is perfect, AND the registered directional
prediction was wrong on one adjacent pair. The prereg predicted
curvK2 >= ladL4 >= ladL0 >= weights >= random. The observed ordering in BOTH
regimes is curvK2 > ladL0 > ladL4 > weights > random -- L0 and L4 are swapped
relative to the prediction. tau-b = 1.000 measures agreement BETWEEN the two
regimes, not agreement with the prediction; it is high precisely because the
same unpredicted swap appears in both. The predicted rank of L0 above L4 --
that is, more lookahead being worth more -- is the part that failed, and it
failed the same way on a maximally dissimilar register.

## 4. Diagnostic dissociation: score agreement rises, causal value does not

Median per-layer Spearman rho of each rung's neuron scores against the full
K2 scores (`k2_raw_s0`), a registered secondary that was never a gate:

| rung | median layer rho vs K2 | causal rank among rungs (1 = best) |
|---|---|---|
| ladL0 | 0.3064 | 1 |
| ladL1 | 0.3098 | 4 |
| ladL4 | 0.3340 | 3 |
| ladL16 | 0.3704 | 2 |

Score-level agreement with K2 rises monotonically with lookahead, exactly as
the ladder's construction predicts -- more B-side steps, more of the true
update direction, scores closer to K2's. Causal retention value does not
follow that order at all: the rung whose scores look LEAST like K2 protects
best, and the rung ranked second on agreement (L1) is last on value. This is
the program's recurring dissociation between score agreement and causal value,
now observed within a single family of estimators that differ only in how much
lookahead they get. It vindicates the registered decision to keep agreement a
diagnostic and never a gate: a gate on agreement would have selected L16 and
discarded the best rung in the experiment.

## 5. Gates

All four block gates passed before their downstream numbers were read.

| gate | criterion | observed | pass |
|---|---|---|---|
| G1 | curvK2 mask bitwise reproduction, all layers | 22/22 layers match | yes |
| G2 | L0 brute-force reference, max rel err <= 1e-3 on layers {0,11,21} x 8 seqs x 64 neurons | worst 2.146e-07 (layer 0, R2); all six checks <= 2.15e-07 | yes |
| G3 | endpoint reproduction of published weights_s1..s4 to <= 1e-6, bf16 convention (Amendment 3) | abs_diff 0.0 on all four | yes |
| G4 | (i) repeat-stability of the k=1 capture (Amendment 2); (ii) median per-neuron delta norm strictly increasing in k | (i) delta-norm rho median 0.99945 / min 0.99755 vs threshold 0.99; top-20% Jaccard median 0.9660 / min 0.9297 vs threshold 0.90. (ii) 0.001135 (k=1) < 0.002550 (k=4) < 0.004662 (k=16), ordered | yes |

G4's bitwise sub-check FAILED as originally registered and is disclosed rather
than buried: 62 of 66 tensors differ between two identically seeded k=1
captures, max relative jitter 2.5e-04, from bf16 reduction-order
nondeterminism. See deviations below.

## 6. Boundaries

- One model, TinyLlama-1.1B; one anchor task pair (math -> code) plus one
  transfer pair (math -> fiction); 20% protection budget; neuron granularity.
- Native parameterization with fixed AdamW. The E-M4 optimizer-coordinate
  scope condition is inherited in full: protection value is not
  parameterization-invariant, so every ladder comparison here is a statement
  in these coordinates.
- The k=1 lookahead DIRECTION carries 6.28% run-to-run jitter
  (||delta_a - delta_b|| / ||delta|| = 0.0628, PREREG Amendment 2, recorded
  there as a boundary and not a gate). ladL1's sketch inherits that jitter.
  This is a documented CANDIDATE CONTRIBUTOR to ladL1 being the worst rung and
  is flagged as a caveat, NOT a conclusion: the experiment does not separate
  "one microbatch of lookahead is genuinely harmful" from "one microbatch is
  too noisy to be useful". Distinguishing them requires repeated k=1 captures
  under independent streams, which was not registered and was not run. The
  jitter shrinks as k grows and signal accumulates, which is consistent with
  L4 and L16 recovering, but consistency is not evidence.
- Sketch convergence: the m gate sequence 32 -> 64 -> 128 stopped at m = 64
  under the registered rho >= 0.9 and Jaccard >= 0.8 early-stop criteria.
  `lookahead.py` printed each rung's observed m=64 rho/Jaccard to stdout but
  did not persist the per-rung convergence margin in the npz, so most of
  those values cannot be recovered after the fact. From run logs, two
  surviving observed values are look16 (rho +0.991, Jaccard 0.891) and
  b2full (rho +0.993, Jaccard 0.924), both against the 0.9/0.8 thresholds;
  look1 and look4 were not recorded. This is a reproducibility gap in the
  logging, not a result -- future runs should persist these margins in the
  npz rather than stdout.
- Transfer is n = 3, estimation only, no hypothesis test. tau-b = 1.000 with a
  degenerate CI reflects an ordering that no bootstrap resample disturbed, not
  a precise population estimate.
- Movement is excluded from the arm set: it is a rollback endpoint rather than
  a protection endpoint, as established earlier in the program.
- Primary (c) is a negative result about a specific band (epsilon = 0.09 NLL,
  frozen as half the published K2-vs-Fisher margin of 0.183). It says no rung
  is within that band of curvK2; it does not quantify how much lookahead would
  be needed.

## 7. PREREG deviations

Three dated amendments, all appended and never edited in place, all made
before the numbers they affect existed.

1. **2026-07-19, G4 operationalization** (before any capture ran). The
   registered bitwise prefix property -- 1-step and 4-step captures equalling
   the first 1/4 steps of the 16-step capture -- is not observable from
   endpoint checkpoints, because `train_e4.py` saves no intermediate steps.
   G4 was re-expressed as (i) repeat-determinism of the k=1 capture plus
   (ii) strictly increasing median delta norm in k, with seeded determinism
   over an identical init and stream supplying the prefix property.
2. **2026-07-19, Amendment 2, G4(i) bitwise -> repeat-stability** (after the
   repeat check ran, disclosed in full). Bitwise repeat-determinism FAILS on
   this stack (62/66 tensors differ, ~2.5e-04 max relative) due to bf16
   reduction-order nondeterminism; forcing deterministic kernels would have
   diverged from the training stack every published arm used. G4(i) was
   replaced by a quantitative stability criterion (delta-norm Spearman rho >=
   0.99 median, top-20% Jaccard >= 0.90 median) with thresholds set AFTER
   observing the k=1 repeat values, which is disclosed as such. Observed
   values pass with margin. The 0.0628 direction jitter was recorded here as
   a boundary.
3. **2026-07-19, Amendment 3, G3 convention equivalence + all-fp32 analysis
   rows** (before G3 ran, disclosed in full). Code inspection found the
   published `outcome_half_evals.json` was produced under bf16 eval, so an
   fp32 evaluator cannot reproduce it to 1e-6 and the two registered
   requirements conflicted. Resolution: G3 was re-scoped to CONVENTION
   EQUIVALENCE (eval_arms.py in bf16 mode reproduces published
   weights_s1..s4, proving the new pipeline is the old pipeline), while the
   registered fp32 endpoint stands unchanged -- every number entering this
   analysis, primaries and context rows alike, is a fresh fp32 evaluation
   from its own after-B checkpoint. No published bf16 number appears in any
   analysis input.

Also recorded, not an amendment: `analyze_ladder.transfer()` carries an
operational skip guard that returns a skipped result when transfer rows are
absent, added so the anchor half could be analyzed before the transfer sweep
existed. It never imputes a missing value and it affects no registered
statistic; in the run of record all 15 transfer rows were present and the
guard did not fire.

## 8. Method notes

- **RNG threading.** The analyzer creates a SINGLE `numpy.default_rng(20260718)`
  stream and threads it through primary (a), then (b), then (c), then transfer,
  in that fixed order. B = 10000 for every bootstrap. Consequently the CIs are
  not independent draws per endpoint and the numbers are reproducible only when
  the endpoints are computed in the registered order; re-running any endpoint
  in isolation from a fresh stream will give bootstrap CIs that differ in the
  last digits.
- **Tie handling in primary (b).** The sign test counts a win as a strictly
  negative difference, so an exact tie would count AGAINST ladL0. This is the
  conservative direction. No tie occurred (all six diffs are <= -0.157).
- **CI level.** 96.7% throughout (1 - 2 * alpha_per), the TOST convention,
  applied uniformly to the (a), (b) and transfer intervals as well as the (c)
  equivalence tests.
- **Endpoint.** Outcome-half NLL degradation = fp32 eval at the after-B
  checkpoint minus fp32 eval at ckpt_A, on the math OUTCOME_IDX eval texts,
  computed by `e6-ladder/src/eval_arms.py` for every arm. The outcome half is
  never touched by the L0 reservoir. Seed 0 builds all masks and never
  evaluates.

## Artifact index

Analysis: `e6-ladder/results/analysis_ladder.json` (all primaries, transfer,
diagnostics), `e6-ladder/results/outcome_ladder.json` (raw fp32 rows, one per
arm and seed, plus ckpt_A).

Gates: `gate_curvk2.json` (G1), `gate_l0.json` (G2), `gate_eval_repro.json`
(G3), `gate_lookahead.json` and `gate_capture_determinism.json` (G4), all in
`e6-ladder/results/`.

Scores and masks: `l0_scores_tinyllama-1.1b.npz`,
`k2_look{1,4,16}_s0_tinyllama-1.1b.npz`, `k2_b2full_s0_tinyllama-1.1b.npz`,
`k2_b2look4_s0_tinyllama-1.1b.npz` (in `e6-ladder/results/`);
`mask_lad{L0,L1,L4,L16,K2b2,L4b2}.npz` (in `e4-continual/data/`).

Code: `e6-ladder/src/` -- `analyze_ladder.py`, `eval_arms.py`, `ledger_zero.py`,
`lookahead.py`, `make_masks.py`, `prep_b2.py`. The analyzer's `--selftest` and
`--selftest-transfer` modes carry synthetic positive and RED cases for the pass
rules.

Registration: `e6-ladder/PREREG.md`. SHA256 hashes: `e6-ladder/results/MANIFEST_SHA256.txt`
covers both the ladder's own 12 artifacts (scores and masks) and the
load-bearing artifacts inherited from earlier programs it depends on
(mask_weights.npz, mask_curvK2.npz, the four mask_random_s{1..4}.npz,
k2_raw_s0_tinyllama-1.1b.npz, ckpt_A.pt, train_B2_fiction.jsonl), listed
under a separate labeled section in the same file.