Amortized Discovery of Load-Bearing Reasoning Steps

When a language model writes out its reasoning before answering, most of those steps may not affect the answer at all. Finding which steps do matter currently means rerunning the model many times, deleting or resampling steps one by one and watching whether the answer moves. This is accurate but very slow. We propose to train a small auxiliary network, once, that reads a single forward pass of the reasoning model and outputs which steps the answer actually depends on. It learns this by repeatedly hiding random subsets of steps and checking whether the frozen model's answer distribution changes. The subset choice is made trainable with a standard trick for differentiating through discrete random choices.

The motivation is a mismatch in cost. Causal diagnostics such as the True Thinking Score in Can Aha Moments Be Fake? and the counterfactual resampling in Thought Anchors show that reasoning traces are mostly decoration. On AIME, Qwen-2.5 has a mean score of 0.03, and only 2.3% of steps are critical. These tools need many forward passes per step, so they cannot run during deployment or inside a training loop. Neural architecture search went through the same crisis: scoring every candidate architecture by full training was too expensive. Researchers responded by sharing weights across candidates and building cheap proxies, then judged those proxies by how well their rankings agreed with the expensive ground truth. We bring that playbook to faithfulness auditing. Choosing which reasoning steps to keep is a discrete subset-selection problem, and it gets the same treatment: amortization with shared weights, plus validation by rank correlation and cost.

Core Claim

A step-selection network trained without labels can match expensive causal step-importance scores at roughly the cost of one extra forward pass per trace. Here "trained without labels" means it uses no expensive ground-truth scores, and it is trained by sampling hard subsets of reasoning steps, with gradients obtained through the straight-through Gumbel-Softmax estimator. Because the network scores steps jointly rather than one at a time, it should also find load-bearing steps that leave-one-out ablation misses. The clearest case is redundancy: two steps each carry the same fact, so deleting either alone changes nothing, yet deleting both breaks the answer.

Research Program

Take a frozen reasoning model $f$, a prompt $x$, and a generated chain split into steps $c_1,\dots,c_n$. Let $p_f(a \mid x, c)$ be the model's distribution over the final answer $a$. A small explainer $g_\phi$ reads the frozen model's hidden states at step boundaries, which come from a single pass. It outputs per-step logits, from which we draw a hard $k$-of-$n$ mask $m$ using Gumbel top-$k$ sampling. The forward pass uses the hard mask, so the frozen model genuinely loses access to the hidden steps through its attention mask. The backward pass routes gradients through the softened relaxation. We train $\phi$ to make the kept subset sufficient and the dropped subset unnecessary:

$$\min_\phi \; \mathbb{E}_{m \sim g_\phi}\Big[\mathrm{KL}\big(p_f(a\mid x,c)\,\|\,p_f(a\mid x,c\odot m)\big) \;-\; \lambda\,\mathrm{KL}\big(p_f(a\mid x,c)\,\|\,p_f(a\mid x,c\odot(1-m))\big)\Big]$$

In this objective, $c\odot m$ keeps only the selected steps, $1-m$ is the complement, and $\lambda$ balances sufficiency against necessity. The budget $k$ is either fixed or sampled per batch, so one network covers many sparsity levels. At test time, the explainer's logits are the step-importance scores, computed with no masking passes at all.

Each part of this design comes from a specific source. Instance-Wise Causal Feature Selection supplies the method. It trains a Gumbel-Softmax explainer that picks $k$ image patches with maximal causal effect, reaching 0.953 post-hoc accuracy on MNIST versus 0.942 for L2X. We move this from fixed pixel grids to variable-length, ordered reasoning steps, where deleting a step can make the remaining text incoherent. That is why hard forward masking matters. Continuous soft masks would show the frozen model inputs it never sees in practice, which is the train-versus-test discretization mismatch documented for relaxed graph and architecture optimization. NodeFormer shows that Gumbel-relaxed structure learning scales, but it learns graphs for node prediction, not causal audits of a fixed model. Topology of Reasoning and CRV build reasoning graphs after the fact, by clustering activations or by transcoder attribution. Both motivate the need for structure, but neither learns which steps the answer depends on. CRV is described as orders of magnitude more expensive than text verifiers.

Two cautionary findings from architecture search shape the evaluation. First, rankings from weight-sharing and early-stopping proxies agree with the ground truth in local comparisons but not globally (Rethinking Performance Estimation in NAS). Second, cheap proxies fail to separate candidates within the top decile (EZNAS). Since critical steps are only about 2% of a trace, the second failure is exactly the one that would sink our method. We therefore report precision on the rare critical steps, not only overall rank correlation.

Baselines

The naive reference point uses no training. It scores steps with attention from the answer position, or with uniform importance, and costs zero extra passes. A more serious cheap baseline is the receiver-head attention score from Thought Anchors, whose late-layer heads were shown to point at load-bearing steps. This is the strongest zero-training competitor and gets the same single forward pass.

The strongest existing method, which also serves as ground truth, is expensive causal resampling. We use two variants: the necessity and sufficiency tests behind the True Thinking Score (Can Aha Moments Be Fake?) and counterfactual sentence resampling from Thought Anchors. Both run at full budget on a held-out audit set.

The file reports no rank correlation between any cheap step-importance proxy and these scores. No reported result was found on Lacuna for proxy-versus-TTS agreement. The only nearby reference numbers are TTS's 0.03 mean and 2.3% critical fraction on AIME, and EZNAS-A's Kendall tau of 0.65 on NASBench-201 against 0.57 for Synflow and NASWOT. The EZNAS figures show what counts as a useful proxy in architecture search; they are not a target on this task. We will count our method as successful if its Kendall tau with resampling scores is clearly above the receiver-head baseline at equal cost, and if its precision on critical steps is above that baseline too.

Leave-one-out deletion costs $n$ passes per trace. It isolates the value of joint selection and is run with the same frozen model, data, and masking code.

A supervised regressor uses the same architecture as $g_\phi$, but is trained directly on resampling scores. It is matched to our method on total forward passes, counting the passes spent generating its labels. It tests whether the label-free objective is worth having.

Three internal ablations isolate the key ingredients. The first replaces joint $k$-subset sampling with independent per-step Bernoulli gates. The second replaces hard straight-through masks with soft attention scaling. The third uses fixed rather than annealed temperature.

All methods share the frozen models, traces, step segmentation, and hyperparameter search budget.

Why not just…?

Why not just use leave-one-out deletion? It costs $n$ passes rather than about one, and by construction it cannot see redundancy. We test this directly on traces where a critical step is duplicated. Leave-one-out should assign near-zero importance to both copies, while joint selection should keep one. If real traces show little redundancy, the advantage shrinks to cost alone, and we will report that.

Why not just read attention from receiver heads? This is the real threat, because it is free and has shown promise. However, attention measures where information flows, not whether the answer needs it. Confirmation bias work (Unveiling Confirmation Bias in CoT) and fake aha moments show heavily attended corrections that the answer then ignores. If attention matches our explainer on critical-step precision, the training is not justified, and the experiments are designed to show that if it is true.

Why not just train a probe on expensive labels, as ProFIL does for commitment detection? Drop the Act trains its probe with a forced-answering protocol. Producing step-level causal labels at scale costs exactly what we are trying to avoid. The cost-matched supervised regressor answers this. If it wins at equal budget, the label-free objective is unnecessary.

Why not just use black-box perturbation tests? Measuring Faithfulness in CoT gives trace-level verdicts, such as early answering or added mistakes, not step-level structure. CRV reports black-box verification at 76.45 AUROC versus 92.47 for its white-box graph on synthetic arithmetic. We include early-answering as a trace-level comparator in the RFEval check below.

Proposed Experiments

We use open reasoning models in the 7B–8B range on GSM8K and AIME traces. Explainers are trained on unlabeled traces. Full TTS and Thought Anchors resampling scores are computed on a held-out audit set of a few hundred traces per benchmark. The primary metrics are three: Kendall tau with resampling scores, precision and recall on steps above the 0.7 TTS threshold, and the number of model forward passes per trace. We plot rank agreement against forward-pass budget for every method, which is the standard way architecture-search proxies are compared.

The first decisive check uses the synthetic redundancy construction described above.

The second is a downstream test on RFEval, which injects flawed counterfactual reasoning prefixes and found 49.7% of outputs unfaithful across 12 models. If the explainer captures real dependence, the fraction of score assigned to the injected prefix should separate faithful from unfaithful outputs. We measure this as AUROC against early-answering and attention baselines.

The third tests transfer across domains, training on math and testing on RFEval's code and logic splits. This guards against the gap between local and global agreement seen in architecture search.

A negative result on the first and third checks, where attention matches the explainer and the explainer fails on rare critical steps, would mean that amortized causal auditing faces the same top-decile wall as zero-cost architecture proxies. That finding would also be worth publishing.