{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "a44bdc20",
   "metadata": {},
   "source": [
    "# Wolff vs. Metropolis: Algorithmic Efficiency in the Critical Regime\n",
    "\n",
    "Near a second-order phase transition, standard Metropolis-Hastings [[1]](#Bibliography) suffers from *critical slowing down*: the integrated autocorrelation time $\\tau_{\\mathrm{int}}$ grows as $\\tau_{\\mathrm{int}} \\sim L^z$, with a dynamic critical exponent $z \\approx 2.17$ for the 2D Ising model. Physically, successive spin configurations generated by single-site flips remain highly correlated for many steps because proposed flips within a large correlated domain are overwhelmingly rejected and the system cannot efficiently cross free-energy barriers by small local moves.\n",
    "\n",
    "The Wolff cluster algorithm [[2]](#Bibliography) eliminates this bottleneck directly. Rather than proposing a single-spin flip, Wolff grows a cluster from a random seed by probabilistically bonding same-sign nearest neighbours with probability $P_{\\mathrm{add}} = 1 - e^{-2\\beta J}$, then flips the entire cluster in one accepted collective move. The bond probability is derived from the Fortuin-Kasteleyn random-cluster representation [[3]](#Bibliography) and guarantees detailed balance without any rejections. The dynamic critical exponent drops to $z \\approx 0.25$, nearly an order of magnitude smaller than Metropolis.\n",
    "\n",
    "The practical benefit is regime-dependent. Far below $T_c$ the equilibrium state is a single near-spanning ferromagnetic domain; all grown clusters are system-spanning and flipping them merely reverses the global magnetization without decorrelating the configuration. Far above $T_c$ the correlation length is short and clusters are vanishingly small, so the BFS overhead dominates. The Wolff advantage is concentrated in the window $|T - T_c| \\lesssim 0.2\\,T_c$ where $\\xi$ is large but finite. For a comprehensive review of these methods, see Newman and Barkema [[4]](#Bibliography).\n",
    "\n",
    "## The normalisation problem\n",
    "\n",
    "A naive comparison of $\\tau_{\\mathrm{int}}$ step counts between the two algorithms is **misleading** because the algorithms do different amounts of physical work per recorded step:\n",
    "\n",
    "| Algorithm | Work per step |\n",
    "|-----------|---------------|\n",
    "| Metropolis (checkerboard) | $L^2$ single-spin flip *attempts* - one full lattice sweep |\n",
    "| Wolff cluster | 1 cluster flip of $\\langle C \\rangle$ spins - 100% acceptance rate |\n",
    "\n",
    "Counting raw steps treats a Wolff step at $T \\gg T_c$ (where $\\langle C \\rangle \\approx 1$ spin) as equivalent to a Metropolis step that touches all $L^2$ spins. This makes Wolff appear arbitrarily fast in the disordered phase for the wrong reason, and artificially slow below $T_c$ where clusters are nearly system-spanning. Neither conclusion reflects the actual computational cost.\n",
    "\n",
    "The standard fix is to express autocorrelation time in units of one $L^2$ flip-attempt sweep:\n",
    "$$\\tau^{\\mathrm{norm}}_{\\mathrm{metro}} = \\tau_{\\mathrm{steps}} \\qquad\\qquad \\tau^{\\mathrm{norm}}_{\\mathrm{Wolff}} = \\tau_{\\mathrm{steps}} \\times \\frac{\\langle C \\rangle}{L^2}$$\n",
    "\n",
    "where $\\langle C \\rangle$ is the mean cluster size measured from recorded per-step cluster sizes. After normalisation, both algorithms are on the same ruler: how many equivalent full-lattice sweep attempts are needed to decorrelate.\n",
    "\n",
    "This notebook therefore reports two complementary views:\n",
    "- **work-normalised $\\tau_{\\mathrm{int}}$** for fair cross-algorithm decorrelation-cost comparison,\n",
    "- **ISS in 1/s** (independent samples per second), which is unit-invariant under update-unit rescaling and therefore directly comparable without extra scaling."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "791b7d27",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-03-19T09:03:04.824074Z",
     "iopub.status.busy": "2026-03-19T09:03:04.822618Z",
     "iopub.status.idle": "2026-03-19T09:03:05.645480Z",
     "shell.execute_reply": "2026-03-19T09:03:05.641208Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Exact Onsager T_c = 2.269185\n"
     ]
    }
   ],
   "source": [
    "from __future__ import annotations\n",
    "\n",
    "import os\n",
    "import time\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "TC_ISING: float = 2.0 / np.log(1.0 + np.sqrt(2.0))\n",
    "PALETTE = {'metro': '#4878CF', 'wolff': '#D65F5F'}\n",
    "\n",
    "print(f'Exact Onsager T_c = {TC_ISING:.6f}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f964c4fb",
   "metadata": {},
   "source": [
    "## Load or compute data\n",
    "\n",
    "This notebook compares the independent-sample rate and autocorrelation structure of **checkerboard Metropolis** and Wolff dynamics across temperature. It first searches for precomputed measurements at `../results/ising/wolff_efficiency.npz`.\n",
    "\n",
    "When the cache file is present, the notebook loads robust summaries (median and 16–84% bands across seeds) and, when available, per-seed sample arrays for uncertainty-aware analysis. The same plotting code also supports legacy caches that only contain single-value arrays.\n",
    "\n",
    "When the cache file is absent, the notebook runs a small inline fallback (`L=16`, 8 temperature points, several seed replicas) so the workflow remains self-contained. This fallback is useful for validating analysis logic and plotting, but it is intentionally small and should be treated as demo quality.\n",
    "\n",
    "For publication-quality data, run:\n",
    "```bash\n",
    "python scripts/ising/wolff_efficiency.py --size 64 --t-points 20 --n-seeds 10 --meas-steps 2000\n",
    "```\n",
    "This stores both aggregate statistics and per-seed arrays in `../results/ising/wolff_efficiency.npz` for reuse on subsequent notebook runs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "97b4f505",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-03-19T09:03:05.649330Z",
     "iopub.status.busy": "2026-03-19T09:03:05.648999Z",
     "iopub.status.idle": "2026-03-19T09:03:05.678433Z",
     "shell.execute_reply": "2026-03-19T09:03:05.670657Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loaded pre-computed data: L=64, 20 temperature points, 10 seed replicas.\n"
     ]
    }
   ],
   "source": [
    "NPZ_PATH = '../results/ising/wolff_efficiency.npz'\n",
    "\n",
    "\n",
    "def _bands_from_samples(samples: np.ndarray) -> tuple[np.ndarray, np.ndarray, np.ndarray]:\n",
    "    med = np.nanmedian(samples, axis=1)\n",
    "    p16 = np.nanpercentile(samples, 16, axis=1)\n",
    "    p84 = np.nanpercentile(samples, 84, axis=1)\n",
    "    return med, p16, p84\n",
    "\n",
    "\n",
    "_cache_ok = False\n",
    "if os.path.exists(NPZ_PATH):\n",
    "    data = np.load(NPZ_PATH)\n",
    "    _required = {\n",
    "        'temperatures', 'tau_metro', 'tau_wolff',\n",
    "        'iss_metro', 'iss_wolff', 'mean_cluster_frac',\n",
    "        'chi_metro', 'chi_wolff', 'L',\n",
    "    }\n",
    "    if _required.issubset(set(data.files)):\n",
    "        temperatures = data['temperatures']\n",
    "        tau_metro = data['tau_metro']\n",
    "        tau_wolff = data['tau_wolff']\n",
    "        iss_metro = data['iss_metro']\n",
    "        iss_wolff = data['iss_wolff']\n",
    "        mean_cluster_frac = data['mean_cluster_frac']\n",
    "        chi_metro = data['chi_metro']\n",
    "        chi_wolff = data['chi_wolff']\n",
    "        L = int(data['L'])\n",
    "\n",
    "        have_samples = {\n",
    "            'tau_metro_samples', 'tau_wolff_samples',\n",
    "            'iss_metro_samples', 'iss_wolff_samples',\n",
    "            'mean_cluster_frac_samples',\n",
    "            'chi_metro_samples', 'chi_wolff_samples',\n",
    "        }.issubset(set(data.files))\n",
    "\n",
    "        if have_samples:\n",
    "            tau_metro_samples = data['tau_metro_samples']\n",
    "            tau_wolff_samples = data['tau_wolff_samples']\n",
    "            iss_metro_samples = data['iss_metro_samples']\n",
    "            iss_wolff_samples = data['iss_wolff_samples']\n",
    "            mean_cluster_frac_samples = data['mean_cluster_frac_samples']\n",
    "            chi_metro_samples = data['chi_metro_samples']\n",
    "            chi_wolff_samples = data['chi_wolff_samples']\n",
    "            n_seeds = int(data['n_seeds']) if 'n_seeds' in data.files else int(tau_metro_samples.shape[1])\n",
    "\n",
    "            tau_metro, tau_metro_p16, tau_metro_p84 = _bands_from_samples(tau_metro_samples)\n",
    "            tau_wolff, tau_wolff_p16, tau_wolff_p84 = _bands_from_samples(tau_wolff_samples)\n",
    "            iss_metro, iss_metro_p16, iss_metro_p84 = _bands_from_samples(iss_metro_samples)\n",
    "            iss_wolff, iss_wolff_p16, iss_wolff_p84 = _bands_from_samples(iss_wolff_samples)\n",
    "            mean_cluster_frac, mean_cluster_frac_p16, mean_cluster_frac_p84 = _bands_from_samples(mean_cluster_frac_samples)\n",
    "            chi_metro, chi_metro_p16, chi_metro_p84 = _bands_from_samples(chi_metro_samples)\n",
    "            chi_wolff, chi_wolff_p16, chi_wolff_p84 = _bands_from_samples(chi_wolff_samples)\n",
    "\n",
    "            print(\n",
    "                f'Loaded pre-computed data: L={L}, {len(temperatures)} temperature points, '\n",
    "                f'{n_seeds} seed replicas.'\n",
    "            )\n",
    "        else:\n",
    "            # Legacy cache compatibility: synthesize singleton sample dimension.\n",
    "            tau_metro_samples = tau_metro[:, None]\n",
    "            tau_wolff_samples = tau_wolff[:, None]\n",
    "            iss_metro_samples = iss_metro[:, None]\n",
    "            iss_wolff_samples = iss_wolff[:, None]\n",
    "            mean_cluster_frac_samples = mean_cluster_frac[:, None]\n",
    "            chi_metro_samples = chi_metro[:, None]\n",
    "            chi_wolff_samples = chi_wolff[:, None]\n",
    "            n_seeds = 1\n",
    "\n",
    "            tau_metro_p16 = tau_metro_p84 = tau_metro\n",
    "            tau_wolff_p16 = tau_wolff_p84 = tau_wolff\n",
    "            iss_metro_p16 = iss_metro_p84 = iss_metro\n",
    "            iss_wolff_p16 = iss_wolff_p84 = iss_wolff\n",
    "            mean_cluster_frac_p16 = mean_cluster_frac_p84 = mean_cluster_frac\n",
    "            chi_metro_p16 = chi_metro_p84 = chi_metro\n",
    "            chi_wolff_p16 = chi_wolff_p84 = chi_wolff\n",
    "\n",
    "            print(\n",
    "                f'Loaded legacy cache: L={L}, {len(temperatures)} temperature points, '\n",
    "                'no seed uncertainty arrays.'\n",
    "            )\n",
    "\n",
    "        _cache_ok = True\n",
    "    else:\n",
    "        print(f'Cache at {NPZ_PATH} is missing expected keys; running inline fallback.')\n",
    "\n",
    "if not _cache_ok:\n",
    "    print('Pre-computed data not found. Running inline demo (L=16, 8 T-points, 5 seeds, ~2–4 min)...')\n",
    "    from models.ising_model import IsingSimulation\n",
    "    from utils.exceptions import ZeroVarianceAutocorrelationError\n",
    "    from utils.physics_helpers import calculate_autocorr, calculate_thermodynamics\n",
    "    from utils.system_helpers import convergence_equilibrate\n",
    "\n",
    "    L = 16\n",
    "    temperatures = np.linspace(1.8, 3.2, 8)\n",
    "    EQ_CHUNK, EQ_MAX, MEAS = 100, 10000, 500\n",
    "    n_seeds = 5\n",
    "    n_temp = len(temperatures)\n",
    "\n",
    "    tau_metro_samples = np.full((n_temp, n_seeds), np.nan)\n",
    "    tau_wolff_samples = np.full((n_temp, n_seeds), np.nan)\n",
    "    iss_metro_samples = np.full((n_temp, n_seeds), np.nan)\n",
    "    iss_wolff_samples = np.full((n_temp, n_seeds), np.nan)\n",
    "    mean_cluster_frac_samples = np.full((n_temp, n_seeds), np.nan)\n",
    "    chi_metro_samples = np.full((n_temp, n_seeds), np.nan)\n",
    "    chi_wolff_samples = np.full((n_temp, n_seeds), np.nan)\n",
    "\n",
    "    for i, T in enumerate(temperatures):\n",
    "        for s in range(n_seeds):\n",
    "            base_seed = i * 1000 + s * 50\n",
    "\n",
    "            # -- Metropolis (checkerboard) --\n",
    "            sim_m_r = IsingSimulation(size=L, temp=T, update='checkerboard', init_state='random', seed=base_seed)\n",
    "            sim_m_o = IsingSimulation(size=L, temp=T, update='checkerboard', init_state='ordered', seed=base_seed)\n",
    "            convergence_equilibrate(sim_m_r, sim_m_o, chunk_size=EQ_CHUNK, max_steps=EQ_MAX)\n",
    "\n",
    "            t0 = time.perf_counter()\n",
    "            mags_m, engs_m = sim_m_r.run(n_steps=MEAS)\n",
    "            t_m = time.perf_counter() - t0\n",
    "            mags_m_a = np.array(mags_m)\n",
    "            try:\n",
    "                _, tau_m = calculate_autocorr(time_series=mags_m_a)\n",
    "            except (ZeroVarianceAutocorrelationError, ValueError):\n",
    "                tau_m = float('nan')\n",
    "            _, _, chi_m, _ = calculate_thermodynamics(\n",
    "                mags=mags_m_a, engs=np.array(engs_m), T=T, L=L,\n",
    "            )\n",
    "            iss_m = (MEAS / t_m) / tau_m if np.isfinite(tau_m) and tau_m > 0 else float('nan')\n",
    "\n",
    "            # -- Wolff --\n",
    "            sim_w_r = IsingSimulation(size=L, temp=T, update='wolff', init_state='random', seed=base_seed + 1)\n",
    "            sim_w_o = IsingSimulation(size=L, temp=T, update='wolff', init_state='ordered', seed=base_seed + 1)\n",
    "            convergence_equilibrate(sim_w_r, sim_w_o, chunk_size=EQ_CHUNK, max_steps=EQ_MAX)\n",
    "\n",
    "            t0 = time.perf_counter()\n",
    "            mags_w, engs_w = sim_w_r.run(n_steps=MEAS)\n",
    "            t_w = time.perf_counter() - t0\n",
    "            mags_w_a = np.array(mags_w)\n",
    "            try:\n",
    "                _, tau_w = calculate_autocorr(time_series=mags_w_a)\n",
    "            except (ZeroVarianceAutocorrelationError, ValueError):\n",
    "                tau_w = float('nan')\n",
    "            _, _, chi_w, _ = calculate_thermodynamics(\n",
    "                mags=mags_w_a, engs=np.array(engs_w), T=T, L=L,\n",
    "            )\n",
    "            iss_w = (MEAS / t_w) / tau_w if np.isfinite(tau_w) and tau_w > 0 else float('nan')\n",
    "\n",
    "            # -- Cluster sizes --\n",
    "            _, _, cluster_sizes_arr = sim_w_r.run_with_cluster_sizes(n_steps=min(MEAS, 300))\n",
    "            cfrac = float(np.mean(cluster_sizes_arr)) / (L * L)\n",
    "\n",
    "            tau_metro_samples[i, s] = tau_m\n",
    "            tau_wolff_samples[i, s] = tau_w\n",
    "            iss_metro_samples[i, s] = iss_m\n",
    "            iss_wolff_samples[i, s] = iss_w\n",
    "            mean_cluster_frac_samples[i, s] = cfrac\n",
    "            chi_metro_samples[i, s] = chi_m\n",
    "            chi_wolff_samples[i, s] = chi_w\n",
    "\n",
    "        print(f'  T={T:.2f} complete ({n_seeds} seeds)', flush=True)\n",
    "\n",
    "    tau_metro, tau_metro_p16, tau_metro_p84 = _bands_from_samples(tau_metro_samples)\n",
    "    tau_wolff, tau_wolff_p16, tau_wolff_p84 = _bands_from_samples(tau_wolff_samples)\n",
    "    iss_metro, iss_metro_p16, iss_metro_p84 = _bands_from_samples(iss_metro_samples)\n",
    "    iss_wolff, iss_wolff_p16, iss_wolff_p84 = _bands_from_samples(iss_wolff_samples)\n",
    "    mean_cluster_frac, mean_cluster_frac_p16, mean_cluster_frac_p84 = _bands_from_samples(mean_cluster_frac_samples)\n",
    "    chi_metro, chi_metro_p16, chi_metro_p84 = _bands_from_samples(chi_metro_samples)\n",
    "    chi_wolff, chi_wolff_p16, chi_wolff_p84 = _bands_from_samples(chi_wolff_samples)\n",
    "    print('Inline fallback complete.')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1aa20250",
   "metadata": {},
   "source": [
    "## Work normalisation\n",
    "\n",
    "Raw `tau_wolff` values count Wolff cluster updates, not full-lattice sweep equivalents. Before comparing dynamics, we convert both algorithms to the same work unit: one $L^2$-flip-attempt sweep.\n",
    "\n",
    "Metropolis (checkerboard) already touches $L^2$ spins per step, so:\n",
    "$$\\tau^{\\mathrm{norm}}_{\\mathrm{metro}} = \\tau_{\\mathrm{metro}}.$$\n",
    "\n",
    "Wolff touches $\\langle C \\rangle$ spins per step, so:\n",
    "$$\\tau^{\\mathrm{norm}}_{\\mathrm{Wolff}} = \\tau_{\\mathrm{Wolff}} \\times \\frac{\\langle C \\rangle}{L^2}.$$\n",
    "\n",
    "The cluster fraction $\\langle C \\rangle / L^2$ is measured directly from per-step cluster sizes (`run_with_cluster_sizes`), not inferred from a proxy.\n",
    "\n",
    "### Why ISS itself is unit-invariant\n",
    "\n",
    "ISS has units of inverse time (independent samples per second):\n",
    "$$\\mathrm{ISS} = \\frac{r_u}{\\tau_u}.$$\n",
    "Here $r_u$ is the update rate (updates per second) and $\\tau_u$ is the autocorrelation time measured in the same update unit $u$.\n",
    "\n",
    "If we rescale the update unit by a factor $a$, then $r_{u'} = r_u / a$ and $\\tau_{u'} = a\\,\\tau_u$. Their product is unchanged, so ISS is invariant under this conversion.\n",
    "\n",
    "So in this notebook:\n",
    "- we **normalise $\\tau$ explicitly** for algorithm-comparison plots,\n",
    "- and we keep ISS numerically unchanged (but report uncertainty bands across seeds)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "3a672bca",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "L = 64,  N = L² = 4096,  seed replicas = 10\n",
      "\n",
      "Mean cluster size fraction <C>/L² per temperature (median [16th,84th]):\n",
      "  T = 1.800:  0.9103 [0.9026, 0.9215]  (<C> ≈ 3728.7 spins)\n",
      "  T = 1.874:  0.8995 [0.8867, 0.9030]  (<C> ≈ 3684.2 spins)\n",
      "  T = 1.947:  0.8620 [0.8435, 0.8759]  (<C> ≈ 3530.7 spins)\n",
      "  T = 2.021:  0.8211 [0.7984, 0.8377]  (<C> ≈ 3363.4 spins)\n",
      "  T = 2.095:  0.7514 [0.7441, 0.7708]  (<C> ≈ 3077.6 spins)\n",
      "  T = 2.168:  0.6742 [0.6513, 0.6893]  (<C> ≈ 2761.6 spins)\n",
      "  T = 2.242:  0.5008 [0.4696, 0.5246]  (<C> ≈ 2051.3 spins)\n",
      "  T = 2.316:  0.1607 [0.1418, 0.1831]  (<C> ≈ 658.1 spins)\n",
      "  T = 2.389:  0.0483 [0.0418, 0.0508]  (<C> ≈ 197.6 spins)\n",
      "  T = 2.463:  0.0212 [0.0170, 0.0231]  (<C> ≈ 86.6 spins)\n",
      "  T = 2.537:  0.0114 [0.0103, 0.0129]  (<C> ≈ 46.7 spins)\n",
      "  T = 2.611:  0.0069 [0.0065, 0.0085]  (<C> ≈ 28.4 spins)\n",
      "  T = 2.684:  0.0053 [0.0047, 0.0062]  (<C> ≈ 21.6 spins)\n",
      "  T = 2.758:  0.0037 [0.0034, 0.0043]  (<C> ≈ 15.3 spins)\n",
      "  T = 2.832:  0.0034 [0.0031, 0.0038]  (<C> ≈ 13.8 spins)\n",
      "  T = 2.905:  0.0028 [0.0025, 0.0031]  (<C> ≈ 11.5 spins)\n",
      "  T = 2.979:  0.0025 [0.0023, 0.0028]  (<C> ≈ 10.2 spins)\n",
      "  T = 3.053:  0.0021 [0.0019, 0.0022]  (<C> ≈ 8.6 spins)\n",
      "  T = 3.126:  0.0021 [0.0018, 0.0022]  (<C> ≈ 8.5 spins)\n",
      "  T = 3.200:  0.0017 [0.0016, 0.0019]  (<C> ≈ 7.2 spins)\n",
      "\n",
      "Work-normalised tau_int (L²-sweep equivalents), median [16th,84th]:\n",
      "       T            tau_metro_norm            tau_wolff_norm\n",
      "   1.800     1.140 [  1.074,   1.275]     0.697 [  0.639,   0.752]\n",
      "   1.874     1.781 [  1.353,   1.909]     0.723 [  0.683,   0.798]\n",
      "   1.947     1.906 [  1.756,   2.392]     0.723 [  0.673,   0.788]\n",
      "   2.021     3.155 [  2.561,   4.014]     0.814 [  0.782,   0.908]\n",
      "   2.095     5.771 [  4.626,   8.905]     0.882 [  0.819,   0.978]\n",
      "   2.168     8.120 [  6.866,   9.234]     1.032 [  0.923,   1.211]\n",
      "   2.242    37.198 [ 25.955,  59.747]     1.413 [  1.208,   1.583]\n",
      "   2.316    72.022 [ 48.216, 130.542]     0.683 [  0.522,   0.819]\n",
      "   2.389    31.058 [ 21.481,  41.720]     0.157 [  0.119,   0.193]\n",
      "   2.463    14.602 [ 11.395,  22.412]     0.098 [  0.070,   0.140]\n",
      "   2.537     9.087 [  7.670,  10.939]     0.073 [  0.062,   0.091]\n",
      "   2.611     5.687 [  5.108,   7.665]     0.071 [  0.057,   0.091]\n",
      "   2.684     4.486 [  3.195,   5.066]     0.084 [  0.051,   0.099]\n",
      "   2.758     3.135 [  2.716,   3.487]     0.076 [  0.050,   0.128]\n",
      "   2.832     2.459 [  2.211,   2.892]     0.067 [  0.058,   0.087]\n",
      "   2.905     2.294 [  2.035,   2.726]     0.071 [  0.057,   0.084]\n",
      "   2.979     1.736 [  1.541,   1.974]     0.061 [  0.035,   0.098]\n",
      "   3.053     1.553 [  1.333,   1.791]     0.057 [  0.041,   0.071]\n",
      "   3.126     1.409 [  1.269,   1.495]     0.066 [  0.041,   0.094]\n",
      "   3.200     1.319 [  1.183,   1.452]     0.062 [  0.038,   0.078]\n"
     ]
    }
   ],
   "source": [
    "# Work-normalisation: convert tau to L²-sweep equivalents.\n",
    "# mean_cluster_frac = <C> / L²  (recorded per-step from run_with_cluster_sizes)\n",
    "L2 = L * L\n",
    "\n",
    "# Median normalised autocorrelation times\n",
    "tau_metro_norm = tau_metro\n",
    "tau_wolff_norm = tau_wolff * mean_cluster_frac\n",
    "\n",
    "# Seed-level normalised tau for uncertainty propagation\n",
    "tau_metro_norm_samples = tau_metro_samples\n",
    "tau_wolff_norm_samples = tau_wolff_samples * mean_cluster_frac_samples\n",
    "\n",
    "def _bands(samples: np.ndarray) -> tuple[np.ndarray, np.ndarray, np.ndarray]:\n",
    "    med = np.nanmedian(samples, axis=1)\n",
    "    p16 = np.nanpercentile(samples, 16, axis=1)\n",
    "    p84 = np.nanpercentile(samples, 84, axis=1)\n",
    "    return med, p16, p84\n",
    "\n",
    "tau_metro_norm, tau_metro_norm_p16, tau_metro_norm_p84 = _bands(tau_metro_norm_samples)\n",
    "tau_wolff_norm, tau_wolff_norm_p16, tau_wolff_norm_p84 = _bands(tau_wolff_norm_samples)\n",
    "\n",
    "# ISS is unit-invariant under update-unit rescaling, so keep values unchanged.\n",
    "iss_metro_norm = iss_metro\n",
    "iss_wolff_norm = iss_wolff\n",
    "iss_metro_norm_samples = iss_metro_samples\n",
    "iss_wolff_norm_samples = iss_wolff_samples\n",
    "iss_metro_norm, iss_metro_norm_p16, iss_metro_norm_p84 = _bands(iss_metro_norm_samples)\n",
    "iss_wolff_norm, iss_wolff_norm_p16, iss_wolff_norm_p84 = _bands(iss_wolff_norm_samples)\n",
    "\n",
    "print(f'L = {L},  N = L² = {L2},  seed replicas = {n_seeds}')\n",
    "print('\\nMean cluster size fraction <C>/L² per temperature (median [16th,84th]):')\n",
    "for T, c, c16, c84 in zip(temperatures, mean_cluster_frac, mean_cluster_frac_p16, mean_cluster_frac_p84):\n",
    "    print(f'  T = {T:.3f}:  {c:.4f} [{c16:.4f}, {c84:.4f}]  (<C> ≈ {c * L2:.1f} spins)')\n",
    "\n",
    "print('\\nWork-normalised tau_int (L²-sweep equivalents), median [16th,84th]:')\n",
    "hdr = f'  {\"T\":>6}  {\"tau_metro_norm\":>24}  {\"tau_wolff_norm\":>24}'\n",
    "print(hdr)\n",
    "for T, tm, tm16, tm84, tw, tw16, tw84 in zip(\n",
    "    temperatures,\n",
    "    tau_metro_norm, tau_metro_norm_p16, tau_metro_norm_p84,\n",
    "    tau_wolff_norm, tau_wolff_norm_p16, tau_wolff_norm_p84,\n",
    "):\n",
    "    print(\n",
    "        f'  {T:>6.3f}  '\n",
    "        f'{tm:>8.3f} [{tm16:>7.3f}, {tm84:>7.3f}]  '\n",
    "        f'{tw:>8.3f} [{tw16:>7.3f}, {tw84:>7.3f}]'\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "025e29a6",
   "metadata": {},
   "source": [
    "## Four-panel overview\n",
    "\n",
    "The four panels show the efficiency landscape across temperature using **median values with 16–84% uncertainty bands** from seed replicas.\n",
    "\n",
    "**Top-left — $\\tau^{\\mathrm{norm}}_{\\mathrm{int}}(T)$:** Autocorrelation times in $L^2$-sweep equivalents. This is the correct work-comparable view of decorrelation cost. Metropolis peaks sharply near $T_c$ (critical slowing down), while Wolff remains much lower.\n",
    "\n",
    "**Top-right — $\\mathrm{ISS}(T)$ (log scale):** Independent samples per second with seed-uncertainty bands. ISS is unit-invariant under update-unit rescaling, so values are unchanged by the $\\tau$ normalisation step. The log axis exposes both crossover structure and order-of-magnitude separations.\n",
    "\n",
    "**Bottom-left — $\\langle C \\rangle / L^2(T)$:** Mean cluster-size fraction (with uncertainty). This is the Wolff work-normalisation factor and the physical mechanism behind reduced critical slowing down.\n",
    "\n",
    "**Bottom-right — $\\chi(T)$:** Susceptibility agreement between algorithms (with uncertainty). Agreement confirms both updates sample the same equilibrium distribution; systematic disagreement would indicate a correctness issue."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "02a0532f",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-03-19T09:03:05.681833Z",
     "iopub.status.busy": "2026-03-19T09:03:05.681585Z",
     "iopub.status.idle": "2026-03-19T09:03:06.625651Z",
     "shell.execute_reply": "2026-03-19T09:03:06.621509Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1100x800 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axes = plt.subplots(2, 2, figsize=(11, 8))\n",
    "fig.suptitle(\n",
    "    f'Wolff vs. Metropolis Efficiency — 2D Ising Model  (L = {L}, seeds = {n_seeds})', fontsize=13,\n",
    ")\n",
    "\n",
    "# tau_int_norm(T) — work-normalised, L²-sweep equivalents\n",
    "ax = axes[0, 0]\n",
    "ax.semilogy(temperatures, tau_metro_norm, '-o', color=PALETTE['metro'], ms=4, label='Metropolis')\n",
    "ax.semilogy(temperatures, tau_wolff_norm, '-s', color=PALETTE['wolff'], ms=4, label='Wolff (normalised)')\n",
    "ax.fill_between(temperatures, tau_metro_norm_p16, tau_metro_norm_p84, color=PALETTE['metro'], alpha=0.15)\n",
    "ax.fill_between(temperatures, tau_wolff_norm_p16, tau_wolff_norm_p84, color=PALETTE['wolff'], alpha=0.15)\n",
    "ax.axvline(TC_ISING, color='0.4', ls='--', lw=1, label=r'$T_c$')\n",
    "ax.set_xlabel('Temperature $T$')\n",
    "ax.set_ylabel(r'$\\tau^{\\mathrm{norm}}_{\\mathrm{int}}$ ($L^2$-sweep equiv.)')\n",
    "ax.set_title('Integrated autocorrelation time\\n(work-normalised; median with 16–84% band)')\n",
    "ax.legend(fontsize=8)\n",
    "\n",
    "# ISS(T) — unit-invariant under update-unit conversion; log scale improves readability\n",
    "ax = axes[0, 1]\n",
    "ax.semilogy(temperatures, iss_metro_norm, '-o', color=PALETTE['metro'], ms=4, label='Metropolis')\n",
    "ax.semilogy(temperatures, iss_wolff_norm, '-s', color=PALETTE['wolff'], ms=4, label='Wolff')\n",
    "ax.fill_between(temperatures, iss_metro_norm_p16, iss_metro_norm_p84, color=PALETTE['metro'], alpha=0.15)\n",
    "ax.fill_between(temperatures, iss_wolff_norm_p16, iss_wolff_norm_p84, color=PALETTE['wolff'], alpha=0.15)\n",
    "ax.axvline(TC_ISING, color='0.4', ls='--', lw=1, label=r'$T_c$')\n",
    "ax.set_xlabel('Temperature $T$')\n",
    "ax.set_ylabel('Independent samples / s')\n",
    "ax.set_title('Sampling efficiency ISS\\n(median with 16–84% band)')\n",
    "ax.legend(fontsize=8)\n",
    "\n",
    "# mean cluster size fraction — normalisation factor\n",
    "ax = axes[1, 0]\n",
    "ax.plot(temperatures, mean_cluster_frac, '-^', color=PALETTE['wolff'], ms=4)\n",
    "ax.fill_between(temperatures, mean_cluster_frac_p16, mean_cluster_frac_p84, color=PALETTE['wolff'], alpha=0.15)\n",
    "ax.axvline(TC_ISING, color='0.4', ls='--', lw=1, label=r'$T_c$')\n",
    "ax.set_xlabel('Temperature $T$')\n",
    "ax.set_ylabel(r'$\\langle C \\rangle \\,/\\, L^2$')\n",
    "ax.set_title(r'Mean cluster size fraction (Wolff)' + '\\n' + r'= normalisation factor $\\langle C\\rangle/L^2$')\n",
    "ax.legend(fontsize=8)\n",
    "\n",
    "# chi consistency\n",
    "ax = axes[1, 1]\n",
    "ax.plot(temperatures, chi_metro, '-o', color=PALETTE['metro'], ms=4, label='Metropolis')\n",
    "ax.plot(temperatures, chi_wolff, '-s', color=PALETTE['wolff'], ms=4, label='Wolff')\n",
    "ax.fill_between(temperatures, chi_metro_p16, chi_metro_p84, color=PALETTE['metro'], alpha=0.15)\n",
    "ax.fill_between(temperatures, chi_wolff_p16, chi_wolff_p84, color=PALETTE['wolff'], alpha=0.15)\n",
    "ax.axvline(TC_ISING, color='0.4', ls='--', lw=1, label=r'$T_c$')\n",
    "ax.set_xlabel('Temperature $T$')\n",
    "ax.set_ylabel(r'$\\chi$')\n",
    "ax.set_title(r'Susceptibility (agreement validates correctness)')\n",
    "ax.legend(fontsize=8)\n",
    "\n",
    "fig.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "28b88a92",
   "metadata": {},
   "source": [
    "The four panels now combine two complementary quality dimensions: physically consistent work normalisation for $\\tau_{\\mathrm{int}}$ and seed-level uncertainty reporting (median with 16–84% bands) for all plotted observables. The top-left panel compares decorrelation cost in equivalent sweep units; the top-right panel reports ISS directly in 1/s, which is invariant under update-unit rescaling. The bottom-left panel shows the normalisation factor $\\langle C \\rangle / L^2$, and the bottom-right panel verifies equilibrium consistency through susceptibility agreement."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eb31308e",
   "metadata": {},
   "source": [
    "## ISS improvement factor at three characteristic temperatures\n",
    "\n",
    "The bar chart below extracts\n",
    "$$\\mathrm{ISS}_{\\mathrm{Wolff}} / \\mathrm{ISS}_{\\mathrm{Metropolis}}$$\n",
    "at three temperatures: $T_c - 0.4$, $T_c$, and $T_c + 0.4$.\n",
    "\n",
    "To keep the panel fully consistent with the four-panel ISS plot, **bar heights are computed as the ratio of the same median ISS curves** shown in the top-right panel:\n",
    "$$\\text{bar height} = \\frac{\\mathrm{median}(\\mathrm{ISS}_{\\mathrm{Wolff}})}{\\mathrm{median}(\\mathrm{ISS}_{\\mathrm{Metropolis}})}.$$\n",
    "\n",
    "Error bars are estimated by paired bootstrap resampling of seed replicas (16th-84th percentile of the bootstrap ratio distribution). This keeps uncertainty transparent without changing the panel's central statistic."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "86fe6f13",
   "metadata": {},
   "source": [
    "### Reading the three-temperature ISS bars\n",
    "\n",
    "Bars report the same center statistic as the four-panel ISS curves: the ratio of medians,\n",
    "$$\\frac{\\mathrm{median}(\\mathrm{ISS}_{\\mathrm{Wolff}})}{\\mathrm{median}(\\mathrm{ISS}_{\\mathrm{Metropolis}})}.$$ \n",
    "\n",
    "Error bars are the 16th-84th percentile interval from paired bootstrap resampling of seed replicas (ratio-of-medians per resample). Values above 1 indicate Wolff yields more independent samples per second; values below 1 indicate Metropolis is more efficient at that temperature."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "dd27ce84",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-03-19T09:03:06.631436Z",
     "iopub.status.busy": "2026-03-19T09:03:06.631110Z",
     "iopub.status.idle": "2026-03-19T09:03:06.923604Z",
     "shell.execute_reply": "2026-03-19T09:03:06.922456Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 720x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Context at selected temperatures (median values):\n",
      "     T     <C>/L^2    tau_m_norm    tau_w_norm       ISS_m       ISS_w     ratio\n",
      " 1.874      0.8995        1.7808        0.7228     5182.24     2174.23     0.420\n",
      " 2.242      0.5008       37.1980        1.4129      105.47      987.58     9.364\n",
      " 2.684      0.0053        4.4861        0.0843      776.57      982.05     1.265\n"
     ]
    }
   ],
   "source": [
    "t_targets = [TC_ISING - 0.4, TC_ISING, TC_ISING + 0.4]\n",
    "bar_labels = [\n",
    "    f'$T_c - 0.4$\\n$T = {t_targets[0]:.2f}$',\n",
    "    f'$T_c$\\n$T = {t_targets[1]:.2f}$',\n",
    "    f'$T_c + 0.4$\\n$T = {t_targets[2]:.2f}$',\n",
    "]\n",
    "bar_colors = ['#7fc97f', PALETTE['wolff'], '#7fc97f']\n",
    "\n",
    "ratio_med = []\n",
    "ratio_p16 = []\n",
    "ratio_p84 = []\n",
    "context_rows = []\n",
    "rng = np.random.default_rng(12345)\n",
    "\n",
    "for Tt in t_targets:\n",
    "    idx = int(np.argmin(np.abs(temperatures - Tt)))\n",
    "\n",
    "    # Center statistic: ratio of medians (matches the four-panel ISS curves).\n",
    "    med_ratio = float(iss_wolff_norm[idx] / iss_metro_norm[idx])\n",
    "\n",
    "    # Uncertainty: paired bootstrap over seed replicas of the ratio-of-medians.\n",
    "    m_samples = iss_metro_norm_samples[idx]\n",
    "    w_samples = iss_wolff_norm_samples[idx]\n",
    "    valid = np.isfinite(m_samples) & np.isfinite(w_samples) & (m_samples > 0)\n",
    "    m_valid = m_samples[valid]\n",
    "    w_valid = w_samples[valid]\n",
    "\n",
    "    if len(m_valid) >= 2:\n",
    "        n_boot = 2000\n",
    "        boot = np.empty(n_boot, dtype=float)\n",
    "        n = len(m_valid)\n",
    "        for b in range(n_boot):\n",
    "            pick = rng.integers(0, n, size=n)\n",
    "            m_med = np.nanmedian(m_valid[pick])\n",
    "            w_med = np.nanmedian(w_valid[pick])\n",
    "            boot[b] = w_med / m_med if np.isfinite(m_med) and m_med > 0 else np.nan\n",
    "        boot = boot[np.isfinite(boot)]\n",
    "        if boot.size:\n",
    "            p16 = float(np.nanpercentile(boot, 16))\n",
    "            p84 = float(np.nanpercentile(boot, 84))\n",
    "        else:\n",
    "            p16 = med_ratio\n",
    "            p84 = med_ratio\n",
    "    else:\n",
    "        p16 = med_ratio\n",
    "        p84 = med_ratio\n",
    "\n",
    "    ratio_med.append(med_ratio)\n",
    "    ratio_p16.append(p16)\n",
    "    ratio_p84.append(p84)\n",
    "\n",
    "    context_rows.append({\n",
    "        'T': float(temperatures[idx]),\n",
    "        'tau_m_norm': float(tau_metro_norm[idx]),\n",
    "        'tau_w_norm': float(tau_wolff_norm[idx]),\n",
    "        'iss_m': float(iss_metro_norm[idx]),\n",
    "        'iss_w': float(iss_wolff_norm[idx]),\n",
    "        'cfrac': float(mean_cluster_frac[idx]),\n",
    "    })\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(7.2, 4.8))\n",
    "x = np.arange(len(bar_labels))\n",
    "vals = np.array(ratio_med)\n",
    "err_low = np.clip(vals - np.array(ratio_p16), 0, None)\n",
    "err_high = np.clip(np.array(ratio_p84) - vals, 0, None)\n",
    "yerr = np.vstack([err_low, err_high])\n",
    "\n",
    "bars = ax.bar(\n",
    "    x,\n",
    "    vals,\n",
    "    yerr=yerr,\n",
    "    color=bar_colors,\n",
    "    width=0.45,\n",
    "    zorder=2,\n",
    "    edgecolor='0.3',\n",
    "    capsize=4,\n",
    ")\n",
    "ax.set_xticks(x)\n",
    "ax.set_xticklabels(bar_labels)\n",
    "ax.axhline(1.0, color='0.35', ls='--', lw=1.2, label='Break-even (ratio = 1)')\n",
    "ax.set_ylabel(r'$\\mathrm{ISS}_{\\mathrm{Wolff}}\\;/\\;\\mathrm{ISS}_{\\mathrm{Metropolis}}$', fontsize=12)\n",
    "ax.set_title('ISS Improvement Factor\\n(ratio of median ISS curves; 16th-84th bootstrap interval)', fontsize=11)\n",
    "ax.legend(fontsize=9)\n",
    "ax.grid(axis='y', alpha=0.35, zorder=0)\n",
    "\n",
    "finite_vals = [v for v in vals if np.isfinite(v)]\n",
    "if finite_vals:\n",
    "    ax.set_ylim(0, max(finite_vals) * 1.35 + 0.3)\n",
    "\n",
    "for bar, val in zip(bars, vals):\n",
    "    if np.isfinite(val):\n",
    "        ax.text(\n",
    "            bar.get_x() + bar.get_width() / 2,\n",
    "            bar.get_height() + 0.05,\n",
    "            f'{val:.2f}x',\n",
    "            ha='center',\n",
    "            va='bottom',\n",
    "            fontsize=11,\n",
    "            fontweight='bold',\n",
    "        )\n",
    "\n",
    "fig.tight_layout()\n",
    "plt.show()\n",
    "\n",
    "print('\\nContext at selected temperatures (median values):')\n",
    "print(f'{\"T\":>6}  {\"<C>/L^2\":>10}  {\"tau_m_norm\":>12}  {\"tau_w_norm\":>12}  {\"ISS_m\":>10}  {\"ISS_w\":>10}  {\"ratio\":>8}')\n",
    "for row, ratio in zip(context_rows, vals):\n",
    "    print(\n",
    "        f\"{row['T']:>6.3f}  {row['cfrac']:>10.4f}  {row['tau_m_norm']:>12.4f}  {row['tau_w_norm']:>12.4f}  \"\n",
    "        f\"{row['iss_m']:>10.2f}  {row['iss_w']:>10.2f}  {ratio:>8.3f}\"\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a01c171d",
   "metadata": {},
   "source": [
    "## When to use Wolff\n",
    "\n",
    "The uncertainty-aware ISS results above translate directly into the algorithm selection rule documented in `AGENTS.md`.\n",
    "\n",
    "**Use `update='wolff'`** for equilibrium studies near criticality (roughly within 20% of $T_c$): finite-size scaling around susceptibility peaks, Binder-cumulant crossing analyses, or critical-exponent measurements. In this regime, the work-normalised $\\tau_{\\mathrm{int}}$ is much smaller for Wolff, and the higher ISS directly reduces statistical error at fixed wall time.\n",
    "\n",
    "**Use `update='checkerboard'`** sufficiently far from $T_c$ when the ISS curves indicate no Wolff advantage. The checkerboard kernel is highly efficient for local updates, and at some temperatures the cluster overhead offsets Wolff's decorrelation gain.\n",
    "\n",
    "**Core comparability rule:** never compare raw $\\tau_{\\mathrm{int}}$ step counts across algorithms. Always compare $\\tau$ in common work units (here, $L^2$-sweep equivalents). ISS can be compared directly in 1/s and is shown with seed uncertainty bands.\n",
    "\n",
    "**For kinetics studies**, avoid both checkerboard and Wolff: use `update='random'` to preserve the intended non-equilibrium Glauber-like dynamics.\n",
    "\n",
    "For theoretical background — FK representation, cluster updates, and bond-addition probability derivation — see `PHYSICS.md`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bibliography-section",
   "metadata": {},
   "source": [
    "## Bibliography\n",
    "\n",
    "[[1]](#Bibliography) W. K. Hastings, \"Monte Carlo sampling methods using Markov chains and their applications,\" *Biometrika*, vol. 57, no. 1, pp. 97–109, 1970. [Oxford Academic](https://academic.oup.com/biomet/article/57/1/97/252073)\n",
    "\n",
    "[[2]](#Bibliography) U. Wolff, \"Collective Monte Carlo Updating for Spin Systems,\" *Physical Review Letters*, vol. 62, no. 4, pp. 361–364, 1989. [APS Open Access](https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.62.361)\n",
    "\n",
    "[[3]](#Bibliography) C. M. Fortuin and P. W. Kasteleyn, \"On the random-cluster model. I. Introduction and relation to other models,\" *Physica*, vol. 57, no. 4, pp. 536–564, 1972. [Elsevier Open Access](https://doi.org/10.1016/0031-8914(72)90045-6)\n",
    "\n",
    "[[4]](#Bibliography) M. E. J. Newman and G. T. Barkema, \"Monte Carlo Methods in Statistical Physics,\" Oxford University Press, 1999. [Lecture Notes Summary (H. G. Katzgraber)](https://arxiv.org/abs/0905.1629)\n",
    "\n",
    "[[5]](#Bibliography) A. D. Sokal, \"Monte Carlo Methods in Statistical Mechanics: Foundations and New Algorithms,\" lecture notes (1989), published in *Functional Integration: Basics and Applications* (C. DeWitt-Morette, P. Cartier, A. Folacci, eds.), Springer, 1997, pp. 131–192. Standard reference for the integrated autocorrelation time and the automatic windowing estimator. [Springer Link](https://link.springer.com/chapter/10.1007/978-1-4899-0319-8_6)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv (3.12.12)",
   "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.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}