Causal Graphs

Why Does This Exist?

In the early days of statistics, researchers tried to solve confounding by simply controlling for every variable they could measure. This "kitchen sink" approach to regression often makes things worse. Adding the wrong variable to a model can actively create spurious correlations that didn't exist in the raw data, completely destroying your ability to measure the true causal effect.

Causal graphs (specifically, Directed Acyclic Graphs, or DAGs) exist to solve this variable selection problem. They give us a visual, mathematical language to write down our assumptions about how data was generated. Once the graph is drawn, simple graphical rules tell us exactly which variables we must include in our model, and which variables we must exclude, to isolate the true causal effect.

Think of It Like This

Imagine a plumbing system where water flows through pipes from a source to a drain.

How It Actually Works

A causal graph consists of nodes (variables) and directed edges (arrows). An arrow from $A \rightarrow B$ means that changing $A$ physically or logically changes $B$. The graph must be acyclic, meaning you cannot follow arrows and end up back where you started; time only flows forward.

When we want to know the effect of a treatment $T$ on an outcome $Y$, we are looking for the direct and indirect causal paths that start at $T$ and end at $Y$ with all arrows pointing forward.

However, correlation can flow backwards. A path like $T \leftarrow Z \rightarrow Y$ creates a spurious correlation between $T$ and $Y$. This is a backdoor path.

The Backdoor Criterion

To find the true causal effect of $T$ on $Y$, we must block all spurious correlation while leaving all true causal paths open. We do this by applying the Backdoor Criterion. A set of variables $Z$ satisfies the backdoor criterion if:

1. No node in $Z$ is a descendant of $T$ (don't control for things that happen after the treatment).
2. $Z$ blocks every path between $T$ and $Y$ that contains an arrow pointing into $T$.

If we can observe and control for a set $Z$ that meets these conditions, then the conditional probability $P(Y | T, Z)$ equals the causal probability $P(Y | do(T))$.

d-separation

How do we know if a path is "blocked"? A path is blocked (d-separated) if it contains any of the following structures:

• A chain $A \rightarrow B \rightarrow C$, and we condition on the middle node $B$.
• A fork $A \leftarrow B \rightarrow C$, and we condition on the middle node $B$.
• A collider $A \rightarrow B \leftarrow C$, and we do not condition on the middle node $B$.

The collider is the trap. If two independent causes both influence a third variable, they are uncorrelated. But if you condition on that shared effect (the collider), you actively force the two causes to become correlated. This is why the "kitchen sink" regression approach fails: controlling for a collider opens a blocked path, introducing bias.

Show Me the Code

We can use the networkx library to draw a causal graph and visually inspect the paths, though in practice, specialized causal libraries like DoWhy handle the graphical identification for you.

1import networkx as nx2
3# Define the causal graph (Directed Acyclic Graph)4G = nx.DiGraph()5
6# Add edges: (Cause, Effect)7# Z is a confounder, W is a mediator, C is a collider8G.add_edges_from([9    ("Z", "Treatment"),10    ("Z", "Outcome"),11    ("Treatment", "W"),     # Causal path: Treatment -> W -> Outcome12    ("W", "Outcome"),13    ("Treatment", "C"),     # Collider: Treatment -> C <- Outcome14    ("Outcome", "C")15])16
17def check_backdoor(graph, treatment, outcome, conditioning_set):18    """19    A simplified check for whether controlling for a set blocks20    the spurious path T <- Z -> Y.21    """22    print(f"Conditioning on: {conditioning_set}")23    24    # 1. Did we condition on a descendant of treatment?25    descendants = nx.descendants(graph, treatment)26    for var in conditioning_set:27        if var in descendants:28            print(f"FAIL: {var} is caused by {treatment} (Mediator or Collider).")29            return False30            31    # 2. Did we block the confounder?32    if "Z" not in conditioning_set:33        print("FAIL: Confounder Z is unblocked. Spurious path remains.")34        return False35        36    print("SUCCESS: Backdoor paths blocked. Causal effect is identifiable.")37    return True38
39# Scenario 1: Control for nothing (Kitchen Sink = False)40check_backdoor(G, "Treatment", "Outcome", [])41# -> FAIL: Confounder Z is unblocked.42
43# Scenario 2: Control for the confounder Z44check_backdoor(G, "Treatment", "Outcome", ["Z"])45# -> SUCCESS: Backdoor paths blocked.46
47# Scenario 3: Control for Z, but also control for W (a mediator)48check_backdoor(G, "Treatment", "Outcome", ["Z", "W"])49# -> FAIL: W is caused by Treatment. We blocked the actual causal effect!

Watch Out For

The Quick Version

• A causal graph (DAG) maps out the cause-and-effect relationships between variables.
• We want to isolate the forward-pointing paths from Treatment to Outcome.
• Backdoor paths (paths that start with an arrow pointing into the Treatment) create spurious correlations and must be blocked.
• We block backdoor paths by conditioning on the right variables, defined by the Backdoor Criterion.
• Conditioning on a collider (a node where two arrows meet) actively creates bias by opening a previously blocked path.

What to Read Next

• confounding-and-colliders — A deep dive into the specific three-node structures that dictate when to control and when not to control.
• instrumental-variables — What to do when your DAG tells you a confounder is unobserved and un-blockable.
• potential-outcomes — The counterfactual math that runs under the hood of these graphical models.