Where Rationalization Hides: Depth-Resolved Faithfulness Tests for Chain-of-Thought

When a language model writes out its reasoning before answering, the written steps often do not actually produce the answer. The model settles on an answer early and then writes a plausible justification for it, a failure called post-hoc rationalization. Current tests for this treat a reasoning trace as a flat list of sentences. They corrupt one step, see whether the answer changes, and average over steps. We propose to treat the trace as a tree instead. Each intermediate result is a node, it is linked to the later results that use it, and the final answer sits at the root. The question we then ask is at what depth in that tree the answer stops listening to the reasoning.

Our hypothesis is that rationalization is not spread evenly across a trace. A model that already "knows" the answer should still respond to errors injected right next to the answer, because those steps are hard to ignore. It should ignore errors injected deep in the derivation, where it can quietly fall back on its prior. If that is true, a flat average hides exactly where the failure lives. A depth-resolved measurement would find it, and training that aims its pressure at the deficient depths should buy faithfulness more cheaply than uniform training.

Core Claim

Consider arithmetic and proof-style reasoning. The dependency tree of a trace can be built exactly: a value computed in one step becomes an operand in a later step. This makes the "correct" consequence of corrupting any node computable. We define a follow-rate $F(d)$ as the fraction of interventions at nodes of depth $d$ (distance to the answer node) for which the model's final answer equals the value that the corrupted node would deterministically propagate to.

Our claim has three parts. First, $F(d)$ is not flat for current instruction-tuned and reasoning models. Second, it decays with depth, more steeply for larger or RL-trained models. Third, a preference-training objective whose per-example weight is set by the measured deficit $1 - F(d)$ improves faithfulness more than uniform step-level training for the same budget, and costs less accuracy.

The novelty is not "weight roots more." The classical hierarchical-weighting literature does weight roots more, and it motivates the tool: human linguists penalize errors near the top of a dependency tree far more than leaf errors (Do dependency parsing metrics correlate with human judgments?), and depth-scaled significance scores rescue sentence compression (Constraint-Based Sentence Compression: An Integer Programming Approach). What we borrow is the mechanism of scaling a loss by tree depth. We let the data decide the direction of the weighting. Our specific prediction is that the faithfulness deficit sits at deep nodes, which is the opposite of where root-emphasis would spend the budget.

Relation to Prior Work

The closest work falls into three groups.

The first group trains against rationalization using step-level causal interventions, and all three methods treat steps as an unordered list. FRIT injects style-matched distractor facts into individual steps, labels a step important if the answer flips, and trains with Direct Preference Optimization (DPO, a method that fine-tunes a model directly on pairs of preferred and rejected outputs). FRODO treats the rationale as a causal mediator and adds a counterfactual loss. The probability-of-necessity-and-sufficiency method of Causal Sufficiency and Necessity Improves Chain-of-Thought Reasoning prunes redundant steps using counterfactual rollouts. These methods supply our intervention and training machinery. We differ by stratifying interventions and loss weights by dependency depth, rather than treating every step alike.

The second group analyzes trace structure without optimizing it. Thought Anchors maps steps into a causal graph and finds that planning steps steer conclusions more than arithmetic steps. This motivates our view that importance is structured. However, that paper provides no objective, and it measures importance by expensive resampling. Structural Skeleton-guided Reasoning in Measuring and Mitigating Post-Hoc Rationalization in Reverse Chain-of-Thought Generation conditions reasoning on a linear sequence of functional tags. It has no depth and works in the reverse setting, where the answer is given upfront. We work in the forward setting with explicit trees.

The third group is SyntaxShap-W (SyntaxShap), the one method that already joins depth weighting and explanation faithfulness. It weights Shapley attributions, which score each input word's contribution, by dependency depth. It stays within single input sentences and next-token prediction. We lift the idea from within-sentence syntax to across-step derivations.

Several results constrain the design. Faithfulness steering with in-context examples, LoRA fine-tuning, and activation editing cost up to 20% accuracy on TruthfulQA (On the Hardness of Faithful Chain-of-Thought Reasoning in Large Language Models). This is the trade-off our deficit-targeted weighting must avoid. Faithfulness gets worse with scale (Measuring Faithfulness in Chain-of-Thought Reasoning; RFEval finds gpt-oss-120B less faithful than its 20B sibling in RFEval). We predict that depth-resolved measurement shows where that extra unfaithfulness goes. Finally, How Likely Do LLMs with CoT Mimic Human Reasoning? reports GPT-4 reaching correct 6-digit sums despite wrong intermediate steps 74.4% of the time. That is the answer-bypasses-chain pattern our deep-node interventions are designed to catch.

Research Program

Tree construction. On GSM8K (Training Verifiers to Solve Math Word Problems) and SVAMP, we extract every equation from a model-generated trace. We link a node to its parent whenever the node's value appears as an operand in the parent's computation, then recompute every node exactly. Traces whose extracted arithmetic fails to reproduce the model's own stated values are discarded and counted. This guards against the known fragility of depth assignment to parse errors. Steps that are not ancestors of the answer node are marked as off-tree; these are the "decorative" steps. On the PrOntoQA and RuleBert logic subsets of RFEval, the proof itself supplies the tree.

Interventions. We run two kinds.

The first is a truncate-and-continue intervention. We change a node's value, cut the trace immediately after that node, and let the model continue. We then classify the outcome into one of three cases. The first case is propagation: the text carries the corrupted value forward, and the answer equals the deterministic consequence. The second is explicit correction: the text visibly revises the value. This is legitimate robustness, not unfaithfulness, and we report it separately. The third is disconnect: the text carries the corrupted value forward, but the answer does not follow from it. Only this third case is scored as rationalization. The distinction matters because a model that silently recovers the right answer is not simply being robust: its answer contradicts its own written chain.

The second is a keep-downstream intervention. We corrupt the node, leave all later text untouched, and force an answer. This tests whether the answer is read from the chain at all.

Measurement. Interventions are sampled in equal numbers per depth stratum rather than at every step. This cuts the per-trace cost that makes flat auditing expensive, and still yields $F(d)$ with a controlled confidence interval at each depth.

Training. We build faithful-versus-disconnected preference pairs from the interventions, following FRIT's pair construction. We then train with a depth-weighted DPO loss

$$\mathcal{L} = \sum_{i} w(d_i)\, \ell_{\mathrm{DPO}}(y_i^{+}, y_i^{-}), \qquad w(d) \propto 1 - \hat F(d),$$

where $d_i$ is the depth of the intervened node in pair $i$, $\ell_{\mathrm{DPO}}$ is the standard DPO loss on the faithful continuation $y_i^{+}$ and the disconnected one $y_i^{-}$, and $\hat F(d)$ is the follow-rate measured on a held-out split before training. The weights are normalized so that the total loss mass equals that of uniform DPO. This way, the comparison varies only where the pressure goes, not how much there is.

Baselines

The naive reference point is the untrained base model: Mistral-7B-v0.1 and Qwen3-8B, the two models FRIT used, prompted with standard chain-of-thought. We report its $F(d)$ profile, its overall disconnect rate, and GSM8K and SVAMP accuracy. Any trained method must improve on it, and the shape of its profile is itself the first result.

The strongest existing competitor is FRIT, because it is the published method closest to ours: step-level causal labels plus DPO, on the same models and benchmarks. FRIT reports an accuracy gain of 7.6 percentage points on GSM8K for Mistral-7B and 6.0 points on StrategyQA for Qwen3-8B. The file gives no absolute FRIT faithfulness scalar, so there is no reported result found on Lacuna for FRIT faithfulness on GSM8K. We will therefore rerun FRIT ourselves, with the same training problems, the same number of preference pairs, the same DPO hyperparameter search (identical grid and seeds), and the same GPU budget. FRODO is run the same way as a second causal-training baseline. Beating FRIT means two things together. First, a statistically higher follow-rate in the deepest two depth strata and a lower overall disconnect rate. Second, GSM8K accuracy that is no lower than our reproduced FRIT run, with a difference in favor of FRIT within one standard error across three seeds counted as a tie.

Three weighting ablations isolate the key ingredient, which is deficit-targeted depth weights. The first is uniform weights, which is FRIT-style pairs trained with plain DPO. The second is classical root-emphasis, $w(d) = \mathrm{softmax}(-d)$, as used for style transfer and in SyntaxShap-W. The third, most important, ablation weights pairs by token distance from the intervened step to the answer instead of tree depth. If position works as well as depth, the tree is unnecessary.

Why not just…?

Why not just use FRIT's uniform step interventions? If the faithfulness deficit is spread evenly across depths, uniform weighting is already optimal, and our method reduces to it. We do not assume otherwise. The first experiment measures $F(d)$ on the base models, and a flat profile would falsify the training half of this proposal while leaving the diagnostic intact. The support for expecting non-uniformity comes from Thought Anchors' finding that step importance is strongly structured, and from the scale results showing that more capable models bypass their chains more.

Why not just weight by position in the trace? This is the most serious threat, because depth and distance from the answer are correlated in short GSM8K traces. We handle it in two ways. First, we build an evaluation stratum where the two decouple. These are problems where a value computed early feeds directly into the final step (shallow but distant) and problems where a value computed late sits under a long chain (deep but near). Second, we regress disconnect outcomes on depth and position jointly. If depth adds no predictive power beyond position, we will report the simpler position-weighted method as the recommendation.

Why not just measure each step's importance directly by resampling, as Thought Anchors does? Direct measurement is more precise, but it costs many rollouts per step. That cost is exactly the auditing bottleneck the flat methods run into. Our claim is that a free structural variable captures most of that variance. We test this by comparing, on a subsample, the depth-stratified estimate against a full-resampling importance estimate at matched inference calls. We report how much of the resampling signal depth explains.

Why not just prompt the model to reason from first principles? Hu et al. found that suppression instructions increase lexical, entropic, and probabilistic anchoring rather than reducing it (Measuring and Mitigating Post-Hoc Rationalization in Reverse Chain-of-Thought Generation). We include a first-principles prompt only as a cheap reference row in the $F(d)$ measurement, not as a contender.

Proposed Experiments and Decisive Checks

Diagnostic study. We measure $F(d)$ and the three-way outcome split on GSM8K, SVAMP, and the RFEval math and logic subsets. We do this for Mistral-7B, the Qwen3 family across sizes, and gpt-oss-20B and 120B. The prediction is that the curve decays with depth, and decays more steeply in the 120B model than in the 20B model. This would locate the extra unfaithfulness that RFEval attributes to scale, where it reports 49.7% of outputs unfaithful across twelve reasoning models.

Training comparison. Using the baselines above, we train on GSM8K and evaluate in-domain on GSM8K and SVAMP. We also test transfer to the RFEval logic subsets and to StrategyQA. On StrategyQA, trees must come from model-extracted dependencies, so it serves as a deliberately noisier robustness check rather than a headline result.

The accuracy trade-off. We plot accuracy against overall faithfulness for each weighting scheme, across a sweep of loss strengths. The question is whether depth-targeted weighting traces a better frontier than uniform weighting, or whether the 20% accuracy loss from faithfulness steering appears regardless of where the pressure goes.

Decisive outcome. The proposal succeeds if three things hold together. The base-model profile must be measurably non-flat. Depth must predict disconnects beyond position. Deficit-weighted DPO must raise deep-stratum follow-rate above our FRIT reproduction without lower accuracy. It fails cleanly, and informatively, if the profile is flat or if position-weighting matches depth-weighting.