Pith. sign in

REVIEW 4 major objections 4 minor 17 references

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

Reviewed by Pith at T0; open to challenge. T0 means a machine referee read the full paper against a public rubric. the ladder, T0–T4 →

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

T0 review · deepseek-v4-flash

2026-08-02 21:48 UTC pith:6EGJJZAH

load-bearing objection 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. the 4 major comments →

arxiv 2602.18905 v2 pith:6EGJJZAH submitted 2026-02-21 cs.LG cs.AIcs.CL

TRUE: A Trustworthy Unified Explanation Framework for Large Language Model Reasoning

Yujiao Yang This is my paper
classification cs.LG cs.AIcs.CL
keywords executable explanationsblind execution verificationfeasible-region DAGreasoning stabilityfailure mode analysisShapley attributionchain-of-thought faithfulnessLLM interpretability
verification ladder T0 review T1 audit T2 compute T3 formal T4 reserved

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

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.

Core claim

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

What carries the argument

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.

Load-bearing premise

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.

What would settle it

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.

Watch this falsifier — get emailed when new claim-graph text bears on it.

If this is right

  • 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.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

  • 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.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit.

Referee Report

4 major / 4 minor

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.

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 (4)
  1. [§3.1, Definition 2 and Eq. (2); §4.1, Table 1 and Table 2] 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).
  2. [§4.1, Tables 1–2; §4.2, Table 3; §4.3, Table 5] 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.
  3. [§3.3, Eq. (11); §4.3, Table 5] 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.
  4. [§3.2, Table 3] 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.
minor comments (4)
  1. [§4.2, Table 4 and text] 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.
  2. [Table 2 caption and Eq. (14)] 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.
  3. [Table 5 title] 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.
  4. [§4.2 and §4.3 notation] The symbol n is used for both cluster size in Section 4.2 and subsampling size in Section 4.3, which may confuse readers.

Circularity Check

2 steps flagged

Blind-execution trustworthiness is measured with the same model family that generates the explanations, and the local DAG is evaluated on the perturbed trajectories used to build it; headline EA/EC and Pret. coverage numbers are therefore partly self-validating.

specific steps
  1. other [Section 3.1 (Definition 2) and Section 4.1 (Experimental Settings)]
    "Definition 2: 'An executable explanation E is considered trustworthy if it contains sufficient information such that an independent executor can recover the correct answer without access to the original input problem x.' Section 4.1: 'we adopt GPT-4o-mini as the base language model and generate explanations...' 'During the blind execution stage, GPT-4o-mini is uniformly used as the executor to control execution variance across models, ensuring that performance differences reflect explanation quality rather than executor capability.'"

    Definition 2 makes trustworthiness depend on an 'independent executor' recovering the answer from E alone. The experiments, however, set the executor to GPT-4o-mini, the same model family used to generate the explanations. A successful blind execution can therefore be produced by the executor's pretraining priors filling in omitted steps or reconstructing the problem, rather than by the information encoded in E. Since the white-box arithmetic/rule-based modules that were supposed to constrain the LLM executor are not described or reported in the experiments, EA and EC are effectively self-consistency scores between two calls to the same model family. The paper's inference that successful blind execution proves the explanation encodes a complete, self-contained solution structure is thus no

  2. fitted input called prediction [Section 4.2, Experimental Setup and Table 4]
    "'We then aggregate reasoning traces from the original and perturbed instances using the proposed framework to construct a local feasible-region DAG...' 'Pret.(%) represents the average trajectory coverage rate of perturbed instances, while GT(%) denotes the coverage rate of ground-truth reasoning trajectories.'"

    The DAG is constructed from the original and perturbed instances, and Table 4 then reports Pret. coverage on those same perturbed instances. Because the DAG's nodes and edges are defined as merged reasoning steps observed across these trajectories, high Pret. coverage is expected from the construction itself. It is an in-sample fit, not an independent measurement of generalization to new instances. The paper presents the Pret. column as evidence that the DAG 'captures nearly all reasoning steps observed across both perturbed and original instances,' but that metric is forced by the fact that the evaluation trajectories are the ones used to build the DAG; only the GT column provides partially independent evidence.

full rationale

The central definitional idea—an explanation is trustworthy if an independent executor can recover the answer from the explanation alone—is not tautological and is, in principle, testable. However, the experimental operationalization breaks the required independence: GPT-4o-mini is used both to generate the explanations and as the blind executor, and the white-box modules that were supposed to restrict the LLM executor are absent from the experiment section. Consequently, Executable Accuracy and Executable Consistency measure self-consistency between two calls to the same model family rather than whether the explanation is a complete, self-contained procedure. A second partial circularity occurs in the local feasible-region evaluation, where the DAG is built from the same perturbed trajectories later used to compute Pret. coverage, so that coverage number is a training-fit quantity. The class-level failure-mode analysis also has a self-assessment flavor—the same LLM discovers, selects, and evaluates failure modes—but this is less cleanly a construction-level reduction and does not independently raise the score. No self-citation chain or imported uniqueness theorem is involved, and external checks such as GT trajectory coverage and standard benchmarks provide some non-circular evidence. Overall, the paper has substantial independent content, but its two headline validations are partially circular, justifying a score of 6.

Axiom & Free-Parameter Ledger

3 free parameters · 6 axioms · 2 invented entities

The framework introduces no physical entities, but it relies on several unverified methodological premises: an LLM blind executor that is independent, perturbation families that preserve solution structure, LLM semantic verifiers that are accurate, and LLM-discovered failure modes that are causally manipulable. Most are asserted rather than demonstrated.

free parameters (3)
  • Number of failure modes per cluster (K=5) = 5
    Hand-selected as the five failure modes 'assessed by the LLM as having high structural impact potential' (Section 4.3). Shapley decomposition and stability results depend on this choice.
  • Perturbation regime strengths (mild/moderate/aggressive) = not specified
    Chosen by hand and not quantitatively defined in Section 4.2; Table 4 coverage results depend on these boundaries.
  • Subsampling cluster sizes for stability analysis = 5, 10, 20, 40
    Manual scales used in Section 4.3; the claim that stability saturates at n approximately 20 depends on these particular values.
axioms (6)
  • ad hoc to paper A blind executor that is itself an LLM will not use prior knowledge to fill gaps in the explanation.
    Definition 2 requires an 'independent executor', but Section 4.1 uses GPT-4o-mini as executor with no control against latent knowledge. This is the load-bearing premise.
  • domain assumption Structure-preserving perturbations can be generated such that the reference solution remains valid and labels can be recomputed.
    Section 3.2 assumes parameter variations, entity substitutions, and condition adjustments preserve the solution structure without a formal criterion.
  • domain assumption The LLM semantic verifier's agreement indicates semantic correctness.
    Equation (4) uses an LLM g to determine semantic consistency Ci; no validation of the verifier's accuracy is provided.
  • domain assumption LLM-assisted inductive summarization yields clusters with shared reasoning structure.
    Section 3.3 clusters samples via LLM-assisted summarization without comparison to human clusters or formal similarity measures.
  • standard math Shapley value formula (Eq. 11) is applicable to v(S) estimated on small, non-independent intervention sets.
    Equation 11 is the standard Shapley formula, but its causal interpretation requires well-defined v(S) for all coalitions and interventions that change only the target failure mode, which is not established.
  • domain assumption API models are treated as fixed and deterministic for the evaluation.
    No seeds, temperatures, or API versions are pinned, yet the tables treat model outputs as stable enough for percentage-level comparisons.
invented entities (2)
  • Feasible-region DAG over merged reasoning steps no independent evidence
    purpose: Compact representation of local reasoning stability and executable paths
    Node and edge construction depends on LLM merging and semantic equivalence judgments; there is no uniqueness guarantee or external benchmark for this object.
  • Failure mode f_i as a minimal structural condition no independent evidence
    purpose: Binary indicator used to summarize and intervene on recurring reasoning errors
    Failure modes are defined by the same LLM being diagnosed; no validation that they are minimal, structural, or causally distinct.

pith-pipeline@v1.3.0-alltime-deepseek · 12761 in / 14446 out tokens · 129435 ms · 2026-08-02T21:48:51.105013+00:00 · methodology

0 comments
read the original abstract

Large language models (LLMs) have demonstrated strong capabilities in complex reasoning tasks, yet their decision-making processes remain difficult to interpret. Existing explanation methods often lack trustworthy structural insight and are limited to single-instance analysis, failing to reveal reasoning stability and systematic failure mechanisms. To address these limitations, we propose the Trustworthy Unified Explanation Framework (TRUE), which integrates executable reasoning verification, feasible-region directed acyclic graph (DAG) modeling, and causal failure mode analysis. At the instance level, we redefine reasoning traces as executable process specifications and introduce blind execution verification to assess operational validity. At the local structural level, we construct feasible-region DAGs via structure-consistent perturbations, enabling explicit characterization of reasoning stability and the executable region in the local input space. At the class level, we introduce a causal failure mode analysis method that identifies recurring structural failure patterns and quantifies their causal influence using Shapley values. Extensive experiments across multiple reasoning benchmarks demonstrate that the proposed framework provides multi-level, verifiable explanations, including executable reasoning structures for individual instances, feasible-region representations for neighboring inputs, and interpretable failure modes with quantified importance at the class level. These results establish a unified and principled paradigm for improving the interpretability and reliability of LLM reasoning systems.

Figures

Figures reproduced from arXiv: 2602.18905 by Yujiao Yang.

Figure 1
Figure 1. Figure 1: Generation and verification of executable [PITH_FULL_IMAGE:figures/full_fig_p004_1.png] view at source ↗
Figure 2
Figure 2. Figure 2: Construction of the local feasible-region [PITH_FULL_IMAGE:figures/full_fig_p005_2.png] view at source ↗
Figure 3
Figure 3. Figure 3: Overview of the proposed failure mode discovery [PITH_FULL_IMAGE:figures/full_fig_p006_3.png] view at source ↗
Figure 4
Figure 4. Figure 4: Cluster size scaling of failure mode stability. Mode overlap (Jaccard) and ranking stability [PITH_FULL_IMAGE:figures/full_fig_p013_4.png] view at source ↗

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Reference graph

Works this paper leans on

17 extracted references · 11 linked inside Pith

  1. [1]

    Measuring faithfulness in chain-of-thought reasoning.arXiv preprint arXiv:2307.13702,

    Tamera Lanham, Anna Chen, Ansh Radhakrishnan, Benoit Steiner, Carson Denison, Danny Hernan- dez, Dustin Li, Esin Durmus, Evan Hubinger, Jackson Kernion, et al. Measuring faithfulness in chain-of-thought reasoning.arXiv preprint arXiv:2307.13702,

    Pith/arXiv arXiv

  2. [6]

    Attribot: A bag of tricks for efficiently approximat- ing leave-one-out context attribution.arXiv preprint arXiv:2411.15102,

    Fengyuan Liu, Nikhil Kandpal, and Colin Raffel. Attribot: A bag of tricks for efficiently approximat- ing leave-one-out context attribution.arXiv preprint arXiv:2411.15102,

    Pith/arXiv arXiv

  3. [7]

    Maxshapley: Towards incentive-compatible generative search with fair context attribution.arXiv preprint arXiv:2512.05958,

    Sara Patel, Mingxun Zhou, and Giulia Fanti. Maxshapley: Towards incentive-compatible generative search with fair context attribution.arXiv preprint arXiv:2512.05958,

    Pith/arXiv arXiv

  4. [8]

    Understanding data influence with differential approximation.arXiv preprint arXiv:2508.14648,

    Haoru Tan, Sitong Wu, Xiuzhe Wu, Wang Wang, Bo Zhao, Zeke Xie, Gui-Song Xia, and Xiaojuan Qi. Understanding data influence with differential approximation.arXiv preprint arXiv:2508.14648,

    Pith/arXiv arXiv

  5. [9]

    llmshap: A principled approach to llm explainability.arXiv preprint arXiv:2511.01311,

    Filip Naudot, Tobias Sundqvist, and Timotheus Kampik. llmshap: A principled approach to llm explainability.arXiv preprint arXiv:2511.01311,

    arXiv

  6. [10]

    Larger language models do in-context learning differently.arXiv preprint arXiv:2303.03846,

    Jerry Wei, Jason Wei, Yi Tay, Dustin Tran, Albert Webson, Yifeng Lu, Xinyun Chen, Hanxiao Liu, Da Huang, Denny Zhou, et al. Larger language models do in-context learning differently.arXiv preprint arXiv:2303.03846,

    Pith/arXiv arXiv

  7. [11]

    Self-consistency improves chain of thought reasoning in language models

    15 Xuezhi Wang, Jason Wei, Dale Schuurmans, Quoc Le, Ed Chi, Sharan Narang, Aakanksha Chowdh- ery, and Denny Zhou. Self-consistency improves chain of thought reasoning in language models. arXiv preprint arXiv:2203.11171,

    Pith/arXiv arXiv

  8. [13]

    Language models of code are few-shot commonsense learners

    Aman Madaan, Shuyan Zhou, Uri Alon, Yiming Yang, and Graham Neubig. Language models of code are few-shot commonsense learners. InProceedings of the 2022 Conference on Empirical Methods in Natural Language Processing, pages 1384–1403,

    2022

  9. [14]

    Context-faithful prompting for large language models

    Wenxuan Zhou, Sheng Zhang, Hoifung Poon, and Muhao Chen. Context-faithful prompting for large language models. InFindings of the Association for Computational Linguistics: EMNLP 2023, pages 14544–14556,

    2023

  10. [15]

    Training verifiers to solve math word problems.arXiv preprint arXiv:2110.14168,

    Karl Cobbe, Vineet Kosaraju, Mohammad Bavarian, Mark Chen, Heewoo Jun, Lukasz Kaiser, Matthias Plappert, Jerry Tworek, Jacob Hilton, Reiichiro Nakano, et al. Training verifiers to solve math word problems.arXiv preprint arXiv:2110.14168,

    Pith/arXiv arXiv

  11. [17]

    Challenging big-bench tasks and whether chain-of-thought can solve them

    Mirac Suzgun, Nathan Scales, Nathanael Schärli, Sebastian Gehrmann, Yi Tay, Hyung Won Chung, Aakanksha Chowdhery, Quoc Le, Ed Chi, Denny Zhou, et al. Challenging big-bench tasks and whether chain-of-thought can solve them. InFindings of the Association for Computational Linguistics: ACL 2023, pages 13003–13051,

    2023

  12. [2016]

    Noiser: Bounded input perturbations for attributing large language models.arXiv preprint arXiv:2504.02911,

    Mohammad Reza Ghasemi Madani, Aryo Pradipta Gema, Gabriele Sarti, Yu Zhao, Pasquale Min- ervini, and Andrea Passerini. Noiser: Bounded input perturbations for attributing large language models.arXiv preprint arXiv:2504.02911,

    Pith/arXiv arXiv

  13. [2021]

    Measuring mathematical problem solving with the math dataset.arXiv preprint arXiv:2103.03874,

    Dan Hendrycks, Collin Burns, Saurav Kadavath, Akul Arora, Steven Basart, Eric Tang, Dawn Song, and Jacob Steinhardt. Measuring mathematical problem solving with the math dataset.arXiv preprint arXiv:2103.03874,

    Pith/arXiv arXiv

  14. [2022]

    Selfcite: Self-supervised alignment for context attribution in large language models.arXiv preprint arXiv:2502.09604,

    Yung-Sung Chuang, Benjamin Cohen-Wang, Shannon Zejiang Shen, Zhaofeng Wu, Hu Xu, Xi Victo- ria Lin, James Glass, Shang-Wen Li, and Wen-tau Yih. Selfcite: Self-supervised alignment for context attribution in large language models.arXiv preprint arXiv:2502.09604,

    Pith/arXiv arXiv

  15. [2023]

    Making reasoning matter: Measuring and improving faithfulness of chain-of-thought reasoning

    Debjit Paul, Robert West, Antoine Bosselut, and Boi Faltings. Making reasoning matter: Measuring and improving faithfulness of chain-of-thought reasoning. InFindings of the Association for Computational Linguistics: EMNLP 2024, pages 15012–15032,

    2024

  16. [2024]

    Token- shapley: Token level context attribution with shapley value

    Yingtai Xiao, Yuqing Zhu, Sirat Samyoun, Wanrong Zhang, Jiachen T Wang, and Jian Du. Token- shapley: Token level context attribution with shapley value. InFindings of the Association for Computational Linguistics: ACL 2025, pages 3882–3894,

    2025

  17. [2025]

    Faithfulness vs

    Chirag Agarwal, Sree Harsha Tanneru, and Himabindu Lakkaraju. Faithfulness vs. plausibility: On the (un) reliability of explanations from large language models.arXiv preprint arXiv:2402.04614,

    Pith/arXiv arXiv