Dense Latent Query Executor Experiment

Results at a glance 8

Overview

This experiment tests whether a recurrent model with a fixed-width dense hidden state can learn modular belief-state execution from one sampled final query value per example.

Contents

• src/dense_latent_query_executor_experiment.py: training, probing, and evaluation harness.
• src/analyze_dense_latent_query_executor.py: analysis and figure generation.
• reports/dense_latent_query_executor_paper.md: standalone writeup.
• reports/dense_latent_query_executor_paper.html: standalone HTML report.
• reports/dense_latent_query_executor_experiment_log.md: chronological experiment log.
• runs/: JSON and CSV run outputs.
• analysis/: generated summaries and figures.
• checkpoint_manifest.csv: paths and sizes for saved checkpoints.

Checkpoints are written outside the experiment directory under:

../../large_artifacts/dense_latent_query_executor/checkpoints/

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

Report

Rendered from reports/dense_latent_query_executor_paper.md

A controlled experiment on whether a fixed-width hidden state can learn sequential belief execution from one sampled final answer

Abstract

This experiment tests whether a recurrent runtime with an ordinary dense hidden vector can learn to execute modular arithmetic and observation-filter programs when the loss supplies only one sampled final query value per example. Each example starts with an unknown pair of registers constrained by B=A+d (mod p). A program applies arithmetic updates and bucket observations. The model receives one query type such as A, B, A+B, or A-B, and the training label is one value sampled from the exact final query distribution.

The full final query distribution and full final belief distribution over (A,B) pairs are withheld from the loss and used only for evaluation. A separate frozen post-hoc probe is trained after executor training to test whether the dense hidden state contains recoverable belief-state information.

On the scaled modulus-31 task, trained on lengths 1-8 and evaluated on lengths 4, 8, 12, 16, and 24, the dense recurrent executor shows a real compute threshold: performance rises when internal recurrent steps K reach program length L. At the first K>=L, exact query target mass is 70.2%, 49.3%, 36.1%, 29.6%, and 21.5% for lengths 4, 8, 12, 16, and 24. A matched static compiler reaches 50.4%, 26.9%, 13.6%, 9.0%, and 5.5%. The dense recurrent state is therefore doing useful sequential work, but the result is not near-exact: sampled query supervision plus a generic dense state is insufficient to learn a high-fidelity belief executor at this scale.

Lay Summary

The model starts with partial knowledge:

B = A + d (mod p)

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

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

Training gives only one sampled final answer value. It does not give the whole answer distribution, and it does not give the set of possible (A,B) worlds. The question is whether a dense recurrent hidden state learns a reusable internal executor anyway.

The answer is mixed. The dense recurrent model does learn something sequential: it improves sharply once it has enough internal steps to read the whole program, and it beats a static one-pass compiler on held-out lengths. But the learned dense state is approximate. It is much better than the static control, not a solved belief machine.

1. Question

The experiment asks whether sampled-answer supervision can induce a latent recurrent executor in a generic dense hidden state.

The target evidence has five parts:

1. Query quality should depend on internal step budget K.
2. The threshold should align with program length L: weak when K<L, stronger when K>=L.
3. The threshold should hold beyond the training length range.
4. A post-hoc probe should recover nontrivial belief information from the dense state.
5. Static and order-destroying controls should be weaker.

This is a controlled mechanism test. It is not an open-ended language benchmark. The goal is to isolate whether recurrent latent computation emerges from low-bandwidth final-answer supervision.

2. Task

Programs operate over two registers modulo p.

Initial belief:

{(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:

Observation residues are sampled from the live support, so every target support is non-empty. For the scaled run, p=31, observation modulus is 5, and each instruction is an observation with probability 0.3.

Each example samples one final query type:

The training label is one value sampled from the exact query distribution. Evaluation computes the exact final query distribution and exact final pair belief.

Training used lengths 1-8. Evaluation used lengths 4, 8, 12, 16, and 24. Lengths 12, 16, and 24 test length generalization.

3. Models

Dense Recurrent Executor

The primary model stores only a dense hidden vector. It embeds the initial relation parameter d, then updates the hidden vector with a GRU-style cell, one program instruction per internal recurrent step. A query head maps the hidden state to logits over all query values for all query types.

The dense state is not a categorical belief table and receives no direct belief supervision.

Static Compiler Control

The static control receives the whole program and initial relation, processes the instruction sequence with a small Transformer encoder, pools the sequence, and predicts query logits in one pass. It has no recurrent execution axis and no variable internal step budget.

Shuffled Recurrent Control

The shuffled recurrent control uses the same dense recurrent architecture as the primary model, but it sorts each program's active instructions before execution. This preserves instruction content while destroying the original order.

Frozen Belief Probe

After executor training, the executor is frozen. A separate MLP probe maps hidden states to distributions over (A,B) pairs. For the recurrent model, the probe is trained on hidden states from training-length prefixes. For the static model, it is trained on the final pooled state. Probe metrics audit hidden-state information; they are not executor training losses.

4. Metrics

The primary metrics evaluate the exact final query distribution:

• query_target_mass: total probability assigned to the exact query support.
• query_top1_on_support: whether the most likely queried value is inside the exact query support.
• query_target_nll: cross-entropy against the exact query distribution.

The audit metrics evaluate recoverable belief information:

• probe_belief_target_mass: total probe probability assigned to the exact final (A,B) support.
• probe_belief_top1_on_support: whether the most likely probed pair is inside the exact support.
• probe_belief_target_nll: cross-entropy against the exact final pair distribution.

The belief metrics are post-hoc probe measurements, not executor objectives.

5. Main Result

The dense recurrent executor shows a clear execution-threshold shape at modulus 31. Query mass is weak when K<L, then rises when K reaches program length.

The probe-belief audit shows the same qualitative threshold, but the recovered belief mass is much lower than an exact belief state would require.

The K curves show the threshold by length.

Numerically, averaged across query types:

The threshold is real, but the scale is limited. Length 24 improves from 6.0% query mass before the execution threshold to 21.5% at K=24. That is a meaningful gain, not a strong solution.

6. Query Types

All four query types show the same broad pattern: direct register queries are easiest, relational queries are harder, and all degrade with length.

At length 24:

Relational queries are important because they are harder to answer from shallow marginal cues. The dense recurrent executor improves them, but does not solve them.

7. Controls

The scaled static compiler control shows that the dense recurrent result is not merely one-pass sequence fitting.

At modulus 31, averaged across query types:

Probe belief target mass separates the models more sharply:

The small-modulus order control also matters. At modulus 11, the dense recurrent model reached 89.3%, 72.0%, 55.7%, and 47.7% query mass at lengths 3, 6, 9, and 12. The shuffled recurrent control reached 75.8%, 43.1%, 26.3%, and 19.8%. Preserving instruction content while destroying order removes much of the length-generalizing behavior.

8. Small-Modulus Diagnostic

A modulus-11 diagnostic used training lengths 1-6 and evaluation lengths 3, 6, 9, and 12. It shows the same phenomenon in an easier state space.

The dense recurrent model is consistently best, but it still degrades with length. The scaled modulus-31 result is therefore not a surprise failure; it is the harder version of the same approximate dense execution behavior.

9. Interpretation

The result supports a narrow mechanism claim:

A generic dense recurrent hidden state can learn a partial sequential executor from one sampled final query label per example, and additional internal steps help when those steps correspond to consuming more program instructions.

The result does not support the stronger claim that sampled final-answer supervision reliably induces an exact hidden belief machine in a generic dense vector.

The evidence for useful sequential execution is:

1. the K=L threshold in query metrics,
2. the same threshold in post-hoc belief-probe metrics,
3. length-generalized improvement beyond the training range,
4. a clear gap over the scaled static compiler,
5. weaker behavior from the order-destroying recurrent control at small modulus.

The evidence against a strong dense executor is just as important:

1. query target mass is only 49.3% at the maximum training length of 8,
2. query target mass drops to 21.5% at length 24,
3. probe belief target mass drops to 5.7% at length 24,
4. relational queries remain notably weaker than direct register queries,
5. the dense state does not preserve enough information for the post-hoc probe to reconstruct the final belief well.

This is a useful boundary result. Dense recurrence alone creates a measurable serial-compute axis, but the architecture or objective needs more pressure if the target is robust hidden-state execution.

10. Limits

This is a structured experiment.

• The recurrent model uses a direct program counter.
• The instruction vocabulary is small and fixed.
• The operation family is modular arithmetic plus bucket observations.
• The largest completed state space has 961 pairs.
• Supervision is an exact sample from an exact query distribution.
• The belief probe is post-hoc and only measures recoverable information, not necessarily all information in the state.

The dense model has no explicit categorical belief table, but the task itself is still synthetic and tightly controlled. The result should be read as a mechanistic signal, not as a claim about open-ended reasoning.

11. Next Tests

Useful next tests:

1. Add auxiliary prefix-query losses or occasional belief distillation and measure whether the dense state becomes stable without fully supervising every example.
2. Increase state dimension and compare whether the probe-belief bottleneck is capacity-limited or optimization-limited.
3. Replace the GRU cell with a recurrent block that attends over the instruction sequence at each step rather than using a direct program counter.
4. Train with randomized K and a monotonic refinement loss so later recurrent states are explicitly pressured to improve.
5. Add a learned halt/no-op policy and test whether the model can choose compute budget.

12. Reproducibility

Primary files:

• Experiment script: ../src/dense_latent_query_executor_experiment.py
• Analysis script: ../src/analyze_dense_latent_query_executor.py
• Experiment log: dense_latent_query_executor_experiment_log.md
• Results directory: ../runs/
• Analysis directory: ../analysis/
• Checkpoint manifest: ../checkpoint_manifest.csv

Key run directories:

• ../runs/main_dense_mod31
• ../runs/control_static_mod31
• ../runs/pilot_dense_mod11
• ../runs/control_static_mod11
• ../runs/control_shuffled_mod11
• ../runs/smoke_dense_mod7

Large checkpoint files are stored outside the experiment bundle under:

../../../large_artifacts/dense_latent_query_executor/checkpoints/

Environment:

• Python 3.12.3
• PyTorch 2.8.0+cu128
• GPU: NVIDIA RTX 6000 Ada Generation

13. Bottom Line

The dense recurrent executor learned a real but weak latent execution strategy from sampled final query labels. The K-threshold is visible, it generalizes beyond the training length range, and it beats a full-budget static compiler. But the dense state does not become a high-fidelity belief state at modulus 31. The most defensible conclusion is that recurrent dense latent execution is learnable in this setup, but not strong enough without additional architectural or training pressure.

Experiment log 16

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

python experiments/dense_latent_query_executor/src/dense_latent_query_executor_experiment.py --mode dense --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 32 --probe_steps 2 --probe_batch_size 16 --state_dim 64 --instr_dim 32 --log_every 1 --probe_log_every 1 --lr 0.001 --probe_lr 0.001 --output_dir experiments/dense_latent_query_executor/runs/smoke_dense_mod7 --checkpoint_dir large_artifacts/dense_latent_query_executor/checkpoints/smoke_dense_mod7

python experiments/dense_latent_query_executor/src/dense_latent_query_executor_experiment.py --mode dense --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 3000 --batch_size 512 --eval_batch_size 512 --eval_examples 512 --probe_steps 1500 --probe_batch_size 512 --state_dim 256 --instr_dim 128 --log_every 200 --probe_log_every 150 --lr 0.001 --probe_lr 0.001 --output_dir experiments/dense_latent_query_executor/runs/pilot_dense_mod11 --checkpoint_dir large_artifacts/dense_latent_query_executor/checkpoints/pilot_dense_mod11

python experiments/dense_latent_query_executor/src/dense_latent_query_executor_experiment.py --mode static --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 3000 --batch_size 512 --eval_batch_size 512 --eval_examples 512 --probe_steps 1500 --probe_batch_size 512 --state_dim 256 --instr_dim 128 --heads 4 --compiler_layers 2 --log_every 200 --probe_log_every 150 --lr 0.001 --probe_lr 0.001 --output_dir experiments/dense_latent_query_executor/runs/control_static_mod11 --checkpoint_dir large_artifacts/dense_latent_query_executor/checkpoints/control_static_mod11

python experiments/dense_latent_query_executor/src/dense_latent_query_executor_experiment.py --mode shuffled --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 3000 --batch_size 512 --eval_batch_size 512 --eval_examples 512 --probe_steps 1500 --probe_batch_size 512 --state_dim 256 --instr_dim 128 --log_every 200 --probe_log_every 150 --lr 0.001 --probe_lr 0.001 --output_dir experiments/dense_latent_query_executor/runs/control_shuffled_mod11 --checkpoint_dir large_artifacts/dense_latent_query_executor/checkpoints/control_shuffled_mod11

python experiments/dense_latent_query_executor/src/dense_latent_query_executor_experiment.py --mode dense --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 5000 --batch_size 512 --eval_batch_size 512 --eval_examples 512 --probe_steps 2000 --probe_batch_size 512 --state_dim 256 --instr_dim 128 --log_every 250 --probe_log_every 200 --lr 0.001 --probe_lr 0.001 --output_dir experiments/dense_latent_query_executor/runs/main_dense_mod31 --checkpoint_dir large_artifacts/dense_latent_query_executor/checkpoints/main_dense_mod31

python experiments/dense_latent_query_executor/src/dense_latent_query_executor_experiment.py --mode static --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 5000 --batch_size 512 --eval_batch_size 512 --eval_examples 512 --probe_steps 2000 --probe_batch_size 512 --state_dim 256 --instr_dim 128 --heads 4 --compiler_layers 2 --log_every 250 --probe_log_every 200 --lr 0.001 --probe_lr 0.001 --output_dir experiments/dense_latent_query_executor/runs/control_static_mod31 --checkpoint_dir large_artifacts/dense_latent_query_executor/checkpoints/control_static_mod31

PYTHONDONTWRITEBYTECODE=1 python experiments/dense_latent_query_executor/src/analyze_dense_latent_query_executor.py

Figures 7

Data files 18

Result tables and metrics copied from the experiment folder — preview inline or open the raw file.

• previewanalysis/all_metrics_long.csv83 kB
• previewanalysis/final_metrics_long.csv83 kB
• previewanalysis/final_metrics_query_mean.csv11 kB
• previewanalysis/mod31_control_summary.csv1.8 kB
• previewanalysis/mod31_per_query_threshold_summary.csv2.4 kB
• previewanalysis/mod31_threshold_summary.csv947 B
• previewruns/control_shuffled_mod11/metrics_final.csv16 kB
• previewruns/control_shuffled_mod11/results.json72 kB
• previewruns/control_static_mod11/metrics_final.csv2.5 kB
• previewruns/control_static_mod11/results.json18 kB
• previewruns/control_static_mod31/metrics_final.csv3.1 kB
• previewruns/control_static_mod31/results.json22 kB
• previewruns/main_dense_mod31/metrics_final.csv23 kB
• previewruns/main_dense_mod31/results.json100 kB
• previewruns/pilot_dense_mod11/metrics_final.csv16 kB
• previewruns/pilot_dense_mod11/results.json72 kB
• previewruns/smoke_dense_mod7/metrics_final.csv4.2 kB
• previewruns/smoke_dense_mod7/results.json20 kB

Reproduce

The run commands are documented inside the experiment folder (see the README).

Browse the experiment folder on GitHub ↗

Related

Related experiments

Nearest by shared name, tags, and programs.

• imported 2026-07-12 Sampled Query Filter Executor Experiment
• imported 2026-07-12 Query Filter Executor Experiment
• imported 2026-07-12 Qwen Register-Token Latent Compiler
• imported 2026-07-12 Qwen Latent Beam Program Compiler
• imported 2026-07-12 Latent Recurrent Executor Experiment
• imported 2026-07-12 Dense Supervision Ladder Experiment