Causal Sufficiency and Necessity Improves Chain-of-Thought Reasoning

1.[Q1] How does your method implement causal reasoning—if there is no explicit structural dependence or counterfactual modeling? Would the results differ if standard conditional probabilities were used instead?

(1) Why Our Method Is Counterfactual

Counterfactual reasoning follows the “abduction–intervention–prediction” paradigm. In our case:

• Abduction is implicitly simulated by fixing the upstream context $(s_{<t}, q)$ for all rollouts.
• Intervention is performed by replacing a single reasoning step $s_t$ with a semantically disjoint alternative $\bar{s}_t$.
• Prediction is executed by generating a full downstream reasoning chain from the modified input and evaluating the outcome.

While we do not build a causal graph explicitly, this process mimics counterfactual inference by isolating a cause ($s_t$) and observing the impact of its intervention ($\bar{s}_t$) on the final answer. This is distinct from simply computing conditional probabilities like $p(a \mid s, q)$ or $p(a’ \mid \bar{s}, q)$, which lack an explicit notion of intervention or structural manipulation. In our setting, we actively intervene on the step and generate downstream consequences.

(2) How PNS Is Computed Operationally

While PNS is theoretically defined in terms of counterfactual probabilities, it is not directly computable. In our paper, we derive an empirical approximation (see paper Equation 10):

$$\mathrm{PNS}(\mathbf{S}, \overline{\mathbf{s}}\_t, \mathbf{q}) \approx 1 - \frac{1}{k} \sum_{i=1}^{k} V(\overline{\mathbf{S}}^{(i)})$$

Here’s how we compute it in practice:

1. We perform a counterfactual intervention on a single step $s_t$ by replacing it with a semantically disjoint alternative $\bar{s}_t$ (i.e., not a trivial paraphrase).
2. From the alternative step, we use a large language model to generate a full reasoning chain $\bar{S}_{>t}$.
3. We apply a validator $V$ to check whether the counterfactual reasoning still leads to the correct final answer.

The validator $V$ is not a static function, but rather an operation that executes the new reasoning path and checks its correctness.

We repeat this process for $k$ different $\bar{s}_t^{(i)}$, and estimate the counterfactual success rate:

$$\frac{1}{k} \sum_{i=1}^{k} V(\overline{\mathbf{S}}^{(i)})$$

This success rate quantifies how easily the original step $s_t$ can be replaced without affecting the final outcome:

• A high success rate implies that $s_t$ is not necessary—it can be replaced with alternatives that still lead to the correct result.
• A low success rate suggests that $s_t$ is causally necessary—its absence results in incorrect answers.

Thus, the complement term 1 - $\text{success rate}$ serves as an empirical estimate of the PNS value for step $s_t$.

(3) Validator Accuracy and Robustness

To assess the reliability of the validator $V$, we conduct experiments varying both the underlying LLM and the number of rollouts $k$. The table below shows the mean absolute error between estimated PNS values and ground-truth, where ground-truth PNS is set to 1 based on a reasoning chain judged by experts to be both necessary and sufficient.

Table R1. Validator Accuracy Across LLMs and Rollout Sizes

Values indicate the mean absolute error $| \widehat{\mathrm{PNS}} - \mathrm{PNS} |$ across evaluation samples. Lower is better.

• Increasing $k$ improves the stability and reliability of the PNS estimate.
• Stronger LLMs used as validators yield more accurate evaluations.
• The validator $V$ is crucial for enabling counterfactual analysis in practice.

We will include this explanation in the revised manuscript.

2.[Q2] Analysis of the Number and Complexity of Tokens for Complete PNS Reasoning.

(1) We added a new experiment (see Table R2) showing token cost and rollout complexity across LLMs (e.g., Qwen2.5) and LRMs (e.g., DeepSeek R1) during PNS filtering.

(2) We also compare average tokens per CoT before and after PNS-based fine-tuning (see Table 3 in the main paper), demonstrating reduced inference cost and improved conciseness.

• Across three different LLM families, we observe a consistent trend: while PNS filtering introduces a moderate one-time token cost during data preparation, it yields over 20% token savings during inference.
• The accuracy of all models is either maintained or improved, confirming that the CoTs retained after causal filtering are both concise and effective.
• This supports our central claim: PNS filtering reshapes the training distribution, enabling the model to generate more efficient and logically minimal reasoning paths—without requiring inference-time pruning.

Table R2. Token usage and complexity during PNS filtering

Rollouts: Average number of step-level interventions (regenerations) per CoT.
Avg. Tokens: Average total number of tokens generated per example during PNS filtering.

Overall, our results show that the proposed method reduces reasoning redundancy, trading a one-time overhead for sustained improvements in inference efficiency.

3.[Q3] How many rollouts per intervention are typically needed to get reliable PNS estimates in practice?

As shown in Table R1(above), we conducted additional evaluations to assess how the number of rollouts $k$ affects the stability of PNS estimates. Both theoretical considerations and empirical results indicate that increasing $k$ improves estimation reliability. In practice, we found that using $k = 3 \sim 5$ strikes a good balance between computational cost and accuracy. We will clarify this design choice in the final version.

4.[Q4] In Equation 4, should q be included as a conditioning variable on the right-hand side?

Thank you for pointing this out. Yes, all probability expressions in our method are implicitly conditioned on the question $q$ (e.g., Equation 4). We followed the standard convention of omitting global conditions like the input prompt for notational simplicity. In the revised manuscript, we will explicitly clarify that all probability terms are conditioned on $q$, unless otherwise specified.

5.[Q5] There is a whole literature on necessity and sufficiency for XAI that may be relevant here (see links below).

Thank you very much for the valuable references — these are all excellent and inspiring works. We will incorporate them into the Related Work section of the revised version.

Causal Necessity and Sufficiency in XAI. Our work relates closely to prior studies that explain model behavior via necessity and sufficiency [1–5]. For instance, LENS [1] identifies necessary and sufficient conditions for outputs better than mainstream XAI methods; Darwiche et al. [2] use Decision-DNNF circuits to compute all sufficient reasons efficiently; Mothilal et al. [3] generate diverse counterfactuals using determinant point processes; Beckers [4] formalizes sufficiency-based explanations for action guidance and fairness; Galhotra et al. [5] introduce LEWIS, a probabilistic counterfactual explanation method. In contrast, our PNS evaluation targets LLM reasoning chains, using counterfactual rollouts to assess the causal necessity and sufficiency of CoT traces—offering a causal solution to the overthinking problem in LLMs.

We sincerely thank you for your constructive and insightful feedback. Our responses are as follows:

1. [Q1] Can you discuss how PNS optimization is different from SPIRIT [1]? They look similar as both involve counterfactual intervention and scoring with an LLM.

Thank you for raising this important point. We have conducted an additional experiment to directly compare our method with SPIRIT, focusing on its prompt-based ICL version. The results are shown in Table R1 below, and more baseline reproductions will be added in future work.

Although both our method and SPIRIT [1] involve selecting reasoning steps, there are fundamental differences in their principles and goals:

1. Causal vs. Heuristic: Our method is grounded in causal theory, using Probability of Necessity and Sufficiency (PNS) to guide selection. In contrast, SPIRIT relies on perplexity, a fluency-based heuristic that reflects the LLM’s confidence but not its causal contribution.
2. Counterfactual Intervention: We perform actual interventions (i.e., step modification and rollout) to estimate how altering each step impacts the final outcome. SPIRIT does not perform such counterfactual evaluation.
3. Optimization Objective: Our goal is to retain only those steps that are both necessary and sufficient, ensuring causal minimality. SPIRIT, on the other hand, aims to reduce token count while maintaining fluency, which may inadvertently discard causally important steps.

We have added both SPIRIT [1] and Ton et al. [2] to the Related Work section of the revised manuscript:

SPIRIT [1] uses perplexity to effectively identify key reasoning steps, achieving a balance between accuracy and efficiency in both few-shot CoT and fine-tuning settings, and also exhibits strong cross-model transferability. Ton et al. [2], based on information-theoretic principles, quantify the contribution of each step in the reasoning chain to the final correct answer using conditional mutual information, enabling the identification of reasoning failure patterns in large language models without requiring manual annotation of intermediate steps.

Table R1. Comparison with SPIRIT.

Our additional experiments corroborate the main findings reported in the paper (see lines 212–222): our method consistently achieves better accuracy–efficiency trade-offs across diverse models and datasets. Compared to several baselines, it significantly reduces the number of steps and tokens without compromising accuracy—and often improves it.

2.[Q2] In Equation 2, what is $\bar{S}$ in the RHS? It’s not defined in the LHS. Can I understand RHS as the average for any $\bar{S}$?

Thank you for pointing this out. In Equation 2, $\bar{S}$ denotes a reasoning chain that fails to produce the correct answer. The expression on the right-hand side should not be interpreted as an average over all possible , but rather as being restricted to the context where $A \ne y$.

3. [Q3] Is Equation 4 factorizable as $P(A_S = y) \cdot P(A_{S'} \ne y)$? That would be more intuitive for your Lemma 1.

Thank you for the question. This factorization is mathematically invalid due to a causal dependency between the events $A_S = y$ and $A_{S'} \ne y$.

Equation (4) defines a joint probability:

$$PNS(S, s_t, q) = P(A_S = y, A_{S'} \ne y)$$

By the chain rule of probability:

$$P(A_S = y, A_{S'} \ne y) = P(A_S = y) \cdot P(A_{S'} \ne y \mid A_S = y)$$

Since $S$ and $S'$ differ by only one step, their outputs are highly correlated. Therefore, the conditional probability cannot be simplified to a marginal:

$$P(A_{S'} \ne y \mid A_S = y) \ne P(A_{S'} \ne y)$$

We will include this derivation and explanation in the final version of the paper for clarity.

4. [Q4] What is semantic disjointness in Algorithm 1?

In Algorithm 1, semantic disjointness refers to the requirement that the perturbed step and its subsequent steps are substantially different in meaning and reasoning logic from the original step. This constraint avoids trivial rewordings and ensures that the counterfactual chain represents a truly distinct reasoning path. We will clarify this in the algorithm description.

5. [Q5] Where do the unoptimized CoT traces come from? Are they human annotated, or elicited by zero-shot CoT prompting? If there is no comparison against other CoT optimization methods, how can I trust the initial unoptimized CoT traces are not deliberately made overthinking?

Thank you for the question. The unoptimized CoTs used in our experiments are generated via zero-shot or few-shot prompting from strong language models (e.g., Qwen-2.5-72B-Instruct). These are produced using the same system prompt as in our Ours-ICL setting (see Appendix C), and no human editing or annotation is applied. To avoid bias, we use standard open-ended prompts and do not manually craft overthinking chains.

We have already included multiple prompt-based baselines for comparison (see Table 2 in the paper main text and prompt templates in Appendix C). In this revision, we also added SPIRIT as a new baseline in the expanded Table R1 (which extends Table 2 of the main paper).

6. [Q6] What is the setting for measuring accuracy in Table 1? Is it like in-context learning in Table 2 or fine-tuning in Table 3?

Accuracy is consistently computed as follows, and the setting corresponds to in-context learning as in Table 2 or fine-tuning as in Table 3, depending on the experiment. $\text{Acc} = \frac{\text{Number of correct CoTs}}{\text{Total number of CoTs in the dataset}}.$

The accuracy improvements in Table 1 arise from repeated applications of Algorithm 1 across the dataset, where each step in the CoT undergoes multiple rollouts. This significantly increases the likelihood of generating a correct answer. CoTs with PS < 1 may be ignored in a single run, but will be revisited in subsequent rollouts. Thus, PS enhancement is implicitly achieved via repeated generation and validation within each CoT execution unit.

7. [Q7] Table 3: Does “Original” refer to the model before SFT? Does “Noncausal” refer to unoptimized SFT data?

Yes, exactly:

• “Original” refers to the base model before any supervised fine-tuning (SFT).
• “Noncausal” refers to the model fine-tuned on unfiltered, unoptimized CoTs.
• “Causal” refers to the model fine-tuned on CoTs filtered and optimized via our PNS method.

8.[Q8] Line 97: “in Pearl” → “by Pearl”

Thank you for catching this! We will correct “in Pearl” to “by Pearl” in the revised version.

We sincerely thank the reviewer for the close and thoughtful reading. Your comment helps us clarify the structure and intent of our method more precisely.

Contrary to the concern, our method does not assume sufficiency is fulfilled. Instead, it incorporates a mechanism that explicitly optimizes sufficiency (PS) through iterative sampling and evaluation. Specifically, when the original Chain-of-Thought (CoT) is insufficient—i.e., it fails to produce the correct answer—our method repeatedly executes Algorithm 1 under the same question context to sample new CoTs and re-evaluate their PS. This iterative resampling increases the chance of obtaining a causally sufficient CoT before applying any necessity-based pruning.

Therefore, sufficiency is not assumed, but actively optimized through multiple generations and evaluations. We will revise the manuscript to clarify this mechanism and ensure the abstract and contributions section more accurately reflect this two-phase design.

1.[Q1 & W1, W2] Does the complete PNS procedure consume more tokens than CoT? If so, can we reduce the token usage or train the model to generate shorter and more effective reasoning directly? Is this approach just prompt engineering?

Thank you for the thoughtful questions. We respond as follows:

Our method adopts a two-stage framework (see Lines 120–128):

1. Data preparation stage: We apply the PNS-based filtering method to existing CoT data to optimize and clean reasoning traces. This ensures that the selected CoTs satisfy both necessity and sufficiency.
2. Inference stage: We use the optimized dataset to perform in-context learning or fine-tuning, enabling the model to learn to generate short and effective reasoning in a single forward pass.

While it is true that the PNS filtering process incurs additional token usage during the data preparation phase, this is a one-time cost. Crucially, the actual inference process after fine-tuning consumes fewer tokens, as the model learns to generate concise and accurate reasoning directly—without requiring step-by-step rollout or post-hoc pruning.

In this sense, the strength of our method does not lie in reducing token usage during the filtering phase, but rather in reshaping the training distribution. By training on high-PNS data, the model internalizes causally meaningful and non-redundant reasoning patterns. The benefit manifests at inference time, where the model naturally produces streamlined CoTs, improving both efficiency and interpretability.

Finally, we would like to clarify that our method is not merely prompt engineering. Although the filtering procedure is prompt-based, the core of our approach lies in learning from causally sound CoTs via supervised fine-tuning (SFT). After this training, the model is able to generalize the PNS principle, generating short and effective reasoning from scratch—without requiring further intervention.

We will revise the manuscript to clarify this two-stage design and the distinction between one-time filtering overhead and long-term inference efficiency.

2.[Q2 & W3] Analysis of the Number and Complexity of Tokens for Complete PNS Reasoning.

(1) We added a new experiment (see Table R1) showing token cost and rollout complexity across LLMs (e.g., Qwen2.5) and LRMs (e.g., DeepSeek R1) during PNS filtering.

(2) We also compare average tokens per CoT before and after PNS-based fine-tuning (see Table 3 in the main paper), demonstrating reduced inference cost and improved conciseness.

• Across three different LLM families, we observe a consistent trend: while PNS filtering introduces a moderate one-time token cost during data preparation, it yields over 20% token savings during inference.
• The accuracy of all models is either maintained or improved, confirming that the CoTs retained after causal filtering are both concise and effective.
• This supports our central claim: PNS filtering reshapes the training distribution, enabling the model to generate more efficient and logically minimal reasoning paths—without requiring inference-time pruning.

Table R1. Token usage and complexity during PNS filtering

Rollouts: Average number of step-level interventions (regenerations) per CoT.
Avg. Tokens: Average total number of tokens generated per example during PNS filtering.

Time Complexity Derivation:

Let $n$ be the number of reasoning steps in a CoT;

$k$ the number of rollouts per step;

$l_{\text{step}}$ the average number of tokens generated per step;

$l_{\text{out}}$ the number of tokens required to generate an answer during verification (typically constant);

and $t_{\text{token}}$ the time required to generate one token (a constant).

Assuming each rollout at step $i$ generates approximately $(n - i)$ subsequent steps, each with $l_{\text{step}}$ tokens, the total rollout cost is:

$$T_{\text{rollout}} = \sum_{i=1}^{n} k \cdot (n - i) \cdot l_{\text{step}} \cdot t_{\text{token}} = O(k \cdot l_{\text{step}} \cdot t_{\text{token}} \cdot n^2)$$

Each rollout also requires evaluating whether the generated result is valid, including generating the answer ($l_{\text{out}}$ tokens) and the full chain:

$$T_{\text{eval}} = \sum_{i=1}^{n} k \cdot \left[ (n - i) \cdot l_{\text{step}} + l_{\text{out}} \right] \cdot t_{\text{token}} = O(k \cdot t_{\text{token}} \cdot (l_{\text{step}} \cdot n^2 + l_{\text{out}} \cdot n))$$

Since $l_{\text{out}} \ll l_{\text{step}} \cdot n$, we simplify:

$$T_{\text{eval}} = O(k \cdot l_{\text{step}} \cdot t_{\text{token}} \cdot n^2)$$

Combining both rollout and evaluation:

$$T_{\text{total}} = T_{\text{rollout}} + T_{\text{eval}} = O(k \cdot l_{\text{step}} \cdot t_{\text{token}} \cdot n^2)$$

Since $l_{\text{step}}$ and $t_{\text{token}}$ are typically constant or nearly so, the final complexity simplifies to:

$$T_{\text{PNS}} = O(k \cdot n^2)$$

Overall, our results show that the proposed method reduces reasoning redundancy, trading a one-time overhead for sustained improvements in inference efficiency.

3.[Q3 & W4] Qualitative Analysis of Whether the Final Reasoning Is Sufficient and Necessary.

Thank you for the insightful suggestion. We conducted an additional human evaluation on 50 CoT samples, all generated by a model fine-tuned on data optimized using our PNS-based algorithm. Five mathematics experts were involved in validating the 50 samples, assessing whether each reasoning chain was sufficient and necessary to support the final answer.

• S&N: The reasoning is both sufficient and necessary to support the final answer;
• SbU: The reasoning is sufficient but includes unnecessary (redundant) steps;
• NbI: The reasoning is insufficient, i.e., missing critical steps;

The results are summarized as follows:

Table R2. Human Evaluation of Reasoning Quality

These results confirm that most model outputs are not only accurate but also logically sound under the criteria of sufficiency and necessity.

Notably:

• 84% of CoTs are classified as both sufficient and necessary (S&N),
• Only 3 out of 50 CoTs (6.0%) were deemed insufficient (Nbl),
• MATH-500 exhibits a slightly higher rate of redundancy and incompleteness, which is expected due to the complexity of mathematical reasoning.

We will include this evaluation and Table R2 in the revised manuscript.

We added a supplementary analysis to better address the issue of token usage and reasoning complexity in complete PNS filtering. Specifically, we introduced two new metrics—Original Step Length and Original Token Count—to more precisely capture the input CoT complexity before filtering. This extended analysis, shown in Table R4, offers deeper insight into how input length correlates with PNS overhead.

Table R4. Token usage and complexity during PNS filtering

Contrary to intuition, our findings show that longer original CoTs do not necessarily incur higher PNS cost. Token usage during filtering varies with the causal structure, not just surface length, demonstrating that PNS adapts dynamically rather than scaling linearly with input size.

As before, this cost is incurred only once during the offline data cleaning phase. After fine-tuning, the model learns to produce short, causally sufficient CoTs without any inference-time rollouts—delivering both efficiency and effectiveness.

We would like to supplement more experiment results to fully address your concerns on whether our model indeed learns to generate shorter and more effective reasoning traces—beyond prompt engineering or manual filtering.

We conducted a semantic redundancy analysis on three model families: DeepSeek-R1-Distill-Qwen-1.5B, Phi-4-mini-reasoning, and DeepScaleR-1.5B-Preview. Each model was evaluated before and after PNS fine-tuning using 15 GSM8k and CommonsenseQA questions. We measured average steps per CoT, redundancy score (via sentence embedding similarity), and expert-rated logical validity.

Table R3. Semantic Redundancy Analysis Across Models

Results show that across all three models, PNS-finetuned versions consistently generate shorter and less redundant reasoning while improving logical validity. This demonstrates that the model has learned to eliminate trivial steps and focus on causally essential information.

1. [W1] Related Work Discussion about Using PS and PN in CoT.

Thank you for your insightful comment. To the best of our knowledge, this work is the first to formally introduce the causal concept of Probability of Necessity and Sufficiency (PNS) into large language models, specifically to address the issue of “overthinking” in Chain-of-Thought (CoT) reasoning. While prior studies have explored counterfactual metrics such as PS and PN, PNS has not been applied in this context, nor has it been employed as a causal criterion to identify and prune unnecessary reasoning steps. Our approach offers a novel and actionable causal perspective, leveraging effective intervention strategies to improve both the performance and interpretability of the model.

2.[W2] In Algorithm 1, how is PS improved if the original CoT is incorrect?

Thank you for the question. As PS is defined over the entire reasoning chain (CoT), while PN is defined at the step level, our approach aims to improve PS by repeatedly executing Algorithm 1 under the same question context, especially when the original CoT is insufficient (i.e., fails to yield the correct answer).

In each execution, the model samples an alternative CoT, and its PS is re-evaluated. This repeated sampling increases the likelihood of obtaining a CoT with higher PS, thereby enhancing the reliability of the subsequent PN-based intervention.

Although Algorithm 1 does not explicitly separate this process as a standalone stage, it plays a key role in improving PS before any pruning is applied. We will clarify this iterative refinement mechanism in the revised manuscript to better reflect the actual implementation and practical utility of our method.

3.[W3] Details about metric definition and inference setup (e.g., accuracy calculation and decoding setup)

Thank you for your question. We address each point as follows:

a. On metric definition and decoding setup:

The reported accuracy refers to the average proportion of correctly answered instances in the test set. It is computed as: $\text{Accuracy} = \frac{\text{Number of correct CoTs}}{\text{Total number of CoTs in the dataset}}$

This is a standard evaluation setup in LLM reasoning benchmarks and is consistent with prior CoT literature.

Regarding the decoding configuration, the mention of greedy decoding in the appendix was a typo. We apologize for the confusion. In practice, we consistently use temperature = 0.6 and top_p = 0.95 across all experiments.

b. On the meaning of “accuracy improvement” in RQ1:

The accuracy gains reported in RQ1 result from the fact that, in practice, we continuously apply Algorithm 1 across the dataset. Through repeated rollouts of each CoT step, the probability of generating a correct answer increases significantly. A CoT with PS < 1 might be overlooked in a single run of Algorithm 1, but is revisited and re-evaluated in subsequent rollouts until the entire dataset undergoes PNS-based optimization.

c. On fairness concerns regarding manual inspection in RQ2:

We confirm that no manual editing was performed on the CoTs selected by our method—only human verification of quality was conducted. As shown in RQ1, the CoTs filtered via the PNS method are already causally sound and can be directly used for SFT.

The Non-Causal SFT baseline uses raw, unfiltered CoTs (including both correct and incorrect samples). In contrast, the Causal SFT baseline uses CoTs that were optimized via the PNS-based filtering procedure. This distinction is intentional and fair, as our goal is to demonstrate how causal filtering improves data quality and, ultimately, downstream performance.

We will clarify this design choice and its rationale in greater detail in the revised manuscript.