🤖 AI

CauSim: Scaling Causal Reasoning with Increasingly Complex Causal Simulators

CauSim is a framework that addresses the scarcity of causal reasoning data by enabling LLMs to construct increasingly complex, executable structural causal models (SCMs) that serve as scalable simulators for generating verifiable training data and improving model performance across diverse representations.

Original authors: Nicolás Astorga, Anita Kriz, Mihaela van der Schaar

Published 2026-05-12

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Nicolás Astorga, Anita Kriz, Mihaela van der Schaar

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

The Big Problem: LLMs Are Great at Facts, Bad at "What-Ifs"

Imagine Large Language Models (LLMs) as incredibly well-read librarians. They have read almost every book ever written. If you ask them, "Who wrote Pride and Prejudice?" or "How do I write a Python loop?", they can answer instantly and perfectly.

But if you ask them a "What-If" question, they often stumble.

Example: "If I had taken this specific drug yesterday, would my tumor be smaller today?"

To answer this, the model needs to do Causal Reasoning. It can't just guess based on patterns; it has to simulate a chain reaction: Drug A changes Cell B, which changes Protein C, which shrinks Tumor D.

The paper argues that LLMs struggle here for three main reasons:

Scale: Real-world systems are huge. Tracking a chain of 50 interacting variables is like trying to follow a game of "telephone" played by 50 people at once.
Language vs. Code: Causal knowledge is usually written in messy natural language (like a doctor's notes). Computers need precise code to run simulations, but translating messy notes into perfect code is hard.
No Answer Key: In the real world, we can't go back in time to see what would have happened if we gave a patient a different drug. We don't have the "ground truth" (the correct answer) to teach the AI. Without an answer key, the AI can't learn.

The Solution: CauSim (The "Causal Simulator" Factory)

The authors introduce CauSim, a framework that turns the impossible task of learning from scarce real-world data into a scalable, supervised game.

Think of CauSim as a video game engine that the AI builds for itself. Instead of trying to learn from real, messy history, the AI builds a virtual world where it knows the rules, runs the simulation, and gets a perfect score.

Here is how it works, step-by-step:

1. Building the World Brick by Brick (Incremental Construction)

If you ask an AI to build a complex 3D city in one go, it will likely crash or make a mess.

The Paper's Trick: CauSim asks the AI to build the world one room at a time.
The Analogy: Imagine building a massive LEGO castle. Instead of dumping 10,000 bricks and hoping they stick, you build one small tower, check if it stands, then add the next tower, check again, and so on.
Why it works: By building the "Causal Simulator" (a computer program that simulates cause-and-effect) incrementally, the AI ensures every new piece fits perfectly with the old ones. This allows them to create incredibly complex systems (with many variables) that would be impossible to generate in a single step.

2. Translating Between "Human Talk" and "Computer Code"

The paper solves the "Language vs. Code" problem by acting as a universal translator.

Formalizing (Human $\to$ Code): The AI takes a messy, non-executable description (like a medical guideline) and translates it into a strict Python program. Now, the computer can run it and get a definite answer.
Informalizing (Code $\to$ Human): The AI takes a strict Python program and turns it back into a natural language story.
The Benefit: This creates a loop. The AI can generate infinite "What-If" scenarios in code, run them to get the correct answers, and then turn those scenarios into text to teach itself how to reason in human language.

3. The Infinite Answer Key

Because the AI built the simulator itself, it knows the answer key.

In the real world, we don't know if Drug X cures Disease Y.
In the CauSim world, the AI defines the rules. It says, "In this simulation, Drug X always shrinks Tumor Y."
It then generates millions of "What-If" questions based on these rules, runs the code to get the answer, and uses that data to train the model. It turns a "scarce-label problem" (not enough data) into a "scalable, supervised one" (infinite data with perfect answers).

What Did They Discover? (The Results)

The paper ran four main experiments to see if this "self-made simulator" actually helps the AI think better.

1. Generalization (The "Transfer" Test)

The Setup: They trained the AI on a simulator using nonsense words (e.g., "If variable A increases, variable B decreases"). The AI didn't know what A or B meant.
The Result: When they tested the AI on real medical terms (e.g., "If Drug A increases, Tumor B decreases"), the AI performed much better.
The Takeaway: The AI didn't just memorize medical facts; it learned the logic of cause-and-effect. It learned the "grammar" of causality, which it could then apply to new, real-world topics.

2. The Curriculum Effect (Learning by Difficulty)

The Setup: They tested if the AI learns better if it starts with simple simulators (few variables) and moves to complex ones (many variables), or if it just gets dumped into the deep end.
The Result: The AI learned best when it followed a curriculum—starting small and getting harder.
The Takeaway: Just like a human student, the AI needs to learn to walk before it can run. Building complex causal reasoning requires a step-by-step approach.

3. Self-Improvement (The "Bootstrapping" Test)

The Setup: Can an AI improve itself by generating its own training data?
The Result: Yes. An AI model generated its own simulators, trained on them, and became better at answering causal questions.
The Takeaway: The AI can act as its own teacher. It doesn't need a human to write the "What-If" questions; it can invent them, solve them, and learn from the solutions.

4. Data Augmentation (Supercharging Existing Knowledge)

The Setup: They took a real-world dataset (NIH Stroke Scale) that had very few examples of "What-If" scenarios. They converted the rules of this dataset into a simulator and generated 1,000 new examples.
The Result: The AI trained on this "augmented" data performed significantly better on the original real-world questions than the AI trained only on the small original dataset.
The Takeaway: You can take a small, real-world dataset and use a simulator to "fill in the blanks," creating a massive training set that helps the AI understand the real world better.

Summary

CauSim is a framework that helps AI learn to think like a scientist. Instead of waiting for humans to provide perfect "What-If" answers (which are rare and expensive), the AI builds its own virtual laboratories. It constructs these labs brick-by-brick to ensure they are stable, translates them between human language and computer code, and runs millions of experiments to generate its own "Answer Key."

The result is an AI that doesn't just memorize facts, but actually learns the underlying logic of cause and effect, allowing it to answer complex "What-If" questions with much greater accuracy.

Technical Summary: CauSim: Scaling Causal Reasoning with Increasingly Complex Causal Simulators

1. Problem Statement

Despite achieving superhuman performance in mathematics, coding, and knowledge-intensive tasks, Large Language Models (LLMs) continue to struggle with causal reasoning. The paper identifies three core obstacles preventing LLMs from mastering this capability:

Scale (C1): As the number of variables in a causal system increases (e.g., side effects, patient characteristics), tracing all interactions and dependencies becomes computationally and cognitively challenging.
Representation (C2): Causal knowledge is frequently expressed in non-executable forms, such as natural language or diagrams. To answer queries, models must correctly extract and compose underlying causal relationships, a process prone to error when the representation is unstructured.
Lack of Ground-Truth Supervision (C3): Causal reasoning requires answers to interventional and counterfactual queries. However, ground-truth answers for these queries are inherently scarce in real-world data; interventional data is costly to obtain, and counterfactual outcomes are unobservable. This scarcity makes direct supervised training for causal inference infeasible.

The central research question is: How can we obtain verifiable supervision for causal reasoning across varying scales and representations?

2. Methodology: The CauSim Framework

The authors introduce CauSim, a framework designed to transform causal reasoning from a scarce-label problem into a scalable, supervised one. The core innovation is the construction of increasingly complex causal simulators—executable Structural Causal Models (SCMs) built incrementally by LLMs.

2.1 Incremental Construction of SCMs

To address the Scale (C1) challenge, CauSim avoids one-shot generation of complex models, which often leads to structural errors. Instead, it employs a four-stage, iterative procedure:

Specification: An LLM specifies an initial executable SCM (Python code).
Planning: The LLM is provided with a semantic view (functional summaries and graph structure) of the current SCM and plans an edit by proposing a new structural mechanism ( $f_i$ ) and exogenous sampler ( $U_i$ ), defining their parents and children.
Execution: The LLM implements the update using only localized context (full code for children, docstrings for parents) to ensure the new node integrates correctly without breaking existing logic.
Verification: Deterministic checks enforce acyclicity, connectivity, and runtime executability. If checks fail, the edit is rejected and retried.

This incremental approach allows the generation of globally complex systems (up to 10+ nodes in experiments) while maintaining structural validity.

2.2 Cross-Representation Translation

To address the Representation (C2) challenge, CauSim operates bidirectionally between executable and non-executable forms:

Formalization (Informal $\to$ Executable): The framework translates unstructured causal descriptions (e.g., clinical notes) into executable Python SCMs. This enables the generation of ground-truth answers for queries that would otherwise be unsupervisable.
Informalization (Executable $\to$ Informal): Conversely, executable SCMs are translated back into natural language. This allows for supervised training on non-executable representations, leveraging the ground truth generated by the executable version.

2.3 Query Generation and Training

Once a verified SCM is constructed, the framework samples causal queries covering four types: Deduction, Intervention, Abduction, and Counterfactuals.

Data Generation: The framework generates effectively unlimited supervised data by executing the SCM to obtain ground-truth answers.
Training Pipeline: The authors employ a rejection-sampling fine-tuning pipeline (similar to STaR/RAFT). The base model generates answers; only those matching the verifiable ground truth are retained for Supervised Fine-Tuning (SFT).
Curriculum Scaling: Training is conducted across increasing levels of SCM complexity (number of nodes) to study the effects of curriculum design.

3. Key Contributions

CauSim Framework: A novel method for constructing increasingly complex, executable causal simulators that scale across both system complexity and representation types.
Systematic Empirical Study: A comprehensive evaluation demonstrating that:
- Training on executable SCMs generalizes to non-executable representations and out-of-distribution semantic content.
- Performance gains are consistent with curriculum scaling (progressive difficulty) and increased data volume.
- LLMs can self-improve by generating and reasoning over their own causal simulators.
- Existing domain knowledge can be formalized into executable SCMs to augment datasets and improve performance on original distributions.

4. Experimental Results

The authors evaluated CauSim using Qwen2.5 models and GPT-5 for generation, focusing on "Nonsense" variables (4-letter strings) to disentangle causal reasoning from prior knowledge, as well as medical domains (NIH Stroke Scale) and external benchmarks (bnlearn, GSM8K).

Generalization (Q1): Models trained on executable SCMs with meaningless variables significantly outperformed base models on unseen medical terms and non-executable (natural language) representations. This suggests the training teaches causal logic rather than memorizing domain facts.
Scaling Effects (Q2):
- Curriculum: A progressive curriculum (training on small SCMs before large ones) consistently outperformed training on all complexities at once or training only on easy/hard subsets.
- Data Volume: Increasing the number of causal queries per SCM (from 5 to 135) led to consistent accuracy improvements, particularly for complex SCMs.
Self-Improvement (Q3): An LLM fine-tuned on SCMs generated by itself (Qwen2.5-7B) achieved performance comparable to models trained on SCMs generated by stronger models (GPT-5), demonstrating the viability of bootstrapping causal reasoning capabilities.
Data Augmentation (Q4): Formalizing the NIH Stroke Scale (NIHSS) into an executable SCM allowed the generation of 1,000 additional interventional and counterfactual samples. Models trained on this augmented data significantly outperformed those trained only on the original 100 samples, with gains increasing as SCM complexity grew.

5. Significance and Claims

The paper claims that CauSim provides a scalable solution to the data scarcity problem in causal reasoning. By leveraging the executability of code, the framework creates a "verifiable training environment" where ground-truth answers are mechanically derived rather than human-curated.

The authors emphasize that their work focuses on improving causal reasoning capabilities rather than merely evaluating them. They argue that the incremental construction of simulators is essential for maintaining fidelity in complex systems, a feat difficult to achieve with one-shot generation.

Limitations and Modesty:
The authors are modest regarding the implications of their findings. They explicitly state that:

High accuracy on causal queries does not guarantee the model has learned invariant causal mechanisms or recovered the true underlying graph; the model may still rely on predictive shortcuts.
Self-improvement is bounded by the diversity and quality of the generator's output; recursive self-improvement without external grounding risks model collapse or bias reinforcement.
Current experiments are primarily deterministic; extending to stochastic reasoning where counterfactuals are ambiguous remains future work.

In conclusion, CauSim demonstrates that turning causal reasoning into a scalable, supervised problem via executable simulators is a viable path toward enhancing LLMs' ability to handle complex "what-if" scenarios across diverse representations.