Dynamical Critical Exponents in the 2D Ising Model

Critical slowing down makes equilibrium sampling progressively harder as a continuous transition is approached. At the Onsager point \(T_c = 2/\ln(1+\sqrt{2})\) [1], the integrated autocorrelation time of the magnetization of a finite lattice scales as

\[\tau_{\mathrm{int}}(L) \propto L^z,\]

so the dynamical critical exponent \(z\) quantifies how fast the decorrelation cost grows with lattice size [3].

This notebook compares random-site Metropolis dynamics with the Wolff cluster update using the same measurement target as scripts/ising/measure_z.py. The central observable is the slope of \(\tau_{\mathrm{int}}(L)\) on log-log axes. For local single-spin-flip dynamics the established value is \(z \approx 2.17\) [5]. For the Wolff algorithm it is \(z^{\mathrm{sw}} \approx 0.25\) when time is counted in sweep-equivalent units [6], which corresponds to \(z^{\mathrm{cs}} \approx 0.5\) in the cluster-step units used for the fit in this notebook.

The analysis proceeds in four parts. It first explains the physical mechanism behind the two scaling slopes and fixes the unit convention that makes them comparable, then loads the cached script output or runs a small fallback in its place. The fit that follows estimates \(z\) in log-log space with diagnostics, and the closing section connects the slopes to sampling strategy and to the difference between algorithmic efficiency and physical dynamics. The outputs stored with this notebook come from the fallback (three lattice sizes, one seed each), which is far too small to determine \(z\); the text says where the stored numbers depart from the literature values and why.

Why the slopes differ

Local Metropolis updates change one spin at a time, so near \(T_c\) relaxation is diffusive: the correlation length \(\xi\) grows to the system size, and long-wavelength fluctuations of the magnetization have to be built and dissolved by small local moves. This gives \(z \approx 2.17\) for the 2D Ising model with random-site single-spin-flip dynamics; the most precise estimate, \(z = 2.1665(12)\), was obtained for heat-bath transition probabilities with random site selection [5], which belongs to the same dynamic universality class as random-site Metropolis.

Wolff [2] instead grows a cluster from a random seed by bonding same-sign nearest neighbours with probability

\[P_{\mathrm{add}} = 1 - e^{-2\beta J},\]

a choice derived from the Fortuin–Kasteleyn random-cluster representation [4] that guarantees detailed balance with a 100% acceptance rate. Flipping a whole correlated domain in one move matches the scale of critical fluctuations and removes most of the diffusive bottleneck. The resulting exponent is \(z^{\mathrm{sw}} \approx 0.25\) in sweep-equivalent units [6], or \(z^{\mathrm{cs}} \approx 0.5\) in cluster-step units, as derived below.

Defining \(\tau_{\mathrm{int}}\) and the update unit

\(\tau_{\mathrm{int}}\) counts the number of update steps required to generate one statistically independent sample. The meaning of “one step” differs between algorithms:

Algorithm

Work per step

Random-site Metropolis

one sweep: \(L^2\) single-spin flip attempts at randomly chosen sites

Wolff cluster

one cluster flip of \(\langle C \rangle\) spins, accepted with probability 1

Counting raw steps treats one Wolff cluster flip as equivalent to one Metropolis sweep. Near \(T_c\) a Wolff cluster contains \(\langle C \rangle \sim L^{7/4}\) spins, a fraction \(\sim L^{-1/4}\) of the lattice that shrinks with \(L\), so a cluster step does less work than a sweep and the gap widens with system size. Comparing raw \(\tau_{\mathrm{int}}\) values directly therefore misstates the cost of the two algorithms, and it also changes the fitted exponent.

Normalisation to sweep-equivalent units

The standard fix is to express both algorithms in units of one \(L^2\)-flip-attempt sweep. Metropolis is already in this unit; Wolff requires reweighting by the mean cluster fraction:

\[\tau^{\mathrm{sw}}_{\mathrm{Wolff}} = \tau^{\mathrm{cs}}_{\mathrm{Wolff}} \times \frac{\langle C \rangle}{L^2}.\]

At \(T_c\), the mean Wolff cluster size scales as \(\langle C \rangle \sim \chi \sim L^{\gamma/\nu} = L^{7/4}\), using the exact 2D Ising exponents \(\gamma = 7/4\) and \(\nu = 1\). Substituting into the sweep-equivalent relation:

\[z^{\mathrm{sw}} = z^{\mathrm{cs}} + \frac{7}{4} - 2 = z^{\mathrm{cs}} - \frac{1}{4}.\]

With \(z^{\mathrm{sw}} \approx 0.25\) this gives \(z^{\mathrm{cs}} \approx 0.5\). The sweep-equivalent exponent is about nine times smaller than the Metropolis value but not zero: Wolff reduces critical slowing down by changing the exponent, it does not eliminate it.

For the full work-normalisation derivation, ISS (independent-samples-per-second) comparison, and temperature-resolved data, see the companion Wolff Efficiency notebook.

Units used in this notebook

This notebook reports \(\tau_{\mathrm{int}}\) in cluster-step units for Wolff, matching the output of scripts/ising/measure_z.py. The Wolff slope it fits is therefore the cluster-step exponent, expected near \(z^{\mathrm{cs}} \approx 0.5\) for large \(L\); the sweep-equivalent exponent follows as \(z^{\mathrm{sw}} = z^{\mathrm{cs}} - 1/4\).

Load or compute data

This notebook needs \(\tau_{\mathrm{int}}(L)\) measurements at \(T_c\) for random-site Metropolis and Wolff updates across multiple lattice sizes. It first searches for precomputed results at ../results/ising/dynamic_exponent_z.npz.

If the cache exists, the notebook loads it directly. When per-size replicate arrays (tau_metro_samples, tau_wolff_samples) are present, medians are used as central values and 16–84% percentile bands are shown as error bars. If those fields are absent (legacy single-trajectory cache), the notebook still runs and treats each size as a single-point estimate with no error bars.

If the cache is missing, the notebook runs a small inline fallback: sizes \(L = 16, 24, 32\), one seed per (algorithm, \(L\)) point, two-start equilibration at \(T_c\), then 2,500 Metropolis sweeps or 800 Wolff cluster flips of measurement. The fallback is only for pipeline validation and quick plotting; it is not an estimate of \(z\). The outputs stored with this notebook were produced by this fallback.

To generate high-quality cached data with uncertainty bands, run:

python scripts/ising/measure_z.py --sizes 16 32 48 64 96 128 --n-seeds 10

This writes ../results/ising/dynamic_exponent_z.npz with 10 independent seed replicas per (algorithm, \(L\)) point, matching the replication depth of the reference notebooks.

[1]:
from __future__ import annotations

import os

import matplotlib.pyplot as plt
import numpy as np

from utils.exceptions import ZeroVarianceAutocorrelationError
from utils.statistics import calculate_autocorr

TC_ISING = 2.0 / np.log(1.0 + np.sqrt(2.0))
NPZ_PATH = '../results/ising/dynamic_exponent_z.npz'
PALETTE = {'metro': '#4878CF', 'wolff': '#D65F5F'}


def estimate_tau(update: str, size: int, meas_steps: int, seed: int) -> float:
    from models.ising_model import IsingSimulation
    from utils.equilibration import prepare_equilibrated_simulation

    # Two independent starts; a pair that never agrees is not measured.
    sim, outcome = prepare_equilibrated_simulation(
        model_cls=IsingSimulation, model_kwargs={}, size=size, temp=TC_ISING, seed=seed,
        chunk_size=100, max_steps=10000, update=update,
    )
    if not outcome.certified:
        return float('nan')
    mags, _ = sim.run(n_steps=meas_steps)

    try:
        _, tau_int = calculate_autocorr(time_series=np.asarray(mags, dtype=float))
    except ZeroVarianceAutocorrelationError:
        tau_int = float('nan')

    return float(tau_int)


def _shape_to_samples(arr: np.ndarray) -> np.ndarray:
    """Return a 2D (n_size, n_rep) view for uncertainty handling."""
    a = np.asarray(arr, dtype=float)
    if a.ndim == 1:
        return a[:, None]
    return a


_cache_ok = False
if os.path.exists(NPZ_PATH):
    data = np.load(NPZ_PATH)
    required = {'L_metro', 'tau_metro', 'L_wolff', 'tau_wolff', 'Tc'}
    if required.issubset(set(data.files)):
        L_metro = np.asarray(data['L_metro'], dtype=float)
        tau_metro = np.asarray(data['tau_metro'], dtype=float)
        L_wolff = np.asarray(data['L_wolff'], dtype=float)
        tau_wolff = np.asarray(data['tau_wolff'], dtype=float)
        Tc = float(data['Tc'])

        # Optional replicate/sample arrays for uncertainty-aware aggregation.
        tau_metro_samples = _shape_to_samples(data['tau_metro_samples']) if 'tau_metro_samples' in data.files else tau_metro[:, None]
        tau_wolff_samples = _shape_to_samples(data['tau_wolff_samples']) if 'tau_wolff_samples' in data.files else tau_wolff[:, None]

        # Robust summary across replicates if available.
        tau_metro_med = np.nanmedian(tau_metro_samples, axis=1)
        tau_wolff_med = np.nanmedian(tau_wolff_samples, axis=1)
        tau_metro_p16 = np.nanpercentile(tau_metro_samples, 16, axis=1)
        tau_metro_p84 = np.nanpercentile(tau_metro_samples, 84, axis=1)
        tau_wolff_p16 = np.nanpercentile(tau_wolff_samples, 16, axis=1)
        tau_wolff_p84 = np.nanpercentile(tau_wolff_samples, 84, axis=1)

        n_rep_m = tau_metro_samples.shape[1]
        n_rep_w = tau_wolff_samples.shape[1]
        print(
            f'Loaded pre-computed data from {NPZ_PATH}: '
            f'{len(L_metro)} Metropolis sizes (replicates per size: {n_rep_m}), '
            f'{len(L_wolff)} Wolff sizes (replicates per size: {n_rep_w}).'
        )
        _cache_ok = True
    else:
        print(f'Cache at {NPZ_PATH} is missing expected keys; running inline fallback.')

if not _cache_ok:
    print(
        'Pre-computed data not found. Running inline demo '
        '(sizes 16, 24, 32; non-publication-quality).'
    )
    sizes = [16, 24, 32]
    L_metro = np.asarray(sizes, dtype=float)
    L_wolff = np.asarray(sizes, dtype=float)

    tau_metro = np.asarray(
        [estimate_tau(update='random', size=size, meas_steps=2500, seed=idx * 100) for idx, size in enumerate(sizes)],
        dtype=float,
    )
    tau_wolff = np.asarray(
        [estimate_tau(update='wolff', size=size, meas_steps=800, seed=idx * 100 + 1) for idx, size in enumerate(sizes)],
        dtype=float,
    )

    tau_metro_samples = tau_metro[:, None]
    tau_wolff_samples = tau_wolff[:, None]
    tau_metro_med = tau_metro.copy()
    tau_wolff_med = tau_wolff.copy()
    tau_metro_p16 = tau_metro.copy()
    tau_metro_p84 = tau_metro.copy()
    tau_wolff_p16 = tau_wolff.copy()
    tau_wolff_p84 = tau_wolff.copy()

    Tc = TC_ISING
    print(f'Computed fallback data at T_c = {Tc:.6f} for sizes {sizes}.')
Pre-computed data not found. Running inline demo (sizes 16, 24, 32; non-publication-quality).
Computed fallback data at T_c = 2.269185 for sizes [16, 24, 32].

Scaling fit with diagnostics and uncertainty

We fit the power law

\[\tau_{\mathrm{int}}(L) = A L^z\]

by linear regression in log space:

\[\log \tau_{\mathrm{int}} = z\,\log L + \log A,\]

where \(\tau_{\mathrm{int}}\) is the integrated autocorrelation time of the magnetization time series and \(A = A(T_c)\) is a non-universal prefactor.

Primary estimate: per-seed z distribution

When the cache holds several independent seed replicas per \((L, \text{algorithm})\) point (10 with the command above), the most direct way to quantify uncertainty in \(z\) is to fit independently for each seed and collect the resulting distribution:

\[z_s = \text{slope of } \log \tau_{\mathrm{int}}^{(s)} \text{ vs } \log L, \quad s = 1, \ldots, N_{\mathrm{seeds}}.\]

The reported \(z\) and its 16–84% interval come from the median and percentiles of \(\{z_s\}\). This captures run-to-run variability in \(\tau_{\mathrm{int}}\) directly, rather than relying on OLS residuals over a handful of lattice sizes.

With the single-seed fallback the distribution contains one value per algorithm. Its 16–84% interval then collapses to that value and carries no information about the uncertainty, and the per-seed estimate coincides with the OLS fit below.

Reference curve: OLS fit on per-size medians

An OLS fit on the per-size median values provides a smooth reference line and 95% confidence band for the scaling plot. Per-size uncertainty is shown as error bars (16–84% across seeds at each \(L\)); with one seed these bars have zero length.

Both estimates are printed in the summary table below the figure.

[2]:
def fit_loglog(L: np.ndarray, tau: np.ndarray) -> dict[str, float | np.ndarray]:
    """Fit log(tau) = z*log(L) + b and return diagnostics."""
    valid = np.isfinite(L) & np.isfinite(tau) & (L > 0) & (tau > 0)
    x = np.log(np.asarray(L[valid], dtype=float))
    y = np.log(np.asarray(tau[valid], dtype=float))
    n = x.size
    if n < 3:
        raise ValueError('Need at least 3 valid points for log-log fit.')

    z, b = np.polyfit(x, y, 1)
    yhat = z * x + b
    resid = y - yhat
    rss = float(np.sum(resid**2))
    tss = float(np.sum((y - y.mean())**2))
    r2 = 1.0 - rss / tss if tss > 0 else np.nan

    sxx = float(np.sum((x - x.mean())**2))
    sigma2 = rss / (n - 2)
    z_se = float(np.sqrt(sigma2 / sxx))
    b_se = float(np.sqrt(sigma2 * (1.0 / n + (x.mean() ** 2) / sxx)))

    return {
        'z': float(z), 'b': float(b), 'A': float(np.exp(b)),
        'z_se': z_se, 'b_se': b_se, 'r2': float(r2),
        'x': x, 'y': y, 'yhat': yhat, 'resid': resid,
        'n': int(n), 'sigma': float(np.sqrt(sigma2)),
        'x_mean': float(x.mean()), 'sxx': sxx,
    }


def mean_band(fit: dict, x_new: np.ndarray) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
    """OLS 95% confidence band for the mean log prediction, transformed to linear scale."""
    y_pred = fit['z'] * x_new + fit['b']
    se_mean = fit['sigma'] * np.sqrt(1.0 / fit['n'] + ((x_new - fit['x_mean']) ** 2) / fit['sxx'])
    return np.exp(y_pred), np.exp(y_pred - 1.96 * se_mean), np.exp(y_pred + 1.96 * se_mean)


# ---------------------------------------------------------------------------
# Per-seed z estimates: fit z independently for each replicate trajectory.
# This is the primary uncertainty estimate — it directly reflects run-to-run
# variability in tau_int rather than relying on OLS residuals over 6 sizes.
# ---------------------------------------------------------------------------
def _per_seed_z(L: np.ndarray, samples: np.ndarray) -> np.ndarray:
    """Return z fitted independently for each seed column in samples (n_size, n_seed)."""
    n_seeds = samples.shape[1]
    z_arr = np.full(n_seeds, np.nan)
    for s in range(n_seeds):
        col = samples[:, s]
        valid = np.isfinite(col) & (col > 0)
        if valid.sum() >= 3:
            z_arr[s] = fit_loglog(L[valid], col[valid])['z']
    return z_arr[np.isfinite(z_arr)]


z_seeds_m = _per_seed_z(L_metro, tau_metro_samples)
z_seeds_w = _per_seed_z(L_wolff, tau_wolff_samples)

z_m_med  = float(np.median(z_seeds_m))
z_w_med  = float(np.median(z_seeds_w))
z_m_p16, z_m_p84 = float(np.percentile(z_seeds_m, 16)), float(np.percentile(z_seeds_m, 84))
z_w_p16, z_w_p84 = float(np.percentile(z_seeds_w, 16)), float(np.percentile(z_seeds_w, 84))

# OLS fit on the per-size medians: used for the reference curve and CI band only.
fit_m = fit_loglog(L_metro, tau_metro_med)
fit_w = fit_loglog(L_wolff, tau_wolff_med)

L_fit = np.linspace(min(np.min(L_metro), np.min(L_wolff)),
                    max(np.max(L_metro), np.max(L_wolff)), 300)
tau_fit_m, tau_fit_m_lo, tau_fit_m_hi = mean_band(fit_m, np.log(L_fit))
tau_fit_w, tau_fit_w_lo, tau_fit_w_hi = mean_band(fit_w, np.log(L_fit))

# ---------------------------------------------------------------------------
# Figure: Left — scaling plot with seed uncertainty bands.
#         Right — per-seed z distributions (the primary uncertainty view).
# ---------------------------------------------------------------------------
fig, axes = plt.subplots(1, 2, figsize=(13, 5))

# --- Left panel: tau_int(L) scaling ---
ax = axes[0]
yerr_m = np.vstack([tau_metro_med - tau_metro_p16, tau_metro_p84 - tau_metro_med])
yerr_w = np.vstack([tau_wolff_med - tau_wolff_p16, tau_wolff_p84 - tau_wolff_med])

ax.errorbar(L_metro, tau_metro_med, yerr=yerr_m,
            fmt='o', color=PALETTE['metro'], markersize=6, capsize=3,
            label=f'Metropolis  $z = {z_m_med:.2f}$ [{z_m_p16:.2f}, {z_m_p84:.2f}]')
ax.errorbar(L_wolff, tau_wolff_med, yerr=yerr_w,
            fmt='s', color=PALETTE['wolff'], markersize=6, capsize=3,
            label=f'Wolff (cs)  $z = {z_w_med:.2f}$ [{z_w_p16:.2f}, {z_w_p84:.2f}]')

ax.loglog(L_fit, tau_fit_m, '--', color=PALETTE['metro'], alpha=0.9)
ax.loglog(L_fit, tau_fit_w, '--', color=PALETTE['wolff'], alpha=0.9)
ax.fill_between(L_fit, tau_fit_m_lo, tau_fit_m_hi, color=PALETTE['metro'], alpha=0.15)
ax.fill_between(L_fit, tau_fit_w_lo, tau_fit_w_hi, color=PALETTE['wolff'], alpha=0.15)

ax.set_xlabel('Lattice size $L$')
ax.set_ylabel(r'Integrated autocorrelation time $\tau_{\mathrm{int}}$')
ax.set_title(fr'Scaling at $T_c \approx {Tc:.4f}$  (error bars: 16–84% over seeds)')
ax.legend(fontsize=9, title='16–84% from per-seed z', title_fontsize=8)
ax.grid(True, which='both', alpha=0.25)

# --- Right panel: per-seed z distributions ---
ax = axes[1]
n_m = len(z_seeds_m)
n_w = len(z_seeds_w)

rng = np.random.default_rng(42)
jitter_m = rng.uniform(-0.15, 0.15, n_m)
jitter_w = rng.uniform(-0.15, 0.15, n_w)

ax.scatter(np.ones(n_m) + jitter_m, z_seeds_m,
           color=PALETTE['metro'], alpha=0.6, s=30, zorder=3)
ax.scatter(2 * np.ones(n_w) + jitter_w, z_seeds_w,
           color=PALETTE['wolff'], alpha=0.6, s=30, zorder=3)

for x_pos, med, p16, p84, col in [
    (1, z_m_med, z_m_p16, z_m_p84, PALETTE['metro']),
    (2, z_w_med, z_w_p16, z_w_p84, PALETTE['wolff']),
]:
    ax.plot([x_pos - 0.25, x_pos + 0.25], [med, med], '-', color=col, lw=2.5, zorder=4)
    ax.plot([x_pos, x_pos], [p16, p84], '-', color=col, lw=1.5, alpha=0.7, zorder=4)

ax.set_xticks([1, 2])
ax.set_xticklabels(['Metropolis', 'Wolff (cluster-step)'])
ax.set_ylabel('Fitted dynamical exponent $z$')
ax.set_title(f'Per-seed $z$ distribution  ({n_m} Metro, {n_w} Wolff seeds)')
ax.grid(axis='y', alpha=0.25)
ax.set_xlim(0.5, 2.5)

fig.tight_layout()
plt.show()

# ---------------------------------------------------------------------------
# Summary table
# ---------------------------------------------------------------------------
print('z from per-seed fit distribution (primary estimate):')
print('-' * 70)
print(f'  Metropolis     z = {z_m_med:.3f}  (16–84%: {z_m_p16:.3f} – {z_m_p84:.3f})  n_seeds = {n_m}')
print(f'  Wolff (cs)     z = {z_w_med:.3f}  (16–84%: {z_w_p16:.3f} – {z_w_p84:.3f})  n_seeds = {n_w}')
print()
print('OLS fit on per-size medians (reference line on left panel):')
print('-' * 70)
print(f"  Metropolis     z = {fit_m['z']:.3f}  (OLS SE: {fit_m['z_se']:.3f},  R² = {fit_m['r2']:.4f})")
print(f"  Wolff (cs)     z = {fit_w['z']:.3f}  (OLS SE: {fit_w['z_se']:.3f},  R² = {fit_w['r2']:.4f})")
print()
print('Note: Wolff z is in cluster-step units; sweep-equivalent z ≈ z_cs − 0.25.')
_images/dynamic_critical_exponents_5_0.png
z from per-seed fit distribution (primary estimate):
----------------------------------------------------------------------
  Metropolis     z = 0.767  (16–84%: 0.767 – 0.767)  n_seeds = 1
  Wolff (cs)     z = -0.111  (16–84%: -0.111 – -0.111)  n_seeds = 1

OLS fit on per-size medians (reference line on left panel):
----------------------------------------------------------------------
  Metropolis     z = 0.767  (OLS SE: 0.075,  R² = 0.9905)
  Wolff (cs)     z = -0.111  (OLS SE: 0.945,  R² = 0.0136)

Note: Wolff z is in cluster-step units; sweep-equivalent z ≈ z_cs − 0.25.

Reading the result

The stored output comes from the fallback run: one seed per point and three lattice sizes, \(L = 16, 24, 32\). On these data the fit gives \(z = 0.77\) for Metropolis (OLS standard error 0.075, \(R^2 = 0.99\)) and \(z^{\mathrm{cs}} = -0.11\) for Wolff (standard error 0.95, \(R^2 = 0.01\)). Neither number is a measurement of the dynamic exponent. The Metropolis \(\tau_{\mathrm{int}}\) rises by less than a factor of two between \(L = 16\) and \(L = 32\), where \(L^{2.17}\) predicts a factor of about 4.5, and the Wolff values scatter between roughly 2 and 4 cluster steps with no trend.

Three sizes spanning a factor of two in \(L\), with one trajectory each, cannot determine \(z\). The OLS standard error describes the scatter of three points about a straight line, with a single degree of freedom left, and says nothing about the statistical error of each \(\tau_{\mathrm{int}}\) or about corrections to scaling at small \(L\). The statistical error is large: for a summation window \(W\) and \(N\) measurements the variance of the estimator is approximately \(2(2W+1)\,\tau_{\mathrm{int}}^2/N\) [3], so with \(W\) of a few times \(\tau_{\mathrm{int}}\) and \(N = 2500\) sweeps each Metropolis point carries a relative error of several tens of percent. The close Metropolis fit (\(R^2 = 0.99\)) is therefore a coincidence of three noisy points, not evidence of a power law with slope 0.77. For Wolff the expected change over this range, a factor \(2^{0.5} \approx 1.4\) in cluster-step units, is smaller than that scatter, which is why the fitted slope is consistent with zero and even slightly negative. Because there is one seed, the 16–84% interval in the legend and in the right panel collapses to a single value and should not be read as an uncertainty.

The established values are \(z \approx 2.17\) for local single-spin-flip dynamics [5] and \(z^{\mathrm{sw}} \approx 0.25\) for Wolff in sweep-equivalent units [6], that is \(z^{\mathrm{cs}} \approx 0.5\) in the cluster-step units of this fit. Reproducing them requires the cached multi-seed run from scripts/ising/measure_z.py over a wider range of sizes (the command in the data section uses \(L = 16\) to \(128\) with 10 seeds). With such data the two algorithms should differ in slope rather than only in offset, which is the point of the comparison: cluster updates change the scaling law, not merely a prefactor.

Unit interpretation. A Wolff slope fitted here is the cluster-step exponent \(z^{\mathrm{cs}}\). In sweep-equivalent units the normalised exponent is

\[z^{\mathrm{sw}} = z^{\mathrm{cs}} - \tfrac{1}{4},\]

which follows from \(\langle C \rangle \sim L^{\gamma/\nu} = L^{7/4}\) (exact 2D Ising FK scaling). With the literature value \(z^{\mathrm{sw}} \approx 0.25\) the Wolff exponent is about nine times smaller than the Metropolis exponent, a large reduction though not a complete elimination of critical slowing down. For a full normalised comparison see the Wolff Efficiency notebook.

With a multi-seed cache, the per-seed spread in the right panel becomes the useful diagnostic: a tight cluster of \(z_s\) values near the median indicates a stable power-law regime over the measured \(L\) range, while a wide or skewed spread points to too few sizes or too short trajectories. Treat the intervals as stability diagnostics rather than final error bars, because the finite-size window and the replicate count in the cache can differ between runs.

Scientific implication

For equilibrium sampling near criticality, Wolff is generally the right algorithmic choice because it suppresses critical slowing down while preserving the Boltzmann target distribution.

However, a smaller algorithmic \(z\) does not mean Wolff reproduces physical kinetic time. For non-equilibrium kinetics and dynamic universality studies tied to local physical updates, random-site Metropolis (or another local dynamics) remains the physically interpretable model, even when it is computationally slower.

Bibliography

[1] L. Onsager, “Crystal Statistics. I. A Two-Dimensional Model with an Order-Disorder Transition,” Physical Review, vol. 65, no. 3-4, pp. 117-149, 1944. APS Open Access

[2] U. Wolff, “Collective Monte Carlo Updating for Spin Systems,” Physical Review Letters, vol. 62, no. 4, pp. 361-364, 1989. APS Open Access

[3] 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 critical slowing down, the dynamic exponent, and integrated autocorrelation-time estimators and their errors in Markov-chain Monte Carlo. Springer Link

[4] 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. Original paper introducing the random-cluster (FK) representation that underpins the Wolff and Swendsen–Wang algorithms. Elsevier Open Access

[5] M. P. Nightingale and H. W. J. Blöte, “Dynamic Exponent of the Two-Dimensional Ising Model and Monte Carlo Computation of the Subdominant Eigenvalue of the Stochastic Matrix,” Physical Review Letters, vol. 76, p. 4548, 1996. Gives \(z = 2.1665(12)\) for single-spin-flip dynamics with random site selection. arXiv:cond-mat/9601059

[6] P. D. Coddington and C. F. Baillie, “Empirical relations between static and dynamic exponents for Ising model cluster algorithms,” Physical Review Letters, vol. 68, p. 962, 1992. Measures the dynamic exponents of the Wolff and Swendsen–Wang algorithms, with \(z \approx 0.25\) for Wolff on the 2D Ising model in sweep-equivalent units.