🤖 machine learning

Continuous-Depth Field Theory for Transformer Patching and Mechanistic Interpretability

This paper proposes a continuous-depth field theory framework that models Transformer activation patching as localized source insertions and predicts downstream behavioral changes via Green-function responses, thereby establishing a mathematical language of sensitivities and propagated fields to organize and infer mechanistic interventions.

Original authors: David N. Olivieri, Antonio F. Pérez Rodríguez

Published 2026-05-26

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: David N. Olivieri, Antonio F. Pérez Rodríguez

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 Transformer (the type of AI behind models like GPT-2) not as a stack of computer code, but as a giant, flowing river.

In this river:

Depth is the distance the water has traveled downstream (from the source to the ocean).
Tokens (the words in a sentence) are like different boats floating side-by-side in the river.
The Residual Stream is the water itself, carrying all the information as it flows from one layer of the model to the next.

This paper proposes a new way to understand how we can "tweak" or "patch" these AI models to change their behavior. Instead of just guessing which part of the code to fix, the authors treat the model like a physics field where we can predict exactly how a small change will ripple through the system.

Here is the breakdown of their ideas using everyday analogies:

1. The "Drop in the Pond" (Patching as a Source)

Usually, when researchers want to see what a specific part of the AI is doing, they perform "activation patching." This is like taking a snapshot of the AI's brain at a specific moment, swapping it with a snapshot from a different scenario, and seeing how the output changes.

The authors describe this as dropping a stone into the river.

The Stone: The "patch" (the change you make).
The Ripple: The effect that travels downstream through the rest of the model.
The Theory: They argue that if you know the shape of the river (the model's structure), you can predict exactly how that ripple will spread, how big it will get, and which boats (tokens) it will hit, without having to drop the stone a million times to find out.

2. The "Sensitivity Map" (Predicting the Effect)

To predict where a ripple will go, you need a map. The authors introduce a Sensitivity Field.

Think of this as a weather map showing wind speed. Some spots in the river are very sensitive (a small stone creates a huge wave); others are calm (a stone barely makes a splash).
The paper shows that you can calculate this "wind map" once. Once you have it, you don't need to test every single direction you could throw a stone. You can mathematically predict: "If I throw a stone here, in this direction, the wave will hit the answer with this much force."
The Result: They found that for small changes, this prediction is incredibly accurate. It's like knowing that a gentle breeze will move a feather, but a hurricane will knock over a tree.

3. The "Green Function" (The Ripple Spreader)

The paper uses a concept called a Green Function. In simple terms, this is a "ripple rulebook."

It answers the question: "If I disturb the water at point A, how does the water move at point B?"
The authors found that these ripples don't just go straight down; they spread out sideways to other words (tokens) and travel deeper into the model.
They tested this by measuring how a change at one layer affected layers far downstream. They found that the "ripple rulebook" works well, but only if the change isn't too huge. If you throw a boulder (a massive change), the water gets chaotic and the simple rules break down. But for small nudges, the rules hold up perfectly.

4. The "Reverse Engineering" (Finding the Right Stone)

Usually, researchers try random patches to see what happens. This paper flips the script. They propose an Inverse Problem.

The Goal: "I want the AI to say 'Paris' instead of 'London'."
The Old Way: Try patching every layer and every word until you get lucky.
The New Way: Use the "ripple rulebook" (Green Function) and the "sensitivity map" to mathematically calculate exactly where and how to drop the stone to create that specific wave.
It's like being a sound engineer who knows exactly which knob to turn to fix a specific frequency in a song, rather than turning every knob randomly.

5. The "Translation" Between Models (Scaling)

Finally, the authors suggest a way to transfer knowledge from a small model to a big one.

Imagine you have a small pond (a small AI model) and a massive ocean (a large AI model).
If you drop a stone in the small pond and watch the ripples, you can use that pattern to guess where to drop a stone in the ocean to get a similar result.
They call this a "shared latent response geometry." Essentially, the "physics" of how information flows might be the same in small and big models, just at different scales. This could let us figure out how to fix a giant model by studying a tiny one first.

Summary of Findings

The authors tested these ideas on GPT-2 models and found:

Small changes behave predictably: If you nudge the model gently, the math predicts the outcome almost perfectly.
Ripples spread: Changes don't stay local; they travel through the layers and affect different words in structured ways.
High-sensitivity spots exist: Only a few specific "drops" in the river matter most for the final answer.
Prompt changes are just ripples: Changing the input sentence (e.g., from "Capital of Spain" to "Capital of France") is mathematically similar to dropping a specific stone in the river. The model reacts to this "displacement" in a predictable way, allowing us to steer the answer.

In short: This paper provides a mathematical "physics of AI" that turns trial-and-error patching into a predictable, calculable science. It suggests we can treat AI interventions like engineering problems where we can calculate the exact force and location needed to get a desired result.

Technical Summary: Continuous-Depth Field Theory for Transformer Patching and Mechanistic Interpretability

Problem Statement
Mechanistic interpretability aims to identify the internal circuits responsible for Transformer behavior by intervening on activations (e.g., activation patching, causal tracing, path patching). While these methods successfully localize behaviorally meaningful sites and directions, they often rely on exhaustive enumeration of layers, tokens, and subspaces. This paper addresses the complementary question: Can such interventions be organized, predicted, and reconstructed using a unified field-theoretic framework over depth and token position? The authors propose treating the residual stream not as a discrete sequence of layers but as a continuous field, allowing patching to be formulated as a localized source insertion problem within a linear-response formalism.

Methodology
The paper develops a continuous-depth field theory where the Transformer's residual stream $R(t, x)$ is modeled as a field over a depth-token lattice. Here, layer index $\ell$ is mapped to a depth coordinate $t \in [0, T]$ , and token index is mapped to a spatial coordinate $x$ .

Field-Theoretic Formulation:
- Patching as Source Insertion: An activation patch is modeled as a localized source term $J(t, x)$ added to the depth evolution equation: $\partial_t R(t, x) = F_t[R](x) + J(t, x)$ .
- Response Objects: The framework defines two primary response objects:
  - Sensitivity Field ( $a(t, x)$ ): The functional derivative of an observable $y$ (e.g., logit difference) with respect to the residual field, $a(t, x) = \delta y / \delta R(t, x)$ . This predicts the effect of a patch.
  - Green Function ( $G(t, x; t', x')$ ): The two-point response function $\delta R(t, x) / \delta R(t', x')$ , describing how a perturbation at $(t', x')$ propagates to $(t, x)$ .
- Linear Response: In a local linear regime, the change in an observable is approximated by $\delta y \approx \int dt dx \, a(t, x) J(t, x)$ .
- Inverse Problem (Patch Inference): The framework reframes patch-site inference as a constrained variational problem. Given a desired behavioral shift, one seeks a sparse source $J$ that satisfies the integral equation $\Delta R_{target} \approx \int G J$ . This is solved using an action principle with an adjoint field (costate) $\lambda(t, x)$ , which corresponds to the sensitivity field.
Empirical Validation:
The theory is tested on GPT-2-style autoregressive Transformers using discrete residual-stream interventions. The experiments measure:
- Local Linearity and Superposition: Verifying that small perturbations exhibit linear scaling and that effects of combined interventions sum linearly.
- Sensitivity Prediction: Comparing measured patch effects against predictions derived from first-order sensitivities (autograd gradients).
- Residual Propagation: Measuring the downstream residual field $\delta R$ induced by a localized patch to characterize the "Green response."
- Composition: Testing if propagation through an intermediate layer approximates the product of Green operators ( $G(t_2; t_0) \approx G(t_2; t_1)G(t_1; t_0)$ ).
- Reduced Representations: Analyzing "sliced" Green operators (component-level propagation between fixed sites) and sensitivity site scores to reduce dimensionality.
- Prompt Displacements: Treating the difference between two prompts as a localized source to test if it acts as a transformation direction.

Key Contributions

Field-Theoretic Framework: The paper establishes a formalism where patching is viewed as localized source insertion, attribution as sensitivity-field prediction, and propagation as empirical Green-function response.
Adjoint Inference Formulation: It frames patch-site inference as an inverse problem solvable via an adjoint variational principle, moving beyond simple enumeration to a constrained reconstruction problem.
Empirical Linear-Response Regime: The authors identify a bounded local linear regime in GPT-2 models where first-order sensitivities accurately predict patch effects and superposition holds.
Structured Propagation: Experiments demonstrate that residual perturbations propagate in a structured, anisotropic manner across depth and token position, exhibiting approximate compositional properties consistent with the linearized theory.
Reduced Descriptions: The paper shows that high-sensitivity sites and sliced Green operators provide tractable, low-dimensional descriptions of the otherwise high-dimensional residual response space.
Scaling Hypothesis: A theoretical proposal is made that response geometry (Green-function fingerprints) may be shared across model scales. This suggests that response information from a smaller model could define candidate patch-site maps for a larger model, provided local anchors are used.

Results

Linearity: Local perturbations exhibit a bounded linear regime where nonlinearity and superposition errors remain low (below 20% in tested ranges) for moderate amplitudes.
Prediction Accuracy: Autograd sensitivities ( $a(t, x)$ ) successfully predict measured scalar patch effects across various residual sites and directions, validating the first-order approximation.
Propagation Structure: Localized interventions generate structured downstream response fields that spread anisotropically. The composition test confirms that intermediate residual fields retain sufficient information to reproduce downstream responses within the perturbative regime.
Site Concentration: Sensitivity scores ( $\|a(t, x)\|$ ) are highly non-uniform, concentrating on a small set of layer-token sites, which allows for the reduction of the intervention search space.
Prompt Displacement: Differences between prompts act as local transformation directions. Their effects are predicted by causal sensitivities, are most effective in later layers, and can successfully shift target answer ranks in the vocabulary.

Significance and Claims
The paper claims to provide a "practical language" for organizing patching experiments, shifting the paradigm from enumerating interventions to estimating response quantities (sensitivities and kernels). By establishing the linear-response foundation empirically, the work makes the reconstruction of internal mechanisms mathematically well-posed: the Green function serves as the forward operator for an inverse problem that identifies patch sites and directions.

The authors modestly frame their scaling hypothesis as a motivation for future work rather than a proven result, noting that it relies on a "shared-latent response hypothesis" and requires local anchors (weights, activations, or sparse patches) to be viable. The primary contribution is the unification of mechanistic interpretability tools (patching, tracing, steering) under a single continuous-depth field theory, offering a principled route from measurement to inference and potentially to model-scale transfer.