💬 NLP

Causal Tongue-Tie: LLMs Can Encode Causal Direction, But Their Yes/No Outputs Fail to Express

This paper reveals a "Causal Tongue-Tie" phenomenon in large language models where hidden states accurately encode causal evidence (approx. 97% accuracy) despite the models' verbal Yes/No outputs failing to express this knowledge (approx. 50% accuracy), suggesting that standard benchmarks based solely on final answers may misrepresent a model's true causal reasoning capabilities.

Original authors: Ziyi Ding, Xiao-Ping Zhang

Published 2026-05-26

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Ziyi Ding, Xiao-Ping Zhang

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine a large language model (LLM) as a brilliant but shy student sitting in a classroom. This student has taken a test about cause and effect (like "Does smoking cause lung cancer?").

The paper discovers a strange phenomenon the authors call "Causal Tongue-Tie." Here is what is happening, broken down into simple parts:

1. The Two Voices: The "Brain" vs. The "Mouth"

Usually, we assume that if a computer's "brain" (its internal math and hidden calculations) knows the answer, its "mouth" (the text it types out) will say the same thing.

This paper found that for these models, the brain and the mouth are telling different stories.

The Brain (Hidden State): When you peek inside the model's math while it's thinking, it has clearly figured out the correct answer based on the evidence provided in the question. It's like the student raising their hand and whispering the right answer to the teacher.
The Mouth (The Output): When the model actually speaks (writes "Yes" or "No"), it ignores its own brain and reverts to what it thinks is common sense, even if the evidence says otherwise. It's like the student whispering the right answer but then loudly shouting the wrong one because they are afraid of being wrong.

2. The "Anti-Commonsense" Test

To prove this, the researchers used a trick. They gave the models questions where the evidence was backwards.

The Scenario: They told the model, "In this story, smoking prevents lung cancer." (In the real world, smoking causes it).
The Result:
- The Model's Mouth: Said "No, smoking doesn't prevent lung cancer." It refused to accept the new rule and stuck to real-world habits.
- The Model's Brain: A special tool (a "probe") looked inside the model's math and found it had perfectly understood the new rule. It knew the answer was "Yes" based on the story provided.

The gap between the brain knowing the truth (97% accuracy) and the mouth saying the wrong thing (50% accuracy) is the "Causal Tongue-Tie."

3. The "Tongue-Tie" Metaphor

Think of it like a person who is tongue-tied.

They know exactly what they want to say.
They have the right words in their head.
But when they try to speak, their tongue gets stuck, and they accidentally say the opposite or something generic.

The paper argues that when a model gets a causal question "wrong," it doesn't always mean the model is stupid or doesn't understand. Sometimes, it means the model understands perfectly but cannot express it through the standard "Yes/No" format.

4. Why "Yes/No" is the Problem

The researchers tried different ways to ask the question to see if they could "untie" the tongue.

Asking "Yes/No": The model fails. It gets stuck on its old habits.
Asking "A or B": When they forced the model to choose between two specific options (e.g., "Does A cause B, or does B cause A?"), the model suddenly got it right almost 100% of the time.

This suggests the problem isn't that the model lacks the knowledge. The problem is the interface. The simple "Yes/No" button acts like a trap that forces the model to default to its training data (common sense) rather than the specific evidence in the prompt.

5. What This Means for "Reasoning"

The paper makes a crucial point about how we judge AI:

If a model gets the answer right: It might just be guessing or following a pattern, not necessarily "reasoning."
If a model gets the answer wrong: It doesn't mean it can't reason. It might be reasoning correctly inside its "brain" but failing to say it out loud.

The Bottom Line:
We can't just look at the final "Yes" or "No" to decide if an AI understands cause and effect. Sometimes, the AI knows the truth but is too "tongue-tied" to say it in the way we expect. The paper suggests we need better ways to listen to what the model is actually thinking, not just what it is saying.

Technical Summary: Causal Tongue-Tie

Problem Statement

The paper addresses a critical mismatch between the internal causal reasoning capabilities of Large Language Models (LLMs) and their explicit textual outputs. While standard benchmarks evaluate causal reasoning based on the accuracy of a model's "Yes/No" answers, this work investigates whether LLMs possess the correct causal direction in their hidden states even when their verbal output fails to express it. Specifically, the authors focus on anti-commonsense causal queries (e.g., prompts stipulating that "smoking prevents lung cancer"), where models often revert to commonsense priors in their output despite evidence in the prompt suggesting otherwise.

The core problem is that a single accuracy metric on output-only benchmarks conflates two distinct failure modes:

Causal Parrots: The model lacks the internal causal signal entirely and relies on surface heuristics.
Causal Tongue-Tie: The model encodes the evidence-supported causal direction internally but fails to verbalize it in the standard output format.

Methodology

The authors propose a measurement protocol that compares two readout channels from the same single forward pass of a frozen, instruction-tuned transformer decoder:

Internal Readout (Probe): A linear probe (frozen logistic regression) or a counterfactual subspace direction ( $V_{cs}$ ) derived from hidden state activations ( $h^{(\ell)}$ ) at the last prompt token.
External Output: The model's own next-token probabilities ( $lm\_head$ ) for the standard "Yes/No" answer.

Experimental Setup

Datasets: The study utilizes CLADDER (Jin et al., 2023) and CounterBench (Chen et al., 2025), focusing on anti-commonsense (anti-CS) items where the prompt's evidence contradicts real-world priors.
Counterfactual Minimal Pairs: For each prompt $x_i$ , a counterfactual pair $x_i^{cf}$ is generated by swapping causal words (e.g., "cause" vs. "prevent") to flip the gold answer while keeping surface form identical. The difference in hidden states ( $\Delta h$ ) defines the causal direction signal.
Models: The protocol is applied across eight instruction-tuned models, including Qwen2.5 (0.5B to 72B), Mistral-7B, and DeepSeek-7B.
Controls: The study employs rigorous controls to rule out surface-word memorization, including:
- Sham Subspaces: Probes trained on nonsense-entity prompts.
- Random Direction Controls: Haar-random vectors of the same rank.
- Causal Word Variation: Removing or altering causal vocabulary while maintaining structure.
- Interface Variations: Testing different answer formats (Yes/No, A/B forced-choice, True/False, Chinese, etc.).

Key Contributions

The paper introduces the concept of Causal Tongue-Tie, defined as the empirical phenomenon where:
$\Delta = Acc_{probe} - Acc_{out} \approx +0.5$
On anti-commonsense items, the linear probe recovers the evidence-supported answer with high accuracy ( $\approx 0.97$ ), while the spoken Yes/No output reverts to the commonsense prior ( $\approx 0.5$ ).

The authors formalize a 2×2 framework for causal benchmark failures:

(a) Aligned Correct: Both probe and output are correct.
(b) Causal Tongue-Tie (This Work): Probe is correct; output is wrong (the paper's focus).
(c) Causal Parrot: Probe finds nothing; output is correct by surface heuristic.
(d) Genuine Failure: Both are wrong.

Empirical Results

Scalability of the Gap: The gap ( $\Delta \approx +0.5$ ) persists across model sizes from 0.5B to 72B parameters. As model size increases, the internal probe accuracy rises (reaching 1.0 on 72B), while the output accuracy remains stagnant near chance (0.35–0.53).
Internal Signal Validity:
- The probe direction is not random; it tracks the causal evidence, not just surface words.
- Lesioning: Projecting the causal direction ( $V_{cs}$ ) out of the hidden state collapses the model's internal ability to distinguish counterfactual pairs (KL drop of -96.3%), confirming the direction is functionally used for internal comparison.
- Activation Patching: Replacing the hidden state of a wrong anti-CS item with that of a matched commonsense item flips the output accuracy from 0 to 0.57, demonstrating that the internal state contains sufficient information to correct the output, though a simple scalar swap of the direction vector is insufficient.
Interface Dependence: The failure is localized to the verbal answer interface.
- When the output format is changed to a structured A/B forced-choice (e.g., "Which is more plausible: A. c causes e, or B. c does not?"), accuracy jumps to near-perfect (1.0), while the standard Yes/No format remains at chance.
- The gap persists across different surface forms (Yes/No, True/False, Chinese "Shi/Fou"), indicating the issue is not specific to the "Yes/No" tokens but rather the commitment step in the verbal interface.
Entropy Analysis: The model exhibits low entropy (high confidence) on the wrong answer in the Yes/No format, indicating a "confident wrong commit" driven by commonsense priors, whereas the A/B format allows the internal signal to express itself with near-zero entropy.

Significance and Claims

The paper claims that sweeping conclusions about whether LLMs can perform causal reasoning based on a single output accuracy number are flawed.

Re-evaluating Benchmarks: A benchmark "wrong" verdict does not necessarily mean the model lacks causal knowledge; it may simply mean the model cannot express that knowledge through the specific verbal interface used. Conversely, a "correct" verdict does not guarantee the model has understood the causal mechanism (it could be a Causal Parrot).
Nature of the Failure: The authors characterize Causal Tongue-Tie as a verbal interface failure, not a lack of internal representation. The model "knows" the answer in its hidden states but is "tied" in its ability to say it when forced to commit to a commonsense-biased verbal format.
Limitations: The authors explicitly state that "encoding" in this context refers to the recoverability of a linear direction in the hidden state, not human-like understanding or a complete causal circuit. The internal direction is causally sufficient for correcting the output in >50% of cases but not all, and the recovered direction is sensitive to template wording.

In summary, the paper argues for a dual-channel evaluation of LLMs (internal state + external output) to distinguish between genuine reasoning failures and expressive limitations, urging caution in interpreting output-only causal benchmarks.