{"id":"0040232f-5c35-44fa-85cc-e7808ae4c937","arxiv_id":"2602.18905","paper_version":2,"verdict":"REJECT","confidence":"MODERATE","novelty_score":5.0,"correctness_risk":"high","formal_verification":"none","parameter_count":3,"one_line_summary":"TRUE checks whether LLM reasoning traces are self-sufficient by executing them blind, maps neighboring reasoning paths into a DAG, and ranks recurring failure modes by Shapley values.","lead":"TRUE is a proposed three-level framework for explaining LLM reasoning: it executes extracted explanations without the original question, builds feasibility graphs over nearby inputs, and clusters recurring failure modes. It matters because it aims to turn LLM explanations into checkable structures rather than persuasive narratives, though the checks themselves depend on another LLM.","discovery_kind":"extension","skeptic_critique":{"model":"deepseek-v4-flash","headline":"Blind executor not truly independent: using the same model family (GPT-4o-mini) as generator and executor allows latent priors to fill gaps, so EA/EC do not prove explanations are self-contained.","rationale":"Section 3.1 is the foundation of the entire TRUE framework. If Executable Accuracy (EA) does not actually measure whether an explanation is self-contained, then the instance-level 'verifiable explanation' claim collapses. The higher-level structures (feasible-region DAGs, failure modes) are built on the same executable traces and inherit this failure. The paper explicitly acknowledges the goal of preventing external knowledge, but the implementation using GPT-4o-mini as executor does not satisfy this. The absence of an independent executor with no shared priors means that the core measurement apparatus is confounded. The reader's weakest_assumption correctly identifies this. Other concerns (lack of significance tests, manual clusters) are real but secondary; they affect the strength of the evidence, whereas the executor independence affects the validity of the primary measurement. The proposed test—using a deterministic or cross-family executor—would settle whether the concern is actual. If the results hold under such an executor, the paper would need only better reporting and statistics; if not, the central claim is unsupported. Thus the reader's REJECT verdict remains appropriate.","tokens_in":13074,"tokens_out":6633,"duration_ms":58477,"concrete_test":"Re-run the blind-execution evaluation of Section 4.1 on the GSM8K and MATH 300-sample subsets with a strictly deterministic executor: a parser that only executes explicitly listed arithmetic operations and fails on any natural-language step requiring inference, and with a different-family LLM (e.g., Llama-3-8B-Instruct) as the executor under the same prompt. Compare EA and EC to the reported GPT-4o-mini values. If EA drops by more than 15 percentage points (or EC by more than 10 points), the explanations are not self-contained and the reported numbers are inflated by the executor's priors. If EA/EC are unchanged, the independence concern is weakened.","verdict_should_be":"UNCHANGED","load_bearing_attack":"The central instance-level claim (Section 3.1, Definition 2) is that an explanation is trustworthy iff an independent executor recovers the correct answer without seeing the original problem x. The methodology says the verifier is a 'composite verification framework' with white-box arithmetic solvers, and that 'the LLM is only responsible for interpreting and executing the provided steps.' But Section 4.1 states: 'During the blind execution stage, GPT-4o-mini is uniformly used as the executor to control execution variance across models.' This is the same model family that generates the explanations in the first experiment. A GPT-4o-mini executor comes with the same pretraining knowledge as the generator; when the explanation is under-specified, it can fill in missing steps or infer the problem from context, inflating Executable Accuracy (EA) and Executable Consistency (EC). The paper gives no evidence that the executor is restricted to the literal steps (e.g., no ablations of intermediate steps, no comparison with a weaker/different-family executor). Moreover, the claimed white-box components are not mentioned in the experiment section, so it is unclear they were actually used. Therefore, EA/EC do not establish that the explanation alone contains a complete solution structure; they may only show that a strong LLM can solve the problem when given a hint.","agreement_with_reader":"agree"},"referee_report":{"model":"deepseek-v4-flash","summary":"The paper proposes TRUE, a three-level framework for explaining and verifying LLM reasoning. At the instance level, reasoning traces are treated as executable specifications, and a 'blind execution verifier' attempts to recover the answer from the explanation alone; if it succeeds, the explanation is declared trustworthy. At the local level, structure-preserving perturbations around an anchor instance are used to build a feasible-region DAG whose node weights combine semantic correctness and execution success. At the class level, clusters of similar problems are analyzed by injecting/removing hypothesized failure modes, and Shapley values are used to quantify each failure mode's impact on prediction errors. Experiments on GSM8K, MATH, MMLU-CF, and BBH report executable accuracy, consistency, DAG-based success-rate prediction, and cluster-level failure-mode rankings.","tokens_in":13442,"tokens_out":3931,"duration_ms":38367,"significance":"If the claims were fully supported, the framework would be a useful contribution: it formalizes a verifiable, multi-level notion of explanation for LLM reasoning, and the proposed metrics (EA, EC, ERR) are natural and clearly defined. The paper also attempts a stronger standard than typical plausibility-based evaluation. However, the central verification protocol relies on an executor that is from the same model family as the generator, the statistical evidence is thin (n=300 per benchmark, no confidence intervals; clusters of 10–20 manually selected instances), and the causal interpretation of Shapley values is not justified. These issues are load-bearing because they directly affect whether the paper's core claims—that explanations are self-contained, that DAGs characterize local stability, and that failure modes have quantified causal influence—are established.","major_comments":[{"comment":"The trustworthiness criterion requires an independent executor that recovers the answer without the original problem. The implementation violates this independence: Section 4.1 states that 'GPT-4o-mini is uniformly used as the executor' while GPT-4o-mini is also the model that generates the explanations in Table 1. A pretrained LLM can use latent priors to fill missing steps or even reconstruct the problem from context, so high EA/EC do not establish that the explanation alone contains a complete solution procedure. The composite verifier with white-box components is described in Section 3.1 but is not reported or ablated in the experiments. I request an executor from a different model family, or additional controls (e.g., ablating steps, degrading the explanation, and showing that the executor cannot solve the problem without the explanation).","section":"§3.1, Definition 2 and Eq. (2); §4.1, Table 1 and Table 2"},{"comment":"All headline results are point estimates on small samples with no uncertainty quantification. Section 4.1 uses 300 randomly sampled instances per benchmark; a 2–4 percentage point difference (e.g., 68.0% vs 66.0% on MMLU in Table 1) is within binomial sampling noise. Section 4.2 uses only five manually selected clusters of 10–20 instances each; the CE differences in Table 3 are reported without confidence intervals or significance tests, and two categories (Classification and Rules, Science and Technology) show negative ΔCE. Section 4.3 uses clusters of tens of samples. I request confidence intervals, per-cluster variability, and a statement of how clusters were selected.","section":"§4.1, Tables 1–2; §4.2, Table 3; §4.3, Table 5"},{"comment":"The paper calls the Shapley values 'causal' and equates them with 'causal influence', but the estimation uses empirical prediction correctness on a set of controlled perturbations whose construction is not described in enough detail to rule out confounds. Failure modes are first discovered by an LLM from errors, then five are selected per cluster as 'high structural impact', and then Shapley values are computed on that selected set. This selection step biases the estimated contributions, and the interventions (injecting/removing failure conditions) may change the problem in correlated ways. The result is at best a conditional association, not a causal effect. Please provide an explicit identification strategy or soften the causal language.","section":"§3.3, Eq. (11); §4.3, Table 5"},{"comment":"The success-rate prediction experiment compares a DAG built from anchor-instance perturbations against a baseline that uses repeated CoT sampling from the anchor only. The DAG has access to many perturbed instances (i.e., similar but distinct inputs), whereas the baseline does not; the improvement may reflect access to a broader sample set rather than the DAG's structural representation. The 'equal computational budget' claim is not substantiated, and it is unclear whether the baseline LLM predictor receives the same amount of context. I ask for a matched baseline that receives the same perturbed instances in raw form, or a controlled study that isolates the DAG structure.","section":"§3.2, Table 3"}],"minor_comments":[{"comment":"The text says 'The lower overall coverage compared to GSM8K' but Table 4 reports MATH and MMLU-CF, not GSM8K. Also, 'Pert. SR' and 'Pret. SR' are used inconsistently in Table 3.","section":"§4.2, Table 4 and text"},{"comment":"Table 2's caption defines ERR as 'Execution Error Rate', while Eq. (14) defines ERR as Executable Recovery Rate. This is confusing and should be harmonized.","section":"Table 2 caption and Eq. (14)"},{"comment":"The title says 'Enhanced Shapley Values' but no definition of 'enhanced' is given; Eq. (11) is the standard Shapley formula. Either define the enhancement or remove the term.","section":"Table 5 title"},{"comment":"The symbol n is used for both cluster size in Section 4.2 and subsampling size in Section 4.3, which may confuse readers.","section":"§4.2 and §4.3 notation"}],"recommendation":"major_revision","confidential_remarks":"This is a preprint under review. The central idea is interesting and the multi-level framing is appealing, but the experimental validation is not yet at the level required for the paper's strong claims. The same-model executor issue is the most serious: it directly undermines the Definition 2 test. The causal language in Section 3.3 is also overclaimed. These are fixable with additional experiments and careful rewording, so I do not recommend rejection, but the revision needs substantial work."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"You should know this paper proposes a clean three-level framework: executable explanations verified by blind execution, feasible-region DAGs from perturbations, and cluster-level Shapley failure attribution. The combination is new in the cited literature, even if each piece reduces to known techniques. What it does well: the definitions are clear, the metrics are sensible, and the finding that executability degrades on knowledge-heavy tasks is a real observation. The paper is also honestly written—no obvious attempt to hide the weak spots. The soft spot is load-bearing, not cosmetic. The central claim in Section 3.1 is that an explanation is trustworthy if an independent executor can recover the answer without the original problem. But in the experiments the executor is GPT-4o-mini, the same model family that generated the explanations. That isn't an independent executor in any meaningful sense. A strong LLM with the same pretraining priors can fill in missing steps or effectively solve the problem from a hint, so high Executable Accuracy and Consistency don't establish that the explanation alone is a complete, self-contained procedure. The paper mentions a composite verification framework with white-box arithmetic solvers, but the experiment section doesn't show those components being used, which makes it unclear whether the claimed mechanism actually ran. Other issues are real but secondary: n=300 with no confidence intervals, clusters selected manually or via LLM without clear reproducibility, and the Shapley analysis is called causal without any identification strategy. The failure-mode results are plausible but correlational. No code or data is released, which hurts the trustworthiness of a framework whose entire purpose is verification. The core idea is still worth engaging with. The framework is a reasonable way to structure interpretability evaluations, and a careful rework of the executor independence problem—using a strictly deterministic executor, ablating steps, or comparing with a different-family model—could make the central claim credible. This deserves a serious referee, not a desk reject. I'd send it to review with a clear request for those experiments and uncertainty quantification, but my own verdict would be that the current evidence doesn't support the paper's central claim.","headline":"The three-level framework is a sensible packaging of known ideas, but the core verification claim is undercut by using the same model family as both generator and executor.","tokens_in":623,"tokens_out":690,"would_cite":false,"duration_ms":23477,"reading_group":"maybe","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":[],"pacs":[],"model":"deepseek-v4-flash","headline":"The paper argues that LLM reasoning traces can be redefined as executable process specifications checked by a blind executor, with feasible-region DAGs and Shapley-based failure modes extending the check to neighborhoods and problem classes","keywords":["executable explanations","blind execution verification","feasible-region DAG","reasoning stability","failure mode analysis","Shapley attribution","chain-of-thought faithfulness","LLM interpretability"],"falsifier":"Take a set of traces that pass blind execution, delete one essential step from each, and run the same executor again: if it still recovers the correct answer, the executor is supplying the missing information and the verification is not blind. A cleaner empirical test is to replace the LLM executor with a formal arithmetic interpreter on GSM8K; if Executable Accuracy drops materially from the reported numbers, the reported executability partly reflects executor knowledge rather than trace completeness.","tokens_in":12951,"feed_emoji":"🧠","tokens_out":7196,"duration_ms":62356,"temperature":0.7,"pith_summary":"This paper tries to establish that a chain-of-thought explanation from an LLM can be checked for whether it actually contains a complete path to the correct answer, rather than just being plausible text. It defines an executable explanation as a sequence of steps from which an independent executor can recover the answer without seeing the original problem, and it treats a trace as trustworthy when blind execution succeeds. To move beyond single instances, it builds feasible-region DAGs from structure-preserving perturbations and identifies class-level failure modes whose causal influence is quantified with Shapley values. A sympathetic reader would care because this converts LLM explanations from descriptive narratives into mechanically verifiable artifacts, and it offers a single vocabulary for comparing reasoning strategies, model capabilities, and systematic weaknesses.","feed_headline":"Blind execution turns LLM explanations into testable procedures","feed_subtitle":"It checks whether a trace alone yields the answer, maps local stability, and ranks failure patterns by causal impact.","key_machinery":"The load-bearing object is the blind execution verifier V(E), which receives only the explanation sequence and produces a prediction; the identity yhat = V(E) is what makes executability testable. Around it, the feasible-region DAG G=(S,E) represents local reasoning structure: nodes are merged reasoning steps weighted by W_i = C_i * R_i (semantic consistency times execution success rate over perturbations), and directed edges encode step dependencies observed across trajectories. For class-level analysis, the Shapley value phi_i over failure-mode configurations, with empirical correctness v(S) as the characteristic function, quantifies the marginal causal impact of each failure mode.","core_discovery":"The central claim is that reasoning traces can be treated as executable process specifications. An explanation E=(e1,...,eT) is trustworthy, in the paper's sense, exactly when a blind executor V(E) recovers the correct answer without access to the original input x. The paper then claims that aggregating structure-preserving perturbations around an anchor instance into a DAG produces a feasible-region representation whose node weights encode both semantic correctness and blind executability, and that this DAG predicts execution success better than repeated sampling on the anchor. At the cluster level, the paper claims that automated failure-mode discovery plus Shapley attribution identifies r","pith_inferences":["The paper leaves implicit that blind execution can be used as a filter: traces that fail are exactly the ones that are not self-contained, so a system could re-prompt for more explicit steps or flag the prediction as less trustworthy.","A stricter blind test would use an executor with no prior exposure to the problem family; because the paper's executor is itself a large language model with latent problem-solving knowledge, part of the measured executability may reflect the executor's competence rather than trace completeness.","The feasible-region DAG could be extended into a robustness probe: regions where the DAG predicts low success probability are natural targets for data augmentation or adversarial input generation.","The Shapley failure-mode rankings suggest a direct falsifiable extension—injecting the highest-ranked failure mode into correct samples should degrade accuracy more than injecting low-ranked ones; reporting error bars and baseline injection rates would sharpen that test."],"forward_implications":["On numerical reasoning tasks, correct traces usually survive blind execution, so explanation completeness and prediction correctness nearly coincide; on logic and knowledge tasks the gap widens, exposing where traces rely on implicit input information.","The feasible-region DAG built from perturbations can predict execution success substantially better than repeated chain-of-thought sampling, indicating it captures structural information beyond individual trajectories.","Stronger base models produce more executable explanations, so executability tracks model capability and can serve as a diagnostic for explanation quality.","Failure modes concentrate in a few structural operations—like percentage transformations and date calculations—rather than being uniformly distributed, pointing toward targeted interventions.","The near-zero recovery rate on math tasks versus nonzero recovery on multiple-choice tasks suggests the framework can distinguish settings where explanations contain recoverable signals that correct the original prediction."],"fun_headline_variants":["Reasoning traces pass a blind test or they don't count","LLM explanations get a DAG that maps where they actually work","Shapley values reveal why LLM reasoning fails","Unified framework turns traces into tests, maps stability, and ranks failures","Blind execution validates LLM traces; DAGs map stability; Shapley ranks failures"],"cache_read_input_tokens":2304,"weakest_assumption_plain":"The load-bearing premise is that the blind executor contributes no knowledge beyond the explanation itself; if the executor's latent ability fills in missing steps or recognizes the problem family, a high Executable Accuracy does not actually prove the explanation is complete and self-contained.","fun_headline_variants_meta":{"raw":{"variants":["Reasoning traces pass a blind test or they don't count","LLM explanations get a DAG that maps where they actually work","Shapley values reveal why LLM reasoning fails","Unified framework turns traces into tests, maps stability, and ranks failures","Blind execution validates LLM traces; DAGs map stability; Shapley ranks failures"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000709,"raw_usage":{"total_tokens":3028,"prompt_tokens":739,"completion_tokens":2289,"prompt_tokens_details":{"cached_tokens":256},"prompt_cache_hit_tokens":256,"prompt_cache_miss_tokens":483,"completion_tokens_details":{"reasoning_tokens":2195}},"tokens_in":483,"tokens_out":2289,"duration_ms":13859,"temperature":1.0,"reasoning_tokens":2195,"cache_read_input_tokens":256,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-02T21:48:51.105013+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Take a set of traces that pass blind execution, delete one essential step from each, and run the same executor again: if it still recovers the correct answer, the executor is supplying the missing information and the verification is not blind. A cleaner empirical test is to replace the LLM executor with a formal arithmetic interpreter on GSM8K; if Executable Accuracy drops materially from the reported numbers, the reported executability partly reflects executor knowledge rather than trace completeness.","supporting_citations":[],"review_version":1}