acceptodds
Under review as a conference paper at ICLR 2027

Causal Abstraction of Linear Systems: Sufficient Conditions and Methods

Abstract

Causal systems often admit multiple levels of description, where micro-level variables are aggregated into macro-level representations. A valid causal abstraction (CA) must preserve interventional semantics while producing a more compact, interpretable model. We study the problem of learning CAs for linear structural causal models (SCMs), formulating it as a two-stage pipeline: graph partitioning followed by linear aggregation weight learning. For the first stage, we establish sufficient graphical conditions for exact CA and propose three partitioning algorithms including one that guarantees these conditions. For the second stage, we extend algebraic characterizations of CA to a subclass of cyclic SCMs and introduce a differentiable objective for learning aggregation weights as a constrained optimization problem. Together, our end-to-end framework reduces a -variable system to a target dimension . Experiments on synthetic graphs and empirical economic input-output networks demonstrate that our approach is able to recover non-trivial abstractions and outperforms existing unsupervised baselines while offering a principled trade-off between exactness and informativeness.

Primary area:
causal reasoning
Keywords:
Causal Abstraction

Reviews

Among:
Shape:
1234this paper, Top 30%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.67 over 3 reviews, above 70% of the others.
Reviewer_38wSOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper studies the research problem of constructing linear causal abstractions (CA) for linear structural causal models (SCM). It departs from existing work by extending to a cyclic SCMs. Specifically, the authors provide an algebraic characterisation for a subclass of cyclic models and provide a sufficient graphical condition (All-In, One-Child, acyclic cluster) for the existence of an abstraction map. Furthermore, the authors propose a two stage pipeline for learning CAs for linear SCMs. The first stage includes three graph partitioning algorithms (where one algorithm claims to guarantee sufficiency). The second stage includes a constrained optimization formulation for learning the aggregation weights of a given partition. The proposed method is evaluated on synthetic graphs and economic input-output networks and the results demonstrate superior performance to UCA (unsupervised baseline).

Critical strengths
  • The cyclic extension for CA construction is well motivated and addresses an immediate gap in existing works.
  • The paper not only includes a novel algebraic characterisation but also a constructive pipeline that is well connected to the developed theory.
Critical weaknesses
  • The validity guarantee claim for AOC Closure is not supported. The paper claims to "propose three partitioning algorithms including one that guarantees these conditions" in the abstract. In the caption of Figure 3, it is claimed that "AOC Closure which is guaranteed to admit a valid abstraction by Theorem 8". Theorem 8 states that All-In, One-Child, and acyclicity are sufficient conditions for the existence of a valid abstraction. I interpret this as AOC Closure's output is guaranteed to satisfy the three sufficiency conditions and hence, must admit a valid abstraction. However, in Sec 4.2 where AOC Closure is proposed, the authors only states that AOC Closure will satisfy the All-In and One-Child conditions but do not mention the acyclic condition.

  • The paper's claim on providing a principled tradeoff between exactness and informativeness is weakly supported. In Figure 3, AOC closure, the only method with a claimed guarantee to admit a valid abstraction is consistently at ReconErr ~1 (which is the value of a trivial abstraction) across all three plots. The only method that consistently achieves ReconErr below 1 is Greedy All-In which doesn't have any theoretical guarantees (its output isn't guaranteed to satisfy any of the sufficiency conditions in Theorem 8). This is further supported in Figure 2 where Greedy All-In’s lower ReconErr comes with visibly higher RAE, whereas AOC Closure has lower RAE but substantially higher ReconErr (sometimes >1). Together, this means that AOC Closure is exact but not informative while Greedy All-In is informative but not exact. This weakens the paper's claim to offer "a principled trade-off between exactness and informativeness" as the paper only proposes two extreme options.

Questions for authors

Questions:

  • Can the authors theoretically support the claim that the AOC Closure algorithm is guaranteed to satisfy the three sufficiency conditions?

  • Can the authors provide any additional support for claiming a principled trade-off between exactness and informativeness beyond a method that is exact but non-informative and a method that is informative but inexact?

  • With regard to the metric RAE which is defined as the max over all subsets of {1, ..., k}, the paper computes RAE only over the empty set and singletons due to intractability for large k. However, the experiments in Table 1 and Figure 3 all use k=10. Full enumeration would then require computing over 1,024 subsets. Could the authors report RAE computed over more than just singleton subsets at k=10 or report RAE computed over all subsets at a smaller k (k=5 would only require computing over 32 subsets)?

2 comments

We thank reviewer 38wS for taking the time to review our paper and for their considered comments.

AOC Closure guarantee

You are right that we left the acyclic condition implicit and could have spelt this out more. In the statement of Theorem 8 we claim in passing that the cluster graph will be acyclic whenever the low-level graph is acyclic and the All-In condition is satisfied. Here is the full argument for this.

Suppose we have an acyclic low-level graph G\mathcal{G} and a partition π\pi that satisfies the All-In condition. Let Gπ\mathcal{G}_{\pi} denote the cluster graph and suppose we have a cycle in this graph i0→i1→⋯→il−1→i0i_{0} \rightarrow i_{1} \rightarrow \dots \rightarrow i_{l-1} \rightarrow i_{0}. By the All-In condition, we can construct a low-level path beginning with r0∈π(i0)r_{0} \in \pi(i_{0}), going to r1∈π(i1)r_{1} \in \pi(i_{1}) and so on each time picking a low-level variable rj∈π(ij)r_{j} \in \pi(i_{j}) for j∈{0,...,l}j \in \{0,...,l\} in the order of the cycle. Since we assume G\mathcal{G} is a finite graph, this path will eventually contain a cycle contradicting the acyclicity of G\mathcal{G}.

So when G\mathcal{G} is acyclic, AOC Closure is guaranteed to admit a valid abstraction. For cyclic G\mathcal{G}, we can ensure that Gπ\mathcal{G}_{\pi} is acyclic by beginning with the strongly connected components (SCCs) as our initial partition and running AOC Closure to find a coarsening of it that satisfies the All-In and One-Child conditions. The argument above then adapts. Suppose such a coarsening had a cycle i0→⋯→il−1→i0i_{0} \rightarrow \dots \rightarrow i_{l-1} \rightarrow i_{0} in its cluster graph. The low-level walk constructed above is now closed, so it contains a low-level cycle; the variables on that cycle therefore lie in a single SCC, hence in a single block of the initial partition, and hence in a single cluster of any coarsening of it. This contradicts the distinctness of i0,…,il−1i_{0},\dots,i_{l-1}. Note that finding the initial SCC partition does not affect the asymptotic runtime complexity of the algorithm.

Exactness-Informativeness trade-off

AOC Closure and Greedy All-In do indeed give two extreme points on the RAE-ReconErr curve and are intended to act as baselines for other methods. Further experiments show that OC Closure gives a genuine trade-off between the two methods, particularly when the low-level graph is cyclic and its cycles are contained within clusters. In our latest version of the paper we present results that make this explicit. OC Closure has no guarantee, since it targets One-Child but not All-In, but it is exact on almost every cyclic instance we tested. Indeed under One-Child each cluster is constrained by at most one collinearity equation and a cycle of clusters defines an eigenvector equation which generically admits a solution. The solution is not in general marginalisation-free; this is only guaranteed if it additionally satisfies the All-In Condition.

At the end of section 4 we briefly mention a gradient-based method, GradCAP, which admits a regulariser on cluster size via a hyperparameter λintra\lambda_{\text{intra}}. Our latest results show that the largest cluster shrinks in size monotonically as λintra\lambda_{\text{intra}} increases and that selecting among a small grid of λintra\lambda_{\text{intra}} at a fixed RAE tolerance (a selection that requires no ground truth, since both RAE and ReconErr are computable from A\mathbf{A} alone) yields an abstraction that improves on AOC Closure's ReconErr up to 77% of the time for cyclic graphs whose cycles are contained within clusters.

Computing exact RAE

Thank you for your suggestion. We have ensured that the full RAE is now computed whenever k≤12k\leq12. This does not materially change any of our results.

Thank you again for your careful review. In response we have proved that AOC Closure’s output satisfies all three sufficiency conditions — it now initialises from strongly connected components, so every partition it returns is a coarsening of them and GπG_{\pi} is acyclic (Section 4.2, Appendix A.8). We have also shown that the λintra\lambda_{\text{intra}} hyperparameter in the GradCAP algorithm acts as a dial that trades off exactness with intra-cluster edges (Section 5, Table 1). Expanding our synthetic experiments to different graph settings and considering win-rate against AOC Closure, we see that the different methods we propose are advantageous in different settings (Section 5, Figure 2; Appendix E.4) with some cross-over when the tolerance α≈0.1\alpha \approx 0.1 (e.g. Cyclic graphs in Figure 2 with dintra=0d_{\text{intra}} = 0). We now report RAE over all 2k2^{k} subsets rather than singletons, both on synthetic graphs and across sixteen economies in out Leontief experiments (Appendix E.5, Table 4).

We would be glad to address any further questions while the discussion period allows.

Reviewer_1CD6OpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper presents a framework for learning causal abstractions of linear SCMs by combining graph partitioning with linear aggregation weight optimization. The authors extend algebraic characterisations of constructive causal abstractions to cyclic linear SCMs with non-negative weight matrices and bounded spectral radius. They establish that the All-In and One-Child conditions on graph partitions are sufficient to guarantee the existence of the causal abstractions, introducing three agglomerative partitioning algorithms to discover macro-variable groupings. Evaluated on synthetic graphs and empirical Leontief economic input-output models, the proposed pipeline provides a controllable trade-off between exactness and informativeness while outperforming existing unsupervised baselines

Critical strengths

To my knowledge, the proposed theory on linear SCM causal abstractions is novel and a significant extension of previous work to a subset of cyclic graphs.

The sufficient conditions for the existence of causal abstraction and proposed algorithms are commendable steps towards developing more practical methods for causal abstractions.

The developed method enables a controllable trade-off between Relative Abstraction Error and Reconstruction Error.

Critical weaknesses

The paper’s primary graphical contribution (Theorem 8) proves that if a cluster graph is acyclic and satisfies both the All-In and One-Child conditions, a marginalization-free, T-faithful linear abstraction is guaranteed to exist. However, requiring every high-level cluster to have out-degree at most 1 (One-Child) restricts the high-level causal graph to a collection of directed in-trees forcing any children sharing a common parent to merge into a single cluster, triggering a cascading giant-cluster collapse on graphs with realistic branching density. It’s likely the reason why in figure 4a there is a big cluster for 97 sectors.

One of the selling points of the theoretical part of the paper is that the theorems work for cyclicic graphs. Yet, IIUC, all the synthetic experiments in the main text of the paper concern acyclic graphs. It would greatly improve the paper if we could see more systematic experiments on synthetic, cyclic graphs, e.g., by varying the graph size, target cluster size, cycle frequency and length, edge density, to evaluate the limits of the proposed framework on cyclic graphs.

The manuscript claims that UCA (Zhu et al., 2024) is "the only other existing method for unsupervised causal abstraction we are aware of". The authors cite D'Acunto et al. (ICML 2025) solely as a "category-theoretical reformulation". However, D'Acunto et al. (2025) also provide Riemannian optimization algorithms on the Stiefel manifold (including a partial-prior formulation that jointly learns the constructive cluster support matrix and the linear aggregation weights). Evaluating against D'Acunto et al. (2025) would improve the paper.

Questions for authors
  1. Is it possible to incorporate some sort of regularization to the method to avoid the big clusters like in Figure 4a?
  2. In Algorithm 4, Phase 1 pins tit_i for cyclic SCCs using only the shortest simple cycle, and Propagate(x) only updates and scores acyclic singletons. How does Algorithm 4 enforce collinearity when an SCC contains overlapping cycles, or when a cyclic cluster i∈Ci \in C has outgoing edges to acyclic descendants j∉Cj \notin C?
2 comments

We thank reviewer 1CD6 for their considered comments.

One-Child Condition

We acknowledge that the One-Child condition is restrictive on the high-level graph structure (i.e. it only admits in-trees) and is chiefly responsible for the large sink clusters we get with the AOC Closure algorithm. First we write Mij:=Aij(I−Ajj)−1\mathbf{M}_{ij} := \mathbf{A}_{ij}(\mathbf{I} - \mathbf{A}_{jj})^{-1} so that the Massidda Equations become Mijtj=a~ijti\mathbf{M}_{ij}\mathbf{t}_{j} = \tilde{a}_{ij}\mathbf{t}_{i}.

i) This is a sufficient condition on graph partitions without having any knowledge of the edge weights. If the All-In and One-Child conditions are satisfied and the cluster graph is acyclic, then we can always satisfy the Massidda Equations no matter what the weight matrix A\mathbf{A}: if cluster ii has one child cluster jj, then ti\mathbf{t}_{i} is determined by Mijtj\mathbf{M}_{ij}\mathbf{t}_{j}. But if cluster ii has children j1,j2j_{1},j_{2} then the weight matrix could be chosen so that Mij1\mathbf{M}_{ij_{1}} and Mij2\mathbf{M}_{ij_{2}} have orthogonal column spaces and so there is no consistent choice of tj1\mathbf{t}_{j_{1}} and tj2\mathbf{t}_{j_{2}} to determine ti\mathbf{t}_{i}.

ii) Of course with knowledge of the weight matrix A\mathbf{A}, we need not settle for the One-Child condition but writing down a sufficient condition which could be turned into a tractable partition learning algorithm proved difficult. With tj\mathbf{t}_{j} as free parameters for sink clusters jj, we would require, at each cluster ii that was an ancestor of jj, collinearity of Mij1Mj1j2…Mjl−1jtj\mathbf{M}_{ij_{1}}\mathbf{M}_{j_{1}j_{2}}\dots\mathbf{M}_{j_{l-1}j}\mathbf{t}_{j} over paths i→j1→⋯→ji\rightarrow j_{1}\rightarrow\dots\rightarrow j.

iii) We have since recognised that, in practice, the utility of an abstraction is context-dependent. For instance, there may be a subset of target variables in the low-level model whose values we want to predict. The goal of an abstraction in this case, would be to compress the model (outside of these target variables) so that we can make predictions about our target variables using the high-level model.

Cyclic Graph Experiments

We have included systematic experiments on synthetic cyclic graphs in our revised paper. We consider three regimes: i) acyclic low and high-level graphs, ii) cyclic low-level graph and acyclic high-level graph (cycles contained within clusters) and iii) cyclic high-level graph. For the third regime, we vary the number of cycles in the high-level graph as well as the length of the cycles and density. We find that AOC Closure still guarantees exactness since it now begins with strongly connected components (SCCs) as an initial partition to ensure that cycles are contained within clusters and OC Closure empirically achieves exactness in the cyclic regimes, often with better ReconErr than AOC Closure. One limitation is that in regime iii), if the high-level density is too high (above 0.20.2) then it often becomes one SCC and AOC Closure collapses to a single cluster.

D'Acunto et al.

You are right that their partial-prior formulation learns the cluster support and the aggregation weights jointly, however to the best of our understanding, the setting of D'Acunto et al. is different to ours in some important ways. While they do not assume access to any SCMs (we start with a fully specified low-level SCM), their approach requires knowledge of probability measures in the low-level and high-level models as well as partial knowledge of the structure of the abstraction. On the other hand, we assume no knowledge of the high-level model (except that we provide a target number of variables kk) and we seek to learn suitable high-level models. We also seek to learn strong abstractions which are defined independently of the low-level distribution.

Cluster size regularisation

At the end of section 4 we briefly mention a gradient-based method, GradCAP, which admits a regulariser on cluster size via a hyperparameter λintra\lambda_{\text{intra}}. Our latest results show that the largest cluster shrinks in size monotonically as λintra\lambda_{\text{intra}} increases and that selecting among a small grid of λintra\lambda_{\text{intra}} at a fixed RAE tolerance (a selection that requires no ground truth, since both RAE and ReconErr are computable from A\mathbf{A} alone) yields an abstraction that improves on AOC Closure's ReconErr up to 77% of the time for cyclic graphs in regime ii).

Algorithm 4

You are right to point out that as written, the Massidda Equations are not enforced for such clusters. We realised this after submission and have adjusted the algorithm so that, in addition to sink clusters, we also have a learnable parameter ti\mathbf{t}_{i} for one cluster ii per cyclic SCC and we enforce the Massidda Equations over every edge (i.e. Propagate(x) applies to all SCCs). This corrected algorithm is the basis of all our other experiments that learn T\mathbf{T}.

Thank you again for your detailed review. Following your comments we added systematic experiments on synthetic cyclic graphs, varying graph size, target cluster size, cycle frequency, cycle length and edge density (Section 5.1, Appendix E.4); corrected the algorithm so that the Massidda Equations are enforced across all cluster-graph edges, including overlapping cycles within an SCC and cyclic clusters with acyclic descendants (Appendix C.2, Algorithm 5); introduced a cluster-size regulariser via GradCAP’s λintra\lambda_{\text{intra}}; and revised our discussion of D’Acunto et al. in Section 1.1 to set out precisely how their assumptions differ from ours.

We would be glad to address any further questions while the discussion period allows.

Reviewer_BtThOpenReview ↗
Rating
4(+1)
Confidence
4
Informativeness
2
Presentation
2
Soundness
3
Read review
Paper summary

This paper provides theoretical grounding and practical conditions for learning linear causal abstractions of linear low level models. A theoretical characterisation of high level strong abstraction is given along with two practical conditions for finding a viable condition in practice. The authors demonstrate the method on an economic model.

Critical strengths

This paper tackles an important problem of finding causal abstractions in an unsupervised manner. The proposed theoretical contribution looks sound to me and lays a foundation for unsupervised causal abstraction in the linear case.

The two practical conditions all in and one child are well motivated for the practical algorithm and the authors have a useful example on an economic model.

Critical weaknesses

Since the papers main purpose is to provide practical algorithms, one real world example seems insufficient to empirically evaluate the usefulness of the two proposed conditions for finding exact abstractions.

Questions for authors

In why sense are the two proposed conditions useful in practice? After all, there may be many choices of exact abstractions, so how do we know the ones found your algorithms are the useful ones?

2 comments

We thank reviewer BtTH for taking the time to review our paper and for their thoughtful comments.

Usefulness of All-In and One-Child

Note that we frame the task of learning an abstraction as consisting of two parts in sequence: i) learning a graph partition π\pi and ii) learning an abstraction matrix T\mathbf{T} consistent with π\pi. The \textit{All-In} condition is a necessary graphical condition for exact [marginalisation-free, T\mathbf{T}-faithful] abstractions (Corollary of Proposition 7) and the One-Child condition (in addition to All-In) is a sufficient graphical condition (for acyclic low-level graphs) for the existence of an exact causal abstraction. These conditions are thus useful insofar as we care about our abstraction being exact. You are right to point out that there are in general many choices of exact abstractions, which is why we attempt to measure the usefulness of an abstraction by Reconstruction Error (roughly, how much information about the low-level model is destroyed in the abstraction). In practice however, the utility of an abstraction will be context-dependent. For instance, there may be a subset of target variables in the low-level model whose values we want to predict. The goal of an abstraction in this case, would be to compress the model (outside of these target variables) so that we can make predictions using the high-level model whilst remaining faithful to the low-level model even under interventions. Any abstraction that achieves this (i.e. RAE=0\text{RAE} = 0) would be considered useful.

Other real world example

The EXIOBASE3 table we use covers 49 regions. In the appendix of the revised paper we run the identical pipeline on the input–output networks of several further economies, reporting the same metrics as Figure 4: RAE, Reconstruction Error and the fraction of edges falling inside clusters.

Thank you again for your review. Following your comment on having only one real-world example, we now apply our pipeline to input–output tables for sixteen economies (Appendix E.5, Table 4), and we have added an experiment on abstractions that preserve a set of target variables, which speaks to your question about when an exact abstraction is a useful one (Appendix E.1).

We would be glad to address any further questions while the discussion period allows.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.