📊 statistics

Learning Causal Abstractions of Linear Structural Causal Models

This paper addresses the open problem of learning causal abstractions for linear structural causal models by characterizing the theoretical conditions linking low-level and high-level models and introducing Abs-LiNGAM, a method that leverages these constraints to efficiently discover causal structures from observational data under non-Gaussian noise assumptions.

Original authors: Riccardo Massidda, Sara Magliacane, Davide Bacciu

Published 2026-09-01

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Riccardo Massidda, Sara Magliacane, Davide Bacciu

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

Scientists have long sought to understand the world by building maps of cause and effect. These maps, known as causal models, help us predict what will happen if we change a specific part of a system, whether that system is a human brain, a climate pattern, or a machine learning algorithm. However, the real world is incredibly complex, filled with thousands of interacting parts. Trying to draw a map for every single detail often results in a tangled mess that is impossible to read or use. To make sense of this, researchers often create simplified versions of these maps, grouping many small details into larger, more manageable concepts. This process of simplification is called abstraction. The challenge has always been knowing exactly when a simplified map is a true, faithful representation of the complex one beneath it, and how to learn the rules that connect the two when we only have data to look at.

In a new study, researchers Riccardo Massidda, Sara Magliacane, and Davide Bacciu have cracked the code on how to build these connections for a specific, common type of system: one where causes and effects follow straight-line relationships. They tackled two major problems that had previously blocked progress. First, they figured out the precise rules that determine when a simplified model is a valid abstraction of a detailed one. Before this work, scientists knew that abstractions existed, but they did not have a clear checklist of what the underlying connections must look like to make the simplification mathematically sound. Second, they developed a new method to learn these connections directly from data, even when the simplified model is not yet known. This is a significant leap forward because, until now, learning these relationships required already knowing the structure of both the complex and the simple models.

The team focused on systems where variables influence each other in a linear way, meaning that if you double a cause, the effect doubles as well. They discovered that for a simplified model to be a valid abstraction, the variables in the complex model must be organized into specific, non-overlapping groups. Each variable in the simplified model corresponds to one of these groups. Crucially, they proved that the simplified model imposes strict rules on the order in which these groups must appear. If the simplified model says one concept causes another, then every variable in the first group must be able to influence variables in the second group through a specific chain of events that does not get blocked or canceled out by other variables. If this chain is broken or if the groups overlap in the wrong way, the simplification fails to represent the reality accurately.

To test these ideas, the researchers created a new tool called Abs-LiNGAM. Imagine trying to find a hidden pattern in a massive, noisy dataset. Usually, you have to check every possible connection between every single point, which takes a tremendous amount of time and computing power. Abs-LiNGAM changes the game by using a small amount of extra information to narrow the search. The method works by first learning the relationship between the complex data and a simplified version of it, even if that simplified version is just a guess at first. Once it understands how the complex data folds into the simple data, it uses the rules they discovered to tell the computer which connections are impossible. It effectively tells the search algorithm, "Do not waste time looking for a link between these two points because the rules of abstraction say it cannot exist."

The researchers tested this approach using simulated data, creating artificial worlds with known cause-and-effect structures to see if their method could find them. They found that when they provided the algorithm with even a small number of paired observations—data points that showed both the complex details and the simplified view together—the method became dramatically faster. It reduced the time needed to find the correct map of the complex system by cutting out vast numbers of wrong possibilities. The accuracy of the final map remained just as high as if the researchers had used the standard, slower method, but the process was much more efficient. This suggests that by understanding the mathematical rules of how we simplify our world, we can build better tools to understand the complex systems that shape our lives, from the workings of the brain to the behavior of artificial intelligence.

Technical Summary: Learning Causal Abstractions of Linear Structural Causal Models

Problem Statement

The paper addresses the challenge of modeling causal knowledge at different levels of granularity. While Causal Abstraction provides a framework for relating two Structural Causal Models (SCMs) at different levels of detail, the specific graphical and parametrical conditions under which one linear SCM can abstract another remain unknown. Furthermore, the problem of learning these abstractions directly from observational data, particularly when the high-level model is unknown, is an open problem. Existing methods often assume prior knowledge of both the low-level and high-level models or at least the high-level graphical structure. This work focuses on the scenario where two linear SCMs are related by a linear transformation, aiming to characterize the necessary and sufficient conditions for this relationship and to develop a method for learning these models and their abstraction function from data, given access to a small joint dataset of paired observations.

Methodology and Theoretical Framework

1. Theoretical Characterization of Linear T-Abstraction

The authors define a T-abstraction where an abstract SCM $H$ (on variables $Y$ ) is a linear transformation of a concrete SCM $L$ (on variables $X$ ) via a matrix $T$ . The core theoretical contributions establish the following:

Disjoint Relevant Variables: For a valid T-abstraction, the sets of concrete variables directly depended upon by each abstract variable (defined as relevant variables, $\Pi_R(Y)$ ) must be mutually disjoint. This implies that linear T-abstractions are a form of constructive abstraction.
Graphical Connectivity Conditions:
- Sufficiency: A directed path between relevant variables in the concrete graph mediated only by irrelevant variables (a T-direct path) is sufficient to imply an edge between the corresponding abstract variables.
- Necessity: For an abstract edge $Y_i \to Y_j$ to exist, every variable in the relevant set of the source ( $\Pi_R(Y_i)$ ) must have a T-direct path to at least one variable in the relevant set of the target ( $\Pi_R(Y_j)$ ). If this condition is violated, the abstraction is invalid.
Block Ordering: The abstraction function induces concrete blocks ( $\Pi(Y)$ ), which include relevant variables and any irrelevant variables connected to them via T-direct paths. The causal ordering of these blocks in the concrete model must strictly follow the topological ordering of the abstract model. Variables outside these blocks do not influence the abstraction and can be ignored.
Parametric Constraints: The paper derives a necessary and sufficient condition relating the coefficients of the linear models ( $W$ for concrete, $M$ for abstract) and the abstraction function ( $T$ ). Specifically, for any pair of abstract variables, the relationship $W_{ij}s_j = m_{ij}t_i$ must hold, where $s_j$ is derived from the exogenous abstraction function. This allows for the characterization of the set of all possible concrete models (concretizations) that satisfy a given abstract model.

2. Abs-LiNGAM: A Learning Algorithm

Building on these theoretical results, the authors propose Abs-LiNGAM, an algorithm to learn the abstract model, the concrete model, and the abstraction function from observational data under the assumption of non-Gaussian noise. The method operates in four stages, leveraging a small joint dataset ( $D_J$ ) of paired concrete-abstract observations and a larger concrete dataset ( $D_L$ ):

T-Reconstruction: Using the joint dataset ( $D_J$ ), the algorithm estimates the linear transformation matrix $T$ via least squares. This step relies on the availability of paired observations to map concrete variables to abstract variables.
Relevant Variable Identification: Based on the estimated $T$ , the algorithm identifies the sets of relevant concrete variables for each abstract variable.
Abstract Causal Discovery: The algorithm applies the estimated transformation $T$ to the large concrete dataset ( $D_L$ ) to generate a synthetic abstract dataset. It then uses a standard causal discovery algorithm (DirectLiNGAM) on this synthetic data to learn the abstract causal structure ( $\hat{M}$ ).
Constrained Concrete Discovery: The learned abstract structure is used to infer constraints on the concrete graph. Specifically, if no path exists between abstract variables $Y_i$ and $Y_j$ , the algorithm infers that no path can exist between any variable in $\Pi_R(Y_i)$ and any variable in $\Pi_R(Y_j)$ . These constraints are fed into DirectLiNGAM to recover the concrete model ( $\hat{W}$ ) within a significantly reduced search space.

Key Results

Experiments conducted on simulated data demonstrate the effectiveness of the proposed approach:

Search Space Reduction: Abs-LiNGAM substantially reduces the search space for causal discovery compared to applying DirectLiNGAM directly to the low-level dataset without abstraction-induced constraints.
Execution Time: This reduction in search space translates to a significant decrease in execution time, particularly as the number of concrete nodes increases.
Data Efficiency: The method requires only a small number of paired samples ( $|D_J|$ ) to reconstruct the abstraction function. Performance approaches that of the baseline (DirectLiNGAM on full data) when the number of paired samples is comparable to the number of concrete nodes.
Robustness: Bootstrapping the abstract causal discovery step (aggregating results from multiple sub-datasets) improves the quality of the downstream concrete discovery without significantly increasing execution time.

Significance and Claims

The paper claims to make the following contributions to the field of causal inference and abstraction:

Theoretical Foundation: It provides the first characterization of the necessary and sufficient graphical and parametrical conditions for linear causal abstraction, specifically addressing how low-level coefficients and abstraction functions determine high-level coefficients and causal ordering.
Sampling Procedure: It introduces a complete and sound algorithm (Algorithm 1) to sample any concrete model from the set of valid concretizations of a given abstract SCM, a capability previously unavailable.
Learning from Data: It proposes Abs-LiNGAM, a method to learn high-level and low-level causal models and their abstraction function directly from observational data. Unlike prior works that assume known graphical structures, this method learns the structures from data, provided a small joint dataset of paired observations is available to establish the variable correspondence.
Scalability: It demonstrates that leveraging abstract information can improve the scalability of causal discovery for large linear non-Gaussian models by constraining the search space, offering a practical solution for scenarios where high-level concepts are sparse but low-level data is abundant.

The authors note that future work could extend these results to non-linear models and address the causal sufficiency assumption, but the current work is strictly limited to linear SCMs with linear abstraction functions and non-Gaussian noise.