{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "e7ffc122",
   "metadata": {},
   "source": [
    "# Is this difference real, or am I looking at noise?\n",
    "\n",
    "Two numbers side by side, one bigger than the other. Mobile converts at\n",
    "2.4%, desktop at 1.9%. One region beats another. This week beats last week.\n",
    "The whole job runs on comparisons like these, and the reflex is to read the\n",
    "gap as a fact about the world.\n",
    "\n",
    "Most of the time it is a fact about the sample.\n",
    "\n",
    "**The data in this notebook is synthetic.** It is generated here, with the\n",
    "answer built in, so that every reading can be scored against a truth nobody\n",
    "has to guess at. Run it on your own numbers in the last section; nothing\n",
    "leaves your machine.\n",
    "\n",
    "The idea everything else follows from: a rate computed from a hundred clicks\n",
    "and a rate computed from a hundred thousand are not the same kind of number,\n",
    "and a table of forty rows is not one comparison. It is forty."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "29f78c2c",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-24T12:58:35.819191Z",
     "iopub.status.busy": "2026-10-24T12:58:35.817657Z",
     "iopub.status.idle": "2026-10-24T12:58:36.911377Z",
     "shell.execute_reply": "2026-10-24T12:58:36.910418Z"
    }
   },
   "outputs": [],
   "source": [
    "import json\n",
    "import math\n",
    "import warnings\n",
    "from pathlib import Path\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "SEED = 20260908\n",
    "rng = np.random.default_rng(SEED)\n",
    "\n",
    "PAPER = \"#fdfcf9\"\n",
    "INK = \"#1f2124\"\n",
    "MUTED = \"#565c66\"\n",
    "LINE = \"#e6e2da\"\n",
    "SIGNAL = \"#0f6e56\"\n",
    "FLAG = \"#b06a2c\"\n",
    "NAIVE = \"#2a78d6\"\n",
    "\n",
    "plt.rcParams.update({\n",
    "    \"figure.facecolor\": PAPER, \"axes.facecolor\": PAPER, \"savefig.facecolor\": PAPER,\n",
    "    \"axes.edgecolor\": LINE, \"axes.labelcolor\": INK, \"text.color\": INK,\n",
    "    \"xtick.color\": MUTED, \"ytick.color\": MUTED, \"axes.grid\": True,\n",
    "    \"grid.color\": LINE, \"grid.linewidth\": 0.8, \"axes.spines.top\": False,\n",
    "    \"axes.spines.right\": False, \"font.size\": 11,\n",
    "})\n",
    "warnings.filterwarnings(\"ignore\", category=RuntimeWarning)\n",
    "\n",
    "HERE = Path.cwd()\n",
    "DATA = HERE / \"data\"\n",
    "FIGURES = HERE / \"figures\"\n",
    "DATA.mkdir(exist_ok=True)\n",
    "FIGURES.mkdir(exist_ok=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2c8bf9dd",
   "metadata": {},
   "source": [
    "## The engine\n",
    "\n",
    "Four pieces, each doing one job. They are written out rather than imported\n",
    "from a statistics package so you can read exactly what is being computed,\n",
    "and so the interactive version on the page can run the identical arithmetic\n",
    "in your browser."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "8a94fcf2",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-24T12:58:36.916985Z",
     "iopub.status.busy": "2026-10-24T12:58:36.916589Z",
     "iopub.status.idle": "2026-10-24T12:58:36.935083Z",
     "shell.execute_reply": "2026-10-24T12:58:36.934261Z"
    }
   },
   "outputs": [],
   "source": [
    "ALPHA = 0.05                 # a single test's significance level\n",
    "Q = 0.05                     # the false-discovery rate we are willing to live with\n",
    "Z95 = 1.959963984540054      # the standard-normal quantile at 95%\n",
    "EYEBALL_DROP = 0.20          # \"it's down more than a fifth\" — the reflex rule\n",
    "\n",
    "\n",
    "def clamp(x, n):\n",
    "    \"\"\"A count held inside its own domain before it becomes a rate.\n",
    "\n",
    "    A refund can push a conversion total below zero and a cross-device credit can push it above\n",
    "    the clicks; either way p(1-p) stops being a variance. Clamping here rather than guarding\n",
    "    later is what keeps every function below total.\n",
    "    \"\"\"\n",
    "    return min(max(float(x), 0.0), float(n))\n",
    "\n",
    "\n",
    "def two_proportion_test(x_a, n_a, x_b, n_b, continuity=False):\n",
    "    \"\"\"Is the gap between two rates bigger than the counts can explain?\n",
    "\n",
    "    The standard error is POOLED - both groups' counts combined into one rate under the\n",
    "    assumption that they are the same. That is the right form for testing equality. An unpooled\n",
    "    standard error answers a different question (how wide is the gap), and using one for the\n",
    "    other is the most common way this test is got wrong.\n",
    "    \"\"\"\n",
    "    if n_a <= 0 or n_b <= 0:\n",
    "        return {\"evaluable\": False, \"reason\": \"one of the groups has no trials\"}\n",
    "    x_a, x_b = clamp(x_a, n_a), clamp(x_b, n_b)\n",
    "    p_a, p_b = x_a / n_a, x_b / n_b\n",
    "    pooled = (x_a + x_b) / (n_a + n_b)\n",
    "    var = pooled * (1 - pooled) * (1 / n_a + 1 / n_b)\n",
    "    if var <= 0:\n",
    "        return {\"evaluable\": False, \"reason\": \"both groups are all-success or all-fail\"}\n",
    "    diff = p_a - p_b\n",
    "    if continuity:\n",
    "        shrink = 0.5 * (1 / n_a + 1 / n_b)\n",
    "        diff = math.copysign(max(abs(diff) - shrink, 0.0), diff)\n",
    "    z = diff / math.sqrt(var)\n",
    "    return {\"evaluable\": True, \"rate_a\": p_a, \"rate_b\": p_b, \"diff\": p_a - p_b,\n",
    "            \"z\": z, \"p\": math.erfc(abs(z) / math.sqrt(2))}\n",
    "\n",
    "\n",
    "def wilson_interval(x, n, z=Z95):\n",
    "    \"\"\"An honest range for one rate, wide when the count is small.\n",
    "\n",
    "    The textbook interval - the rate plus or minus a multiple of its standard error - collapses\n",
    "    to zero width when nothing has converted yet, which asserts certainty from no evidence.\n",
    "    This one never does.\n",
    "    \"\"\"\n",
    "    if n <= 0:\n",
    "        return {\"evaluable\": False, \"reason\": \"no trials\"}\n",
    "    x = clamp(x, n)\n",
    "    p = x / n\n",
    "    centre = (p + z * z / (2 * n)) / (1 + z * z / n)\n",
    "    half = (z * math.sqrt(p * (1 - p) / n + z * z / (4 * n * n))) / (1 + z * z / n)\n",
    "    return {\"evaluable\": True, \"rate\": p, \"low\": max(centre - half, 0.0),\n",
    "            \"high\": min(centre + half, 1.0)}\n",
    "\n",
    "\n",
    "def wald_interval(x, n, z=Z95):\n",
    "    \"\"\"The textbook interval, here only so the notebook can show where it fails.\"\"\"\n",
    "    if n <= 0:\n",
    "        return {\"evaluable\": False}\n",
    "    p = clamp(x, n) / n\n",
    "    half = z * math.sqrt(p * (1 - p) / n)\n",
    "    return {\"evaluable\": True, \"rate\": p, \"low\": max(p - half, 0.0), \"high\": min(p + half, 1.0)}\n",
    "\n",
    "\n",
    "def benjamini_hochberg(pvalues):\n",
    "    \"\"\"Adjusted p-values for a family of tests, returned in the order they came in.\n",
    "\n",
    "    Scan forty rows at the usual threshold and about two of them come up significant by chance\n",
    "    alone. This is the correction for that: it controls the share of false positives among the\n",
    "    rows you end up flagging, rather than the chance of any false positive at all - which is a\n",
    "    weaker guarantee and a much less punishing one.\n",
    "    \"\"\"\n",
    "    p = np.asarray(pvalues, dtype=float)\n",
    "    m = p.size\n",
    "    if m == 0:\n",
    "        return np.array([])\n",
    "    order = np.argsort(p)\n",
    "    ranked = p[order]\n",
    "    scaled = ranked * m / np.arange(1, m + 1)\n",
    "    # the step-up: taken from the largest rank downward so the adjusted values never decrease\n",
    "    adjusted_sorted = np.minimum.accumulate(scaled[::-1])[::-1]\n",
    "    out = np.empty(m, dtype=float)\n",
    "    out[order] = np.minimum(adjusted_sorted, 1.0)\n",
    "    return out\n",
    "\n",
    "\n",
    "def ratio_difference_test(num_a, den_a, count_a, num_b, den_b, count_b, z=Z95):\n",
    "    \"\"\"The same question for a ratio like cost per acquisition.\n",
    "\n",
    "    A rate is successes over trials; a ratio is one total over another, and the thing that sets\n",
    "    its uncertainty is the number of EVENTS behind it, not the size of the totals. Twenty\n",
    "    conversions at ten euros each and twenty at a thousand carry the same uncertainty about the\n",
    "    cost per conversion.\n",
    "    \"\"\"\n",
    "    if min(den_a, den_b, count_a, count_b) <= 0 or num_a <= 0 or num_b <= 0:\n",
    "        return {\"evaluable\": False, \"reason\": \"a non-positive total or count\"}\n",
    "    r_a, r_b = num_a / den_a, num_b / den_b\n",
    "    se = math.sqrt(1 / count_a + 1 / count_b)\n",
    "    log_ratio = math.log(r_a / r_b)\n",
    "    return {\"evaluable\": True, \"ratio_a\": r_a, \"ratio_b\": r_b,\n",
    "            \"ratio_of_ratios\": math.exp(log_ratio), \"z\": log_ratio / se,\n",
    "            \"p\": math.erfc(abs(log_ratio / se) / math.sqrt(2)),\n",
    "            \"ci_low\": math.exp(log_ratio - z * se), \"ci_high\": math.exp(log_ratio + z * se)}\n",
    "\n",
    "\n",
    "def eyeball_flag(rate, baseline, drop=EYEBALL_DROP):\n",
    "    \"\"\"The reflex: flag a row that sits more than a fifth away from the account's own average.\"\"\"\n",
    "    if baseline <= 0:\n",
    "        return False\n",
    "    return abs(rate - baseline) / baseline >= drop"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7e8c2e81",
   "metadata": {},
   "source": [
    "## A synthetic account\n",
    "\n",
    "Forty segments, the shape of any breakdown a platform will hand you, by\n",
    "device, region, match type or placement. Most of them convert at the same\n",
    "true rate. Three genuinely do not. The clicks are spread the way they always\n",
    "are: a few heavy rows and a long tail of thin ones.\n",
    "\n",
    "Every flag raised on one of the thirty-seven identical rows is a false one,\n",
    "by construction."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "290e08ad",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-24T12:58:36.938656Z",
     "iopub.status.busy": "2026-10-24T12:58:36.938327Z",
     "iopub.status.idle": "2026-10-24T12:58:36.956721Z",
     "shell.execute_reply": "2026-10-24T12:58:36.955545Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "one account, 40 segments, 43,181 clicks, 865 conversions\n",
      "  truly different rows      : 3\n",
      "  flagged by the reflex     : 21\n",
      "  flagged by one test each  : 4\n",
      "  flagged after correction  : 1\n"
     ]
    }
   ],
   "source": [
    "SEGMENTS = 40\n",
    "BASE_CVR = 0.020\n",
    "TRUE_LIFTS = {5: 1.50, 17: 0.60, 28: 1.30}     # segment index -> multiplier on the base rate\n",
    "CLICK_FLOOR, CLICK_CEILING = 180, 9000\n",
    "\n",
    "\n",
    "def make_account(generator, segments=SEGMENTS, base=BASE_CVR, lifts=None):\n",
    "    \"\"\"One account's breakdown table, with the truth recorded beside it.\"\"\"\n",
    "    lifts = TRUE_LIFTS if lifts is None else lifts\n",
    "    # a realistic long tail: a few heavy segments, many thin ones\n",
    "    weights = generator.lognormal(mean=0.0, sigma=1.1, size=segments)\n",
    "    clicks = np.clip(CLICK_FLOOR + weights / weights.sum() * segments * 900,\n",
    "                     CLICK_FLOOR, CLICK_CEILING).astype(int)\n",
    "    true_rate = np.full(segments, base, dtype=float)\n",
    "    for idx, mult in lifts.items():\n",
    "        true_rate[idx] = base * mult\n",
    "    conversions = generator.binomial(clicks, true_rate)\n",
    "    return {\"segment\": np.arange(segments), \"clicks\": clicks, \"conversions\": conversions,\n",
    "            \"true_rate\": true_rate, \"really_different\": np.array(\n",
    "                [i in lifts for i in range(segments)])}\n",
    "\n",
    "\n",
    "def read_account(account):\n",
    "    \"\"\"Score every row three ways: the reflex, one test per row, and the corrected family.\n",
    "\n",
    "    Each row is tested against the REST of the account pooled, which is what a person actually\n",
    "    does when they look at a breakdown and ask whether a row stands out.\n",
    "    \"\"\"\n",
    "    clicks, conversions = account[\"clicks\"], account[\"conversions\"]\n",
    "    total_c, total_x = clicks.sum(), conversions.sum()\n",
    "    rows = []\n",
    "    for i in range(len(clicks)):\n",
    "        rest_c, rest_x = total_c - clicks[i], total_x - conversions[i]\n",
    "        rest_rate = rest_x / rest_c if rest_c > 0 else 0.0\n",
    "        test = two_proportion_test(conversions[i], clicks[i], rest_x, rest_c)\n",
    "        wilson = wilson_interval(conversions[i], clicks[i])\n",
    "        rows.append({\n",
    "            \"segment\": i, \"clicks\": int(clicks[i]), \"conversions\": int(conversions[i]),\n",
    "            \"rate\": conversions[i] / clicks[i], \"rest_rate\": rest_rate,\n",
    "            \"p\": test[\"p\"] if test[\"evaluable\"] else 1.0,\n",
    "            \"z\": test[\"z\"] if test[\"evaluable\"] else 0.0,\n",
    "            \"wilson_low\": wilson[\"low\"], \"wilson_high\": wilson[\"high\"],\n",
    "            \"eyeball\": eyeball_flag(conversions[i] / clicks[i], rest_rate),\n",
    "            \"really_different\": bool(account[\"really_different\"][i]),\n",
    "        })\n",
    "    frame = pd.DataFrame(rows)\n",
    "    frame[\"p_adjusted\"] = benjamini_hochberg(frame[\"p\"].to_numpy())\n",
    "    frame[\"single_test\"] = frame[\"p\"] < ALPHA\n",
    "    frame[\"corrected\"] = frame[\"p_adjusted\"] < Q\n",
    "    return frame\n",
    "\n",
    "\n",
    "account = make_account(rng)\n",
    "table = read_account(account)\n",
    "print(f\"one account, {SEGMENTS} segments, {int(account['clicks'].sum()):,} clicks, \"\n",
    "      f\"{int(account['conversions'].sum()):,} conversions\")\n",
    "print(f\"  truly different rows      : {int(table['really_different'].sum())}\")\n",
    "print(f\"  flagged by the reflex     : {int(table['eyeball'].sum())}\")\n",
    "print(f\"  flagged by one test each  : {int(table['single_test'].sum())}\")\n",
    "print(f\"  flagged after correction  : {int(table['corrected'].sum())}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "53a5c3a5",
   "metadata": {},
   "source": [
    "## How often each reading is wrong\n",
    "\n",
    "One account tells you nothing: the counts that came up are one draw. So the\n",
    "same account is generated many times over, and each reading is scored against\n",
    "the truth that was written in.\n",
    "\n",
    "Two numbers matter, and they are not the same. **How many of the rows you\n",
    "flagged are wrong** is the one you feel, because those are the rows you spend\n",
    "a week acting on. **How many of the truly different rows you found** is what\n",
    "you give up to get there."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "4e6d42e3",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-24T12:58:36.961186Z",
     "iopub.status.busy": "2026-10-24T12:58:36.960809Z",
     "iopub.status.idle": "2026-10-24T12:58:38.687696Z",
     "shell.execute_reply": "2026-10-24T12:58:38.686108Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    reading  flagged_per_account  false_per_account  share_of_flags_that_are_false  false_discovery_rate_per_account  share_of_real_ones_found  accounts_with_at_least_one_false_flag\n",
      "    eyeball                 18.4               16.0                           87.0                              86.8                      79.7                                  100.0\n",
      "single_test                  3.0                1.8                           59.0                              55.7                      41.4                                   85.5\n",
      "  corrected                  0.5                0.1                           12.7                               4.4                      13.8                                    6.0\n"
     ]
    }
   ],
   "source": [
    "ACCOUNTS = 400\n",
    "\n",
    "\n",
    "def score_readings(reps=ACCOUNTS, seed=SEED + 1):\n",
    "    \"\"\"Every reading, over many accounts, scored against the built-in truth.\"\"\"\n",
    "    generator = np.random.default_rng(seed)\n",
    "    names = [\"eyeball\", \"single_test\", \"corrected\"]\n",
    "    tally = {n: {\"flagged\": 0, \"false\": 0, \"found\": 0, \"accounts_with_a_false_flag\": 0,\n",
    "                 \"per_account_false_share\": 0.0}\n",
    "             for n in names}\n",
    "    truly = 0\n",
    "    for _ in range(reps):\n",
    "        frame = read_account(make_account(generator))\n",
    "        truly += int(frame[\"really_different\"].sum())\n",
    "        for name in names:\n",
    "            picked = frame[name].to_numpy()\n",
    "            real = frame[\"really_different\"].to_numpy()\n",
    "            tally[name][\"flagged\"] += int(picked.sum())\n",
    "            tally[name][\"false\"] += int((picked & ~real).sum())\n",
    "            tally[name][\"found\"] += int((picked & real).sum())\n",
    "            tally[name][\"accounts_with_a_false_flag\"] += int((picked & ~real).any())\n",
    "            # The correction's promise is about this average: each account's share of wrong flags,\n",
    "            # an account with no flags counting as none wrong. The pooled share below divides the\n",
    "            # totals instead, so a few accounts with one wrong flag each weigh far more.\n",
    "            if picked.any():\n",
    "                tally[name][\"per_account_false_share\"] += (picked & ~real).sum() / picked.sum()\n",
    "    out = []\n",
    "    for name in names:\n",
    "        t = tally[name]\n",
    "        out.append({\n",
    "            \"reading\": name,\n",
    "            \"flagged_per_account\": t[\"flagged\"] / reps,\n",
    "            \"false_per_account\": t[\"false\"] / reps,\n",
    "            \"share_of_flags_that_are_false\": (100 * t[\"false\"] / t[\"flagged\"]) if t[\"flagged\"] else 0.0,\n",
    "            \"false_discovery_rate_per_account\": 100 * t[\"per_account_false_share\"] / reps,\n",
    "            \"share_of_real_ones_found\": 100 * t[\"found\"] / truly,\n",
    "            \"accounts_with_at_least_one_false_flag\": 100 * t[\"accounts_with_a_false_flag\"] / reps,\n",
    "        })\n",
    "    return pd.DataFrame(out)\n",
    "\n",
    "\n",
    "readings = score_readings()\n",
    "print(readings.round(1).to_string(index=False))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff67b3ca",
   "metadata": {},
   "source": [
    "## The trap is the table, not the test\n",
    "\n",
    "A single test at the usual threshold is wrong about one time in twenty. That\n",
    "is the deal you sign when you pick the threshold, and on one comparison it is\n",
    "a good deal.\n",
    "\n",
    "It stops being a good deal when you make the comparison forty times. Nobody\n",
    "decides to run forty tests; they scan a breakdown and stop at the row that\n",
    "looks off. That is the same thing, and it carries the same arithmetic."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "46d59d1e",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-24T12:58:38.691441Z",
     "iopub.status.busy": "2026-10-24T12:58:38.691120Z",
     "iopub.status.idle": "2026-10-24T12:58:53.402827Z",
     "shell.execute_reply": "2026-10-24T12:58:53.401061Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " rows_scanned  false_flags_single_test  false_flags_corrected  chance_of_at_least_one_false_flag_pct\n",
      "            5                     0.24                   0.07                                  20.17\n",
      "           10                     0.47                   0.05                                  36.83\n",
      "           20                     0.91                   0.06                                  59.67\n",
      "           40                     1.87                   0.07                                  86.00\n",
      "           80                     3.90                   0.13                                  97.67\n",
      "          160                     7.92                   0.13                                 100.00\n"
     ]
    }
   ],
   "source": [
    "# From five rows: each row is tested against the rest of the table, so a one-row table has no\n",
    "# rest to test against and would read as never wrong rather than wrong one time in twenty.\n",
    "FAMILY_SIZES = [5, 10, 20, 40, 80, 160]\n",
    "FAMILY_REPS = 600\n",
    "\n",
    "\n",
    "def false_flags_by_family_size(sizes=None, reps=FAMILY_REPS, seed=SEED + 2):\n",
    "    \"\"\"Rows that are all identical, scanned in families of growing size.\n",
    "\n",
    "    Every flag here is false by construction: nothing in these accounts differs from anything\n",
    "    else. What changes is only how many rows were looked at.\n",
    "    \"\"\"\n",
    "    sizes = FAMILY_SIZES if sizes is None else sizes\n",
    "    generator = np.random.default_rng(seed)\n",
    "    rows = []\n",
    "    for m in sizes:\n",
    "        single = corrected = any_single = 0\n",
    "        for _ in range(reps):\n",
    "            acct = make_account(generator, segments=m, lifts={})\n",
    "            frame = read_account(acct)\n",
    "            single += int(frame[\"single_test\"].sum())\n",
    "            corrected += int(frame[\"corrected\"].sum())\n",
    "            any_single += int(frame[\"single_test\"].any())\n",
    "        rows.append({\"rows_scanned\": m,\n",
    "                     \"false_flags_single_test\": single / reps,\n",
    "                     \"false_flags_corrected\": corrected / reps,\n",
    "                     \"chance_of_at_least_one_false_flag_pct\": 100 * any_single / reps})\n",
    "    return pd.DataFrame(rows)\n",
    "\n",
    "\n",
    "family = false_flags_by_family_size()\n",
    "print(family.round(2).to_string(index=False))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1571534c",
   "metadata": {},
   "source": [
    "## Thin rows: the interval that lies, and the one that does not\n",
    "\n",
    "The other half of the problem is the row with almost nothing in it. A segment\n",
    "with 40 clicks and 1 conversion reads as 2.5%, which looks like a number. The\n",
    "textbook interval around it is badly behaved exactly here, and the zero case\n",
    "is the clearest: nothing has converted yet, and the textbook form reports a\n",
    "rate of zero with no width at all: certainty, from no evidence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "761ee9a5",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-24T12:58:53.408885Z",
     "iopub.status.busy": "2026-10-24T12:58:53.408371Z",
     "iopub.status.idle": "2026-10-24T12:58:53.529980Z",
     "shell.execute_reply": "2026-10-24T12:58:53.528323Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " clicks  wilson_coverage_pct  textbook_coverage_pct\n",
      "     20                 93.7                   33.5\n",
      "     50                 91.7                   62.8\n",
      "    100                 94.1                   87.2\n",
      "    250                 96.4                   87.0\n",
      "    500                 96.0                   93.2\n",
      "   1000                 94.6                   94.8\n",
      "   5000                 95.5                   95.1\n",
      "\n",
      "nothing converted yet, out of 40 clicks:\n",
      "  the textbook interval : 0.00% to 0.00%\n",
      "  an honest interval    : 0.00% to 8.76%\n"
     ]
    }
   ],
   "source": [
    "COVERAGE_REPS = 4000\n",
    "COVERAGE_NS = [20, 50, 100, 250, 500, 1000, 5000]\n",
    "\n",
    "\n",
    "def interval_coverage(ns=None, rate=BASE_CVR, reps=COVERAGE_REPS, seed=SEED + 3):\n",
    "    \"\"\"How often each 95% interval actually contains the true rate.\"\"\"\n",
    "    ns = COVERAGE_NS if ns is None else ns\n",
    "    generator = np.random.default_rng(seed)\n",
    "    rows = []\n",
    "    for n in ns:\n",
    "        draws = generator.binomial(n, rate, reps)\n",
    "        wilson_hits = sum(1 for x in draws\n",
    "                          if (w := wilson_interval(x, n))[\"low\"] <= rate <= w[\"high\"])\n",
    "        wald_hits = sum(1 for x in draws\n",
    "                        if (w := wald_interval(x, n))[\"low\"] <= rate <= w[\"high\"])\n",
    "        rows.append({\"clicks\": n,\n",
    "                     \"wilson_coverage_pct\": 100 * wilson_hits / reps,\n",
    "                     \"textbook_coverage_pct\": 100 * wald_hits / reps})\n",
    "    return pd.DataFrame(rows)\n",
    "\n",
    "\n",
    "coverage = interval_coverage()\n",
    "print(coverage.round(1).to_string(index=False))\n",
    "\n",
    "zero_n = 40\n",
    "zero_wilson = wilson_interval(0, zero_n)\n",
    "zero_wald = wald_interval(0, zero_n)\n",
    "print(f\"\\nnothing converted yet, out of {zero_n} clicks:\")\n",
    "print(f\"  the textbook interval : {100 * zero_wald['low']:.2f}% to {100 * zero_wald['high']:.2f}%\")\n",
    "print(f\"  an honest interval    : {100 * zero_wilson['low']:.2f}% to {100 * zero_wilson['high']:.2f}%\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cdd304f1",
   "metadata": {},
   "source": [
    "## Ratios are a different sum\n",
    "\n",
    "Cost per acquisition is not a rate. It is one total divided by another, and\n",
    "what sets its uncertainty is the number of conversions behind it, not the\n",
    "money. Twenty conversions at ten euros each and twenty at a thousand carry\n",
    "the same uncertainty about the cost per conversion.\n",
    "\n",
    "There is a limit here worth stating before the method is used rather than\n",
    "after, and the notebook measures it rather than asserting it: the same\n",
    "arithmetic applied to a ratio whose top half is a sum of *variable* amounts\n",
    "(revenue, where every order is a different size) is wrong, and wrong in the\n",
    "dangerous direction."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "4b10344e",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-24T12:58:53.535553Z",
     "iopub.status.busy": "2026-10-24T12:58:53.534978Z",
     "iopub.status.idle": "2026-10-24T12:58:53.654056Z",
     "shell.execute_reply": "2026-10-24T12:58:53.652639Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "two segments with the same true cost per conversion, 4000 runs:\n",
      "  cost per conversion, spend over a count : cries wolf 4.6% of the time\n",
      "  return on spend, order values varying    : 16.8%\n",
      "  (the threshold it is aiming at is 5%)\n"
     ]
    }
   ],
   "source": [
    "RATIO_REPS = 4000\n",
    "\n",
    "\n",
    "def ratio_false_positive_rate(value_spread, reps=RATIO_REPS, expected=60, seed=SEED + 4):\n",
    "    \"\"\"Two segments with the SAME true ratio: how often does the test say they differ?\n",
    "\n",
    "    THE SHAPE OF THE RATIO IS THE WHOLE POINT, and a first version of this study got it wrong by\n",
    "    making every event worth exactly the same amount - which makes the ratio identical on both\n",
    "    sides no matter what the counts do, so nothing could ever fire and the study measured its own\n",
    "    construction. Cost per acquisition is a near-fixed spend divided by a COUNT that varies, and\n",
    "    that count is what the test builds its uncertainty from. Return on spend is a sum of variable\n",
    "    order values divided by a near-fixed spend, and that variation sits on top of the count's.\n",
    "    \"\"\"\n",
    "    generator = np.random.default_rng(seed)\n",
    "    fires = 0\n",
    "    for _ in range(reps):\n",
    "        totals = []\n",
    "        for _ in range(2):\n",
    "            conversions = max(int(generator.poisson(expected)), 1)\n",
    "            spend = 10.0 * expected              # the same budget behind both segments\n",
    "            if value_spread <= 0:\n",
    "                # cost per acquisition: the spend over a count, which is the shape the test is for\n",
    "                totals.append((spend, float(conversions), float(conversions)))\n",
    "            else:\n",
    "                # return on spend: revenue is a sum of order values that differ from each other\n",
    "                shape = 1.0 / value_spread ** 2\n",
    "                revenue = float(generator.gamma(shape, 25.0 / shape, conversions).sum())\n",
    "                totals.append((revenue, spend, float(conversions)))\n",
    "        test = ratio_difference_test(*totals[0], *totals[1])\n",
    "        if test[\"evaluable\"] and test[\"p\"] < ALPHA:\n",
    "            fires += 1\n",
    "    return 100 * fires / reps\n",
    "\n",
    "\n",
    "ratio_flat = ratio_false_positive_rate(0.0)\n",
    "ratio_dispersed = ratio_false_positive_rate(1.0)\n",
    "print(f\"two segments with the same true cost per conversion, {RATIO_REPS} runs:\")\n",
    "print(f\"  cost per conversion, spend over a count : cries wolf {ratio_flat:.1f}% of the time\")\n",
    "print(f\"  return on spend, order values varying    : {ratio_dispersed:.1f}%\")\n",
    "print(f\"  (the threshold it is aiming at is {100 * ALPHA:.0f}%)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "85ae89cb",
   "metadata": {},
   "source": [
    "## Figure 1: one account, forty rows, three real differences\n",
    "\n",
    "Every row with its honest range. The three rows that genuinely differ are\n",
    "marked. What the eye flags, what one test per row flags, and what survives\n",
    "the correction are three different sets, and the first is mostly wrong."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "930f0b24",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-24T12:58:53.660017Z",
     "iopub.status.busy": "2026-10-24T12:58:53.659569Z",
     "iopub.status.idle": "2026-10-24T12:58:54.279318Z",
     "shell.execute_reply": "2026-10-24T12:58:54.277699Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1100x540 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def figure_breakdown(frame, path):\n",
    "    order = frame.sort_values(\"rate\").reset_index(drop=True)\n",
    "    fig, ax = plt.subplots(figsize=(11, 5.4))\n",
    "    y = np.arange(len(order))\n",
    "    ax.hlines(y, 100 * order[\"wilson_low\"], 100 * order[\"wilson_high\"],\n",
    "              color=LINE, lw=3, zorder=1)\n",
    "    for label, mask, colour, marker, size in [\n",
    "            (\"flagged by eye only\", order[\"eyeball\"] & ~order[\"single_test\"], NAIVE, \"o\", 34),\n",
    "            (\"flagged by one test\", order[\"single_test\"] & ~order[\"corrected\"], FLAG, \"o\", 40),\n",
    "            (\"survives the correction\", order[\"corrected\"], SIGNAL, \"o\", 62),\n",
    "            (\"not flagged\", ~(order[\"eyeball\"] | order[\"single_test\"]), MUTED, \"o\", 20)]:\n",
    "        if mask.any():\n",
    "            ax.scatter(100 * order.loc[mask, \"rate\"], y[mask.to_numpy()], s=size,\n",
    "                       color=colour, label=label, zorder=3, alpha=0.9)\n",
    "    real = order[\"really_different\"].to_numpy()\n",
    "    ax.scatter(100 * order.loc[real, \"rate\"], y[real], s=180, facecolors=\"none\",\n",
    "               edgecolors=INK, lw=1.6, label=\"genuinely different\", zorder=4)\n",
    "    ax.axvline(100 * order[\"rest_rate\"].median(), color=INK, lw=1.2, ls=\"--\")\n",
    "    ax.set_yticks([])\n",
    "    ax.set_xlabel(\"conversion rate (%), with the range each row's own clicks allow\")\n",
    "    ax.set_title(\"Forty segments, three of them genuinely different\", loc=\"left\", fontsize=12)\n",
    "    ax.legend(frameon=False, fontsize=9, loc=\"lower right\")\n",
    "    fig.tight_layout()\n",
    "    fig.savefig(path, dpi=150, bbox_inches=\"tight\")\n",
    "    plt.show()\n",
    "    plt.close(fig)\n",
    "\n",
    "\n",
    "figure_breakdown(table, FIGURES / \"fig_breakdown.png\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6321a480",
   "metadata": {},
   "source": [
    "## Figure 2: the cost of looking at more rows\n",
    "\n",
    "These accounts contain no real differences at all: every row converts at the\n",
    "same true rate. The only thing that changes across the chart is how many rows\n",
    "were looked at."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "b628f7cc",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-24T12:58:54.283648Z",
     "iopub.status.busy": "2026-10-24T12:58:54.283225Z",
     "iopub.status.idle": "2026-10-24T12:58:55.195413Z",
     "shell.execute_reply": "2026-10-24T12:58:55.194385Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1150x430 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def figure_multiplicity(frame, path):\n",
    "    fig, (ax, ax2) = plt.subplots(1, 2, figsize=(11.5, 4.3))\n",
    "    ax.plot(frame[\"rows_scanned\"], frame[\"false_flags_single_test\"], \"o-\",\n",
    "            color=FLAG, lw=2.2, label=\"one test per row\")\n",
    "    ax.plot(frame[\"rows_scanned\"], frame[\"false_flags_corrected\"], \"o-\",\n",
    "            color=SIGNAL, lw=2.2, label=\"corrected for the whole table\")\n",
    "    ax.set_xscale(\"log\")\n",
    "    ax.set_xticks(frame[\"rows_scanned\"])\n",
    "    ax.set_xticklabels(frame[\"rows_scanned\"])\n",
    "    ax.set_xlabel(\"rows in the table\")\n",
    "    ax.set_ylabel(\"findings that are not there\")\n",
    "    ax.set_title(\"What a table of identical rows hands you\", loc=\"left\", fontsize=11.5)\n",
    "    ax.legend(frameon=False, fontsize=9)\n",
    "\n",
    "    ax2.plot(frame[\"rows_scanned\"], frame[\"chance_of_at_least_one_false_flag_pct\"], \"o-\",\n",
    "             color=FLAG, lw=2.2)\n",
    "    ax2.set_xscale(\"log\")\n",
    "    ax2.set_xticks(frame[\"rows_scanned\"])\n",
    "    ax2.set_xticklabels(frame[\"rows_scanned\"])\n",
    "    ax2.set_ylim(0, 105)\n",
    "    ax2.set_xlabel(\"rows in the table\")\n",
    "    ax2.set_ylabel(\"% of accounts\")\n",
    "    ax2.set_title(\"Chance of at least one false finding\", loc=\"left\", fontsize=11.5)\n",
    "    fig.tight_layout()\n",
    "    fig.savefig(path, dpi=150, bbox_inches=\"tight\")\n",
    "    plt.show()\n",
    "    plt.close(fig)\n",
    "\n",
    "\n",
    "figure_multiplicity(family, FIGURES / \"fig_multiplicity.png\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa691085",
   "metadata": {},
   "source": [
    "## Figure 3: the interval that lies about thin rows\n",
    "\n",
    "A 95% range should contain the true rate 95% of the time. The textbook one\n",
    "does not, and it fails worst exactly where a breakdown table is thinnest."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "07a7de45",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-24T12:58:55.199733Z",
     "iopub.status.busy": "2026-10-24T12:58:55.199319Z",
     "iopub.status.idle": "2026-10-24T12:58:56.011193Z",
     "shell.execute_reply": "2026-10-24T12:58:56.009687Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1150x430 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def figure_intervals(frame, path):\n",
    "    fig, (ax, ax2) = plt.subplots(1, 2, figsize=(11.5, 4.3),\n",
    "                                  gridspec_kw={\"width_ratios\": [1.4, 1]})\n",
    "    ax.axhline(95, color=INK, lw=1.2, ls=\"--\")\n",
    "    ax.plot(frame[\"clicks\"], frame[\"wilson_coverage_pct\"], \"o-\", color=SIGNAL, lw=2.2,\n",
    "            label=\"the honest range\")\n",
    "    ax.plot(frame[\"clicks\"], frame[\"textbook_coverage_pct\"], \"o-\", color=FLAG, lw=2.2,\n",
    "            label=\"the textbook range\")\n",
    "    ax.set_xscale(\"log\")\n",
    "    ax.set_xticks(frame[\"clicks\"])\n",
    "    ax.set_xticklabels(frame[\"clicks\"])\n",
    "    ax.set_ylim(20, 102)\n",
    "    ax.set_xlabel(\"clicks in the row\")\n",
    "    ax.set_ylabel(\"% of the time it contains the truth\")\n",
    "    ax.set_title(\"How often a 95% range is actually right\", loc=\"left\", fontsize=11.5)\n",
    "    ax.legend(frameon=False, fontsize=9, loc=\"lower right\")\n",
    "\n",
    "    labels = [\"the textbook range\", \"an honest range\"]\n",
    "    lows = [100 * zero_wald[\"low\"], 100 * zero_wilson[\"low\"]]\n",
    "    highs = [100 * zero_wald[\"high\"], 100 * zero_wilson[\"high\"]]\n",
    "    for i, (lo, hi, colour) in enumerate(zip(lows, highs, [FLAG, SIGNAL])):\n",
    "        ax2.barh(i, max(hi - lo, 0.06), left=lo, height=0.34, color=colour)\n",
    "        ax2.text(hi + 0.25, i, f\"{lo:.2f}% to {hi:.2f}%\", va=\"center\", fontsize=10, color=colour)\n",
    "    ax2.set_yticks([0, 1])\n",
    "    ax2.set_yticklabels(labels)\n",
    "    ax2.set_xlim(-0.4, 13)\n",
    "    ax2.set_xlabel(\"conversion rate (%)\")\n",
    "    ax2.set_title(f\"No conversions yet, out of {zero_n} clicks\", loc=\"left\", fontsize=11.5)\n",
    "    fig.tight_layout()\n",
    "    fig.savefig(path, dpi=150, bbox_inches=\"tight\")\n",
    "    plt.show()\n",
    "    plt.close(fig)\n",
    "\n",
    "\n",
    "figure_intervals(coverage, FIGURES / \"fig_intervals.png\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c882e2d6",
   "metadata": {},
   "source": [
    "## Figure 4: where the ratio test stops being valid\n",
    "\n",
    "Both bars are two segments whose true ratio is identical, so every flag is\n",
    "false. The left is cost per conversion, the shape the test is built for. The\n",
    "right is return on spend, where each order is a different size."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "26efb9a1",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-24T12:58:56.021412Z",
     "iopub.status.busy": "2026-10-24T12:58:56.021022Z",
     "iopub.status.idle": "2026-10-24T12:58:56.340810Z",
     "shell.execute_reply": "2026-10-24T12:58:56.339135Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 740x390 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def figure_ratio(path):\n",
    "    fig, ax = plt.subplots(figsize=(7.4, 3.9))\n",
    "    bars = [\"cost per conversion\\n(spend over a count)\", \"return on spend\\n(order values vary)\"]\n",
    "    values = [ratio_flat, ratio_dispersed]\n",
    "    ax.bar(bars, values, color=[SIGNAL, FLAG], width=0.5)\n",
    "    ax.axhline(100 * ALPHA, color=INK, lw=1.3, ls=\"--\")\n",
    "    ax.text(1.42, 100 * ALPHA + 0.4, f\"what it is aiming at ({100 * ALPHA:.0f}%)\",\n",
    "            fontsize=9.5, color=INK, ha=\"right\")\n",
    "    for i, v in enumerate(values):\n",
    "        ax.text(i, v + 0.5, f\"{v:.1f}%\", ha=\"center\", fontsize=13, color=INK, fontweight=\"bold\")\n",
    "    ax.set_ylabel(\"% of the time it calls a difference\")\n",
    "    ax.set_ylim(0, max(values) * 1.3)\n",
    "    ax.set_title(\"Two segments with the same true ratio\", loc=\"left\", fontsize=12)\n",
    "    fig.tight_layout()\n",
    "    fig.savefig(path, dpi=150, bbox_inches=\"tight\")\n",
    "    plt.show()\n",
    "    plt.close(fig)\n",
    "\n",
    "\n",
    "figure_ratio(FIGURES / \"fig_ratio.png\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dfe6bfb1",
   "metadata": {},
   "source": [
    "## A worked example: two creatives\n",
    "\n",
    "The comparison everyone actually makes. Two ads in the same campaign, one\n",
    "converting better than the other, and the question of whether to move the\n",
    "budget."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "d45bc1fa",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-24T12:58:56.345269Z",
     "iopub.status.busy": "2026-10-24T12:58:56.344861Z",
     "iopub.status.idle": "2026-10-24T12:58:56.359741Z",
     "shell.execute_reply": "2026-10-24T12:58:56.358718Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "two creatives, the same true conversion rate written in:\n",
      "  creative A: 15 of 620 = 2.42%  (honest range 1.47% to 3.95%)\n",
      "  creative B: 9 of 580 = 1.55%  (honest range 0.82% to 2.92%)\n",
      "  the gap looks like 0.87 points, and the test says p = 0.28\n",
      "  which is: nothing here to act on\n"
     ]
    }
   ],
   "source": [
    "WORKED = {\"a\": {\"name\": \"creative A\", \"clicks\": 620, \"true_rate\": 0.0215},\n",
    "          \"b\": {\"name\": \"creative B\", \"clicks\": 580, \"true_rate\": 0.0215}}\n",
    "worked_rng = np.random.default_rng(SEED + 9)\n",
    "for side in WORKED.values():\n",
    "    side[\"conversions\"] = int(worked_rng.binomial(side[\"clicks\"], side[\"true_rate\"]))\n",
    "\n",
    "worked_test = two_proportion_test(WORKED[\"a\"][\"conversions\"], WORKED[\"a\"][\"clicks\"],\n",
    "                                  WORKED[\"b\"][\"conversions\"], WORKED[\"b\"][\"clicks\"])\n",
    "worked_wilson = {k: wilson_interval(v[\"conversions\"], v[\"clicks\"]) for k, v in WORKED.items()}\n",
    "print(\"two creatives, the same true conversion rate written in:\")\n",
    "for key, side in WORKED.items():\n",
    "    w = worked_wilson[key]\n",
    "    print(f\"  {side['name']}: {side['conversions']} of {side['clicks']:,} = \"\n",
    "          f\"{100 * side['conversions'] / side['clicks']:.2f}%  \"\n",
    "          f\"(honest range {100 * w['low']:.2f}% to {100 * w['high']:.2f}%)\")\n",
    "gap = 100 * (worked_test[\"rate_a\"] - worked_test[\"rate_b\"])\n",
    "print(f\"  the gap looks like {abs(gap):.2f} points, and the test says p = {worked_test['p']:.2f}\")\n",
    "print(\"  which is: nothing here to act on\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc6b391d",
   "metadata": {},
   "source": [
    "## What the notebook found\n",
    "\n",
    "Every number the article quotes is written out here, so the article can never\n",
    "carry a figure this notebook did not produce."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "806937c8",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-24T12:58:56.363492Z",
     "iopub.status.busy": "2026-10-24T12:58:56.363150Z",
     "iopub.status.idle": "2026-10-24T12:58:56.403293Z",
     "shell.execute_reply": "2026-10-24T12:58:56.401266Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\n",
      " \"eyeball\": {\n",
      "  \"flagged_per_account\": 18.4,\n",
      "  \"false_per_account\": 16.0,\n",
      "  \"share_of_flags_that_are_false_pct\": 87.0,\n",
      "  \"false_discovery_rate_per_account_pct\": 86.8,\n",
      "  \"share_of_real_ones_found_pct\": 79.7,\n",
      "  \"accounts_with_a_false_flag_pct\": 100.0\n",
      " },\n",
      " \"single_test\": {\n",
      "  \"flagged_per_account\": 3.0,\n",
      "  \"false_per_account\": 1.8,\n",
      "  \"share_of_flags_that_are_false_pct\": 59.0,\n",
      "  \"false_discovery_rate_per_account_pct\": 55.7,\n",
      "  \"share_of_real_ones_found_pct\": 41.4,\n",
      "  \"accounts_with_a_false_flag_pct\": 85.5\n",
      " },\n",
      " \"corrected\": {\n",
      "  \"flagged_per_account\": 0.5,\n",
      "  \"false_per_account\": 0.1,\n",
      "  \"share_of_flags_that_are_false_pct\": 12.7,\n",
      "  \"false_discovery_rate_per_account_pct\": 4.4,\n",
      "  \"share_of_real_ones_found_pct\": 13.8,\n",
      "  \"accounts_with_a_false_flag_pct\": 6.0\n",
      " }\n",
      "}\n"
     ]
    }
   ],
   "source": [
    "by_reading = {row[\"reading\"]: row for _, row in readings.iterrows()}\n",
    "family_at = {int(row[\"rows_scanned\"]): row for _, row in family.iterrows()}\n",
    "coverage_at = {int(row[\"clicks\"]): row for _, row in coverage.iterrows()}\n",
    "\n",
    "worked_example = {\n",
    "    \"settings\": {\"segments\": SEGMENTS, \"base_cvr_pct\": round(100 * BASE_CVR, 2),\n",
    "                 \"alpha\": ALPHA, \"q\": Q, \"eyeball_drop_pct\": round(100 * EYEBALL_DROP),\n",
    "                 \"accounts\": ACCOUNTS, \"family_reps\": FAMILY_REPS,\n",
    "                 \"coverage_reps\": COVERAGE_REPS, \"ratio_reps\": RATIO_REPS,\n",
    "                 \"truly_different\": len(TRUE_LIFTS)},\n",
    "    \"readings\": {\n",
    "        name: {\n",
    "            \"flagged_per_account\": round(float(row[\"flagged_per_account\"]), 1),\n",
    "            \"false_per_account\": round(float(row[\"false_per_account\"]), 1),\n",
    "            \"share_of_flags_that_are_false_pct\": round(float(row[\"share_of_flags_that_are_false\"]), 1),\n",
    "            \"false_discovery_rate_per_account_pct\": round(float(row[\"false_discovery_rate_per_account\"]), 1),\n",
    "            \"share_of_real_ones_found_pct\": round(float(row[\"share_of_real_ones_found\"]), 1),\n",
    "            \"accounts_with_a_false_flag_pct\": round(float(row[\"accounts_with_at_least_one_false_flag\"]), 1),\n",
    "        } for name, row in by_reading.items()},\n",
    "    \"family\": {\n",
    "        str(m): {\"false_flags_single_test\": round(float(r[\"false_flags_single_test\"]), 2),\n",
    "                 \"false_flags_corrected\": round(float(r[\"false_flags_corrected\"]), 2),\n",
    "                 \"chance_of_at_least_one_pct\": round(float(r[\"chance_of_at_least_one_false_flag_pct\"]), 1)}\n",
    "        for m, r in family_at.items()},\n",
    "    \"intervals\": {\n",
    "        \"coverage\": {str(n): {\"honest_pct\": round(float(r[\"wilson_coverage_pct\"]), 1),\n",
    "                              \"textbook_pct\": round(float(r[\"textbook_coverage_pct\"]), 1)}\n",
    "                     for n, r in coverage_at.items()},\n",
    "        \"zero_case\": {\"clicks\": zero_n,\n",
    "                      \"textbook_low_pct\": round(100 * zero_wald[\"low\"], 2),\n",
    "                      \"textbook_high_pct\": round(100 * zero_wald[\"high\"], 2),\n",
    "                      \"honest_low_pct\": round(100 * zero_wilson[\"low\"], 2),\n",
    "                      \"honest_high_pct\": round(100 * zero_wilson[\"high\"], 2)}},\n",
    "    \"sample_account\": {\n",
    "        \"segments\": int(len(table)),\n",
    "        \"eyeball_flags\": int(table[\"eyeball\"].sum()),\n",
    "        \"single_test_flags\": int(table[\"single_test\"].sum()),\n",
    "        \"corrected_flags\": int(table[\"corrected\"].sum()),\n",
    "        \"really_different\": int(table[\"really_different\"].sum()),\n",
    "        \"really_different_missed_by_everything\": int(\n",
    "            (table[\"really_different\"] & ~table[\"eyeball\"] & ~table[\"single_test\"]).sum()),\n",
    "        \"corrected_survivors_that_are_real\": int(\n",
    "            (table[\"corrected\"] & table[\"really_different\"]).sum()),\n",
    "        \"clicks_total\": int(table[\"clicks\"].sum()),\n",
    "        \"conversions_total\": int(table[\"conversions\"].sum()),\n",
    "        \"account_rate_pct\": round(100 * table[\"conversions\"].sum() / table[\"clicks\"].sum(), 3),\n",
    "        \"thinnest_row_clicks\": int(table[\"clicks\"].min()),\n",
    "        \"heaviest_row_clicks\": int(table[\"clicks\"].max()),\n",
    "    },\n",
    "    # The single illustrated account, row by row, so the explainer video draws THESE points\n",
    "    # rather than regenerating a copy of them. Sorted by clicks so the long tail reads as one.\n",
    "    \"sample_rows\": {\n",
    "        \"clicks\": [int(v) for v in table.sort_values(\"clicks\")[\"clicks\"]],\n",
    "        \"conversions\": [int(v) for v in table.sort_values(\"clicks\")[\"conversions\"]],\n",
    "        \"rate_pct\": [round(100 * float(v), 4) for v in table.sort_values(\"clicks\")[\"rate\"]],\n",
    "        \"low_pct\": [round(100 * float(v), 4) for v in table.sort_values(\"clicks\")[\"wilson_low\"]],\n",
    "        \"high_pct\": [round(100 * float(v), 4) for v in table.sort_values(\"clicks\")[\"wilson_high\"]],\n",
    "        # p and its adjusted twin, so the downloadable workbook is checked against the numbers\n",
    "        # themselves rather than only against the verdicts they produce. A sheet whose flags agree\n",
    "        # while its arithmetic differs is a sheet nobody has actually verified.\n",
    "        \"p\": [round(float(v), 8) for v in table.sort_values(\"clicks\")[\"p\"]],\n",
    "        \"p_adjusted\": [round(float(v), 8) for v in table.sort_values(\"clicks\")[\"p_adjusted\"]],\n",
    "        \"eyeball\": [bool(v) for v in table.sort_values(\"clicks\")[\"eyeball\"]],\n",
    "        \"single_test\": [bool(v) for v in table.sort_values(\"clicks\")[\"single_test\"]],\n",
    "        \"corrected\": [bool(v) for v in table.sort_values(\"clicks\")[\"corrected\"]],\n",
    "        \"really_different\": [bool(v) for v in table.sort_values(\"clicks\")[\"really_different\"]],\n",
    "    },\n",
    "    \"ratio\": {\"cost_per_conversion_pct\": round(ratio_flat, 1),\n",
    "              \"return_on_spend_pct\": round(ratio_dispersed, 1),\n",
    "              \"aiming_at_pct\": round(100 * ALPHA)},\n",
    "    \"worked\": {\n",
    "        \"a_clicks\": WORKED[\"a\"][\"clicks\"], \"a_conversions\": WORKED[\"a\"][\"conversions\"],\n",
    "        \"b_clicks\": WORKED[\"b\"][\"clicks\"], \"b_conversions\": WORKED[\"b\"][\"conversions\"],\n",
    "        \"a_rate_pct\": round(100 * worked_test[\"rate_a\"], 2),\n",
    "        \"b_rate_pct\": round(100 * worked_test[\"rate_b\"], 2),\n",
    "        \"gap_points\": round(abs(gap), 2),\n",
    "        \"p\": round(worked_test[\"p\"], 2),\n",
    "        \"a_low_pct\": round(100 * worked_wilson[\"a\"][\"low\"], 2),\n",
    "        \"a_high_pct\": round(100 * worked_wilson[\"a\"][\"high\"], 2),\n",
    "        \"b_low_pct\": round(100 * worked_wilson[\"b\"][\"low\"], 2),\n",
    "        \"b_high_pct\": round(100 * worked_wilson[\"b\"][\"high\"], 2),\n",
    "        \"true_rate_pct\": round(100 * WORKED[\"a\"][\"true_rate\"], 2)},\n",
    "}\n",
    "(DATA / \"worked_example.json\").write_text(json.dumps(worked_example, indent=2) + \"\\n\",\n",
    "                                          encoding=\"utf-8\")\n",
    "print(json.dumps(worked_example[\"readings\"], indent=1))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "66b654ef",
   "metadata": {},
   "source": [
    "## Run it on your own numbers\n",
    "\n",
    "Everything above runs on a synthetic account so every answer can be checked against a truth.\n",
    "This section runs the same test and the same correction on a table you export yourself. It runs\n",
    "on your machine; nothing is uploaded.\n",
    "\n",
    "**The table this expects.** One row per segment - a device, a region, a match type, an ad\n",
    "group - with that segment's clicks and its conversions as COUNTS, never a rate. A Google Ads\n",
    "download works as it comes: Campaigns (or Devices, or Locations), pick the columns, Download;\n",
    "its title lines and Total rows are set aside for you. Column names are matched loosely\n",
    "(Clicks, Sessions; Conversions, Conv., Purchases, Leads).\n",
    "\n",
    "**Two things to check in the platform before you export.** Count each click's conversion\n",
    "once: a conversion action set to count every conversion can report more conversions than\n",
    "clicks, and the test then compares something that is not a rate. And compare like with like:\n",
    "rows added up across campaigns mix the campaigns' own differences into the comparison, so a\n",
    "device can look different only because its traffic sits in a different campaign. Compare\n",
    "within one campaign, or check each campaign separately."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "8dc3bc52",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-24T12:58:56.409543Z",
     "iopub.status.busy": "2026-10-24T12:58:56.409157Z",
     "iopub.status.idle": "2026-10-24T12:58:56.618227Z",
     "shell.execute_reply": "2026-10-24T12:58:56.617288Z"
    }
   },
   "outputs": [],
   "source": [
    "# ---- export reader (shared across every Stochastic Strata notebook; do not edit here) ----------\n",
    "# One reader for the file you bring. Ad platforms and analytics tools do not hand over clean tables:\n",
    "# a Google Ads download opens with a title line and a date-range line and closes with \"Total:\" rows,\n",
    "# a GA4 download opens with \"#\" lines and writes dates as 20261019, a European download separates\n",
    "# with semicolons and writes 1.234,56, and Excel turns numbers into \"1,234.56\" or \"€12.30\". This\n",
    "# reader finds the real header row, sets the title, comment and total rows aside, turns formatted\n",
    "# numbers back into numbers, and reads dates in the platforms' own forms. Where a file is genuinely\n",
    "# ambiguous - 06/07/2026 could be the 6th of July or the 7th of June - it stops and asks rather than\n",
    "# guessing, because a guessed date silently moves a day to the wrong weekday.\n",
    "#\n",
    "#     table, notes = read_export(\"my_export.csv\", columns={\"date\": [\"day\", \"date\"], ...})\n",
    "#     for note in notes: print(note)\n",
    "#\n",
    "# `columns` maps the names this notebook uses to the names your file might use (case and spacing do\n",
    "# not matter, and a currency suffix such as \"(EUR)\" is ignored). `date_columns` are read as dates,\n",
    "# `id_columns` are kept as text. Everything else that reads as numbers becomes numbers; a share\n",
    "# written \"49.41%\" becomes 0.4941. A share the platform shows only as \"< 10%\" or \"> 90%\" is read as\n",
    "# 0.10 or 0.90 and the direction is kept in a column ending \"_bound\", because it is a limit, not a\n",
    "# measurement. Every row set aside, and why, comes back in `notes`.\n",
    "import csv as _csv\n",
    "import io as _io\n",
    "import re as _re\n",
    "from pathlib import Path as _Path\n",
    "\n",
    "import numpy as _np\n",
    "import pandas as _pd\n",
    "\n",
    "\n",
    "class ExportReadError(ValueError):\n",
    "    \"\"\"The file cannot be read without guessing; the message says what to change.\"\"\"\n",
    "\n",
    "\n",
    "_TOTAL_ROW = _re.compile(r\"^\\s*(grand\\s+)?totals?\\b\", _re.I)\n",
    "_CURRENCY = _re.compile(r\"[€$£¥₹]|\\b(EUR|USD|GBP|CHF|SEK|NOK|DKK|PLN|AUD|CAD)\\b\", _re.I)\n",
    "_EMPTY = {\"\", \"--\", \"-\", \"—\", \"–\", \"n/a\", \"na\", \"nan\", \"none\", \"null\", \"(not set)\"}\n",
    "_MONTHS = {m: i for i, m in enumerate(\n",
    "    [\"jan\", \"feb\", \"mar\", \"apr\", \"may\", \"jun\", \"jul\", \"aug\", \"sep\", \"oct\", \"nov\", \"dec\"], 1)}\n",
    "\n",
    "\n",
    "def _norm(name):\n",
    "    name = _re.sub(r\"\\((?:[A-Z]{3}|[€$£])\\)\", \"\", str(name))\n",
    "    return _re.sub(r\"[\\s_\\-./]+\", \" \", name).strip().lower()\n",
    "\n",
    "\n",
    "def _decode(raw):\n",
    "    if raw[:2] in (b\"\\xff\\xfe\", b\"\\xfe\\xff\"):\n",
    "        return raw.decode(\"utf-16\")\n",
    "    for encoding in (\"utf-8-sig\", \"cp1252\", \"latin-1\"):\n",
    "        try:\n",
    "            return raw.decode(encoding)\n",
    "        except UnicodeDecodeError:\n",
    "            continue\n",
    "    return raw.decode(\"utf-8\", errors=\"replace\")\n",
    "\n",
    "\n",
    "def _rows_from(source):\n",
    "    \"\"\"Every row of the file as a list of strings, whatever the container.\"\"\"\n",
    "    if isinstance(source, _pd.DataFrame):\n",
    "        return [list(map(str, source.columns))] + source.astype(str).values.tolist(), \",\"\n",
    "    path = _Path(source)\n",
    "    if not path.exists():\n",
    "        raise ExportReadError(f\"There is no file at {path}. Check the name and the folder.\")\n",
    "    if path.suffix.lower() in (\".xlsx\", \".xlsm\", \".xls\"):\n",
    "        sheet = _pd.read_excel(path, header=None, dtype=str).fillna(\"\")\n",
    "        return sheet.values.tolist(), \",\"\n",
    "    text = _decode(path.read_bytes())\n",
    "    lines = [ln for ln in text.splitlines() if not ln.lstrip().startswith(\"#\")]\n",
    "    counts = {d: sum(ln.count(d) for ln in lines[:60]) for d in (\",\", \";\", \"\\t\")}\n",
    "    delimiter = max(counts, key=counts.get) if any(counts.values()) else \",\"\n",
    "    return [row for row in _csv.reader(_io.StringIO(\"\\n\".join(lines)), delimiter=delimiter)], delimiter\n",
    "\n",
    "\n",
    "def _find_header(rows, wanted):\n",
    "    \"\"\"The first row that names the columns: the one matching most expected names, else the first\n",
    "    row as wide as the data below it that is mostly words rather than numbers.\"\"\"\n",
    "    widths = [len([c for c in r if str(c).strip()]) for r in rows]\n",
    "    if wanted:\n",
    "        best, best_hits = None, 0\n",
    "        for i, row in enumerate(rows[:40]):\n",
    "            names = {_norm(c) for c in row if str(c).strip()}\n",
    "            hits = sum(1 for options in wanted.values() if names & set(options))\n",
    "            if hits > best_hits:\n",
    "                best, best_hits = i, hits\n",
    "        if best is not None:\n",
    "            return best\n",
    "    body = [w for w in widths if w > 1]\n",
    "    width = max(set(body), key=body.count) if body else 1\n",
    "    for i, row in enumerate(rows[:40]):\n",
    "        cells = [str(c).strip() for c in row if str(c).strip()]\n",
    "        if len(cells) >= max(2, width - 1) and sum(_looks_number(c) for c in cells) <= len(cells) / 2:\n",
    "            return i\n",
    "    return 0\n",
    "\n",
    "\n",
    "def _looks_number(text):\n",
    "    if _re.fullmatch(r\"\\d{1,4}[./\\-]\\d{1,2}[./\\-]\\d{1,4}\", str(text).strip()):\n",
    "        return False  # a date such as 22.09.2026, not a number with separators\n",
    "    return bool(_re.fullmatch(r\"[<>]?\\s*[-+(]?[€$£]?\\s*[\\d.,\\s']+\\s*%?\\)?\", str(text).strip()))\n",
    "\n",
    "\n",
    "def _decimal_comma(values):\n",
    "    \"\"\"True when these values write 1.234,56 (a comma followed by one or two final digits, or dots\n",
    "    grouping thousands with a comma after them), False when they write 1,234.56, None when they do\n",
    "    not say (whole numbers only, or a lone '1.340').\"\"\"\n",
    "    comma_votes = dot_votes = 0\n",
    "    for v in values:\n",
    "        s = _re.sub(r\"[^\\d.,]\", \"\", v)\n",
    "        if \",\" in s and \".\" in s:\n",
    "            comma_votes += s.rfind(\",\") > s.rfind(\".\")\n",
    "            dot_votes += s.rfind(\".\") > s.rfind(\",\")\n",
    "        elif _re.search(r\",\\d{1,2}$\", s):\n",
    "            comma_votes += 1\n",
    "        elif _re.search(r\"\\.\\d{1,2}$\", s) or _re.search(r\"\\.\\d{4,}$\", s):\n",
    "            dot_votes += 1\n",
    "    if comma_votes == dot_votes:\n",
    "        return None\n",
    "    return comma_votes > dot_votes\n",
    "\n",
    "\n",
    "def _to_number(text, comma_decimal):\n",
    "    s = str(text).strip().replace(\" \", \" \")\n",
    "    if s.lower() in _EMPTY:\n",
    "        return _np.nan, None, True\n",
    "    bound = None\n",
    "    if s[:1] in \"<>\":\n",
    "        bound, s = s[0], s[1:].strip()\n",
    "    negative = s.startswith(\"(\") and s.endswith(\")\")\n",
    "    s = _CURRENCY.sub(\"\", s).strip(\"() \").replace(\" \", \"\").replace(\"'\", \"\")\n",
    "    percent = s.endswith(\"%\")\n",
    "    s = s.rstrip(\"%\")\n",
    "    if comma_decimal:\n",
    "        s = s.replace(\".\", \"\").replace(\",\", \".\")\n",
    "    else:\n",
    "        s = s.replace(\",\", \"\")\n",
    "    try:\n",
    "        value = float(s)\n",
    "    except ValueError:\n",
    "        return _np.nan, None, False\n",
    "    if negative:\n",
    "        value = -value\n",
    "    return (value / 100.0 if percent else value), bound, True\n",
    "\n",
    "\n",
    "def _parse_dates(values, column, dayfirst):\n",
    "    text = [str(v).strip() for v in values]\n",
    "    present = [t for t in text if t.lower() not in _EMPTY]\n",
    "    if not present:\n",
    "        return _pd.Series([_pd.NaT] * len(text)), []\n",
    "    notes = []\n",
    "    if all(_re.fullmatch(r\"\\d{8}\", t) for t in present):\n",
    "        return _pd.to_datetime(_pd.Series(text), format=\"%Y%m%d\", errors=\"coerce\"), notes\n",
    "    if all(_re.fullmatch(r\"\\d{10}(\\.\\d+)?|\\d{13}|\\d{16}\", t) for t in present):\n",
    "        digits = len(present[0].split(\".\")[0])\n",
    "        unit = {10: \"s\", 13: \"ms\", 16: \"us\"}[digits]\n",
    "        notes.append(f\"'{column}' holds epoch times in {dict(s='seconds', ms='milliseconds', us='microseconds')[unit]}; read as such.\")\n",
    "        return _pd.to_datetime(_pd.to_numeric(_pd.Series(text), errors=\"coerce\"), unit=unit), notes\n",
    "    cleaned = [_re.sub(r\"\\s+(UTC|GMT|Z)$\", \"\", t) for t in text]\n",
    "    slash = [t for t in cleaned if _re.fullmatch(r\"\\d{1,2}[/.\\-]\\d{1,2}[/.\\-]\\d{2,4}(\\s.*)?\", t)]\n",
    "    if slash and len(slash) >= len(present) * 0.9:\n",
    "        firsts = [int(_re.split(r\"[/.\\-]\", t)[0]) for t in slash]\n",
    "        seconds = [int(_re.split(r\"[/.\\-]\", t)[1]) for t in slash]\n",
    "        dotted = all(\".\" in t.split(\" \")[0] for t in slash)\n",
    "        if dayfirst is None:\n",
    "            if max(firsts) > 12 and max(seconds) <= 12:\n",
    "                dayfirst = True\n",
    "            elif max(seconds) > 12 and max(firsts) <= 12:\n",
    "                dayfirst = False\n",
    "            elif dotted:\n",
    "                dayfirst = True\n",
    "            else:\n",
    "                raise ExportReadError(\n",
    "                    f\"The dates in '{column}' (for example {slash[0]}) could be day-first or month-first, \"\n",
    "                    \"and nothing in the file says which. Re-run with dayfirst=True for 6 July written \"\n",
    "                    \"06/07, or dayfirst=False for June 7 written 06/07 - or export the dates as \"\n",
    "                    \"2026-07-06.\")\n",
    "        return _pd.to_datetime(_pd.Series(cleaned), dayfirst=dayfirst, errors=\"coerce\"), notes\n",
    "    parsed = _pd.to_datetime(_pd.Series(cleaned), errors=\"coerce\", format=\"mixed\")\n",
    "    return parsed, notes\n",
    "\n",
    "\n",
    "def read_export(source, columns=None, date_columns=(), id_columns=(), dayfirst=None,\n",
    "                max_unreadable_share=0.02):\n",
    "    \"\"\"Read a downloaded report into a table with this notebook's column names. Returns\n",
    "    (table, notes); raises ExportReadError with a plain-words fix when it cannot read without\n",
    "    guessing.\"\"\"\n",
    "    columns = columns or {}\n",
    "    # Each name's candidates in the caller's order of preference, the name itself first.\n",
    "    wanted = {name: list(dict.fromkeys([_norm(name)] + [_norm(a) for a in aliases]))\n",
    "              for name, aliases in columns.items()}\n",
    "    rows, delimiter = _rows_from(source)\n",
    "    rows = [r for r in rows if any(str(c).strip() for c in r)]\n",
    "    if not rows:\n",
    "        raise ExportReadError(\"The file is empty.\")\n",
    "    notes = []\n",
    "    h = _find_header(rows, wanted)\n",
    "    if h:\n",
    "        notes.append(f\"set aside {h} line(s) above the header (a report title or date range).\")\n",
    "    header = [str(c).strip() for c in rows[h]]\n",
    "    body, totals = [], 0\n",
    "    for r in rows[h + 1:]:\n",
    "        first = next((str(c) for c in r if str(c).strip()), \"\")\n",
    "        if _TOTAL_ROW.match(first):\n",
    "            totals += 1\n",
    "            continue\n",
    "        if [str(c).strip() for c in r] == header:\n",
    "            continue\n",
    "        body.append([str(c) for c in r] + [\"\"] * (len(header) - len(r)))\n",
    "    if totals:\n",
    "        notes.append(f\"set aside {totals} total row(s).\")\n",
    "    frame = _pd.DataFrame([r[:len(header)] for r in body], columns=header)\n",
    "    rename = {}\n",
    "    for name, options in wanted.items():\n",
    "        by_norm = {}\n",
    "        for c in frame.columns:\n",
    "            by_norm.setdefault(_norm(c), c)\n",
    "        match = next((by_norm[o] for o in options if o in by_norm and by_norm[o] not in rename), None)\n",
    "        if match is not None:\n",
    "            rename[match] = name\n",
    "    frame = frame.rename(columns=rename)\n",
    "    missing = [name for name in columns if name not in frame.columns]\n",
    "    if missing:\n",
    "        seen = \", \".join(f\"'{c}'\" for c in header[:12])\n",
    "        raise ExportReadError(\n",
    "            f\"Could not find the column(s) {', '.join(missing)}. The file's columns are {seen}. \"\n",
    "            \"Rename the column in the file, or add its name to the list this cell accepts.\")\n",
    "    dates = set(date_columns)\n",
    "    # The file's own convention, for a column that cannot tell by itself: a clicks column of whole\n",
    "    # numbers says nothing, but its \"1.340\" means one thousand three hundred and forty when the\n",
    "    # file's other columns write decimals with a comma.\n",
    "    every = [str(v) for c in frame.columns if c not in date_columns for v in frame[c].tolist()\n",
    "             if _looks_number(v)]\n",
    "    file_comma = _decimal_comma(every)\n",
    "    if file_comma is None:\n",
    "        file_comma = delimiter == \";\"\n",
    "    ids = set(id_columns) | {c for c in frame.columns if _re.search(r\"(^|[ _])(id|pseudo id)$\", _norm(c))}\n",
    "    for col in frame.columns:\n",
    "        values = frame[col].tolist()\n",
    "        if col in dates:\n",
    "            parsed, extra = _parse_dates(values, col, dayfirst)\n",
    "            notes += extra\n",
    "            bad = int(parsed.isna().sum() - sum(str(v).strip().lower() in _EMPTY for v in values))\n",
    "            if bad > max(1, max_unreadable_share * len(values)):\n",
    "                example = next(v for v, p in zip(values, parsed) if _pd.isna(p) and str(v).strip())\n",
    "                raise ExportReadError(f\"{bad} value(s) in '{col}' are not dates I can read, for example '{example}'.\")\n",
    "            frame[col] = parsed.values\n",
    "            continue\n",
    "        if col in ids:\n",
    "            continue\n",
    "        present = [v for v in values if str(v).strip().lower() not in _EMPTY]\n",
    "        if not present or sum(_looks_number(v) for v in present) < 0.5 * len(present):\n",
    "            continue\n",
    "        comma = _decimal_comma(present)\n",
    "        if comma is None:\n",
    "            comma = file_comma\n",
    "        parsed = [_to_number(v, comma) for v in values]\n",
    "        unreadable = [v for v, (_, _, ok) in zip(values, parsed) if not ok]\n",
    "        if unreadable and col not in columns:\n",
    "            notes.append(f\"'{col}' mixes numbers with labels such as '{unreadable[0]}'; kept as text.\")\n",
    "            continue\n",
    "        if unreadable:\n",
    "            notes.append(f\"{len(unreadable)} value(s) in '{col}' could not be read as numbers, for example \"\n",
    "                         f\"'{unreadable[0]}'; they are left empty.\")\n",
    "            if len(unreadable) > max(1, max_unreadable_share * len(values)):\n",
    "                raise ExportReadError(\n",
    "                    f\"{len(unreadable)} of {len(values)} values in '{col}' are not numbers I can read, for \"\n",
    "                    f\"example '{unreadable[0]}'. Fix them in the file, or export the column unformatted.\")\n",
    "        frame[col] = [p[0] for p in parsed]\n",
    "        bounds = [p[1] for p in parsed]\n",
    "        if any(bounds):\n",
    "            # An object column, so a day with no limit stays None: a newer pandas would infer a string\n",
    "            # column here and turn None into NaN, which is truthy and reads as a limit.\n",
    "            frame[f\"{col}_bound\"] = _pd.Series(bounds, index=frame.index, dtype=object)\n",
    "            notes.append(f\"'{col}' has values the platform shows only as a limit (for example \"\n",
    "                         f\"'{next(v for v, b in zip(values, bounds) if b)}'); kept as the limit, with the \"\n",
    "                         f\"direction in '{col}_bound'.\")\n",
    "    if dates:\n",
    "        undated = frame[list(dates)].isna().all(axis=1)\n",
    "        if undated.any():\n",
    "            frame = frame[~undated].reset_index(drop=True)\n",
    "            notes.append(f\"set aside {int(undated.sum())} row(s) with no date (GA4 writes its grand total \"\n",
    "                         \"this way, under the header).\")\n",
    "    return frame, notes\n",
    "# ---- end of export reader -------------------------------------------------------------------------\n",
    "\n",
    "\n",
    "class TableProblem(Exception):\n",
    "    \"\"\"Raised with a plain-words explanation the reader can act on.\"\"\"\n",
    "\n",
    "\n",
    "def read_my_table(path, segment_column=None, dayfirst=None):\n",
    "    \"\"\"Read a breakdown table into (segment, clicks, conversions), or refuse in plain words.\"\"\"\n",
    "    try:\n",
    "        frame, notes = read_export(\n",
    "            path, columns={\"clicks\": [\"clicks\", \"sessions\", \"visits\", \"interactions\", \"trials\"],\n",
    "                           \"conversions\": [\"conversions\", \"conv.\", \"purchases\", \"leads\",\n",
    "                                           \"transactions\", \"key events\", \"results\", \"successes\"]},\n",
    "            dayfirst=dayfirst)\n",
    "    except ExportReadError as problem:\n",
    "        raise TableProblem(str(problem)) from None\n",
    "    for note in notes:\n",
    "        print(\"  \" + note)\n",
    "    text_columns = [c for c in frame.columns\n",
    "                    if c not in (\"clicks\", \"conversions\") and not c.endswith(\"_bound\")\n",
    "                    and frame[c].dtype == object]\n",
    "    if not text_columns:\n",
    "        raise TableProblem(\"No column names the rows (a device, a region, a campaign). Keep one in the file.\")\n",
    "    if segment_column:\n",
    "        matches = [c for c in frame.columns if c.strip().lower() == segment_column.strip().lower()]\n",
    "        if not matches:\n",
    "            raise TableProblem(f\"There is no column '{segment_column}'; the naming columns are {text_columns}.\")\n",
    "        label = matches[0]\n",
    "    else:\n",
    "        label = text_columns[0]\n",
    "    others = [c for c in text_columns if c != label and frame[c].nunique() > 1]\n",
    "    if others:\n",
    "        print(f\"  the rows are named by '{label}' (set SEGMENT_COLUMN to choose another), and they also \"\n",
    "              f\"differ by {others}: adding those up mixes their own differences into the comparison. \"\n",
    "              \"Filter to one of them, or check each separately.\")\n",
    "    frame = frame.rename(columns={label: \"segment\"})[[\"segment\", \"clicks\", \"conversions\"]]\n",
    "    frame = frame.dropna(subset=[\"clicks\", \"conversions\"])\n",
    "    over = frame[\"conversions\"] > frame[\"clicks\"]\n",
    "    if over.any():\n",
    "        names = list(frame.loc[over, \"segment\"])[:5]\n",
    "        raise TableProblem(\n",
    "            f\"{int(over.sum())} row(s) have more conversions than clicks ({names}). That happens when a \"\n",
    "            \"conversion action counts every conversion rather than one per click; this test needs at \"\n",
    "            \"most one per click. Export a conversion action set to count one, or the converting \"\n",
    "            \"clicks, and run again.\")\n",
    "    if frame[\"segment\"].duplicated().any():\n",
    "        before = len(frame)\n",
    "        frame = frame.groupby(\"segment\", as_index=False)[[\"clicks\", \"conversions\"]].sum()\n",
    "        print(f\"  {before} rows added up to {len(frame)} segments (the same name appeared more than once)\")\n",
    "    empty = frame[\"clicks\"] <= 0\n",
    "    if empty.any():\n",
    "        print(f\"  left out {int(empty.sum())} row(s) with no clicks: {list(frame.loc[empty, 'segment'])[:5]}\")\n",
    "        frame = frame[~empty]\n",
    "    if (frame[\"conversions\"] % 1 != 0).any():\n",
    "        print(\"  the conversions are fractional (credit shared between ads); the test reads them as \"\n",
    "              \"they are, which treats a modelled share as if it were a count.\")\n",
    "    if len(frame) < 2:\n",
    "        raise TableProblem(\"The table needs at least two rows to compare.\")\n",
    "    return frame.reset_index(drop=True)\n",
    "\n",
    "\n",
    "def judge_my_table(frame):\n",
    "    \"\"\"Each row against the rest of the table, then the correction across every row tested.\"\"\"\n",
    "    total_c, total_x = frame[\"clicks\"].sum(), frame[\"conversions\"].sum()\n",
    "    rows = []\n",
    "    for _, r in frame.iterrows():\n",
    "        rest_c, rest_x = total_c - r[\"clicks\"], total_x - r[\"conversions\"]\n",
    "        test = two_proportion_test(r[\"conversions\"], r[\"clicks\"], rest_x, rest_c)\n",
    "        w = wilson_interval(r[\"conversions\"], r[\"clicks\"])\n",
    "        expected = r[\"clicks\"] * (rest_x / rest_c if rest_c > 0 else 0.0)\n",
    "        rows.append({\"segment\": r[\"segment\"], \"clicks\": r[\"clicks\"], \"conversions\": r[\"conversions\"],\n",
    "                     \"rate\": r[\"conversions\"] / r[\"clicks\"], \"rest_rate\": rest_x / rest_c if rest_c else 0.0,\n",
    "                     \"low\": w[\"low\"], \"high\": w[\"high\"],\n",
    "                     \"p\": test[\"p\"] if test[\"evaluable\"] else 1.0,\n",
    "                     \"testable\": bool(test[\"evaluable\"]) and expected >= 3.7})\n",
    "    out = pd.DataFrame(rows)\n",
    "    out[\"p_adjusted\"] = benjamini_hochberg(out[\"p\"].to_numpy())\n",
    "    out[\"verdict\"] = np.where(~out[\"testable\"], \"too thin to test\",\n",
    "                     np.where(out[\"p_adjusted\"] < Q, \"different, after correcting\",\n",
    "                     np.where(out[\"p\"] < ALPHA, \"would pass alone - not after correcting\", \"no evidence of a difference\")))\n",
    "    return out\n",
    "\n",
    "\n",
    "def report_my_table(path, segment_column=None):\n",
    "    frame = read_my_table(path, segment_column)\n",
    "    out = judge_my_table(frame)\n",
    "    print(f\"\\n{len(out)} rows tested against the rest of the table; \"\n",
    "          f\"{int((out['verdict'] == 'different, after correcting').sum())} survive the correction.\")\n",
    "    for _, r in out.sort_values(\"p\").iterrows():\n",
    "        print(f\"  {str(r['segment'])[:28]:28} {r['conversions']:>9,.1f} / {r['clicks']:>9,.0f}  \"\n",
    "              f\"{r['rate']:6.2%}  range {r['low']:6.2%} to {r['high']:6.2%}  vs rest {r['rest_rate']:6.2%}  \"\n",
    "              f\"-> {r['verdict']}\")\n",
    "    print(\"  The test assumes every click is an independent draw at one rate. Real weeks wobble more: \"\n",
    "          \"split the counts by week and check a gap holds in most weeks before acting on it.\")\n",
    "    return out"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4cded9e8",
   "metadata": {},
   "source": [
    "### Your file\n",
    "\n",
    "Put your export's file name below and run every cell. Leave it as `None` to see the\n",
    "demonstration that follows instead."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "2d930ff1",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-24T12:58:56.622555Z",
     "iopub.status.busy": "2026-10-24T12:58:56.622191Z",
     "iopub.status.idle": "2026-10-24T12:58:56.649852Z",
     "shell.execute_reply": "2026-10-24T12:58:56.647524Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MY_FILE is empty - running a demonstration on a small table instead.\n",
      "  set aside 2 line(s) above the header (a report title or date range).\n",
      "  set aside 1 total row(s).\n",
      "  left out 1 row(s) with no clicks: ['TV screens']\n",
      "  the conversions are fractional (credit shared between ads); the test reads them as they are, which treats a modelled share as if it were a count.\n",
      "\n",
      "3 rows tested against the rest of the table; 2 survive the correction.\n",
      "  Mobile phones                    268.4 /     9,912   2.71%  range  2.41% to  3.05%  vs rest  3.77%  -> different, after correcting\n",
      "  Computers                        171.0 /     4,487   3.81%  range  3.29% to  4.41%  vs rest  2.75%  -> different, after correcting\n",
      "  Tablets                           21.0 /       610   3.44%  range  2.26% to  5.21%  vs rest  3.05%  -> no evidence of a difference\n",
      "  The test assumes every click is an independent draw at one rate. Real weeks wobble more: split the counts by week and check a gap holds in most weeks before acting on it.\n"
     ]
    }
   ],
   "source": [
    "MY_FILE = None          # <- your breakdown table, for example \"google_ads_devices.csv\"\n",
    "SEGMENT_COLUMN = None   # the column that names the rows, e.g. \"Device\"; None takes the first one\n",
    "\n",
    "if MY_FILE:\n",
    "    print(f\"YOUR FILE: {MY_FILE}\")\n",
    "    my_result = report_my_table(MY_FILE, SEGMENT_COLUMN)\n",
    "else:\n",
    "    print(\"MY_FILE is empty - running a demonstration on a small table instead.\")\n",
    "    demo_path = DATA / \"demo_breakdown.csv\"\n",
    "    demo_path.write_text(\n",
    "        \"Device report\\n\\\"October 1, 2026 - October 19, 2026\\\"\\n\"\n",
    "        \"Device,Clicks,Impr.,Conversions\\nComputers,\\\"4,487\\\",\\\"61,206\\\",171.00\\n\"\n",
    "        \"Mobile phones,\\\"9,912\\\",\\\"143,880\\\",268.40\\nTablets,610,\\\"9,102\\\",21.00\\n\"\n",
    "        \"TV screens,0,312,0.00\\nTotal: Account,\\\"15,009\\\",\\\"214,500\\\",460.40\\n\", encoding=\"utf-8\")\n",
    "    my_result = report_my_table(demo_path)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c15d4a7",
   "metadata": {},
   "source": [
    "## Pinned cases\n",
    "\n",
    "Four comparisons the interactive version on the page has to reproduce\n",
    "exactly, plus one family of p-values for the correction. If the page and this\n",
    "notebook ever disagree, the page is wrong."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "3808b63e",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-24T12:58:56.655068Z",
     "iopub.status.busy": "2026-10-24T12:58:56.654506Z",
     "iopub.status.idle": "2026-10-24T12:58:56.678111Z",
     "shell.execute_reply": "2026-10-24T12:58:56.676887Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pinned 4 comparisons and one family of 10 p-values\n",
      "  a clear winner               p = 0.0000\n",
      "  the one everybody acts on    p = 0.4355\n",
      "  two thin rows                p = 0.3506\n",
      "  nothing has converted yet    p = 0.6044\n",
      "  the family: 5 of 10 flagged alone, 2 after correcting\n"
     ]
    }
   ],
   "source": [
    "PINNED = [\n",
    "    (\"a clear winner\", 260, 8000, 150, 8000),\n",
    "    (\"the one everybody acts on\", 99, 4100, 84, 3900),\n",
    "    (\"two thin rows\", 3, 140, 1, 130),\n",
    "    (\"nothing has converted yet\", 0, 40, 6, 900),\n",
    "]\n",
    "cases = []\n",
    "for label, x_a, n_a, x_b, n_b in PINNED:\n",
    "    test = two_proportion_test(x_a, n_a, x_b, n_b)\n",
    "    cases.append({\n",
    "        \"label\": label, \"x_a\": x_a, \"n_a\": n_a, \"x_b\": x_b, \"n_b\": n_b,\n",
    "        \"expected\": {\n",
    "            \"evaluable\": bool(test[\"evaluable\"]),\n",
    "            \"z\": round(test.get(\"z\", 0.0), 6), \"p\": round(test.get(\"p\", 1.0), 6),\n",
    "            \"rate_a\": round(test.get(\"rate_a\", 0.0), 6), \"rate_b\": round(test.get(\"rate_b\", 0.0), 6),\n",
    "            \"wilson_a\": [round(wilson_interval(x_a, n_a)[\"low\"], 6),\n",
    "                         round(wilson_interval(x_a, n_a)[\"high\"], 6)],\n",
    "            \"wilson_b\": [round(wilson_interval(x_b, n_b)[\"low\"], 6),\n",
    "                         round(wilson_interval(x_b, n_b)[\"high\"], 6)],\n",
    "        }})\n",
    "\n",
    "PINNED_FAMILY = [0.001, 0.008, 0.021, 0.031, 0.049, 0.052, 0.20, 0.33, 0.51, 0.77]\n",
    "checks = {\n",
    "    \"tolerance\": 1e-4,\n",
    "    \"settings\": {\"alpha\": ALPHA, \"q\": Q, \"z95\": Z95},\n",
    "    \"cases\": cases,\n",
    "    \"family\": {\"p_values\": PINNED_FAMILY,\n",
    "               \"expected_adjusted\": [round(v, 6) for v in benjamini_hochberg(PINNED_FAMILY)],\n",
    "               \"expected_flagged_uncorrected\": [bool(p < ALPHA) for p in PINNED_FAMILY],\n",
    "               \"expected_flagged_corrected\": [bool(v < Q) for v in benjamini_hochberg(PINNED_FAMILY)]},\n",
    "}\n",
    "(DATA / \"checks.json\").write_text(json.dumps(checks, indent=2) + \"\\n\", encoding=\"utf-8\")\n",
    "print(f\"pinned {len(cases)} comparisons and one family of {len(PINNED_FAMILY)} p-values\")\n",
    "for case in cases:\n",
    "    print(f\"  {case['label']:28} p = {case['expected']['p']:.4f}\")\n",
    "uncorrected = sum(checks[\"family\"][\"expected_flagged_uncorrected\"])\n",
    "corrected = sum(checks[\"family\"][\"expected_flagged_corrected\"])\n",
    "print(f\"  the family: {uncorrected} of {len(PINNED_FAMILY)} flagged alone, {corrected} after correcting\")"
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}