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-07-31T19:07:08.628200Z",
     "iopub.status.busy": "2026-07-31T19:07:08.627976Z",
     "iopub.status.idle": "2026-07-31T19:07:09.437317Z",
     "shell.execute_reply": "2026-07-31T19:07:09.436468Z"
    }
   },
   "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-07-31T19:07:09.439404Z",
     "iopub.status.busy": "2026-07-31T19:07:09.439105Z",
     "iopub.status.idle": "2026-07-31T19:07:09.443641Z",
     "shell.execute_reply": "2026-07-31T19:07:09.443107Z"
    }
   },
   "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-07-31T19:07:09.445012Z",
     "iopub.status.busy": "2026-07-31T19:07:09.444898Z",
     "iopub.status.idle": "2026-07-31T19:07:10.294913Z",
     "shell.execute_reply": "2026-07-31T19:07:10.294147Z"
    }
   },
   "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-07-31T19:07:10.296823Z",
     "iopub.status.busy": "2026-07-31T19:07:10.296692Z",
     "iopub.status.idle": "2026-07-31T19:07:10.345988Z",
     "shell.execute_reply": "2026-07-31T19:07:10.345358Z"
    }
   },
   "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-07-31T19:07:10.347583Z",
     "iopub.status.busy": "2026-07-31T19:07:10.347459Z",
     "iopub.status.idle": "2026-07-31T19:07:11.014653Z",
     "shell.execute_reply": "2026-07-31T19:07:11.014018Z"
    }
   },
   "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-07-31T19:07:11.016201Z",
     "iopub.status.busy": "2026-07-31T19:07:11.016094Z",
     "iopub.status.idle": "2026-07-31T19:07:11.668833Z",
     "shell.execute_reply": "2026-07-31T19:07:11.668228Z"
    }
   },
   "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-07-31T19:07:11.670279Z",
     "iopub.status.busy": "2026-07-31T19:07:11.670157Z",
     "iopub.status.idle": "2026-07-31T19:07:15.071932Z",
     "shell.execute_reply": "2026-07-31T19:07:15.071287Z"
    }
   },
   "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": 1,
   "id": "fe7e9476",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-31T19:07:15.076626Z",
     "iopub.status.busy": "2026-07-31T19:07:15.076482Z",
     "iopub.status.idle": "2026-07-31T19:07:15.083797Z",
     "shell.execute_reply": "2026-07-31T19:07:15.083266Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Optional market-data scan unavailable; continuing without it.\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
}