Dense Supervision Ladder Experiment

Finishedimported 2026-07-12imported · line YBenchmark Generalization Structured Execution and Compilers GitHub ↗

The one idea you need

Picture a card player tracking every hand an opponent could still hold as cards come down. Handing them one final answer teaches almost nothing; showing the full odds of every possibility at every step teaches the tracking skill itself.

The question

When a small model must track many still-possible answers through a step-by-step program, is the model too small, or is its training feedback too thin?

What we found

It's the feedback. With the model held fixed, training it on only one sampled final answer left it weak; showing it the full odds of every possible answer at every step roughly doubled how often it solved the hardest 24-step programs, from 9% to 19%, and left its internal tracking more readable than any other recipe. Even the richest feedback, though, left it far from accurate.

Why it matters

When a small model underperforms at multi-step tracking, invest in richer training targets — full answer distributions and per-step labels — before assuming it needs to be bigger. Expect that to narrow the gap on long chains, not close it.

Getting the hardest programs right9% → 19%share correct on 24-step programs: one final answer vs full step-by-step feedback

Getting short programs right51% → 74%same weak-to-rich feedback jump on 4-step programs

Readable internal tracking on hardest programsnear zero → about 5%only rich feedback makes the hidden state directly decodable

Best-case ceiling on hardest programsabout 1 in 519% correct even with the richest feedback

On this page

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

Results at a glance 7

More training feedback lifts accuracy at every program length

How to read

Each line is one training recipe. Horizontal axis is program length (longer is harder); vertical axis is how much probability lands on correct answers (higher is better). The top line saw the full odds of every possible answer at every step; the bottom saw only one final answer.

Takeaway → The full-feedback line sits above every other at every length, roughly doubling the single-answer line on the longest 24-step programs.

Data table

program length L (evaluated at K=L)	sampled final answer	exact final query distribution	prefix query distributions	sparse belief distillation	full belief distillation
4	51%	62%	72.8%	66.7%	74.1%
8	28.2%	39.4%	46.3%	42.4%	49.7%
12	20.5%	30.2%	34.1%	31.5%	35.8%
16	13.6%	22.2%	25.8%	22.8%	27.3%
24	9.4%	16.1%	18.5%	16.2%	19.4%

Numbers from experiments/dense_supervision_ladder/analysis/summary.md (Modulus 31 Ladder at K=L table)

Technical framing

Query accuracy by supervision strength (modulus 31) — With architecture fixed, richer training targets win at every length: full belief supervision roughly doubles sampled-label accuracy at L=24.

Only rich feedback leaves the internal tracking readable

How to read

Bars show how much of the hidden state can be read back as the set of still-possible answers, on the longest programs. One color reads the state as-is; the other trains a dedicated reader for it. Taller is better.

Takeaway → Only the two recipes that trained on possible-answer sets produce a readable state; the rest sit near zero.

Data table

supervision level	post-hoc probe	trained decoder
sampled final	1.2%	0.2%
soft final query	3.2%	0.2%
prefix query	4.3%	0.2%
sparse belief	3.2%	3%
full belief	4.8%	4.6%

Numbers from experiments/dense_supervision_ladder/analysis/summary.md (Modulus 31 Ladder at K=L table, L=24 rows)

Technical framing

Is the belief state decodable at length 24? (modulus 31) — Only belief-distilled conditions yield a working belief decoder at scale; full belief supervision gives the most recoverable state.

Giving the model a full thinking step per instruction matters

How to read

Both lines use the richest feedback. Horizontal axis is program length; vertical axis is accuracy (higher is better). The upper line gives one internal update per program instruction; the lower line cuts those updates short.

Takeaway → Accuracy roughly doubles whenever the model gets a full internal step per instruction, though it still fades on the longest programs.

Data table

program length L	K = L (full budget)	best K < L (truncated budget)
4	74.1%	52.6%
8	49.7%	28.7%
12	35.8%	18.8%
16	27.3%	12.7%
24	19.4%	6.4%

Numbers from experiments/dense_supervision_ladder/reports/dense_supervision_ladder_paper.md (Section 6 K-Scaling table)

Technical framing

Recurrent budget matters: full-belief accuracy with K=L vs best K<L — Performance jumps when the recurrent budget K reaches the program length, but accuracy still degrades with length even under full supervision.

A simpler warm-up task shows the same ordering

How to read

The same recipes on an easier version of the task. Each line is a training recipe; horizontal axis is program length, vertical axis is accuracy (higher is better).

Takeaway → The recipes stack in the same order as the main task, so richer feedback winning is not a fluke.

Data table

program length L (evaluated at K=L)	sampled final answer	exact final query distribution	prefix query distributions	sparse belief distillation	full belief distillation
3	69.1%	81.7%	90.2%	86.8%	90.9%
6	48.1%	60.5%	70.9%	62.8%	71.3%
9	35.8%	46.8%	56.9%	47.8%	57.7%
12	28.9%	39.2%	45.3%	38.8%	45.7%

Numbers from experiments/dense_supervision_ladder/analysis/summary.md (Modulus 11 Pilot at K=L table)

Technical framing

Pilot (modulus 11) shows the same supervision ordering — The smaller modulus-11 diagnostic reproduces the ladder: prefix targets are a big jump and full belief distillation is best overall.

Sums and differences are harder than direct reads

How to read

Bars group four question kinds — read the first register, read the second, their sum, their difference — with one bar per training recipe. Taller means the top guess was a valid answer more often (higher is better).

Takeaway → Sum and difference questions sit below plain reads for every recipe, and full feedback is tallest on three of the four question kinds, edged out by prefix feedback on sums.

Data table

Query type	Sampled final	Soft final query	Prefix query	Sparse belief	Full belief
A	12.9%	24.2%	23.8%	21.9%	25.8%
B	14.8%	25.8%	25%	22.3%	28.1%
A + B (mod 31)	12.5%	16%	23%	17.2%	21.5%
A − B (mod 31)	9.8%	16.8%	20.7%	21.5%	23.8%

Numbers from analysis/mod31_ladder_per_query_threshold_summary.csv

Technical framing

Accuracy by query type at length 24: sums and differences are hardest — Direct reads of A or B beat arithmetic queries for every supervision; the supervision ordering holds across all four query types.

Readable tracking fades with length but rich feedback keeps the lead

How to read

Each line is a training recipe. Horizontal axis is program length; vertical axis is how much of the still-possible-answer set can be read from the hidden state (higher is better).

Takeaway → Every line drops as programs lengthen, but the full-feedback line stays highest at every length, not only the longest.

Data table

Sequence length L (evaluated at K = L)	Sampled final	Soft final query	Prefix query	Sparse belief	Full belief
4	12.9%	21.3%	39.5%	29.4%	49.4%
8	4%	9.1%	15.3%	11.8%	21.5%
12	2.7%	6.2%	8.8%	7%	11.8%
16	1.8%	4.7%	6.2%	4.8%	7.9%
24	1.2%	3.2%	4.3%	3.2%	4.8%

Numbers from analysis/mod31_ladder_threshold_summary.csv

Technical framing

Linear-probe decodability of the belief state across sequence length — Probe decodability decays with length for every supervision, but full-belief keeps the largest readable margin at every L, not just L = 24.

Longer programs actually narrow down to fewer possible answers

How to read

Two lines count how many answers remain consistent with the clues as the program runs; horizontal axis is program length. Lower means fewer candidates left.

Takeaway → By the longest programs only about one or two answers remain, so lower accuracy there reflects harder reasoning, not more choices.

Data table

Sequence length L	Query support size	Belief support size
4	11.5	13.4
8	5.68	6.74
12	3.83	4.3
16	2.4	2.65
24	1.54	1.64

Numbers from analysis/mod31_ladder_threshold_summary.csv

Technical framing

The task itself sharpens with length: candidate answer sets shrink — By L = 24 only ~1.5-1.6 answers remain consistent on average, so falling accuracy at long lengths reflects harder inference, not more options.

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

At K=L, query target mass at length 24 rises from 9.4% with sampled final labels to 16.1% with exact final query distributions, 18.5% with prefix query supervision, and 19.4% with full belief distillation. Full belief supervision is best at every evaluated length and is the only condition that trains a useful belief decoder at scale.

Overview

This experiment tests which training signal is sufficient for a recurrent model with a fixed-width dense hidden state to learn modular belief-state execution.

src/dense_supervision_ladder_experiment.py: training, probing, and evaluation harness.
src/analyze_dense_supervision_ladder.py: analysis and figure generation.
reports/dense_supervision_ladder_experiment_log.md: chronological experiment log.
reports/dense_supervision_ladder_paper.md: standalone written report.
reports/dense_supervision_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/dense_supervision_ladder/checkpoints/

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

Report

Rendered from reports/dense_supervision_ladder_paper.md

A controlled experiment on how much supervision a dense recurrent state needs to learn modular belief execution

Abstract

This experiment tests whether a fixed-width dense recurrent hidden state can learn to execute modular belief programs, and which training signal is strong enough to make that happen. Each example begins with an uncertain pair of registers constrained by B=A+d (mod p). A program then applies modular arithmetic updates and bucket observations. The exact belief state is a distribution over (A,B) pairs, but the executor itself stores only a dense vector.

Five training objectives are compared under the same architecture: one sampled final query label, the exact final query distribution, exact query distributions at every prefix, sparse belief-state distillation, and full belief-state distillation. Evaluation always uses exact final query distributions and exact final pair beliefs. A frozen post-hoc belief probe is also trained after each executor run.

On the scaled modulus-31 task, trained on lengths 1-8 and evaluated on lengths 4, 8, 12, 16, and 24, supervision strength is the dominant bottleneck. At K=L, query target mass at length 24 rises from 9.4% with sampled final labels to 16.1% with exact final query distributions, 18.5% with prefix query supervision, and 19.4% with full belief distillation. Full belief supervision is best at every evaluated length and is the only condition that trains a useful belief decoder at scale.

Lay Summary

The model starts with partial knowledge:

B = A + d (mod p)

That relation leaves many possible (A,B) worlds. A program changes the registers and sometimes filters possible worlds:

A = A + 7
observe B % 5 = 3
B = B - A
query A + B

The experiment asks how much training signal is required before a dense recurrent state learns to act like a belief executor. A single sampled answer is weak. Giving the whole final answer distribution is better. Giving targets at every prefix is much better. Giving the full belief state at every prefix is best and also makes the internal state directly decodable.

1. Question

The central question is:

Is the dense recurrent substrate the bottleneck, or is weak supervision the bottleneck?

The ladder is designed to answer that by holding the architecture fixed and increasing only the target information supplied during training.

The five objectives are:

Objective	Training target
`sampled_final`	One sampled final query value
`soft_final_query`	Exact final query distribution
`prefix_query`	Exact query distribution at every executed prefix
`sparse_belief`	Prefix query targets plus belief distillation on sampled prefix states
`full_belief`	Prefix query targets plus belief distillation on every prefix state

If full_belief fails, the dense recurrent state is likely too weak for the task. If full_belief succeeds while weaker objectives fail, the main bottleneck is training signal.

2. Task

Programs operate over two registers modulo p. The initial belief is:

{(A, B): B = A + d mod p}

For p=31, the full state space has 31 * 31 = 961 register pairs, and the initial support contains 31 pairs.

Operations:

Operation	Meaning
`A=A+c`	add a constant to `A`
`A=A-c`	subtract a constant from `A`
`B=B+c`	add a constant to `B`
`B=B-c`	subtract a constant from `B`
`A=A+B`	add `B` into `A`
`B=B+A`	add `A` into `B`
`A=A-B`	subtract `B` from `A`
`B=B-A`	subtract `A` from `B`
`OBS_A_BUCKET`	filter to states where `A % m = r`
`OBS_B_BUCKET`	filter to states where `B % m = r`

Observation residues are sampled from the current support, so the target support is never empty. The scaled run uses p=31, observation modulus 5, and observation probability 0.3.

Each example samples one query type:

Query	Distribution
`A`	final distribution of `A`
`B`	final distribution of `B`
`A_PLUS_B`	final distribution of `A+B mod p`
`A_MINUS_B`	final distribution of `A-B mod p`

Training lengths are 1-8 for the scaled run. Evaluation lengths are 4, 8, 12, 16, and 24. Lengths 12, 16, and 24 test beyond the training range.

3. Model

All ladder levels use the same dense recurrent executor. The model embeds the initial relation parameter d, embeds program instructions, then updates a dense hidden state with a recurrent cell. The recurrent budget K controls how many program instructions can be consumed. The final hidden state feeds a query head. Belief-supervised variants also train a belief decoder from the recurrent hidden state to a distribution over (A,B) pairs.

The recurrent state is not an explicit categorical table. Exact pair beliefs are used to generate labels and evaluation metrics, but the executor state remains a fixed-width dense vector.

After executor training, a separate post-hoc MLP probe is trained with the executor frozen. This tests whether exact pair-belief information is recoverable from the hidden state even when it was not part of the executor loss.

4. Metrics

Primary query metrics:

Metric	Meaning
`query_target_mass`	Total probability assigned to exact final query support
`query_top1_on_support`	Whether the most likely query value is in the exact support
`query_target_nll`	Cross-entropy against the exact final query distribution

Belief audit metrics:

Metric	Meaning
`probe_belief_target_mass`	Post-hoc probe probability assigned to exact final `(A,B)` support
`decoder_belief_target_mass`	Trained decoder probability assigned to exact final `(A,B)` support
`*_top1_on_support`	Whether the most likely pair is in the exact support

The headline summaries report the first evaluated K satisfying K>=L, which is K=L for all evaluated lengths here.

5. Main Result

The scaled modulus-31 ladder separates cleanly.

Modulus 31 query mass ladder

Modulus 31 probe belief ladder

Modulus 31 decoder belief ladder

At K=L, averaged across query types:

Supervision	L=4 query	L=8 query	L=12 query	L=16 query	L=24 query	L=24 probe belief	L=24 decoder belief
Sampled final	51.0%	28.2%	20.5%	13.6%	9.4%	1.2%	0.2%
Soft final query	62.0%	39.4%	30.2%	22.2%	16.1%	3.2%	0.2%
Prefix query	72.8%	46.3%	34.1%	25.8%	18.5%	4.3%	0.2%
Sparse belief	66.7%	42.4%	31.5%	22.8%	16.2%	3.2%	3.0%
Full belief	74.1%	49.7%	35.8%	27.3%	19.4%	4.8%	4.6%

The order is informative:

sampled_final is weakest. It learns some recurrent behavior but little long-chain belief structure.
soft_final_query is a large improvement, so exact final distributions are much better labels than sampled values.
prefix_query is the largest query-performance jump, showing that per-step targets strongly help recurrent execution.
sparse_belief trains a decoder above chance but costs query performance under this budget.
full_belief is best at every evaluated length and trains the strongest decoder.

6. K-Scaling

The K curves show that the recurrent budget matters: performance is weak for small K and rises when K reaches the program length.

Full belief query mass heatmap

Full belief decoder mass heatmap

Full-belief query mass by length:

Length	Best query mass for `K<L`	Query mass at `K=L`	Probe belief at `K=L`	Decoder belief at `K=L`
4	52.6%	74.1%	49.4%	51.4%
8	28.7%	49.7%	21.5%	21.7%
12	18.8%	35.8%	11.8%	11.3%
16	12.7%	27.3%	7.9%	7.4%
24	6.4%	19.4%	4.8%	4.6%

The absolute scores still degrade with length. Full supervision does not solve length generalization, but it makes the dense state much more useful than weak final labels.

7. Pilot Diagnostic

A smaller modulus-11 diagnostic used the same ladder with training lengths 1-6 and evaluation lengths 3, 6, 9, and 12. It served as a fast check before scaling the full ladder.

At K=L, averaged across query types:

Supervision	L=3 query	L=6 query	L=9 query	L=12 query	L=12 probe belief	L=12 decoder belief
Sampled final	69.1%	48.1%	35.8%	28.9%	9.9%	1.7%
Soft final query	81.7%	60.5%	46.8%	39.2%	20.1%	1.7%
Prefix query	90.2%	70.9%	56.9%	45.3%	26.4%	1.7%
Sparse belief	86.8%	62.8%	47.8%	38.8%	20.6%	17.5%
Full belief	90.9%	71.3%	57.7%	45.7%	30.2%	28.9%

The diagnostic matches the scaled result: prefix query supervision is a large jump, and full belief supervision is the best overall condition.

8. Interpretation

The experiment supports a specific mechanism claim:

The dense recurrent executor can host useful belief-state computation, but weak sampled final-answer supervision is not enough to train it well.

The strongest evidence is that full_belief succeeds more than sampled_final under the same architecture. That rules out the simple explanation that the dense recurrent substrate alone is too weak. The substrate can carry useful belief information when the target exposes it.

The result also shows that exact belief supervision is not a magic solution. At length 24 and modulus 31, full-belief query mass is 19.4%, not near exact execution. The architecture and optimizer still struggle with long-chain generalization. The practical lesson is that dense recurrent execution needs both a better objective and likely stronger architecture or curriculum to become high fidelity.

9. Reproducibility

Main scaled command pattern:

python experiments/dense_supervision_ladder/src/dense_supervision_ladder_experiment.py \
  --mode dense --supervision <level> \
  --modulus 31 --observe_mod 5 --observe_prob 0.3 \
  --train_max_len 8 --eval_lengths 4,8,12,16,24 --eval_k 0,1,2,4,8,12,16,24 \
  --train_steps 2000 --batch_size 256 --eval_batch_size 256 --eval_examples 256 \
  --probe_steps 800 --probe_batch_size 256 \
  --state_dim 256 --instr_dim 128 \
  --log_every 250 --probe_log_every 200 \
  --lr 0.001 --probe_lr 0.001 \
  --output_dir experiments/dense_supervision_ladder/runs/main_<level>_mod31 \
  --checkpoint_dir large_artifacts/dense_supervision_ladder/checkpoints/main_<level>_mod31

Analysis command:

python experiments/dense_supervision_ladder/src/analyze_dense_supervision_ladder.py

Key artifacts:

Artifact	Path
Experiment log	`reports/dense_supervision_ladder_experiment_log.md`
Analysis summary	`analysis/summary.md`
Main threshold table	`analysis/mod31_ladder_threshold_summary.csv`
Per-query threshold table	`analysis/mod31_ladder_per_query_threshold_summary.csv`
Full metrics table	`analysis/all_metrics_long.csv`
Checkpoint manifest	`checkpoint_manifest.csv`

Large checkpoint files are stored outside the experiment directory under ../../large_artifacts/dense_supervision_ladder/checkpoints/.

Experiment log 9

Show the running log (9 entries)

Objective

Test which level of supervision is sufficient for a dense recurrent hidden state to learn sequential modular belief execution.

The model keeps a fixed-width dense vector. It does not store an explicit categorical table as its recurrent state. The experiment compares a ladder of increasingly informative executor training objectives:

sampled_final: one sampled final query label.
soft_final_query: exact final query distribution.
prefix_query: exact query distributions at every executed prefix.
sparse_belief: prefix query supervision plus exact belief distillation on a sampled subset of prefix states.
full_belief: prefix query supervision plus exact belief distillation on every executed prefix state.

Exact final query distributions and exact final belief distributions are used for evaluation. A frozen post-hoc belief probe is trained after executor training for all variants. Variants with belief distillation also have a trained belief decoder, which is evaluated separately from the post-hoc probe.

Hypothesis

If the dense recurrent architecture can host the belief algorithm but the sampled final-answer objective is too weak, then stronger supervision should lift the same architecture substantially:

sampled_final should show the weakest K-threshold.
soft_final_query should improve final query calibration but may not produce a strong belief state.
prefix_query should improve recurrent execution because every internal step receives query-level pressure.
sparse_belief should show whether occasional exact state targets are enough to stabilize the dense representation.
full_belief should reveal whether the architecture can represent the belief state at all.

If full_belief fails, the dense recurrent substrate is likely the bottleneck. If full_belief succeeds but weaker variants fail, the objective is the bottleneck.

Task

Initial belief:

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

Programs contain modular arithmetic updates over A and B, plus observation filters of the form A % m = r or B % m = r. Observation residues are sampled from the current support so the target support is never empty.

Each example samples one final query type:

A
B
A+B mod p
A-B mod p

The supervision ladder changes what target information is used during training. Evaluation always measures exact final query support mass, exact final query top-1 support membership, post-hoc probe belief support mass, and trained belief-decoder support mass.

Planned Sequence

Implement ladder losses and trained belief decoder.
Smoke test at tiny modulus.
Run a small-modulus pilot across all ladder levels.
Analyze the pilot and tune run budget if needed.
Run the scaled modulus-31 ladder.
Aggregate metrics, generate figures, and write a standalone report.

Implementation Notes

Implemented:

Dense recurrent executor with query head and trained belief decoder.
Supervision ladder choices: sampled_final, soft_final_query, prefix_query, sparse_belief, full_belief.
Exact query-distribution projection from pair distributions.
Prefix query loss over executed prefix states.
Sparse/full belief distillation losses over executed prefix states.
Final evaluation rows with query metrics, post-hoc probe belief metrics, and trained decoder belief metrics.

Smoke Test: Modulus 7 Ladder

Runs:

../runs/smoke_sampled_final_mod7
../runs/smoke_soft_final_query_mod7
../runs/smoke_prefix_query_mod7
../runs/smoke_sparse_belief_mod7
../runs/smoke_full_belief_mod7

Command pattern:

python experiments/dense_supervision_ladder/src/dense_supervision_ladder_experiment.py --mode dense --supervision <level> --modulus 7 --observe_mod 3 --observe_prob 0.4 --train_max_len 3 --eval_lengths 2,3 --eval_k 0,1,2,3 --train_steps 2 --batch_size 16 --eval_batch_size 16 --eval_examples 16 --probe_steps 2 --probe_batch_size 16 --state_dim 32 --instr_dim 16 --log_every 1 --probe_log_every 1 --lr 0.001 --probe_lr 0.001 --output_dir experiments/dense_supervision_ladder/runs/smoke_<level>_mod7 --checkpoint_dir large_artifacts/dense_supervision_ladder/checkpoints/smoke_<level>_mod7

Status: complete.

Result: all five supervision levels compile, train, probe, evaluate, write CSV/JSON outputs, and save checkpoints.

Bug found and fixed: the first prefix-query smoke showed qloss=0.0000. The projection helper used out[mask].scatter_add_, which mutates an indexed copy rather than the output tensor. The helper now scatters into a temporary tensor and assigns it back to out[mask]. After the fix, prefix_query, sparse_belief, and full_belief all report nonzero query losses.

Interpretation: the full ladder path is functional. The smoke runs are intentionally too short to test learning.

Pilot: Modulus 11 Ladder

Runs:

../runs/pilot_sampled_final_mod11
../runs/pilot_soft_final_query_mod11
../runs/pilot_prefix_query_mod11
../runs/pilot_sparse_belief_mod11
../runs/pilot_full_belief_mod11

Command pattern:

python experiments/dense_supervision_ladder/src/dense_supervision_ladder_experiment.py --mode dense --supervision <level> --modulus 11 --observe_mod 4 --observe_prob 0.3 --train_max_len 6 --eval_lengths 3,6,9,12 --eval_k 0,1,2,3,6,9,12 --train_steps 1200 --batch_size 256 --eval_batch_size 256 --eval_examples 256 --probe_steps 600 --probe_batch_size 256 --state_dim 256 --instr_dim 128 --log_every 200 --probe_log_every 100 --lr 0.001 --probe_lr 0.001 --output_dir experiments/dense_supervision_ladder/runs/pilot_<level>_mod11 --checkpoint_dir large_artifacts/dense_supervision_ladder/checkpoints/pilot_<level>_mod11

Status: complete.

Aggregated final-query metrics at K=L, averaged across the four query types:

supervision	L=3 qmass	L=6 qmass	L=9 qmass	L=12 qmass	L=12 probe belief	L=12 decoder belief
`sampled_final`	69.1%	48.1%	35.8%	28.9%	9.9%	1.7%
`soft_final_query`	81.7%	60.5%	46.8%	39.2%	20.1%	1.7%
`prefix_query`	90.2%	70.9%	56.9%	45.3%	26.4%	1.7%
`sparse_belief`	86.8%	62.8%	47.8%	38.8%	20.6%	17.5%
`full_belief`	90.9%	71.3%	57.7%	45.7%	30.2%	28.9%

Interpretation:

sampled_final learns a weak recurrent threshold but leaves little recoverable belief information at longer lengths.
soft_final_query improves both final query mass and post-hoc belief readability, showing that exact final distributions are a better objective than sampled labels.
prefix_query produces a large gain, implying that per-step query supervision is a high-leverage training signal for this dense recurrent substrate.
sparse_belief trains a nontrivial decoder, but the sparse distillation objective underperforms prefix-query on final query mass at this pilot budget.
full_belief matches or slightly exceeds prefix-query on final query mass and also trains a useful belief decoder, making it the strongest pilot variant.

Decision for scaled run: run the complete five-level ladder at modulus 31. The scaled run should preserve the full ladder, because the pilot shows useful separation across all adjacent supervision levels. Use a moderate budget rather than a single long run so the final result can compare the whole ladder under one matched protocol.

Main Run: Modulus 31 Ladder

Runs:

../runs/main_sampled_final_mod31
../runs/main_soft_final_query_mod31
../runs/main_prefix_query_mod31
../runs/main_sparse_belief_mod31
../runs/main_full_belief_mod31

Command pattern:

python experiments/dense_supervision_ladder/src/dense_supervision_ladder_experiment.py --mode dense --supervision <level> --modulus 31 --observe_mod 5 --observe_prob 0.3 --train_max_len 8 --eval_lengths 4,8,12,16,24 --eval_k 0,1,2,4,8,12,16,24 --train_steps 2000 --batch_size 256 --eval_batch_size 256 --eval_examples 256 --probe_steps 800 --probe_batch_size 256 --state_dim 256 --instr_dim 128 --log_every 250 --probe_log_every 200 --lr 0.001 --probe_lr 0.001 --output_dir experiments/dense_supervision_ladder/runs/main_<level>_mod31 --checkpoint_dir large_artifacts/dense_supervision_ladder/checkpoints/main_<level>_mod31

Status: complete.

Aggregated final-query metrics at K=L, averaged across the four query types:

supervision	L=4 qmass	L=8 qmass	L=12 qmass	L=16 qmass	L=24 qmass	L=24 probe belief	L=24 decoder belief
`sampled_final`	51.0%	28.2%	20.5%	13.6%	9.4%	1.2%	0.2%
`soft_final_query`	62.0%	39.4%	30.2%	22.2%	16.1%	3.2%	0.2%
`prefix_query`	72.8%	46.3%	34.1%	25.8%	18.5%	4.3%	0.2%
`sparse_belief`	66.7%	42.4%	31.5%	22.8%	16.2%	3.2%	3.0%
`full_belief`	74.1%	49.7%	35.8%	27.3%	19.4%	4.8%	4.6%

Interpretation:

The ladder separates cleanly at modulus 31. Stronger supervision increases query mass and belief-state readability under the same architecture and training budget.
sampled_final is a weak objective for this task: it learns a K-dependent signal, but its long-chain accuracy and belief readability remain low.
soft_final_query is a large improvement over sampled labels, so exact final distributions matter.
prefix_query is the largest jump in query performance, showing that per-step query supervision is highly useful for training recurrent execution.
sparse_belief trains a decoder above chance but underperforms prefix_query on query mass; sampled state distillation is not enough to justify its optimization cost in this configuration.
full_belief is best at every evaluated length and trains a decoder whose belief mass tracks the post-hoc probe, so the dense recurrent state can represent useful belief information when the objective directly asks for it.

Decision: no extra extension run is needed for the primary claim. The matched five-level ladder already identifies the main bottleneck as supervision strength rather than the dense recurrent substrate alone. A longer full_belief run could improve absolute scores, but it would not replace the matched ladder as the central evidence.