# RESULT — 076 curriculum-path: is ladder-TAE anatomy PATH-DEPENDENT?

**Tier: T3-exploratory. DONE + HARVESTED.** tmux `c100_076` (driver, wave-1/2 train) +
`c100_076b` (watchdog-fix re-run of long2short) + `c100_076c` (eval+aggregate), box
`campaign100/076-curriculum-path/`, GPUs CVD 0/1/2 = phys 0/2/3 (dead GPU1 auto-excluded).
5 curricula over ONE fixed 500M-token pool at FIXED seed 0 (rung-A arm-D d_z=256, lr 5e-4
cosine, batch 512, max_len 64) — **only the presentation ORDER differs.** Anatomy eval reuses
075 verbatim (`eval_067.py` knee/recon/z GPU; `eval_operators.py` operators+Procrustes CPU;
`binding_battery.py` surfX/roleXflip CPU); `aggregate_076.py` compares cross-ORDER variance to
075's cross-SEED band.

## Verdict (headline) — a REVERSAL of the prereg's path-INDEPENDENT hypothesis

**Reconstruction anatomy is strongly PATH-DEPENDENT; the surface/relational code and operator
geometry are PATH-INDEPENDENT.** Holding data-multiset and seed fixed, reordering the 500M tokens
into a monotone curriculum (length or frequency) **collapses reconstruction fidelity** far outside
any seed band, while leaving the binding code and operator geometry intact. The mechanism is
**end-of-curriculum recency / catastrophic forgetting**, not divergence. This **refutes the frozen
core hypothesis P6 (path-INDEPENDENT, p=0.55)** and the strong recon prior **P1 (p=0.80)**.

| order | val_f1 | knee_tok | tokf1 L8 | tokf1 L62 | chrF L62 | surfX | roleXflip | ‖z‖ |
|---|---|---|---|---|---|---|---|---|
| random_a | **0.6447** | 21.1 | 0.820 | 0.456 | 34.6 | 0.725 | 0.280 | 9.38 |
| random_b | **0.6487** | 21.9 | 0.817 | 0.454 | 34.9 | 0.727 | 0.277 | 9.49 |
| short2long | 0.5202 | 54.3 | **0.197** | 0.459 | 35.0 | 0.695 | 0.301 | 10.38 |
| common2rare | 0.3996 | 14.3 | 0.317 | 0.187 | 15.8 | 0.712 | 0.287 | 10.15 |
| long2short | **0.1146** | 9.0 | 0.728 | **0.0003** | **0.01** | 0.636 | 0.361 | 10.44 |

- **order-CV(val_f1) over all 5 = 0.476** vs 075 cross-SEED CV **0.0046** → **~104× the seed band**
  (52× the pre-registered 2× threshold). Curriculum order dwarfs seed as a source of variance.
- **order-CV(knee) = 0.733** vs seed CV 0.025 → ~29×. Capacity knee is also strongly path-dependent.
- **order-CV(surfX) = 0.0533 ≤ 2× seed band (0.0558)**, roleXflip < 0.45 in ALL 5 → surface code is
  **path-ROBUST** (P3 TRUE), surviving even in the collapsed models.

## The mechanism: end-of-curriculum recency / catastrophic forgetting (per-length-bin token_f1)

Each monotone curriculum ends on a homogeneous slice and **forgets the opposite end**:
- **short2long** ends on LONG sentences → forgets SHORT: **L8 f1 0.82→0.197** (long-bins intact, L62 0.46). knee shifts up to 54 (only long prefixes reconstruct).
- **long2short** ends on SHORT sentences → catastrophically forgets LONG: **L62 f1 0.46→0.0003, chrF 34.6→0.01** (short-bins intact, L8 0.73). knee collapses to 9. Final val_f1 0.115 (best mid-run 0.513).
- **common2rare** ends on RARE tokens → degrades broadly (L8 0.32, L62 0.19, val_f1 0.40; best mid-run 0.634 at step 34k, then collapses on the rarest tail).

This is a clean recency signature: the FINAL data phase dominates the final weights. It is a
**trajectory/optimization effect, not a data-content effect** — the multiset is provably identical
(G3). Best-f1 mid-run (short2long 0.52, common2rare 0.63, long2short 0.51) shows the curricula reach
respectable reconstruction *before* the terminal phase erases it.

## G3 — token-multiset-identity control (the load-bearing control): PASS

All 5 arms share **IDENTICAL** `tgt_multiset_sha` (`81f48b1f…`) AND `src_multiset_sha`
(`f8a55f03…`), each consumed exactly **19,900,000 lines at pct_budget 1.0398**. Deterministic
per-line noise (crc32-seeded) made even the SRC multiset order-invariant. The path comparison is
therefore airtight: **every difference below is due to ORDER alone**, not data content or budget.

## Order-null floor (P5 TRUE) — mild reorderings ARE path-independent

random_a vs random_b (two independent reshuffles at fixed seed): Δval_f1 **0.004**, Δknee 0.75,
ΔsurfX 0.0027 — all within the 075 seed band. **Pure reshuffling ≈ seed variance.** Path-dependence
is not created by *any* reordering; it requires a *structured, monotone* curriculum whose terminal
phase is homogeneous. (This bounds the claim: it is about curriculum structure, not shuffling noise.)

## Operators (P4 FALSE, informative direction) — fixed seed ⇒ shared absolute z-basis

Across the two reshuffle orders, offset operators have **raw** cross-order cosine median **0.887**
and **aligned** 0.911 (≥ 075's cross-seed aligned 0.829; question 0.99, negation 0.97). P4 predicted
raw < 0.5 (operators "rotated across orders like seeds"). **Wrong direction, and that is the
finding:** at FIXED seed there is no re-rolled initialization, so there is **no rotation of the
z-basis** — raw cosine is already high without Procrustes. The absolute-direction non-identifiability
seen across seeds in 075 is driven by **initialization (seed), not data order**. (Operators for the
three collapsed curricula are computed but unreliable — a model at val_f1 0.11 has no trustworthy
operator geometry — so the cross-order operator comparison is limited to the reshuffle pair; thin,
noted as a limitation.)

## Watchdog-abort incident + fix provenance

Wave-2 `long2short` DIED **rc=3** at 59% budget: `train_curriculum.py`'s val-CE watchdog
(`ce > 1.5·best_ce` for 2 evals → `SystemExit(3)`, wrote `runs/long2short/DIVERGED`) fired as val CE
rose 4.75→8.85 while the curriculum crossed long→short sentences. `common2rare` survived rc=0 only by
luck (last periodic val_ce 4.85 vs threshold 4.875) then collapsed on its final eval. **The val-CE
watchdog is invalid for curriculum arms** — a curriculum deliberately shifts the data distribution,
so val CE rises transiently BY DESIGN (this is the SAME inappropriate watchdog that killed 074 v1).
**Fix (mirrors 074 v2, logged as PREREG_LITE §AMENDMENT, predictions FROZEN):** removed the
`ce > WATCHDOG_FACTOR·best_ce → EXIT_DIVERGED` path; the non-finite (NaN/inf) guards on train loss
and val CE remain the ONLY divergence catch. Re-ran ONLY long2short with the fixed trainer, SAME
pool/`stream_long2short.txt`/seed/500M budget (`c100_076b`). It sailed **past the previously-fatal
step 14000** and ran to pool exhaustion (final val_f1 0.115) — confirming the abort was a false
positive, and that long2short genuinely degrades (real path-dependence, not divergence). No re-run
hit the non-finite guard, so there was **no real divergence** in any arm. common2rare kept as-is
(completed rc=0 with final.pt; its collapse is a genuine end-of-curriculum result). Diverged evidence
archived at `runs/long2short_wd_abort/` (`out/long2short_wd_abort_DIVERGED.json`).

## Brier on P1–P6 (frozen prereg TEXT, scored over ALL 5 orders — the reversal, scored honestly)

| pred | p(true) | frozen claim | outcome | Brier |
|---|---|---|---|---|
| P1 | 0.80 | recon path-indep: order-CV≤2×seed AND all 5 val_f1∈[0.63,0.67], no collapse | **FALSE** (0.11–0.65; 3 collapse) | 0.640 |
| P2 | 0.65 | knee ≤3×seed AND long2short knee ≥ short2long knee | **FALSE** (CV 0.73≫; 9.0 < 54.3) | 0.4225 |
| P3 | 0.70 | surfX ≤2×seed AND roleXflip<0.45 in all 5 | **TRUE** (CV 0.053≤0.056; max 0.36) | 0.090 |
| P4 | 0.65 | ops raw<0.5 BUT aligned≥0.75 | **FALSE** (raw 0.887 — no rotation) | 0.4225 |
| P5 | 0.60 | random_a-vs-b Δ ≤ seed band (recon/knee/surfX) | **TRUE** | 0.160 |
| P6 | 0.55 | OVERALL path-indep: ≥3/4 invariants ≤2×seed | **FALSE** (2/4: surfX,ops only) | 0.3025 |

**Mean Brier = 0.340** (well above 075's 0.104 — the prereg's path-independent prior was wrong on
the reconstruction/knee axis, correct on the surface-code/null axis).

> **Scoring note (honesty):** `aggregate_076.py` mechanically reports mean_brier **0.173** and
> verdict "path-INDEPENDENT (4/4)". This is a **G4-gate ARTIFACT**, not the real result: the sanity
> gate (val_f1>0.5 AND tokf1_L8>0.5) excluded exactly the 3 curricula that collapsed (short2long
> fails on tokf1_L8=0.197; long2short & common2rare on val_f1), leaving `valid`={random_a, random_b}
> — the two reshuffles, which trivially match the seed band. The automated code scores its predicates
> over `valid` only, whereas the frozen prereg TEXT says "all 5". The honest score above uses the
> frozen text over all 5 orders. `atlas_076.json` retains the mechanical numbers for provenance; this
> table is authoritative. (Lesson: a sanity gate that excludes the treatment arms silently inverts the
> verdict — future curriculum aggregators must score the collapse explicitly, not gate it out.)

## Placement in Block I (training dynamics) — synthesis refinement

073 → *when* the surface/role code forms (mid-training, locked to reconstruction, diverse data).
074 → over-training on low-diversity data adds nothing: **"diversity, not compute, drives the code."**
075 → the anatomy is **seed-stable up to a z-basis rotation** (init-driven non-identifiability).
**076 adds the ORDER axis, and it splits the anatomy in two:**
- **Reconstruction fidelity & capacity (val_f1, knee) are PATH-DEPENDENT** — a monotone curriculum
  whose terminal phase is homogeneous erases competence on the opposite regime (recency/forgetting).
  Training *order* is a real lever on *what the model can reconstruct*, even at fixed data+seed.
- **The relational/surface code & operator geometry are PATH-INDEPENDENT** — surfX, anti-transfer,
  and (fixed-seed) operator directions are essentially unchanged across orders, robust even when
  reconstruction has collapsed. These are properties of *data + objective*, as 074/075 implied.

Refined one-liner: **074 says diversity (not compute) builds the relational code; 076 says training
ORDER (not just diversity) governs reconstruction fidelity — but the relational code, once formed, is
order-robust.** The 075 "up-to-rotation" non-identifiability is confirmed to be an *initialization*
phenomenon: fixed seed removes the rotation entirely (raw operator cosine 0.89, no Procrustes needed).

## Limitations
- 3 of 5 orders collapsed below the G4 sanity floor → the cross-order CV of the *anatomy* invariants
  is thin (the operator/surfX cross-order comparison effectively rests on the 2 reshuffles + partial
  short2long); the collapse itself is the robust, quantitative result, not the surviving-arm CVs.
- The path-dependence is specifically **terminal-phase recency**; we did not test whether a milder
  curriculum (e.g. interleaved or cosine-annealed mixing) or a replay buffer would recover fidelity —
  it very likely would. So the claim is "monotone curricula ending on a homogeneous slice are
  path-dependent," not "all reorderings matter" (P5 shows they do not).
- Operators on collapsed models are untrustworthy; excluded from the aligned comparison.
- Single rung/arm/seed (rung-A arm-D d_z=256, seed 0); T3-exploratory.

## Follow-up worth funding? **Y-modest.**
The reconstruction path-dependence is a clean, mechanistic recency/forgetting result that a
1-GPU-hour follow-up could sharpen: (a) mid-vs-final checkpoint anatomy for a curriculum arm (does the
*relational* code peak-and-hold while reconstruction peaks-and-forgets? the best-f1 milestones suggest
yes); (b) a replay/interleave control to confirm the effect is terminal-recency, not curriculum per se;
(c) does a length curriculum with a *balanced* final phase recover val_f1 to the 0.645 band. Lower
priority than new axes, but the "anatomy splits into order-robust structure + order-fragile fidelity"
finding is worth one confirmatory run before promotion above T3.