physicskit 0.1.0__py3-none-any.whl

physicskit/relativity/visualizers/spacetime_diagrams.py

@@ -0,0 +1,198 @@
+"""Kruskal-Szekeres and Penrose-Carter conformal diagrams for the Schwarzschild spacetime.
+
+Schwarzschild coordinates :math:`(t, r)` are singular at the horizon
+:math:`r = 2M` -- a mere coordinate artifact, not a physical singularity,
+but one that hides the true global structure of the spacetime. Kruskal and
+Szekeres independently found coordinates :math:`(X, T)` that are perfectly
+regular at the horizon and reveal that maximally extended Schwarzschild
+spacetime actually contains *two* asymptotically flat regions connected by
+a non-traversable wormhole (the Einstein-Rosen bridge). Compactifying
+Kruskal coordinates further via Penrose and Carter's conformal
+transformation brings the entire (infinite) spacetime into a single finite
+diagram, making the causal structure -- including the true curvature
+singularity at :math:`r=0` and the boundaries at infinity -- visible at a
+glance.
+"""
+
+from __future__ import annotations
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+__all__ = [
+    "kruskal_coordinates",
+    "penrose_carter_coordinates",
+    "plot_kruskal_diagram",
+    "plot_penrose_diagram",
+]
+
+
+def kruskal_coordinates(t, r, M):
+    """Convert Schwarzschild :math:`(t, r)` to Kruskal-Szekeres :math:`(X, T)`.
+
+    For the exterior region (:math:`r > 2M`):
+
+    .. math::
+
+        X = \\sqrt{r/2M - 1}\\, e^{r/4M} \\cosh(t/4M), \\qquad
+        T = \\sqrt{r/2M - 1}\\, e^{r/4M} \\sinh(t/4M)
+
+    and for the interior (:math:`r < 2M`), :math:`\\sinh` and
+    :math:`\\cosh` swap roles. Curves of constant :math:`r` are hyperbolae
+    :math:`X^2 - T^2 = (r/2M - 1)e^{r/2M}`; curves of constant :math:`t` are
+    straight lines through the origin; the horizon :math:`r=2M` maps to the
+    lines :math:`X = \\pm T`.
+
+    Parameters
+    ----------
+    t, r : float or array_like
+        Schwarzschild time and radial coordinates.
+    M : float
+        Mass, in geometrized units.
+
+    Returns
+    -------
+    X, T : float or ndarray
+        Kruskal-Szekeres coordinates.
+    """
+    t = np.asarray(t, dtype=np.float64)
+    r = np.asarray(r, dtype=np.float64)
+    exterior = r > 2.0 * M
+    prefactor = np.sqrt(np.abs(r / (2.0 * M) - 1.0)) * np.exp(r / (4.0 * M))
+    X = np.where(exterior, prefactor * np.cosh(t / (4.0 * M)), prefactor * np.sinh(t / (4.0 * M)))
+    T = np.where(exterior, prefactor * np.sinh(t / (4.0 * M)), prefactor * np.cosh(t / (4.0 * M)))
+    return X, T
+
+
+def penrose_carter_coordinates(t, r, M):
+    """Compactified Penrose-Carter diagram coordinates.
+
+    Applies :math:`\\arctan` to the Kruskal null coordinates
+    :math:`u = T - X`, :math:`v = T + X`, bringing the entire
+    (infinite-range) spacetime into a finite diamond
+    :math:`(\\text{space}, \\text{time}) \\in (-\\pi/2, \\pi/2)^2`.
+
+    Parameters
+    ----------
+    t, r : float or array_like
+        Schwarzschild time and radial coordinates.
+    M : float
+        Mass, in geometrized units.
+
+    Returns
+    -------
+    space, time : float or ndarray
+        Compactified diagram coordinates; light rays travel at
+        :math:`\\pm 45^\\circ` exactly as in the Kruskal diagram.
+    """
+    X, T = kruskal_coordinates(t, r, M)
+    u = T - X
+    v = T + X
+    up = np.arctan(u)
+    vp = np.arctan(v)
+    space = (vp - up) / 2.0
+    time = (vp + up) / 2.0
+    return space, time
+
+
+def _plot_r_and_t_lines(ax, coord_transform, M, r_lines, t_lines, n_dense=400, t_span=40.0, r_span=(1.0e-3, 30.0)):
+    t_dense = np.linspace(-t_span * M, t_span * M, n_dense)
+    for rl in r_lines:
+        x, y = coord_transform(t_dense, np.full_like(t_dense, rl), M)
+        ax.plot(x, y, color="steelblue", linewidth=1.0)
+
+    r_dense = np.linspace(r_span[0] * M, r_span[1] * M, n_dense)
+    for tl in t_lines:
+        x, y = coord_transform(np.full_like(r_dense, tl), r_dense, M)
+        ax.plot(x, y, color="salmon", linewidth=0.7)
+
+
+def plot_kruskal_diagram(M, ax=None, r_lines=None, t_lines=None, lim=6.0):
+    """Plot a Kruskal-Szekeres diagram: constant-:math:`r` and constant-:math:`t` grid lines,
+    the horizon light cone, and the :math:`r=0` singularity.
+
+    Parameters
+    ----------
+    M : float
+        Mass, in geometrized units.
+    ax : matplotlib.axes.Axes, optional
+        Axes to draw into. A new figure and axes are created if not given.
+    r_lines : array_like, optional
+        Radii (in units of ``M``) at which to draw constant-:math:`r` hyperbolae.
+    t_lines : array_like, optional
+        Times (in units of ``M``) at which to draw constant-:math:`t` rays.
+    lim : float, default=6.0
+        Axis limits, :math:`\\pm` this value.
+
+    Returns
+    -------
+    matplotlib.axes.Axes
+    """
+    if ax is None:
+        _, ax = plt.subplots(figsize=(6, 6))
+    if r_lines is None:
+        r_lines = np.array([0.5, 1.0, 1.5, 2.5, 3.5, 5.0]) * M
+    if t_lines is None:
+        t_lines = np.linspace(-8.0, 8.0, 9) * M
+
+    _plot_r_and_t_lines(ax, kruskal_coordinates, M, r_lines, t_lines)
+
+    ax.plot([-lim, lim], [-lim, lim], "k--", linewidth=1.2, label="horizon r=2M")
+    ax.plot([-lim, lim], [lim, -lim], "k--", linewidth=1.2)
+
+    Xs = np.linspace(-lim, lim, 200)
+    ax.plot(Xs, np.sqrt(Xs**2 + 1.0), "r-", linewidth=2, label="singularity r=0")
+    ax.plot(Xs, -np.sqrt(Xs**2 + 1.0), "r-", linewidth=2)
+
+    ax.set_xlim(-lim, lim)
+    ax.set_ylim(-lim, lim)
+    ax.set_aspect("equal")
+    ax.set_xlabel("X")
+    ax.set_ylabel("T")
+    ax.set_title("Kruskal-Szekeres diagram")
+    ax.legend(loc="upper left", fontsize=8)
+    return ax
+
+
+def plot_penrose_diagram(M, ax=None, r_lines=None, t_lines=None):
+    """Plot a compactified Penrose-Carter diagram for maximally extended Schwarzschild spacetime.
+
+    Parameters
+    ----------
+    M : float
+        Mass, in geometrized units.
+    ax : matplotlib.axes.Axes, optional
+        Axes to draw into. A new figure and axes are created if not given.
+    r_lines : array_like, optional
+        Radii (in units of ``M``) at which to draw constant-:math:`r` curves.
+    t_lines : array_like, optional
+        Times (in units of ``M``) at which to draw constant-:math:`t` curves.
+
+    Returns
+    -------
+    matplotlib.axes.Axes
+    """
+    if ax is None:
+        _, ax = plt.subplots(figsize=(6, 6))
+    if r_lines is None:
+        r_lines = np.array([0.5, 1.0, 2.0, 4.0, 8.0]) * M
+    if t_lines is None:
+        t_lines = np.linspace(-10.0, 10.0, 9) * M
+
+    _plot_r_and_t_lines(ax, penrose_carter_coordinates, M, r_lines, t_lines, t_span=200.0, r_span=(1.0e-3, 400.0))
+
+    lim = np.pi / 2.0
+    ax.plot([-lim, lim], [-lim, lim], "k--", linewidth=1.2, label="horizon r=2M")
+    ax.plot([-lim, lim], [lim, -lim], "k--", linewidth=1.2)
+
+    ax.plot([-lim, 0], [0, lim], "r-", linewidth=2, label="singularity r=0")
+    ax.plot([0, lim], [lim, 0], "r-", linewidth=2)
+
+    ax.set_xlim(-lim - 0.1, lim + 0.1)
+    ax.set_ylim(-lim - 0.1, lim + 0.1)
+    ax.set_aspect("equal")
+    ax.set_xlabel("space")
+    ax.set_ylabel("time")
+    ax.set_title("Penrose-Carter conformal diagram")
+    ax.legend(loc="upper left", fontsize=8)
+    return ax

physicskit/relativity/visualizers/wave_plots.py

@@ -0,0 +1,185 @@
+"""Visualizations of gravitational wave strain time series and spatial ripple patterns."""
+
+from __future__ import annotations
+
+import matplotlib.pyplot as plt
+import numpy as np
+from matplotlib.animation import FuncAnimation
+
+from physicskit.relativity.utils.constants import check_geometrized_distance, check_geometrized_mass
+
+__all__ = [
+    "animate_wave_ripple",
+    "plot_strain_waveform",
+    "plot_wave_ripple",
+    "wave_ripple_snapshot",
+]
+
+
+def plot_strain_waveform(t, h_plus, h_cross=None, ax=None, t_merger=None):
+    """Plot a gravitational wave strain time series.
+
+    Parameters
+    ----------
+    t : array_like
+        Time samples.
+    h_plus : array_like
+        Plus-polarization strain.
+    h_cross : array_like, optional
+        Cross-polarization strain, plotted alongside ``h_plus`` if given.
+    ax : matplotlib.axes.Axes, optional
+        Axes to draw into. A new figure and axes are created if not given.
+    t_merger : float, optional
+        Merger time, marked with a vertical dashed line.
+
+    Returns
+    -------
+    matplotlib.axes.Axes
+    """
+    if ax is None:
+        _, ax = plt.subplots(figsize=(8, 4))
+    ax.plot(t, h_plus, label=r"$h_+$", linewidth=1.2)
+    if h_cross is not None:
+        ax.plot(t, h_cross, label=r"$h_\times$", linewidth=1.0, alpha=0.75)
+    if t_merger is not None:
+        ax.axvline(t_merger, color="k", linestyle="--", linewidth=1, alpha=0.6, label="merger")
+    ax.set_xlabel("time")
+    ax.set_ylabel("strain")
+    ax.legend()
+    return ax
+
+
+def wave_ripple_snapshot(merger, t, t_merger, grid_size=150, extent=40.0):
+    """Compute a 2D spatial snapshot of a merger's radiated wave pattern in the orbital plane.
+
+    Uses the actual (oscillating) :math:`h_+` strain from
+    ``merger.full_waveform`` evaluated at each grid point's retarded time
+    :math:`t_{\\text{ret}} = t - r`, with :math:`1/r` amplitude falloff and
+    the schematic quadrupolar :math:`\\cos(2\\varphi)` azimuthal pattern
+    characteristic of the dominant (l=2, m=2) gravitational wave mode as
+    seen face-on. Using the oscillating strain itself, rather than its
+    envelope, is what makes concentric ripples appear at all: at fixed
+    ``t``, sweeping outward in ``r`` sweeps ``t_ret`` backward through the
+    chirp's accumulating phase, so the wave's rising frequency shows up
+    directly as rings that pack tighter close to the source. Warns (via
+    :func:`~physicskit.relativity.utils.constants.check_geometrized_mass` /
+    :func:`~physicskit.relativity.utils.constants.check_geometrized_distance`)
+    if ``merger``'s mass or distance looks like an unconverted physical
+    value rather than a geometrized length -- this is exactly the failure
+    mode that once made this function's animation silently non-oscillating
+    (see the package history).
+
+    Parameters
+    ----------
+    merger : BinaryMerger
+        The source binary.
+    t : float
+        Observation time.
+    t_merger : float
+        Coalescence time, forwarded to ``merger.full_waveform``.
+    grid_size : int, default=150
+        Number of grid points per spatial axis.
+    extent : float, default=40.0
+        Half-width of the spatial grid, in units of ``M``.
+
+    Returns
+    -------
+    X, Y : ndarray of shape (grid_size, grid_size)
+        Spatial grid coordinates.
+    pattern : ndarray of shape (grid_size, grid_size)
+        The schematic strain pattern at time ``t``.
+    """
+    check_geometrized_mass(merger.m1, name="merger.m1")
+    check_geometrized_mass(merger.m2, name="merger.m2")
+    check_geometrized_distance(merger.distance, name="merger.distance")
+
+    x = np.linspace(-extent, extent, grid_size)
+    y = np.linspace(-extent, extent, grid_size)
+    X, Y = np.meshgrid(x, y)
+    R = np.sqrt(X**2 + Y**2)
+    Phi = np.arctan2(Y, X)
+    R_safe = np.clip(R, 1.0, None)
+
+    t_ret = t - R_safe
+    hp_flat, _ = merger.full_waveform(t_ret.ravel(), t_merger)
+    hp = hp_flat.reshape(R.shape)
+    pattern = hp * (merger.distance / R_safe) * np.cos(2.0 * Phi)
+    return X, Y, pattern
+
+
+def plot_wave_ripple(merger, t, t_merger, ax=None, grid_size=150, extent=40.0, cmap="RdBu"):
+    """Plot one snapshot of a merger's spatial wave ripple pattern.
+
+    Parameters
+    ----------
+    merger : BinaryMerger
+        The source binary.
+    t : float
+        Observation time.
+    t_merger : float
+        Coalescence time.
+    ax : matplotlib.axes.Axes, optional
+        Axes to draw into.
+    grid_size : int, default=150
+        Spatial grid resolution.
+    extent : float, default=40.0
+        Half-width of the spatial grid, in units of ``M``.
+    cmap : str, default="RdBu"
+        Diverging colormap name.
+
+    Returns
+    -------
+    matplotlib.axes.Axes
+    """
+    X, Y, pattern = wave_ripple_snapshot(merger, t, t_merger, grid_size=grid_size, extent=extent)
+    if ax is None:
+        _, ax = plt.subplots(figsize=(6, 6))
+    vmax = np.max(np.abs(pattern)) or 1.0
+    im = ax.pcolormesh(X, Y, pattern, cmap=cmap, vmin=-vmax, vmax=vmax, shading="auto")
+    ax.set_aspect("equal")
+    ax.set_xlabel("x [M]")
+    ax.set_ylabel("y [M]")
+    ax.set_title(f"GW spatial ripple pattern, t={t:.1f}")
+    plt.colorbar(im, ax=ax, fraction=0.046, pad=0.04, label="strain (schematic)")
+    return ax
+
+
+def animate_wave_ripple(merger, t_merger, t_values, grid_size=100, extent=40.0, cmap="RdBu"):
+    """Animate a merger's spatial wave ripple pattern over a sequence of times.
+
+    Parameters
+    ----------
+    merger : BinaryMerger
+        The source binary.
+    t_merger : float
+        Coalescence time.
+    t_values : array_like
+        Sequence of observation times, one per animation frame.
+    grid_size : int, default=100
+        Spatial grid resolution.
+    extent : float, default=40.0
+        Half-width of the spatial grid, in units of ``M``.
+    cmap : str, default="RdBu"
+        Diverging colormap name.
+
+    Returns
+    -------
+    matplotlib.animation.FuncAnimation
+    """
+    fig, ax = plt.subplots(figsize=(6, 6))
+    X, Y, pattern0 = wave_ripple_snapshot(merger, t_values[0], t_merger, grid_size=grid_size, extent=extent)
+    vmax = np.max(np.abs(pattern0)) or 1.0
+    mesh = ax.pcolormesh(X, Y, pattern0, cmap=cmap, vmin=-vmax, vmax=vmax, shading="auto")
+    ax.set_aspect("equal")
+    ax.set_xlabel("x [M]")
+    ax.set_ylabel("y [M]")
+    title = ax.set_title(f"t={t_values[0]:.1f}")
+
+    def update(frame):
+        t = t_values[frame]
+        _, _, pattern = wave_ripple_snapshot(merger, t, t_merger, grid_size=grid_size, extent=extent)
+        mesh.set_array(pattern.ravel())
+        title.set_text(f"t={t:.1f}")
+        return mesh, title
+
+    return FuncAnimation(fig, update, frames=len(t_values), blit=False, interval=60)

physicskit/rmt/__init__.py

@@ -0,0 +1,8 @@
+"""physicskit.rmt -- a random matrix theory library organized around Dyson's
+threefold way, validated against exact theory and seminal-paper results."""
+
+from . import ensembles, stats, validation
+from .spectrum import Spectrum
+
+__all__ = ["ensembles", "stats", "validation", "Spectrum"]
+__version__ = "0.1.0"

physicskit/rmt/ensembles/__init__.py

@@ -0,0 +1,108 @@
+from .banded import PowerLawBandedEnsemble
+from .base import MatrixEnsemble
+from .bdg import BdGClassC, BdGClassCI, BdGClassD, BdGClassDIII
+from .chiral import (
+    ChiralBetaEnsemble,
+    QCDDiracEnsemble,
+    QCDDiracGOE,
+    QCDDiracGSE,
+    QCDDiracGUE,
+    chGOE,
+    chGSE,
+    chGUE,
+)
+from .circular import COE, CSE, CUE
+from .crossover import GOEGUECrossoverEnsemble
+from .density_matrix import BuresHallEnsemble, HilbertSchmidtEnsemble, InducedMeasureEnsemble
+from .effective_hamiltonian import (
+    EffectiveHamiltonianEnsemble,
+    EffGOE,
+    EffGSE,
+    EffGUE,
+)
+from .embedded import EmbeddedGaussianEnsemble, TwoBodyRandomEnsemble
+from .gaussian import GOE, GSE, GUE, HermiteBetaEnsemble
+from .ginibre import GinOE, GinSE, GinUE
+from .girko import GirkoElliptic, IIDEnsemble, standard_normal
+from .graph_laplacian import GraphLaplacianEnsemble
+from .haar import HaarOrthogonalEnsemble
+from .jacobi import JOE, JSE, JUE, JacobiBetaEnsemble
+from .poisson import PoissonEnsemble
+from .polynomial import PolynomialEnsemble, fuss_catalan_moment
+from .pt_symmetric import PTSymmetricEnsemble
+from .single_ring import NonHermitianWishartEnsemble, SingleRingEnsemble
+from .sparse import BernoulliWignerEnsemble, ErdosRenyiEnsemble
+from .syk import SYKEnsemble, majorana_operators
+from .truncated_unitary import TruncatedUnitaryEnsemble
+from .universality import (
+    GeneralWignerEnsemble,
+    exponential_centered_unit_variance,
+    rademacher,
+    uniform_unit_variance,
+)
+from .wishart import LOE, LSE, LUE, LaguerreBetaEnsemble
+
+__all__ = [
+    "MatrixEnsemble",
+    "HermiteBetaEnsemble",
+    "GOE",
+    "GUE",
+    "GSE",
+    "LaguerreBetaEnsemble",
+    "LOE",
+    "LUE",
+    "LSE",
+    "COE",
+    "CUE",
+    "CSE",
+    "GinOE",
+    "GinUE",
+    "GinSE",
+    "JacobiBetaEnsemble",
+    "JOE",
+    "JUE",
+    "JSE",
+    "GeneralWignerEnsemble",
+    "uniform_unit_variance",
+    "rademacher",
+    "exponential_centered_unit_variance",
+    "BdGClassD",
+    "BdGClassC",
+    "BdGClassCI",
+    "BdGClassDIII",
+    "ChiralBetaEnsemble",
+    "chGOE",
+    "chGUE",
+    "chGSE",
+    "QCDDiracEnsemble",
+    "QCDDiracGOE",
+    "QCDDiracGUE",
+    "QCDDiracGSE",
+    "EffectiveHamiltonianEnsemble",
+    "EffGOE",
+    "EffGUE",
+    "EffGSE",
+    "IIDEnsemble",
+    "GirkoElliptic",
+    "standard_normal",
+    "PoissonEnsemble",
+    "SYKEnsemble",
+    "majorana_operators",
+    "PolynomialEnsemble",
+    "fuss_catalan_moment",
+    "HaarOrthogonalEnsemble",
+    "GraphLaplacianEnsemble",
+    "ErdosRenyiEnsemble",
+    "BernoulliWignerEnsemble",
+    "PowerLawBandedEnsemble",
+    "InducedMeasureEnsemble",
+    "HilbertSchmidtEnsemble",
+    "BuresHallEnsemble",
+    "EmbeddedGaussianEnsemble",
+    "TwoBodyRandomEnsemble",
+    "SingleRingEnsemble",
+    "NonHermitianWishartEnsemble",
+    "PTSymmetricEnsemble",
+    "TruncatedUnitaryEnsemble",
+    "GOEGUECrossoverEnsemble",
+]

physicskit/rmt/ensembles/banded.py

@@ -0,0 +1,114 @@
+"""Power-law banded random matrices (PBRM) -- a random matrix model for
+the Anderson localization transition, multifractality, and 1-D
+disordered quantum chains with long-range hopping.
+
+Reference: A. D. Mirlin, Y. V. Fyodorov, F.-M. Dittes, J. Quezada,
+T. H. Seligman, "Transition from localized to extended eigenstates in
+the ensemble of power-law random banded matrices", Phys. Rev. E 54
+(1996) 3221.
+
+Construction: a real symmetric n x n matrix H with independent Gaussian
+entries, mean zero, whose variance decays as a power law in the
+distance from the diagonal:
+
+    Var(H_ij) = [1 + (``abs(i - j)`` / b)**(2*alpha)]**(-1)     (i != j)
+
+with band-width parameter ``b`` and decay exponent ``alpha``. Two
+limits recover familiar physics: alpha -> infinity (or b -> infinity)
+recovers a strictly banded matrix (short-range hopping, Anderson-
+localized eigenstates for a fixed finite band); alpha -> 0 recovers the
+standard (unbanded) GOE (delocalized, semicircle statistics). The
+celebrated special case is alpha = 1 (the default here): the model is
+then exactly at a MULTIFRACTAL critical point, with a b-dependent
+family of critical level statistics interpolating continuously between
+Poisson (b -> 0) and Wigner-Dyson/GOE (b -> infinity) -- unlike every
+other ensemble in this package, PBRM has no single universal limiting
+bulk density or fixed Dyson-class level statistic; the level statistics
+themselves are the tunable object of study, which is why no
+``natural_scale`` rescaling beyond leaving raw energies alone is
+attempted here (see ``tests/test_banded.py`` for what is checked
+instead: the two limiting regimes' qualitative behavior, not a single
+closed-form target).
+
+Diagonal entries are independent standard Gaussian (order 1, like the
+off-diagonal entries nearest the diagonal) -- their exact distribution
+does not affect the localization physics, which is governed entirely by
+the off-diagonal decay profile.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+from .base import MatrixEnsemble
+
+
+def _power_law_variance_profile(n: int, b: float, alpha: float) -> np.ndarray:
+    idx = np.arange(n)
+    distance = np.abs(idx[:, None] - idx[None, :])
+    with np.errstate(divide="ignore"):
+        variance = 1.0 / (1.0 + (distance / b) ** (2.0 * alpha))
+    return variance
+
+
+class PowerLawBandedEnsemble(MatrixEnsemble):
+    """Power-law banded random matrix ensemble (see module docstring).
+
+    Parameters
+    ----------
+    n : int
+    b : float
+        Band-width parameter (b > 0).
+    alpha : float, optional
+        Power-law decay exponent (default 1.0, the multifractal
+        critical point).
+    """
+
+    beta: float = 1
+
+    def __init__(
+        self,
+        n: int,
+        b: float,
+        alpha: float = 1.0,
+        seed: int | np.random.Generator | None = None,
+    ) -> None:
+        if b <= 0:
+            raise ValueError(f"b must be positive, got {b}")
+        super().__init__(n, seed=seed)
+        self.b = float(b)
+        self.alpha = float(alpha)
+
+    def _sample_matrix(self, rng: np.random.Generator) -> np.ndarray:
+        n = self.n
+        variance = _power_law_variance_profile(n, self.b, self.alpha)
+        std = np.sqrt(variance)
+        # A single Gaussian draw per (i, j) pair (i < j), mirrored to
+        # (j, i) -- unlike GOE's (x + x.T)/sqrt(2), which averages TWO
+        # independent draws and so needs an extra /sqrt(2), there is
+        # only one random variable per off-diagonal pair here, so
+        # Var(H_ij) = std_ij**2 = variance_ij exactly, with no further
+        # factor -- confirmed numerically during development (see
+        # tests/test_banded.py) after an initial /2 factor undershot
+        # the target profile by half.
+        upper = np.triu(rng.standard_normal((n, n)) * std, k=1)
+        h = upper + upper.T
+        h += np.diag(rng.standard_normal(n))
+        return h
+
+    def _sample_eigenvalues(self, rng: np.random.Generator) -> np.ndarray:
+        return np.linalg.eigvalsh(self._sample_matrix(rng))
+
+    def _sample_eigenvalues_and_vectors(self, rng: np.random.Generator) -> tuple[np.ndarray, np.ndarray]:
+        # Eigenvector localization (inverse participation ratio,
+        # multifractal spectrum) is the entire physical motivation for
+        # this ensemble -- see physicskit.rmt.stats.localization and
+        # tests/test_localization.py for the Anderson-localization-
+        # transition check this enables (IPR flat/O(1/n) for b large,
+        # O(1) for b small, as the band-width parameter tunes the
+        # ensemble between GOE-like and strictly-banded-localized).
+        eigenvalues, eigenvectors = np.linalg.eigh(self._sample_matrix(rng))
+        return eigenvalues, eigenvectors
+
+    def natural_scale(self) -> float:
+        return 1.0