CIfly · Efficient Algorithms for Causal Inference

What is CIfly?

CIfly is a framework for developing and writing causal inference algorithms.

Python and R support:

CIfly algorithms can be developed language-independent and easily be called from both Python and R.

Concise specification:

Algorithms are specified in rule tables to avoid boilerplate and put the causal logic in the center.

Performance:

CIfly runs in linear time and its Rust implementation enables further speedups over native R or Python code.

Installation

CIfly can be installed via pip in Python and from R-universe in R (a CRAN submission is planned).

# Python installation with pip
pip install ciflypy

In Python, the installation should work out-of-the-box without relying on any further dependencies. In R, if the package is build on your system, as is the case for Linux distributions, the Rust toolchain needs to be installed.

Example

As a "Hello World" example, we show how to test d-separation with CIfly. The CIfly algorithm specified by the following rule table returns all nodes d-connected to set X given set Z.

dsep.txt

EDGES --> <--
SETS X, Z
START <-- AT X
OUTPUT ...

--> | <-- | current in Z
... | ... | current not in Z

The rule table can be embedded into the code as a multi-line string or loaded via file path such as in the implementation below that tests d-separation using Python and R.

import ciflypy as cf

dsep_table_path = "./dsep.txt"

def test_dsep(G, x, y, Z):
      R = cf.reach(G, {"X": x, "Z": Z}, dsep_table_path)
      return y not in R

# for graph 0 -> 1 -> 2, test whether 0 is d-separated from 2 by 1
print(test_dsep({"-->": [(0, 1), (1, 2)]}, 0, 2, [1]))

library("ciflyr")

dsepTablePath <- "./dsep.txt"

test_dsep <- function(G, x, y, Z) {
      R <- reach(G, list("X" = x, "Z" = Z), dsepTablePath)
      return (!(y %in% R))
}
# for graph 1 -> 2 -> 3, test whether 1 is d-separated from 3 by 2
print(test_dsep(list("-->" = rbind(c(1, 2), c(2, 3))), 1, 3, c(2)))

Find more details on this example and how to use CIfly in our documentation.

Applications

Beyond fundamental tasks such as deciding d-separation, a large class of problems in causal inference can be solved flexibly using CIfly. We present a number of selected applications.

Verifying adjustment sets (CPDAG)

Test whether a set of variables can be used for adjustment for a given CPDAG and sets of treatment and outcome variables.

References:

Perković et al. (2018)

Ruletables

We believe that causal inference software should be transparent, reusable and easy-to-adapt to the users needs. At the core of our framework lie rule tables which ensure these properties. We provide ruletables for many basic primitives.

Ancestors (ADMG)

EDGES --> <--, <->
SETS X
START <-- AT X
OUTPUT ...

... | <-- | true

Backdoor-connected (CPDAG)

EDGES --> <--, ---
SETS X, C, W
START <-- AT X
OUTPUT ...

--> | <-- | current in W
--- | --- | current not in W
... | --> | current not in W and (current not in X or next not in C)
<-- | ... | current not in W

Forbidden-path connected (CPDAG)

EDGES --> <--, ---
SETS X, W
COLORS pass, yield
START --> [pass] AT X
OUTPUT ... [yield]

... [pass]  | ---, --> [pass]  | next not in X and next not in W
... [pass]  | ---, --> [yield] | next not in X and next in W
... [yield] | ---, --> [yield] | next not in X

Non-causal connected (CPDAG)

EDGES --> <--, ---
SETS X, W
COLORS init, poss-causal, non-causal
START ... [init] AT X
OUTPUT ... [non-causal]

... [init]        | ---, --> [poss-causal] | next not in X
... [init]        | <--      [non-causal]  | next not in X
--> [...]         | <--      [non-causal]  | next not in X and current in W
--- [poss-causal] | ---      [poss-causal] | next not in X and current not in W
... [poss-causal] | -->      [poss-causal] | next not in X and current not in W
--- [non-causal]  | ---      [non-causal]  | next not in X and current not in W
<-- [non-causal]  | ...      [non-causal]  | next not in X and current not in W
... [non-causal]  | -->      [non-causal]  | next not in X and current not in W

Not-amenable (CPDAG)

EDGES --> <--, ---
SETS X
COLORS init, yield
START ... [init] AT X
OUTPUT ... [yield]

... [init]  | ---      [yield] | next not in X
... [yield] | ---, --> [yield] | next not in X

Optimal IV (ADMG)

EDGES  --> <--, <->
SETS   S, D, F
COLORS pass, yield
START  <-- [pass] AT S
OUTPUT ... [yield]

...         | -->              | false
<-- [pass]  | <--      [pass]  | next in D     and next not in F
<-- [pass]  | <--, <-> [yield] | next not in D and next not in F
<-> [yield] | <--, <-> [yield] | next not in D and next not in F

Theoretical Foundations

CIfly is based on causality-specific reductions to reachability, which we formally introduce in this paper. The mapping to the reachability input and back to the causal domain is constrained such that the overall algorithm runs in linear time.

A declarative framework for designing efficient causal inference algorithms