Linear-Time Primitives for Algorithm Development in Graphical Causal Inference

2025-06-18

AI Summary

In graphical causal inference, traditional methods—such as moralization and latent variable projection—exhibit computational complexity equivalent to Boolean matrix multiplication, rendering them inefficient. This paper introduces CIfly, the first framework unifying core tasks—including d-separation, adjustment set discovery, and instrumental variable identification—as online reachability queries over a dynamically maintained state-space graph, enabling linear-time algorithmic primitives. We formally characterize the computational essence of classical approaches and propose a novel, formally verifiable rule-table paradigm. Implemented in Rust for high performance, CIfly supports Python/R bindings, declarative text-based rule parsing, and just-in-time compilation. Experiments demonstrate that CIfly significantly outperforms existing tools on standard benchmarks, achieving order-of-magnitude speedups on large-scale graphs. The open-source implementation is publicly available.

Technology Category

• Reasoning under Uncertainty: Causality
• Machine Learning: Causal Learning
• Knowledge Representation and Reasoning: Action, Change, and Causality

Application Category

• Graph Algorithms and Modeling for the Web: Efficient manipulation of static and dynamic Web-related graphs
• Search and Retrieval-Augmented AI: Web learning to rank, online learning, and counterfactual learning for ranking
• Semantics and Knowledge: Scalable techniques for the creation, curation, publication, maintenance, and consumption of large, Web-based, structured, reusable, knowledge graphs and ontologies

Abstract

We introduce CIfly, a framework for efficient algorithmic primitives in graphical causal inference that isolates reachability as a reusable core operation. It builds on the insight that many causal reasoning tasks can be reduced to reachability in purpose-built state-space graphs that can be constructed on the fly during traversal. We formalize a rule table schema for specifying such algorithms and prove they run in linear time. We establish CIfly as a more efficient alternative to the common primitives moralization and latent projection, which we show are computationally equivalent to Boolean matrix multiplication. Our open-source Rust implementation parses rule table text files and runs the specified CIfly algorithms providing high-performance execution accessible from Python and R. We demonstrate CIfly's utility by re-implementing a range of established causal inference tasks within the framework and by developing new algorithms for instrumental variables. These contributions position CIfly as a flexible and scalable backbone for graphical causal inference, guiding algorithm development and enabling easy and efficient deployment.

Problem

• Efficient algorithmic primitives for graphical causal inference
• Reducing causal reasoning tasks to reachability in state-space graphs
• Providing a scalable backbone for causal inference algorithm development

Innovation

• Reachability as reusable core operation
• Linear-time rule table schema
• Open-source Rust implementation