Cyclic Transition Ladder Experiment

Finished2026-06-21imported · line YBenchmark Generalization Structured Execution and Compilers GitHub ↗

The one idea you need

Picture two hidden numbers on a clock face, where counting wraps past the top back to the start. Each step nudges them forward or back, or rules out positions. The network must apply that same wrap-around rule again and again, dozens of times in a row.

The question

When a model must keep updating its guess about hidden clock-style numbers using wrap-around arithmetic, does it need matching wrap-around parts, or is a bigger generic network enough?

What we found

It needs the matching wrap-around parts. A network built from clock-arithmetic moves stayed perfectly exact on programs three times longer than it practiced on. A plain generic network of the same size drifted down to just 6% exact answers, and feeding it clock-style coordinates made it slightly worse, not better. Structure wins here, not raw size.

Why it matters

When a model must apply the same wrap-around update over and over, don't just add parameters or reformat the inputs; give it the matching structural moves. Generic networks learn partial signal but steadily drift and plateau as programs grow longer.

Correct-answer confidence on the longest programs23% → 100%plain generic network vs. clock-structured network

Exact full-state confidence, stricter test6% → 100%same comparison at three times the practice length

Generic network dressed up with clock coordinatesstill about 4%exact full-state confidence — slightly worse than the plain generic network

Accuracy on a clock roughly three times bigger≈ 100%clock-structured network still near-perfect as the number range triples

On this page

Results at a glance
Overview
Report
Experiment log
Figures
Data files
Reproduce
Related

Results at a glance 4

Only clock-structured networks stay perfect on the longest programs

How to read

Five networks: a perfect rule-follower, a plain generic network, a generic network fed clock coordinates, and two built from clock-style parts. Two bars each — confidence in the correct answer and a stricter full-state match. Taller is better.

Takeaway → The two clock-structured networks reach full height, matching the perfect rule-follower, while both generic networks sit near the floor: structure, not size, solves it.

Data table

transition mode	query mass	strict belief mass
exact ceiling	100%	100%
MLP	22.6%	5.9%
Fourier MLP	18.4%	3.9%
cyclic mixer	100%	100%
primitive router	100%	100%

Numbers from report table (reports/cyclic_transition_ladder_paper.md, Main Results; matches analysis/first_k_ge_l_summary.csv)

Technical framing

Held-out length 24 (mod 31): only cyclic-structured transitions stay exact — Generic and Fourier MLP transitions collapse at length 24, while cyclic mixer and primitive router match the exact-rule ceiling at 100%.

Generic networks drift down as programs get longer; structured ones stay flat

How to read

Left-to-right is program length, stretching well past the length networks practiced on; height is confidence in the correct answer, higher being better. Each line is one network.

Takeaway → The two generic lines slope steadily downward as programs lengthen while the structured lines stay pinned at the top: generic networks lose the thread, structured ones don't.

Data table

held-out program length	exact ceiling	cyclic mixer	primitive router	MLP	Fourier MLP
4	100%	100%	100%	66.4%	60.2%
8	100%	100%	100%	50.3%	43.9%
12	100%	100%	100%	39.1%	33.1%
16	100%	100%	100%	31.4%	26.1%
24	100%	100%	100%	22.6%	18.4%

Numbers from report table (reports/cyclic_transition_ladder_paper.md, Main Results; matches analysis/first_k_ge_l_summary.csv)

Technical framing

Query mass vs program length (mod 31 main sweep) — Dense MLP variants degrade steadily with length (training saw lengths 1-8); structured transitions generalize exactly to 3x the training horizon.

Structured networks stay near-perfect even on a much bigger clock

How to read

Each group is a network; two bars compare its exact full-state confidence on the smaller number range versus a roughly tripled range. Taller bars are better.

Takeaway → The bars barely shrink when the number range triples, staying essentially full height: the structured approach holds up as the problem grows.

Data table

transition mode	mod 31, L=24 belief mass	mod 97, L=24 belief mass
exact ceiling	100%	100%
cyclic mixer	100%	99.8%
primitive router	100%	99.9%

Numbers from report tables (reports/cyclic_transition_ladder_paper.md, Main Results and Modulus-97 Scale Check)

Technical framing

Scale check: structured transitions stay near-exact at modulus 97 — Tripling the residue space barely dents the structured learners: 99.8-99.9% belief mass at length 24, with 100% route accuracy.

Softer routing sometimes mislabels a step yet still answers exactly

How to read

Left-to-right is task size; height is how often each network picks the exact intended update step, higher being better. Two bars compare a soft-gating network with a hard-picking one.

Takeaway → The soft-routing bars dip slightly below the always-perfect hard-routing bars on smaller tasks: it occasionally mislabels a step but still reads out the right answer.

Data table

Modulus (longest held-out length)	Cyclic mixer (soft)	Primitive router (hard)
Mod 7 (len 3)	89.6%	100%
Mod 11 (len 12)	91.2%	100%
Mod 31 (len 24)	94.3%	100%
Mod 97 (len 24)	100%	100%

Numbers from experiments/cyclic_transition_ladder/analysis/summary.md

Technical framing

Soft routing stays slightly imperfect while hard routing is exact — The cyclic mixer's soft routing misroutes ~5-10% at small moduli yet still reads out exactly; the hard router is always at 1.0.

In the author’s words from the Report · “Abstract”

At modulus 31, a generic MLP transition reaches only 22.6% query mass and 5.9% strict belief mass at held-out length 24. A Fourier-feature MLP is weaker, reaching 18.4% query mass and 3.9% belief mass. In contrast, a cyclic candidate mixer reaches 100.0% query mass and 100.0% belief mass through length 24. A learned primitive router also reaches 100.0%. A modulus-97 scale check keeps the structured variants essentially exact: 99.8% belief mass for the cyclic mixer and 99.9% for the primitive router at length 24.

Overview

This experiment tests which transition inductive bias is sufficient for a recurrent slot model to learn modular belief-state execution.

src/cyclic_transition_ladder_experiment.py: task generator, transition ladder models, checkpointing, and evaluation harness.
src/analyze_cyclic_transition_ladder.py: analysis and figure generation.
reports/cyclic_transition_ladder_experiment_log.md: chronological experiment log.
reports/cyclic_transition_ladder_paper.md: standalone written report.
reports/cyclic_transition_ladder_paper.html: standalone HTML report.
runs/: JSON and CSV run outputs.
analysis/: generated summaries and figures.
checkpoint_manifest.csv: checkpoint paths and sizes.

Checkpoints are written outside the experiment directory under:

../../large_artifacts/cyclic_transition_ladder/checkpoints/

Download this experiment directory for the normal research bundle. Download ../../large_artifacts/cyclic_transition_ladder/ only when saved model weights are needed.

Report

Rendered from reports/cyclic_transition_ladder_paper.md

Abstract

This experiment tests whether modular arithmetic structure is sufficient for a recurrent slot model to learn exact latent belief-state transitions. Each task starts with a hidden relation B = A + d (mod p), then applies arithmetic updates and observation filters to hidden registers A and B. The model is given the initial support in oracle slots, so the experiment isolates the transition learner.

The result is sharp. At modulus 31, a generic MLP transition reaches only 22.6% query mass and 5.9% strict belief mass at held-out length 24. A Fourier-feature MLP is weaker, reaching 18.4% query mass and 3.9% belief mass. In contrast, a cyclic candidate mixer reaches 100.0% query mass and 100.0% belief mass through length 24. A learned primitive router also reaches 100.0%. A modulus-97 scale check keeps the structured variants essentially exact: 99.8% belief mass for the cyclic mixer and 99.9% for the primitive router at length 24.

Task

Each example begins with:

B = A + d (mod p), with A unknown

The initial belief contains p possible (A,B) states. Programs contain arithmetic updates and observation filters:

A=A+c, A=A-c, B=B+c, B=B-c
A=A+B, B=B+A, A=A-B, B=B-A
A % m = r, B % m = r

Observation residues are sampled from the live support, so target beliefs are never empty. The final query asks for the distribution of A, B, A+B mod p, or A-B mod p.

Model

The recurrent state is a fixed set of weighted slots. Each slot contains:

logits over A,
logits over B,
one slot-weight logit.

The decoded belief is:

P(A,B) = sum_s softmax(w)_s * P_s(A) * P_s(B)

All reported runs use oracle initialization: slot a starts at (A=a, B=a+d). This makes the transition rule the only learned component.

Transition Ladder

Five transition modes are compared:

Mode	Description
Exact ceiling	Applies the known transition rule directly.
MLP	Uses expected slot embeddings, operation embeddings, and argument embeddings to predict new slot logits.
Fourier MLP	Replaces value embeddings with cyclic Fourier residue features before the MLP.
Cyclic mixer	Learns gates over equivariant candidate updates such as circular shifts, circular sums/differences, and observation conditioning.
Primitive router	Learns a soft route over exact equivariant transition primitives.

The cyclic mixer is less direct than the primitive router. It does not choose a single full operation primitive. Instead, it separately gates candidate updates for A, B, and the slot weights. This tests whether reusable cyclic update features are enough to recover exact behavior.

Protocol

Phase	Modulus	Training lengths	Evaluation lengths	Examples per length
Smoke	7	1-3	2, 3	128
Pilot	11	1-6	3, 6, 9, 12	512
Main	31	1-8	4, 8, 12, 16, 24	512
Scale	97	1-8	4, 8, 12, 16, 24	128

For each length L, headline rows report the first recurrent budget K such that K >= L.

Metrics:

decoder_query_target_mass: probability assigned to the exact final query support.
decoder_belief_target_mass: probability assigned to the exact final (A,B) support.
mean_slot_purity: average product of the strongest A probability and strongest B probability per slot.
mean_route_accuracy: route match for transition modes with explicit learned routing.

Smoke Results

Variant	Transition	L=2 query	L=2 belief	L=3 query	L=3 belief	L=3 route acc
Exact ceiling	exact	100.0%	100.0%	100.0%	100.0%	n/a
MLP	MLP	83.9%	57.0%	70.3%	45.3%	n/a
Fourier MLP	Fourier MLP	73.0%	36.5%	56.8%	24.5%	n/a
Cyclic mixer	cyclic mixer	100.0%	100.0%	100.0%	100.0%	89.6%
Primitive router	primitive router	100.0%	100.0%	100.0%	100.0%	100.0%

The smoke phase validates all code paths. The two structured transition modes recover exact held-out behavior on the small task.

Pilot Results

Variant	Transition	L=3 query	L=6 query	L=9 query	L=12 query	L=12 belief	L=12 route acc
Exact ceiling	exact	100.0%	100.0%	100.0%	100.0%	100.0%	n/a
MLP	MLP	73.7%	55.1%	44.8%	38.2%	16.4%	n/a
Fourier MLP	Fourier MLP	60.6%	38.4%	28.4%	23.1%	5.1%	n/a
Cyclic mixer	cyclic mixer	100.0%	100.0%	100.0%	100.0%	100.0%	91.2%
Primitive router	primitive router	100.0%	100.0%	100.0%	100.0%	100.0%	100.0%

The pilot shows a clean separation. Dense MLP transitions learn useful partial signal but do not learn the exact belief transition. The structured transition modes generalize exactly to lengths twice the training horizon.

Pilot belief mass

Main Results

Variant	Transition	L=4 query	L=8 query	L=12 query	L=16 query	L=24 query	L=24 belief	L=24 route acc
Exact ceiling	exact	100.0%	100.0%	100.0%	100.0%	100.0%	100.0%	n/a
MLP	MLP	66.4%	50.3%	39.1%	31.4%	22.6%	5.9%	n/a
Fourier MLP	Fourier MLP	60.2%	43.9%	33.1%	26.1%	18.4%	3.9%	n/a
Cyclic mixer	cyclic mixer	100.0%	100.0%	100.0%	100.0%	100.0%	100.0%	94.3%
Primitive router	primitive router	100.0%	100.0%	100.0%	100.0%	100.0%	100.0%	100.0%

Main belief mass

Main route accuracy

The main sweep identifies the bottleneck. Adding Fourier residue features to a generic MLP does not solve transition learning. Giving the model cyclic candidate updates does solve it.

Modulus-97 Scale Check

The scale check evaluates only the exact ceiling and the two structured learned transition modes.

Variant	Transition	L=4 query	L=8 query	L=12 query	L=16 query	L=24 query	L=24 belief	L=24 route acc
Exact ceiling	exact	100.0%	100.0%	100.0%	100.0%	100.0%	100.0%	n/a
Cyclic mixer	cyclic mixer	100.0%	100.0%	100.0%	99.9%	99.9%	99.8%	100.0%
Primitive router	primitive router	100.0%	100.0%	100.0%	100.0%	99.9%	99.9%	100.0%

Scale belief mass

The structured transition modes remain essentially exact at a much larger residue space. The small deviations from 100% are probability-mass deviations, while route accuracy is 100%.

Interpretation

The experiment supports a narrow claim:

The transition learner needs cyclic modular structure, not merely more dense parameters or residue features.

The oracle slot state already contains the correct initial support. The hard part is applying the same update rule repeatedly. A generic MLP can learn some task-level query signal, but its decoded belief remains far from exact at modulus 31. Fourier features expose cyclic coordinates, but do not enforce cyclic transition algebra. The cyclic mixer changes the learning problem: it offers the correct equivariant update families and trains a small controller to compose them.

The primitive router is the clean learned-dispatch ceiling. Its exact route accuracy confirms that a small controller can learn to select the right modular operation when the primitive library is available. The cyclic mixer is more interesting because its gates are factored by target component; exact decoded belief does not require every gate family to choose the canonical label.

Limitations

The experiment uses oracle slot initialization. It does not test whether a model can populate the slot memory from raw text or from a learned encoder.

The cyclic mixer contains hand-designed equivariant candidate updates. The result should be read as evidence for the required transition structure, not as evidence that a generic neural model will discover that structure unaided.

The task is symbolic and exactly generated. It is useful for isolating the transition mechanism, but it is not a natural-language reasoning benchmark.

Reproducibility

Run outputs are in:

experiments/cyclic_transition_ladder/runs/

Checkpoints are stored externally:

large_artifacts/cyclic_transition_ladder/checkpoints/

Regenerate analysis:

PYTHONDONTWRITEBYTECODE=1 python experiments/cyclic_transition_ladder/src/analyze_cyclic_transition_ladder.py

Example main run:

PYTHONDONTWRITEBYTECODE=1 python experiments/cyclic_transition_ladder/src/cyclic_transition_ladder_experiment.py \
  --variant_name main_cyclic_mixer \
  --modulus 31 \
  --observe_mod 5 \
  --observe_prob 0.3 \
  --slot_capacity 31 \
  --init_mode oracle \
  --transition_mode cyclic_mixer \
  --supervision full_belief \
  --slot_dim 96 \
  --hidden_dim 192 \
  --train_min_len 1 \
  --train_max_len 8 \
  --train_steps 800 \
  --batch_size 512 \
  --eval_lengths 4,8,12,16,24 \
  --eval_k 0,1,2,4,8,12,16,24 \
  --output_dir experiments/cyclic_transition_ladder/runs/main_cyclic_mixer \
  --checkpoint_dir large_artifacts/cyclic_transition_ladder/checkpoints/main_cyclic_mixer

Experiment log 12

Show the running log (12 entries, 2026-06-21)

Objective

Test whether modular arithmetic inductive bias is the missing ingredient for learning recurrent belief-state transitions in an oracle-initialized slot memory.

Each example starts from:

B = A + d (mod p), with A unknown

Programs apply arithmetic updates and observation filters over hidden registers A and B. The model receives the initial support in slots, then must update that support recurrently. The experiment varies only the transition architecture.

Primary Questions

Can a generic per-slot MLP learn the transition at small modulus but fail at larger modulus?
Do residue/Fourier features improve the generic MLP transition?
Does a cyclic candidate mixer learn scale-stable modular transitions?
Does a learned router over exact equivariant primitives provide an upper learnable-dispatch control?
How close do learned transition variants get to the exact transition ceiling?

Metrics

decoder_query_target_mass: probability assigned to the exact final query support after projecting the decoded slot belief.
decoder_belief_target_mass: probability assigned to the exact final (A,B) support.
decoder_belief_top1_on_support: whether the highest-probability pair is in the exact final support.
mean_slot_purity: mean product of the strongest A and B probabilities per slot.
mean_route_entropy: entropy of the learned transition routing distribution where applicable.
mean_route_accuracy: whether the highest-probability transition route matches the true operation where applicable.

The strict headline metric is decoder_belief_target_mass; query mass is the task-level readout metric.

Artifact Layout

Code and lightweight outputs: experiments/cyclic_transition_ladder/
Checkpoints: large_artifacts/cyclic_transition_ladder/checkpoints/
Run outputs: experiments/cyclic_transition_ladder/runs/<variant>/
Analysis outputs: experiments/cyclic_transition_ladder/analysis/

Planned Sequence

Smoke tests on modulus 7 to validate exact, MLP, Fourier MLP, cyclic mixer, and primitive-router transitions.
Pilot runs on modulus 11 to compare transition learnability under moderate scale.
Main runs on modulus 31 for the full ladder.
Optional scale run on modulus 97 if the main sweep identifies a promising learned transition.
Generate tables, figures, checkpoint manifest, standalone report, and HTML report.

Variant Plan

exact_ceiling: exact recurrent transition, no trainable parameters.
mlp: generic MLP transition from expected slot embeddings.
fourier_mlp: generic MLP transition with cyclic residue features.
cyclic_mixer: learned gates over equivariant candidate updates.
primitive_router: learned router over exact equivariant primitive updates.

2026-06-21 Setup

Created the standalone experiment directory:

experiments/cyclic_transition_ladder/src/
experiments/cyclic_transition_ladder/reports/
experiments/cyclic_transition_ladder/runs/
experiments/cyclic_transition_ladder/analysis/figures/
large_artifacts/cyclic_transition_ladder/checkpoints/

Next action: implement the transition ladder and run smoke tests.

2026-06-21 Smoke Tests

Implemented the training and evaluation harness:

Oracle slot initialization.
Exact, generic MLP, Fourier-feature MLP, cyclic-mixer, and primitive-router transitions.
Full prefix-belief supervision.
Decoded query and belief metrics.
Slot purity, route entropy, and route-accuracy diagnostics.
External checkpoint writing.
Analysis script and figures.

Ran five modulus-7 smoke variants with evaluation lengths 2 and 3:

Variant	Transition	Steps	L=2 query	L=2 belief	L=3 query	L=3 belief	L=3 route acc
`smoke_exact_ceiling`	exact	0	100.0%	100.0%	100.0%	100.0%	n/a
`smoke_mlp`	MLP	500	83.9%	57.0%	70.3%	45.3%	n/a
`smoke_fourier_mlp`	Fourier MLP	500	73.0%	36.5%	56.8%	24.5%	n/a
`smoke_cyclic_mixer`	cyclic mixer	500	100.0%	100.0%	100.0%	100.0%	89.6%
`smoke_primitive_router`	primitive router	500	100.0%	100.0%	100.0%	100.0%	100.0%

Smoke interpretation:

The exact ceiling confirms that generation, decoding, and K-indexed evaluation are wired correctly.
The generic MLP learns partially on the small task.
Fourier features alone do not improve the generic MLP in this short smoke run.
Both structured routed variants reach exact held-out smoke performance. The primitive router learns exact operation dispatch; the cyclic mixer reaches exact decoded belief even though its three gate families are not all perfectly one-hot.

Pilot decision:

Run all five transition modes at modulus 11.
Keep oracle initialization fixed.
Use training lengths 1-6 and held-out evaluation lengths 3, 6, 9, and 12.
Use the pilot to decide which learned transition modes deserve full modulus-31 budgets.

2026-06-21 Pilot Sweep

Ran five modulus-11 pilot variants with training lengths 1-6 and evaluation lengths 3, 6, 9, and 12:

Variant	Transition	Steps	L=3 query	L=6 query	L=9 query	L=12 query	L=12 belief	L=12 route acc
`pilot_exact_ceiling`	exact	0	100.0%	100.0%	100.0%	100.0%	100.0%	n/a
`pilot_mlp`	MLP	900	73.7%	55.1%	44.8%	38.2%	16.4%	n/a
`pilot_fourier_mlp`	Fourier MLP	900	60.6%	38.4%	28.4%	23.1%	5.1%	n/a
`pilot_cyclic_mixer`	cyclic mixer	600	100.0%	100.0%	100.0%	100.0%	100.0%	91.2%
`pilot_primitive_router`	primitive router	500	100.0%	100.0%	100.0%	100.0%	100.0%	100.0%

Pilot interpretation:

The exact ceiling remains perfect through held-out length 12.
The generic MLP learns a useful but incomplete transition at modulus 11.
Fourier residue features alone are weaker than the generic MLP.
The cyclic mixer exactly preserves the target belief through held-out length 12 after training only up to length 6.
The primitive router also stays exact and learns the direct operation route.
The cyclic mixer reaches exact decoded belief with route accuracy below 100%, indicating that the candidate families have some redundant routes.

Main decision:

Run the full five-variant ladder at modulus 31.
Use training lengths 1-8 and evaluation lengths 4, 8, 12, 16, and 24.
Keep exact and primitive-router rows as ceilings/controls.
Keep MLP and Fourier MLP rows as negative baselines even though the pilot is weak, because they define the value of adding cyclic transition structure.

2026-06-21 Main Sweep

Ran five modulus-31 main variants with training lengths 1-8 and evaluation lengths 4, 8, 12, 16, and 24:

Variant	Transition	Steps	L=4 query	L=8 query	L=12 query	L=16 query	L=24 query	L=24 belief	L=24 route acc
`main_exact_ceiling`	exact	0	100.0%	100.0%	100.0%	100.0%	100.0%	100.0%	n/a
`main_mlp`	MLP	1200	66.4%	50.3%	39.1%	31.4%	22.6%	5.9%	n/a
`main_fourier_mlp`	Fourier MLP	1200	60.2%	43.9%	33.1%	26.1%	18.4%	3.9%	n/a
`main_cyclic_mixer`	cyclic mixer	800	100.0%	100.0%	100.0%	100.0%	100.0%	100.0%	94.3%
`main_primitive_router`	primitive router	600	100.0%	100.0%	100.0%	100.0%	100.0%	100.0%	100.0%

Main interpretation:

The exact ceiling remains perfect at modulus 31.
The generic MLP fails to learn the exact recurrent transition at scale. At held-out length 24 it reaches only 22.6% query mass and 5.9% strict belief mass.
Fourier residue features are not enough. They underperform the generic MLP, reaching only 18.4% query mass and 3.9% belief mass at length 24.
The cyclic mixer reaches exact decoded belief at every evaluated length, including held-out length 24.
The primitive router also reaches exact decoded belief and exact operation route accuracy.
The cyclic mixer route accuracy is below 100% because its A, B, and weight gate families contain redundant correct routes; exact decoded belief is the stricter behavioral metric.

Scale decision:

Run a small modulus-97 scale check for the exact ceiling, cyclic mixer, and primitive router.
Do not run modulus-97 MLP baselines because both dense baselines already fail at modulus 31 and modulus-97 dense pair decoding is substantially more expensive.

2026-06-21 Modulus-97 Scale Check

Ran three modulus-97 variants with training lengths 1-8, evaluation lengths 4, 8, 12, 16, and 24, and 128 examples per evaluated length:

Variant	Transition	Steps	L=4 query	L=8 query	L=12 query	L=16 query	L=24 query	L=24 belief	L=24 route acc
`scale_exact_ceiling`	exact	0	100.0%	100.0%	100.0%	100.0%	100.0%	100.0%	n/a
`scale_cyclic_mixer`	cyclic mixer	300	100.0%	100.0%	100.0%	99.9%	99.9%	99.8%	100.0%
`scale_primitive_router`	primitive router	300	100.0%	100.0%	100.0%	100.0%	99.9%	99.9%	100.0%

Scale interpretation:

The structured transition variants transfer to a much larger residue space.
The cyclic mixer and primitive router remain essentially exact through length 24 after training only on lengths up to 8.
The small drop below 100% at length 24 is in probability mass, not top-level route selection; route accuracy is 100% for both learned scale variants.

Next action: write the standalone report and HTML artifact, generate the checkpoint manifest, and run the final audit.

2026-06-21 Final Audit

Report artifacts generated:

reports/cyclic_transition_ladder_paper.md
reports/cyclic_transition_ladder_paper.html

Consistency checks:

Source compilation passed for src/cyclic_transition_ladder_experiment.py and src/analyze_cyclic_transition_ladder.py.
The experiment directory is 6.0M and contains no .pt, .pth, or .ckpt files.
External artifacts are stored under large_artifacts/cyclic_transition_ladder/ and total 3.8M.
checkpoint_manifest.csv contains 14 rows; every listed checkpoint exists and matches the recorded byte count.
The HTML report references 3 local figure files, and all referenced figures exist.
There are 18 run directories, and each contains metrics_final.csv and results.json.
The standalone paper markdown and HTML were checked for backward-looking references to external experiment context; no matches were found.
No __pycache__ directories remain under the experiment directory.

Final status:

The experiment has its own subdirectory with source, runs, analysis, reports, checkpoint manifest, and a progress log.
Large model checkpoints are separated from the experiment directory and indexed by manifest.
The write-up is standalone and does not rely on any external experiment context.