🤖 machine learning

Structural Sensitivity in Compressed Transformers: Error Propagation, Lyapunov Stability, and Formally Verified Bounds

This paper reveals that transformer compression sensitivity varies by five orders of magnitude across specific matrix types, demonstrating that while Lyapunov stability ensures error contraction, architecture-specific redundancy is equally critical for robustness, a finding validated through extensive empirical testing and formally verified by ten machine-checked Lean 4 theorems.

Original authors: Abhinaba Basu

Published 2026-03-24

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Abhinaba Basu

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 massive, intricate factory (a Large Language Model like GPT-2 or Mistral) that turns raw materials (text) into finished products (intelligent responses). This factory has thousands of workers (mathematical matrices) arranged in assembly lines (layers).

The paper asks a simple but dangerous question: "If we fire some workers or make them work faster by cutting corners, which specific ones can we mess with without the whole factory collapsing?"

Here is the breakdown of their findings, translated into everyday language:

1. The "One Bad Apple" Problem (Structural Sensitivity)

The researchers found that not all workers are created equal. In fact, the difference in importance is massive—like comparing a janitor to the CEO.

The Analogy: Imagine the factory has 468 different teams. If you fire the janitor in the basement, nothing happens. But if you fire the first team that receives the raw materials, the entire factory stops working immediately.
The Finding: They discovered that the first few layers of the factory, specifically the teams that "expand" the data (called MLP up-projections), are incredibly fragile. Compressing just one of these specific teams caused the model's performance to crash by 20,000 times.
The Safe Zone: Conversely, some teams (like the "Value" projections in the attention mechanism) are like overstaffed departments. You can cut their workforce in half, and they barely notice. They are "compressible for free."

The Rule: You cannot treat the factory uniformly. You must protect the "Entry Gate" teams at all costs, while you can aggressively trim the "Middle Management" and "Output" teams.

2. The "Shock Absorber" System (Lyapunov Stability)

You might wonder: "If errors happen in the middle layers, why don't they just pile up until the factory explodes?"

The Analogy: Think of the factory as a series of water slides. If you drop a pebble (an error) at the top, it usually gets washed away. Why? Because the water (the hidden state of the model) is rushing down the slide much faster than the pebble can fall. The speed of the water "dilutes" the pebble.
The Finding: The paper proves mathematically that the "residual connections" (the skip connections that let data jump over layers) act as these shock absorbers. As long as the data stream grows faster than the errors do, the errors get washed away.
The Catch: This "shock absorber" system isn't perfect for every factory design.
- GPT-2 Small: The water flows so fast it swallows every error (Very stable).
- Qwen3-8B: The water flow is a bit wobbly; errors sometimes get amplified, causing a crash.
- LFM2 (Hybrid): Even though the water flow is wobbly, the factory has so many backup generators (redundancy) that it survives anyway.

The Lesson: Having a good shock absorber system is necessary, but it's not enough. You also need a factory design that has built-in backups.

3. The "Mathematical Safety Net" (Formal Verification)

Usually, when engineers compress models, they just guess and check. "Does it still work? Okay, good."

The Analogy: This is like building a bridge and hoping it doesn't fall down.
The Innovation: This paper used a "Mathematical Safety Net" (formal verification using Lean 4). They didn't just guess; they wrote a computer program that proved with 100% certainty that their error estimates were correct.
The Result: They tested over 14,000 different scenarios. The "Safety Net" held up every single time. They proved that their mathematical formulas for "how much error we introduced" were always conservative (safe) and never lied.

4. The "Smart Budget" Strategy

So, how do we compress these models effectively?

The Old Way: "Let's cut 50% of the workers from every team equally." -> Result: Disaster.
The New Way (The Paper's Strategy): "Let's look at the map of sensitivity."
1. Protect the Entry Gate: Do not touch the first few layers.
2. Trim the Fat: Cut heavily in the middle and end layers where the "shock absorbers" work well.
3. Use the Map: They created a "Sensitivity Map" that tells you exactly which specific teams to fire and which to keep.

Summary in One Sentence

This paper proves that AI models are like fragile castles where the foundation is made of glass (very sensitive) but the walls are made of foam (very compressible), and they provide a mathematically guaranteed map to tell you exactly where you can safely take a sledgehammer without bringing the whole thing down.

1. Problem Statement

Large Language Models (LLMs) are increasingly bottlenecked by memory bandwidth rather than compute, driving the need for model compression (pruning, quantization, low-rank factorization). However, current compression methods rely heavily on empirical heuristics and lack a fundamental understanding of how compression errors propagate through transformer layers.

The Gap: Practitioners do not know which components are safe to compress and which are catastrophic. There is a lack of formal guarantees on output quality, and the structural reasons why certain components (e.g., early-layer MLPs) are hypersensitive while others (e.g., value projections) are robust remain unexplained.
The Core Question: How do compression errors propagate through transformer layers, and what structural properties govern this propagation?

2. Methodology

The authors propose a framework called "Living Inference," which combines structural sensitivity mapping, dynamical systems theory, and formal verification.

A. Structural Sensitivity Mapping

The authors perform granular ablation studies across five architectures (GPT-2 Small/Medium, LFM2-2.6B, Mistral-7B, Qwen3-8B).

Granularity: They compress individual weight matrices (468 matrices in GPT-2 Small) rather than whole layers.
Metrics: They measure "Regret" (additive perplexity increase) and "Degradation Factor" (multiplicative perplexity increase).
Compression Techniques: They apply three composable approximation stages:
1. Semantic Caching: Reusing cached outputs for similar inputs.
2. Sparse Activation: Pruning weights based on magnitude (top-k%).
3. Low-Rank Approximation: Truncating Singular Value Decomposition (SVD) to rank $r$ .

B. Lyapunov Stability Analysis

To explain why errors do not accumulate catastrophically over 12+ layers, the authors apply Lyapunov stability theory from dynamical systems.

Definition: They define relative error energy $V(t) = \|e_t\|^2 / \|h_t\|^2$ , where $e_t$ is the error and $h_t$ is the hidden state.
Mechanism: They prove that residual connections (not LayerNorm alone) are responsible for error contraction. Contraction occurs when the hidden state grows faster than the error ( $\alpha > \beta$ ), causing the relative error to shrink ( $\rho < 1$ ).
Bound: This yields a geometric series bound for error accumulation, which is significantly tighter ( $23\times$ ) than naive linear bounds.

C. Formal Verification (Lean 4)

The authors formalize the error bounds for the three approximation stages and their composition using Lean 4.

Theorems: Ten machine-checked theorems define per-matrix error bounds (e.g., $\|Wx - \hat{W}x\| \leq \|W_{residual}\| \cdot \|x\|$ ).
Verification: These proofs contain no sorry markers and are verified against 14,040+ configurations, ensuring the bounds hold in IEEE 754 arithmetic.

3. Key Contributions

Structural Sensitivity Hierarchy:
- Discovered a consistent hierarchy of sensitivity spanning five orders of magnitude:
  $mlp\_fc \gg Q > K > mlp\_proj > attn\_proj > V$
- The "Catastrophe": Compressing the MLP up-projection in Layer 0 alone (1 out of 468 matrices in GPT-2 Small) increases perplexity by 20,000×.
- The "Cliff": There is a sharp phase transition between Layer 2 and Layer 3; early layers are catastrophically sensitive, while mid-to-late layers are relatively robust.
- Free Compression: Value projections ( $V$ ) can be compressed nearly "for free" with negligible impact.
Lyapunov Stability of Error Propagation:
- Demonstrated that residual connections contract errors by growing the hidden state faster than the error accumulates.
- Identified that LayerNorm alone is insufficient; the interplay between sub-layer gain and residual alignment determines stability.
- Showed that GPT-2 Small is fully contracting ( $\rho_{max} = 0.96$ ), while GPT-2 Medium has an amplifying final layer ( $\rho_{max} = 2.05$ ).
Cross-Architecture Validation & The "Fragility Index":
- Validated findings across models from 117M to 8B parameters.
- Stability is Necessary but Not Sufficient:
  - Qwen3-8B ( $\rho_{max}=1.33$ ) collapses at 42,922× degradation.
  - Mistral-7B ( $\rho_{max}=1.14$ ) degrades only 11×.
  - GPT-2 Small (fully contracting, $\rho_{max}=0.96$ ) degrades 120×.
  - LFM2-2.6B (hybrid, $\rho_{max}=1.12$ ) degrades only 7×.
- Conclusion: Compression robustness depends on both Lyapunov stability (error amplification) and architecture-specific redundancy (e.g., hybrid conv-attention designs or wider dimensions).
- Proposed a Compression Fragility Index (CFI) combining instability terms and width penalties to predict robustness.
Formally Verified Bounds:
- Provided the first machine-checked error bounds for transformer inference approximation.
- Verified zero violations across 14,040+ configurations, confirming that linear per-matrix bounds are conservative even when composed through the full nonlinear forward pass.

4. Key Results

Sensitivity Landscape: The sensitivity hierarchy is invariant across compression levels (5% to 99% sparsity), evaluation scales (2K to 51K tokens), and datasets (WikiText-103, C4).
Early-Layer Catastrophe: The Layer 0 MLP up-projection is the most critical component. Its sensitivity is due to low output covariance rank, heavy-tailed activations, and low GELU sparsity. It acts as an "irreducible feature-creation bottleneck."
Greedy Allocation: A greedy strategy that compresses the least sensitive components first (starting with $V$ projections and later layers) achieves 24% FLOPS savings with only a 27% perplexity increase. Uniform compression fails catastrophically (168× baseline perplexity).
Downstream Impact: Perplexity degradation correlates with task accuracy loss. For Mistral-7B, uniform 50% pruning drops HellaSwag accuracy from 81.1% to 43.9%. Sensitivity-guided pruning mitigates this loss.

5. Significance and Implications

Principled Compression: The paper moves compression from empirical trial-and-error to a principled, structural approach. It identifies exactly which matrices to protect (early MLPs) and which to compress aggressively (Value projections).
Theoretical Insight: It reveals that transformer representations concentrate information density at the embedding-to-hidden-space transition (Layer 0), making this stage non-redundant.
Formal Guarantees: The integration of Lean 4 verification provides a new standard for safety in model compression, offering provable error bounds that are currently absent in methods like SparseGPT or Wanda.
Architectural Design: The findings suggest that future model architectures should consider "compression robustness" as a design metric, potentially favoring hybrid designs (like LFM2) or wider dimensions that offer structural redundancy against weight perturbations.

In summary, this work provides a rigorous mathematical and empirical framework for understanding transformer compression, proving that structural sensitivity is a dominant factor in model robustness, and offering formal tools to optimize compression without catastrophic failure.