📈 economics

CausalForge: A Formally Grounded, Self-Improving Agentic Framework for Automated Research in Causal Inference

CausalForge is a formally grounded, self-improving agentic framework that automates causal inference research by combining the Lean-based Causalean library with a pipeline that generates, formalizes, and audits proofs to ensure the reliability of machine-checked results.

Original authors: Jiyuan Tan, Vasilis Syrgkanis

Published 2026-07-27

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Jiyuan Tan, Vasilis Syrgkanis

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 a detective trying to solve a mystery about cause and effect. You want to know: "If I take this medicine, will I get better?" or "Did that rain actually cause the flood?" In the world of science, this is called causal inference. It's different from just watching things happen; it's about figuring out what would happen if we changed something. For a long time, scientists have used math to prove these cause-and-effect stories are true. But math is hard, and one tiny mistake in a proof can make the whole story false.

Recently, computers got really good at writing stories and solving puzzles using something called Large Language Models (LLMs). These are like super-smart robots that can read almost everything ever written and then write their own papers, proofs, and theories. But here's the catch: these robots are great at sounding confident, but they are terrible at checking their own work. They often make up facts, invent numbers, or write proofs that look perfect but are actually nonsense. If we let a robot write a scientific paper and then ask another robot to check it, they might just nod at each other and say, "Yep, that's true!" even when it's completely wrong. This is a big problem because in science, being wrong can lead to bad decisions.

This is where a new project called CausalForge comes in. Think of it as a "self-improving robot scientist" designed specifically to do research in causal inference, but with a very strict safety net. Instead of just trusting a robot to check another robot's homework, CausalForge uses a magical, unbreakable math tool called Lean (a proof assistant). Lean is like a super-strict teacher who will never accept an answer unless every single step is logically perfect. If the math doesn't add up, Lean says "Nope!" and refuses to sign off.

But there's a second problem: even if the math is perfect, the robot might be proving the wrong thing. Imagine a robot proving that "All cats are dogs" with perfect logic. The math is sound, but the claim is silly. CausalForge solves this by adding a "Statement Audit." It's like a translator that checks: "Did the robot actually prove what it said it was going to prove?"

So, what did CausalForge actually do? The team built two main parts. First, they created a massive library called Causalean, which contains over 7,000 pre-checked, perfect math facts about cause and effect. It's like a giant toolbox where every tool has already been tested to make sure it works. Second, they built a robot pipeline called CausalSmith. This robot can pick a research topic, try to invent a new theorem, write the proof in the Lean language, and then have the system check if the proof is real and if the claim matches the math.

The results are a mix of success and reality checks. Out of 123 attempts the system made to discover new things, 9 were fully accepted as correct, novel, and machine-verified. The system was surprisingly good at finding small, technical gaps in existing research (like fixing a tiny error in a formula) but struggled when asked to come up with entirely new, big ideas from scratch. The paper shows that while we can't fully trust robots to judge their own creativity yet, we can trust them to do the heavy lifting of writing and checking math, as long as we have a strict "magic teacher" (Lean) and a careful "translator" (the audit) watching over them. It's not a magic wand that solves all science problems, but it's a powerful new way to make sure our scientific stories are actually true.

Technical Summary: CausalForge

Problem Statement

Automating theoretical research in causal inference faces a critical bottleneck: the reliable evaluation of generated results. While Large Language Models (LLMs) can rapidly generate conjectures, proofs, and papers, they struggle to evaluate their own correctness. Empirical studies indicate that LLM reviewers are unreliable, often accepting fabricated papers at rates close to chance and failing to distinguish between correct and incorrect theorems.

Relying solely on formal verification (e.g., via the Lean 4 proof assistant) is insufficient for two reasons:

Cost: Formalizing results from first principles is labor-intensive. Automated discovery requires a reusable, verified library of causal theorems to avoid rebuilding standard theory for every run.
Faithfulness: A machine-checked proof guarantees that a formal statement follows from its assumptions, but it does not guarantee that the formal statement faithfully captures the intended scientific claim. An LLM might produce a type-checking proof for a vacuous definition, a theorem with contradictory hypotheses, or a result where an unproven step was substituted with an axiom.

Methodology: The CausalForge Framework

CausalForge is a self-improving agentic framework designed to automate theoretical research in causal inference. It integrates a foundational formal library with a multi-stage pipeline that emphasizes both proof soundness and statement faithfulness.

Core Components

Causalean (The Library):
- A foundational Lean 4 library containing 7,035 machine-checked declarations covering graphical models, structural causal models (SCMs), potential outcomes, identification, estimation, and asymptotic statistics.
- Built with LLM assistance under human design and review, it provides a retrieval interface for agents to reuse verified primitives (e.g., backdoor adjustment, double machine learning estimators).
- It enforces strict separation between the core library and pipeline-specific lemmas, allowing the library to grow through a feedback loop.
CausalSmith (The Pipeline):
- A deterministic state machine executing four stages: Discovery, Formalization, Proof Construction, and Presentation.
- Logic Graph: The central artifact is a logic graph where nodes represent statements (definitions, lemmas, theorems) and edges represent dependencies. This graph tracks the "critical path" of gated nodes (unproven substrate) versus cited nodes (borrowed results).
- Discovery: Selects research topics (either user-supplied or autonomously selected from literature gaps) and proposes natural-language results.
- Formalization & Proof: Maps the logic graph to Lean 4 declarations, fills proof obligations using Causalean retrieval, and constructs proofs.
- Statement Audit (The Core Innovation): A dedicated "statement match" gate that verifies whether the formal Lean 4 declaration logically matches the intended natural-language claim. This involves:
  - Checking for "unproved shortcuts" (e.g., sorry, admit, hidden axioms).
  - Detecting "vacuity" (definitions reducing to True, unsatisfiable hypotheses).
  - Ensuring "faithfulness" via back-translation: converting the intended claim into a Lean-shaped hypothesis/conclusion list and comparing it against the formal declaration to ensure logical equivalence (neither stronger nor weaker).
- Convergence Review: A dual-model review of the entire frozen graph before presentation to catch any drift in statement meaning.
Self-Improvement Mechanism:
- Run Record: Every run (accepted, downgraded, or failed) is logged. Failed runs prevent future agents from repeating dead ends; downgraded runs refine novelty targets.
- Library Feedback: When a run requires a new, load-bearing lemma not present in Causalean, the system enters "study mode" to prove it. Once verified and reviewed for reusability, the lemma is promoted into Causalean, expanding the library for future runs.

Key Contributions

Causalean Library: A broad, machine-checked formalization of the causal inference toolkit (7,035 declarations) that serves as a verified foundation for automated discovery.
CausalSmith Pipeline: An end-to-end system that autonomously selects topics, proposes results, formalizes them, proves them in Lean 4, and audits the faithfulness of the formal statements.
Statement Audit Mechanism: A novel approach to bridging the gap between formal verification and scientific intent. By auditing the logic graph node-by-node, the system ensures that a kernel-accepted proof corresponds to the specific scientific claim being made, rather than just a syntactically valid theorem.
Empirical Evaluation: A catalogue of 123 recorded autonomous research runs, including 9 accepted results that close technical gaps in existing literature.

Results

The system was evaluated using 123 recorded runs:

Outcomes: 9 runs were accepted, 44 were downgraded (sound but lacking novelty), and 70 failed (rejected at proposal or mathematical derivation).
Performance Patterns: The system excels in Statistical Theory, Experimentation, and Panel Methods, where it successfully closed technical gaps (e.g., matching upper bounds to known lower bounds). It struggled in Exact Identification, Partial Identification, and SCM clusters, where the contribution requires a new conceptual idea rather than technical refinement. In these areas, the system frequently produced results that were mathematically sound but reduced to known constructions (e.g., "generic Manski-style outer containment").
Flagship Result: The system successfully closed a minimax gap in Average Treatment Effect (ATE) estimation under high-dimensional discrete confounding. It constructed a computable estimator that closed a $\log^2$ -factor gap between known upper and lower bounds established by Zeng et al. [54]. This result was machine-checked, audited for statement faithfulness, and formally linked to the Lean 4 development.
Library Growth: The feedback loop successfully promoted 13 new lemmas (e.g., Bretagnolle–Huber affinity bounds, Fano's inequality) from specific runs into the general Causalean library.

Significance and Claims

The paper posits that CausalForge offers a new trust model for automated theoretical research by separating three distinct questions:

Proof Soundness: Guaranteed by the Lean 4 kernel.
Statement Faithfulness: Verified by the statement audit (comparing formal vs. intended claims).
Scientific Significance: Remains a human judgment, informed but not determined by the pipeline's novelty tiers.

The authors claim that this framework addresses the unreliability of LLM reviewers by grounding evaluation in formal verification while explicitly acknowledging the limits of automation regarding the meaning of theorems. The system demonstrates that automated agents can produce machine-checked, faithful causal theorems, particularly in domains where technical gaps are well-defined. However, the paper modestly notes that the current system is limited in generating truly novel conceptual ideas and that the reliability of the LLM-based novelty and faithfulness audits requires further rigorous study. The work does not claim to replace human researchers but to provide a formally grounded, self-improving tool for exploring the boundaries of causal inference theory.