{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "63e07805",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-19T05:23:53.508781Z",
     "iopub.status.busy": "2026-07-19T05:23:53.506774Z",
     "iopub.status.idle": "2026-07-19T05:23:56.259415Z",
     "shell.execute_reply": "2026-07-19T05:23:56.259415Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Setup complete. numpy 1.26.4\n"
     ]
    }
   ],
   "source": [
    "# Standard scientific-Python stack. Nothing here reaches the network — every\n",
    "# number below is generated locally from a single seed.\n",
    "import csv\n",
    "import io\n",
    "import json\n",
    "from collections import defaultdict\n",
    "from datetime import date, timedelta\n",
    "from pathlib import Path\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.ticker as mticker\n",
    "import numpy as np\n",
    "\n",
    "# Reproducibility: one seed drives the whole synthetic corpus.\n",
    "SEED = 20260719\n",
    "rng = np.random.default_rng(SEED)\n",
    "\n",
    "# Brand palette (validated colour-blind-safe, light + dark, via the design system).\n",
    "C_TREAT   = \"#0a8f5f\"   # treatment arm            (emerald)\n",
    "C_CONTROL = \"#2a78d6\"   # control arm              (blue)\n",
    "C_EFFECT  = \"#b06a2c\"   # the measured lift        (warm)\n",
    "C_INK     = \"#1f2124\"   # near-black text\n",
    "C_MUTED   = \"#8a8f98\"   # recessive grid / axis\n",
    "PAPER     = \"#fdfcf9\"   # warm paper surface\n",
    "\n",
    "plt.rcParams.update({\n",
    "    \"figure.facecolor\": PAPER,\n",
    "    \"axes.facecolor\":   PAPER,\n",
    "    \"savefig.facecolor\": PAPER,\n",
    "    \"font.size\": 11,\n",
    "    \"axes.edgecolor\": C_MUTED,\n",
    "    \"axes.labelcolor\": C_INK,\n",
    "    \"text.color\": C_INK,\n",
    "    \"xtick.color\": C_INK,\n",
    "    \"ytick.color\": C_INK,\n",
    "    \"axes.spines.top\": False,\n",
    "    \"axes.spines.right\": False,\n",
    "})\n",
    "\n",
    "FIGS = Path(\"figures\")\n",
    "DATA = Path(\"data\")\n",
    "FIGS.mkdir(exist_ok=True)\n",
    "DATA.mkdir(exist_ok=True)\n",
    "print(\"Setup complete. numpy\", np.__version__)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dea1a1f5",
   "metadata": {},
   "source": [
    "# Does this channel actually cause sales? A runnable geo-holdout notebook\n",
    "\n",
    "This notebook implements the method behind the post **\"Is this channel actually\n",
    "causing sales, or would they have happened anyway?\"** — a **geo-holdout**\n",
    "experiment (also called a geo-lift or geo-incrementality test).\n",
    "\n",
    "It runs end to end on your own machine. Part one is a worked example on\n",
    "**synthetic** data (clearly labelled): it fits the method, generates every figure\n",
    "in the article, and writes the numbers the article and the interactive widget both\n",
    "read. Part two is a **your-data** section: point it at a CSV of your own geo test\n",
    "and it runs the same method, with plain-words warnings when your data is too thin\n",
    "to trust. Your data never leaves your machine.\n",
    "\n",
    "The one honest headline first: a clean geo-holdout is the strongest evidence a\n",
    "marketer can get that a channel *causes* sales — but it still returns a **lift with\n",
    "a range**, not a single certain number. Randomising which regions get the change\n",
    "removes the confounding; it does not remove sampling noise. This notebook shows\n",
    "both the lift and the range, and refuses to report a number when the experiment\n",
    "was too small to measure one."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "29e0d0fd",
   "metadata": {},
   "source": [
    "## The method in one paragraph\n",
    "\n",
    "Split a set of regions at random into two arms. The **treatment** arm gets the\n",
    "change you want to test (more budget on a channel, a new campaign, a bid change);\n",
    "the **control** arm is held back and left alone. Run them side by side for a\n",
    "window. Both arms feel whatever the market does over that window — a seasonal\n",
    "demand swing, a category-wide cost change — so comparing each region only to *its\n",
    "own past* would blame the change for the whole market move. The control arm fixes\n",
    "that: because the two arms differ only by the coin flip, the control arm is what\n",
    "the treated regions *would have done without the change* — observed directly, not\n",
    "modelled. The lift is the **difference in differences**: how much the treatment\n",
    "arm moved from before to during, minus how much the control arm moved over the\n",
    "same window. Whatever both arms shared cancels; what is left is the change's\n",
    "causal effect."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "247a4e69",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-19T05:23:56.265434Z",
     "iopub.status.busy": "2026-07-19T05:23:56.265434Z",
     "iopub.status.idle": "2026-07-19T05:23:56.282493Z",
     "shell.execute_reply": "2026-07-19T05:23:56.282493Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Engine defined: region_deltas, readout, randomisation_pvalue, balance_gap\n"
     ]
    }
   ],
   "source": [
    "# ------------------------------------------------------------------------------\n",
    "# The engine. Pure functions: they take arrays in and return numbers out, with no\n",
    "# hidden state, so the interactive widget and the spreadsheet can reproduce them\n",
    "# exactly. \"Delta\" always means one region's (live-window mean) minus its\n",
    "# (pre-period mean) -- the region's own before/after change.\n",
    "# ------------------------------------------------------------------------------\n",
    "\n",
    "CI_Z = 1.645   # normal multiplier for a 90% interval (the platform-wide default level)\n",
    "\n",
    "\n",
    "def region_deltas(daily, n_pre):\n",
    "    \"\"\"Per-region change: mean over the live window minus mean over the pre-period.\n",
    "\n",
    "    `daily` is a 2-D array, one row per region, columns = days (pre-period then\n",
    "    live window). Returns a 1-D array of one delta per region.\n",
    "    \"\"\"\n",
    "    daily = np.asarray(daily, dtype=float)\n",
    "    pre_mean = daily[:, :n_pre].mean(axis=1)\n",
    "    live_mean = daily[:, n_pre:].mean(axis=1)\n",
    "    return live_mean - pre_mean\n",
    "\n",
    "\n",
    "def readout(delta_treatment, delta_control, ci_z=CI_Z):\n",
    "    \"\"\"The geo-holdout readout from the two arms' region-deltas.\n",
    "\n",
    "    delta_treatment / delta_control are arrays of per-region before/after changes,\n",
    "    one entry per region in that arm.\n",
    "\n",
    "      naive        = the treated arm's own before/after move  (mean of treatment deltas)\n",
    "      market_move  = what the control arm did over the window  (mean of control deltas)\n",
    "      did          = naive - market_move  = the difference-in-differences lift\n",
    "      se           = the standard error of `did` from region-to-region spread\n",
    "      ci_lower/upper = did +/- z * se\n",
    "\n",
    "    The standard error is the ordinary two-sample SE of a difference of means: the\n",
    "    lift is uncertain because a different random split of the same regions would\n",
    "    have landed a bit differently, and `se` measures exactly that.\n",
    "    \"\"\"\n",
    "    dt = np.asarray(delta_treatment, dtype=float)\n",
    "    dc = np.asarray(delta_control, dtype=float)\n",
    "    n_t, n_c = len(dt), len(dc)\n",
    "    naive = float(dt.mean())\n",
    "    market_move = float(dc.mean())\n",
    "    did = naive - market_move\n",
    "    # ddof=1: sample variance, the honest small-sample estimate.\n",
    "    var_t = float(dt.var(ddof=1)) if n_t > 1 else 0.0\n",
    "    var_c = float(dc.var(ddof=1)) if n_c > 1 else 0.0\n",
    "    se = float(np.sqrt(var_t / n_t + var_c / n_c))\n",
    "    return {\n",
    "        \"n_treatment\": n_t,\n",
    "        \"n_control\": n_c,\n",
    "        \"naive\": naive,\n",
    "        \"market_move\": market_move,\n",
    "        \"did\": did,\n",
    "        \"se\": se,\n",
    "        \"ci_lower\": did - ci_z * se,\n",
    "        \"ci_upper\": did + ci_z * se,\n",
    "    }\n",
    "\n",
    "\n",
    "def randomisation_pvalue(delta_treatment, delta_control, n_perm=5000, seed=0):\n",
    "    \"\"\"Design-based significance: how often a *random* re-split of the same\n",
    "    regions would produce a lift as large as the one we saw, if the change did\n",
    "    nothing. Pool both arms' deltas, re-draw the treatment/control labels\n",
    "    `n_perm` times, recompute the difference of means each time, and read the\n",
    "    observed lift's rank in that null distribution.\n",
    "\n",
    "    Returns (p_value, null_sd, null_distribution). This is the inference the\n",
    "    platform uses; it leans on the randomisation actually performed, not on a\n",
    "    parametric error model.\n",
    "    \"\"\"\n",
    "    dt = np.asarray(delta_treatment, dtype=float)\n",
    "    dc = np.asarray(delta_control, dtype=float)\n",
    "    pooled = np.concatenate([dt, dc])\n",
    "    n_t = len(dt)\n",
    "    observed = dt.mean() - dc.mean()\n",
    "    r = np.random.default_rng(seed)\n",
    "    null = np.empty(n_perm)\n",
    "    for k in range(n_perm):\n",
    "        perm = r.permutation(pooled)\n",
    "        null[k] = perm[:n_t].mean() - perm[n_t:].mean()\n",
    "    # +1 smoothing so a zero count never reports p = 0 exactly.\n",
    "    p = (np.sum(np.abs(null) >= abs(observed)) + 1) / (n_perm + 1)\n",
    "    return float(p), float(null.std(ddof=1)), null\n",
    "\n",
    "\n",
    "def balance_gap(pre_treatment_means, pre_control_means):\n",
    "    \"\"\"Pre-period balance: the arms should look alike before the change. Returns\n",
    "    the level gap (treatment minus control pre-period average) and a rough z\n",
    "    against the arm-to-arm spread. Near zero is the evidence randomisation worked.\n",
    "    \"\"\"\n",
    "    a = np.asarray(pre_treatment_means, dtype=float)\n",
    "    b = np.asarray(pre_control_means, dtype=float)\n",
    "    gap = float(a.mean() - b.mean())\n",
    "    se = float(np.sqrt(a.var(ddof=1) / len(a) + b.var(ddof=1) / len(b)))\n",
    "    z = gap / se if se > 0 else 0.0\n",
    "    return gap, float(z)\n",
    "\n",
    "\n",
    "print(\"Engine defined: region_deltas, readout, randomisation_pvalue, balance_gap\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "737b63e8",
   "metadata": {},
   "source": [
    "## A synthetic set of regions (labelled synthetic)\n",
    "\n",
    "We simulate a small advertiser's geo test. There are `N_GEOS` regions. Each has\n",
    "its own baseline conversion level — some regions are big, some small (region size\n",
    "is heavy-tailed, as it is in real life). The regions are split at random into a\n",
    "treatment arm and a control arm.\n",
    "\n",
    "Then two things happen at once in the **live window**:\n",
    "\n",
    "- a **market-wide seasonal lift** raises conversions in *every* region — and each\n",
    "  region feels the season a little differently; and\n",
    "- the **tested change** adds an incremental lift to the **treatment** regions only.\n",
    "\n",
    "This is the exact trap the holdout is built for: a naive before/after reading of\n",
    "the treated regions alone can't tell the season apart from the change. The control\n",
    "arm can. Everything below is generated from the seed above — no hand-typed numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "6efa0eec",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-19T05:23:56.288529Z",
     "iopub.status.busy": "2026-07-19T05:23:56.286509Z",
     "iopub.status.idle": "2026-07-19T05:23:56.304387Z",
     "shell.execute_reply": "2026-07-19T05:23:56.304387Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20 regions: 10 treatment, 10 control\n",
      "treatment deltas: [ 9.59 11.44  7.71 19.76 22.71  7.37 19.14 20.57 12.56 20.02]\n",
      "control   deltas: [ 2.27 12.93 18.92 11.36  7.2   7.37 10.44 12.23  0.11  3.94]\n"
     ]
    }
   ],
   "source": [
    "def simulate_panel(n_geos, n_pre, n_live, base_median, base_logsd,\n",
    "                   market_mean, market_sd, effect, sigma, rng, frac_treat=0.5):\n",
    "    \"\"\"Simulate daily conversions for `n_geos` regions across a pre-period and a\n",
    "    live window, split at random into treatment and control arms.\n",
    "\n",
    "    For region g on day t:\n",
    "        conversions = base_g\n",
    "                     + market_g * live_t                 (seasonal lift, both arms)\n",
    "                     + effect    * live_t * is_treated_g  (the tested change, treated only)\n",
    "                     + noise\n",
    "    base_g is heavy-tailed (region size). market_g varies region to region — that\n",
    "    region-to-region difference in how strongly the season hits is the real source\n",
    "    of geo-experiment noise, and it is why more regions give a tighter read.\n",
    "\n",
    "    Returns (daily, arm, treat_idx, control_idx): the daily matrix, an array of\n",
    "    'treatment'/'control' labels, and the row indices of each arm.\n",
    "    \"\"\"\n",
    "    days = np.arange(n_pre + n_live)\n",
    "    live = (days >= n_pre).astype(float)\n",
    "\n",
    "    base = base_median * np.exp(rng.normal(0.0, base_logsd, n_geos))\n",
    "    market = market_mean + rng.normal(0.0, market_sd, n_geos)\n",
    "\n",
    "    order = rng.permutation(n_geos)\n",
    "    n_treat = int(round(n_geos * frac_treat))\n",
    "    treat_idx = np.sort(order[:n_treat])\n",
    "    control_idx = np.sort(order[n_treat:])\n",
    "    is_treat = np.zeros(n_geos, dtype=bool)\n",
    "    is_treat[treat_idx] = True\n",
    "\n",
    "    daily = np.empty((n_geos, n_pre + n_live))\n",
    "    for g in range(n_geos):\n",
    "        mean_series = base[g] + market[g] * live\n",
    "        if is_treat[g]:\n",
    "            mean_series = mean_series + effect * live\n",
    "        daily[g] = mean_series + rng.normal(0.0, sigma, n_pre + n_live)\n",
    "\n",
    "    arm = np.where(is_treat, \"treatment\", \"control\")\n",
    "    return daily, arm, treat_idx, control_idx\n",
    "\n",
    "\n",
    "# ---- The worked-example (hero) scenario. Realistic marketing numbers. ----\n",
    "N_GEOS = 20            # 20 regions, split 10 / 10\n",
    "N_PRE = 21             # three weeks of pre-period\n",
    "N_LIVE = 14            # a two-week live window\n",
    "BASE_MEDIAN = 45.0     # a mid-size region converts ~45/day at baseline\n",
    "BASE_LOGSD = 0.45      # region size is heavy-tailed (a few big metros)\n",
    "MARKET_MEAN = 8.0      # the season lifts conversions ~8/day in the live window ...\n",
    "MARKET_SD = 5.0        # ... but regions feel it differently (this is the geo noise)\n",
    "EFFECT = 6.0           # the tested change truly adds ~6 conversions/day (treated only)\n",
    "SIGMA = 3.0            # day-to-day idiosyncratic noise\n",
    "\n",
    "daily, arm, treat_idx, control_idx = simulate_panel(\n",
    "    N_GEOS, N_PRE, N_LIVE, BASE_MEDIAN, BASE_LOGSD,\n",
    "    MARKET_MEAN, MARKET_SD, EFFECT, SIGMA, rng,\n",
    ")\n",
    "\n",
    "deltas = region_deltas(daily, N_PRE)\n",
    "dT = deltas[treat_idx]\n",
    "dC = deltas[control_idx]\n",
    "print(f\"{N_GEOS} regions: {len(treat_idx)} treatment, {len(control_idx)} control\")\n",
    "print(\"treatment deltas:\", np.round(dT, 2))\n",
    "print(\"control   deltas:\", np.round(dC, 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c1d0d7f2",
   "metadata": {},
   "source": [
    "## The naive reading vs the holdout — where the confound bites\n",
    "\n",
    "Two ways to read the same experiment:\n",
    "\n",
    "- **Naive (treated arm only):** how much did conversions in the treated regions\n",
    "  rise from the pre-period to the live window? This is the number a dashboard\n",
    "  shows. It hands the change credit for the *whole* rise — including the season.\n",
    "- **Geo-holdout (difference in differences):** the treated arm's rise **minus the\n",
    "  control arm's rise**. The control arm reveals the season, and subtracting it\n",
    "  leaves the part only the treated regions got — the change's real effect."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "f91648cb",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-19T05:23:56.310411Z",
     "iopub.status.busy": "2026-07-19T05:23:56.308403Z",
     "iopub.status.idle": "2026-07-19T05:23:57.711926Z",
     "shell.execute_reply": "2026-07-19T05:23:57.711926Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Naive (treated arm before/after):   +15.09 conversions/day\n",
      "What the market did (control arm):  +8.68 conversions/day\n",
      "Geo-holdout lift (DiD):             +6.41 conversions/day\n",
      "  90% interval: [2.16, 10.66]  (SE 2.59)\n",
      "Pre-period balance gap: -1.57 (z = -0.38) -- near zero = arms comparable\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 820x440 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 740x430 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "res = readout(dT, dC)\n",
    "pre_treat_means = daily[treat_idx, :N_PRE].mean(axis=1)\n",
    "pre_control_means = daily[control_idx, :N_PRE].mean(axis=1)\n",
    "gap, gap_z = balance_gap(pre_treat_means, pre_control_means)\n",
    "\n",
    "print(f\"Naive (treated arm before/after):   +{res['naive']:.2f} conversions/day\")\n",
    "print(f\"What the market did (control arm):  +{res['market_move']:.2f} conversions/day\")\n",
    "print(f\"Geo-holdout lift (DiD):             +{res['did']:.2f} conversions/day\")\n",
    "print(f\"  90% interval: [{res['ci_lower']:.2f}, {res['ci_upper']:.2f}]  (SE {res['se']:.2f})\")\n",
    "print(f\"Pre-period balance gap: {gap:+.2f} (z = {gap_z:+.2f}) -- near zero = arms comparable\")\n",
    "\n",
    "# ---- Figure 1: the two arms over time ----\n",
    "def fig_arms(daily, treat_idx, control_idx, n_pre, path):\n",
    "    days = np.arange(daily.shape[1])\n",
    "    t_avg = daily[treat_idx].mean(axis=0)\n",
    "    c_avg = daily[control_idx].mean(axis=0)\n",
    "    fig, ax = plt.subplots(figsize=(8.2, 4.4))\n",
    "    ax.axvspan(n_pre - 0.5, days[-1] + 0.2, color=C_EFFECT, alpha=0.06)\n",
    "    ax.axvline(n_pre - 0.5, color=C_MUTED, lw=1, ls=\"--\")\n",
    "    ax.plot(days, t_avg, color=C_TREAT, lw=2.2, marker=\"o\", ms=3, label=\"Treatment arm (got the change)\")\n",
    "    ax.plot(days, c_avg, color=C_CONTROL, lw=2.2, marker=\"o\", ms=3, label=\"Control arm (held back)\")\n",
    "    ax.text(n_pre / 2, ax.get_ylim()[1], \"pre-period\", ha=\"center\", va=\"top\", color=C_MUTED, fontsize=10)\n",
    "    ax.text(n_pre + (daily.shape[1] - n_pre) / 2, ax.get_ylim()[1], \"live window\",\n",
    "            ha=\"center\", va=\"top\", color=C_MUTED, fontsize=10)\n",
    "    ax.set_xlabel(\"Day\")\n",
    "    ax.set_ylabel(\"Conversions per region / day\")\n",
    "    ax.set_title(\"The two arms track together before the change, then separate\")\n",
    "    ax.legend(loc=\"lower right\", frameon=False, fontsize=9)\n",
    "    ax.yaxis.set_major_locator(mticker.MaxNLocator(6))\n",
    "    fig.tight_layout()\n",
    "    fig.savefig(path, dpi=150, bbox_inches=\"tight\")\n",
    "    plt.show()\n",
    "    plt.close(fig)\n",
    "\n",
    "\n",
    "fig_arms(daily, treat_idx, control_idx, N_PRE, FIGS / \"fig_arms.png\")\n",
    "\n",
    "# ---- Figure 2: naive = market + change (the decomposition) ----\n",
    "def fig_decomposition(res, path):\n",
    "    labels = [\"Naive read\\n(treated arm)\", \"What the market\\ndid (control)\", \"Geo-holdout lift\\n(the change)\"]\n",
    "    vals = [res[\"naive\"], res[\"market_move\"], res[\"did\"]]\n",
    "    colors = [C_TREAT, C_CONTROL, C_EFFECT]\n",
    "    fig, ax = plt.subplots(figsize=(7.4, 4.3))\n",
    "    bars = ax.bar(labels, vals, color=colors, width=0.62)\n",
    "    # honest point comparison: draw the holdout CI as a thin whisker on its bar only\n",
    "    ax.errorbar(2, res[\"did\"], yerr=[[res[\"did\"] - res[\"ci_lower\"]], [res[\"ci_upper\"] - res[\"did\"]]],\n",
    "                fmt=\"none\", ecolor=C_INK, elinewidth=1.4, capsize=6)\n",
    "    for idx, (b, v) in enumerate(zip(bars, vals)):\n",
    "        y = res[\"ci_upper\"] + 0.4 if idx == 2 else v + 0.3   # keep the lift label clear of its whisker\n",
    "        ax.text(b.get_x() + b.get_width() / 2, y, f\"+{v:.1f}\", ha=\"center\", va=\"bottom\", fontsize=11)\n",
    "    ax.axhline(0, color=C_MUTED, lw=1)\n",
    "    ax.set_ylabel(\"Conversions per region / day\")\n",
    "    ax.set_title(\"The naive read is the change plus the season; the holdout keeps only the change\")\n",
    "    ax.set_ylim(0, res[\"naive\"] * 1.3)\n",
    "    fig.tight_layout()\n",
    "    fig.savefig(path, dpi=150, bbox_inches=\"tight\")\n",
    "    plt.show()\n",
    "    plt.close(fig)\n",
    "\n",
    "\n",
    "fig_decomposition(res, FIGS / \"fig_decomposition.png\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "026afc01",
   "metadata": {},
   "source": [
    "## Is the lift real? Inference from the randomisation itself\n",
    "\n",
    "The lift is `+6`-ish, but a random split of regions never comes out perfectly even\n",
    "— maybe the treated arm just happened to draw the regions with a stronger season.\n",
    "The **randomisation test** asks exactly that: if the change did nothing, how often\n",
    "would a *random* re-labelling of these same regions produce a lift this big? We\n",
    "re-shuffle which regions are \"treatment\" thousands of times, recompute the lift\n",
    "each time, and see where the real lift falls in that null distribution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "7babeb35",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-19T05:23:57.715940Z",
     "iopub.status.busy": "2026-07-19T05:23:57.715940Z",
     "iopub.status.idle": "2026-07-19T05:23:58.548288Z",
     "shell.execute_reply": "2026-07-19T05:23:58.548288Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Observed lift: +6.41\n",
      "Randomisation p-value: 0.0256  (null spread 2.93, analytic SE 2.59)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 760x420 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "p_value, null_sd, null = randomisation_pvalue(dT, dC, n_perm=5000, seed=SEED)\n",
    "print(f\"Observed lift: +{res['did']:.2f}\")\n",
    "print(f\"Randomisation p-value: {p_value:.4f}  (null spread {null_sd:.2f}, analytic SE {res['se']:.2f})\")\n",
    "\n",
    "\n",
    "def fig_randomisation(null, observed, path):\n",
    "    fig, ax = plt.subplots(figsize=(7.6, 4.2))\n",
    "    ax.hist(null, bins=40, color=C_CONTROL, alpha=0.55, edgecolor=\"white\", linewidth=0.4)\n",
    "    ax.axvline(observed, color=C_EFFECT, lw=2.4, label=f\"observed lift +{observed:.1f}\")\n",
    "    ax.axvline(-observed, color=C_EFFECT, lw=1.0, ls=\":\", alpha=0.7)\n",
    "    ax.set_xlabel(\"Lift from a random re-split (conversions/region/day)\")\n",
    "    ax.set_ylabel(\"How often\")\n",
    "    ax.set_title(\"If the change did nothing: where the real lift falls\")\n",
    "    ax.legend(loc=\"upper left\", frameon=False, fontsize=9)\n",
    "    ax.set_yticks([])\n",
    "    fig.tight_layout()\n",
    "    fig.savefig(path, dpi=150, bbox_inches=\"tight\")\n",
    "    plt.show()\n",
    "    plt.close(fig)\n",
    "\n",
    "\n",
    "fig_randomisation(null, res[\"did\"], FIGS / \"fig_randomisation.png\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fdae3104",
   "metadata": {},
   "source": [
    "## How many regions do you need? The power curve\n",
    "\n",
    "The single biggest reason a geo test comes back \"no result\" is that it was too\n",
    "small: too few regions, and the range is so wide it swallows any realistic lift.\n",
    "Below, we hold the true effect fixed and grow the number of regions. Watch the\n",
    "interval shrink — and note that with too few regions the interval **crosses zero**,\n",
    "which is not \"the change did nothing\", it is \"this test was too small to tell.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "a1f6272d",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-19T05:23:58.554315Z",
     "iopub.status.busy": "2026-07-19T05:23:58.552305Z",
     "iopub.status.idle": "2026-07-19T05:23:59.773699Z",
     "shell.execute_reply": "2026-07-19T05:23:59.773699Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  6 regions:  lift +4.60 +/- 6.42   detected-clear in 38% of runs\n",
      " 10 regions:  lift +6.26 +/- 4.69   detected-clear in 78% of runs\n",
      " 16 regions:  lift +6.12 +/- 4.19   detected-clear in 80% of runs\n",
      " 24 regions:  lift +6.12 +/- 3.37   detected-clear in 85% of runs\n",
      " 40 regions:  lift +5.74 +/- 2.61   detected-clear in 95% of runs\n",
      " 60 regions:  lift +6.12 +/- 2.15   detected-clear in 100% of runs\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 760x430 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def power_curve(geo_counts, effect, seed=0, reps=40):\n",
    "    \"\"\"For each region count, the average lift and average 90% half-width across\n",
    "    `reps` fresh random experiments at a fixed true effect.\"\"\"\n",
    "    out = []\n",
    "    r = np.random.default_rng(seed)\n",
    "    for n in geo_counts:\n",
    "        dids, halfs, excl = [], [], 0\n",
    "        for _ in range(reps):\n",
    "            d, a, ti, ci = simulate_panel(\n",
    "                n, N_PRE, N_LIVE, BASE_MEDIAN, BASE_LOGSD,\n",
    "                MARKET_MEAN, MARKET_SD, effect, SIGMA, r,\n",
    "            )\n",
    "            dd = region_deltas(d, N_PRE)\n",
    "            rr = readout(dd[ti], dd[ci])\n",
    "            dids.append(rr[\"did\"]); halfs.append(CI_Z * rr[\"se\"])\n",
    "            if rr[\"ci_lower\"] > 0:\n",
    "                excl += 1\n",
    "        out.append((n, float(np.mean(dids)), float(np.mean(halfs)), excl / reps))\n",
    "    return out\n",
    "\n",
    "\n",
    "GEO_COUNTS = [6, 10, 16, 24, 40, 60]\n",
    "pc = power_curve(GEO_COUNTS, EFFECT, seed=SEED + 1)\n",
    "for n, d, h, frac in pc:\n",
    "    print(f\"{n:3d} regions:  lift +{d:.2f} +/- {h:.2f}   detected-clear in {frac*100:.0f}% of runs\")\n",
    "\n",
    "\n",
    "def fig_power(pc, effect, path):\n",
    "    ns = [x[0] for x in pc]; ds = [x[1] for x in pc]; hs = [x[2] for x in pc]\n",
    "    fig, ax = plt.subplots(figsize=(7.6, 4.3))\n",
    "    ax.axhline(0, color=C_MUTED, lw=1)\n",
    "    ax.axhline(effect, color=C_EFFECT, lw=1.2, ls=\"--\", label=f\"true effect +{effect:.0f}\")\n",
    "    ax.errorbar(ns, ds, yerr=hs, fmt=\"o-\", color=C_TREAT, ecolor=C_TREAT,\n",
    "                elinewidth=1.6, capsize=5, ms=5, label=\"measured lift +/- 90%\")\n",
    "    ax.set_xlabel(\"Number of regions in the test\")\n",
    "    ax.set_ylabel(\"Measured lift (conversions/region/day)\")\n",
    "    ax.set_title(\"Too few regions and the range swallows the effect\")\n",
    "    ax.legend(loc=\"upper right\", frameon=False, fontsize=9)\n",
    "    fig.tight_layout()\n",
    "    fig.savefig(path, dpi=150, bbox_inches=\"tight\")\n",
    "    plt.show()\n",
    "    plt.close(fig)\n",
    "\n",
    "\n",
    "fig_power(pc, EFFECT, FIGS / \"fig_power.png\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4fe44faf",
   "metadata": {},
   "source": [
    "## Pinned results — the numbers the article and the widget both use\n",
    "\n",
    "Everything the article states and everything the interactive widget recomputes is\n",
    "written here to `data/checks.json` (the widget authority) and\n",
    "`data/worked_example.json` (the article's numbers). Nothing downstream is\n",
    "hand-typed. Each pinned scenario stores the two arms' region-deltas; the widget\n",
    "rebuilds the exact readout from those stored numbers, so the on-page check is a\n",
    "real re-computation, not a copy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "18215a66",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-19T05:23:59.780730Z",
     "iopub.status.busy": "2026-07-19T05:23:59.778723Z",
     "iopub.status.idle": "2026-07-19T05:23:59.803498Z",
     "shell.execute_reply": "2026-07-19T05:23:59.803498Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "wrote data/checks.json with 4 pinned scenarios\n",
      "wrote data/worked_example.json\n",
      "{\n",
      "  \"data_label\": \"synthetic\",\n",
      "  \"n_geos\": 20,\n",
      "  \"n_treatment\": 10,\n",
      "  \"n_control\": 10,\n",
      "  \"n_pre\": 21,\n",
      "  \"n_live\": 14,\n",
      "  \"true_effect\": 6.0,\n",
      "  \"market_lift\": 8.0,\n",
      "  \"naive\": 15.09,\n",
      "  \"market_move\": 8.68,\n",
      "  \"did\": 6.41,\n",
      "  \"se\": 2.59,\n",
      "  \"ci_lower\": 2.16,\n",
      "  \"ci_upper\": 10.66,\n",
      "  \"naive_over_credit\": 8.68,\n",
      "  \"randomisation_p_value\": 0.0256,\n",
      "  \"randomisation_null_sd\": 2.93,\n",
      "  \"balance_gap\": -1.57,\n",
      "  \"balance_z\": -0.38,\n",
      "  \"power_curve\": [\n",
      "    {\n",
      "      \"n_geos\": 6,\n",
      "      \"lift\": 4.6,\n",
      "      \"half_width\": 6.42,\n",
      "      \"detected_clear_frac\": 0.38\n",
      "    },\n",
      "    {\n",
      "      \"n_geos\": 10,\n",
      "      \"lift\": 6.26,\n",
      "      \"half_width\": 4.69,\n",
      "      \"detected_clear_frac\": 0.78\n",
      "    },\n",
      "    {\n",
      "      \"n_geos\": 16,\n",
      "      \"lift\": 6.12,\n",
      "      \"half_width\": 4.19,\n",
      "      \"detected_clear_frac\": 0.8\n",
      "    },\n",
      "    {\n",
      "      \"n_geos\": 24,\n",
      "      \"lift\": 6.12,\n",
      "      \"half_width\": 3.37,\n",
      "      \"detected_clear_frac\": 0.85\n",
      "    },\n",
      "    {\n",
      "      \"n_geos\": 40,\n",
      "      \"lift\": 5.74,\n",
      "      \"half_width\": 2.61,\n",
      "      \"detected_clear_frac\": 0.95\n",
      "    },\n",
      "    {\n",
      "      \"n_geos\": 60,\n",
      "      \"lift\": 6.12,\n",
      "      \"half_width\": 2.15,\n",
      "      \"detected_clear_frac\": 1.0\n",
      "    }\n",
      "  ]\n",
      "}\n"
     ]
    }
   ],
   "source": [
    "def round_list(a, dp=4):\n",
    "    return [round(float(x), dp) for x in a]\n",
    "\n",
    "\n",
    "def expected_block(dt, dc):\n",
    "    \"\"\"Compute the readout from the ROUND-TRIPPED stored deltas, so checks.json is\n",
    "    self-consistent with what the widget will actually read.\"\"\"\n",
    "    dt_r = np.array(round_list(dt), dtype=float)\n",
    "    dc_r = np.array(round_list(dc), dtype=float)\n",
    "    r = readout(dt_r, dc_r)\n",
    "    return {k: round(float(v), 6) for k, v in r.items()\n",
    "            if k in (\"naive\", \"market_move\", \"did\", \"se\", \"ci_lower\", \"ci_upper\")}\n",
    "\n",
    "\n",
    "def make_scenario(name, description, n_geos, effect, market_sd, seed):\n",
    "    r = np.random.default_rng(seed)\n",
    "    d, a, ti, ci = simulate_panel(\n",
    "        n_geos, N_PRE, N_LIVE, BASE_MEDIAN, BASE_LOGSD,\n",
    "        MARKET_MEAN, market_sd, effect, SIGMA, r,\n",
    "    )\n",
    "    dd = region_deltas(d, N_PRE)\n",
    "    dt = round_list(dd[ti]); dc = round_list(dd[ci])\n",
    "    return {\n",
    "        \"name\": name,\n",
    "        \"description\": description,\n",
    "        \"n_pre\": N_PRE,\n",
    "        \"n_live\": N_LIVE,\n",
    "        \"delta_treatment\": dt,\n",
    "        \"delta_control\": dc,\n",
    "        \"expected\": expected_block(dt, dc),\n",
    "    }\n",
    "\n",
    "\n",
    "scenarios = [\n",
    "    make_scenario(\"clear-win\", \"20 regions, a real +6/day effect; the range clears zero.\",\n",
    "                  20, 6.0, 5.0, SEED + 11),\n",
    "    make_scenario(\"big-clear-win\", \"30 regions, a large +10/day effect; a tight, decisive read.\",\n",
    "                  30, 10.0, 5.0, SEED + 12),\n",
    "    make_scenario(\"no-effect\", \"20 regions, the change truly does nothing; the range contains zero.\",\n",
    "                  20, 0.0, 5.0, SEED + 19),\n",
    "    make_scenario(\"underpowered\", \"Only 6 regions and a modest +5/day; the range swallows the effect.\",\n",
    "                  6, 5.0, 6.0, SEED + 14),\n",
    "]\n",
    "\n",
    "checks = {\n",
    "    \"method\": \"Geo-holdout experiment (difference-in-differences lift)\",\n",
    "    \"ci_z\": CI_Z,\n",
    "    \"ci_level\": 0.90,\n",
    "    \"tolerance\": 1e-4,\n",
    "    \"note\": (\"Given the two arms' per-region deltas (live-window mean minus \"\n",
    "             \"pre-period mean), the widget must reproduce naive, market_move, did, \"\n",
    "             \"se, ci_lower and ci_upper within tolerance.\"),\n",
    "    \"scenarios\": scenarios,\n",
    "}\n",
    "(DATA / \"checks.json\").write_text(json.dumps(checks, indent=2), encoding=\"utf-8\")\n",
    "print(\"wrote data/checks.json with\", len(scenarios), \"pinned scenarios\")\n",
    "\n",
    "# Article-authority numbers: every figure the prose quotes.\n",
    "naive_over = res[\"naive\"] - res[\"did\"]   # how much the naive read over-credits (= the season)\n",
    "worked = {\n",
    "    \"data_label\": \"synthetic\",\n",
    "    \"n_geos\": N_GEOS,\n",
    "    \"n_treatment\": len(treat_idx),\n",
    "    \"n_control\": len(control_idx),\n",
    "    \"n_pre\": N_PRE,\n",
    "    \"n_live\": N_LIVE,\n",
    "    \"true_effect\": EFFECT,\n",
    "    \"market_lift\": MARKET_MEAN,\n",
    "    \"naive\": round(res[\"naive\"], 2),\n",
    "    \"market_move\": round(res[\"market_move\"], 2),\n",
    "    \"did\": round(res[\"did\"], 2),\n",
    "    \"se\": round(res[\"se\"], 2),\n",
    "    \"ci_lower\": round(res[\"ci_lower\"], 2),\n",
    "    \"ci_upper\": round(res[\"ci_upper\"], 2),\n",
    "    \"naive_over_credit\": round(naive_over, 2),\n",
    "    \"randomisation_p_value\": round(p_value, 4),\n",
    "    \"randomisation_null_sd\": round(null_sd, 2),\n",
    "    \"balance_gap\": round(gap, 2),\n",
    "    \"balance_z\": round(gap_z, 2),\n",
    "    \"power_curve\": [{\"n_geos\": n, \"lift\": round(d, 2), \"half_width\": round(h, 2),\n",
    "                     \"detected_clear_frac\": round(frac, 2)} for n, d, h, frac in pc],\n",
    "}\n",
    "(DATA / \"worked_example.json\").write_text(json.dumps(worked, indent=2), encoding=\"utf-8\")\n",
    "print(\"wrote data/worked_example.json\")\n",
    "print(json.dumps(worked, indent=2))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c421af1",
   "metadata": {},
   "source": [
    "## Run it on your own data\n",
    "\n",
    "Everything below runs the same method on **your** geo test. It never touches the\n",
    "network; your file stays on your machine.\n",
    "\n",
    "**The input format.** One row per region per day, with these columns:\n",
    "\n",
    "| column | meaning | example |\n",
    "|---|---|---|\n",
    "| `geo` | region name or code | `US-CA` |\n",
    "| `date` | the day, ISO format | `2026-05-01` |\n",
    "| `arm` | `treatment` or `control` | `treatment` |\n",
    "| `conversions` | that region's conversions that day | `47` |\n",
    "\n",
    "You also tell it the **launch date** — the first day the change was live. Days\n",
    "before it are the pre-period; days on or after it are the live window.\n",
    "\n",
    "If you only have a raw per-touch or per-conversion export, skip to *Getting your\n",
    "own data into this format* below — there is a consolidator that builds this table\n",
    "for you."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "5ba8201d",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-19T05:23:59.808521Z",
     "iopub.status.busy": "2026-07-19T05:23:59.808521Z",
     "iopub.status.idle": "2026-07-19T05:23:59.839866Z",
     "shell.execute_reply": "2026-07-19T05:23:59.839866Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Your-data loader ready: read_geo_panel(csv_text, launch_date)\n"
     ]
    }
   ],
   "source": [
    "REQUIRED_COLUMNS = [\"geo\", \"date\", \"arm\", \"conversions\"]\n",
    "\n",
    "# Labelled rules-of-thumb, not tuned platform settings. They flag data too thin to\n",
    "# trust; they do not silently change any number.\n",
    "MIN_GEOS_PER_ARM = 5     # fewer than this per arm and randomisation cannot balance\n",
    "MIN_PRE_DAYS = 7         # need a pre-period to establish the baseline\n",
    "MIN_LIVE_DAYS = 7        # structural floor on the live window (14+ for a full read)\n",
    "BALANCE_Z_WARN = 2.0     # pre-period arms this far apart = a shaky randomisation\n",
    "\n",
    "_ARM_ALIASES = {\n",
    "    \"treatment\": \"treatment\", \"treat\": \"treatment\", \"test\": \"treatment\",\n",
    "    \"exposed\": \"treatment\", \"on\": \"treatment\",\n",
    "    \"control\": \"control\", \"holdout\": \"control\", \"held_out\": \"control\",\n",
    "    \"holdback\": \"control\", \"off\": \"control\", \"ctrl\": \"control\",\n",
    "}\n",
    "\n",
    "\n",
    "class DataProblem(Exception):\n",
    "    \"\"\"Raised with a plain-words message when the input cannot be read honestly.\"\"\"\n",
    "\n",
    "\n",
    "def read_geo_panel(text, launch_date):\n",
    "    \"\"\"Parse a geo-day CSV into treatment/control region-deltas + diagnostics.\n",
    "\n",
    "    Returns a dict with the readout plus a `warnings` list. Raises DataProblem\n",
    "    (with a plain-words message) when the file cannot be read at all.\n",
    "    \"\"\"\n",
    "    reader = csv.DictReader(io.StringIO(text))\n",
    "    if reader.fieldnames is None:\n",
    "        raise DataProblem(\"The file is empty -- there are no rows to read.\")\n",
    "    have = [c.strip().lower() for c in reader.fieldnames]\n",
    "    missing = [c for c in REQUIRED_COLUMNS if c not in have]\n",
    "    if missing:\n",
    "        raise DataProblem(\n",
    "            \"The file is missing the column(s): \" + \", \".join(missing) + \".\\n\"\n",
    "            \"Expected columns: \" + \", \".join(REQUIRED_COLUMNS) + \".\")\n",
    "\n",
    "    if isinstance(launch_date, str):\n",
    "        launch_date = date.fromisoformat(launch_date)\n",
    "\n",
    "    # region -> arm, region -> {pre:[..], live:[..]}\n",
    "    arm_of = {}\n",
    "    series = defaultdict(lambda: {\"pre\": [], \"live\": []})\n",
    "    bad_arm = set()\n",
    "    n_rows = 0\n",
    "    for raw in reader:\n",
    "        row = {k.strip().lower(): (v.strip() if isinstance(v, str) else v)\n",
    "               for k, v in raw.items()}\n",
    "        geo = row[\"geo\"]\n",
    "        arm_raw = (row[\"arm\"] or \"\").lower()\n",
    "        arm_norm = _ARM_ALIASES.get(arm_raw)\n",
    "        if arm_norm is None:\n",
    "            bad_arm.add(row[\"arm\"])\n",
    "            continue\n",
    "        try:\n",
    "            d = date.fromisoformat(row[\"date\"])\n",
    "            conv = float(row[\"conversions\"])\n",
    "        except (ValueError, KeyError, TypeError):\n",
    "            continue\n",
    "        prev = arm_of.get(geo)\n",
    "        if prev is not None and prev != arm_norm:\n",
    "            raise DataProblem(\n",
    "                f\"Region '{geo}' appears in both arms. Each region must be in one \"\n",
    "                \"arm for the whole test.\")\n",
    "        arm_of[geo] = arm_norm\n",
    "        bucket = \"pre\" if d < launch_date else \"live\"\n",
    "        series[geo][bucket].append(conv)\n",
    "        n_rows += 1\n",
    "\n",
    "    if bad_arm:\n",
    "        raise DataProblem(\n",
    "            \"Unrecognised arm label(s): \" + \", \".join(sorted(bad_arm)) + \".\\n\"\n",
    "            \"Use 'treatment' (or test/holdout-exposed) and 'control' (or holdout).\")\n",
    "    if n_rows == 0:\n",
    "        raise DataProblem(\"No usable rows -- check the date and conversions columns.\")\n",
    "\n",
    "    warnings = []\n",
    "    # Per-region pre/live means -> delta, grouped by arm.\n",
    "    dT, dC, pre_T, pre_C = [], [], [], []\n",
    "    min_pre = min_live = 10 ** 9\n",
    "    dropped = []\n",
    "    for geo, s in series.items():\n",
    "        if not s[\"pre\"] or not s[\"live\"]:\n",
    "            dropped.append(geo)\n",
    "            continue\n",
    "        min_pre = min(min_pre, len(s[\"pre\"]))\n",
    "        min_live = min(min_live, len(s[\"live\"]))\n",
    "        delta = np.mean(s[\"live\"]) - np.mean(s[\"pre\"])\n",
    "        if arm_of[geo] == \"treatment\":\n",
    "            dT.append(delta); pre_T.append(np.mean(s[\"pre\"]))\n",
    "        else:\n",
    "            dC.append(delta); pre_C.append(np.mean(s[\"pre\"]))\n",
    "\n",
    "    if dropped:\n",
    "        warnings.append(\n",
    "            f\"{len(dropped)} region(s) had no pre-period or no live-window rows and \"\n",
    "            \"were dropped: \" + \", \".join(dropped[:6]) + (\"...\" if len(dropped) > 6 else \"\"))\n",
    "    if len(dT) < MIN_GEOS_PER_ARM or len(dC) < MIN_GEOS_PER_ARM:\n",
    "        warnings.append(\n",
    "            f\"Thin design: {len(dT)} treatment and {len(dC)} control regions \"\n",
    "            f\"(rule of thumb: at least {MIN_GEOS_PER_ARM} per arm). With this few \"\n",
    "            \"regions the range below is wide and randomisation may not have balanced \"\n",
    "            \"the arms -- treat the number as directional.\")\n",
    "    if min_pre < MIN_PRE_DAYS:\n",
    "        warnings.append(\n",
    "            f\"Short pre-period: as few as {min_pre} day(s) for some region \"\n",
    "            f\"(rule of thumb: at least {MIN_PRE_DAYS}). The baseline is shaky.\")\n",
    "    if min_live < MIN_LIVE_DAYS:\n",
    "        warnings.append(\n",
    "            f\"Short live window: as few as {min_live} day(s) for some region \"\n",
    "            f\"(rule of thumb: at least {MIN_LIVE_DAYS}, ideally 14+). The lift is \"\n",
    "            \"measured over very little time.\")\n",
    "\n",
    "    if len(dT) < 2 or len(dC) < 2:\n",
    "        raise DataProblem(\n",
    "            \"Need at least 2 regions in each arm to measure a lift and its range.\")\n",
    "\n",
    "    r = readout(dT, dC)\n",
    "    gap, gap_z = balance_gap(pre_T, pre_C)\n",
    "    r[\"balance_gap\"] = gap\n",
    "    r[\"balance_z\"] = gap_z\n",
    "    if abs(gap_z) > BALANCE_Z_WARN:\n",
    "        warnings.append(\n",
    "            f\"Arms look unbalanced before the change (pre-period gap {gap:+.1f}, \"\n",
    "            f\"z {gap_z:+.1f}). The randomisation may not have produced comparable \"\n",
    "            \"arms; the lift may be biased by that head start.\")\n",
    "    if r[\"ci_lower\"] <= 0 <= r[\"ci_upper\"]:\n",
    "        warnings.append(\n",
    "            \"The range includes zero: this test could not detect a clear effect. \"\n",
    "            \"That is NOT proof the change did nothing -- it usually means the test \"\n",
    "            \"was too small. Add regions or run longer before concluding.\")\n",
    "    r[\"warnings\"] = warnings\n",
    "    return r\n",
    "\n",
    "\n",
    "def show_result(r):\n",
    "    print(f\"  regions: {r['n_treatment']} treatment, {r['n_control']} control\")\n",
    "    print(f\"  naive (treated before/after): +{r['naive']:.2f}\")\n",
    "    print(f\"  what the market did (control): +{r['market_move']:.2f}\")\n",
    "    print(f\"  GEO-HOLDOUT LIFT: {r['did']:+.2f}  90% range [{r['ci_lower']:+.2f}, {r['ci_upper']:+.2f}]\")\n",
    "    for w in r[\"warnings\"]:\n",
    "        print(\"  ! \" + w)\n",
    "    if not r[\"warnings\"]:\n",
    "        print(\"  (no data-sufficiency warnings)\")\n",
    "\n",
    "\n",
    "print(\"Your-data loader ready: read_geo_panel(csv_text, launch_date)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f044d20",
   "metadata": {},
   "source": [
    "### A worked example on a second (independent) synthetic file\n",
    "\n",
    "To prove the loader works, we generate a *fresh* geo panel with a known effect,\n",
    "write it out as the exact CSV a reader would supply, and read it back. The\n",
    "recovered lift should land near the true effect we baked in."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "9edc7f65",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-19T05:23:59.845891Z",
     "iopub.status.busy": "2026-07-19T05:23:59.843883Z",
     "iopub.status.idle": "2026-07-19T05:23:59.871049Z",
     "shell.execute_reply": "2026-07-19T05:23:59.871049Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First few lines of the reader-format CSV:\n",
      "geo,date,arm,conversions\n",
      "geo00,2026-04-10,control,47\n",
      "geo00,2026-04-11,control,54\n",
      "geo00,2026-04-12,control,57\n",
      "\n",
      "True effect baked in: +5.0/day. Reading it back:\n",
      "  regions: 12 treatment, 12 control\n",
      "  naive (treated before/after): +14.11\n",
      "  what the market did (control): +8.42\n",
      "  GEO-HOLDOUT LIFT: +5.69  90% range [+2.68, +8.69]\n",
      "  (no data-sufficiency warnings)\n"
     ]
    }
   ],
   "source": [
    "def panel_to_csv(daily, arm, launch_date, n_pre):\n",
    "    \"\"\"Serialise a simulated panel to the reader's geo,date,arm,conversions CSV.\"\"\"\n",
    "    start = date.fromisoformat(launch_date) - timedelta(days=n_pre)\n",
    "    out = io.StringIO()\n",
    "    w = csv.writer(out)\n",
    "    w.writerow(REQUIRED_COLUMNS)\n",
    "    for g in range(daily.shape[0]):\n",
    "        for t in range(daily.shape[1]):\n",
    "            d = start + timedelta(days=t)\n",
    "            conv = max(0, int(round(daily[g, t])))\n",
    "            w.writerow([f\"geo{g:02d}\", d.isoformat(), arm[g], conv])\n",
    "    return out.getvalue()\n",
    "\n",
    "\n",
    "check_rng = np.random.default_rng(SEED + 202)\n",
    "d2, a2, ti2, ci2 = simulate_panel(24, N_PRE, N_LIVE, 50.0, 0.4, 7.0, 4.5, 5.0, 3.0, check_rng)\n",
    "LAUNCH = \"2026-05-01\"\n",
    "csv_text = panel_to_csv(d2, a2, LAUNCH, N_PRE)\n",
    "print(\"First few lines of the reader-format CSV:\")\n",
    "print(\"\\n\".join(csv_text.splitlines()[:4]))\n",
    "print(\"\\nTrue effect baked in: +5.0/day. Reading it back:\")\n",
    "r2 = read_geo_panel(csv_text, LAUNCH)\n",
    "show_result(r2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2c4778b2",
   "metadata": {},
   "source": [
    "### The loader fails honestly\n",
    "\n",
    "A method that prints a confident number on unusable data is worse than useless.\n",
    "Two deliberately broken inputs — wrong columns, and a test far too small — must\n",
    "produce a plain-words error or a warning, never a silent wrong answer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "8ec80636",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-19T05:23:59.875064Z",
     "iopub.status.busy": "2026-07-19T05:23:59.875064Z",
     "iopub.status.idle": "2026-07-19T05:23:59.886284Z",
     "shell.execute_reply": "2026-07-19T05:23:59.886284Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1) Correctly refused wrong columns:\n",
      "   The file is missing the column(s): geo, date, arm, conversions.\n",
      "   Expected columns: geo, date, arm, conversions.\n",
      "\n",
      "(2) A 4-region, 5-day test -- reads, but warns:\n",
      "  regions: 2 treatment, 2 control\n",
      "  naive (treated before/after): +18.90\n",
      "  what the market did (control): +5.87\n",
      "  GEO-HOLDOUT LIFT: +13.03  90% range [+6.01, +20.06]\n",
      "  ! Thin design: 2 treatment and 2 control regions (rule of thumb: at least 5 per arm). With this few regions the range below is wide and randomisation may not have balanced the arms -- treat the number as directional.\n",
      "  ! Short pre-period: as few as 6 day(s) for some region (rule of thumb: at least 7). The baseline is shaky.\n",
      "  ! Short live window: as few as 5 day(s) for some region (rule of thumb: at least 7, ideally 14+). The lift is measured over very little time.\n"
     ]
    }
   ],
   "source": [
    "# (1) Wrong columns entirely.\n",
    "BROKEN_CSV = \"region,clicks\\nUS-CA,120\\nUS-NY,98\\n\"\n",
    "try:\n",
    "    read_geo_panel(BROKEN_CSV, \"2026-05-01\")\n",
    "    print(\"(1) ERROR: should have raised\")\n",
    "except DataProblem as e:\n",
    "    print(\"(1) Correctly refused wrong columns:\\n   \" + str(e).replace(\"\\n\", \"\\n   \"))\n",
    "\n",
    "# (2) A tiny test: 2 regions per arm, a 5-day live window. It should read, but\n",
    "#     warn loudly that it is underpowered and (very likely) that the range covers zero.\n",
    "tiny_rng = np.random.default_rng(SEED + 303)\n",
    "d3, a3, ti3, ci3 = simulate_panel(4, 6, 5, 45.0, 0.4, 8.0, 6.0, 4.0, 3.5, tiny_rng)\n",
    "tiny_csv = panel_to_csv(d3, a3, \"2026-05-01\", 6)\n",
    "print(\"\\n(2) A 4-region, 5-day test -- reads, but warns:\")\n",
    "r3 = read_geo_panel(tiny_csv, \"2026-05-01\")\n",
    "show_result(r3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "25adcb2e",
   "metadata": {},
   "source": [
    "## Getting your own data into this format\n",
    "\n",
    "Most analytics exports are not a tidy geo-day table — they are a long log of\n",
    "individual conversions, each stamped with a region and a date. The consolidator\n",
    "below rolls that raw log up into the `geo,date,conversions` shape (filling in the\n",
    "zero-conversion days, which matter), after which you add the `arm` column from\n",
    "your own assignment and set the launch date.\n",
    "\n",
    "**Two entry points, both local:**\n",
    "\n",
    "1. **A ready daily table** — `geo,date,arm,conversions`, one row per region-day.\n",
    "   Feed it straight to `read_geo_panel`.\n",
    "2. **A raw conversion log** — `geo,date`, one row per conversion. Run\n",
    "   `consolidate_conversions` to get daily counts, attach your arm assignment, and\n",
    "   then read it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "28358cb6",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-19T05:23:59.890300Z",
     "iopub.status.busy": "2026-07-19T05:23:59.890300Z",
     "iopub.status.idle": "2026-07-19T05:23:59.902533Z",
     "shell.execute_reply": "2026-07-19T05:23:59.902533Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Raw log -> daily counts (note the filled-in 2026-05-02 zero for US-CA):\n",
      "geo,date,conversions\r\n",
      "US-CA,2026-05-01,2\r\n",
      "US-CA,2026-05-02,0\r\n",
      "US-CA,2026-05-03,1\r\n",
      "US-NY,2026-05-02,1\r\n",
      "\n"
     ]
    }
   ],
   "source": [
    "RAW_COLUMNS = [\"geo\", \"date\"]   # one row per conversion event\n",
    "\n",
    "\n",
    "def consolidate_conversions(text, fill_zero_days=True):\n",
    "    \"\"\"Roll a raw per-conversion log (geo,date) into daily counts per region.\n",
    "\n",
    "    Fills in zero-conversion days across each region's own date span, because a\n",
    "    day with no conversions is real signal, not a missing row.\n",
    "    \"\"\"\n",
    "    reader = csv.DictReader(io.StringIO(text))\n",
    "    have = [c.strip().lower() for c in (reader.fieldnames or [])]\n",
    "    missing = [c for c in RAW_COLUMNS if c not in have]\n",
    "    if missing:\n",
    "        raise DataProblem(\"Raw log missing column(s): \" + \", \".join(missing) + \".\")\n",
    "    counts = defaultdict(int)\n",
    "    all_dates = defaultdict(list)\n",
    "    for raw in reader:\n",
    "        row = {k.strip().lower(): (v.strip() if isinstance(v, str) else v) for k, v in raw.items()}\n",
    "        try:\n",
    "            d = date.fromisoformat(row[\"date\"])\n",
    "        except (ValueError, KeyError, TypeError):\n",
    "            continue\n",
    "        counts[(row[\"geo\"], d)] += 1\n",
    "        all_dates[row[\"geo\"]].append(d)\n",
    "    rows = []\n",
    "    for geo, ds in all_dates.items():\n",
    "        lo, hi = min(ds), max(ds)\n",
    "        span = [(lo + timedelta(days=i)) for i in range((hi - lo).days + 1)] if fill_zero_days else sorted(set(ds))\n",
    "        for d in span:\n",
    "            rows.append((geo, d.isoformat(), counts.get((geo, d), 0)))\n",
    "    rows.sort()\n",
    "    out = io.StringIO()\n",
    "    w = csv.writer(out)\n",
    "    w.writerow([\"geo\", \"date\", \"conversions\"])\n",
    "    w.writerows(rows)\n",
    "    return out.getvalue()\n",
    "\n",
    "\n",
    "# Demo: a handful of raw conversions -> a daily table with zero-days filled.\n",
    "RAW_DEMO = \"geo,date\\nUS-CA,2026-05-01\\nUS-CA,2026-05-01\\nUS-CA,2026-05-03\\nUS-NY,2026-05-02\\n\"\n",
    "print(\"Raw log -> daily counts (note the filled-in 2026-05-02 zero for US-CA):\")\n",
    "print(consolidate_conversions(RAW_DEMO))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d0873826",
   "metadata": {},
   "source": [
    "### Getting the raw conversions out of GA4 (BigQuery)\n",
    "\n",
    "If your site sends conversions to GA4 with BigQuery export on, this pulls one row\n",
    "per conversion, stamped with region and date — the raw-log shape the consolidator\n",
    "takes. Swap the event name for your conversion event and the region dimension for\n",
    "however you defined your test geographies.\n",
    "\n",
    "```sql\n",
    "-- One row per conversion, with region and date. Feed to consolidate_conversions().\n",
    "SELECT\n",
    "  geo.region                                   AS geo,\n",
    "  PARSE_DATE('%Y%m%d', event_date)             AS date\n",
    "FROM `your_project.analytics_XXXXXX.events_*`\n",
    "WHERE event_name = 'purchase'                  -- your conversion event\n",
    "  AND geo.region IS NOT NULL\n",
    "  AND _TABLE_SUFFIX BETWEEN '20260410' AND '20260514'\n",
    "```\n",
    "\n",
    "Then, in your own spreadsheet or a one-line join, add the `arm` column from the\n",
    "treatment/control split you actually ran, and set the launch date below."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "89b6226c",
   "metadata": {},
   "source": [
    "### Your turn\n",
    "\n",
    "Set the two variables below and run. Leave `YOUR_PANEL_CSV` as `None` to keep\n",
    "seeing the worked example; point it at your file to run your own test."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "f0a2b5e6",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-19T05:23:59.908559Z",
     "iopub.status.busy": "2026-07-19T05:23:59.906550Z",
     "iopub.status.idle": "2026-07-19T05:23:59.914538Z",
     "shell.execute_reply": "2026-07-19T05:23:59.914538Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No file set -- showing the worked example from the top of the notebook:\n",
      "  regions: 10 treatment, 10 control\n",
      "  naive (treated before/after): +15.09\n",
      "  what the market did (control): +8.68\n",
      "  GEO-HOLDOUT LIFT: +6.41  90% range [+2.16, +10.66]\n",
      "  (no data-sufficiency warnings)\n"
     ]
    }
   ],
   "source": [
    "YOUR_PANEL_CSV = None          # e.g. \"my_geo_test.csv\" (columns: geo,date,arm,conversions)\n",
    "YOUR_LAUNCH_DATE = \"2026-05-01\"  # the first day the change was live (ISO format)\n",
    "\n",
    "if YOUR_PANEL_CSV:\n",
    "    text = Path(YOUR_PANEL_CSV).read_text(encoding=\"utf-8\")\n",
    "    print(f\"Reading {YOUR_PANEL_CSV} ...\")\n",
    "    show_result(read_geo_panel(text, YOUR_LAUNCH_DATE))\n",
    "else:\n",
    "    print(\"No file set -- showing the worked example from the top of the notebook:\")\n",
    "    show_result({**res, \"warnings\": [], \"n_treatment\": len(treat_idx),\n",
    "                 \"n_control\": len(control_idx)})"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8b30cc5e",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "### What this notebook is, and is not\n",
    "\n",
    "**It is** a faithful, runnable implementation of a geo-holdout's core: the\n",
    "difference-in-differences lift, the randomisation-based significance test, the\n",
    "pre-period balance check, and the honest range. All data here is **synthetic** and\n",
    "labelled as such; the point is the method, not the numbers.\n",
    "\n",
    "**It is not** the platform's production estimator. A production geo-holdout adds\n",
    "refinements this notebook keeps out for clarity — pairing comparable regions and\n",
    "trimming the most extreme pairs to tighten the read, a synthetic-control fallback\n",
    "when the arms cannot be balanced, spillover handling when neighbouring regions\n",
    "leak, and a formal power analysis before the test is ever launched. Those make the\n",
    "read sturdier; they do not change the idea you just ran.\n",
    "\n",
    "The deepest honest point stays the same at every level of sophistication: a\n",
    "geo-holdout removes *confounding* by randomising, but it cannot remove *sampling\n",
    "noise*. It gives you a lift **and a range** — and when the range covers zero, the\n",
    "right answer is \"too small to tell,\" never \"proven to do nothing.\""
   ]
  }
 ],
 "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.12.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}