CauSim: Scalable Causal Simulation Framework

• CauSim is a framework that uses executable structural causal models to scale and automate causal reasoning.
• It incrementally builds complex simulators with dedicated verification and curriculum-based scaling to enhance model performance.
• The framework bridges formal code with natural language, enabling deduction, intervention, abduction, and counterfactual analysis for improved LLM supervision.

CauSim most commonly denotes a framework for scaling causal reasoning in LLMs by constructing increasingly complex, executable structural causal models (SCMs) and using them to generate verifiable supervision for causal queries (Astorga et al., 9 May 2026). Its central claim is that causal reasoning need not remain a scarce-label problem: if causal knowledge can be formalized as executable code, then deduction, intervention, abduction, and counterfactual questions become automatically answerable by simulation, and those answers can supervise models across both formal and natural-language representations. In this sense, CauSim is not merely a simulator, but a supervision pipeline that couples SCM construction, representation translation, query generation, and verification.

1. Definition and intellectual context

CauSim was introduced to address a persistent asymmetry in machine reasoning. LLMs may perform strongly on mathematics and coding, yet causal reasoning remains difficult because causal systems are complex, often specified in non-executable forms, and associated with intrinsically scarce labels for interventional and especially counterfactual questions (Astorga et al., 9 May 2026). CauSim responds by constructing executable SCM-based simulators, incrementally building them with LLMs, and using those simulators to produce mechanically verified answers at scale.

The framework is organized around two research questions. The first is how to construct increasingly complex causal simulators while preserving executability and correctness. The second is what such simulators enable once available: generalization across representations, curriculum-based scaling, self-improvement through self-generated data, and augmentation of existing domain knowledge. This places CauSim at the intersection of program synthesis, causal inference, and LLM training.

A recurrent misconception is that CauSim is chiefly a benchmark or a domain simulator. Its actual emphasis is broader and more abstract: it uses executable SCMs as environments for supervision. This distinguishes it from domain-specific causal simulators that target estimator benchmarking or scene generation, such as network-based SEM simulation in simcausal (Sofrygin et al., 2017), controllable mixed-type tabular generation in CausalMix (Zhang et al., 3 Mar 2026), physics-based production-line simulation in CausalMan (Tagliapietra et al., 18 Feb 2025), multi-agent driving environments in CausalCity (McDuff et al., 2021), and configurable high-fidelity CRL simulation in CausalVerse (Chen et al., 15 Oct 2025). A plausible implication is that CauSim should be understood as a meta-framework for causal supervision, rather than as a simulator tied to one scientific domain.

2. Structural causal semantics

CauSim is grounded in the standard SCM formalism. An SCM is written as

$M = \langle U, p(u), V, F \rangle,$

where $U = \{U_i\}_{i=1}^m$ are exogenous variables with distribution $p(u)$, $V = \{V_i\}_{i=1}^n$ are endogenous variables, and $F = \{f_i\}_{i=1}^n$ are structural assignments. Each endogenous variable is generated by

$V_i := f_i(Pa_i, U_i),$

with $Pa_i \subset V \setminus \{V_i\}$, under acyclicity and autonomous mechanisms (Astorga et al., 9 May 2026).

Within this formalism, interventions replace structural assignments. CauSim adopts Pearl’s do-semantics: setting $X := x$ yields the interventional distribution

$P(Y \mid do(X = x)).$

When the SCM is executable, this distribution is obtained by running the modified program over the exogenous support. For counterfactuals, CauSim uses the standard abduction–action–prediction semantics: infer exogenous contexts consistent with factual evidence, intervene on the structural equations, and predict with the same exogenous values held fixed across factual and counterfactual worlds.

The framework explicitly supports common causal estimands and identification formulas when relevant. These include the average treatment effect,

$ATE = E[Y \mid do(X=1)] - E[Y \mid do(X=0)],$

the back-door adjustment,

$U = \{U_i\}_{i=1}^m$0

and the front-door adjustment,

$U = \{U_i\}_{i=1}^m$1

However, CauSim does not run the ID algorithm or do-calculus. A common misunderstanding is therefore corrected by the framework itself: simulation-based verifiability under a specified SCM does not imply identifiability from observational data alone (Astorga et al., 9 May 2026).

A small mediator example used in the framework’s exposition makes this operational. With binary variables $U = \{U_i\}_{i=1}^m$2, $U = \{U_i\}_{i=1}^m$3, and $U = \{U_i\}_{i=1}^m$4, exogenous Bernoulli noise, and structural equations

$U = \{U_i\}_{i=1}^m$5

the interventional contrast satisfies

$U = \{U_i\}_{i=1}^m$6

For $U = \{U_i\}_{i=1}^m$7 and $U = \{U_i\}_{i=1}^m$8, this gives $U = \{U_i\}_{i=1}^m$9. The same SCM also illustrates counterfactual verification by support enumeration: under factual evidence $p(u)$0, the counterfactual outcome under $p(u)$1 has support $p(u)$2 unless further exogenous values are observed (Astorga et al., 9 May 2026).

3. Incremental construction of increasingly complex simulators

A defining feature of CauSim is that SCMs are not generated monolithically. They are built incrementally, node by node or mechanism by mechanism, because one-shot generation degrades sharply as scale and topological complexity increase (Astorga et al., 9 May 2026). The construction process separates into specification, planning, execution, and verification.

In the specification stage, an LLM proposes a small initial SCM consistent with an informal source or a synthetic topology. In planning, the model proposes a new mechanism $p(u)$3, its exogenous variable $p(u)$4, its parent set, and its children, while respecting topology and acyclicity. In execution, it implements the new mechanism and updates only the affected child functions, with parent semantics supplied locally through docstrings. In verification, deterministic checks enforce acyclicity, connectedness, executability, single exogenous parent per structural node, and topology compliance.

Complexity is scaled along several axes: number of endogenous variables, graph density, topology class, path length, presence of colliders and mediators, and mechanism class. The reported topologies include chains, stars, inverted stars or colliders, layered DAGs, trees, and polytrees. Mechanisms may involve logical conditionals, categorical states, nonlinearity, deterministic structural functions, discrete exogenous supports, and optional stochasticity through exogenous noise. The framework generally excludes latent confounding and feedback loops unless they are explicitly introduced (Astorga et al., 9 May 2026).

This incremental protocol is coupled to curriculum scaling. Simulators are grown from simple to complex and used to train models in blocks such as $p(u)$5, $p(u)$6, $p(u)$7, and $p(u)$8. The reported training policies include semi-online block curriculum, at-once ordered training, Easy-Only, and Hard-Only, with the semi-online curriculum performing best. This suggests that simulator complexity functions not only as data generation but also as a controllable pedagogical variable.

4. Cross-representation supervision and data generation

CauSim’s second major contribution is representation bridging. It supports formalization from informal causal descriptions into executable code, and informalization from executable SCMs into natural-language descriptions (Astorga et al., 9 May 2026). The former turns non-executable causal knowledge into simulation-ready artifacts; the latter turns code-verified answers into supervision for natural-language tasks.

Formalization proceeds incrementally to preserve faithfulness. Informal knowledge such as text, diagrams, or rules is translated into Python SCMs. Informalization then produces verbalized graphs, mechanism summaries, and narrative descriptions. To test whether this translation is effectively lossless, the natural-language representation is mapped back into code and re-verified for semantic consistency and execution. This round-trip constraint is central to CauSim’s claim that it can supervise models in distributions that were previously difficult to label.

Once an SCM is executable, CauSim generates four classes of causal queries. Deduction enumerates completions of missing exogenous variables and forward-propagates to collect the support of possible endogenous outputs. Intervention applies $p(u)$9 to selected endogenous variables and computes the resulting support. Abduction identifies exogenous assignments consistent with observed endogenous evidence. Counterfactual reasoning combines abduction with intervention and prediction while holding exogenous values fixed. In deterministic tasks, verification reduces to the unique output; in stochastic tasks, outputs are accepted by support membership (Astorga et al., 9 May 2026).

The framework also incorporates data augmentation. It varies functional forms, topologies, exogenous supports, and query compositions; produces multiple paraphrases of the same mechanism; and formalizes external knowledge such as NIHSS into executable causal tasks. Self-improvement is handled in a distinctive manner: a target LLM generates SCMs, verification filters invalid simulators, and labels are computed by execution rather than by direct pseudo-labeling. This means that generator errors do not propagate through unverified labels, although the generator still shapes the diversity and richness of the resulting training distribution.

5. Empirical results and scaling behavior

CauSim was evaluated primarily with Qwen2.5-3B-Instruct for training and evaluation, GPT-5-family models for generation baselines, and Qwen2.5-7B-Instruct for self-improvement studies; training used rejection-sampling SFT in an STaR/RFT/RAFT-style regime on $V = \{V_i\}_{i=1}^n$0A100 GPUs, with sequential curriculum across $V = \{V_i\}_{i=1}^n$1, $V = \{V_i\}_{i=1}^n$2, $V = \{V_i\}_{i=1}^n$3, and $V = \{V_i\}_{i=1}^n$4 (Astorga et al., 9 May 2026). For nonsense-code training, the framework used 10-node SCMs with three topologies—chains, inverted stars, and layered DAGs—with 400 SCM IDs per topology, 10 incremental versions per SCM, and 5 queries per version.

The empirical pattern is consistent across generation, supervision, and transfer. Incremental SCM generation scales more reliably than one-shot generation: for formalizing external NIHSS knowledge, incremental generation succeeded in 52/100 trials, versus 20/100 for one-shot generation. For one-shot 20-node SCMs, dominant failure modes were disconnected graphs for Qwen, with 75/100 failures, and wrong node count for GPT-5, with 44/100 failures. These results support the framework’s core design choice that globally complex simulators should be constructed incrementally rather than synthesized all at once.

Transfer across representations is one of the framework’s strongest empirical claims. On informal medical tasks, average pass@1 at 10 nodes increased from 0.02 in the base model to 0.155 after training on formal-nonsense SCMs, and to 0.205 after training on formal-to-informal nonsense data. For counterfactuals at 10 nodes, the same progression was 0.02 to 0.17 to 0.25; for interventions, 0.02 to 0.14 to 0.16. The reported absolute improvements of 0.14–0.32 across sizes are presented as typical.

External benchmark transfer shows the same tendency. On formalized bnlearn SCMs, overall pass@1 on ASIA increased from 0.040 to 0.155, on CANCER from 0.065 to 0.115, and on SURVEY from 0.010 to 0.055. On Re-Imagine-derived GSM8K SCMs, overall performance increased from 0.331 to 0.396, with counterfactual performance improving from 0.231 to 0.364. On extremely informal GSM8K verbalizations, average causal pass@1 increased from 0.138 to 0.194, counterfactual pass@1 from 0.122 to 0.189, and intervention pass@1 from 0.153 to 0.199.

Scaling with data volume is similarly monotone in the reported experiments: increasing queries per SCM version from 5 to 15 to 45 to 135 yields consistent pass@1 gains across intervention and counterfactual tasks. Self-improvement also appears viable. With 250 SCMs and 5 instances per SCM, counterfactual pass@1 at 6 nodes increased from 0.157 in the base model to 0.213 with self-generated simulators, 0.218 with GPT-5-mini-generated simulators, and 0.188 with GPT-5-generated simulators. Another practical result concerns domain augmentation: expanding 100 NIHSS instances with 1000 simulator-generated instances improved pass@8 by 0.16–0.23 absolute across sizes, and a separate study reported base accuracy of approximately 0.19–0.26 versus augmented accuracy of approximately 0.35–0.42 for sizes 4–9.

6. Scope, ambiguity, limitations, and broader significance

The name “CauSim” is not unique in the arXiv record. It has been used or retrospectively mapped onto several different simulation systems, including the network-causal simcausal workflow (Sofrygin et al., 2017), the calibrated Simu5G automation layer for 5G studies (Boeira et al., 2024), and several other domain simulators in causal or simulation-adjacent settings. A plausible implication is that the label has evolved into a generic shorthand for causal simulation. Nevertheless, in contemporary causal-reasoning research, the best-defined use of the term refers to the LLM-centered SCM framework of 2026 (Astorga et al., 9 May 2026).

Its limitations are stated explicitly. Domain realism remains a major challenge: rich scientific mechanisms such as PK/PD dynamics, circuits, or robotics are difficult to formalize faithfully in logic-based code. Although labels are verified by execution, recursive self-generation can narrow the training distribution toward generator biases, reducing diversity and risking synthetic-data drift. Simulation under a specified SCM does not solve identifiability from observational data. Models may also overfit simulator artifacts, and ethical risks arise if synthetic causal supervision is treated as sufficient grounding for real-world decisions.

The present regime also makes structural assumptions. It generally enforces acyclicity, one exogenous parent per node, and excludes correlated exogenous noise and feedback loops unless explicitly modeled. The framework’s own future directions therefore emphasize richer real-world mechanisms, hybrid neuro-symbolic constraints, explicit identification tools, stochastic and partially observed counterfactual tasks, and diversity safeguards for self-improvement (Astorga et al., 9 May 2026).

Within the broader history of causal simulation, CauSim’s distinctive contribution is not simply that it simulates causal systems, but that it turns executable causal simulation into a scalable source of verified supervision for LLMs. Earlier simulators supplied controlled environments for estimator validation, intervention studies, or representation learning in specific domains (Sofrygin et al., 2017, McDuff et al., 2021, Tagliapietra et al., 18 Feb 2025, Chen et al., 15 Oct 2025, Zhang et al., 3 Mar 2026). CauSim extends that logic to the training of causal reasoning systems themselves. This suggests a shift in the function of simulators within machine learning: from evaluation infrastructure to a primary substrate for causal supervision.