💬 NLP

When Self-Reference Fails to Close: Matrix-Level Dynamics in Large Language Models

This paper demonstrates that while grounded self-reference remains stable in large language models, prompts inducing non-closing truth recursion (NCTR) trigger significant internal matrix-level disruptions—such as elevated attention effective rank and variance kurtosis—across multiple architectures and layers, leading to increased output contradictions and suggesting a link to classical matrix-semigroup instability problems.

Original authors: Ji Ho Bae

Published 2026-04-15

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Ji Ho Bae

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

The Big Idea: When a Brain Gets Stuck in a Loop

Imagine you ask a very smart robot, "Is this sentence false?"
If the sentence is true, it must be false. If it's false, it must be true. This is a classic logic trap called the Liar Paradox.

For a human, this is just a fun brain teaser. But for a Large Language Model (LLM)—a giant AI that thinks in layers of math—this question causes a specific kind of internal chaos.

This paper investigates what happens inside the robot's brain when it tries to solve these impossible puzzles. The researchers discovered that the robot doesn't just get "confused"; its internal math breaks down in a very specific, measurable way.

The Core Discovery: It's Not About "Self," It's About "Stuck"

The team tested four different AI models (like Qwen, Llama, and Gemma) with hundreds of different prompts. They found a surprising truth:

Self-reference itself isn't the problem.

Stable Self-Reference: If you ask the AI, "This sentence has five words," the AI handles it fine. It's a fact. The math inside the brain stays calm.
The Real Villain (NCTR): The trouble starts with Non-Closing Truth Recursion (NCTR). This is a fancy term for a sentence that creates a loop with no exit.
- Example: "This statement is false."
- Example: "Sentence A says B is false. Sentence B says A is true."

When the AI tries to process these "stuck" loops, its internal machinery goes haywire.

The Analogy: The Elevator That Won't Stop

Think of the AI's brain as a 100-story building. Information enters at the bottom (Layer 1) and travels up to the top (Layer 100) to produce an answer.

Normal Questions: The elevator goes up smoothly, stopping at each floor to process the data, and arrives at the top with a clear answer.
Stable Self-Reference: The elevator goes up, maybe does a little spin on a floor to check a fact, but keeps moving up.
The Paradox (NCTR): The elevator hits a floor where the button for "Up" is broken and the button for "Down" is broken. The elevator starts shaking, vibrating, and spinning in place. It can't decide which way to go.

The researchers found that when the AI faces a paradox, the "elevator" (the data) doesn't just stop; it spreads out everywhere. Instead of focusing on one clear path, the attention mechanism (the part of the brain that decides what to focus on) gets scattered across the whole building.

The "Matrix" Evidence: What They Measured

The researchers didn't just look at the AI's final answer; they looked at the math happening inside every single layer. They measured 106 different things, like:

Attention Rank: How focused is the AI? (Paradoxes make it scatter like a dropped deck of cards).
Oscillations: Is the AI flipping back and forth between "True" and "False" like a light switch?
Variance: Is the math getting wild and unpredictable?

The Result:
When the AI faced a paradox, its internal math became 3 to 4 times more chaotic than when it faced normal questions. They could even build a "lie detector" (a classifier) that could tell if the AI was processing a paradox just by looking at these math numbers, with 81% to 90% accuracy.

Why Does This Matter?

It's Not Just "Hallucination": The paper shows that when AI gives contradictory answers (saying "Yes" and "No" in the same breath), it's often because it hit a "non-closing loop" in its math. The system literally cannot find a stable place to land.
The "Undecidable" Connection: The authors connect this to a deep branch of math called Matrix Semigroup Theory. In simple terms, there are certain math problems that are proven to be impossible to solve in a finite number of steps. The AI, being a machine with a fixed number of layers, hits a wall when it tries to solve these "impossible" loops. It's like trying to count to infinity in a finite amount of time.
Architecture Matters: Interestingly, different AI models react differently. Some models "explode" (get very chaotic), while others "freeze" (get very rigid). But they all show signs of stress when faced with these loops.

The Takeaway

The paper concludes that AI doesn't fail because it's "self-aware" or "thinking about itself." It fails because it hits a logical wall where the answer requires an infinite loop to resolve, and the AI's brain (which has a limited depth) cannot close the loop.

In short: If you ask an AI a riddle with no answer, its internal math starts to spin out of control, scattering its focus and leading to contradictory, messy outputs. The AI isn't "lying"; it's just stuck in an elevator that won't stop shaking.

1. Problem Statement

The paper investigates the internal computational dynamics of Large Language Models (LLMs) when processing self-referential inputs, specifically focusing on the "Liar Paradox" and similar logical contradictions.

The Core Question: What happens inside the transformer's linear algebra when a model encounters a statement like "This statement is false," which has no consistent truth value and requires infinite recursion to resolve?
The Gap: Previous research focused on vocabulary, feature activation, or behavioral outputs. This paper argues that self-reference per se is not the primary cause of instability. Instead, the critical factor is whether the prompt induces a Non-Closing Truth Recursion (NCTR)—a truth-value computation that admits no finite-depth resolution within the model's fixed layer count.

2. Methodology

Experimental Setup

Models: Four instruction-tuned models across three architecture families:
- Qwen3-VL-8B (8B params, GQA + QK-norm)
- Llama-3.2-11B (11B params, standard GQA)
- Llama-3.3-70B (70B params, standard GQA)
- Gemma-2-9B (9B params, interleaved local/global attention)
Dataset: 300 prompts organized into a 14-level hierarchy based on Tarski's stratification of truth predicates.
- Clusters: Prompts were grouped into four analytical clusters:
  - C1: Stable non-self-reference (controls).
  - C2: Stable self-reference (grounded statements, e.g., "This sentence has 5 words").
  - C3: Closable hard reasoning (complex logic with a solution).
  - C4: Non-Closing Truth Recursion (NCTR) (paradoxes, Gödelian undecidables, mutual-cyclic references, infinite regress).
Conditions: Evaluated at three temperatures ( $T \in \{0.0, 0.3, 0.7\}$ ).
Metrics: A comprehensive suite of 106 scalar metrics extracted per prompt across all layers, including:
- Attention eigenspectra (effective rank, entropy).
- Singular-value trajectories (SVD of attention/MLP outputs).
- Truth-delta layer profiles (projection onto "True"/"False" unembedding vectors).
- Mortality contraction ratios and autoregressive probes.
- Metrics inspired by matrix-semigroup theory (Skolem problem, Joint Spectral Radius).

Theoretical Framework

The authors propose a Conjectural Framework linking transformer dynamics to Matrix Semigroup Theory.

Computational Semigroup: The transformer is modeled as an input-dependent sequence of transformation matrices ( $J_l(x)$ ).
The NCTR Hypothesis: NCTR prompts force the model's computational semigroup toward dynamical boundaries where classical undecidable problems concentrate (e.g., Matrix Mortality, Skolem Problem, Joint Spectral Radius).
Mechanism: Unlike grounded self-reference (which converges), NCTR prompts prevent the residual stream from contracting to a low-dimensional attractor, resulting in persistent high-rank, oscillatory dynamics near the critical spectral radius ( $\rho \approx 1$ ).

3. Key Contributions

The NCTR Hypothesis: Distinguishes between "stable" self-reference and "non-closing" recursion, identifying the latter as the true source of matrix-level instability.
Theory-Driven Metric Suite: Introduced 106 metrics derived from formal undecidability problems (Mortality, Skolem, JSR) rather than post-hoc selection.
Falsifiable Conjecture: Proposed a link between transformer failure modes on paradoxes and the dynamical boundaries of matrix semigroups.
Minimal-Pair Ablation: Demonstrated that changing a single word (e.g., "This sentence" $\to$ "That sentence") significantly alters internal dynamics, isolating the self-referential mechanism.
Cross-Architecture Validation: Validated findings across four models and three distinct architectural families.

4. Key Results

Matrix-Level Instability

Attention Effective Rank: NCTR prompts (C4) cause a massive, anomalous elevation in attention effective rank compared to stable self-reference (C2) and controls (C1).
- Effect Sizes (Cohen's $d$ ): Ranging from 2.93 (Qwen) to 4.20 (Gemma 9B) and 3.02 (Llama 70B).
- Interpretation: This indicates global dispersion of attention rather than simple concentration collapse. The model fails to compress information into a stable attractor.
Per-Layer Analysis: The disruption occurs at every sampled layer (not just an aggregation artifact).
- In Llama 70B, $d > +1.67$ across all 80 layers.
- The effect peaks in middle layers (e.g., Layer 28 in Gemma), suggesting an information bottleneck where closure failure is most fully expressed.
Stability of Grounded Self-Reference: C2 prompts (grounded self-reference) are markedly more stable than C4, often as stable as factual controls. This refutes the idea that self-reference in general destabilizes models.

Statistical Significance

Differentiation: 281 out of 397 metric-model combinations significantly differentiate NCTR (C4) from stable self-reference (C2) after FDR correction ( $q < 0.05$ ).
Large Effects: 198 of these combinations show large effect sizes ( $|d| > 0.8$ ).
Classification: A logistic classifier using only matrix-level metrics achieves 5-fold cross-validated AUC of 0.81–0.90 in distinguishing NCTR from all other prompt types.

Behavioral Correlates

Contradictory Outputs: NCTR prompts produce significantly higher rates of contradictory output (containing both affirmative and negative markers) compared to controls.
- Increase: +34 to +56 percentage points (e.g., Gemma 9B: 58.8% vs. 2.5% for controls).
Correlation: There is a significant positive correlation ( $\rho \approx 0.34–0.44$ ) between attention effective rank disruption and contradictory output rates.

Minimal-Pair Ablation

Changing "This sentence is false" to "That sentence is false" resulted in 42 significant metric-model combinations across all four models, confirming that the instability is triggered specifically by the self-referential binding, not just the semantic content of the paradox.

5. Significance and Implications

Mechanistic Understanding: The paper moves beyond behavioral observation to provide a linear algebraic explanation for why LLMs fail on paradoxes. It suggests that the failure is not a lack of "reasoning" capability but a fundamental dynamical constraint of finite-depth transformers attempting to resolve infinite recursion.
Architecture Invariance vs. Sensitivity: While the core signature (elevated attention rank) is invariant across architectures, the specific manifestation (e.g., variance kurtosis direction) depends on architectural features like QK-normalization and attention mechanisms (local vs. global).
Theoretical Bridge: It connects empirical LLM behavior to formal undecidability (Matrix Semigroups), suggesting that NCTR prompts push models into dynamical regimes where mathematical decidability breaks down.
Practical Relevance: Understanding these "failure modes" is crucial for developing models that can reason reliably about themselves, potentially mitigating hallucinations and logical inconsistencies in high-stakes applications.

Conclusion

The paper concludes that self-reference is not inherently destabilizing. Instability arises specifically from Non-Closing Truth Recursion (NCTR), which forces the transformer's internal matrix dynamics into a high-rank, oscillatory, near-critical state that prevents convergence. This provides a principled, mathematically grounded explanation for the "Liar Paradox" failure mode in LLMs.