Causal Algorithms and Intervention Modeling: From Causal Graphs to Policy Action

Last Updated June 21, 2026

Causal algorithms and intervention modeling explain how computational systems can represent causes, simulate changes, estimate intervention effects, and support disciplined reasoning about what should be done. Causal inference asks whether one condition changes another. Counterfactual reasoning asks what would have happened under an alternative. Intervention modeling takes the next step: it asks how algorithms can encode, test, compare, and govern possible actions before those actions are treated as reliable guidance.

This matters because many algorithmic systems are not used only to describe the world. They are used to recommend treatments, redesign platforms, evaluate policies, allocate resources, set thresholds, rank options, target services, and model institutional change. When algorithms move from prediction to intervention, they must be able to distinguish statistical association from causal structure, estimated effect from justified action, and technical output from accountable decision-making.

This article introduces causal algorithms and intervention modeling as a bridge between causal inference, computational reasoning, scientific modeling, policy analysis, and responsible automation. It explains causal graphs, structural models, do-calculus, intervention operators, adjustment sets, identification, estimation, simulation, policy modeling, causal discovery, validation, sensitivity analysis, governance, and interpretation limits.

This article explains causal algorithms, intervention modeling, causal graphs, structural causal models, do-calculus, adjustment sets, identification algorithms, treatment effects, policy simulation, causal discovery, experimental and observational evidence, causal machine learning, sensitivity analysis, governance, and representation risk. It emphasizes that intervention-oriented computation requires visible assumptions, explicit comparisons, documented boundaries, and accountable interpretation.

Why Intervention Modeling Matters

Intervention modeling matters because many computational systems are expected to guide action. A predictive model may estimate who is at risk, which transaction is suspicious, which student may struggle, which user may churn, or which infrastructure component may fail. Those predictions may be useful, but they do not by themselves show what action would improve the situation.

An intervention model asks what happens if something is changed. It may ask whether a treatment improves health, whether a policy reduces harm, whether a platform redesign changes behavior, whether a support program improves learning, or whether a threshold adjustment changes downstream outcomes. These questions require causal structure, not merely predictive association.

Intervention modeling helps algorithms reason about action, not only prediction.

Back to top ↑

Causal Algorithms Defined

A causal algorithm is a computational procedure designed to reason about causal structure, intervention effects, counterfactual alternatives, identification, estimation, or decision consequences. It may search a causal graph, test an adjustment set, estimate a treatment effect, simulate an intervention, compare policy scenarios, or evaluate the sensitivity of a causal conclusion.

The term does not mean that the algorithm automatically discovers truth. Causal algorithms operate within assumptions. They may make assumptions explicit, test some implications, or automate parts of the reasoning process, but the causal claim still depends on design, evidence, domain knowledge, measurement quality, and governance.

Causal algorithms are not substitutes for judgment. They are tools for disciplined causal reasoning.

Back to top ↑

From Causal Questions to Computational Procedures

A causal question becomes computational when it is translated into variables, contrasts, assumptions, estimands, data structures, algorithms, and review outputs. This translation is powerful, but it can also distort the problem if the intervention, outcome, population, time horizon, or decision context is poorly specified.

The central movement is from an ordinary question such as “Does this program work?” to a structured causal question such as “What is the average effect of offering this program, compared with not offering it, on a defined outcome, for a defined population, over a defined time period, under specified assumptions?”

Good intervention modeling begins before estimation. It begins with a well-formed causal question.

Back to top ↑

Interventions and Do-Calculus

In causal modeling, an intervention is not the same as observation. Observing that a variable has a value may tell us how the world happened to be. Intervening means setting a variable to a value and asking how the system would respond. This distinction is commonly expressed through do-notation.

The expression P(Y | X=x) describes the distribution of an outcome when X is observed to equal x. The expression P(Y | do(X=x)) describes the distribution of the outcome when X is set by intervention. These are not generally the same. Confounding, selection, and feedback can make observed association different from intervention effect.

Do-notation forces a computational system to state whether it is observing the world or changing it.

Back to top ↑

Causal Graphs and Structural Models

Causal graphs represent assumptions about how variables influence one another. Structural causal models go further by representing variables as generated by functions of other variables and background conditions. Together, they help algorithms reason about intervention, counterfactuals, identification, and causal pathways.

A causal graph can show confounders, mediators, colliders, feedback risks, post-treatment variables, and paths that should be blocked or left open. A structural model can specify how a change in one variable propagates through a system. Neither is automatically true. Their value is that they make assumptions explicit enough for inspection.

Causal graphs and structural models are computational instruments for making causal assumptions visible.

Back to top ↑

Identification Algorithms and Adjustment Sets

Identification asks whether a causal effect can be recovered from available evidence under stated assumptions. Estimation asks how large the effect appears to be. Identification comes first. An intervention effect can be estimated precisely and still be wrong if the effect is not identified.

Identification algorithms search causal structures to determine whether a causal query can be expressed in terms of observable quantities. Adjustment sets are one common mechanism: they specify variables that should be controlled for to block confounding pathways. But adjustment can also create bias if it conditions on colliders, mediators, or post-treatment variables.

Identification is the logic of whether the causal question can be answered before the algorithm estimates the answer.

Back to top ↑

Simulation, Policy Analysis, and Scenario Testing

Intervention modeling often uses simulation. A computational model may compare outcomes under different policies, thresholds, allocation rules, treatment strategies, or institutional designs. Simulation can reveal possible consequences, but simulated consequences are only as reliable as the structure, assumptions, parameters, and data-generating process behind them.

Scenario testing is especially useful when direct experimentation is difficult, costly, slow, or ethically constrained. But simulated policy analysis should not be treated as a magic substitute for evidence. It is a disciplined way to ask what would follow if the model assumptions were reasonable.

Simulation can support causal reasoning when it is treated as conditional analysis, not as prediction without assumptions.

Back to top ↑

Experiments, Observational Designs, and Quasi-Experiments

Intervention models can be informed by randomized experiments, observational data, natural experiments, regression discontinuity designs, instrumental variables, difference-in-differences, matching, weighting, and structural modeling. Each design offers a different way to connect evidence to causal claims.

Randomized experiments are often strong for estimating intervention effects because assignment is controlled. But they may be impossible, unethical, expensive, narrow, or difficult to generalize. Observational and quasi-experimental designs are common in institutional systems, but they require especially careful assumptions and documentation.

The design behind an intervention model is as important as the algorithm used to estimate it.

Back to top ↑

Causal Discovery and Its Limits

Causal discovery algorithms attempt to learn causal structure from data, often using conditional independence, score-based search, functional assumptions, temporal ordering, or invariance across environments. These methods can be useful, especially when they generate hypotheses, reveal possible structures, or test assumptions. But they should not be treated as automatic causal truth machines.

Many causal structures are statistically indistinguishable without additional assumptions. Measurement error, hidden variables, selection bias, small samples, changing environments, feedback, and institutional data-generation processes can undermine causal discovery. Domain knowledge remains essential.

Causal discovery can inform intervention modeling, but causal discovery does not remove the need for causal judgment.

Back to top ↑

Intervention Modeling in Algorithmic Systems

Algorithmic systems often embed interventions even when they are described as neutral tools. A recommendation changes visibility. A ranking changes attention. A threshold changes eligibility. A triage model changes access. A risk score changes institutional response. An automated rule changes the path a person or case can take.

Intervention modeling asks whether these changes are understood, justified, monitored, and reviewable. It also asks whether the algorithm is only estimating what is likely or whether it is actively changing the system that produces future data.

Algorithmic systems often intervene before anyone calls them intervention models.

Back to top ↑

Validation, Sensitivity, and Robustness

Intervention models require validation because their central claims depend on unobserved alternatives. The model may estimate what would happen under a policy, threshold, or treatment that was not directly observed. That makes sensitivity analysis, falsification checks, placebo tests, uncertainty reporting, external validation, and post-deployment monitoring essential.

A responsible model should report how conclusions change under alternative assumptions. It should distinguish robust findings from fragile findings. It should also clarify whether uncertainty comes from sampling error, model structure, unmeasured confounding, measurement error, external validity, or decision context.

A causal algorithm should produce not only an estimate, but also a review record of why the estimate should or should not be trusted.

Back to top ↑

Governance and Responsible Use

Intervention modeling can shape real decisions. It may influence public policy, healthcare, platform design, education, labor systems, environmental planning, finance, public administration, or automated triage. Because it connects computation to action, it requires governance.

Governance should clarify who defines the intervention, who defines the outcome, whose evidence counts, what assumptions are accepted, what harms are monitored, where the model applies, and who can challenge the model. Causal language should not be used to make contested institutional choices appear technically inevitable.

Responsible intervention modeling treats causal computation as accountable institutional reasoning.

Back to top ↑

Representation Risk

Representation risk appears when a causal model makes intervention claims look more settled than they are. A diagram can look authoritative even when the causal structure is disputed. A simulation can look precise even when the parameters are uncertain. An optimization result can look objective even when the outcome metric is narrow. A policy model can appear neutral while encoding institutional priorities.

There is also a risk of intervention laundering: using causal or algorithmic language to justify decisions whose values, assumptions, or power relations remain hidden. A responsible article, model, or audit record should make uncertainty visible rather than using computation to conceal it.

Intervention models should clarify action under uncertainty, not disguise judgment as inevitability.

Back to top ↑

Back to top ↑

Mathematics, Computation, and Modeling

An observational conditional distribution can be written as:

An intervention distribution can be written as:

A simple adjustment formula can be written as:

A structural causal model may represent variables as functions of their causes and background conditions:

A policy intervention can be represented as a change from one decision rule to another:

A threshold intervention can be expressed as:

These formulas show how intervention modeling formalizes action, comparison, structural assumptions, and decision consequences.

Back to top ↑

Python Workflow: Intervention Modeling Audit

The Python workflow below creates a dependency-light intervention modeling audit. It generates synthetic observational data, defines alternative policy thresholds, compares estimated intervention outcomes, checks covariate balance, records assumptions, and writes reproducible CSV and JSON outputs.

# causal_algorithms_intervention_modeling_audit.py
# Dependency-light workflow for intervention comparison, threshold policy review,
# adjustment diagnostics, sensitivity checks, and causal governance records.

from __future__ import annotations

from dataclasses import asdict, dataclass
from pathlib import Path
from statistics import mean, pstdev
import csv
import json
import math
import random
from datetime import datetime, timezone

ARTICLE_ROOT = Path(__file__).resolve().parents[1]
TABLES = ARTICLE_ROOT / "outputs" / "tables"
JSON_DIR = ARTICLE_ROOT / "outputs" / "json"


@dataclass(frozen=True)
class InterventionConfig:
    experiment_name: str
    seed: int
    n: int
    baseline_threshold: float
    candidate_thresholds: tuple[float, ...]
    intervention_effect: float


@dataclass(frozen=True)
class InterventionAssumption:
    assumption: str
    description: str
    review_question: str
    status: str


def timestamp_utc() -> str:
    return datetime.now(timezone.utc).isoformat()


def sigmoid(value: float) -> float:
    return 1.0 / (1.0 + math.exp(-value))


def write_csv(path: Path, rows: list[dict[str, object]]) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    if not rows:
        path.write_text("", encoding="utf-8")
        return
    fieldnames = sorted({key for row in rows for key in row.keys()})
    with path.open("w", newline="", encoding="utf-8") as handle:
        writer = csv.DictWriter(handle, fieldnames=fieldnames, extrasaction="ignore")
        writer.writeheader()
        writer.writerows(rows)


def write_json(path: Path, payload: object) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    path.write_text(json.dumps(payload, indent=2, sort_keys=True), encoding="utf-8")


def default_config() -> InterventionConfig:
    return InterventionConfig(
        experiment_name="causal_algorithms_intervention_modeling",
        seed=2026,
        n=900,
        baseline_threshold=0.60,
        candidate_thresholds=(0.45, 0.55, 0.60, 0.70),
        intervention_effect=-0.16,
    )


def generate_units(config: InterventionConfig) -> list[dict[str, object]]:
    rng = random.Random(config.seed)
    rows: list[dict[str, object]] = []
    for unit_id in range(1, config.n + 1):
        baseline_need = rng.random()
        access_constraint = max(0.0, min(1.0, rng.gauss(0.35 + 0.30 * baseline_need, 0.18)))
        support_capacity = max(0.0, min(1.0, rng.gauss(0.55 - 0.18 * baseline_need, 0.16)))
        score = sigmoid(-1.0 + 2.1 * baseline_need + 1.2 * access_constraint - 0.8 * support_capacity)
        untreated_outcome = 0.28 + 0.38 * baseline_need + 0.22 * access_constraint - 0.18 * support_capacity + rng.gauss(0.0, 0.07)
        rows.append({
            "unit_id": unit_id,
            "baseline_need": round(baseline_need, 6),
            "access_constraint": round(access_constraint, 6),
            "support_capacity": round(support_capacity, 6),
            "score": round(score, 6),
            "untreated_outcome": round(untreated_outcome, 6),
            "interpretation": "Synthetic units represent cases that may receive an algorithmic intervention based on a score threshold.",
        })
    return rows


def evaluate_threshold(rows: list[dict[str, object]], threshold: float, intervention_effect: float) -> dict[str, object]:
    treated = 0
    outcomes: list[float] = []
    for row in rows:
        action = 1 if float(row["score"]) >= threshold else 0
        treated += action
        outcome = float(row["untreated_outcome"]) + intervention_effect * action
        outcomes.append(outcome)
    return {
        "policy_threshold": threshold,
        "treated_count": treated,
        "treated_share": round(treated / len(rows), 6),
        "mean_modeled_outcome": round(mean(outcomes), 6),
        "interpretation": "Lower modeled outcome is better in this synthetic risk-reduction example.",
    }


def policy_comparisons(rows: list[dict[str, object]], config: InterventionConfig) -> list[dict[str, object]]:
    baseline = evaluate_threshold(rows, config.baseline_threshold, config.intervention_effect)
    results = []
    for threshold in config.candidate_thresholds:
        candidate = evaluate_threshold(rows, threshold, config.intervention_effect)
        results.append({
            **candidate,
            "baseline_threshold": config.baseline_threshold,
            "change_in_treated_count": int(candidate["treated_count"]) - int(baseline["treated_count"]),
            "change_in_mean_outcome_vs_baseline": round(float(candidate["mean_modeled_outcome"]) - float(baseline["mean_modeled_outcome"]), 6),
        })
    return results


def balance_diagnostics(rows: list[dict[str, object]], threshold: float) -> list[dict[str, object]]:
    diagnostics: list[dict[str, object]] = []
    for column in ["baseline_need", "access_constraint", "support_capacity"]:
        treated = [float(row[column]) for row in rows if float(row["score"]) >= threshold]
        control = [float(row[column]) for row in rows if float(row["score"]) < threshold]
        treated_mean = mean(treated)
        control_mean = mean(control)
        pooled_sd = math.sqrt((pstdev(treated) ** 2 + pstdev(control) ** 2) / 2.0)
        standardized_difference = 0.0 if pooled_sd == 0 else (treated_mean - control_mean) / pooled_sd
        diagnostics.append({
            "covariate": column,
            "threshold": threshold,
            "treated_mean": round(treated_mean, 6),
            "comparison_mean": round(control_mean, 6),
            "absolute_standardized_difference": round(abs(standardized_difference), 6),
            "interpretation": "Large differences show that threshold-defined groups are not automatically comparable causal groups.",
        })
    return diagnostics


def assumption_register() -> list[dict[str, object]]:
    assumptions = [
        InterventionAssumption("clear_intervention", "The action triggered by the policy threshold is defined precisely.", "What exactly happens when the model intervenes?", "complete"),
        InterventionAssumption("causal_effect_model", "The modeled action effect is separated from predictive association.", "Why should the estimated change be causal?", "partial"),
        InterventionAssumption("no_hidden_harm", "The model checks for omitted harms or downstream burdens.", "Who may be harmed outside the main outcome?", "needs_review"),
        InterventionAssumption("scope_boundary", "The intervention applies only to a defined population and setting.", "Where should the model not be used?", "partial"),
        InterventionAssumption("contestability", "Affected people can challenge the action or threshold.", "Is there an appeal or review path?", "needs_review"),
        InterventionAssumption("monitoring", "Post-deployment consequences are measured over time.", "How will feedback and drift be detected?", "partial"),
    ]
    return [asdict(item) for item in assumptions]


def main() -> None:
    config = default_config()
    rows = generate_units(config)
    policies = policy_comparisons(rows, config)
    diagnostics = balance_diagnostics(rows, config.baseline_threshold)
    assumptions = assumption_register()
    summary = {
        "article": "causal_algorithms_and_intervention_modeling",
        "timestamp_utc": timestamp_utc(),
        "n": config.n,
        "baseline_threshold": config.baseline_threshold,
        "best_modeled_threshold": min(policies, key=lambda row: float(row["mean_modeled_outcome"]))["policy_threshold"],
        "assumption_items_needing_review": sum(1 for row in assumptions if row["status"] in {"partial", "needs_review"}),
        "largest_threshold_group_imbalance": max(float(row["absolute_standardized_difference"]) for row in diagnostics),
        "interpretation": "Intervention models should compare actions under explicit causal assumptions, document imbalance, test sensitivity, and preserve governance review.",
    }
    write_csv(TABLES / "intervention_synthetic_units.csv", rows)
    write_csv(TABLES / "intervention_policy_comparisons.csv", policies)
    write_csv(TABLES / "intervention_balance_diagnostics.csv", diagnostics)
    write_csv(TABLES / "intervention_assumption_register.csv", assumptions)
    write_csv(TABLES / "intervention_modeling_audit_summary.csv", [summary])
    write_json(JSON_DIR / "intervention_config.json", asdict(config))
    write_json(JSON_DIR / "intervention_policy_comparisons.json", policies)
    write_json(JSON_DIR / "intervention_assumption_register.json", assumptions)
    write_json(JSON_DIR / "intervention_modeling_audit_summary.json", summary)
    print("Intervention modeling audit complete.")
    print(TABLES / "intervention_modeling_audit_summary.csv")


if __name__ == "__main__":
    main()

This workflow is intentionally educational. It does not claim that synthetic threshold comparisons are sufficient for real policy deployment. Its purpose is to show how intervention reasoning can be made explicit, documented, and reviewable.

Back to top ↑

R Workflow: Intervention Summary and Diagnostics

The R workflow summarizes intervention-policy outputs and creates simple diagnostic plots. It is designed to run after the Python workflow has generated CSV files.

# causal_algorithms_intervention_modeling_summary.R
# Summary diagnostics for intervention policy comparison outputs.

args <- commandArgs(trailingOnly = FALSE)
file_arg <- grep("^--file=", args, value = TRUE)

if (length(file_arg) > 0) {
  script_path <- normalizePath(sub("^--file=", "", file_arg[1]), mustWork = TRUE)
  article_root <- normalizePath(file.path(dirname(script_path), ".."), mustWork = TRUE)
} else {
  article_root <- getwd()
}

setwd(article_root)
tables_dir <- file.path(article_root, "outputs", "tables")
figures_dir <- file.path(article_root, "outputs", "figures")
dir.create(tables_dir, recursive = TRUE, showWarnings = FALSE)
dir.create(figures_dir, recursive = TRUE, showWarnings = FALSE)

policy_path <- file.path(tables_dir, "intervention_policy_comparisons.csv")
if (!file.exists(policy_path)) {
  stop(paste("Missing", policy_path, "Run the Python workflow first."))
}

policies <- read.csv(policy_path, stringsAsFactors = FALSE)

png(file.path(figures_dir, "intervention_policy_outcomes.png"), width = 1300, height = 850)
plot(
  policies$policy_threshold,
  policies$mean_modeled_outcome,
  type = "b",
  xlab = "Policy threshold",
  ylab = "Mean modeled outcome",
  main = "Modeled Outcomes Under Alternative Intervention Thresholds"
)
grid()
dev.off()

png(file.path(figures_dir, "intervention_treated_share.png"), width = 1300, height = 850)
barplot(
  policies$treated_share,
  names.arg = policies$policy_threshold,
  xlab = "Policy threshold",
  ylab = "Share receiving intervention",
  main = "Intervention Reach by Threshold"
)
grid()
dev.off()

balance_path <- file.path(tables_dir, "intervention_balance_diagnostics.csv")
if (file.exists(balance_path)) {
  balance <- read.csv(balance_path, stringsAsFactors = FALSE)
  png(file.path(figures_dir, "intervention_covariate_imbalance.png"), width = 1300, height = 850)
  barplot(
    balance$absolute_standardized_difference,
    names.arg = balance$covariate,
    las = 2,
    ylab = "Absolute standardized difference",
    main = "Covariate Imbalance at Baseline Threshold"
  )
  abline(h = 0.10, lty = 2)
  grid()
  dev.off()
}

summary_path <- file.path(tables_dir, "intervention_modeling_audit_summary.csv")
audit_data <- read.csv(summary_path, stringsAsFactors = FALSE)

r_summary <- data.frame(
  workflow_summary_rows = nrow(audit_data),
  n = audit_data$n[1],
  baseline_threshold = audit_data$baseline_threshold[1],
  best_modeled_threshold = audit_data$best_modeled_threshold[1],
  assumption_items_needing_review = audit_data$assumption_items_needing_review[1],
  largest_threshold_group_imbalance = audit_data$largest_threshold_group_imbalance[1]
)

write.csv(r_summary, file.path(tables_dir, "r_intervention_modeling_summary.csv"), row.names = FALSE)
print(r_summary)

The R layer gives the article a second computational view: one script for generating the intervention audit and another for summarizing and visualizing its outputs.

Back to top ↑

GitHub Repository

The companion repository contains reproducible workflows, synthetic data, audit outputs, calculators, documentation, and multilingual examples for this article.

Back to top ↑

A Practical Method for Reviewing Intervention Models

A practical review of causal algorithms and intervention models should move from question design to assumption review, evidence design, estimation, sensitivity testing, governance, and monitoring.

This method treats causal algorithms as reviewable reasoning systems rather than black-box decision authorities.

Back to top ↑

Common Pitfalls

Causal algorithms and intervention models can fail when they overstate what the data support, hide assumptions, confuse prediction with intervention, or optimize narrow outcomes without governance review.

The main danger is not that causal algorithms are useless. The danger is that their authority can exceed their assumptions.

Back to top ↑

Why Intervention Modeling Is Computational Reasoning

Causal algorithms and intervention modeling are central to computational reasoning because they connect formal procedure to action. They ask not only what patterns exist, but what would happen if a treatment, rule, threshold, policy, or design were changed. They require causal questions, structured assumptions, identification logic, evidence design, estimation, simulation, sensitivity testing, and governance.

This makes intervention modeling different from ordinary prediction. Prediction can forecast what may happen. Intervention modeling asks what could be changed, what should be changed, what would follow, and under what assumptions a computational system can responsibly support that conclusion.

The next article turns from intervention modeling to decision under uncertainty and computational risk, where causal claims, probabilities, thresholds, expected values, uncertainty ranges, and institutional judgment meet the problem of action under incomplete information.

Back to top ↑

Related Articles

• Causal Inference and Computational Reasoning
• Counterfactual Reasoning in Algorithmic Systems
• Decision Under Uncertainty and Computational Risk
• Machine Learning as Algorithmic Inference
• Algorithmic Accountability and Audit Trails
• Algorithmic Risk Management and AI Governance

Back to top ↑

Further Reading

• Bareinboim, E. and Pearl, J. (2016) ‘Causal inference and the data-fusion problem’, Proceedings of the National Academy of Sciences, 113(27), pp. 7345–7352.
• Hernán, M.A. and Robins, J.M. (2020) Causal Inference: What If. Boca Raton: Chapman & Hall/CRC.
• Imbens, G.W. and Rubin, D.B. (2015) Causal Inference for Statistics, Social, and Biomedical Sciences: An Introduction. Cambridge: Cambridge University Press.
• Pearl, J. (2009) Causality: Models, Reasoning, and Inference. 2nd edn. Cambridge: Cambridge University Press.
• Pearl, J., Glymour, M. and Jewell, N.P. (2016) Causal Inference in Statistics: A Primer. Chichester: Wiley.
• Peters, J., Janzing, D. and Schölkopf, B. (2017) Elements of Causal Inference: Foundations and Learning Algorithms. Cambridge, MA: MIT Press.
• Spirtes, P., Glymour, C. and Scheines, R. (2000) Causation, Prediction, and Search. 2nd edn. Cambridge, MA: MIT Press.

Back to top ↑

References

• Bareinboim, E. and Pearl, J. (2016) ‘Causal inference and the data-fusion problem’, Proceedings of the National Academy of Sciences, 113(27), pp. 7345–7352.
• Hernán, M.A. and Robins, J.M. (2020) Causal Inference: What If. Boca Raton: Chapman & Hall/CRC.
• Imbens, G.W. and Rubin, D.B. (2015) Causal Inference for Statistics, Social, and Biomedical Sciences: An Introduction. Cambridge: Cambridge University Press.
• Pearl, J. (1995) ‘Causal diagrams for empirical research’, Biometrika, 82(4), pp. 669–688.
• Pearl, J. (2009) Causality: Models, Reasoning, and Inference. 2nd edn. Cambridge: Cambridge University Press.
• Pearl, J., Glymour, M. and Jewell, N.P. (2016) Causal Inference in Statistics: A Primer. Chichester: Wiley.
• Peters, J., Janzing, D. and Schölkopf, B. (2017) Elements of Causal Inference: Foundations and Learning Algorithms. Cambridge, MA: MIT Press.
• Spirtes, P., Glymour, C. and Scheines, R. (2000) Causation, Prediction, and Search. 2nd edn. Cambridge, MA: MIT Press.

Back to top ↑