💻 computer science

Pattern Selectivity is Not Task-Causal Structure: A Cross-Architecture Mechanistic Study of Composed-Task Circuits in 1B-Class Language Models

This cross-architecture mechanistic study demonstrates that a unified "screen-and-ablate" protocol for identifying task circuits yields inconsistent causal claims across different 1B-class language models, revealing that identical behavioral capabilities are implemented through distinct attention-pattern structures and proposing that MoE models specifically rely on a foundational previous-token positional substrate for composed tasks.

Original authors: Yongzhong Xu

Published 2026-06-05

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Yongzhong Xu

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 you have three different chefs (AI models) who have all learned to cook the exact same dish: a complex recipe called "Indirect Object Identification" (IOI). You want to know how they are cooking it. Do they use the same tools? Do they follow the same steps?

This paper is like a food critic who goes into three different kitchens to find out. The critic uses a standard testing method: they identify a specific tool (like a whisk or a knife), remove it, and see if the dish falls apart.

Here is what the paper found, explained simply:

1. The Same Dish, Different Recipes

The big surprise is that all three chefs make the dish perfectly, but they use completely different tools to do it.

Chef A (Pythia): Uses a "Previous Token" tool. This is like a chef who looks at the ingredient they just picked up to decide what to do next.
Chef B (OLMo): Uses an "S-Inhibition" tool. This is like a chef who specifically suppresses the main ingredient so the side dish can shine.
Chef C (OLMoE): Uses a "Name-Mover" tool. This is like a chef who physically grabs the name of the side dish and moves it to the front of the plate.

The Lesson: Just because two models solve a problem the same way (getting the right answer), it doesn't mean they are using the same internal "circuit" or mechanism. You cannot assume that what works for one AI will work for another.

2. The "Fishing Expedition" Problem

The researchers were worried that if they tried enough different tools, they might just get lucky and find one that seems to work by accident. To prove they weren't just fishing, they used a "Matched Random" control.

Think of it like this: If you remove the chef's actual whisk and the cake collapses, that's good. But if you remove a random spoon from the drawer and the cake also collapses, then the whisk wasn't special; the whole kitchen was just fragile.

The paper shows that for most tasks, removing the specific tool the researchers found caused a massive collapse, while removing random tools did nothing. This proves they found the real "secret sauce" for each specific model.

3. The Five Types of "Tools"

The paper created a new way to categorize what happens when you remove a tool. It's not just "it works" or "it doesn't." They found five distinct outcomes:

The Primary Cause: The main engine. If you remove it, the car stops. (e.g., The "Previous Token" tool in Chef A).
The Secondary Cause: A backup engine. The car still runs if you remove it, but it sputters.
The Correlate: A shiny decoration. It looks like it belongs in the engine room, but if you remove it, the car runs fine. It was just along for the ride.
The Interferer: A saboteur. If you remove this tool, the car actually runs better. In one case, the researchers found tools that were actually hurting the AI's performance, and removing them fixed the problem.
The Null: A tool that does nothing. Removing it changes nothing.

4. The "MoE" Mystery (The Special Case)

One of the chefs (OLMoE) is a "Mixture of Experts" (MoE). Imagine this chef has a team of 64 specialists, but only 8 are allowed to cook at any one time.

The researchers found a strange pattern with this chef:

For three out of four different recipes, this chef relied heavily on the "Previous Token" tool as the foundation. It was like the chef's entire kitchen was built on a conveyor belt that just passed the last item forward.
However, for the "Indirect Object" recipe, this chef switched to the "Name-Mover" tool.

The Hypothesis: The paper suggests that for this specific type of AI (MoE), the "Previous Token" tool is the default "skeleton" or "backbone" that holds everything together. The AI builds complex tasks on top of this simple backbone, unless the task specifically requires a different kind of attention (like copying a name at the very end).

5. Why "Top-1" Accuracy Isn't Enough

The paper also warns that just looking at whether the AI got the "right answer" (Top-1 accuracy) can be misleading.

Sometimes, removing a tool doesn't change the final answer, but it makes the AI less confident. It's like a student who still gets the math problem right, but their handwriting gets shaky and they hesitate longer. If you only check the answer, you miss the fact that the student is struggling. The researchers found that for some models, the "margin" (how much better the right answer is than the wrong one) shrinks even if the answer stays the same.

Summary

The Recipe Works, The Tools Don't: You can't copy-paste the "mechanism" of one AI to another. They solve the same problems with different internal gears.
Be Careful of "Saboteurs": Sometimes, the parts you think are helping are actually hurting the AI.
MoE Models are Unique: Models with "experts" (MoE) seem to rely on a specific "Previous Token" backbone for most tasks, which is a new discovery.
Look Deeper: Don't just check if the AI is right; check how confident it is, because the "confidence" might be where the real story is.

The paper concludes that while we have a great method for finding these "circuits" (the recipe), we cannot assume the circuits are the same across different models. Every model is a unique machine with its own internal logic.

Technical Summary: Pattern Selectivity is Not Task-Causal Structure

Problem Statement
This paper investigates whether the established "screen-and-ablate" recipe for mechanistic interpretability—identifying attention-head circuits via task-pattern selectivity followed by causal ablation—yields consistent mechanistic claims across different model families. While prior work (e.g., Wang et al., 2023) established canonical circuits for tasks like Indirect Object Identification (IOI) in GPT-2 small, it remains unknown if these specific circuits generalize to other 1B-class language models trained on different corpora with different architectures. The core question is whether a single task-pattern screen identifies the same causal circuit across models, or if the mechanistic implementation of composed tasks is model-specific.

Methodology
The authors apply a unified screen-and-ablate protocol across a $4 \times 3$ empirical grid:

Tasks: Four composed tasks: Indirect Object Identification (IOI), Greater-Than, Successor Sequences, and Variable Binding.
Models: Three 1B-class models from distinct pipelines:
- Pythia 1B: Dense architecture, trained on The Pile.
- OLMo 1B: Dense architecture, trained on DCLM.
- OLMoE 1B-7B: Mixture-of-Experts (MoE) architecture (64 experts, top-8), trained on DCLM.
Procedure:
1. Spectral Signal: Heads are pre-screened using a participation-ratio (PR) integral to identify specialized computation.
2. Task-Pattern Screen: Candidate heads are filtered based on selectivity for specific attention patterns (e.g., prev-token, induction, name-mover, S-Inhibition).
3. Causal Verification: Group ablation of the candidate circuit is performed (replacing head outputs with batch-mean activation).
4. Control: A matched-random null is generated for every cell using 10 independent seeds, sampling random heads from the same layers with equal count and no overlap with the picks.
Metrics: Performance is measured via $\Delta$ top-1 accuracy and $\Delta$ logit-diff (difference between correct and distractor logits).

Key Contributions

Empirical Grid: A comprehensive analysis of 12 (task, model) cells at the 1B-class frontier, demonstrating that while the methodology ports, the specific causal circuits do not.
Five-Category Taxonomy: A quantitative framework for classifying screen outcomes:
- Primary Cause: Largest non-saturated effect with high specificity ( $\ge 3\times$ over matched-random).
- Secondary Cause: Meaningful effect but smaller than the primary screen; often a redundant pathway.
- Correlate: Heads show the expected pattern but ablation has little to no causal impact (answer already encoded upstream).
- Interferer: Ablation improves task performance; often caused by BOS-class (first-token) attention sinks competing with the task.
- Null: No causal role; effect size indistinguishable from random noise.
OLMoE Prev-Token-Primacy Hypothesis: A falsifiable claim that MoE models at the 1B-active scale build composed-task circuits on top of a foundational prev-token positional substrate. Task-specific computation is layered on this substrate, except when the task structure directly probes a different pattern (e.g., IOI's final-position name-copying).
Methodological Refinements:
- Demonstration that matched-random controls are essential to distinguish true causality from fishing expeditions, particularly revealing that L0-concentrated screens have high-variance nulls.
- Identification of the margin-not-argmax signature: In some models, ablation compresses the logit margin (reducing confidence) without changing the top-1 prediction, suggesting capabilities are implemented as distributional biases rather than gating decisions.

Key Results

No Cross-Architecture Circuit Transfer: No two cells in the $4 \times 3$ $4 \times 3$ grid share the same primary causal screen at a comparable effect size.
- IOI: Pythia is prev-token primary; OLMo is S-Inhibition primary; OLMoE is name-mover primary.
- Greater-Than: Pythia is GT-specific primary; OLMo shows a margin-only effect; OLMoE is prev-token primary.
- Successor: Pythia is mixed; OLMo is L0-concentrated (unreliable null); OLMoE is prev-token primary.
- Variable Binding: Pythia's naive screen identifies interferers (BOS-confounds); OLMo and OLMoE are prev-token primary.
The OLMoE Pattern: In OLMoE, the prev-token circuit is the primary causal driver for Greater-Than, Successor, and Variable Binding. The exception is IOI, where the task structure (final-position name copying) directly engages the name-mover circuit.
BOS-Class Confounds: In Pythia's Variable Binding task, the top screen candidates were BOS-class heads that acted as interferers. Individual head ablations were required to distinguish these from true supporters, a diagnostic that generalizes across BOS-dominated regimes.
Metric Sensitivity: Relying solely on top-1 accuracy misses significant mechanistic effects. For example, in OLMo's Greater-Than task, ablating the GT-specific screen compressed the logit margin significantly ( $\Delta$ -1.98) while top-1 dropped minimally ( $\Delta$ -0.6).

Significance and Claims
The paper argues that the question "What is the circuit for capability X?" is malformed for the 1B-class frontier, as it presupposes a single, transferable solution. Instead, the authors propose that:

Mechanistic Decoupling: Different models achieve the same behavioral capability through entirely different mechanistic implementations. The "recipe" (screen-and-ablate) is a valid generative procedure, but the specific circuit must be re-derived for each model.
Model-Class Regularities: While specific circuits differ, structural patterns may persist within architecture families. The OLMoE prev-token-primacy hypothesis suggests that MoE architectures rely on a stable positional substrate for routing, upon which task-specific logic is built.
Methodological Honesty: The paper emphasizes that spectral signals alone are insufficient; task-pattern screens and causal verification (specifically individual head ablations in BOS-dominated regimes) are required to distinguish supporters from correlates and interferers.

The authors frame these findings as a starting point for a broader empirical program, noting that the OLMoE hypothesis requires validation on other MoE models (e.g., Mixtral, DBRX) and that the 12-cell grid is sufficient to motivate but not fully establish cross-task generalization.