🤖 machine learning

Unsupervised Causal Abstractions Discovery

This paper addresses the challenge of unsupervised causal abstraction discovery by demonstrating that low-rank causal graphs induce identifiable high-level latent variables and proposing a practical objective to learn these high-level structural causal models directly from low-level measurements.

Original authors: Théo Saulus, Simon Lacoste-Julien, Dhanya Sridhar

Published 2026-06-19

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Théo Saulus, Simon Lacoste-Julien, Dhanya Sridhar

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 are trying to understand how a massive, complex orchestra plays a symphony. You have a recording of every single instrument (the "low-level" data: 100 violins, 50 flutes, 20 drums). But listening to 170 individual tracks is overwhelming. You want to understand the music itself—the melody, the harmony, the rhythm (the "high-level" concepts).

Usually, to understand the music, a conductor (an expert) would guess, "I think the violins are playing the melody," and then check the recording to see if they are right. This is the old way: Hypothesis Testing. You need a guess before you can check.

This paper asks a different question: Can we automatically discover the "music" just by listening to the instruments, without needing a conductor to give us the guess first?

The authors say "Yes," but only if the orchestra follows a specific, organized pattern. Here is how they do it, using simple analogies:

1. The Problem: Too Many Variables, Not Enough Clues

In complex systems (like a brain or a deep learning computer program), there are thousands of tiny parts (neurons or variables) interacting. If you try to map out how every single one talks to every other one, it's a mess. It's like trying to figure out the plot of a movie by watching every single frame of film individually without seeing the story.

2. The Secret Sauce: The "Low-Rank" Structure

The authors assume the system has a hidden simplicity. They call this a "Low-Rank" structure.

The Analogy: Imagine a choir where the singers aren't all singing random notes. Instead, they are grouped into 5 distinct sections (Sopranos, Altos, Tenors, Baritones, Basses).

The Low-Level view sees 100 individual voices.
The High-Level view sees just 5 sections.

The paper assumes that many individual voices are just copies or variations of these 5 sections. If you know the 5 sections, you can explain the whole choir. In math terms, the complex web of connections between 100 people can be compressed into a smaller web connecting just 5 groups.

3. The Discovery: Finding the "Anchors"

Here is the tricky part: If you just listen to the choir, how do you know which singers belong to which section? Maybe the Sopranos are mixed with the Tenors. How do you separate them?

The authors introduce a rule called the "Anchor Assumption."

The Analogy: Imagine that in this choir, there are a few "Super-Singers."

The In-Anchor: A singer who only listens to the Soprano section leader and no one else.
The Out-Anchor: A singer who only sings what the Soprano section leader tells them, and no one else influences them.

If you find these "Super-Singers" (Anchors) in the data, you can use them as a map. Because they are so uniquely tied to one specific section, they act like a lighthouse. Once you find the lighthouse, you can figure out which other singers belong to that same section.

The paper proves that if these "Anchors" exist, you can mathematically guarantee that you will find the correct high-level groups (the 5 sections) without needing to guess them first.

4. The Result: A New Way to "Steer" Systems

Once the computer learns these high-level groups (the "Causal Abstraction"), it can understand the system better.

Old Way: "I think if I change the Soprano section, the melody changes. Let me try changing 50 individual singers to see if I'm right." (Slow, expensive, requires guessing).
New Way: The computer has already figured out, "Ah, the melody is controlled by the 'Soprano Group'." Now, if you want to change the melody, you can just intervene on the "Soprano Group" directly.

The paper tested this on two things:

Fake Data: They created a fake system where they knew the answer. The computer successfully found the hidden groups, proving the math works.
A Simple Neural Network: They trained a computer program to check if a number is divisible by 6. The program figured out that the network was secretly using two main concepts: "Is it divisible by 2?" and "Is it divisible by 3?" It found these high-level ideas just by looking at the low-level math, without being told what to look for.

Summary

This paper provides a recipe for automatically finding the "big picture" rules inside a complex system.

It assumes the system is organized into a few hidden groups (Low-Rank).
It looks for special "Anchor" signals that uniquely identify those groups.
If those anchors exist, it can mathematically prove it has found the correct high-level structure.

This means we might one day be able to look at a complex AI or a biological system and say, "Here are the 5 main concepts it is using," without needing an expert to tell us what those concepts might be.

Technical Summary: Unsupervised Causal Abstractions Discovery

Problem Statement

The paper addresses the challenge of discovering high-level causal abstractions directly from low-level measurements without relying on expert-proposed hypotheses. While existing work in mechanistic interpretability and causal abstraction largely follows a hypothesis-testing paradigm—where an expert proposes a candidate high-level Structural Causal Model (SCM) to verify if a low-level system (e.g., a Deep Neural Network) implements it—this approach is costly and infeasible for systems that are not fully understood. The authors aim to solve the complementary problem: learning a high-level SCM directly from low-level observations in an unsupervised manner.

Methodology

Theoretical Framework: Factor DAGs and Low-Rank Structure

The authors leverage the concept of Factor Directed Acyclic Graphs (f-DAGs), a family of models where low-level variables are parameterized by a small number of latent factors. This relies on the assumption that the adjacency matrix $A$ of the low-level causal graph exhibits a low-rank structure (specifically, Boolean rank $m < n$ ).

Factorization: The low-level adjacency matrix $A$ is decomposed into $A = Q \diamond R^\top$ , where $Q$ represents edges from observed variables to latent factors ( $X \to Z$ ) and $R$ represents edges from factors back to variables ( $Z \to X$ ).
Causal Abstraction: The authors formalize the relationship between the low-level SCM ( $L$ ) and the high-level SCM ( $H$ ) over latent factors. They prove that if the low-level system is generated by an f-SCM, the collapsed SCM over the factors constitutes a uniform transformation of the low-level SCM. This means the high-level model preserves the interventional behavior of the low-level system under specific state and intervention maps.

Identifiability and the Anchor Assumption

A critical contribution is establishing conditions under which these latent factors are identifiable.

The Anchor Assumption: Inspired by topic modeling, the authors introduce the "anchor" condition. For each latent factor $Z$ , there must exist at least one in-anchor (a low-level variable $X$ that is a child only of $Z$ ) and one out-anchor (a low-level variable $X$ that is a parent only of $Z$ ).
Identifiability Results: Under this assumption (along with standard causal sufficiency and faithfulness assumptions), the authors prove:
1. The Boolean factorization of the adjacency matrix is unique up to a permutation of factors.
2. The mechanisms of the f-SCM are identifiable up to simple reparameterizations (specifically affine transformations if mechanisms are linear).

Practical Implementation: UCAD

The authors propose a practical algorithm, Unsupervised Causal Abstractions Discovery (UCAD), which formulates the learning problem as a constrained optimization task.

Objective: The model maximizes the likelihood of observed data under a parameterized graph model while satisfying specific constraints.
Constraints:
1. Acyclicity (CDAG): Enforces that the learned graph is a DAG, adapted for the low-rank structure to ensure block upper-triangularity in layered systems.
2. Anchors (Canchors): Enforces the existence of in-anchors and out-anchors for each factor to ensure identifiability.
3. Sparsity: An $L_1$ constraint to prevent overfitting.
Approximate Transformation: The learning objective is linked to the theoretical goal via an "approximate transformation" bound. The authors show that minimizing the learning objective (negative log-likelihood) linearly bounds the error in approximating the high-level causal abstraction.

Key Results

Synthetic Experiments

The authors validated UCAD on synthetic f-SCMs with varying complexities (linear/non-linear mechanisms, layered/non-layered structures, noise levels).

Recovery of Latents: The method successfully recovered ground-truth latent factors. When mechanisms were linear, the Mean Correlation Coefficient (MCC) between learned and true factors reached an average of 0.83.
Non-linear Cases: In fully non-linear settings, the MCC (Pearson) dropped (as expected due to arbitrary bijective transformations), but the Randomized Dependence Coefficient (MCC-RDC) remained high (0.70–0.79), indicating successful recovery of the underlying structure up to non-linear reparameterization.
Robustness: Performance was largely invariant to the number of variables (16–128) and factors (3–8).

Neural Network Interpretability

The method was applied to a Deep Neural Network (MLP) trained to solve a divisibility-by-6 task.

Concept Recovery: The model successfully identified factors corresponding to the intuitive concepts of divisibility by 2 ( $c_2$ ) and divisibility by 3 ( $c_3$ ).
Metrics: The learned factors showed strong alignment with the hypothesized concepts (MCC-RDC of 0.72 for positive concepts) compared to negative controls (irrelevant primes), which yielded near-zero alignment (0.07).
Specific Findings: One learned factor showed a Pearson correlation of 0.80 with the concept of divisibility by 2, suggesting the network consistently implements this logic.

Significance and Claims

The paper claims to provide the first theoretical and practical framework for the unsupervised discovery of causal abstractions from low-level data alone.

Theoretical Contribution: It bridges low-rank causal discovery with causal abstraction theory, proving that low-rank assumptions naturally induce valid high-level abstractions. It establishes that the "anchor assumption" is sufficient to make these latent factors identifiable up to trivial equivalence.
Practical Contribution: It translates these theoretical guarantees into a differentiable learning objective (UCAD) that can be applied to real-world systems like DNNs.
Modesty: The authors acknowledge limitations, noting that the current approach requires knowing the number of latent factors and that scaling to larger, more complex systems (e.g., large language models) requires further optimization research. They also note that while the method identifies factors, interpreting the specific heuristics learned by DNNs remains challenging, as low agreement with a concept might indicate a different underlying strategy rather than a failure of the method.

The work positions itself as a step toward automating the discovery of high-level causal structures in complex systems, moving beyond the reliance on expert intuition for hypothesis generation.