Adaptive-Barrier-Monitor/notebooks/05_adaptive_barrier_monitor.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "03f5f117",
   "metadata": {},
   "source": [
    "# Notebook 05 — The Adaptive Barrier Monitor\n",
    "\n",
    "We now assemble the full answer. Notebooks 02–04 give an exact Brownian-bridge\n",
    "crossing probability **conditional on two observed endpoints**. If both\n",
    "endpoints are approximated by the current barrier distance $D$, its inversion is\n",
    "\n",
    "$$\\Delta t_{\\mathrm{proxy}} \\;=\\; \\frac{2\\,D^2}{\\sigma^2\\,\\ln(1/\\varepsilon)},\n",
    "\\qquad D = X_t - B.$$\n",
    "\n",
    "This produces a useful **state-dependent scheduling heuristic**: cheap when the\n",
    "market is calm and increasingly dense near a barrier. It is not an unconditional\n",
    "miss guarantee—the future endpoint is unknown—and it does not control jumps.\n",
    "We implement the heuristic with consistent time units, compare its sampling cost\n",
    "with a fixed-rate baseline, and then make the jump-risk limitation explicit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "8ef360fd",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-08-02T16:22:18.975392Z",
     "iopub.status.busy": "2026-08-02T16:22:18.975150Z",
     "iopub.status.idle": "2026-08-02T16:22:20.372605Z",
     "shell.execute_reply": "2026-08-02T16:22:20.371673Z"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# =====================================================================\n",
    "# Helper functions -- self-contained small library,\n",
    "# included verbatim at the top of every notebook so each one runs standalone.\n",
    "# (This cell is identical across the series.)\n",
    "# =====================================================================\n",
    "import types\n",
    "from scipy.stats import norm\n",
    "import matplotlib as mpl\n",
    "\n",
    "# --- config: trading-time & volatility conventions (annualised sigma) ---\n",
    "TRADING_DAYS_PER_YEAR = 252\n",
    "TRADING_HOURS_PER_DAY = 6.5\n",
    "TRADING_MINUTES_PER_HOUR = 60\n",
    "TRADING_MINUTES_PER_DAY = TRADING_HOURS_PER_DAY * TRADING_MINUTES_PER_HOUR     # 390\n",
    "TRADING_MINUTES_PER_YEAR = TRADING_DAYS_PER_YEAR * TRADING_MINUTES_PER_DAY      # 98280\n",
    "DROP_FRACTION = 0.10                       # a 10% drop\n",
    "WINDOW_MINUTES = 5                         # over a 5-minute window\n",
    "WINDOW_YEARS = WINDOW_MINUTES / TRADING_MINUTES_PER_YEAR    # ~5.09e-5\n",
    "LOG_BARRIER = float(np.log(1.0 - DROP_FRACTION))            # ln(0.9) ~ -0.10536\n",
    "TYPICAL_ANNUAL_VOL = 0.30                  # representative liquid large-cap volatility\n",
    "\n",
    "def minutes_to_years(minutes):\n",
    "    return minutes / TRADING_MINUTES_PER_YEAR\n",
    "\n",
    "def horizon_vol(sigma_annual, minutes):\n",
    "    \"\"\"sigma over `minutes` of trading time via Brownian scaling sigma*sqrt(T).\"\"\"\n",
    "    return sigma_annual * np.sqrt(minutes_to_years(minutes))\n",
    "\n",
    "def trading_minutes_to_seconds(minutes):\n",
    "    return minutes * 60.0\n",
    "\n",
    "# --- processes: samplers; each returns (t, X) with X of shape (n_paths, n_steps+1) ---\n",
    "def _as_rng(rng):\n",
    "    return np.random.default_rng() if rng is None else rng\n",
    "\n",
    "def time_grid(T, n_steps):\n",
    "    return np.linspace(0.0, T, n_steps + 1)\n",
    "\n",
    "def brownian_motion(T, n_steps, n_paths=1, drift=0.0, sigma=1.0, rng=None):\n",
    "    \"\"\"Arithmetic BM, dX = drift*dt + sigma*dW, via independent Gaussian increments.\"\"\"\n",
    "    rng = _as_rng(rng)\n",
    "    t = time_grid(T, n_steps)\n",
    "    dt = T / n_steps\n",
    "    dW = rng.normal(loc=drift * dt, scale=sigma * np.sqrt(dt), size=(n_paths, n_steps))\n",
    "    X = np.zeros((n_paths, n_steps + 1))\n",
    "    X[:, 1:] = np.cumsum(dW, axis=1)\n",
    "    return t, X\n",
    "\n",
    "def brownian_motion_cholesky(T, n_steps, n_paths=1, rng=None):\n",
    "    \"\"\"Standard BM via the min(s,t) covariance (Gram) matrix and its Cholesky factor L (x = L z).\"\"\"\n",
    "    rng = _as_rng(rng)\n",
    "    t = time_grid(T, n_steps)\n",
    "    t_inner = t[1:]\n",
    "    K = np.minimum(t_inner[:, None], t_inner[None, :])     # min(s,t) Gram matrix\n",
    "    L = np.linalg.cholesky(K)\n",
    "    z = rng.standard_normal(size=(n_paths, n_steps))\n",
    "    X = np.zeros((n_paths, n_steps + 1))\n",
    "    X[:, 1:] = z @ L.T\n",
    "    return t, X\n",
    "\n",
    "def geometric_brownian_motion(S0, T, n_steps, n_paths=1, mu=0.0, sigma=1.0, rng=None):\n",
    "    \"\"\"GBM, dS = mu*S*dt + sigma*S*dW, via the exact log-space solution (no Euler error).\"\"\"\n",
    "    rng = _as_rng(rng)\n",
    "    t, X = brownian_motion(T, n_steps, n_paths, drift=mu - 0.5 * sigma**2, sigma=sigma, rng=rng)\n",
    "    return t, S0 * np.exp(X)\n",
    "\n",
    "def brownian_bridge(T, n_steps, n_paths=1, start=0.0, end=0.0, sigma=1.0, rng=None):\n",
    "    \"\"\"BM conditioned on B(0)=start, B(T)=end.\"\"\"\n",
    "    rng = _as_rng(rng)\n",
    "    t, W = brownian_motion(T, n_steps, n_paths, drift=0.0, sigma=sigma, rng=rng)\n",
    "    linear = start + (end - start) * (t / T)\n",
    "    bridge = W - np.outer(W[:, -1], t / T) + linear[None, :]\n",
    "    return t, bridge\n",
    "\n",
    "def merton_jump_diffusion(S0, T, n_steps, n_paths=1, mu=0.0, sigma=0.2,\n",
    "                          jump_intensity=0.0, jump_mean=-0.10, jump_sigma=0.15, rng=None):\n",
    "    \"\"\"Merton jump-diffusion; jump_intensity=0 reduces exactly to GBM.\"\"\"\n",
    "    rng = _as_rng(rng)\n",
    "    dt = T / n_steps\n",
    "    k = np.exp(jump_mean + 0.5 * jump_sigma**2) - 1.0          # E[J-1]\n",
    "    nu = mu - 0.5 * sigma**2 - jump_intensity * k               # compensated drift\n",
    "    t, X = brownian_motion(T, n_steps, n_paths, drift=nu, sigma=sigma, rng=rng)\n",
    "    counts = rng.poisson(jump_intensity * dt, size=(n_paths, n_steps))\n",
    "    jump_log = np.zeros((n_paths, n_steps))\n",
    "    K = int(counts.max()) if counts.size else 0\n",
    "    if K > 0:\n",
    "        logJ = rng.normal(jump_mean, jump_sigma, size=(n_paths, n_steps, K))\n",
    "        mask = np.arange(K) < counts[:, :, None]\n",
    "        jump_log = (logJ * mask).sum(axis=2)\n",
    "    jump_path = np.zeros((n_paths, n_steps + 1))\n",
    "    jump_path[:, 1:] = np.cumsum(jump_log, axis=1)\n",
    "    return t, S0 * np.exp(X + jump_path)\n",
    "\n",
    "# --- barriers: first-passage CDFs & the Brownian-bridge miss formula (log-price BM, B<0) ---\n",
    "def first_passage_cdf_zero_drift(B, T, sigma):\n",
    "    \"\"\"P(tau_B<=T) for zero-drift BM, via the reflection principle: 2*Phi(B/(sigma*sqrt(T))).\"\"\"\n",
    "    return 2.0 * norm.cdf(B / (sigma * np.sqrt(T)))\n",
    "\n",
    "def first_passage_cdf(B, T, nu, sigma):\n",
    "    \"\"\"P(tau_B<=T) for BM with drift nu (Bachelier-Levy).\"\"\"\n",
    "    sT = sigma * np.sqrt(T)\n",
    "    return norm.cdf((B - nu * T) / sT) + np.exp(2.0 * nu * B / sigma**2) * norm.cdf((B + nu * T) / sT)\n",
    "\n",
    "def barrier_miss_prob(x0, xT, B, sigma, dt):\n",
    "    \"\"\"P(BM crossed B inside (0,dt) | both endpoints above B): exp(-2(x0-B)(xT-B)/(sigma^2 dt)).\"\"\"\n",
    "    if x0 <= B or xT <= B:\n",
    "        return 1.0\n",
    "    return float(np.exp(-2.0 * (x0 - B) * (xT - B) / (sigma**2 * dt)))\n",
    "\n",
    "def max_safe_dt(D, sigma, epsilon):\n",
    "    \"\"\"Largest sampling interval keeping P(miss)<=epsilon: dt = 2*D^2/(sigma^2 * ln(1/epsilon)).\"\"\"\n",
    "    if not (0.0 < epsilon < 1.0):\n",
    "        raise ValueError(\"epsilon must lie in (0, 1)\")\n",
    "    return 2.0 * D**2 / (sigma**2 * np.log(1.0 / epsilon))\n",
    "\n",
    "def estimate_first_passage_prob(B, T, nu, sigma, n_paths, n_steps, rng=None):\n",
    "    \"\"\"Naive MC of P(tau_B<=T) via discrete grid checks (O(sqrt(dt)) downward bias).\"\"\"\n",
    "    rng = _as_rng(rng)\n",
    "    _, X = brownian_motion(T, n_steps, n_paths, drift=nu, sigma=sigma, rng=rng)\n",
    "    return float(np.mean(np.any(X <= B, axis=1)))\n",
    "\n",
    "def estimate_first_passage_prob_bb(B, T, nu, sigma, n_paths, n_steps, rng=None):\n",
    "    \"\"\"Bias-free MC of P(tau_B<=T) using the Brownian-bridge crossing probability per step.\"\"\"\n",
    "    rng = _as_rng(rng)\n",
    "    _, X = brownian_motion(T, n_steps, n_paths, drift=nu, sigma=sigma, rng=rng)\n",
    "    dt = T / n_steps\n",
    "    x0, x1 = X[:, :-1], X[:, 1:]\n",
    "    both_above = (x0 > B) & (x1 > B)\n",
    "    p_cross = np.where(both_above, np.exp(-2.0 * (x0 - B) * (x1 - B) / (sigma**2 * dt)), 1.0)\n",
    "    u = rng.uniform(size=p_cross.shape)\n",
    "    return float(np.mean(np.any(u < p_cross, axis=1)))\n",
    "\n",
    "def estimate_bridge_breach_prob(x0, xT, B, sigma, dt, n_paths, n_inner, rng=None):\n",
    "    \"\"\"MC check of barrier_miss_prob by simulating bridges pinned at x0, xT.\"\"\"\n",
    "    rng = _as_rng(rng)\n",
    "    _, bridge = brownian_bridge(dt, n_inner, n_paths, start=x0, end=xT, sigma=sigma, rng=rng)\n",
    "    return float(np.mean(np.any(bridge <= B, axis=1)))\n",
    "\n",
    "# --- plotting helpers ---\n",
    "def style():\n",
    "    \"\"\"Apply the project's matplotlib style (serif maths, clean spines).\"\"\"\n",
    "    mpl.rcParams.update({\n",
    "        \"figure.figsize\": (8.0, 4.5), \"figure.dpi\": 110, \"savefig.dpi\": 140,\n",
    "        \"axes.grid\": True, \"grid.alpha\": 0.3,\n",
    "        \"axes.spines.top\": False, \"axes.spines.right\": False,\n",
    "        \"font.size\": 11, \"mathtext.fontset\": \"cm\",\n",
    "        \"axes.titlesize\": 12, \"axes.labelsize\": 11, \"legend.frameon\": False,\n",
    "    })\n",
    "\n",
    "def plot_paths(t, X, ax=None, alpha=0.5, lw=0.8, color=\"C0\", label=None, **kwargs):\n",
    "    \"\"\"Plot each row of X (shape (n_paths, len(t))) against t.\"\"\"\n",
    "    if ax is None:\n",
    "        _, ax = plt.subplots()\n",
    "    X = np.atleast_2d(X)\n",
    "    for i, row in enumerate(X):\n",
    "        ax.plot(t, row, color=color, alpha=alpha, lw=lw, label=label if i == 0 else None, **kwargs)\n",
    "    ax.set_xlabel(\"time\")\n",
    "    return ax\n",
    "\n",
    "def hline(ax, y, color=\"crimson\", label=None, ls=\"--\", lw=1.4):\n",
    "    \"\"\"Draw a horizontal barrier line.\"\"\"\n",
    "    ax.axhline(y, color=color, ls=ls, lw=lw, label=label)\n",
    "    return ax\n",
    "\n",
    "# --- module namespaces (so existing call sites like processes.X / config.Y keep working) ---\n",
    "config = types.SimpleNamespace(\n",
    "    TRADING_DAYS_PER_YEAR=TRADING_DAYS_PER_YEAR, TRADING_HOURS_PER_DAY=TRADING_HOURS_PER_DAY,\n",
    "    TRADING_MINUTES_PER_HOUR=TRADING_MINUTES_PER_HOUR, TRADING_MINUTES_PER_DAY=TRADING_MINUTES_PER_DAY,\n",
    "    TRADING_MINUTES_PER_YEAR=TRADING_MINUTES_PER_YEAR, DROP_FRACTION=DROP_FRACTION,\n",
    "    WINDOW_MINUTES=WINDOW_MINUTES, WINDOW_YEARS=WINDOW_YEARS, LOG_BARRIER=LOG_BARRIER,\n",
    "    TYPICAL_ANNUAL_VOL=TYPICAL_ANNUAL_VOL, minutes_to_years=minutes_to_years,\n",
    "    horizon_vol=horizon_vol, trading_minutes_to_seconds=trading_minutes_to_seconds,\n",
    ")\n",
    "processes = types.SimpleNamespace(\n",
    "    brownian_motion=brownian_motion, brownian_motion_cholesky=brownian_motion_cholesky,\n",
    "    geometric_brownian_motion=geometric_brownian_motion, brownian_bridge=brownian_bridge,\n",
    "    merton_jump_diffusion=merton_jump_diffusion,\n",
    ")\n",
    "barriers = types.SimpleNamespace(\n",
    "    first_passage_cdf_zero_drift=first_passage_cdf_zero_drift, first_passage_cdf=first_passage_cdf,\n",
    "    barrier_miss_prob=barrier_miss_prob, max_safe_dt=max_safe_dt,\n",
    "    estimate_first_passage_prob=estimate_first_passage_prob,\n",
    "    estimate_first_passage_prob_bb=estimate_first_passage_prob_bb,\n",
    "    estimate_bridge_breach_prob=estimate_bridge_breach_prob,\n",
    ")\n",
    "plotting = types.SimpleNamespace(style=style, plot_paths=plot_paths, hline=hline)\n",
    "\n",
    "\n",
    "from pathlib import Path\n",
    "\n",
    "def _repo_root():\n",
    "    \"\"\"Find the repository root without requiring the cache to exist already.\"\"\"\n",
    "    p = Path.cwd()\n",
    "    for cand in [p, *p.parents]:\n",
    "        if (cand / \"pyproject.toml\").is_file() or (\n",
    "            (cand / \"notebooks\").is_dir() and (cand / \"src\").is_dir()\n",
    "        ):\n",
    "            return cand\n",
    "    return p\n",
    "\n",
    "_CACHE_DIR = _repo_root() / \"data\" / \"cache\"\n",
    "_CHART_URL = \"https://query1.finance.yahoo.com/v8/finance/chart/{ticker}\"\n",
    "\n",
    "def cache_path(ticker, interval, range_):\n",
    "    _CACHE_DIR.mkdir(parents=True, exist_ok=True)\n",
    "    return _CACHE_DIR / f\"{ticker}_{interval}_{range_}.csv\"\n",
    "\n",
    "def fetch_intraday(ticker=\"SPY\", interval=\"5m\", range_=\"5d\", use_cache=True):\n",
    "    \"\"\"Intraday OHLCV as a tidy DataFrame (UTC index); cached under data/cache/.\"\"\"\n",
    "    path = cache_path(ticker, interval, range_)\n",
    "    if use_cache and path.exists():\n",
    "        df = pd.read_csv(path, index_col=0, parse_dates=True)\n",
    "        if df.index.tz is None:\n",
    "            df.index = df.index.tz_localize(\"UTC\")\n",
    "        return df\n",
    "    import requests\n",
    "    resp = requests.get(\n",
    "        _CHART_URL.format(ticker=ticker),\n",
    "        params={\"interval\": interval, \"range\": range_, \"includePrePost\": \"false\"},\n",
    "        headers={\"User-Agent\": \"Mozilla/5.0\"}, timeout=30,\n",
    "    )\n",
    "    resp.raise_for_status()\n",
    "    result = resp.json()[\"chart\"][\"result\"][0]\n",
    "    timestamps = pd.to_datetime(result[\"timestamp\"], unit=\"s\", utc=True)\n",
    "    quote = result[\"indicators\"][\"quote\"][0]\n",
    "    df = pd.DataFrame(\n",
    "        {\"open\": quote[\"open\"], \"high\": quote[\"high\"], \"low\": quote[\"low\"],\n",
    "         \"close\": quote[\"close\"], \"volume\": quote[\"volume\"]},\n",
    "        index=timestamps,\n",
    "    )\n",
    "    df.index.name = \"timestamp\"\n",
    "    df = df.dropna(subset=[\"close\"])\n",
    "    if use_cache:\n",
    "        df.to_csv(path)\n",
    "    return df\n",
    "\n",
    "def log_returns(prices):\n",
    "    \"\"\"Log-returns ln(p_t / p_{t-1}).\"\"\"\n",
    "    return pd.Series(np.log(prices).diff().dropna(), name=\"log_return\")\n",
    "\n",
    "data = types.SimpleNamespace(fetch_intraday=fetch_intraday, log_returns=log_returns, cache_path=cache_path)\n",
    "\n",
    "from pathlib import Path\n",
    "\n",
    "def _img_subdir(sub):\n",
    "    \"\"\"Resolve <repo>/images/<sub>, creating it; cwd-independent.\"\"\"\n",
    "    root = Path.cwd()\n",
    "    for cand in (root, *root.parents):\n",
    "        if (cand / \"notebooks\").is_dir():\n",
    "            root = cand\n",
    "            break\n",
    "    d = root / \"images\" / sub\n",
    "    d.mkdir(parents=True, exist_ok=True)\n",
    "    return d\n",
    "\n",
    "_FIG = _img_subdir(\"05_adaptive_detector\")\n",
    "\n",
    "plotting.style()\n",
    "RNG = np.random.default_rng(5)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "abb884d6",
   "metadata": {},
   "source": [
    "## 1. The algorithm\n",
    "\n",
    "Choose a diffusion-design parameter $\\varepsilon$. At each observation we know\n",
    "the current relative log-price $X_t=\\log(S_t/S_0)$ and its distance\n",
    "$D=X_t-B$ from the lower barrier. We schedule the next observation using\n",
    "\n",
    "$$t_{\\text{next}} = t + \\min\\!\\left(\n",
    "\\frac{2D^2}{\\sigma^2\\ln(1/\\varepsilon)},\\;\\Delta t_{\\text{cap}}\n",
    "\\right).$$\n",
    "\n",
    "Here the time grid and $\\sigma$ must use matching units. In the implementation\n",
    "below, time is measured in minutes and $\\sigma$ is the standard deviation per\n",
    "$\\sqrt{\\text{minute}}$.\n",
    "\n",
    "```\n",
    "observe X_t at time t\n",
    "if X_t <= B: ALERT and stop\n",
    "D <- X_t - B\n",
    "dt <- 2 D^2 / (sigma^2 * ln(1/eps))   # local flat-endpoint proxy\n",
    "dt <- min(dt, dt_cap)\n",
    "schedule next sample at t + dt\n",
    "```\n",
    "\n",
    "The rate grows like $1/D^2$ near the barrier. The formula is exact only for a\n",
    "Brownian bridge whose two endpoint distances both equal $D$; online it is a\n",
    "local approximation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "380d9756",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-08-02T16:22:20.374526Z",
     "iopub.status.busy": "2026-08-02T16:22:20.374251Z",
     "iopub.status.idle": "2026-08-02T16:22:20.379690Z",
     "shell.execute_reply": "2026-08-02T16:22:20.378943Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sigma (annual)       = 0.3\n",
      "sigma (per sqrt(min))= 0.000957\n",
      "design parameter eps = 0.001\n"
     ]
    }
   ],
   "source": [
    "# The adaptive scheduler. Given a fine ground-truth relative log-price path,\n",
    "# return the indices that an online monitor would sample.\n",
    "def adaptive_schedule(t, X, B, sigma, eps, dt_cap=None, stop_on_breach=False):\n",
    "    \"\"\"Local symmetric-endpoint bridge proxy; t and sigma must share units.\"\"\"\n",
    "    idx = [0]\n",
    "    n = len(t)\n",
    "    i = 0\n",
    "    while i < n - 1:\n",
    "        if stop_on_breach and X[i] <= B:\n",
    "            break\n",
    "        D = max(float(X[i] - B), 1e-12)\n",
    "        dt = barriers.max_safe_dt(D, sigma, eps)\n",
    "        if dt_cap is not None:\n",
    "            dt = min(dt, dt_cap)\n",
    "        target = t[i] + dt\n",
    "        j = int(np.searchsorted(t, target, side=\"left\"))\n",
    "        j = min(max(j, i + 1), n - 1)\n",
    "        idx.append(j)\n",
    "        i = j\n",
    "    return np.asarray(idx, dtype=int)\n",
    "\n",
    "# Work in minutes, so volatility is expressed per sqrt(minute).\n",
    "sigma_ann = config.TYPICAL_ANNUAL_VOL\n",
    "sigma_min = config.horizon_vol(sigma_ann, 1.0)\n",
    "eps = 1e-3\n",
    "print(f\"sigma (annual)       = {sigma_ann}\")\n",
    "print(f\"sigma (per sqrt(min))= {sigma_min:.6f}\")\n",
    "print(f\"design parameter eps = {eps}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03e55b75",
   "metadata": {},
   "source": [
    "## 2. The allowed interval vs. proximity to the barrier\n",
    "\n",
    "The feedback law in action: $\\Delta t_{\\max}$ is *enormous* when the price is\n",
    "healthy and collapses to milliseconds only at the barrier. Work in **minutes**\n",
    "by using the per-minute volatility."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "c2a82e54",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-08-02T16:22:20.381705Z",
     "iopub.status.busy": "2026-08-02T16:22:20.381505Z",
     "iopub.status.idle": "2026-08-02T16:22:21.651355Z",
     "shell.execute_reply": "2026-08-02T16:22:21.649982Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " drawdown   D (log)   dt_max (min)         dt_max\n",
      "    0.00%    0.1054        3509.71         58.5 h\n",
      "    1.00%    0.0953        2872.07         47.9 h\n",
      "    2.00%    0.0852        2292.79         38.2 h\n",
      "    3.00%    0.0749        1773.76         29.6 h\n",
      "    5.00%    0.0541         924.24     924.24 min\n",
      "    7.00%    0.0328         339.93     339.93 min\n",
      "    8.00%    0.0220         152.73     152.73 min\n",
      "    9.00%    0.0110          38.60      38.60 min\n",
      "    9.50%    0.0055           9.70       9.70 min\n",
      "    9.90%    0.0011           0.39         23.4 s\n",
      "    9.99%    0.0001           0.00          0.2 s\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 924x462 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# How the safe interval depends on how far below the start the price is.\n",
    "sigma_min = config.horizon_vol(sigma_ann, 1.0)\n",
    "drawdown_pct = np.array([0.0, 1, 2, 3, 5, 7, 8, 9, 9.5, 9.9, 9.99])  # % below start\n",
    "rows = []\n",
    "for dd in drawdown_pct:\n",
    "    X = np.log(1 - dd/100.0)                         # current log-price (start = 0)\n",
    "    D = X - config.LOG_BARRIER                       # distance to barrier\n",
    "    dt_min = barriers.max_safe_dt(D, sigma_min, eps) # in minutes\n",
    "    rows.append((dd, D, dt_min))\n",
    "\n",
    "print(f\"{'drawdown':>9} {'D (log)':>9} {'dt_max (min)':>14} {'dt_max':>14}\")\n",
    "for dd, D, dt in rows:\n",
    "    secs = dt*60\n",
    "    pretty = f\"{secs:.1f} s\" if secs < 120 else f\"{dt:.2f} min\" if dt<1440 else f\"{dt/60:.1f} h\" if dt<14400 else f\"{dt/1440:.1f} d\"\n",
    "    print(f\"{dd:>8.2f}% {D:>9.4f} {dt:>14.2f} {pretty:>14}\")\n",
    "\n",
    "ds = np.linspace(0.001, 9.999, 400)            # drawdown from start, in %\n",
    "D = np.log(1 - ds/100.0) - config.LOG_BARRIER  # distance to the -10% barrier\n",
    "plt.figure(figsize=(8.4, 4.2))\n",
    "plt.plot(ds, barriers.max_safe_dt(D, sigma_min, eps))\n",
    "plt.yscale(\"log\")\n",
    "plt.xlabel(\"current drawdown from start (%)\")\n",
    "plt.ylabel(r\"$\\Delta t_{\\max}$ (minutes, log scale)\")\n",
    "plt.title(f\"Adaptive interval vs drawdown  ($\\\\sigma$=30%/yr, $\\\\varepsilon$={eps})\")\n",
    "plt.axhline(1/60000, color=\"k\", ls=\":\", lw=1, label=\"1 millisecond\")\n",
    "plt.grid(alpha=0.3, which=\"both\"); plt.legend(); plt.savefig(_FIG / \"safe_interval_vs_distance.png\", dpi=150, bbox_inches=\"tight\"); plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b31b7ee",
   "metadata": {},
   "source": [
    "The reading is dramatic, but interpret it correctly. Under the local\n",
    "symmetric-endpoint diffusion proxy, a price far from the barrier permits a long\n",
    "interval, while the interval collapses quadratically near the trigger. This\n",
    "explains why blind millisecond polling is inefficient under a continuous\n",
    "low-volatility model. It does **not** imply that a jump cannot cross and recover\n",
    "between polls."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c8dadfb",
   "metadata": {},
   "source": [
    "## 3. Fixed-rate vs adaptive on a controlled jump stress path\n",
    "\n",
    "To make the mechanics visible, we construct a five-minute GBM path and impose a\n",
    "persistent $12\\%$ downward jump halfway through the window. This is a controlled\n",
    "stress scenario, not a calibrated estimate of jump frequency. The adaptive\n",
    "monitor uses a three-second sanity cap and stops once a sampled price confirms\n",
    "the breach; the fixed baseline checks every millisecond."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "0e87492e",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-08-02T16:22:21.657405Z",
     "iopub.status.busy": "2026-08-02T16:22:21.656997Z",
     "iopub.status.idle": "2026-08-02T16:22:21.695746Z",
     "shell.execute_reply": "2026-08-02T16:22:21.694657Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "true breach occurred : True\n",
      "  minimum price      : 88.30  (-11.7%)\n",
      "adaptive samples used:      51   detected: True\n",
      "fixed 1ms samples    : 300,001   detected: True\n",
      "compression ratio    : 5,882x fewer samples\n"
     ]
    }
   ],
   "source": [
    "# Controlled five-minute stress path on a genuine 1 ms grid.\n",
    "S0 = 100.0\n",
    "T_min = 5.0\n",
    "n_fine = int(T_min * 60 * 1000)                 # 300,000 one-millisecond steps\n",
    "T_years = T_min / config.TRADING_MINUTES_PER_YEAR\n",
    "\n",
    "t_years, S = processes.geometric_brownian_motion(\n",
    "    S0, T_years, n_fine, n_paths=1, mu=0.0, sigma=sigma_ann,\n",
    "    rng=np.random.default_rng(51),\n",
    ")\n",
    "t_minutes = t_years * config.TRADING_MINUTES_PER_YEAR\n",
    "\n",
    "# Impose a persistent -12% log jump at the midpoint so a breach definitely occurs.\n",
    "shock_idx = n_fine // 2\n",
    "S[0, shock_idx:] *= np.exp(-0.12)\n",
    "X = np.log(S[0] / S0)                            # relative log-price\n",
    "B = config.LOG_BARRIER\n",
    "\n",
    "idx_adapt = adaptive_schedule(\n",
    "    t_minutes, X, B, sigma_min, eps,\n",
    "    dt_cap=0.05,                                  # at most 3 seconds\n",
    "    stop_on_breach=True,\n",
    ")\n",
    "idx_fixed = np.arange(n_fine + 1, dtype=int)      # every millisecond\n",
    "\n",
    "truth_breach = bool((X <= B).any())\n",
    "adapt_detect = bool((X[idx_adapt] <= B).any())\n",
    "fixed_detect = bool((X[idx_fixed] <= B).any())\n",
    "\n",
    "print(f\"true breach occurred : {truth_breach}\")\n",
    "print(f\"  minimum price      : {S[0].min():.2f}  ({(S[0].min()/S0-1)*100:.1f}%)\")\n",
    "print(f\"adaptive samples used: {len(idx_adapt):>7,}   detected: {adapt_detect}\")\n",
    "print(f\"fixed 1ms samples    : {len(idx_fixed):>7,}   detected: {fixed_detect}\")\n",
    "print(f\"compression ratio    : {len(idx_fixed)/len(idx_adapt):,.0f}x fewer samples\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "7020f046",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-08-02T16:22:21.698571Z",
     "iopub.status.busy": "2026-08-02T16:22:21.698325Z",
     "iopub.status.idle": "2026-08-02T16:22:22.311489Z",
     "shell.execute_reply": "2026-08-02T16:22:22.310482Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1045x506 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(figsize=(9.5, 4.6))\n",
    "ax.plot(t_minutes, S[0], color=\"0.5\", lw=0.8, label=\"stress-path price\")\n",
    "ax.scatter(t_minutes[idx_adapt], S[0][idx_adapt],\n",
    "           c=\"C3\", s=18, zorder=5, label=f\"adaptive samples ({len(idx_adapt)})\")\n",
    "ax.axhline(0.9*S0, color=\"k\", ls=\"--\", lw=1.2, label=\"-10% barrier\")\n",
    "ax.set_xlabel(\"time (minutes)\"); ax.set_ylabel(\"price\")\n",
    "ax.set_title(\"Adaptive sampling with a three-second cap; stop after alert\")\n",
    "ax.legend(loc=\"upper right\")\n",
    "plt.savefig(_FIG / \"adaptive_vs_fixed_path.png\", dpi=150, bbox_inches=\"tight\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aba0fe75",
   "metadata": {},
   "source": [
    "## 4. Cost analysis with a practical polling cap\n",
    "\n",
    "The bridge proxy alone can suggest intervals longer than a trading day when the\n",
    "price is far from a $-10\\%$ barrier. An online monitor cannot adapt to an\n",
    "unobserved approach, so a **hard periodic cap is essential**. Here we impose a\n",
    "one-minute cap and compare it with blind 1 ms polling over a 390-minute trading\n",
    "day."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "5b4cb7b7",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-08-02T16:22:22.314617Z",
     "iopub.status.busy": "2026-08-02T16:22:22.314362Z",
     "iopub.status.idle": "2026-08-02T16:22:23.392042Z",
     "shell.execute_reply": "2026-08-02T16:22:23.390794Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fixed 1ms polling:     23,400,000 samples / trading day\n",
      "adaptive hard cap: 1 minute\n",
      "\n",
      "          scenario   adaptive samples/day   paths alerting      speedup\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "      daily vol 1%                    386            0/200      60,622x\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "      daily vol 3%                    386            0/200      60,622x\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "      daily vol 7%                    370           23/200      63,243x\n"
     ]
    }
   ],
   "source": [
    "fixed_per_day = 390 * 60 * 1000\n",
    "poll_cap_minutes = 1.0\n",
    "print(f\"fixed 1ms polling: {fixed_per_day:>14,} samples / trading day\")\n",
    "print(f\"adaptive hard cap: {poll_cap_minutes:.0f} minute\\n\")\n",
    "\n",
    "scenarios = [\n",
    "    (\"daily vol 1%\", 0.01),\n",
    "    (\"daily vol 3%\", 0.03),\n",
    "    (\"daily vol 7%\", 0.07),\n",
    "]\n",
    "print(f\"{'scenario':>18} {'adaptive samples/day':>22} {'paths alerting':>16} {'speedup':>12}\")\n",
    "for name, daily_vol in scenarios:\n",
    "    sigma_scen = daily_vol * np.sqrt(252)\n",
    "    T_day_years = 390 / config.TRADING_MINUTES_PER_YEAR\n",
    "    npaths, ngrid = 200, 5000\n",
    "    rng = np.random.default_rng(11)\n",
    "    tday_minutes = np.linspace(0.0, 390.0, ngrid + 1)\n",
    "    counts, alerts = [], 0\n",
    "    for _ in range(npaths):\n",
    "        _, Sd = processes.geometric_brownian_motion(\n",
    "            S0, T_day_years, ngrid, 1, 0.0, sigma_scen, rng=rng\n",
    "        )\n",
    "        Xd = np.log(Sd[0] / S0)\n",
    "        idx = adaptive_schedule(\n",
    "            tday_minutes, Xd, B,\n",
    "            config.horizon_vol(sigma_scen, 1.0), eps,\n",
    "            dt_cap=poll_cap_minutes,\n",
    "            stop_on_breach=True,\n",
    "        )\n",
    "        alerts += int((Xd[idx] <= B).any())\n",
    "        counts.append(len(idx))\n",
    "    mean_samples = int(np.mean(counts))\n",
    "    print(f\"{name:>18} {mean_samples:>22,} {alerts:>12}/{npaths:<3} {fixed_per_day/mean_samples:>11,.0f}x\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1ae2cf82",
   "metadata": {},
   "source": [
    "With the one-minute safety cap, the monitor still reduces the polling load by\n",
    "roughly five orders of magnitude relative to 1 ms polling in this stylised\n",
    "experiment. The cap—not the bridge formula—sets the calm-market latency ceiling;\n",
    "the state-dependent rule only becomes denser than the cap near the barrier.\n",
    "These numbers remain model- and parameter-dependent, and jumps are outside the\n",
    "Brownian miss calculation."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ae48b0d",
   "metadata": {},
   "source": [
    "## 5. Beyond GBM: jumps are where extreme moves live\n",
    "\n",
    "Notebook 03 showed a $10\\%$-in-$5$-minutes drop is a $\\sim 49\\sigma$ event\n",
    "under pure GBM — effectively impossible. The **Merton jump-diffusion** superposes\n",
    "a compound Poisson process of discrete jumps on the diffusion:\n",
    "\n",
    "$$\\frac{dS_t}{S_t} \\;=\\; (\\mu - \\lambda \\kappa)\\,dt + \\sigma\\,dW_t + (J_t - 1)\\,dN_t,$$\n",
    "\n",
    "where $N_t$ is a Poisson process of rate $\\lambda$, the jump sizes satisfy\n",
    "$\\log J \\sim \\mathcal N(\\mu_J, \\sigma_J^2)$, and\n",
    "$\\kappa = \\mathbb E[J - 1]$. Downward jumps have $\\mu_J < 0$.\n",
    "\n",
    "Let's see how the *terminal* drop distribution changes when jumps are switched\n",
    "on — and confirm that $10\\%$ drops become genuinely attainable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "5af4075c",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-08-02T16:22:23.394936Z",
     "iopub.status.busy": "2026-08-02T16:22:23.394715Z",
     "iopub.status.idle": "2026-08-02T16:22:27.158074Z",
     "shell.execute_reply": "2026-08-02T16:22:27.157068Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 990x484 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    GBM (no jumps): P(5-min return <= -10%) = 0.000e+00\n",
      "      Merton jumps: P(5-min return <= -10%) = 2.500e-04\n"
     ]
    }
   ],
   "source": [
    "# Compare terminal 5-min returns: pure GBM vs jump-diffusion.\n",
    "T = 5 / config.TRADING_MINUTES_PER_YEAR\n",
    "n_paths, n_steps = 40_000, 300\n",
    "ret = {}\n",
    "ret[\"GBM (no jumps)\"] = np.log(\n",
    "    processes.geometric_brownian_motion(S0, T, n_steps, n_paths, 0.0, sigma_ann, rng=RNG)[1][:,-1] / S0)\n",
    "ret[\"Merton jumps\"]   = np.log(\n",
    "    processes.merton_jump_diffusion(S0, T, n_steps, n_paths, mu=0.0, sigma=sigma_ann,\n",
    "        jump_intensity=10.0, jump_mean=-0.20, jump_sigma=0.15, rng=RNG)[1][:,-1] / S0)\n",
    "\n",
    "plt.figure(figsize=(9, 4.4))\n",
    "for (name, r), col in zip(ret.items(), [\"C0\", \"C3\"]):\n",
    "    plt.hist(r, bins=400, density=True, alpha=0.5, color=col, label=name, range=(-0.15, 0.05))\n",
    "plt.axvline(config.LOG_BARRIER, color=\"k\", ls=\"--\", lw=1.4, label=\"10% drop barrier\")\n",
    "plt.xlabel(\"5-minute log-return\"); plt.ylabel(\"density\")\n",
    "plt.yscale(\"log\")\n",
    "plt.title(\"Jumps put real mass on the -10% tail that GBM leaves empty\")\n",
    "plt.legend(); plt.savefig(_FIG / \"gbm_vs_jump_returns.png\", dpi=150, bbox_inches=\"tight\"); plt.show()\n",
    "\n",
    "for name, r in ret.items():\n",
    "    print(f\"{name:>18}: P(5-min return <= -10%) = {(r <= config.LOG_BARRIER).mean():.3e}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36280d7d",
   "metadata": {},
   "source": [
    "## 6. The event-driven upgrade\n",
    "\n",
    "The adaptive sampler is *time-based*: it polls faster as the price nears the\n",
    "barrier. But a jump can blow through $-10\\%$ between *any* two samples, however\n",
    "close. The fully honest answer is therefore to combine the two ideas:\n",
    "\n",
    "> **Hybrid sampler.** Run the adaptive time-based poll for the diffusion. In\n",
    "> parallel, subscribe to a **microstructure signal** — order-book imbalance,\n",
    "> trade-flow acceleration, realised-volatility spike — and the moment that\n",
    "> signal fires, **switch to event-driven / interrupt-driven** sampling,\n",
    "> effectively moving to continuous monitoring until calm returns.\n",
    "\n",
    "This mirrors how real trading systems are built: a slow poll handles the boring\n",
    "$99.9\\%$ of the time, and a fast event loop handles the rare, violent moments.\n",
    "\n",
    "> **Quant's note.** Under a jump-diffusion the probability of a $-10\\%$ move\n",
    "> over a horizon $T$ is, to first order in $\\lambda T$,\n",
    "> $P \\approx \\lambda T \\cdot P(\\log J \\le B)$. The sampling problem stops being\n",
    "> \"did diffusion wander to the barrier\" and becomes \"did a jump arrive and was\n",
    "> it large enough\" — a Poisson detection problem, best solved event-driven."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6a7b0bc",
   "metadata": {},
   "source": [
    "## 7. Reality check on live data\n",
    "\n",
    "Scan one month of **SPY** 5-minute bars. The largest 5-minute move, and the\n",
    "closest the adaptive barrier ever came to being triggered, make the point that\n",
    "$-10\\%$-in-$5$-minutes simply does not occur in ordinary history."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "fe7e9476",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-08-02T16:22:27.160095Z",
     "iopub.status.busy": "2026-08-02T16:22:27.159895Z",
     "iopub.status.idle": "2026-08-02T16:22:27.182835Z",
     "shell.execute_reply": "2026-08-02T16:22:27.181918Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SPY, 1 month of 5-min bars (1639 bars)\n",
      "  worst 5-min log-return : -0.0130  (-1.30%)\n",
      "  implied annual vol     : 0.132\n",
      "  10% barrier in log-ret : -0.1054\n",
      "  how many 5-min bars <= -10%: 0\n",
      "  -> exactly as GBM predicts: zero such events in normal history.\n",
      "\n",
      "  closest approach to barrier: D = 0.0923\n",
      "  => proxy interval there    : 13851.3 minutes (vs 5-minute bars!)\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    spy = data.fetch_intraday(\"SPY\", interval=\"5m\", range_=\"1mo\")\n",
    "    have = True\n",
    "except Exception as exc:\n",
    "    print(\"Optional market-data scan unavailable; continuing without it.\")\n",
    "    have = False\n",
    "\n",
    "if have:\n",
    "    r5 = data.log_returns(spy[\"close\"])\n",
    "    worst = float(r5.min())\n",
    "    ann_vol = float(r5.std() * np.sqrt(252 * 78))\n",
    "    print(f\"SPY, 1 month of 5-min bars ({len(spy)} bars)\")\n",
    "    print(f\"  worst 5-min log-return : {worst:+.4f}  ({(np.exp(worst)-1)*100:+.2f}%)\")\n",
    "    print(f\"  implied annual vol     : {ann_vol:.3f}\")\n",
    "    print(f\"  10% barrier in log-ret : {config.LOG_BARRIER:.4f}\")\n",
    "    print(f\"  how many 5-min bars <= -10%: {(r5 <= config.LOG_BARRIER).sum()}\")\n",
    "    print(\"  -> exactly as GBM predicts: zero such events in normal history.\\n\")\n",
    "\n",
    "    # How many adaptive samples would we have taken across the whole month,\n",
    "    # had we been monitoring each bar's price vs a -10% barrier from session open?\n",
    "    # (Per-bar distance D ~ |log_barrier| - |5min move|, which is huge -> very few samples.)\n",
    "    sigma_min = config.horizon_vol(ann_vol, 1.0)\n",
    "    typical_D = worst - config.LOG_BARRIER        # closest the price came (log units)\n",
    "    dt_typical = barriers.max_safe_dt(typical_D, sigma_min, eps)\n",
    "    print(f\"  closest approach to barrier: D = {typical_D:.4f}\")\n",
    "    print(f\"  => proxy interval there    : {dt_typical:.1f} minutes \"\n",
    "          f\"(vs 5-minute bars!)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9805bbd4",
   "metadata": {},
   "source": [
    "## 8. The complete answer\n",
    "\n",
    "Putting all five notebooks together:\n",
    "\n",
    "**1. The model.** Under GBM, $dS=\\mu S\\,dt+\\sigma S\\,dW$, the relative log-price\n",
    "$X_t=\\log(S_t/S_0)$ is arithmetic Brownian motion with drift. A $10\\%$ drop is\n",
    "hitting $B=\\log 0.9$.\n",
    "\n",
    "**2. The probability.** The event is a first-passage event. With zero drift,\n",
    "$P(\\tau_B\\le T)=2\\Phi(B/(\\sigma\\sqrt T))$. At $30\\%$ annual volatility, a\n",
    "$10\\%$ five-minute drop is roughly a $49\\sigma$ diffusion event, so GBM assigns\n",
    "it probability below ordinary floating-point resolution. Real extreme moves\n",
    "require richer models, including jumps and market microstructure.\n",
    "\n",
    "**3. The sampling rate.** Conditional on two observed endpoints, the Brownian\n",
    "bridge gives the exact hidden-crossing probability\n",
    "$\\exp(-2(x_0-B)(x_T-B)/(\\sigma^2\\Delta t))$. Replacing the unknown future\n",
    "endpoint distance by the current distance yields the local heuristic\n",
    "$\\Delta t\\propto D^2$: poll sparsely far from the barrier and densely nearby.\n",
    "This can reduce compute dramatically in diffusion simulations, but it is not an\n",
    "unconditional miss guarantee and cannot anticipate jumps. A production design\n",
    "would combine state-dependent polling with event-driven market-data triggers."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "539a3076",
   "metadata": {},
   "source": [
    "## 9. Summary of the series\n",
    "\n",
    "| Notebook | What you gained |\n",
    "|----------|-----------------|\n",
    "| 01 | Log-returns, Brownian motion, the $\\min(s,t)$ kernel, the $\\sqrt T$ law |\n",
    "| 02 | GBM, Itô's lemma, the $-\\tfrac12\\sigma^2$ correction, exact solution |\n",
    "| 03 | First-passage times, reflection principle, the \"$49\\sigma$\" reality check |\n",
    "| 04 | Brownian bridges, conditioning-as-projection, the miss formula |\n",
    "| 05 | The adaptive detector, jumps, the event-driven upgrade, the full answer |\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.14.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}