{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "1ce71a3c",
   "metadata": {},
   "source": [
    "# Reproducibility and memory-bounded scaling\n",
    "\n",
    "If you cannot reproduce a bootstrap result, you cannot cite it. `tsbootstrap` answers that on two fronts: a run is deterministic for a fixed seed and environment, and it records its own provenance. From there we scale to a large number of replicates without running out of memory, using `bootstrap_reduce`, which keeps only a per-replicate statistic instead of the full array of resampled series.\n",
    "\n",
    "Throughout we simulate a stationary AR(1), `x[t] = phi * x[t-1] + e[t]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "29540429",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-06-22T16:15:15.737261Z",
     "iopub.status.busy": "2026-06-22T16:15:15.736984Z",
     "iopub.status.idle": "2026-06-22T16:15:16.568891Z",
     "shell.execute_reply": "2026-06-22T16:15:16.567835Z"
    }
   },
   "outputs": [],
   "source": [
    "# On Colab or Binder, install tsbootstrap first (skipped if already present):\n",
    "try:\n",
    "    import tsbootstrap  # noqa: F401\n",
    "except ImportError:\n",
    "    %pip install -q \"tsbootstrap[examples]\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a6cf80d",
   "metadata": {},
   "source": [
    "## A small AR(1) series\n",
    "\n",
    "A stationary AR(1) with `phi = 0.6` and unit-variance Gaussian noise. We keep `n` small; the scaling demo later pushes the number of replicates, not the series length."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "05ce846f",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-06-22T16:15:16.573278Z",
     "iopub.status.busy": "2026-06-22T16:15:16.572817Z",
     "iopub.status.idle": "2026-06-22T16:15:16.898247Z",
     "shell.execute_reply": "2026-06-22T16:15:16.897307Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.        , -0.13210486,  0.56115973,  0.44159596, -0.2707118 ])"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "PHI = 0.6\n",
    "\n",
    "\n",
    "def ar1(n, phi=PHI, rng=None):\n",
    "    \"\"\"Stationary AR(1) with unit-variance Gaussian noise, started at 0.\"\"\"\n",
    "    rng = np.random.default_rng() if rng is None else rng\n",
    "    x = np.zeros(n)\n",
    "    e = rng.standard_normal(n)\n",
    "    for t in range(1, n):\n",
    "        x[t] = phi * x[t - 1] + e[t]\n",
    "    return x\n",
    "\n",
    "\n",
    "n = 120\n",
    "x = ar1(n, PHI, np.random.default_rng(0))\n",
    "x[:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f879ba51",
   "metadata": {},
   "source": [
    "## Reproducibility: same seed, identical results\n",
    "\n",
    "Pass an integer `random_state` and two runs return bitwise-identical arrays. The RNG contract is per-replicate: replicate `i` is bound to its own generator, derived from `SeedSequence.spawn(n)[i]`, before any work is dispatched. Because the stream for sample `i` is fixed before parallelisation, the results are invariant to the worker count and to how the replicates are chunked. We verify exact equality with `np.array_equal`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "7c0e25c7",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-06-22T16:15:16.901405Z",
     "iopub.status.busy": "2026-06-22T16:15:16.901089Z",
     "iopub.status.idle": "2026-06-22T16:15:17.178100Z",
     "shell.execute_reply": "2026-06-22T16:15:17.176331Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "values identical across two random_state=0 runs: True\n",
      "indices identical across two random_state=0 runs: True\n",
      "random_state=1 differs from random_state=0: True\n"
     ]
    }
   ],
   "source": [
    "from tsbootstrap import MovingBlock, bootstrap\n",
    "\n",
    "run_a = bootstrap(x, method=MovingBlock(block_length=10), n_bootstraps=200, random_state=0)\n",
    "run_b = bootstrap(x, method=MovingBlock(block_length=10), n_bootstraps=200, random_state=0)\n",
    "\n",
    "values_equal = np.array_equal(run_a.values(), run_b.values())\n",
    "indices_equal = np.array_equal(run_a.indices(), run_b.indices())\n",
    "print(f\"values identical across two random_state=0 runs: {values_equal}\")\n",
    "print(f\"indices identical across two random_state=0 runs: {indices_equal}\")\n",
    "\n",
    "# A different seed gives a different draw (sanity check that the seed is doing something).\n",
    "run_c = bootstrap(x, method=MovingBlock(block_length=10), n_bootstraps=200, random_state=1)\n",
    "print(\n",
    "    f\"random_state=1 differs from random_state=0: {not np.array_equal(run_a.values(), run_c.values())}\"\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "34162fa2",
   "metadata": {},
   "source": [
    "`random_state` accepts an `int`, a NumPy `Generator`, a `SeedSequence`, or `None`. An `int` (or a `SeedSequence`) gives a reproducible run for any worker count. A `Generator` is consumed once: a 128-bit seed is drawn from it and recorded, so the live generator is never shared across processes, yet the run is reproducible from the recorded entropy. `None` uses OS entropy (non-reproducible), but the drawn entropy is still recorded for provenance. The next cell shows where that recorded entropy lives.\n",
    "\n",
    "Worker-count invariance is the same contract NumPy and scikit-learn give: results are reproducible for a fixed seed and environment (OS, hardware, BLAS, NumPy version)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ec32037",
   "metadata": {},
   "source": [
    "## Provenance: the run records how it was produced\n",
    "\n",
    "Every result carries a `BootstrapRunMetadata` record at `result.metadata`, which holds what you need to reproduce or cite the run. The next cell prints its fields, so what you read is what the dataclass stores."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "b75e5ccd",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-06-22T16:15:17.182018Z",
     "iopub.status.busy": "2026-06-22T16:15:17.181798Z",
     "iopub.status.idle": "2026-06-22T16:15:17.522048Z",
     "shell.execute_reply": "2026-06-22T16:15:17.520070Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>value</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>field</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>method</th>\n",
       "      <td>'moving_block'</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>method_params</th>\n",
       "      <td>{'kind': 'moving_block', 'block_length': 10}</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>n_bootstraps</th>\n",
       "      <td>200</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>n_obs</th>\n",
       "      <td>120</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>n_series</th>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>random_state_kind</th>\n",
       "      <td>'int'</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>seed_entropy</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>backend</th>\n",
       "      <td>None</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>versions</th>\n",
       "      <td>{'numpy': '2.4.6', 'scipy': '1.15.3', 'tsboots...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>references</th>\n",
       "      <td>(Kunsch 1989, Liu-Singh 1992)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>warnings</th>\n",
       "      <td>()</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>failed</th>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>failure_reason</th>\n",
       "      <td>None</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                               value\n",
       "field                                                               \n",
       "method                                                'moving_block'\n",
       "method_params           {'kind': 'moving_block', 'block_length': 10}\n",
       "n_bootstraps                                                     200\n",
       "n_obs                                                            120\n",
       "n_series                                                           1\n",
       "random_state_kind                                              'int'\n",
       "seed_entropy                                                       0\n",
       "backend                                                         None\n",
       "versions           {'numpy': '2.4.6', 'scipy': '1.15.3', 'tsboots...\n",
       "references                             (Kunsch 1989, Liu-Singh 1992)\n",
       "warnings                                                          ()\n",
       "failed                                                         False\n",
       "failure_reason                                                  None"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "meta = run_a.metadata\n",
    "provenance = pd.DataFrame(\n",
    "    [\n",
    "        (\"method\", repr(meta.method)),\n",
    "        (\"method_params\", meta.method_params),\n",
    "        (\"n_bootstraps\", meta.n_bootstraps),\n",
    "        (\"n_obs\", meta.n_obs),\n",
    "        (\"n_series\", meta.n_series),\n",
    "        (\"random_state_kind\", repr(meta.random_state_kind)),\n",
    "        (\"seed_entropy\", meta.seed_entropy),\n",
    "        (\"backend\", repr(meta.backend)),\n",
    "        (\"versions\", meta.versions),\n",
    "        (\"references\", meta.references),\n",
    "        (\"warnings\", meta.warnings),\n",
    "        (\"failed\", meta.failed),\n",
    "        (\"failure_reason\", repr(meta.failure_reason)),\n",
    "    ],\n",
    "    columns=[\"field\", \"value\"],\n",
    ").set_index(\"field\")\n",
    "provenance"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "12aa1a35",
   "metadata": {},
   "source": [
    "Two fields carry the provenance that matters most. `random_state_kind` records how the seed was supplied (here `'int'`), and `seed_entropy` is the actual entropy the run consumed. Even with `random_state=None` the `seed_entropy` is populated, so an exploratory run can be replayed exactly by feeding its recorded entropy back in. `references` lists the method's literature citations, and `versions` pins the library versions, so a result is self-documenting for a paper or report."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "b32d996f",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-06-22T16:15:17.526426Z",
     "iopub.status.busy": "2026-06-22T16:15:17.525937Z",
     "iopub.status.idle": "2026-06-22T16:15:17.541591Z",
     "shell.execute_reply": "2026-06-22T16:15:17.540178Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "random_state_kind: 'none'\n",
      "recorded seed_entropy: 278104144765395418338305278694271410265\n",
      "replay from recorded entropy reproduces the run: True\n"
     ]
    }
   ],
   "source": [
    "# The recorded entropy replays a 'random' run exactly.\n",
    "auto = bootstrap(x, method=MovingBlock(block_length=10), n_bootstraps=50, random_state=None)\n",
    "recorded = auto.metadata.seed_entropy\n",
    "print(f\"random_state_kind: {auto.metadata.random_state_kind!r}\")\n",
    "print(f\"recorded seed_entropy: {recorded}\")\n",
    "\n",
    "replay = bootstrap(\n",
    "    x,\n",
    "    method=MovingBlock(block_length=10),\n",
    "    n_bootstraps=50,\n",
    "    random_state=np.random.SeedSequence(recorded),\n",
    ")\n",
    "print(\n",
    "    f\"replay from recorded entropy reproduces the run: {np.array_equal(auto.values(), replay.values())}\"\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6442529d",
   "metadata": {},
   "source": [
    "## Memory-bounded scaling to large B\n",
    "\n",
    "Conformal and UQ calibration want many replicates. But the full result is a `(B, n)` array: at `B = 5000` and even a modest `n` that materialised array can be large, and for longer series it stops fitting in RAM. `bootstrap_reduce` solves this by applying a `statistic` to each replicate inside the same chunked loop `bootstrap` uses, keeping only the `(B, |theta|)` array of statistic values. Peak memory is `O(B * |theta|)` instead of `O(B * n)`.\n",
    "\n",
    "The `statistic` is a callable `(values, indices) -> scalar | array`. `values` is one replicate of shape `(n,)`; `indices` is its original-observation indices (or `None` for recursive methods). It must be independent across replicates, since it is evaluated one replicate at a time. We use a cheap statistic, the mean of the replicate, so `B = 5000` runs fast."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "60aa980c",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-06-22T16:15:17.544651Z",
     "iopub.status.busy": "2026-06-22T16:15:17.544443Z",
     "iopub.status.idle": "2026-06-22T16:15:17.677978Z",
     "shell.execute_reply": "2026-06-22T16:15:17.676691Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "reduced.statistics shape: (5000,)   # (B, |theta|)\n",
      "number of replicates kept: 5000\n",
      "reduced.failed: False\n"
     ]
    }
   ],
   "source": [
    "from tsbootstrap import bootstrap_reduce\n",
    "\n",
    "\n",
    "def replicate_mean(values, indices):\n",
    "    \"\"\"Cheap per-replicate statistic: the sample mean. indices is unused here.\"\"\"\n",
    "    return values.mean()\n",
    "\n",
    "\n",
    "B_large = 5000\n",
    "reduced = bootstrap_reduce(\n",
    "    x,\n",
    "    method=MovingBlock(block_length=10),\n",
    "    statistic=replicate_mean,\n",
    "    n_bootstraps=B_large,\n",
    "    random_state=0,\n",
    ")\n",
    "\n",
    "print(f\"reduced.statistics shape: {reduced.statistics.shape}   # (B, |theta|)\")\n",
    "print(f\"number of replicates kept: {len(reduced)}\")\n",
    "print(f\"reduced.failed: {reduced.failed}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "524e3fea",
   "metadata": {},
   "source": [
    "## A confidence interval without the full array\n",
    "\n",
    "`ReducedResult.quantile([...])` takes exact quantiles over the `B` replicates. A percentile confidence interval for the mean falls straight out, computed from the 5000-row statistic array, never from a materialised `(5000, 120)` array of series."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "c40eddc5",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-06-22T16:15:17.681523Z",
     "iopub.status.busy": "2026-06-22T16:15:17.681387Z",
     "iopub.status.idle": "2026-06-22T16:15:17.686347Z",
     "shell.execute_reply": "2026-06-22T16:15:17.685417Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "95% percentile CI for the mean (B=5000): [-0.2740, 0.5846]\n",
      "interval width: 0.8586\n",
      "observed sample mean: 0.1730\n"
     ]
    }
   ],
   "source": [
    "lo, hi = reduced.quantile([0.025, 0.975])\n",
    "point = float(np.median(reduced.statistics))\n",
    "print(f\"95% percentile CI for the mean (B={B_large}): [{lo:.4f}, {hi:.4f}]\")\n",
    "print(f\"interval width: {hi - lo:.4f}\")\n",
    "print(f\"observed sample mean: {x.mean():.4f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df0ea658",
   "metadata": {},
   "source": [
    "### Conceptual memory contrast\n",
    "\n",
    "The two paths keep different things in memory. The full path holds the resampled series; the reduced path holds only the statistic. For a scalar statistic like the mean, `|theta| = 1`, so the reduced footprint is the series length `n` times smaller than the full one. The numbers below are the array sizes the two paths would hold at `B = 5000`; only the reduced one was actually materialised here."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "f5a3f422",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-06-22T16:15:17.688588Z",
     "iopub.status.busy": "2026-06-22T16:15:17.688464Z",
     "iopub.status.idle": "2026-06-22T16:15:17.698222Z",
     "shell.execute_reply": "2026-06-22T16:15:17.697184Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "reduction factor: 120x  (equal to the series length n)\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>array shape</th>\n",
       "      <th>floats held</th>\n",
       "      <th>size (MB)</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>full path</th>\n",
       "      <td>(B, n) = (5000, 120)</td>\n",
       "      <td>600000</td>\n",
       "      <td>4.80</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>reduced path</th>\n",
       "      <td>(B, 1) = (5000, 1)</td>\n",
       "      <td>5000</td>\n",
       "      <td>0.04</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                       array shape  floats held  size (MB)\n",
       "full path     (B, n) = (5000, 120)       600000       4.80\n",
       "reduced path    (B, 1) = (5000, 1)         5000       0.04"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bytes_per_float = 8\n",
    "full_floats = B_large * n  # O(B * n): the materialised (B, n) array\n",
    "reduced_floats = B_large * 1  # O(B * |theta|): one statistic per replicate\n",
    "\n",
    "memory = pd.DataFrame(\n",
    "    {\n",
    "        \"array shape\": [f\"(B, n) = ({B_large}, {n})\", f\"(B, 1) = ({B_large}, 1)\"],\n",
    "        \"floats held\": [full_floats, reduced_floats],\n",
    "        \"size (MB)\": [full_floats * bytes_per_float / 1e6, reduced_floats * bytes_per_float / 1e6],\n",
    "    },\n",
    "    index=[\"full path\", \"reduced path\"],\n",
    ")\n",
    "print(f\"reduction factor: {full_floats / reduced_floats:.0f}x  (equal to the series length n)\")\n",
    "memory"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f5d2af55",
   "metadata": {},
   "source": [
    "## The reduced CI matches the full-array CI\n",
    "\n",
    "Reducing on the fly gives the same answer as keeping the full array. At a smaller `B` where the full array is cheap, we compute the same percentile CI both ways: once from the full `bootstrap(...).values()` array, once from `bootstrap_reduce(...)`. With the same seed and method the replicates are identical, so the intervals agree to floating-point precision."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "db1f448e",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-06-22T16:15:17.700025Z",
     "iopub.status.busy": "2026-06-22T16:15:17.699882Z",
     "iopub.status.idle": "2026-06-22T16:15:17.747519Z",
     "shell.execute_reply": "2026-06-22T16:15:17.746813Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CI bounds identical to floating point: True\n",
      "per-replicate means identical:         True\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>2.5% bound</th>\n",
       "      <th>97.5% bound</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>full path</th>\n",
       "      <td>-0.281177</td>\n",
       "      <td>0.558246</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>reduced path</th>\n",
       "      <td>-0.281177</td>\n",
       "      <td>0.558246</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>abs. difference</th>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                 2.5% bound  97.5% bound\n",
       "full path         -0.281177     0.558246\n",
       "reduced path      -0.281177     0.558246\n",
       "abs. difference    0.000000     0.000000"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B_check = 800\n",
    "common = {\"method\": MovingBlock(block_length=10), \"n_bootstraps\": B_check, \"random_state\": 0}\n",
    "\n",
    "# Full path: materialise every series, then take the per-replicate mean.\n",
    "full = bootstrap(x, **common)\n",
    "full_means = full.values().mean(axis=1)\n",
    "full_lo, full_hi = np.quantile(full_means, [0.025, 0.975])\n",
    "\n",
    "# Reduced path: never materialise the (B, n) array.\n",
    "red = bootstrap_reduce(x, statistic=replicate_mean, **common)\n",
    "red_lo, red_hi = red.quantile([0.025, 0.975])\n",
    "\n",
    "comparison = pd.DataFrame(\n",
    "    {\n",
    "        \"2.5% bound\": [full_lo, float(red_lo), abs(full_lo - float(red_lo))],\n",
    "        \"97.5% bound\": [full_hi, float(red_hi), abs(full_hi - float(red_hi))],\n",
    "    },\n",
    "    index=[\"full path\", \"reduced path\", \"abs. difference\"],\n",
    ")\n",
    "print(f\"CI bounds identical to floating point: {np.allclose([full_lo, full_hi], [red_lo, red_hi])}\")\n",
    "print(f\"per-replicate means identical:         {np.allclose(full_means, red.statistics.ravel())}\")\n",
    "comparison"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "ci-agreement",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-06-22T16:15:17.752143Z",
     "iopub.status.busy": "2026-06-22T16:15:17.751990Z",
     "iopub.status.idle": "2026-06-22T16:15:17.891927Z",
     "shell.execute_reply": "2026-06-22T16:15:17.889851Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 700x320 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# The two CIs land on top of each other: full path (markers) vs reduced path (open rings).\n",
    "fig, ax = plt.subplots(figsize=(7, 3.2), layout=\"constrained\")\n",
    "\n",
    "bounds = [\"2.5% bound\", \"97.5% bound\"]\n",
    "ypos = [1, 0]  # draw 2.5% on top, 97.5% below, so the two rows read cleanly\n",
    "full_vals = [full_lo, full_hi]\n",
    "red_vals = [float(red_lo), float(red_hi)]\n",
    "\n",
    "ax.scatter(\n",
    "    full_vals,\n",
    "    ypos,\n",
    "    s=170,\n",
    "    color=\"#0072B2\",\n",
    "    marker=\"o\",\n",
    "    label=\"full path  bootstrap(...).values()\",\n",
    "    zorder=3,\n",
    ")\n",
    "ax.scatter(\n",
    "    red_vals,\n",
    "    ypos,\n",
    "    s=170,\n",
    "    facecolors=\"none\",\n",
    "    edgecolors=\"#D55E00\",\n",
    "    linewidths=2.4,\n",
    "    marker=\"o\",\n",
    "    label=\"reduced path  bootstrap_reduce(...)\",\n",
    "    zorder=4,\n",
    ")\n",
    "\n",
    "for y, fv, rv in zip(ypos, full_vals, red_vals):\n",
    "    ax.annotate(\n",
    "        f\"diff = {abs(fv - rv):.1e}\",\n",
    "        xy=(fv, y),\n",
    "        xytext=(0, 14),\n",
    "        textcoords=\"offset points\",\n",
    "        ha=\"center\",\n",
    "        fontsize=9,\n",
    "        color=\"dimgray\",\n",
    "    )\n",
    "\n",
    "ax.set_yticks(ypos)\n",
    "ax.set_yticklabels(bounds)\n",
    "ax.set_ylim(-0.6, 1.6)\n",
    "ax.set_xlabel(\"percentile CI bound for the mean (dimensionless statistic)\")\n",
    "ax.set_title(\"Reduced and full paths give the same 95% CI to floating-point precision (B=800)\")\n",
    "ax.legend(loc=\"lower center\", bbox_to_anchor=(0.5, -0.55), ncol=1, frameon=False, fontsize=9)\n",
    "ax.grid(axis=\"x\", alpha=0.3)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "17002768",
   "metadata": {},
   "source": [
    "## Putting it together\n",
    "\n",
    "One figure ties the two ideas together. We grow `B` and watch the reduced-path percentile CI for the mean settle as more replicates accumulate, with the large-`B` interval drawn as a band. Each point reuses the same seed, so the curve is itself reproducible."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "a06718ef",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-06-22T16:15:17.897408Z",
     "iopub.status.busy": "2026-06-22T16:15:17.896756Z",
     "iopub.status.idle": "2026-06-22T16:15:18.373064Z",
     "shell.execute_reply": "2026-06-22T16:15:18.371825Z"
    },
    "nbsphinx-thumbnail": {
     "output-index": 0
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x450 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CI at B=  50: [-0.3003, 0.6105]  width 0.9108\n",
      "CI at B=5000: [-0.2740, 0.5846]  width 0.8586\n"
     ]
    }
   ],
   "source": [
    "grid = [50, 100, 200, 500, 1000, 2000, 5000]\n",
    "los, his = [], []\n",
    "for b in grid:\n",
    "    r = bootstrap_reduce(\n",
    "        x,\n",
    "        method=MovingBlock(block_length=10),\n",
    "        statistic=replicate_mean,\n",
    "        n_bootstraps=b,\n",
    "        random_state=0,\n",
    "    )\n",
    "    lo_b, hi_b = r.quantile([0.025, 0.975])\n",
    "    los.append(float(lo_b))\n",
    "    his.append(float(hi_b))\n",
    "\n",
    "los = np.asarray(los)\n",
    "his = np.asarray(his)\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(8, 4.5), layout=\"constrained\")\n",
    "\n",
    "# Reference band: the large-B interval the curves are converging toward.\n",
    "ax.axhspan(\n",
    "    lo, hi, color=\"#56B4E9\", alpha=0.22, zorder=0, label=f\"reference interval at B={B_large}\"\n",
    ")\n",
    "\n",
    "# The reduced-path CI bounds as they accumulate replicates.\n",
    "ax.plot(\n",
    "    grid, los, \"o-\", color=\"#0072B2\", lw=2, markersize=7, label=\"2.5% quantile (lower CI bound)\"\n",
    ")\n",
    "ax.plot(\n",
    "    grid, his, \"s--\", color=\"#D55E00\", lw=2, markersize=7, label=\"97.5% quantile (upper CI bound)\"\n",
    ")\n",
    "ax.axhline(\n",
    "    x.mean(),\n",
    "    color=\"black\",\n",
    "    lw=1.4,\n",
    "    ls=\":\",\n",
    "    zorder=2,\n",
    "    label=f\"observed sample mean = {x.mean():.3f}\",\n",
    ")\n",
    "\n",
    "ax.set_xscale(\"log\")\n",
    "ax.set_xticks(grid)\n",
    "ax.set_xticklabels(grid)\n",
    "ax.set_xlabel(\"number of bootstrap replicates B (log scale)\")\n",
    "ax.set_ylabel(\"percentile CI bound for the mean\\n(dimensionless statistic)\")\n",
    "ax.set_title(\"Reduced-path 95% CI converges to its large-B value as B grows\")\n",
    "ax.legend(loc=\"center right\", fontsize=9, framealpha=0.92)\n",
    "ax.grid(alpha=0.3)\n",
    "plt.show()\n",
    "\n",
    "print(f\"CI at B={grid[0]:>4d}: [{los[0]:.4f}, {his[0]:.4f}]  width {his[0] - los[0]:.4f}\")\n",
    "print(f\"CI at B={grid[-1]:>4d}: [{los[-1]:.4f}, {his[-1]:.4f}]  width {his[-1] - los[-1]:.4f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5f785319",
   "metadata": {},
   "source": [
    "## Closing the loop on reproducibility\n",
    "\n",
    "A fixed integer seed gives bitwise-identical results no matter how the work is parallelised. Every run records the entropy and the library versions needed to replay or cite it. And `bootstrap_reduce` scales the replicate count to whatever your calibration needs without holding the full `(B, n)` array in memory, while returning the same quantiles the full array would."
   ]
  }
 ],
 "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.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}