physicskit 0.1.0__py3-none-any.whl

physicskit/statphys/utils/landau_theory.py

@@ -0,0 +1,151 @@
+"""Landau's phenomenological theory of continuous phase transitions.
+
+Rather than derive a phase transition from microscopic interactions, Landau
+(1937) asked what the *free energy itself* must look like, given only the
+symmetry of the order parameter, near a continuous transition. For an
+order parameter :math:`m` (magnetization, density difference, ...) that
+the disordered phase's symmetry forbids from appearing at odd order, the
+simplest possible expansion is
+
+.. math::
+
+    F(m, T) = a(T - T_C)\\, m^2 + b\\, m^4 - h\\, m, \\qquad a, b > 0,
+
+with an external field :math:`h` coupling linearly to :math:`m`. Minimizing
+this quartic over :math:`m` reproduces, from symmetry and analyticity
+alone, the qualitative shape of every continuous transition: a single
+minimum at :math:`m = 0` above :math:`T_C`, a spontaneous, symmetry-broken
+pair of minima :math:`m = \\pm\\sqrt{a(T_C - T)/2b}` below it, and a
+susceptibility that diverges from both sides as :math:`T \\to T_C`. Landau
+theory's mean-field critical exponents (:math:`\\beta = 1/2`, :math:`\\gamma
+= 1`) are quantitatively wrong in low dimensions -- famously not matching
+Onsager's exact 2D Ising values -- but the qualitative order-parameter
+picture it introduced, and the idea of classifying transitions by how they
+break symmetry, underlies the entire modern theory of phase transitions
+that the renormalization group later completed.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+__all__ = ["landau_equilibrium_magnetization", "landau_free_energy", "landau_susceptibility"]
+
+
+def landau_free_energy(m, T, Tc, a=1.0, b=1.0, h=0.0):
+    """Landau free energy :math:`F(m) = a(T - T_C) m^2 + b m^4 - h m`.
+
+    Parameters
+    ----------
+    m : array_like
+        Order parameter value(s) at which to evaluate :math:`F`.
+    T : float
+        Temperature.
+    Tc : float
+        Critical temperature.
+    a, b : float, default=1.0
+        Positive Landau expansion coefficients.
+    h : float, default=0.0
+        External field, linearly coupled to :math:`m`.
+
+    Returns
+    -------
+    ndarray
+    """
+    m = np.asarray(m, dtype=np.float64)
+    return a * (T - Tc) * m**2 + b * m**4 - h * m
+
+
+def landau_equilibrium_magnetization(T, Tc, a=1.0, b=1.0, h=0.0):
+    """Order parameter minimizing the Landau free energy at temperature T.
+
+    Solves :math:`\\partial F/\\partial m = 2a(T-T_C)m + 4bm^3 - h = 0` for
+    every real root, and returns the one with the lowest :math:`F` (the
+    true equilibrium branch, correctly following the symmetry-broken
+    minimum rather than the unstable one once :math:`h \\ne 0` tilts the
+    double well). At :math:`h = 0` below :math:`T_C` the two symmetry-broken
+    roots :math:`\\pm\\sqrt{a(T_C-T)/2b}` are exactly degenerate in
+    :math:`F`; ties are broken deterministically in favor of the
+    non-negative root (the conventional "up" branch of spontaneous symmetry
+    breaking), so that :math:`m(T)` is a single-valued, continuous curve
+    rather than jumping unpredictably between the two equally valid
+    branches as :math:`T` is swept. At :math:`h = 0` this reduces to the
+    textbook result :math:`m = 0` for :math:`T \\ge T_C` and :math:`m =
+    \\sqrt{a(T_C - T)/2b}` for :math:`T < T_C` -- the mean-field
+    :math:`\\beta = 1/2` critical exponent.
+
+    Parameters
+    ----------
+    T : float or array_like
+        Temperature(s).
+    Tc : float
+        Critical temperature.
+    a, b : float, default=1.0
+        Positive Landau expansion coefficients.
+    h : float, default=0.0
+        External field.
+
+    Returns
+    -------
+    float or ndarray
+        Equilibrium order parameter, matching the shape of ``T``.
+
+    Examples
+    --------
+    >>> round(landau_equilibrium_magnetization(T=1.0, Tc=2.0, a=1.0, b=1.0, h=0.0), 6)
+    0.707107
+    >>> landau_equilibrium_magnetization(T=3.0, Tc=2.0, a=1.0, b=1.0, h=0.0)
+    0.0
+    """
+    T_arr = np.atleast_1d(np.asarray(T, dtype=np.float64))
+    m_eq = np.empty_like(T_arr)
+    for i, Ti in enumerate(T_arr):
+        coeffs = [4.0 * b, 0.0, 2.0 * a * (Ti - Tc), -h]
+        roots = np.roots(coeffs)
+        real_roots = roots[np.abs(roots.imag) < 1e-8].real
+        F_vals = a * (Ti - Tc) * real_roots**2 + b * real_roots**4 - h * real_roots
+        # Below T_C at h=0 the +/-m branches are exactly degenerate in F, so
+        # argmin alone would tie-break on np.roots' arbitrary root ordering,
+        # flipping sign unpredictably as T is swept. Restrict to the
+        # (numerically) tied minimizers and deterministically prefer the
+        # largest (non-negative, "up"-branch) one among them.
+        is_min = F_vals <= F_vals.min() + 1e-9 * (1.0 + np.abs(F_vals.min()))
+        m_eq[i] = real_roots[is_min].max()
+    return float(m_eq[0]) if np.ndim(T) == 0 else m_eq
+
+
+def landau_susceptibility(T, Tc, a=1.0, b=1.0):
+    """Zero-field susceptibility :math:`\\chi = (\\partial^2 F/\\partial m^2)^{-1}` at equilibrium.
+
+    Evaluated at the :math:`h=0` equilibrium magnetization, this gives the
+    standard mean-field result
+
+    .. math::
+
+        \\chi(T) = \\begin{cases}
+            \\dfrac{1}{2a(T - T_C)}, & T > T_C, \\\\[4pt]
+            \\dfrac{1}{4a(T_C - T)}, & T < T_C,
+        \\end{cases}
+
+    diverging on both sides of :math:`T_C` with the same exponent
+    :math:`\\gamma = 1` but different amplitudes -- the universal
+    mean-field amplitude ratio of 2.
+
+    Parameters
+    ----------
+    T : array_like
+        Temperature(s); may include ``Tc`` itself, where :math:`\\chi`
+        diverges (``inf`` is returned there).
+    Tc : float
+        Critical temperature.
+    a, b : float, default=1.0
+        Positive Landau expansion coefficients (``b`` is unused above
+        :math:`T_C`, kept for a uniform signature).
+
+    Returns
+    -------
+    ndarray
+    """
+    T = np.asarray(T, dtype=np.float64)
+    with np.errstate(divide="ignore"):
+        return np.where(T > Tc, 1.0 / (2.0 * a * (T - Tc)), 1.0 / (4.0 * a * (Tc - T)))

physicskit/statphys/utils/partition_function.py

@@ -0,0 +1,109 @@
+"""Exact partition-function enumeration and the Lee-Yang circle theorem.
+
+Lee and Yang (1952) asked where a phase transition -- a genuine
+discontinuity or divergence in the free energy -- could possibly come from,
+given that a finite system's partition function is a finite sum of
+manifestly analytic terms. Their answer: it comes from the zeros of the
+partition function, analytically continued into the *complex* fugacity
+plane. For a finite ferromagnetic Ising system in a field, every such zero
+lies exactly on the unit circle (the "Lee-Yang circle theorem"); as the
+system size grows, these zeros multiply and crowd toward the positive real
+axis, and a phase transition occurs exactly where, in the thermodynamic
+limit, they pinch that axis. No finite system has a true singularity, but
+the zeros' approach to one is visible well before that limit.
+
+This module computes the partition function of a small Ising system
+*exactly*, by full enumeration of every spin configuration -- feasible up to roughly
+:math:`N \\approx 20` (:math:`2^N` configurations are enumerated
+explicitly) -- as a polynomial in the fugacity, and finds
+that polynomial's roots directly.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+__all__ = ["ising_partition_polynomial", "yang_lee_zeros"]
+
+
+def ising_partition_polynomial(N, beta, J=1.0, periodic=True):
+    """Exact partition function of a small 1D Ising chain, as a polynomial in the fugacity.
+
+    With an external field :math:`h`, the Hamiltonian is :math:`H =
+    -J\\sum_{\\langle i,j\\rangle} s_i s_j - h \\sum_i s_i`. Writing the
+    fugacity :math:`z = e^{2\\beta h}`, the partition function factors as
+
+    .. math::
+
+        Z(\\beta, h) = e^{-\\beta h N} \\sum_{k=0}^{N} g_k\\, z^k,
+
+    where :math:`g_k = \\sum_{\\{s\\}:\\, n_\\uparrow(s) = k}
+    e^{-\\beta H_0(s)}` sums the field-free Boltzmann weight over every
+    configuration with exactly :math:`k` up-spins. The prefactor
+    :math:`e^{-\\beta h N}` is nonzero and analytic in :math:`h`, so it
+    never contributes a zero: the zeros of :math:`Z` as a function of
+    :math:`z` are exactly the roots of this polynomial's coefficients
+    ``g_k``, which is all :func:`yang_lee_zeros` needs.
+
+    Every one of the :math:`2^N` configurations is enumerated directly, so
+    this is only practical for modest :math:`N` (roughly 20 at most --
+    ``2**30`` configurations will exhaust memory).
+
+    Parameters
+    ----------
+    N : int
+        Number of spins.
+    beta : float
+        Inverse temperature.
+    J : float, default=1.0
+        Nearest-neighbor coupling. ``J > 0`` (ferromagnetic) is the regime
+        the Lee-Yang circle theorem applies to.
+    periodic : bool, default=True
+        Periodic (ring) vs. open chain boundary conditions.
+
+    Returns
+    -------
+    ndarray of shape (N + 1,)
+        Coefficients ``g_k``, ordered by increasing power of ``z`` (i.e.
+        ``g[k]`` is the coefficient of ``z**k``).
+    """
+    configs = np.arange(2**N, dtype=np.int64)
+    bits = (configs[:, None] >> np.arange(N)) & 1
+    spins = bits.astype(np.float64) * 2 - 1  # shape (2**N, N), values +/-1
+
+    if periodic:
+        neighbor_product = spins * np.roll(spins, -1, axis=1)
+    else:
+        neighbor_product = spins[:, :-1] * spins[:, 1:]
+    E0 = -J * np.sum(neighbor_product, axis=1)
+
+    n_up = np.sum(bits, axis=1)
+    weights = np.exp(-beta * E0)
+
+    g = np.zeros(N + 1, dtype=np.float64)
+    np.add.at(g, n_up, weights)
+    return g
+
+
+def yang_lee_zeros(coeffs):
+    """Roots, in the complex fugacity plane, of the polynomial :math:`\\sum_k g_k z^k`.
+
+    Lee and Yang's circle theorem predicts that for a ferromagnetic Ising
+    system (``J > 0`` in :func:`ising_partition_polynomial`), every one of
+    these roots lies exactly on the unit circle :math:`|z| = 1`, regardless
+    of system size -- a striking, exact constraint on where a phase
+    transition's mathematical signature is allowed to live.
+
+    Parameters
+    ----------
+    coeffs : array_like
+        Polynomial coefficients ``g_k``, ordered by increasing power of
+        ``z`` (as returned by :func:`ising_partition_polynomial`).
+
+    Returns
+    -------
+    ndarray of complex
+        The polynomial's roots.
+    """
+    coeffs = np.asarray(coeffs, dtype=np.float64)
+    return np.roots(coeffs[::-1])

physicskit/statphys/utils/thermodynamics.py

@@ -0,0 +1,356 @@
+"""Thermodynamic observables derived from Monte Carlo and molecular dynamics samples.
+
+Every function here takes arrays of samples collected during a simulation
+(energies, magnetizations, velocities, spin configurations, ...) and returns a
+scalar or array observable, following the standard fluctuation-dissipation
+relations of the canonical ensemble.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+__all__ = [
+    "bec_condensate_fraction",
+    "binder_cumulant",
+    "bose_einstein_occupation",
+    "fermi_dirac_occupation",
+    "maxwell_boltzmann_component_pdf",
+    "maxwell_boltzmann_speed_pdf",
+    "specific_heat",
+    "spin_correlation_function",
+    "susceptibility",
+]
+
+
+def specific_heat(energies, temperature, n_sites, kB=1.0):
+    """Specific heat per site from the energy fluctuations of a canonical sample.
+
+    .. math::
+
+        C_v = \\frac{\\langle E^2 \\rangle - \\langle E \\rangle^2}{k_B T^2 N}
+
+    Parameters
+    ----------
+    energies : array_like
+        Sampled total energies at fixed temperature.
+    temperature : float
+        Sampling temperature.
+    n_sites : int
+        Number of lattice sites (or particles) ``N``, used to report an
+        intensive, per-site quantity.
+    kB : float, default=1.0
+        Boltzmann constant.
+
+    Returns
+    -------
+    float
+        Specific heat per site.
+
+    Examples
+    --------
+    >>> rng = np.random.default_rng(0)
+    >>> E = rng.normal(loc=-100.0, scale=5.0, size=10000)
+    >>> bool(specific_heat(E, temperature=2.0, n_sites=64) > 0)
+    True
+    """
+    energies = np.asarray(energies, dtype=np.float64)
+    var_E = energies.var()
+    return var_E / (kB * temperature**2 * n_sites)
+
+
+def susceptibility(magnetizations, temperature, n_sites, kB=1.0):
+    """Magnetic susceptibility per site from magnetization fluctuations.
+
+    .. math::
+
+        \\chi = \\frac{\\langle M^2 \\rangle - \\langle M \\rangle^2}{k_B T N}
+
+    Parameters
+    ----------
+    magnetizations : array_like
+        Sampled total magnetizations at fixed temperature.
+    temperature : float
+        Sampling temperature.
+    n_sites : int
+        Number of lattice sites ``N``.
+    kB : float, default=1.0
+        Boltzmann constant.
+
+    Returns
+    -------
+    float
+        Susceptibility per site.
+    """
+    magnetizations = np.asarray(magnetizations, dtype=np.float64)
+    var_M = magnetizations.var()
+    return var_M / (kB * temperature * n_sites)
+
+
+def binder_cumulant(magnetizations):
+    """Fourth-order Binder cumulant of a magnetization sample.
+
+    .. math::
+
+        U_4 = 1 - \\frac{\\langle M^4 \\rangle}{3 \\langle M^2 \\rangle^2}
+
+    ``U_4`` is a standard finite-size-scaling diagnostic: it is
+    size-independent exactly at the critical temperature, which makes
+    crossing plots for several lattice sizes a robust way to locate
+    :math:`T_c`.
+
+    Parameters
+    ----------
+    magnetizations : array_like
+        Sampled total (or per-site) magnetizations.
+
+    Returns
+    -------
+    float
+        The Binder cumulant, in :math:`[0, 2/3]` for a symmetric
+        distribution.
+    """
+    m = np.asarray(magnetizations, dtype=np.float64)
+    m2 = np.mean(m**2)
+    m4 = np.mean(m**4)
+    return 1.0 - m4 / (3.0 * m2**2)
+
+
+def spin_correlation_function(spins, max_r=None):
+    """Radially averaged equal-time spin-spin correlation function :math:`G(r)`.
+
+    Computed efficiently via the Wiener-Khinchin theorem: the autocorrelation
+    of a periodic field equals the inverse FFT of its power spectrum.
+
+    .. math::
+
+        G(r) = \\langle s_0 s_r \\rangle - \\langle s \\rangle^2
+
+    averaged over all site pairs at (periodic, Euclidean-rounded) separation
+    ``r``.
+
+    Parameters
+    ----------
+    spins : ndarray of shape (L, L)
+        Spin (or angle-cosine) configuration on a periodic square lattice.
+    max_r : int, optional
+        Largest separation to report. Defaults to ``L // 2``.
+
+    Returns
+    -------
+    r : ndarray of shape (max_r,)
+        Integer separations ``0, 1, ..., max_r - 1``.
+    G : ndarray of shape (max_r,)
+        Correlation function averaged over all pairs at each rounded
+        separation.
+    """
+    spins = np.asarray(spins, dtype=np.float64)
+    L = spins.shape[0]
+    if max_r is None:
+        max_r = L // 2
+
+    mean_s = spins.mean()
+    fft = np.fft.fft2(spins)
+    autocorr = np.fft.ifft2(fft * np.conj(fft)).real / (L * L)
+
+    ii, jj = np.meshgrid(np.arange(L), np.arange(L), indexing="ij")
+    di = np.minimum(ii, L - ii)
+    dj = np.minimum(jj, L - jj)
+    dist = np.sqrt(di**2 + dj**2)
+    r_bin = np.round(dist).astype(int)
+
+    G = np.zeros(max_r, dtype=np.float64)
+    for r in range(max_r):
+        mask = r_bin == r
+        if np.any(mask):
+            G[r] = autocorr[mask].mean() - mean_s**2
+    return np.arange(max_r), G
+
+
+def maxwell_boltzmann_speed_pdf(v, temperature, mass=1.0, kB=1.0, dim=2):
+    """Equilibrium Maxwell-Boltzmann probability density of the speed :math:`|v|`.
+
+    In :math:`d` dimensions,
+
+    .. math::
+
+        f(v) = v^{d-1}
+               \\left(\\frac{m}{2\\pi k_B T}\\right)^{d/2}
+               S_{d-1} \\, e^{-m v^2 / 2 k_B T}
+
+    where :math:`S_{d-1}` is the surface area of the unit :math:`(d-1)`-sphere
+    (:math:`2` for :math:`d=1`, :math:`2\\pi` for :math:`d=2`, :math:`4\\pi`
+    for :math:`d=3`).
+
+    Parameters
+    ----------
+    v : array_like
+        Speed values (must be non-negative) at which to evaluate the density.
+    temperature : float
+        Temperature.
+    mass : float, default=1.0
+        Particle mass.
+    kB : float, default=1.0
+        Boltzmann constant.
+    dim : {1, 2, 3}, default=2
+        Spatial dimension.
+
+    Returns
+    -------
+    ndarray
+        Probability density :math:`f(v)`, normalized so that
+        :math:`\\int_0^\\infty f(v)\\, dv = 1`.
+    """
+    v = np.asarray(v, dtype=np.float64)
+    beta_m = mass / (kB * temperature)
+    if dim == 1:
+        surface = 2.0
+    elif dim == 2:
+        surface = 2.0 * np.pi
+    elif dim == 3:
+        surface = 4.0 * np.pi
+    else:
+        raise ValueError("dim must be 1, 2, or 3")
+    prefactor = surface * (beta_m / (2.0 * np.pi)) ** (dim / 2.0)
+    return prefactor * v ** (dim - 1) * np.exp(-0.5 * beta_m * v**2)
+
+
+def maxwell_boltzmann_component_pdf(vx, temperature, mass=1.0, kB=1.0):
+    """Equilibrium Gaussian density of a single Cartesian velocity component.
+
+    .. math::
+
+        f(v_x) = \\sqrt{\\frac{m}{2\\pi k_B T}} \\, e^{-m v_x^2 / 2 k_B T}
+
+    Parameters
+    ----------
+    vx : array_like
+        Velocity component values.
+    temperature : float
+        Temperature.
+    mass : float, default=1.0
+        Particle mass.
+    kB : float, default=1.0
+        Boltzmann constant.
+
+    Returns
+    -------
+    ndarray
+        Probability density :math:`f(v_x)`.
+    """
+    vx = np.asarray(vx, dtype=np.float64)
+    beta_m = mass / (kB * temperature)
+    return np.sqrt(beta_m / (2.0 * np.pi)) * np.exp(-0.5 * beta_m * vx**2)
+
+
+def bose_einstein_occupation(energy, mu, temperature, kB=1.0):
+    """Mean occupation number of a bosonic single-particle state, the Bose-Einstein distribution.
+
+    .. math::
+
+        n_{\\text{BE}}(\\varepsilon) = \\frac{1}{e^{(\\varepsilon - \\mu)/k_B T} - 1}
+
+    Unlike Fermi-Dirac statistics, there is no restriction on how many
+    identical bosons can occupy the same state; as the chemical potential
+    :math:`\\mu` approaches the ground-state energy from below, the
+    ground-state occupation diverges -- the onset of Bose-Einstein
+    condensation.
+
+    Parameters
+    ----------
+    energy : array_like
+        Single-particle state energies. Must satisfy ``energy > mu``
+        (otherwise the occupation is unphysical).
+    mu : float
+        Chemical potential.
+    temperature : float
+        Temperature.
+    kB : float, default=1.0
+        Boltzmann constant.
+
+    Returns
+    -------
+    ndarray
+        Mean occupation number :math:`n_{\\text{BE}}(\\varepsilon)`.
+    """
+    x = (np.asarray(energy, dtype=np.float64) - mu) / (kB * temperature)
+    return 1.0 / np.expm1(x)
+
+
+def fermi_dirac_occupation(energy, mu, temperature, kB=1.0):
+    """Mean occupation number of a fermionic single-particle state, the Fermi-Dirac distribution.
+
+    .. math::
+
+        n_{\\text{FD}}(\\varepsilon) = \\frac{1}{e^{(\\varepsilon - \\mu)/k_B T} + 1}
+
+    The Pauli exclusion principle caps :math:`n_{\\text{FD}}` at 1 for every
+    state, in sharp contrast to Bose-Einstein statistics; as :math:`T \\to
+    0`, this sharpens into a step function at the Fermi energy
+    :math:`\\varepsilon = \\mu`.
+
+    Parameters
+    ----------
+    energy : array_like
+        Single-particle state energies.
+    mu : float
+        Chemical potential (the Fermi energy at :math:`T = 0`).
+    temperature : float
+        Temperature.
+    kB : float, default=1.0
+        Boltzmann constant.
+
+    Returns
+    -------
+    ndarray
+        Mean occupation number :math:`n_{\\text{FD}}(\\varepsilon) \\in (0, 1)`.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> bool(np.all(fermi_dirac_occupation(np.array([0.0, 1.0, 2.0]), mu=1.0, temperature=0.01) >= 0))
+    True
+    """
+    x = (np.asarray(energy, dtype=np.float64) - mu) / (kB * temperature)
+    with np.errstate(over="ignore"):
+        # exp(x) legitimately overflows to inf deep in the low-T step-function
+        # limit; 1/(inf+1) still gives the mathematically correct 0 occupation.
+        return 1.0 / (np.exp(x) + 1.0)
+
+
+def bec_condensate_fraction(temperature, critical_temperature):
+    """Condensate fraction of an ideal, homogeneous 3D Bose gas below the BEC transition.
+
+    .. math::
+
+        \\frac{N_0}{N} =
+        \\begin{cases}
+        1 - (T / T_c)^{3/2} & T < T_c \\\\
+        0 & T \\ge T_c
+        \\end{cases}
+
+    A textbook prediction of Bose-Einstein statistics for a trapped ideal
+    gas, first confirmed experimentally in 1995 in dilute alkali-atom gases
+    (Cornell and Wieman; Ketterle; 2001 Nobel Prize in Physics).
+
+    Parameters
+    ----------
+    temperature : array_like
+        Temperature(s) at which to evaluate the condensate fraction.
+    critical_temperature : float
+        The BEC transition temperature :math:`T_c`.
+
+    Returns
+    -------
+    ndarray
+        Condensate fraction :math:`N_0/N \\in [0, 1]`.
+
+    Examples
+    --------
+    >>> f = bec_condensate_fraction(np.array([0.0, 0.5, 1.0, 2.0]), critical_temperature=1.0)
+    >>> [round(float(v), 3) for v in f]
+    [1.0, 0.646, 0.0, 0.0]
+    """
+    T = np.asarray(temperature, dtype=np.float64)
+    fraction = 1.0 - (T / critical_temperature) ** 1.5
+    return np.where(critical_temperature > T, fraction, 0.0)

physicskit/statphys/visualizers/__init__.py

@@ -0,0 +1,87 @@
+"""Matplotlib- and Plotly-based visualizers for every physicskit.statphys chapter.
+
+- :mod:`physicskit.statphys.visualizers.lattice_render` -- spin grid heatmaps, sweep
+  animations, thermodynamic diagnostic plots, and percolation cluster and
+  cluster-size-distribution plots.
+- :mod:`physicskit.statphys.visualizers.vortex_render` -- XY model vector fields and
+  topological vortex/antivortex overlays.
+- :mod:`physicskit.statphys.visualizers.particle_render` -- Lennard-Jones gas snapshots,
+  velocity histograms, and motion animations.
+- :mod:`physicskit.statphys.visualizers.rg_render` -- side-by-side block-spin
+  renormalization group flow panels.
+- :mod:`physicskit.statphys.visualizers.random_walk_render` -- walk trajectories, MSD,
+  and central-limit-theorem histograms.
+- :mod:`physicskit.statphys.visualizers.sandpile_render` -- sandpile heights and
+  avalanche size distributions.
+- :mod:`physicskit.statphys.visualizers.urn_render` -- Ehrenfest urn relaxation and
+  entropy history.
+- :mod:`physicskit.statphys.visualizers.spin_glass_render` -- spin-glass replica-overlap
+  distributions.
+- :mod:`physicskit.statphys.visualizers.kpz_render` -- RSOS interface profiles and
+  width-growth scaling.
+- :mod:`physicskit.statphys.visualizers.jarzynski_render` -- nonequilibrium work
+  distributions and free-energy estimates.
+- :mod:`physicskit.statphys.visualizers.interactive` -- Plotly-based interactive
+  counterparts of the temperature sweep, vortex field, and particle
+  snapshot plots.
+"""
+
+from physicskit.statphys.visualizers.interactive import (
+    interactive_particle_snapshot,
+    interactive_temperature_sweep,
+    interactive_vortex_field,
+)
+from physicskit.statphys.visualizers.jarzynski_render import plot_work_distribution
+from physicskit.statphys.visualizers.kpz_render import plot_interface_profile, plot_width_growth
+from physicskit.statphys.visualizers.lattice_render import (
+    animate_lattice_sweeps,
+    plot_cluster_size_distribution,
+    plot_percolation_clusters,
+    plot_spin_grid,
+    plot_thermodynamics,
+)
+from physicskit.statphys.visualizers.particle_render import (
+    animate_gas,
+    plot_particle_snapshot,
+    plot_velocity_histogram,
+)
+from physicskit.statphys.visualizers.random_walk_render import (
+    plot_clt_histogram,
+    plot_msd,
+    plot_trajectories_2d,
+)
+from physicskit.statphys.visualizers.rg_render import plot_rg_flow
+from physicskit.statphys.visualizers.sandpile_render import (
+    plot_avalanche_size_distribution,
+    plot_sandpile_heights,
+)
+from physicskit.statphys.visualizers.spin_glass_render import plot_overlap_distribution
+from physicskit.statphys.visualizers.urn_render import plot_ehrenfest_history
+from physicskit.statphys.visualizers.vortex_render import plot_vortices, plot_xy_vector_field
+
+__all__ = [
+    "animate_gas",
+    "animate_lattice_sweeps",
+    "interactive_particle_snapshot",
+    "interactive_temperature_sweep",
+    "interactive_vortex_field",
+    "plot_avalanche_size_distribution",
+    "plot_clt_histogram",
+    "plot_cluster_size_distribution",
+    "plot_ehrenfest_history",
+    "plot_interface_profile",
+    "plot_msd",
+    "plot_overlap_distribution",
+    "plot_particle_snapshot",
+    "plot_percolation_clusters",
+    "plot_rg_flow",
+    "plot_sandpile_heights",
+    "plot_spin_grid",
+    "plot_thermodynamics",
+    "plot_trajectories_2d",
+    "plot_velocity_histogram",
+    "plot_vortices",
+    "plot_width_growth",
+    "plot_work_distribution",
+    "plot_xy_vector_field",
+]