From 9d011510e27e5b452a1a38b392f66ce9aa897b15 Mon Sep 17 00:00:00 2001 From: igerber Date: Sat, 18 Jul 2026 14:50:12 -0400 Subject: [PATCH 1/2] docs: Tutorial 27 - When the Average Hides the Action (distributional DiD with CiC) Business-framed walkthrough of ChangesInChanges/QDiD on a seed-locked loyalty-program 2x2 (repeated cross-sections) where mean DiD reads $0.22 (p=0.90) while the known truth is a $3.01 mean effect concentrated below the median (CiC ATT: $3.05): - Reading the QTE profile; joint "which quantiles moved" claims via sup-t uniform bands (excluding zero for exactly tau=0.05-0.50), including the bands-are-silent-not-exonerating framing above the median and the tau=0.55 pointwise blip (p=0.044) as the multiple-testing trap they prevent. - A live interior-range guardrail demo on a short-support control sample: the Assumption-3.4 and interior-range warnings render in the committed output (interior range (0.17, 0.996), NaN tail inference). The notebook contains NO warnings filters and NO asserts - both locked structurally by the drift test (AST-based); the machine-specific path prefix is normalized out of committed stream text ("/Users/" drift-locked out). - The scale-equivariance centerpiece: levels-vs-logs flips mean DiD's verdict ($0.22 p=0.90 vs +14.0% p=0.001) and shifts QDiD's profile by dollars (-0.24/-2.10/-5.65 at tau=0.50/0.75/0.90; a spurious -$8.48 "loss" at tau=0.90 where truth is ~0), while CiC's counterfactual quantiles agree to floating-point precision on unconditional fits - the concrete form of the Athey-Imbens p. 447 CiC-over-QDiD recommendation. Public-API construction (type-1 inverted_cdf treated-post quantiles minus reported QTE; cell size 901 coprime to the grid denominator); drift-tested at rtol 1e-14 (libm-safe across the CI OS matrix). - Covariate-composition confounding fixed with covariates=['tenure']: confidently-wrong 9.38 [8.32, 10.45] -> truth-covering 6.53 [5.35, 7.70] (truth 6.0), on a design ported from the calibrated methodology-test DGP. practitioner_next_steps() close. Committed WITH executed outputs (nbsphinx renders them on RTD; ~65s runtime, well under the 600s notebook-CI budget). Companion drift test (19 tests) re-derives every prose-quoted number from the public API and cross-checks the rendered markdown/output surfaces; the ~1-minute covariate bootstrap re-derivation is @pytest.mark.slow (T24 precedent). Registered in the RTD toctree (Business Applications), the tutorials catalog (also backfilling the missing Tutorial 25 entry), doc-deps, and a fresh CHANGELOG [Unreleased] section; the tutorial's TODO row is removed as completed. Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_01W75ea3yFYQbjVhB2evhRiZ --- CHANGELOG.md | 27 + TODO.md | 1 - docs/doc-deps.yaml | 3 + docs/index.rst | 1 + .../27_cic_distributional_effects.ipynb | 1113 +++++++++++++++++ docs/tutorials/README.md | 15 + ...st_t27_cic_distributional_effects_drift.py | 452 +++++++ 7 files changed, 1611 insertions(+), 1 deletion(-) create mode 100644 docs/tutorials/27_cic_distributional_effects.ipynb create mode 100644 tests/test_t27_cic_distributional_effects_drift.py diff --git a/CHANGELOG.md b/CHANGELOG.md index fb6b9b793..52858cb97 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,6 +5,33 @@ All notable changes to this project will be documented in this file. The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). +## [Unreleased] + +### Added +- **New tutorial: `docs/tutorials/27_cic_distributional_effects.ipynb` - "When the + Average Hides the Action: Distributional DiD with Changes-in-Changes".** A + business-framed walkthrough of `ChangesInChanges`/`QDiD` on a seed-locked loyalty- + program 2x2 (repeated cross-sections) where mean DiD reads $0.22 (p = 0.90) while + the known truth is a $3.01 mean effect concentrated in the bottom half of the spend + distribution: reading the QTE profile, joint "which quantiles moved" claims via + sup-t uniform bands (excluding zero for exactly tau = 0.05-0.50), a live interior- + range guardrail demo on a short-support control sample (the Assumption-3.4 and + interior-range warnings render in the committed output - no warning filters + anywhere in the notebook), the scale-equivariance centerpiece (levels-vs-logs flips + mean DiD's verdict and shifts QDiD's profile by dollars while CiC's counterfactual + quantiles agree to floating-point precision on unconditional fits - the concrete + form of the Athey-Imbens p. 447 CiC-over-QDiD recommendation), covariate- + composition confounding fixed with `covariates=['tenure']` (confidently-wrong 9.38 + -> truth-covering 6.53 on a design ported from the calibrated methodology-test + DGP), and a `practitioner_next_steps()` close. Committed WITH executed outputs + (nbsphinx renders them on RTD; figures are the payload). Companion drift test + `tests/test_t27_cic_distributional_effects_drift.py` (19 tests) re-derives every + prose-quoted number from the public API, locks the no-filters/no-asserts notebook + contract, cross-checks the rendered surface, and slow-marks the ~1-minute covariate + bootstrap re-derivation (T24 precedent). Registered in the RTD toctree (Business + Applications), the tutorials catalog (also backfilling the missing Tutorial 25 + entry), and `docs/doc-deps.yaml`. + ## [3.8.0] - 2026-07-18 ### Added diff --git a/TODO.md b/TODO.md index 9df95552d..6f3dc5d07 100644 --- a/TODO.md +++ b/TODO.md @@ -48,7 +48,6 @@ generic sparse-FE, QR+SVD rank-detection redundancy, `check_finite` bypass — m | Issue | Location | Origin | Effort | Priority | |-------|----------|--------|--------|----------| -| ChangesInChanges/QDiD tutorial notebook (2x2 distributional walkthrough: QTE grid, interior range, uniform bands, CiC-vs-QDiD comparison) - deferred from the implementation PR as a documented decision. | `docs/tutorials/` | #682 | Mid | Low | | Tighten the mypy suppressions that back the enforced-zero posture: burn down `prep_dgp`'s per-module `[index]` override (needs a None-vs-array restructure that preserves the seeded RNG stream), and evaluate re-enabling the globally disabled codes (`arg-type`, `return-value`, `var-annotated`, `assignment`) one at a time — `assignment` alone hid several real annotation drifts found during the 2026-07 triage. | `pyproject.toml` `[tool.mypy]`, `diff_diff/prep_dgp.py` | lint-CI | Mid | Low | | Align the four legacy dataset loaders (`load_card_krueger`, `load_castle_doctrine`, `load_divorce_laws`, `load_mpdta`) with the loud-fallback pattern of `load_prop99`/`load_walmart`: `UserWarning` + `df.attrs["source"]` marker on synthetic fallback (currently silent), plus optional checksum pinning for the CSV downloads. **Upgraded to a live defect 2026-07-13: the `causaldata/causal_datasets` GitHub repo backing castle/card_krueger/divorce is dead (404), so those loaders silently serve synthetic data everywhere - needs loud fallback + replacement sources.** | `diff_diff/datasets.py` | LWDiD precursor | Quick | Medium | | Real-data CI canary for dataset-backed replication tests: `test_methodology_lwdid.py`'s Prop 99 / Walmart goldens skip (visibly) when loaders fall back to synthetic; add a lane or canary asserting `df.attrs["source"] == "lwdid_ssc_ancillary"` in CI so network regressions cannot silently de-gate the replication tests. Pairs with the loader-fallback repair row above. | `tests/test_methodology_lwdid.py`, `.github/workflows/` | LWDiD validation suite | Quick | Low | diff --git a/docs/doc-deps.yaml b/docs/doc-deps.yaml index db142174f..68e2119b9 100644 --- a/docs/doc-deps.yaml +++ b/docs/doc-deps.yaml @@ -670,6 +670,9 @@ sources: type: methodology - path: docs/api/changes_in_changes.rst type: api_reference + - path: docs/tutorials/27_cic_distributional_effects.ipynb + type: tutorial + note: "committed outputs quote seed-locked numbers; companion drift test test_t27_cic_distributional_effects_drift.py re-derives them" - path: README.md section: "Estimators (one-line catalog entry)" type: user_guide diff --git a/docs/index.rst b/docs/index.rst index 33ed0d447..681e81e0a 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -85,6 +85,7 @@ Quick Links tutorials/22_had_survey_design tutorials/23_spillover_tva tutorials/26_composition_drift_calibration + tutorials/27_cic_distributional_effects .. toctree:: :maxdepth: 1 diff --git a/docs/tutorials/27_cic_distributional_effects.ipynb b/docs/tutorials/27_cic_distributional_effects.ipynb new file mode 100644 index 000000000..11233649a --- /dev/null +++ b/docs/tutorials/27_cic_distributional_effects.ipynb @@ -0,0 +1,1113 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "f9b19c35", + "metadata": {}, + "source": [ + "# Tutorial 27: When the Average Hides the Action - Distributional DiD with Changes-in-Changes\n", + "\n", + "A loyalty program was rolled out to a lower-spend customer segment. Finance ran the\n", + "standard difference-in-differences on monthly spend and got a flat zero - the program\n", + "looks dead, and leadership is ready to kill it. This tutorial shows how\n", + "**Changes-in-Changes (CiC)** - the distributional DiD estimator of Athey & Imbens\n", + "(2006) - reveals that the program in fact worked exactly where it was aimed: it moved\n", + "the *bottom half* of the spend distribution, which the mean cannot see under this\n", + "much top-end variance.\n", + "\n", + "**What you'll learn**\n", + "\n", + "1. When to reach for CiC instead of (or alongside) mean DiD and the staggered estimators.\n", + "2. How to read a quantile-treatment-effect (QTE) profile, and how to make *joint*\n", + " \"which quantiles moved\" claims with sup-t uniform bands.\n", + "3. What the interior point-identification range guardrail does when support is short.\n", + "4. CiC's headline robustness property: its distributional answer does not depend on\n", + " whether you analyze levels or logs - and why that is not true for mean DiD or for\n", + " the quantile-DiD (QDiD) comparison estimator.\n", + "5. How to adjust for covariate-composition differences with the quantile-regression\n", + " covariate branch (`covariates=`), and what the conditional support diagnostic guards.\n", + "6. Where to go next with `practitioner_next_steps()`.\n" + ] + }, + { + "cell_type": "markdown", + "id": "9854eb19", + "metadata": {}, + "source": [ + "## 1. When is CiC the right tool?\n", + "\n", + "The decision comes down to the *design* and the *question*:\n", + "\n", + "- **Two groups, two periods (2x2), and a distributional question** - \"who moved, not\n", + " just how much on average?\" - use **ChangesInChanges**. It estimates the treated\n", + " group's full counterfactual outcome distribution, so you get an ATT *and* quantile\n", + " treatment effects on one bootstrap.\n", + "- **Mean-only question, trustworthy parallel trends on your chosen scale** - plain\n", + " `DifferenceInDifferences` is simpler and faster.\n", + "- **Staggered adoption across many periods** - CiC does not apply (it is 2x2 only);\n", + " use `CallawaySantAnna` or another heterogeneity-robust estimator for mean effects.\n", + "- **QDiD** is the quantile-by-quantile DiD comparison estimator. Athey & Imbens (2006,\n", + " p. 447) recommend CiC over it - Section 6 makes their reason concrete on our data.\n", + "\n", + "Our setting is a genuine 2x2 with **repeated cross-sections**: a fresh sample of\n", + "customers is drawn each period (typical for transaction panels). CiC also supports\n", + "true panels - `panel=True` changes only the bootstrap resampling scheme (unit-block\n", + "instead of pooled rows), not the point estimator.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "8c425afc", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-18T18:33:39.810008Z", + "iopub.status.busy": "2026-07-18T18:33:39.809770Z", + "iopub.status.idle": "2026-07-18T18:33:40.741298Z", + "shell.execute_reply": "2026-07-18T18:33:40.740870Z" + } + }, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "from scipy import stats\n", + "\n", + "from diff_diff import ChangesInChanges, DifferenceInDifferences, QDiD, practitioner_next_steps\n" + ] + }, + { + "cell_type": "markdown", + "id": "a6189b31", + "metadata": {}, + "source": [ + "## 2. The data\n", + "\n", + "We simulate the program so that the truth is known by construction - every claim\n", + "below can be checked against it. Three ingredients, each realistic on its own:\n", + "\n", + "- **Heavy-tailed spend.** Customer spend is lognormal-ish: median about \\$30, a long\n", + " right tail past \\$200. The tail is what makes the *mean* a noisy summary.\n", + "- **A nonlinear market trend.** Between periods the whole market moves by a smooth\n", + " transformation with `log y_post = ALPHA + GAMMA * log y_pre` and `GAMMA = 1.06`:\n", + " premium spend grows faster than budget spend. Dollar trends are therefore *not*\n", + " parallel across differently-composed groups - and neither are log trends.\n", + "- **A targeted program.** The treated group is a lower-spend loyalty segment, and the\n", + " program lift fades smoothly - a logistic in spend rank - from about +65% for\n", + " near-lapsed customers to effectively zero across the segment's upper half. The\n", + " **true mean effect on the treated is \\$3.01**.\n", + "\n", + "The seed is locked so every number in the prose is reproducible; a companion drift\n", + "test re-derives them against the installed library.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "c813b304", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-18T18:33:40.742440Z", + "iopub.status.busy": "2026-07-18T18:33:40.742344Z", + "iopub.status.idle": "2026-07-18T18:33:40.751858Z", + "shell.execute_reply": "2026-07-18T18:33:40.751500Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3604 rows (901 per group x period cell)\n", + "control pre-period spend: median $31.03, mean $39.79\n", + "treated pre-period spend: median $20.86 (lower-spend segment)\n" + ] + } + ], + "source": [ + "SEED = 27\n", + "N_CELL = 901 # 17*53 - coprime to 20 (quantile grid) and 100 (QR tau grid)\n", + "\n", + "MU_LOG, SIGMA_LOG = 3.4, 0.75 # log-spend location/scale: median spend ~ $30\n", + "GAMMA, ALPHA = 1.06, -0.17 # market trend: log y_post = ALPHA + GAMMA * log y_pre\n", + "U_LO, U_HI = 0.05, 0.90 # loyalty segment spans the interior of the spend distribution\n", + "BETA_A, BETA_B = 1.2, 2.2 # segment tilt toward lower spenders\n", + "LIFT_MAX, LIFT_MID, LIFT_SCALE = 0.65, 0.22, 0.07 # program lift, strongest for near-lapsed\n", + "\n", + "\n", + "def h_pre(u):\n", + " return np.exp(MU_LOG + SIGMA_LOG * stats.norm.ppf(u))\n", + "\n", + "\n", + "def h_post(u):\n", + " return np.exp(ALPHA + GAMMA * (MU_LOG + SIGMA_LOG * stats.norm.ppf(u)))\n", + "\n", + "\n", + "def lift(u):\n", + " return LIFT_MAX / (1.0 + np.exp((u - LIFT_MID) / LIFT_SCALE))\n", + "\n", + "\n", + "def make_spend_data(seed=SEED, n=N_CELL):\n", + " rng = np.random.default_rng(seed)\n", + " u00 = rng.uniform(0.0005, 0.9995, n)\n", + " u01 = rng.uniform(0.0005, 0.9995, n)\n", + " u10 = U_LO + (U_HI - U_LO) * rng.beta(BETA_A, BETA_B, n)\n", + " u11 = U_LO + (U_HI - U_LO) * rng.beta(BETA_A, BETA_B, n)\n", + " frames = []\n", + " for g, t, y in (\n", + " (0, 0, h_pre(u00)),\n", + " (0, 1, h_post(u01)),\n", + " (1, 0, h_pre(u10)),\n", + " (1, 1, h_post(u11) * (1.0 + lift(u11))),\n", + " ):\n", + " frames.append(pd.DataFrame({\"treated\": g, \"post\": t, \"spend\": y}))\n", + " return pd.concat(frames, ignore_index=True)\n", + "\n", + "\n", + "df = make_spend_data()\n", + "y00 = df.query(\"treated == 0 and post == 0\")[\"spend\"].to_numpy()\n", + "y10 = df.query(\"treated == 1 and post == 0\")[\"spend\"].to_numpy()\n", + "y11 = df.query(\"treated == 1 and post == 1\")[\"spend\"].to_numpy()\n", + "\n", + "print(f\"{len(df)} rows ({N_CELL} per group x period cell)\")\n", + "print(f\"control pre-period spend: median ${np.median(y00):.2f}, mean ${y00.mean():.2f}\")\n", + "print(f\"treated pre-period spend: median ${np.median(y10):.2f} (lower-spend segment)\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "88f3a7f6", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-18T18:33:40.752863Z", + "iopub.status.busy": "2026-07-18T18:33:40.752782Z", + "iopub.status.idle": "2026-07-18T18:33:41.017084Z", + "shell.execute_reply": "2026-07-18T18:33:41.016669Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(1, 2, figsize=(9, 3.2), sharey=True)\n", + "bins = np.geomspace(3, 300, 45)\n", + "for ax, period, label in ((axes[0], 0, \"pre-period\"), (axes[1], 1, \"post-period\")):\n", + " for g, color, name in ((0, \"tab:gray\", \"control\"), (1, \"tab:blue\", \"treated\")):\n", + " vals = df.query(f\"treated == {g} and post == {period}\")[\"spend\"]\n", + " ax.hist(vals, bins=bins, density=True, alpha=0.55, color=color, label=name)\n", + " ax.set_xscale(\"log\")\n", + " ax.set_xlabel(\"monthly spend ($, log scale)\")\n", + " ax.set_title(label)\n", + "axes[0].set_ylabel(\"density\")\n", + "axes[0].legend()\n", + "fig.suptitle(\"Spend distributions: the treated segment sits lower, the market shifts between periods\")\n", + "fig.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "c7d7cee3", + "metadata": {}, + "source": [ + "## 3. The mean answer\n", + "\n", + "Standard practice first: difference-in-differences on mean spend, with robust\n", + "standard errors.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "2b28ac74", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-18T18:33:41.017955Z", + "iopub.status.busy": "2026-07-18T18:33:41.017890Z", + "iopub.status.idle": "2026-07-18T18:33:41.022664Z", + "shell.execute_reply": "2026-07-18T18:33:41.022284Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "======================================================================\n", + " Difference-in-Differences Estimation Results \n", + "======================================================================\n", + "\n", + "Observations: 3604\n", + "Treated: 1802\n", + "Control: 1802\n", + "R-squared: 0.0939\n", + "Variance: HC1 heteroskedasticity-robust\n", + "\n", + "----------------------------------------------------------------------\n", + "Parameter Estimate Std. Err. t-stat P>|t| \n", + "----------------------------------------------------------------------\n", + "ATT 0.2178 1.7351 0.126 0.9001 \n", + "----------------------------------------------------------------------\n", + "\n", + "95% Confidence Interval: [-3.1841, 3.6197]\n", + "CV (SE/abs(ATT)): 7.9670\n", + "\n", + "Signif. codes: '***' 0.001, '**' 0.01, '*' 0.05, '.' 0.1\n", + "======================================================================\n" + ] + } + ], + "source": [ + "did = DifferenceInDifferences().fit(df, outcome=\"spend\", treatment=\"treated\", time=\"post\")\n", + "print(did.summary())\n" + ] + }, + { + "cell_type": "markdown", + "id": "fa390faa", + "metadata": {}, + "source": [ + "The mean verdict: **ATT = \\$0.22, p = 0.90**, confidence interval [-\\$3.18, \\$3.62].\n", + "By this reading the program did nothing, and it gets killed.\n", + "\n", + "Two things are wrong with that reading, and only one of them is about power:\n", + "\n", + "1. **Noise**: the long spend tail puts the DiD standard error near \\$1.74, so even the\n", + " true \\$3.01 mean effect would be hard to detect.\n", + "2. **Bias**: the market trend is multiplicative (`GAMMA = 1.06`), so *dollar* trends are\n", + " not parallel between a \\$21-median segment and a \\$31-median control group. Mean DiD\n", + " with these groups does not target the truth on this scale in the first place - the\n", + " \\$0.22 is not an unlucky draw around \\$3.01.\n", + "\n", + "CiC was built for exactly this situation: it never assumes additive-in-levels trends.\n" + ] + }, + { + "cell_type": "markdown", + "id": "1e750447", + "metadata": {}, + "source": [ + "## 4. Changes-in-Changes: the full picture\n", + "\n", + "CiC (Athey & Imbens 2006) treats the control group's period-to-period change as a\n", + "*transformation of the whole distribution* and applies that transformation to the\n", + "treated group's pre-period distribution. Formally, the counterfactual outcome\n", + "distribution is $F_{10}(F_{00}^{-1}(F_{01}(y)))$ (their Theorem 3.1): \"give every\n", + "treated customer the outcome move that a control customer at the same rank\n", + "experienced.\" Identification needs a monotone outcome model in a scalar unobservable\n", + "and time-invariance of that unobservable within groups - *not* parallel mean trends\n", + "(more on that in Section 6).\n", + "\n", + "Inference is bootstrap-only (999 replicates here, seeded). The point estimates match\n", + "the R `qte` package exactly; see the methodology registry for the parity details.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "b259b612", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-18T18:33:41.023531Z", + "iopub.status.busy": "2026-07-18T18:33:41.023475Z", + "iopub.status.idle": "2026-07-18T18:33:41.189465Z", + "shell.execute_reply": "2026-07-18T18:33:41.188983Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "========================================================================================\n", + " Changes-in-Changes (Athey & Imbens 2006) Results \n", + "========================================================================================\n", + "Observations: 3604 Mode: repeated cross-section\n", + "Cells: control pre=901, control post=901, treated pre=901, treated post=901\n", + "Inference: bootstrap (999/999 valid replicates), replicate-SD SEs, normal-approximation intervals\n", + "Point-identified interior quantile range (eq. 17): (0.0000, 1.0000)\n", + "----------------------------------------------------------------------------------------\n", + " Estimate Std.Err t P>|t| [95% Conf. Int.]\n", + "----------------------------------------------------------------------------------------\n", + " ATT 3.0476 1.0628 2.87 0.004 [ 0.9646, 5.1306] **\n", + "\n", + "Quantile treatment effects:\n", + "----------------------------------------------------------------------------------------\n", + " 0.05 4.9087 0.8252 5.95 0.000 [ 3.2914, 6.5260] ***\n", + " 0.10 5.4037 0.9124 5.92 0.000 [ 3.6154, 7.1920] ***\n", + " 0.15 5.4575 0.9586 5.69 0.000 [ 3.5787, 7.3364] ***\n", + " 0.20 5.3724 0.8286 6.48 0.000 [ 3.7483, 6.9965] ***\n", + " 0.25 5.4433 0.8918 6.10 0.000 [ 3.6953, 7.1913] ***\n", + " 0.30 5.5808 1.0359 5.39 0.000 [ 3.5504, 7.6112] ***\n", + " 0.35 4.2059 1.0267 4.10 0.000 [ 2.1936, 6.2181] ***\n", + " 0.40 4.1270 0.9387 4.40 0.000 [ 2.2871, 5.9668] ***\n", + " 0.45 4.1575 0.8804 4.72 0.000 [ 2.4318, 5.8831] ***\n", + " 0.50 3.8598 1.1207 3.44 0.001 [ 1.6632, 6.0564] ***\n", + " 0.55 2.9191 1.4494 2.01 0.044 [ 0.0782, 5.7599] *\n", + " 0.60 1.7319 1.3488 1.28 0.199 [ -0.9116, 4.3755] \n", + " 0.65 0.7939 1.4164 0.56 0.575 [ -1.9821, 3.5699] \n", + " 0.70 0.3729 1.5852 0.24 0.814 [ -2.7341, 3.4799] \n", + " 0.75 0.5906 1.5996 0.37 0.712 [ -2.5447, 3.7258] \n", + " 0.80 1.3649 1.6163 0.84 0.398 [ -1.8030, 4.5327] \n", + " 0.85 1.0424 2.4456 0.43 0.670 [ -3.7510, 5.8357] \n", + " 0.90 -0.3910 2.3746 -0.16 0.869 [ -5.0450, 4.2631] \n", + " 0.95 2.7981 3.3682 0.83 0.406 [ -3.8035, 9.3997] \n", + "========================================================================================\n", + "Signif. codes: *** p<0.001, ** p<0.01, * p<0.05\n" + ] + } + ], + "source": [ + "cic = ChangesInChanges(n_bootstrap=999, seed=SEED).fit(\n", + " df, outcome=\"spend\", treatment=\"treated\", time=\"post\"\n", + ")\n", + "print(cic.summary())\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "0d52fd55", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-18T18:33:41.190332Z", + "iopub.status.busy": "2026-07-18T18:33:41.190272Z", + "iopub.status.idle": "2026-07-18T18:33:41.427982Z", + "shell.execute_reply": "2026-07-18T18:33:41.427570Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "qe = cic.quantile_effects\n", + "\n", + "# The DGP is synthetic, so the true QTE curve is computable by Monte Carlo:\n", + "rng_mc = np.random.default_rng(123456)\n", + "u_mc = U_LO + (U_HI - U_LO) * rng_mc.beta(BETA_A, BETA_B, 2_000_000)\n", + "truth = np.quantile(h_post(u_mc) * (1 + lift(u_mc)), cic.quantiles) - np.quantile(\n", + " h_post(u_mc), cic.quantiles\n", + ")\n", + "\n", + "fig, ax = plt.subplots(figsize=(7.5, 4))\n", + "ax.fill_between(qe[\"quantile\"], qe[\"conf_low\"], qe[\"conf_high\"], alpha=0.25,\n", + " color=\"tab:blue\", label=\"pointwise 95% CI\")\n", + "ax.plot(qe[\"quantile\"], qe[\"qte\"], \"o-\", color=\"tab:blue\", label=\"CiC QTE\")\n", + "ax.plot(cic.quantiles, truth, \"--\", color=\"black\", alpha=0.7,\n", + " label=\"true effect (known by construction)\")\n", + "ax.axhline(0, color=\"gray\", lw=1)\n", + "ax.axhline(did.att, color=\"tab:red\", lw=1.2, ls=\":\", label=f\"mean DiD (${did.att:.2f})\")\n", + "ax.set_xlabel(\"spend quantile (tau)\")\n", + "ax.set_ylabel(\"treatment effect ($)\")\n", + "ax.set_title(\"The program moved the bottom of the distribution, not the mean\")\n", + "ax.legend(loc=\"upper right\")\n", + "fig.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "9fabf55a", + "metadata": {}, + "source": [ + "The QTE profile tells the real story: **+\\$4.91 at the 5th percentile, +\\$5.44 at the\n", + "25th, +\\$3.86 at the median, and nothing distinguishable from zero above the 70th**.\n", + "For a \\$15-25/month customer, a \\$5 lift is a 20-30% change - the program reactivated\n", + "near-lapsed customers, exactly its design goal.\n", + "\n", + "Note the headline ATT: **\\$3.05 (p = 0.004)**, right on the \\$3.01 truth - CiC's mean\n", + "is the mean of a *correctly constructed* counterfactual distribution, so it does not\n", + "inherit mean DiD's nonparallel-dollar-trend bias. Same data, same 2x2, two very\n", + "different answers - and here the distributional one is right by construction.\n" + ] + }, + { + "cell_type": "markdown", + "id": "a655da72", + "metadata": {}, + "source": [ + "## 5. Which quantiles moved? Joint claims and the interior range\n", + "\n", + "Reading 19 pointwise confidence intervals off the plot and declaring \"significant\n", + "below the median\" is a multiple-testing mistake - pointwise intervals over-reject\n", + "when read jointly. For joint statements use `uniform_bands()`: simultaneous sup-t\n", + "bands over the whole grid, computed at the qte package's fixed 95% level (the band\n", + "level deliberately does *not* follow `alpha`; that is the parity convention).\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "87b44d77", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-18T18:33:41.429002Z", + "iopub.status.busy": "2026-07-18T18:33:41.428932Z", + "iopub.status.idle": "2026-07-18T18:33:41.477026Z", + "shell.execute_reply": "2026-07-18T18:33:41.476615Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "sup-t critical value: 3.260\n", + "quantiles whose uniform band excludes zero: ['0.05', '0.10', '0.15', '0.20', '0.25', '0.30', '0.35', '0.40', '0.45', '0.50']\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "bands = cic.uniform_bands()\n", + "excluded = (bands[\"band_low\"] > 0) | (bands[\"band_high\"] < 0)\n", + "sig = [f\"{t:.2f}\" for t, e in zip(cic.quantiles, excluded) if e]\n", + "print(f\"sup-t critical value: {cic.sup_t_crit:.3f}\")\n", + "print(f\"quantiles whose uniform band excludes zero: {sig}\")\n", + "\n", + "fig, ax = plt.subplots(figsize=(7.5, 4))\n", + "ax.fill_between(qe[\"quantile\"], qe[\"conf_low\"], qe[\"conf_high\"], alpha=0.25,\n", + " color=\"tab:blue\", label=\"pointwise 95% CI\")\n", + "ax.plot(bands[\"quantile\"], bands[\"band_low\"], \"-\", color=\"tab:purple\", lw=1.2,\n", + " label=\"sup-t uniform band (95%)\")\n", + "ax.plot(bands[\"quantile\"], bands[\"band_high\"], \"-\", color=\"tab:purple\", lw=1.2)\n", + "ax.plot(qe[\"quantile\"], qe[\"qte\"], \"o-\", color=\"tab:blue\", label=\"CiC QTE\")\n", + "ax.axhline(0, color=\"gray\", lw=1)\n", + "ax.set_xlabel(\"spend quantile (tau)\")\n", + "ax.set_ylabel(\"treatment effect ($)\")\n", + "ax.set_title(\"Joint claim: the bands exclude zero for every quantile up to the median\")\n", + "ax.legend(loc=\"upper right\")\n", + "fig.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "d8d1bde6", + "metadata": {}, + "source": [ + "The joint statement survives: **the uniform bands exclude zero for every grid\n", + "quantile from 0.05 through 0.50, and for none above** - so \"the program lifted the\n", + "bottom half of the spend distribution\" holds as a single, simultaneous claim.\n", + "\n", + "Be precise about what the bands say above the median: they are *silent*, not\n", + "exonerating. Non-exclusion of zero is absence of evidence, not evidence of absence -\n", + "on real data you would report \"no detectable effect above the median\", never \"zero\n", + "effect\". (Notice the pointwise row at tau = 0.55: nominally significant at p = 0.044.\n", + "That is exactly the kind of isolated pointwise blip that evaporates under the joint\n", + "bands - chasing it would be the multiple-testing mistake this section is about. Here\n", + "we happen to know the truth is ~0 above the median by construction.)\n", + "\n", + "**The interior-range guardrail.** CiC quantile effects are point-identified only\n", + "strictly inside an interior range $(q_{lower}, q_{upper})$ - eq. (17) of the paper -\n", + "determined by where the treated pre-period distribution sits inside the control\n", + "pre-period support. Our sample is support-clean, so the range is the trivial\n", + "$(0, 1)$ and every grid quantile is interior. But short support is common in\n", + "practice - suppose the control sample had only covered *mid-market* customers.\n", + "CiC does not fail silently: watch the warnings this variant raises, and what happens\n", + "to the tail inference.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "3337fdbe", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-18T18:33:41.477961Z", + "iopub.status.busy": "2026-07-18T18:33:41.477898Z", + "iopub.status.idle": "2026-07-18T18:33:41.645718Z", + "shell.execute_reply": "2026-07-18T18:33:41.645289Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "interior range: (0.1698, 0.9956)\n", + "\n", + "quantiles outside the interior range (point estimates kept, inference NaN):\n", + " quantile qte se t_stat p_value conf_low conf_high\n", + " 0.05 2.726330 NaN NaN NaN NaN NaN\n", + " 0.10 4.696848 NaN NaN NaN NaN NaN\n", + " 0.15 6.264059 NaN NaN NaN NaN NaN\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "diff_diff/changes_in_changes.py:981: UserWarning: Treated pre-period outcomes fall outside the control pre-period support (Athey-Imbens Assumption 3.4 violated). The counterfactual distribution is only partially identified (Corollary 3.1): quantile effects are reliable only inside the reported (q_lower, q_upper) interior range, and the ATT involves extrapolation at the support edges.\n", + " _check_support(cells)\n", + "diff_diff/changes_in_changes.py:1324: UserWarning: Quantile effects at [0.05, 0.1, 0.15] lie outside the point-identified interior range (0.1698, 0.9956) (Athey-Imbens eq. 17 / Theorem 5.3). Point estimates are reported for qte parity, but their inference fields are set to NaN.\n", + " return _fit_distributional(\n" + ] + } + ], + "source": [ + "def make_midmarket_variant(seed=SEED, n=N_CELL):\n", + " # Same market, same program - but the control SAMPLE only covers\n", + " # mid-market customers (spend ranks 15%-85%).\n", + " rng = np.random.default_rng(seed + 1)\n", + " u00 = rng.uniform(0.15, 0.85, n)\n", + " u01 = rng.uniform(0.15, 0.85, n)\n", + " u10 = U_LO + (U_HI - U_LO) * rng.beta(BETA_A, BETA_B, n)\n", + " u11 = U_LO + (U_HI - U_LO) * rng.beta(BETA_A, BETA_B, n)\n", + " frames = []\n", + " for g, t, y in (\n", + " (0, 0, h_pre(u00)),\n", + " (0, 1, h_post(u01)),\n", + " (1, 0, h_pre(u10)),\n", + " (1, 1, h_post(u11) * (1.0 + lift(u11))),\n", + " ):\n", + " frames.append(pd.DataFrame({\"treated\": g, \"post\": t, \"spend\": y}))\n", + " return pd.concat(frames, ignore_index=True)\n", + "\n", + "\n", + "cic_v = ChangesInChanges(n_bootstrap=999, seed=SEED).fit(\n", + " make_midmarket_variant(), outcome=\"spend\", treatment=\"treated\", time=\"post\"\n", + ")\n", + "print(f\"interior range: ({cic_v.q_lower:.4f}, {cic_v.q_upper:.4f})\")\n", + "print(\"\\nquantiles outside the interior range (point estimates kept, inference NaN):\")\n", + "print(cic_v.quantile_effects[cic_v.quantile_effects[\"se\"].isna()].to_string(index=False))\n" + ] + }, + { + "cell_type": "markdown", + "id": "61d70818", + "metadata": {}, + "source": [ + "Two warnings fired, on purpose and loudly: treated customers fall outside the\n", + "control sample's support (Athey-Imbens Assumption 3.4), and the quantiles at\n", + "0.05-0.15 lie outside the resulting interior range **(0.17, 0.996)**. Those tail\n", + "effects keep their point estimates (matching the R `qte` package) but report NaN\n", + "inference - the estimator refuses to hand you confidence intervals for quantiles\n", + "where the counterfactual is extrapolated. If you see these warnings on real data,\n", + "fix the sampling frame or report the interior range alongside the tails.\n" + ] + }, + { + "cell_type": "markdown", + "id": "2b463a4c", + "metadata": {}, + "source": [ + "## 6. Scale is not a nuisance: levels, logs, and why CiC doesn't care\n", + "\n", + "Every mean-DiD practitioner has faced the question: *levels or logs?* Parallel\n", + "trends on one scale generally fails on the other, so the modeling choice changes the\n", + "answer. On our data it changes the answer *completely*:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "b2397a47", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-18T18:33:41.646801Z", + "iopub.status.busy": "2026-07-18T18:33:41.646733Z", + "iopub.status.idle": "2026-07-18T18:33:41.650456Z", + "shell.execute_reply": "2026-07-18T18:33:41.650137Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DiD on spend ($): ATT = +0.22 (p = 0.900) -> 'no effect'\n", + "DiD on log(spend): ATT = +0.1307 (p = 0.0011) -> '+14.0% - big win'\n" + ] + } + ], + "source": [ + "df_log = df.assign(log_spend=np.log(df[\"spend\"]))\n", + "did_log = DifferenceInDifferences().fit(\n", + " df_log, outcome=\"log_spend\", treatment=\"treated\", time=\"post\"\n", + ")\n", + "print(f\"DiD on spend ($): ATT = {did.att:+.2f} (p = {did.p_value:.3f}) -> 'no effect'\")\n", + "print(\n", + " f\"DiD on log(spend): ATT = {did_log.att:+.4f} (p = {did_log.p_value:.4f})\"\n", + " f\" -> '+{100 * (np.exp(did_log.att) - 1):.1f}% - big win'\"\n", + ")\n" + ] + }, + { + "cell_type": "markdown", + "id": "944d97b9", + "metadata": {}, + "source": [ + "Same data: **\\$0.22 (p = 0.90)** in dollars, **+14.0% (p = 0.001)** in logs. Neither\n", + "scale has parallel trends here (the market trend is `y -> e^ALPHA * y^GAMMA`, which is\n", + "additive in *neither* dollars nor logs across differently-composed groups), so\n", + "neither number should be trusted - but nothing in the output tells you that. The\n", + "scale choice silently *is* the identification assumption.\n", + "\n", + "CiC removes that choice from the table. Its identifying assumptions - a monotone\n", + "outcome model and time-invariant unobservables - are statements about *ranks*, so\n", + "they are unchanged by any strictly increasing transformation. For unconditional fits\n", + "the estimated counterfactual distribution is **equivariant**: fit in dollars or fit\n", + "in logs, and you get the same answer mapped through the transformation. Concretely,\n", + "the counterfactual quantiles from the levels fit equal `exp()` of the counterfactual\n", + "quantiles from the log fit, up to floating-point rounding:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "ddc89e24", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-18T18:33:41.651301Z", + "iopub.status.busy": "2026-07-18T18:33:41.651240Z", + "iopub.status.idle": "2026-07-18T18:33:41.655230Z", + "shell.execute_reply": "2026-07-18T18:33:41.654902Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " tau cf_from_levels_fit cf_from_log_fit\n", + "0.15 13.902084 13.902084\n", + "0.50 20.316616 20.316616\n", + "0.75 29.905258 29.905258\n", + "0.95 45.271539 45.271539\n", + "\n", + "max relative difference across all 19 quantiles: 0.00e+00\n" + ] + } + ], + "source": [ + "cic_log = ChangesInChanges(n_bootstrap=0).fit(\n", + " df_log, outcome=\"log_spend\", treatment=\"treated\", time=\"post\"\n", + ")\n", + "\n", + "# Counterfactual quantiles = treated-post quantiles minus the QTE. CiC's internal\n", + "# quantile convention is R type-1 (an order statistic - no interpolation), which\n", + "# numpy calls \"inverted_cdf\". Order statistics commute with monotone transforms,\n", + "# and no n*tau lands on an integer (901 is coprime to 20), so the identity is\n", + "# exact up to the exp/log round-trip:\n", + "grid = cic.quantiles\n", + "q11_lvl = np.quantile(y11, grid, method=\"inverted_cdf\")\n", + "q11_log = np.quantile(np.log(y11), grid, method=\"inverted_cdf\")\n", + "cf_levels_fit = q11_lvl - cic.quantile_effects[\"qte\"].to_numpy()\n", + "cf_log_fit = np.exp(q11_log - cic_log.quantile_effects[\"qte\"].to_numpy())\n", + "\n", + "comparison = pd.DataFrame(\n", + " {\"tau\": grid, \"cf_from_levels_fit\": cf_levels_fit, \"cf_from_log_fit\": cf_log_fit}\n", + ")\n", + "print(comparison.iloc[[2, 9, 14, 18]].to_string(index=False))\n", + "max_rel = np.max(np.abs(cf_levels_fit - cf_log_fit) / cf_levels_fit)\n", + "print(f\"\\nmax relative difference across all 19 quantiles: {max_rel:.2e}\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "b543d7a2", + "metadata": {}, + "source": [ + "The two fits agree to floating-point precision (the only daylight is the `exp`/`log`\n", + "round-trip, at most a few units in the last bit - on this machine it is exactly\n", + "zero). The levels-vs-logs debate simply does not arise for CiC's distributional\n", + "answer. (The scope matters: this exact equivariance holds for *unconditional* fits -\n", + "the covariate branch in Section 7 runs linear quantile regressions, which are not\n", + "equivariant to nonlinear transforms. And means never commute with transforms, so the\n", + "ATT is scale-specific for every estimator, CiC included.)\n", + "\n", + "**QDiD does not have this property**, and that is the substance of Athey & Imbens's\n", + "recommendation (p. 447): QDiD imposes the additive quantile-DiD model on whatever\n", + "scale you happen to fit, so its answer *shifts* with the scale:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "9a6de829", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-18T18:33:41.656125Z", + "iopub.status.busy": "2026-07-18T18:33:41.656065Z", + "iopub.status.idle": "2026-07-18T18:33:41.661779Z", + "shell.execute_reply": "2026-07-18T18:33:41.661453Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " tau QDiD_levels QDiD_logs_backmapped gap CiC_levels\n", + "0.25 5.61 5.61 -0.00 5.44\n", + "0.50 2.59 2.83 -0.24 3.86\n", + "0.75 -3.77 -1.67 -2.10 0.59\n", + "0.90 -8.48 -2.84 -5.65 -0.39\n", + "\n", + "QDiD levels-vs-logs gap: median |gap| = 0.24, max |gap| = 5.65 (at tau = 0.90)\n" + ] + } + ], + "source": [ + "qdid = QDiD(n_bootstrap=0).fit(df, outcome=\"spend\", treatment=\"treated\", time=\"post\")\n", + "qdid_log = QDiD(n_bootstrap=0).fit(\n", + " df_log, outcome=\"log_spend\", treatment=\"treated\", time=\"post\"\n", + ")\n", + "\n", + "# Back-transform the log-scale QDiD profile to dollars (QDiD's treated-post\n", + "# quantiles are R type-7, numpy's default \"linear\" interpolation):\n", + "q11_t7_log = np.quantile(np.log(y11), grid, method=\"linear\")\n", + "qdid_backmapped = np.exp(q11_t7_log) - np.exp(q11_t7_log - qdid_log.quantile_effects[\"qte\"].to_numpy())\n", + "qdid_gap = qdid.quantile_effects[\"qte\"].to_numpy() - qdid_backmapped\n", + "\n", + "table = pd.DataFrame(\n", + " {\n", + " \"tau\": grid,\n", + " \"QDiD_levels\": qdid.quantile_effects[\"qte\"].to_numpy(),\n", + " \"QDiD_logs_backmapped\": qdid_backmapped,\n", + " \"gap\": qdid_gap,\n", + " \"CiC_levels\": cic.quantile_effects[\"qte\"].to_numpy(),\n", + " }\n", + ")\n", + "print(table.iloc[[4, 9, 14, 17]].round(2).to_string(index=False))\n", + "print(f\"\\nQDiD levels-vs-logs gap: median |gap| = {np.median(np.abs(qdid_gap)):.2f}, \"\n", + " f\"max |gap| = {np.max(np.abs(qdid_gap)):.2f} (at tau = {grid[np.argmax(np.abs(qdid_gap))]:.2f})\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "d5747160", + "metadata": {}, + "source": [ + "The gap grows toward the top of the distribution - **\\$0.24 at the median, \\$2.10 at\n", + "the 75th percentile, \\$5.65 at the 90th** - and worse, QDiD-in-levels reports a\n", + "*loss* of \\$8.48 at the 90th percentile where the truth (and CiC) say zero: its\n", + "additive dollar model extrapolates the control group's premium-segment dollar growth\n", + "onto a treated segment that has no premium customers. Fit QDiD on logs instead and\n", + "that loss shrinks by two-thirds. An estimator whose story changes with the analyst's\n", + "scale choice is a fragile primary; use QDiD as a cross-check beside CiC, not instead\n", + "of it. (When QDiD's implied counterfactual quantile curve is non-monotone - another\n", + "symptom of the same model failure - the fit warns; on this data it stays monotone on\n", + "both scales.)\n" + ] + }, + { + "cell_type": "markdown", + "id": "71f41d36", + "metadata": {}, + "source": [ + "## 7. When the mix differs: covariates\n", + "\n", + "CiC's time-invariance assumption can fail *observably*: if the treated and control\n", + "groups differ in composition on a variable that also drives the period-to-period\n", + "trend, the unconditional counterfactual attributes the wrong trend to the treated\n", + "group. The fix is to condition: `covariates=` runs the comparison *within* covariate\n", + "values (per-cell linear quantile regressions on a 99-tau grid - an exact port of the\n", + "R `qte` package's `xformla` branch, including its conditional-rank imputation).\n", + "\n", + "Here is a second program where that matters. The outcome is an engagement index; the\n", + "treated group skews toward **longer-tenure** customers (`+0.8` years on average), and\n", + "this quarter's organic engagement growth is strongly tenure-driven while tenure's\n", + "*level* link is weak - latent-index slopes `0.6` (trend) vs `0.15` (level), which the\n", + "`x8` index scaling turns into **4.8 vs 1.2 engagement points per tenure-year**. That\n", + "trend/level decoupling is what makes the confounding bite. The program's true effect\n", + "is **6.0 points**, constant for everyone.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "b4fce306", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-18T18:33:41.662858Z", + "iopub.status.busy": "2026-07-18T18:33:41.662802Z", + "iopub.status.idle": "2026-07-18T18:34:43.494364Z", + "shell.execute_reply": "2026-07-18T18:34:43.493886Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "true effect: 6.0 points\n", + "unconditional CiC: ATT = 9.38 CI [8.32, 10.45]\n", + "conditional CiC: ATT = 6.53 CI [5.35, 7.70] (covariates=['tenure'])\n" + ] + } + ], + "source": [ + "COV_SEED, COV_N = 272, 299 # cell size coprime to 100 (QR tau grid)\n", + "COV_EFFECT = 6.0 # true program effect, engagement points\n", + "COV_SHIFT, COV_TREND, COV_LEVEL, COV_SCALE = 0.8, 0.6, 0.15, 8.0\n", + "\n", + "\n", + "def make_engagement_data(seed=COV_SEED, n=COV_N):\n", + " rng = np.random.default_rng(seed)\n", + " frames = []\n", + " for g in (0, 1):\n", + " for t in (0, 1):\n", + " x = rng.uniform(0, 2, n) + COV_SHIFT * g # tenure (years, centered scale)\n", + " noise = rng.normal(0, 0.4, n)\n", + " y = COV_SCALE * (0.5 + COV_LEVEL * x + COV_TREND * x * t + noise) + COV_EFFECT * g * t\n", + " frames.append(pd.DataFrame({\"treated\": g, \"post\": t, \"tenure\": x, \"engagement\": y}))\n", + " return pd.concat(frames, ignore_index=True)\n", + "\n", + "\n", + "eng = make_engagement_data()\n", + "\n", + "cic_unc = ChangesInChanges(n_bootstrap=999, seed=SEED).fit(\n", + " eng, outcome=\"engagement\", treatment=\"treated\", time=\"post\"\n", + ")\n", + "# The covariate branch refits every per-cell quantile regression inside every\n", + "# bootstrap replicate - this cell takes about a minute:\n", + "cic_cov = ChangesInChanges(n_bootstrap=99, seed=SEED).fit(\n", + " eng, outcome=\"engagement\", treatment=\"treated\", time=\"post\", covariates=[\"tenure\"]\n", + ")\n", + "\n", + "print(f\"true effect: {COV_EFFECT:.1f} points\")\n", + "print(f\"unconditional CiC: ATT = {cic_unc.att:.2f} \"\n", + " f\"CI [{cic_unc.conf_int[0]:.2f}, {cic_unc.conf_int[1]:.2f}]\")\n", + "print(f\"conditional CiC: ATT = {cic_cov.att:.2f} \"\n", + " f\"CI [{cic_cov.conf_int[0]:.2f}, {cic_cov.conf_int[1]:.2f}] (covariates=['tenure'])\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "99588c79", + "metadata": {}, + "source": [ + "The unconditional fit reports **9.38 with CI [8.32, 10.45]** - confidently wrong,\n", + "because the tenure-driven trend is not a monotone transformation of the *outcome*\n", + "(the trend/level decoupling is what breaks the unconditional assumption). Conditioning\n", + "on tenure brings the estimate to **6.53 with CI [5.35, 7.70]**, covering the truth.\n", + "\n", + "Practical notes for the covariate branch:\n", + "\n", + "- Covariates must be **numeric** (dummy-encode categoricals first).\n", + "- A **conditional support diagnostic** replaces the interior-range guardrail: if more\n", + " than 10% of treated pre-period outcomes fall outside their conditional quantile\n", + " envelope, a warning flags out-of-support extrapolation (Melly & Santangelo 2015,\n", + " Assumption 4). This fit is clean, so no warning fired.\n", + "- Bootstrap cost scales with the quantile-regression refits - budget minutes, not\n", + " seconds, at larger sizes (the same cost profile as the R `qte` package).\n" + ] + }, + { + "cell_type": "markdown", + "id": "8caefb49", + "metadata": {}, + "source": [ + "## 8. What next\n", + "\n", + "Fitted results know their own follow-up work: `practitioner_next_steps()` reads the\n", + "estimator type, covariate status, and bootstrap health, and returns the remaining\n", + "steps of the Baker, Callaway, Cunningham, Goodman-Bacon & Sant'Anna (2025) workflow,\n", + "with runnable snippets that mirror this fit's exact specification.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "ae0c2036", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-18T18:34:43.495544Z", + "iopub.status.busy": "2026-07-18T18:34:43.495470Z", + "iopub.status.idle": "2026-07-18T18:34:43.497732Z", + "shell.execute_reply": "2026-07-18T18:34:43.497314Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "============================================================\n", + "Practitioner Guidance — ChangesInChanges (CiC)\n", + "Baker et al. (2025) 8-Step Workflow\n", + "============================================================\n", + "\n", + "Recommended next steps (9 remaining):\n", + "\n", + " * [HIGH] Step 1: Define target parameter\n", + " Why: State explicitly what causal effect you are estimating (ATT, ATT(g,t), weighted/unweighted) and what policy question it answers.\n", + " >>> # What is the target parameter? ATT? Weighted or unweighted?\n", + "\n", + " * [HIGH] Step 2: State identification assumptions (distributional)\n", + " Why: Name the distributional assumptions you are invoking - not a mean parallel-trends variant. CiC (Athey-Imbens 2006, Assumptions 3.1-3.4) requires a monotone outcome model h(U, T) strictly increasing in a scalar unobservable U, time-invariance of U within groups (U independent of T given G), and support inclusion; add no-anticipation and the continuous-outcome scope.\n", + " >>> # Which distributional assumptions? Monotonicity in U? Time-invariance? Support?\n", + "\n", + " * [HIGH] Step 3: Assess the distributional identifying assumptions (not mean parallel trends)\n", + " Why: CiC does not identify off mean parallel trends - and does not require them. Identification (Athey-Imbens 2006, Assumptions 3.1-3.4) needs a monotone outcome model h(U, T) strictly increasing in a scalar unobservable U, time-invariance of U within groups (U independent of T given G), and support inclusion - none directly testable in a 2x2 design. Under a nonlinear h, group mean trends need not be parallel in a valid CiC design, so a pre-period mean-trend break is NOT by itself evidence against CiC; check_parallel_trends() on pre-period means is at most a descriptive mean-DiD anchor, and the relevant falsification exercise is the two-pre-period distributional placebo (see the Placebo step). Also note additive random group-time shocks bias CiC - unlike linear DiD, where they only complicate inference - and are undetectable in a 2x2 (p. 476).\n", + " >>> # CiC does not require mean parallel trends - the relevant\n", + " >>> # falsification is the two-pre-period distributional placebo\n", + " >>> # (see the Placebo step). Optional DESCRIPTIVE mean anchor\n", + " >>> # (needs extra pre-periods in the SOURCE panel):\n", + " >>> from diff_diff import check_parallel_trends\n", + " >>> pt = check_parallel_trends(source_panel, outcome='y',\n", + " >>> time='period',\n", + " >>> treatment_group='treated')\n", + " >>> # a mean-trend break here is NOT by itself evidence against CiC\n", + "\n", + " - [MEDIUM] Step 4: Confirm the 2x2 distributional design fits the question\n", + " Why: CiC in diff-diff is 2x2-only (the Athey-Imbens Section 6 multi-group/multi-period extension is deferred; REGISTRY ChangesInChanges). Collapsing a staggered panel to a 2x2 discards timing variation - for staggered mean effects use CallawaySantAnna or another heterogeneity-robust estimator. If the fit warned about heavy ties (>10% duplicate outcome values within a cell), the outcome looks discrete: the continuous machinery silently delivers one endpoint of the Athey-Imbens Section 4 bounds, not a point estimate (discrete-outcome bounds are deferred) - interpret accordingly.\n", + " >>> # 2x2-only. For staggered mean effects switch estimators:\n", + " >>> # from diff_diff import CallawaySantAnna\n", + " >>> # Ties warning at fit? Point estimates are one endpoint\n", + " >>> # of the Athey-Imbens Section 4 bounds (discrete\n", + " >>> # outcomes; deferred), not point identification.\n", + "\n", + " - [MEDIUM] Step 6: Respect the interior point-identification range (eq. 17)\n", + " Why: Unconditional CiC quantile effects are point-identified only strictly inside the open interval (q_lower, q_upper) (Athey-Imbens eq. 17 / Theorem 5.3). Quantiles at or outside the bounds keep their point estimates (qte parity) but report NaN inference. If the fit also warned about support (Assumption 3.4), the counterfactual distribution is only partially identified (Corollary 3.1) and the ATT involves extrapolation at the support edges. Report the interior range (summary() prints it) and read tail quantiles as partially identified.\n", + " >>> print(f'interior range: ({results.q_lower:.3f}, '\n", + " >>> f'{results.q_upper:.3f})')\n", + " >>> qe = results.quantile_effects\n", + " >>> outside = qe[(qe['quantile'] <= results.q_lower) |\n", + " >>> (qe['quantile'] >= results.q_upper)]\n", + " >>> print(outside) # point estimates kept, inference NaN by design\n", + "\n", + " - [MEDIUM] Step 6: Placebo ChangesInChanges on two pre-periods\n", + " Why: The 2x2 design has no extra pre-periods by definition, but if the source panel has two or more pre-treatment periods, refit the same estimator on two of them with the later relabeled as post. QTE and ATT should be near zero - systematic placebo 'effects' flag a time-invariance violation. Note run_all_placebo_tests() vets the MEAN DiD only; the distributional placebo is this refit.\n", + " >>> # Requires >= 2 pre-periods in the SOURCE panel:\n", + " >>> from diff_diff import ChangesInChanges\n", + " >>> pre = source_panel[source_panel['period'].isin([p0, p1])].copy()\n", + " >>> pre['post'] = (pre['period'] == p1).astype(int)\n", + " >>> placebo = ChangesInChanges(n_bootstrap=200, seed=42).fit(\n", + " >>> pre, outcome='y', treatment='treated', time='post')\n", + " >>> # n_bootstrap=200 is the default; seed=42 is illustrative (default seed=None)\n", + " >>> # carry over quantiles=/alpha= if you customized them\n", + " >>> print(placebo.summary()) # QTE/ATT should be ~ 0\n", + "\n", + " * [HIGH] Step 7: Read the full QTE profile with uniform bands\n", + " Why: Distributional heterogeneity is the point of the estimator - report quantile_effects, not just the headline ATT. When reading the profile jointly across quantiles, pointwise CIs over-reject; uniform_bands() gives sup-t simultaneous bands over the quantile grid at a FIXED 95% level (qte parity - the band level does not follow alpha; the pointwise CIs do). Rows with NaN se (no bootstrap, failed replicate gate, or outside the interior range in an unconditional CiC fit) get NaN bands.\n", + " >>> print(results.quantile_effects) # per-quantile QTE + pointwise inference\n", + " >>> print(results.uniform_bands()) # sup-t simultaneous bands (fixed 95%)\n", + "\n", + " - [MEDIUM] Step 8: Re-estimate with covariates if composition changed\n", + " Why: In repeated cross-sections especially, composition change across periods undermines the time-invariance assumption; the conditional fit assumes invariance conditional on the covariates instead. It ports qte's xformla branch: per-cell linear quantile regressions on a fixed internal 99-tau grid with conditional ranks, integrating over treated PRE-period covariates (qte parity; the full Melly-Santangelo treated-post integration is a documented deferral). Numeric covariates only - dummy-encode categoricals first. Runtime note: every bootstrap replicate refits every per-cell quantile regression, so covariate fits cost tens of seconds at moderate cell sizes.\n", + " >>> from diff_diff import ChangesInChanges\n", + " >>> results_cov = ChangesInChanges(n_bootstrap=200, seed=42).fit(\n", + " >>> data, outcome='y', treatment='treated', time='post',\n", + " >>> covariates=['x1', 'x2'])\n", + " >>> # n_bootstrap=200 is the default; seed=42 is illustrative (default seed=None)\n", + " >>> # carry over quantiles=/alpha= if you customized them\n", + " >>> print(results.att, results_cov.att) # compare ATT + QTE profiles\n", + "\n", + " - [MEDIUM] Step 8: Compare with QDiD and mean DiD\n", + " Why: QDiD is the natural comparison estimator (same 2x2 cells, different justifying model); broadly agreeing QTE profiles strengthen the distributional conclusions, with CiC remaining the recommended primary (p. 447). The linear-DiD ATT is a useful anchor: CiC's ATT can differ from it when the outcome model is nonlinear, so a gap is informative about nonlinearity rather than a red flag on its own - report both.\n", + " >>> from diff_diff import QDiD, DifferenceInDifferences\n", + " >>> qdid_results = QDiD(n_bootstrap=200, seed=42).fit(\n", + " >>> data, outcome='y', treatment='treated', time='post')\n", + " >>> # n_bootstrap=200 is the default; seed=42 is illustrative (default seed=None)\n", + " >>> # carry over quantiles=/alpha= if you customized them\n", + " >>> did_results = DifferenceInDifferences().fit(\n", + " >>> data, outcome='y', treatment='treated', time='post')\n", + " >>> print(results.att, qdid_results.att, did_results.att)\n", + "\n", + "============================================================\n", + "\n" + ] + } + ], + "source": [ + "guidance = practitioner_next_steps(cic)\n" + ] + }, + { + "cell_type": "markdown", + "id": "666e48b9", + "metadata": {}, + "source": [ + "### Takeaways\n", + "\n", + "- **When the question is \"who moved?\", the mean is the wrong summary.** Our program\n", + " produced +\\$5 effects across the bottom half of the spend distribution while mean\n", + " DiD read \\$0.22 (p = 0.90) - both noisy *and* biased under a nonlinear market trend.\n", + "- **CiC gives you the whole distribution for one bootstrap**: ATT (here \\$3.05,\n", + " matching the \\$3.01 truth), per-quantile effects with pointwise CIs, and sup-t\n", + " uniform bands for joint claims.\n", + "- **Guardrails are loud**: short support triggers explicit warnings and NaN inference\n", + " outside the interior range instead of silent extrapolation.\n", + "- **Scale-robustness is CiC's differentiator**: levels-vs-logs changes mean DiD's\n", + " verdict from \"nothing\" to \"+14%\" and moves QDiD's profile by dollars, while CiC's\n", + " distributional answer is identical either way (unconditional fits).\n", + "- **Composition differences are fixable**: `covariates=` turned a confidently-wrong\n", + " 9.4 into a truth-covering 6.5 in the tenure example.\n", + "- CiC is **2x2 only**: for staggered rollouts use `CallawaySantAnna`; for mean-only\n", + " questions with trustworthy parallel trends, plain DiD remains simpler.\n", + "\n", + "### Not covered here (documented deferrals)\n", + "\n", + "Discrete-outcome bounds (Athey-Imbens Section 4 - the ties warning marks that\n", + "boundary), analytical standard errors, the full Melly-Santangelo covariate\n", + "estimator, and staggered/multi-period distributional DiD. See `TODO.md` and the\n", + "methodology registry for status.\n", + "\n", + "### References\n", + "\n", + "- Athey, S. & Imbens, G. W. (2006). Identification and Inference in Nonlinear\n", + " Difference-in-Differences Models. *Econometrica*, 74(2), 431-497.\n", + "- Melly, B. & Santangelo, G. (2015). The Changes-in-Changes Model with Covariates.\n", + " Working paper.\n", + "- Baker, A., Callaway, B., Cunningham, S., Goodman-Bacon, A. & Sant'Anna, P. H. C.\n", + " (2025). Difference-in-Differences Designs: A Practitioner's Guide.\n", + "- Callaway, B. `qte`: Quantile Treatment Effects (R package) - the parity target for\n", + " this implementation.\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.14.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/tutorials/README.md b/docs/tutorials/README.md index 6b7154b13..7024dad45 100644 --- a/docs/tutorials/README.md +++ b/docs/tutorials/README.md @@ -135,6 +135,13 @@ Power-analysis decision guide for geo experiments (framed on a 50-state staggere - When a clean-tail 2×2 is unbiased, the small-holdout and few-clusters caveats, and a CS-vs-2×2 decision guide - Fully self-contained: runs live (no committed data files) +### 25. Synthetic Control for a Policy Evaluation: Two Routes to Inference (`25_synthetic_control_policy.ipynb`) +A single state adopts a clean-energy standard and no other state is a clean control - `SyntheticControl` builds a weighted donor-blend counterfactual, and with one treated unit the analytical inference fields are NaN by design, so the tutorial walks both genuine inference routes: +- Philosophy A - compare across regions: the ADH (2010) in-space placebo permutation (`in_space_placebo()`, RMSPE-ratio rank p-value) and the Firpo-Possebom (2018) confidence set +- Philosophy B - compare across time: Chernozhukov-Wuthrich-Zhu (2021) conformal inference, inverting a permutation-over-time test into a p-value for a hypothesized effect path and per-post-period confidence intervals +- The two philosophies side by side: what each does and does not protect against, and how to report them together +- Fully self-contained: runs live (no committed data files) + ### 26. Composition Drift & Survey Calibration with balance (`26_composition_drift_calibration.ipynb`) The failure-mode companion to Meta balance's `balance_diff_diff_brfss` tutorial: when non-response drift correlates with treatment timing, the design-weight DiD itself is biased and calibration becomes essential for the *causal* estimand: - BRFSS-style smoking-ban DGP with no systematic arm-specific trends (parallel trends hold in expectation; planted ATT -3.0pp, realized -2.98pp) and treatment-correlated non-response drift @@ -144,6 +151,14 @@ The failure-mode companion to Meta balance's `balance_diff_diff_brfss` tutorial: - Estimator sweep (CS / SunAbraham / ImputationDiD), `survey_metadata` DEFF diagnostics, and `as_balance_diagnostic` cross-package diagnostics - Requires `pip install "balance>=0.21"` (this tutorial only); fully self-contained data +### 27. When the Average Hides the Action: Distributional DiD with Changes-in-Changes (`27_cic_distributional_effects.ipynb`) +A loyalty program looks dead on mean DiD ($0.22, p = 0.90) but in truth lifted the bottom half of the spend distribution - `ChangesInChanges` (Athey & Imbens 2006) recovers the full quantile-treatment-effect profile: +- Reading a QTE profile, and making joint "which quantiles moved" claims with sup-t uniform bands (they exclude zero for exactly tau = 0.05-0.50 here) +- The interior-range guardrail live: a short-support control sample triggers loud warnings and NaN tail inference instead of silent extrapolation +- The scale-equivariance centerpiece: levels-vs-logs flips mean DiD's verdict and shifts QDiD's profile by dollars, while CiC's counterfactual quantiles agree to floating-point precision (unconditional fits) +- Covariate-composition confounding fixed with `covariates=` (quantile-regression conditioning, qte `xformla` parity), and the `practitioner_next_steps()` close +- Companion drift-test file (`tests/test_t27_cic_distributional_effects_drift.py`); fully self-contained (runs live, no committed data files) + ## Running the Notebooks 1. Install diff-diff with dependencies: diff --git a/tests/test_t27_cic_distributional_effects_drift.py b/tests/test_t27_cic_distributional_effects_drift.py new file mode 100644 index 000000000..6bd7c4f71 --- /dev/null +++ b/tests/test_t27_cic_distributional_effects_drift.py @@ -0,0 +1,452 @@ +"""Drift detection for Tutorial 27 +(``docs/tutorials/27_cic_distributional_effects.ipynb``). + +The tutorial's narrative rests on five quantitative claims: + +1. **The mean hides the action.** Mean DiD on spend reads ~$0.22 (p ~ 0.90) + while the true mean effect is $3.01 by construction - and CiC's ATT + (~$3.05) lands on the truth. The gap is bias, not just noise: the market + trend is multiplicative, so dollar trends are not parallel. +2. **The bands split at the median.** Sup-t uniform bands exclude zero for + exactly tau = 0.05..0.50 and nowhere above - the tutorial's joint + "bottom half moved" claim. +3. **The guardrail is loud.** The mid-market-control variant fires the + Assumption-3.4 support warning plus the interior-range warning, reports + interior range (0.1698, 0.9956), and NaNs inference at tau = 0.05-0.15 + while keeping point estimates. +4. **Scale-equivariance (the centerpiece).** The unconditional CiC + counterfactual quantiles from the levels fit equal exp() of the log-fit + ones. The property is proven exactly (private-helper route) by + ``test_cic_scale_invariance_nonlinear_dgp`` in + ``tests/test_methodology_changes_in_changes.py``; here we assert the + tutorial's PUBLIC-API construction (type-1 ``inverted_cdf`` treated-post + quantiles minus the reported QTE - exact because the cell size 901 is + coprime to the quantile-grid denominator 20) at rtol 1e-14, not bit + equality: the exp/log round-trip is libm-dependent across the CI OS + matrix. QDiD has no such property: its levels-vs-logs gap grows toward + the top (~-0.24 / -2.10 / -5.65 at tau = 0.50 / 0.75 / 0.90) and + QDiD-in-levels reports ~-$8.48 at tau = 0.90 where the truth is ~0. +5. **Covariates fix composition confounding.** On the tenure design (ported + from the calibrated ``_make_shift_dgp`` in the methodology tests) the + unconditional ATT is ~9.38 with a truth-excluding CI; ``covariates= + ['tenure']`` gives ~6.53 with a truth-covering CI (truth 6.0). + +``pytest --nbmake`` only checks that cells execute; ``nbsphinx_execute = +"never"`` means RTD renders the committed outputs. These tests re-derive the +load-bearing numbers from the same public API the notebook uses and +cross-check the rendered surface, so library drift or notebook-only edits +fail loudly. + +Structure (T24/T25 split): deterministic single-fit pins run unmarked; the +covariate quantile-regression bootstrap re-derivation (~1 min of LP solves, +not ``ci_params``-scalable - it must reproduce the notebook's exact +seed/n_bootstrap numbers) is ``@pytest.mark.slow`` and runs in the ``-m ''`` +CI legs. +""" + +from __future__ import annotations + +import math +import warnings + +import numpy as np +import pandas as pd +import pytest +from scipy import stats + +from diff_diff import ChangesInChanges, DifferenceInDifferences, QDiD, practitioner_next_steps +from tests._tutorial_drift import assert_quotes_in_rendered, notebook_markdown + +NB = "docs/tutorials/27_cic_distributional_effects.ipynb" + +# Locked design - must stay in sync with the notebook's DGP cells +# (cross-checked by ``test_notebook_constants_match``). +SEED = 27 +N_CELL = 901 # 17*53 - coprime to 20 (quantile grid) and 100 (QR tau grid) +MU_LOG, SIGMA_LOG = 3.4, 0.75 +GAMMA, ALPHA = 1.06, -0.17 +U_LO, U_HI = 0.05, 0.90 +BETA_A, BETA_B = 1.2, 2.2 +LIFT_MAX, LIFT_MID, LIFT_SCALE = 0.65, 0.22, 0.07 + +COV_SEED, COV_N = 272, 299 +COV_EFFECT = 6.0 +COV_SHIFT, COV_TREND, COV_LEVEL, COV_SCALE = 0.8, 0.6, 0.15, 8.0 + + +# --------------------------------------------------------------------------- # +# Faithful copies of the notebook's DGP helpers +# --------------------------------------------------------------------------- # +def h_pre(u): + return np.exp(MU_LOG + SIGMA_LOG * stats.norm.ppf(u)) + + +def h_post(u): + return np.exp(ALPHA + GAMMA * (MU_LOG + SIGMA_LOG * stats.norm.ppf(u))) + + +def lift(u): + return LIFT_MAX / (1.0 + np.exp((u - LIFT_MID) / LIFT_SCALE)) + + +def make_spend_data(seed=SEED, n=N_CELL): + rng = np.random.default_rng(seed) + u00 = rng.uniform(0.0005, 0.9995, n) + u01 = rng.uniform(0.0005, 0.9995, n) + u10 = U_LO + (U_HI - U_LO) * rng.beta(BETA_A, BETA_B, n) + u11 = U_LO + (U_HI - U_LO) * rng.beta(BETA_A, BETA_B, n) + frames = [] + for g, t, y in ( + (0, 0, h_pre(u00)), + (0, 1, h_post(u01)), + (1, 0, h_pre(u10)), + (1, 1, h_post(u11) * (1.0 + lift(u11))), + ): + frames.append(pd.DataFrame({"treated": g, "post": t, "spend": y})) + return pd.concat(frames, ignore_index=True) + + +def make_midmarket_variant(seed=SEED, n=N_CELL): + rng = np.random.default_rng(seed + 1) + u00 = rng.uniform(0.15, 0.85, n) + u01 = rng.uniform(0.15, 0.85, n) + u10 = U_LO + (U_HI - U_LO) * rng.beta(BETA_A, BETA_B, n) + u11 = U_LO + (U_HI - U_LO) * rng.beta(BETA_A, BETA_B, n) + frames = [] + for g, t, y in ( + (0, 0, h_pre(u00)), + (0, 1, h_post(u01)), + (1, 0, h_pre(u10)), + (1, 1, h_post(u11) * (1.0 + lift(u11))), + ): + frames.append(pd.DataFrame({"treated": g, "post": t, "spend": y})) + return pd.concat(frames, ignore_index=True) + + +def make_engagement_data(seed=COV_SEED, n=COV_N): + rng = np.random.default_rng(seed) + frames = [] + for g in (0, 1): + for t in (0, 1): + x = rng.uniform(0, 2, n) + COV_SHIFT * g + noise = rng.normal(0, 0.4, n) + y = COV_SCALE * (0.5 + COV_LEVEL * x + COV_TREND * x * t + noise) + COV_EFFECT * g * t + frames.append(pd.DataFrame({"treated": g, "post": t, "tenure": x, "engagement": y})) + return pd.concat(frames, ignore_index=True) + + +def true_mean_effect(n_mc=2_000_000, seed=123456): + rng = np.random.default_rng(seed) + u = U_LO + (U_HI - U_LO) * rng.beta(BETA_A, BETA_B, n_mc) + return float(np.mean(h_post(u) * lift(u))) + + +# --------------------------------------------------------------------------- # +# Shared fits (module-scoped: each is seconds or less) +# --------------------------------------------------------------------------- # +@pytest.fixture(scope="module") +def df(): + return make_spend_data() + + +@pytest.fixture(scope="module") +def df_log(df): + return df.assign(log_spend=np.log(df["spend"])) + + +@pytest.fixture(scope="module") +def cic(df): + with warnings.catch_warnings(): + warnings.simplefilter("error") + return ChangesInChanges(n_bootstrap=999, seed=SEED).fit( + df, outcome="spend", treatment="treated", time="post" + ) + + +@pytest.fixture(scope="module") +def did(df): + return DifferenceInDifferences().fit(df, outcome="spend", treatment="treated", time="post") + + +class TestMainStory: + def test_cell_sizes_coprime_to_grids(self): + # Structural precondition of the invariance demo (no n*tau knife + # edges for the type-1 / inverted_cdf agreement) and of the QR + # vertex-degeneracy avoidance in the covariate section. + assert math.gcd(N_CELL, 20) == 1 + assert math.gcd(N_CELL, 100) == 1 + assert math.gcd(COV_N, 100) == 1 + + def test_main_fits_warning_free_and_support_clean(self, df, df_log, cic): + y00 = df.query("treated == 0 and post == 0")["spend"].to_numpy() + y10 = df.query("treated == 1 and post == 0")["spend"].to_numpy() + assert y00.min() < y10.min() and y10.max() < y00.max() + assert np.isfinite(cic.att) # fixture itself fit under simplefilter("error") + # cic fixture already fit under simplefilter("error"); the other + # main fits must be warning-free too (incl. QDiD monotonicity on + # BOTH scales - the prose claims it stays monotone). + with warnings.catch_warnings(): + warnings.simplefilter("error") + DifferenceInDifferences().fit(df, outcome="spend", treatment="treated", time="post") + ChangesInChanges(n_bootstrap=0).fit( + df_log, outcome="log_spend", treatment="treated", time="post" + ) + QDiD(n_bootstrap=0).fit(df, outcome="spend", treatment="treated", time="post") + QDiD(n_bootstrap=0).fit(df_log, outcome="log_spend", treatment="treated", time="post") + + def test_mean_did_verdict(self, did): + # "$0.22, p = 0.90" - insignificant AND biased (truth is ~$3.01). + assert abs(did.att - 0.22) < 0.01 + assert abs(did.p_value - 0.900) < 0.005 + truth = true_mean_effect() + assert abs(truth - 3.01) < 0.01 + assert abs(did.att - truth) > 2.5 + + def test_cic_att_matches_truth(self, cic, did): + assert abs(cic.att - 3.05) < 0.01 + assert cic.p_value < 0.01 + assert abs(cic.att - true_mean_effect()) < 0.1 + assert abs(cic.att - did.att) > 2.5 + + def test_qte_profile_pins(self, cic): + qe = cic.quantile_effects + for tau, expected in ((0.05, 4.91), (0.25, 5.44), (0.50, 3.86), (0.75, 0.59)): + got = float(qe.loc[np.isclose(qe["quantile"], tau), "qte"].iloc[0]) + assert abs(got - expected) < 0.01, f"tau={tau}: {got} vs quoted {expected}" + + def test_uniform_bands_split_at_median(self, cic): + bands = cic.uniform_bands() + excluded = ((bands["band_low"] > 0) | (bands["band_high"] < 0)).to_numpy() + # The joint claim: zero excluded for EXACTLY tau = 0.05..0.50. + expected = cic.quantiles <= 0.5 + np.testing.assert_array_equal(excluded, expected) + + def test_main_interior_range_trivial(self, cic): + assert cic.q_lower == 0.0 + assert cic.q_upper == 1.0 + + +class TestGuardrailVariant: + def test_variant_warns_and_nans_the_tail(self): + with pytest.warns(UserWarning, match="Assumption 3.4"): + with pytest.warns(UserWarning, match="outside the point-identified interior"): + cic_v = ChangesInChanges(n_bootstrap=999, seed=SEED).fit( + make_midmarket_variant(), outcome="spend", treatment="treated", time="post" + ) + assert abs(cic_v.q_lower - 0.1698) < 0.001 + assert abs(cic_v.q_upper - 0.9956) < 0.001 + qe = cic_v.quantile_effects + nan_taus = qe.loc[qe["se"].isna(), "quantile"].to_numpy() + np.testing.assert_allclose(nan_taus, [0.05, 0.10, 0.15], atol=1e-12) + # Point estimates are kept (qte parity) even where inference is NaN. + assert np.isfinite(qe.loc[qe["se"].isna(), "qte"]).all() + + +class TestScaleEquivariance: + def test_cic_counterfactual_quantiles_equivariant(self, df, df_log, cic): + cic_log = ChangesInChanges(n_bootstrap=0).fit( + df_log, outcome="log_spend", treatment="treated", time="post" + ) + y11 = df.query("treated == 1 and post == 1")["spend"].to_numpy() + grid = cic.quantiles + q11_lvl = np.quantile(y11, grid, method="inverted_cdf") + q11_log = np.quantile(np.log(y11), grid, method="inverted_cdf") + cf_levels = q11_lvl - cic.quantile_effects["qte"].to_numpy() + cf_logs = np.exp(q11_log - cic_log.quantile_effects["qte"].to_numpy()) + # rtol 1e-14, not bit equality: the exp/log round-trip is the only + # daylight and its rounding is libm-dependent across the CI OS + # matrix. The exact-identity property itself is proven via the + # module's own type-1 helpers in test_methodology_changes_in_changes + # .py::test_cic_scale_invariance_nonlinear_dgp. + np.testing.assert_allclose(cf_levels, cf_logs, rtol=1e-14, atol=0.0) + + def test_did_flips_verdict_across_scales(self, df_log, did): + did_log = DifferenceInDifferences().fit( + df_log, outcome="log_spend", treatment="treated", time="post" + ) + assert did.p_value > 0.5 # levels: "no effect" + assert did_log.p_value < 0.005 # logs: "big effect" + assert abs(did_log.att - 0.1307) < 0.001 + assert abs(100 * (np.exp(did_log.att) - 1) - 14.0) < 0.1 + + def test_qdid_scale_gap_grows_toward_top(self, df, df_log): + qdid = QDiD(n_bootstrap=0).fit(df, outcome="spend", treatment="treated", time="post") + qdid_log = QDiD(n_bootstrap=0).fit( + df_log, outcome="log_spend", treatment="treated", time="post" + ) + y11 = df.query("treated == 1 and post == 1")["spend"].to_numpy() + grid = qdid.quantiles + q11_t7_log = np.quantile(np.log(y11), grid, method="linear") + backmapped = np.exp(q11_t7_log) - np.exp( + q11_t7_log - qdid_log.quantile_effects["qte"].to_numpy() + ) + gap = qdid.quantile_effects["qte"].to_numpy() - backmapped + pins = {0.50: -0.24, 0.75: -2.10, 0.90: -5.65} + for tau, expected in pins.items(): + got = float(gap[np.isclose(grid, tau)][0]) + assert abs(got - expected) < 0.02, f"tau={tau}: gap {got} vs quoted {expected}" + # Direction + growth toward the top (the prose claim), and the + # spurious levels-scale "loss" at tau=0.90 where the truth is ~0. + assert abs(gap[np.isclose(grid, 0.90)][0]) > abs(gap[np.isclose(grid, 0.75)][0]) + assert abs(gap[np.isclose(grid, 0.75)][0]) > abs(gap[np.isclose(grid, 0.50)][0]) + qd90 = float(qdid.quantile_effects["qte"].to_numpy()[np.isclose(grid, 0.90)][0]) + assert abs(qd90 - (-8.48)) < 0.02 + + +class TestCovariateSection: + def test_unconditional_is_confidently_wrong(self): + eng = make_engagement_data() + with warnings.catch_warnings(): + warnings.simplefilter("error") + unc = ChangesInChanges(n_bootstrap=999, seed=SEED).fit( + eng, outcome="engagement", treatment="treated", time="post" + ) + assert abs(unc.att - 9.38) < 0.02 + # CI endpoints as quoted in the prose ("CI [8.32, 10.45]"). + assert abs(unc.conf_int[0] - 8.32) < 0.02 + assert abs(unc.conf_int[1] - 10.45) < 0.02 + # CI excludes the truth - the bias is not a power problem. + assert unc.conf_int[0] > COV_EFFECT + + @pytest.mark.slow + def test_conditional_recovers_truth(self): + # ~1 min of quantile-regression LP solves (2 cells x 99 taus x 100 + # fits); must reproduce the notebook's exact seed/n_bootstrap, so it + # cannot be ci_params-scaled. Runs in the -m '' CI legs. + eng = make_engagement_data() + with warnings.catch_warnings(): + warnings.simplefilter("error") + cov = ChangesInChanges(n_bootstrap=99, seed=SEED).fit( + eng, + outcome="engagement", + treatment="treated", + time="post", + covariates=["tenure"], + ) + assert abs(cov.att - 6.53) < 0.1 + # CI endpoints as quoted in the prose ("CI [5.35, 7.70]") - looser + # tolerance than the unconditional pins: quantile-regression LP + # vertex selection can shift bootstrap replicates slightly across + # platforms (see the parity-test header for the tie mechanics). + assert abs(cov.conf_int[0] - 5.35) < 0.1 + assert abs(cov.conf_int[1] - 7.70) < 0.1 + assert cov.conf_int[0] < COV_EFFECT < cov.conf_int[1] + assert abs(cov.att - COV_EFFECT) < 0.6 + + +class TestCloseAndSurface: + def test_practitioner_close_is_clean(self, cic): + out = practitioner_next_steps(cic, verbose=False) + assert out["estimator"] == "ChangesInChanges (CiC)" + assert out["warnings"] == [] + labels = [s["label"] for s in out["next_steps"]] + assert any("Placebo ChangesInChanges" in lbl for lbl in labels) + + def test_notebook_has_no_asserts_or_warning_filters(self): + # The tutorial deliberately lets the guardrail-variant warnings + # render in the committed output rather than filtering them, and + # per the T19 rule all numerical guards live HERE, not in cells. + import ast + import json + from pathlib import Path + + nb_path = Path(__file__).resolve().parents[1] / NB + if not nb_path.exists(): + pytest.skip(f"Notebook not found at {nb_path}; surface checks are full-checkout only.") + cells = [ + "".join(c["source"]) if isinstance(c["source"], list) else c["source"] + for c in json.loads(nb_path.read_text())["cells"] + if c["cell_type"] == "code" + ] + src = "\n".join(cells) + assert "import warnings" not in src + assert "filterwarnings" not in src + assert "simplefilter" not in src + # AST-based: catches indented asserts a substring check would miss. + for cell_src in cells: + tree = ast.parse(cell_src) + asserts = [node for node in ast.walk(tree) if isinstance(node, ast.Assert)] + assert not asserts, f"notebook cell contains assert statements:\n{cell_src[:200]}" + + def test_notebook_constants_match(self): + import json + from pathlib import Path + + nb_path = Path(__file__).resolve().parents[1] / NB + if not nb_path.exists(): + pytest.skip(f"Notebook not found at {nb_path}; sync guard is full-checkout only.") + src = "\n".join( + "".join(c["source"]) if isinstance(c["source"], list) else c["source"] + for c in json.loads(nb_path.read_text())["cells"] + if c["cell_type"] == "code" + ) + for needle in ( + "SEED = 27", + "N_CELL = 901", + "MU_LOG, SIGMA_LOG = 3.4, 0.75", + "GAMMA, ALPHA = 1.06, -0.17", + "U_LO, U_HI = 0.05, 0.90", + "BETA_A, BETA_B = 1.2, 2.2", + "LIFT_MAX, LIFT_MID, LIFT_SCALE = 0.65, 0.22, 0.07", + "COV_SEED, COV_N = 272, 299", + "COV_EFFECT = 6.0", + "COV_SHIFT, COV_TREND, COV_LEVEL, COV_SCALE = 0.8, 0.6, 0.15, 8.0", + "h_post(u11) * (1.0 + lift(u11))", + "rng.uniform(0.15, 0.85", + "COV_SCALE * (0.5 + COV_LEVEL * x + COV_TREND * x * t + noise)", + "ChangesInChanges(n_bootstrap=999, seed=SEED)", + "ChangesInChanges(n_bootstrap=99, seed=SEED)", + 'covariates=["tenure"]', + 'method="inverted_cdf"', + ): + assert needle in src, f"notebook drifted from locked config: {needle!r}" + + def test_rendered_surface_quotes(self): + # Markdown prose quotes (reader-facing claims)... + assert_quotes_in_rendered( + NB, + [ + "p = 0.90", + "(0.17, 0.996)", + "+14.0%", + "bottom half", + "and for none above", # bands are silent, not exonerating, + "absence of evidence", # above the median (no null-acceptance) + "p = 0.044", # the pointwise blip the joint bands protect against + "p. 447", + "**6.0 points**", + ], + surface="markdown", + ) + # ...and the executed-output numbers they round from. + assert_quotes_in_rendered( + NB, + [ + "3.0476", # CiC ATT + "4.9087", # QTE at tau=0.05 + "0.9001", # mean-DiD p-value + "0.1698", # variant interior range lower bound + "9.38", # unconditional covariate-section ATT + "6.53", # conditional covariate-section ATT + "CI [8.32, 10.45]", # unconditional CI (truth-excluding) + "CI [5.35, 7.70]", # conditional CI (truth-covering) + ], + surface="output", + ) + + def test_no_local_paths_in_committed_outputs(self): + # The guardrail-variant warnings render in the committed output by + # design, but the machine-specific checkout prefix is normalized + # away before committing - rendered docs must not leak local + # usernames/paths. + from tests._tutorial_drift import notebook_output_text + + assert "/Users/" not in notebook_output_text(NB) + + def test_headline_claims_present_in_prose(self): + md = notebook_markdown(NB) + assert "When the Average Hides the Action" in md + assert "uniform band" in md or "uniform bands" in md + assert "interior range" in md + assert "equivarian" in md # equivariant / equivariance + assert "CallawaySantAnna" in md # the when-to-use routing From 3d586f2520df33db37c830332301ce4d52d2570f Mon Sep 17 00:00:00 2001 From: igerber Date: Sat, 18 Jul 2026 15:07:44 -0400 Subject: [PATCH 2/2] test(t27): broaden the committed-output local-path guard to all platforms /Users/ alone would miss /home/, /private/, /tmp/, and C:\Users checkout prefixes if the notebook were ever re-executed elsewhere. Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_01W75ea3yFYQbjVhB2evhRiZ --- tests/test_t27_cic_distributional_effects_drift.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/tests/test_t27_cic_distributional_effects_drift.py b/tests/test_t27_cic_distributional_effects_drift.py index 6bd7c4f71..8e8788a4d 100644 --- a/tests/test_t27_cic_distributional_effects_drift.py +++ b/tests/test_t27_cic_distributional_effects_drift.py @@ -438,10 +438,12 @@ def test_no_local_paths_in_committed_outputs(self): # The guardrail-variant warnings render in the committed output by # design, but the machine-specific checkout prefix is normalized # away before committing - rendered docs must not leak local - # usernames/paths. + # usernames/paths, whichever platform executed the notebook. from tests._tutorial_drift import notebook_output_text - assert "/Users/" not in notebook_output_text(NB) + text = notebook_output_text(NB) + for prefix in ("/Users/", "/home/", "/private/", "C:\\Users", "/tmp/"): + assert prefix not in text, f"committed output leaks a local path: {prefix!r}" def test_headline_claims_present_in_prose(self): md = notebook_markdown(NB)