Technical Summary: How Causal Abstraction Underpins Computational Explanation

1. Problem Statement

The paper addresses the fundamental problem of computational implementation: what conditions must a physical system (such as a brain or a neural network) satisfy to be said to "implement" a specific computational model over internal representations?

While cognitive science often posits that intelligent behavior arises from computations over internal representations, the criteria for a physical system to instantiate such a computation remain contentious. Early attempts to define implementation via simple state-mapping led to "triviality arguments" (e.g., Putnam, Searle), suggesting that almost any physical system could implement any computation under loose constraints. Stricter proposals, such as Chalmers' Combinatorial State Automata (CSA), require an isomorphism between the physical system's causal structure and the computational model. However, these accounts often struggle to accommodate the complexity of modern systems like deep neural networks, where information is distributed and representations are not immediately transparent. The authors argue that existing frameworks lack the precision to handle the relationship between low-level physical dynamics and high-level algorithmic descriptions, particularly regarding the role of representation and generalization.

2. Methodology

The authors employ a framework grounded in interventionist causal modeling and causal abstraction theory.

• Causal Models as the Basis: The authors treat both the physical system ($L$) and the computational model ($H$) as causal models. A causal model $M$ is defined as a pair $\langle V, F \rangle$, where $V$ is a set of variables and $F$ is a set of functional mechanisms determining variable values based on parent variables.
• Interventionist Framework: Following Woodward (2003), causality is understood through interventions. The authors define interventionals as operations on models (e.g., hard interventions that fix variables to specific values or replace mechanisms). A set of interventionals forms an intervention algebra if they satisfy modularity properties (e.g., interventions can be performed in any order without affecting outcomes).
• Exact Transformation: The core technical tool is the concept of an exact transformation, a pair of maps $(\tau, \omega)$ where $\tau$ maps low-level variable values to high-level values, and $\omega$ maps low-level interventionals to high-level interventionals. An exact transformation holds if the result of intervening on the low-level system and translating the outcome is identical to translating the low-level state and intervening on the high-level model: $\tau(\text{Run}(L_i)) = \text{Run}(H_{\omega(i)})$.
• Abstraction Types:
  • Constructive Abstraction: A model obtained by partitioning low-level variables into sets and mapping them to high-level variables, ignoring certain low-level distinctions while preserving causal consistency.
  • Translation: A bijective re-carving of the variable space (e.g., rotating a vector space) that preserves causal structure but changes the variable definitions.
  • Abstraction-Under-Translation: The authors propose that a system $L$ implements a computation $H$ if $H$ is a constructive abstraction of a translation of $L$. This allows for the low-level system to be re-interpreted (translated) before being abstracted to the high-level algorithm.

3. Key Contributions

A. A Formal Account of Implementation

The paper proposes Implementation as Abstraction-Under-Translation. This framework posits that for a system to implement a computation, the computational model must be a constructive abstraction of a translation of the system's causal model. This formulation:

• Generalizes previous isomorphism-based accounts (like Chalmers' CSA) by allowing for non-trivial re-mappings (translations) of the low-level variables.
• Provides a rigorous mathematical definition of "mirroring causal structure" that accommodates the distributed, overlapping encodings found in neural networks.

B. Integration of Representation and Causality

The authors argue that representational content in computational explanations is tied to the causal role of variables within the abstracted model.

• They apply standard criteria for representation (Information, Use, Misrepresentation) to the variables in the high-level causal model.
• They demonstrate that under abstraction-under-translation, the "vehicles" of representation in the low-level system may not be individual neurons or simple clusters, but rather complex sets of points in state space or specific interventional operations (e.g., specific function replacements) that induce the high-level state.
• This reframes representation as a property of the mapping between the system and the algorithm, rather than an intrinsic property of the physical substrate alone.

C. Addressing Triviality and Generalization

The paper engages with recent "triviality" results (e.g., Sutter et al., 2025) which suggest that, without constraints on the class of allowed translations ($C$), any neural network can implement any algorithm.

• The authors acknowledge that if the class of translations $C$ is unconstrained, triviality holds.
• However, they argue that the explanatory value of a computational claim depends on its ability to support generalization and prediction.
• They contend that while a "gerrymandered" translation might technically satisfy the definition of implementation, it fails to be a good explanation if it cannot predict behavior on out-of-distribution inputs or new task variations.
• Therefore, the choice of admissible translations ($C$) should be constrained by the goal of explaining the agent's competence (generalization) rather than just fitting a specific input-output mapping.

4. Results and Illustrations

The paper illustrates these concepts through several examples:

• The XNOR Circuit: A simple logic circuit (high-level) is shown to be a constructive abstraction of a small feedforward neural network (low-level).
• Translation Necessity: The authors show that for many neural networks, a direct constructive abstraction is impossible due to distributed representations. However, applying a linear translation (e.g., rotating the vector space of hidden units) reveals the underlying causal structure, allowing the high-level algorithm to be recovered. This supports the hypothesis in mechanistic interpretability that linear readouts often suffice to identify causal variables.
• Hierarchical Equality Task: The paper discusses the task of determining if two pairs of objects share the same relation (e.g., "same" vs. "different"). They show that while neural networks can solve this, identifying the implementation of the symbolic algorithm requires allowing for translation before abstraction.
• Misrepresentation: The framework allows for the analysis of misrepresentation. If a low-level system approximates a high-level model but fails on specific inputs, the system can be said to misrepresent the input relative to the idealized algorithm, provided the abstraction is deemed "apt" for explaining the system's generalization behavior.

5. Significance and Claims

The authors claim that their framework provides a fruitful lens for understanding computational explanation in both cognitive science and machine learning.

• Clarification of Implementation: The paper argues that "implementation" is not a binary, absolute fact but a relationship that depends on the chosen class of translations and the explanatory goals. It bridges the gap between the "isomorphism" requirements of classical philosophy of mind and the distributed, linear-structure findings of modern deep learning interpretability.
• Role of Generalization: A central claim is that the validity of a computational explanation is inextricably linked to generalization. A claim of implementation is most "profitable" when it allows us to predict how an agent will behave on novel tasks or under new conditions. If a mapping from system to algorithm is too complex or "gerrymandered" to support such predictions, it may technically satisfy a minimal definition of implementation but fails as a deep explanation.
• Representation as Causal Role: The paper suggests that representational content is best understood through the causal role a variable plays in a high-level abstraction. However, this role is only meaningful if the abstraction captures the system's capacity to generalize, not just its performance on a fixed dataset.

The authors conclude that while causal abstraction provides a rigorous foundation for defining implementation, the selection of which abstractions are explanatory requires further constraints, likely tied to the specific learning mechanisms and generalization capabilities of the systems under investigation (biological or artificial). They do not claim to have solved the problem of representation entirely but offer a precise causal framework within which these debates can be productively continued.