🤖 AI

Relational Structural Causal Models

This paper introduces relational structural causal models and relational neural causal models to enable AI systems to learn causal representations that support reasoning about interventions and counterfactuals for unseen combinations of objects, even in the presence of unobserved confounding.

Original authors: Adiba Ejaz, Elias Bareinboim

Published 2026-06-16

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Adiba Ejaz, Elias Bareinboim

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 teach a robot how to drive a car. You show it thousands of videos of traffic. But here's the catch: in every video you show it, there are always exactly two cars and one pedestrian.

Now, you put the robot on a real road where there are three cars and two pedestrians. The robot panics. It has never seen this specific combination before. It doesn't know if the third car should stop or go.

This is the problem the paper tackles. It asks: How can we build an AI that understands the rules of how things interact, so it can handle new, unseen combinations of objects without needing to be retrained?

The authors call their solution Relational Structural Causal Models (RSCMs). Here is a breakdown of what they did, using simple analogies.

1. The Problem: The "Recipe" vs. The "Ingredients"

Most AI models today are like a chef who memorized a recipe for a salad with exactly three tomatoes and two cucumbers. If you give them a salad with four tomatoes and one cucumber, they get confused. They don't understand the logic of the salad; they just memorized the specific list of ingredients.

In the real world (like traffic, biology, or social networks), the number of objects changes constantly.

Traffic: Sometimes there are 2 cars, sometimes 10. Sometimes a pedestrian is in front of Car A, sometimes Car B.
The Goal: We need an AI that learns the "recipe" (the causal rules), not just the specific ingredients. It needs to know: "If a red light controls a car, the car stops," regardless of whether there is one car or a hundred.

2. The Solution: The "Universal Rulebook"

The authors created a new type of model called a Relational Structural Causal Model (RSCM).

Think of an RSCM not as a list of specific facts, but as a Universal Rulebook.

Instead of saying "Car 1 stops when Light 1 is red," the rulebook says: "Any car stops if any light controlling it is red."
It also handles relationships: "A car stops if any pedestrian in its path is crossing."

This allows the AI to take the same rulebook and apply it to a scene with 2 cars or a scene with 50 cars. It doesn't need to see every possible combination to know what to do.

3. The Big Discovery: You Can't Just "Guess"

The paper makes a very important, somewhat scary discovery. They proved mathematically that you cannot simply look at data from one set of scenes and automatically figure out what happens in a totally new scene.

The Analogy:
Imagine you have a machine that makes sandwiches.

Scene A: You only ever see the machine make sandwiches with one slice of cheese.
Scene B: You want to know what happens if you put two slices of cheese in.

The authors proved that without knowing the internal mechanism (the "causal graph"), you cannot guess the outcome of Scene B just by watching Scene A.

Maybe the machine adds cheese linearly (2 slices = double the taste).
Maybe the machine has a limit (2 slices = it jams).
Maybe the machine ignores the second slice entirely.

If you only watch the machine make single-slice sandwiches, you have no way of knowing which of these three rules is true. You need to know the structure of the machine (the causal graph) to make that prediction.

4. The Fix: Drawing the Map

To solve this "guessing" problem, the authors say we need to provide the AI with a Map of Relationships (a Relational Causal Graph).

This map tells the AI:

"Signals control Pedestrians."
"Pedestrians in a car's path affect the Car."
"Signals do not directly affect Cars unless they control them."

Once the AI has this map, it can use a special mathematical tool (called "identification criteria") to figure out if it can answer a question about a new scene.

If the map says "Yes": The AI can confidently predict the outcome of the new scene using data from the old scenes.
If the map says "No": The AI knows it doesn't have enough information and shouldn't guess.

5. The "Neural" Engine

Finally, the authors built a computer program (a Neural Network) that uses this Rulebook and Map. They call it a Relational Neural Causal Model.

They tested this on simulated traffic scenes.

They trained the AI on scenes with specific numbers of cars and pedestrians.
They asked it to predict what would happen in scenes with different numbers of cars and pedestrians.

The Result:
The new model was much better at predicting the unseen scenes than standard AI models. Even when the standard models were trained directly on the "unseen" scenes, the new model (trained on different scenes but using the right rules) often performed just as well or better.

Summary

The Problem: AI struggles when the number of objects or their arrangement changes (e.g., 2 cars vs. 10 cars).
The Insight: You can't learn the rules for new combinations just by looking at old data; you need to know the underlying causal structure.
The Tool: They created a "Rulebook" (RSCM) and a "Map" (Causal Graph) that tells the AI how objects interact.
The Proof: They showed mathematically when you can and cannot predict new scenarios, and built a neural network that successfully uses these rules to generalize to unseen traffic scenes.

In short, they gave AI a way to understand the logic of relationships rather than just memorizing lists of objects, allowing it to handle the messy, changing complexity of the real world.

Technical Summary: Relational Structural Causal Models

Problem Statement

Artificial intelligence systems require world models that are both causal (supporting reasoning about interventions and counterfactuals) and combinatorial (supporting generalization to unseen combinations of objects). While Structural Causal Models (SCMs) provide a formalism for causal reasoning, they typically assume a fixed set of variables and a fixed causal graph. This limitation hinders their application in domains where the number of objects and their relational structures vary dynamically, such as autonomous driving, robotics, and biological systems.

Existing relational machine learning methods excel at combinatorial generalization but often fail to provide causal guarantees, frequently exploiting unstable correlations that break under intervention. Conversely, causal inference methods often struggle to generalize across different relational skeletons (e.g., traffic scenes with different numbers of cars and signals) because they rely on fixed-variable assumptions or assume objects are independent and identically distributed (i.i.d.).

The core problem addressed is: How can one formally learn and perform causal inference (including interventional and counterfactual queries) across varying combinations of objects and relations, particularly when data is available only from specific observed relational skeletons?

Methodology

The authors propose a framework centered on Relational Structural Causal Models (RSCMs) and Relational Neural Causal Models (RNCMs).

1. Relational Structural Causal Models (RSCMs)

The paper extends standard SCMs to object-relational settings. An RSCM is defined by a tuple $\langle S, V, U, F, P(U) \rangle$ , where:

Schema ( $S$ ): Defines entity types (e.g., Car, Signal), relation types (e.g., Ctrl, Path), and attributes.
Mechanisms ( $F$ ): Unlike standard SCMs where mechanisms take fixed-size inputs, RSCM mechanisms accept multisets of relational parents. For example, a car's braking mechanism depends on the set of all signals controlling it and all pedestrians in its path. These mechanisms use relational constraints (first-order logic predicates) to determine which objects are relevant and aggregators (e.g., $\lor$ , $\land$ , sum, max) to combine their values.
Grounding: An RSCM acts as a template. When instantiated on a specific relational skeleton (a concrete set of objects and relations), it produces a ground SCM with a fixed set of variables.

2. Impossibility Results

The authors first establish theoretical limits on learning without further assumptions:

Theorem 3.3 (Cross-Skeleton Observational Inference): Even observational distributions for unseen target skeletons cannot be identified from source skeletons without additional assumptions. Two RSCMs can agree on all observed source skeletons but disagree on the target skeleton if the target contains relational configurations (e.g., a car controlled by two signals) not present in the source.
Theorem 3.4 (Within-Skeleton Causal Inference): Even within a single skeleton, if an entity has multiple attributes, observational data alone is insufficient to identify interventional distributions without assumptions about the causal structure.

3. Relational Identification via Graphical Criteria

To overcome these impossibility results, the paper introduces Relational Causal Graphs (RCGs). These graphs encode assumptions about the data-generating process, including:

Non-relational edges: Dependencies between attributes of the same object.
Relational nodes: Aggregated values of related objects (e.g., "all signals controlling car $c$ ").
Constraints: Annotations on edges specifying the relational conditions under which dependencies hold.

Using these graphs, the authors derive symbolic identification criteria:

Observational Identification (Theorem 4.3): A conditional distribution in a target skeleton is identifiable if there exists a source instance with an unconfounded variable and a parent domain that is a superset of the target's parent domain.
Causal Identification (Proposition 4.4): If a query is identifiable via the ctf-calculus (counterfactual calculus) on the marginalized ground graph, it is relationally identifiable.
Non-identifiability (Proposition 4.5): If a within-instance query is non-identifiable in the standard sense (e.g., due to a bow-structure), it remains non-identifiable in the relational setting.

4. Relational Neural Causal Models (RNCMs)

For practical implementation, the authors propose G-Constrained Relational Neural Causal Models (G-RNCMs).

Architecture: A neural network is defined for each attribute type (e.g., one network for Car.B). This network is reused (parameter sharing) across all instances of that type in any skeleton.
Inputs: The network takes non-relational parents and aggregated relational parents (e.g., counts or histograms of related object states).
Algorithm (RelationalNeuralID): The model is trained to fit source distributions (observational or interventional) while minimizing or maximizing the target query. If the minimum and maximum values of the query coincide, the query is identified; otherwise, it is non-identifiable. Theorem 5.2 proves that RNCMs are expressive enough to represent any RSCM consistent with the graph.

Key Contributions

Formalization of RSCMs: A rigorous definition of causal models for object-relational domains that supports varying numbers of objects and relations, extending the SCM framework.
Identification Theory: Proof of the impossibility of cross-skeleton inference without assumptions, followed by the development of graphical criteria (Relational Causal Graphs) that enable identification across skeletons and within skeletons.
Neural Implementation: The proposal of RNCMs, a sound and complete neural approach for relational identification that leverages parameter sharing and aggregation to handle combinatorial generalization.
Empirical Validation: Experiments on simulated traffic scenes demonstrating that RNCMs outperform non-relational causal baselines and relational non-causal baselines, particularly in generalizing to unseen object combinations.

Experimental Results

The authors evaluated their approach using simulated traffic scenes with varying numbers of signals, pedestrians, and cars.

Estimation Accuracy: RNCMs consistently outperformed flat Neural Causal Models (NCMs) and relational non-causal baselines (REL-MLP) by approximately 100x in identifiable settings. Notably, an RNCM trained on a source skeleton (e.g., a slip lane) outperformed baselines trained directly on the target skeleton (e.g., a T-junction) when estimating causal effects for specific cars, highlighting the value of relational structure.
Generalization: RNCMs successfully generalized to smaller and matched relational neighborhoods. Performance degraded only in non-identifiable settings (e.g., generalizing to a car controlled by two signals when the source only had one), aligning with the theoretical impossibility results.
Identification Accuracy: The algorithm successfully distinguished between identifiable and non-identifiable queries. For identifiable cross-car queries, the gap between minimized and maximized estimates collapsed to zero; for non-identifiable within-car queries, the gap remained large.
Scalability: Experiments with up to 75 objects showed that accuracy remained stable as the number of objects increased, with only a moderate increase in runtime, demonstrating the scalability of parameter sharing.

Significance and Claims

The paper claims to provide the methodological foundations for causal inference in object-relational settings. By unifying relational learning (for combinatorial generalization) and causal inference (for robustness to interventions), the work addresses a critical gap in AI world models.

The authors emphasize that their framework does not assume objects are i.i.d. or that relational structures are fixed. Instead, it explicitly models how causal mechanisms depend on relational constraints. The significance lies in enabling AI systems to reason about "what if" scenarios in dynamic environments (like autonomous driving) where the number and arrangement of objects change, provided that the underlying causal mechanisms are consistent across these variations. The work suggests that successful generalization in such domains relies on explicit assumptions about relational structure, which can be encoded via relational causal graphs and learned via RNCMs.