physicskit 0.1.0__py3-none-any.whl

physicskit/rmt/stats/truncated_unitary.py

@@ -0,0 +1,40 @@
+"""Eigenvalue support of a truncated random unitary matrix (see
+``physicskit.rmt.ensembles.truncated_unitary`` for the construction and the
+numerical verification behind the support-radius formula below).
+
+Reference: K. Zyczkowski, H.-J. Sommers, J. Phys. A 33 (2000) 2045.
+"""
+
+import numpy as np
+
+
+def truncated_unitary_edge_radius(alpha: float) -> float:
+    """Support radius of a truncated unitary matrix's eigenvalues:
+    sqrt(alpha), for alpha = m/n the fraction of the full unitary matrix
+    kept.
+
+    Verified numerically (not assumed from memory -- an initial guess
+    of sqrt(1-alpha) had exactly the wrong alpha-dependence, caught
+    immediately since it would shrink toward 0 as more of the unitary
+    matrix is kept, contradicting the alpha=1 exact-unit-circle limit):
+    the 99th-percentile empirical eigenvalue radius converges cleanly to
+    this value as n grows at fixed alpha -- see
+    ``physicskit.rmt.ensembles.truncated_unitary`` module docstring and
+    ``tests/test_truncated_unitary.py``.
+
+    Precision note: this gives only the support EDGE, not the (known to
+    be non-uniform, edge-weighted) bulk density within the disk -- see
+    module docstring for what was and wasn't verified.
+
+    Parameters
+    ----------
+    alpha : float
+        Fraction of the full unitary matrix kept, in (0, 1].
+
+    Returns
+    -------
+    float
+    """
+    if not 0.0 < alpha <= 1.0:
+        raise ValueError(f"alpha must be in (0, 1], got {alpha}")
+    return float(np.sqrt(alpha))

physicskit/rmt/stats/unfolding.py

@@ -0,0 +1,37 @@
+"""Spectral unfolding: rescale eigenvalues locally so the mean
+nearest-neighbor spacing is 1 everywhere, which is what the spacing
+distribution and rigidity statistics are defined relative to.
+
+Where the ensemble's limiting spectral density is known exactly (e.g. the
+semicircle law for the Gaussian ensembles), unfolding via that theoretical
+CDF is preferable to a polynomial/spline fit to the empirical cumulative
+distribution: it introduces no additional fitting noise, and it's exact in
+the same sense the benchmark it will be validated against is exact.
+"""
+
+from collections.abc import Callable
+
+import numpy as np
+
+
+def unfold_by_cdf(eigenvalues: np.ndarray, cdf_func: Callable[[np.ndarray], np.ndarray]) -> np.ndarray:
+    """Unfold a single realization's eigenvalues using a known theoretical
+    integrated density (CDF).
+
+    Parameters
+    ----------
+    eigenvalues : numpy.ndarray, shape (n,)
+        A single realization's eigenvalues (already in the ensemble's
+        natural/rescaled units -- e.g. semicircle support [-2, 2]),
+        ascending order.
+    cdf_func : callable
+        The theoretical CDF matching the ensemble's limiting spectral
+        density (e.g. ``physicskit.rmt.stats.density.semicircle_cdf``).
+
+    Returns
+    -------
+    numpy.ndarray, shape (n,)
+        Unfolded eigenvalues with unit mean nearest-neighbor spacing.
+    """
+    n = len(eigenvalues)
+    return n * cdf_func(eigenvalues)

physicskit/rmt/stats/wachter.py

@@ -0,0 +1,67 @@
+"""The Wachter distribution: limiting eigenvalue density of the Jacobi
+(MANOVA) ensembles.
+
+Reference: K. W. Wachter, "The limiting empirical measure of multiple
+discriminant ratios", Ann. Statist. 8 (1980) 937. Formula and
+parametrization as given in L. Erdos, B. Farrell, "Local Eigenvalue
+Density for General MANOVA Matrices" (arXiv:1207.0031), verified
+numerically during development against real (beta=1) and complex
+(beta=2) Jacobi ensemble simulations (KS statistic < 0.002 in both
+cases at moderate N -- see ``tests/test_jacobi_wachter.py``).
+"""
+
+import numpy as np
+from scipy.integrate import quad
+
+
+def wachter_support(a: float, b: float) -> tuple[float, float]:
+    """Support edges [lambda_minus, lambda_plus] of the Wachter
+    distribution, for inverse aspect ratios a = m1/n, b = m2/n
+    (a, b >= 1)."""
+    s = a + b
+    term1 = np.sqrt((a / s) * (1.0 - 1.0 / s))
+    term2 = np.sqrt((1.0 / s) * (1.0 - a / s))
+    lam_minus = (term1 - term2) ** 2
+    lam_plus = (term1 + term2) ** 2
+    return lam_minus, lam_plus
+
+
+def wachter_pdf(x: np.ndarray, a: float, b: float) -> np.ndarray:
+    """Wachter probability density at x, for inverse aspect ratios
+    a = m1/n, b = m2/n."""
+    lam_minus, lam_plus = wachter_support(a, b)
+    x = np.asarray(x, dtype=float)
+    out = np.zeros_like(x)
+    mask = (x > lam_minus) & (x < lam_plus)
+    xm = x[mask]
+    out[mask] = (a + b) * np.sqrt((xm - lam_minus) * (lam_plus - xm)) / (2.0 * np.pi * xm * (1.0 - xm))
+    return out
+
+
+def _wachter_pdf_scalar(x: float, a: float, b: float, lam_minus: float, lam_plus: float) -> float:
+    # Non-vectorized version for use as a quad integrand (quad calls its
+    # integrand with plain Python floats; an array-returning function
+    # here caused a real bug during development -- see design notes).
+    if x <= lam_minus or x >= lam_plus:
+        return 0.0
+    return (a + b) * np.sqrt((x - lam_minus) * (lam_plus - x)) / (2.0 * np.pi * x * (1.0 - x))
+
+
+def wachter_cdf(x: np.ndarray, a: float, b: float) -> np.ndarray:
+    """Wachter CDF at x. No elementary closed form, so integrated
+    numerically from the lower edge (see
+    ``validation.wachter.Wachter`` for a fast interpolated version used
+    inside KS tests)."""
+    lam_minus, lam_plus = wachter_support(a, b)
+    x = np.atleast_1d(np.asarray(x, dtype=float))
+    out = np.zeros_like(x)
+    for i, xi in enumerate(x):
+        xi = float(xi)
+        if xi <= lam_minus:
+            out[i] = 0.0
+        elif xi >= lam_plus:
+            out[i] = 1.0
+        else:
+            val, _ = quad(_wachter_pdf_scalar, lam_minus, xi, args=(a, b, lam_minus, lam_plus))
+            out[i] = val
+    return out

physicskit/rmt/tests/cache_utils.py

@@ -0,0 +1,107 @@
+"""Disk cache for eigenvalue (and eigenvector, when present) data
+produced by sampling a MatrixEnsemble in tests -- avoids re-running
+expensive matrix diagonalization every time the test suite reruns.
+
+Usage:
+    spectrum = cached_sample(ensemble, n_samples=30)
+
+instead of:
+    spectrum = ensemble.sample(n_samples=30)
+
+Cache key is derived from the ensemble's class name, its public
+constructor-set attributes (n, m, m1, m2, beta, seed, ...), and
+n_samples -- so a fresh cache entry is created whenever any of those
+change, and reruns with identical parameters load straight from disk.
+
+NOT used for reproducibility tests that compare two independently
+constructed ensemble instances with the same seed (e.g.
+``ens_a.sample(...)`` vs ``ens_b.sample(...)``): caching by
+(class, params, seed) would make both calls hit the same cache entry,
+so the second would just re-read the first's cached array rather than
+genuinely resampling -- silently defeating the point of that test. Call
+``ensemble.sample(...)`` directly there instead.
+"""
+
+import hashlib
+import json
+from pathlib import Path
+
+import numpy as np
+
+from physicskit.rmt.spectrum import Spectrum
+
+CACHE_DIR = Path(__file__).parent / ".physicskit.rmt_test_cache"
+CACHE_DIR.mkdir(exist_ok=True)
+
+
+def _public_params(ensemble):
+    """Public, JSON-serializable constructor-set attributes of an
+    ensemble instance (n, m, m1, m2, beta, seed, ...) -- excludes
+    private attributes like ``_rng``."""
+    params = {}
+    for key, value in vars(ensemble).items():
+        if key.startswith("_"):
+            continue
+        if isinstance(value, (int, float, str, bool)) or value is None:
+            params[key] = value
+    return params
+
+
+def _cache_key(ensemble, n_samples):
+    payload = json.dumps(
+        {
+            "cls": type(ensemble).__name__,
+            "params": _public_params(ensemble),
+            "n_samples": n_samples,
+        },
+        sort_keys=True,
+    )
+    return hashlib.sha256(payload.encode()).hexdigest()[:24]
+
+
+def cached_sample(ensemble, n_samples):
+    """Sample ``ensemble`` (or load a matching cached result from disk).
+
+    Parameters
+    ----------
+    ensemble : physicskit.rmt.ensembles.base.MatrixEnsemble
+        An already-constructed ensemble instance (construction itself is
+        cheap; only ``.sample()`` -- the diagonalization -- is cached).
+    n_samples : int
+
+    Returns
+    -------
+    Spectrum
+    """
+    key = _cache_key(ensemble, n_samples)
+    path = CACHE_DIR / f"{key}.npz"
+
+    if path.exists():
+        data = np.load(path, allow_pickle=False)
+        eigenvalues = data["eigenvalues"]
+        beta_raw = data["beta"]
+        beta = None if np.isnan(beta_raw) else float(beta_raw)
+        spectrum = Spectrum(
+            eigenvalues=eigenvalues,
+            n=int(data["n"]),
+            beta=beta,
+            ensemble=str(data["ensemble_name"]),
+            scale=float(data["scale"]),
+        )
+        if "eigenvectors" in data.files:
+            spectrum.eigenvectors = data["eigenvectors"]
+        return spectrum
+
+    spectrum = ensemble.sample(n_samples=n_samples)
+    save_kwargs = dict(
+        eigenvalues=spectrum.eigenvalues,
+        n=spectrum.n,
+        beta=np.nan if spectrum.beta is None else float(spectrum.beta),
+        ensemble_name=spectrum.ensemble,
+        scale=spectrum.scale,
+    )
+    eigenvectors = getattr(spectrum, "eigenvectors", None)
+    if eigenvectors is not None:
+        save_kwargs["eigenvectors"] = eigenvectors
+    np.savez(path, **save_kwargs)
+    return spectrum

physicskit/rmt/tests/conftest.py

@@ -0,0 +1,8 @@
+"""Ensures tests/ is importable as a plain module path (for
+``from cache_utils import cached_sample``) regardless of how pytest is
+invoked (rootdir vs tests/ as cwd)."""
+
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent))

physicskit/rmt/tests/test_banded.py

@@ -0,0 +1,86 @@
+"""Tests for PowerLawBandedEnsemble (PBRM).
+
+PBRM has no single universal limiting law to validate against (the
+level statistics themselves are the tunable object of study -- see
+module docstring), so tests check: (1) the variance-profile construction
+matches its own formula directly (the actual thing that could have a
+normalization bug, as one briefly did during development -- an initial
+version halved the target variance by mistakenly reusing GOE's
+two-independent-draws averaging convention for a single-draw
+construction), and (2) the two well-understood limiting regimes behave
+qualitatively as expected (short-range/localized-like vs. GOE-like).
+"""
+
+import numpy as np
+import pytest
+from cache_utils import cached_sample
+
+import physicskit.rmt as rmt
+
+
+def test_invalid_b_rejected():
+    with pytest.raises(ValueError):
+        rmt.ensembles.PowerLawBandedEnsemble(n=10, b=0.0, seed=0)
+
+
+def test_reproducibility():
+    ens_a = rmt.ensembles.PowerLawBandedEnsemble(n=40, b=5.0, alpha=1.0, seed=42)
+    ens_b = rmt.ensembles.PowerLawBandedEnsemble(n=40, b=5.0, alpha=1.0, seed=42)
+    spec_a = ens_a.sample(n_samples=3)
+    spec_b = ens_b.sample(n_samples=3)
+    np.testing.assert_allclose(spec_a.eigenvalues, spec_b.eigenvalues)
+
+
+def test_default_alpha_is_the_critical_point():
+    ens = rmt.ensembles.PowerLawBandedEnsemble(n=10, b=3.0, seed=0)
+    assert ens.alpha == 1.0
+
+
+def test_variance_profile_matches_target_formula():
+    # Direct check of the construction's second moment against its own
+    # defining formula, pooled over many independent draws -- this is
+    # exactly the check that caught an initial /2 normalization bug
+    # during development (see module docstring).
+    from physicskit.rmt.ensembles.banded import _power_law_variance_profile
+
+    rng = np.random.default_rng(1)
+    n, b, alpha = 20, 5.0, 1.0
+    target = _power_law_variance_profile(n, b, alpha)
+
+    # Build the raw matrix directly (the same way
+    # ``PowerLawBandedEnsemble._sample_eigenvalues`` does, bypassing the
+    # eigendecomposition) many times to check H_ij's empirical variance
+    # against the target profile.
+    entries_i_j = []
+    for _ in range(30_000):
+        variance = target
+        std = np.sqrt(variance)
+        upper = np.triu(rng.standard_normal((n, n)) * std, k=1)
+        h = upper + upper.T
+        entries_i_j.append(h[0, 3])
+    entries_i_j = np.array(entries_i_j)
+    assert entries_i_j.var() == pytest.approx(target[0, 3], rel=0.1)
+
+
+def test_short_range_limit_looks_localized_narrow_band():
+    # alpha very large with a small, fixed band -> effectively a
+    # strictly banded (short-range) matrix; the bulk eigenvalue spread
+    # should stay modest (order the band width), not grow like a full
+    # GOE's sqrt(n).
+    n = 800
+    ens = rmt.ensembles.PowerLawBandedEnsemble(n=n, b=2.0, alpha=6.0, seed=2)
+    spectrum = cached_sample(ens, n_samples=3)
+    goe_like_scale = np.sqrt(n)
+    assert spectrum.eigenvalues.std() < 0.3 * goe_like_scale
+
+
+def test_large_alpha_zero_limit_approaches_goe_like_scale():
+    # alpha -> 0 makes every entry's variance -> 1 (long-range,
+    # effectively unbanded) -- this should look like a GOE matrix with
+    # unit-variance entries, i.e. eigenvalue std growing like sqrt(n),
+    # not staying bounded the way the short-range case does above.
+    n = 800
+    ens = rmt.ensembles.PowerLawBandedEnsemble(n=n, b=5.0, alpha=0.01, seed=3)
+    spectrum = cached_sample(ens, n_samples=3)
+    goe_like_scale = np.sqrt(n)
+    assert spectrum.eigenvalues.std() > 0.5 * goe_like_scale

physicskit/rmt/tests/test_base.py

@@ -0,0 +1,29 @@
+"""Coverage for physicskit.rmt.ensembles.base.MatrixEnsemble's default
+natural_scale (every concrete ensemble in this codebase overrides it, so a
+minimal dummy subclass is needed to exercise the base implementation)."""
+
+from __future__ import annotations
+
+import numpy as np
+
+from physicskit.rmt.ensembles.base import MatrixEnsemble
+
+
+class _DummyEnsemble(MatrixEnsemble):
+    """Implements only the required abstract method; relies on the base
+    class's default natural_scale (1.0, no rescaling)."""
+
+    def _sample_eigenvalues(self, rng):
+        return rng.standard_normal(self.n)
+
+
+def test_default_natural_scale_is_one():
+    ens = _DummyEnsemble(n=4, seed=0)
+    assert ens.natural_scale() == 1.0
+
+
+def test_sample_uses_default_natural_scale_unscaled():
+    ens = _DummyEnsemble(n=4, seed=0)
+    spectrum = ens.sample(n_samples=3)
+    assert spectrum.scale == 1.0
+    assert np.all(np.isfinite(spectrum.eigenvalues))

physicskit/rmt/tests/test_bdg.py

@@ -0,0 +1,133 @@
+"""Tests for the Bogoliubov-de Gennes / Altland-Zirnbauer superconductor
+classes D, C, CI, DIII.
+
+Unlike most of this package, these are validated only structurally
+(Hermiticity, correct real/complex type per class, and the defining
++-lambda eigenvalue pairing), not against a closed-form bulk or edge
+density -- see the module docstring in ``physicskit.rmt/ensembles/bdg.py`` for
+why. The constructions themselves come from two independently citable
+sources: Stephanov-Verbaarschot-Wettig (arXiv:hep-ph/0509286, citing
+Altland-Zirnbauer 1997) for classes D and C, and Stolz
+(arXiv:1707.03793, also citing Altland-Zirnbauer) for classes CI and
+DIII, whose definitions are given in purely mathematical terms
+independent of any physics convention -- reducing the risk of a
+convention mismatch relative to earlier, less precisely specified
+sources found during the initial search for this feature.
+"""
+
+import numpy as np
+import pytest
+from cache_utils import cached_sample
+
+import physicskit.rmt as rmt
+
+BDG_CLASSES = [
+    ("D", rmt.ensembles.BdGClassD, 2, False),  # (name, cls, beta, expect_real)
+    ("C", rmt.ensembles.BdGClassC, 2, False),
+    ("CI", rmt.ensembles.BdGClassCI, 1, True),
+    ("DIII", rmt.ensembles.BdGClassDIII, 4, False),
+]
+
+
+@pytest.mark.parametrize("name,cls,beta,expect_real", BDG_CLASSES)
+def test_beta_is_correct(name, cls, beta, expect_real):
+    ens = cls(n=30, seed=0)
+    assert ens.beta == beta
+
+
+@pytest.mark.parametrize("name,cls,beta,expect_real", BDG_CLASSES)
+def test_produces_2n_eigenvalues(name, cls, beta, expect_real):
+    ens = cls(n=50, seed=1)
+    spectrum = cached_sample(ens, n_samples=5)
+    assert spectrum.eigenvalues.shape == (5, 100)
+
+
+@pytest.mark.parametrize("name,cls,beta,expect_real", BDG_CLASSES)
+def test_eigenvalues_are_real(name, cls, beta, expect_real):
+    # All four classes are built from Hermitian matrices, so eigenvalues
+    # are always real-valued floats regardless of whether the underlying
+    # matrix entries are real (CI) or complex (D, C, DIII).
+    ens = cls(n=40, seed=2)
+    spectrum = cached_sample(ens, n_samples=5)
+    assert not np.iscomplexobj(spectrum.eigenvalues)
+    assert np.all(np.isfinite(spectrum.eigenvalues))
+
+
+@pytest.mark.parametrize("name,cls,beta,expect_real", BDG_CLASSES)
+def test_reproducibility(name, cls, beta, expect_real):
+    ens_a = cls(n=40, seed=42)
+    ens_b = cls(n=40, seed=42)
+    spec_a = ens_a.sample(n_samples=3)
+    spec_b = ens_b.sample(n_samples=3)
+    np.testing.assert_allclose(spec_a.eigenvalues, spec_b.eigenvalues)
+
+
+@pytest.mark.parametrize("name,cls,beta,expect_real", BDG_CLASSES)
+def test_spectrum_symmetric_about_zero(name, cls, beta, expect_real):
+    # The defining particle-hole symmetry: eigenvalues occur in
+    # +-lambda pairs (distinct values, not a Kramers-type degeneracy).
+    ens = cls(n=60, seed=3)
+    spectrum = cached_sample(ens, n_samples=10)
+    for row in spectrum.eigenvalues:
+        row_sorted = np.sort(row)
+        pairing_error = np.abs(row_sorted + row_sorted[::-1]).max()
+        assert pairing_error < 1e-8
+
+
+def test_matrix_construction_hermiticity_and_type_directly():
+    # Direct, un-cached structural check of the raw matrix construction
+    # (not just the eigenvalues) for each class, including confirming
+    # CI is REAL (not just Hermitian) and the other three are complex.
+    from physicskit.rmt.ensembles.bdg import (
+        _dense_antisymmetric,
+        _dense_hermitian,
+        _dense_symmetric,
+    )
+
+    rng = np.random.default_rng(7)
+    n = 20
+
+    a = _dense_hermitian(n, rng, complex_entries=True)
+    b_d = _dense_antisymmetric(n, rng, complex_entries=True)
+    h_d = np.block([[a, b_d], [b_d.conj().T, -a.T]])
+    assert np.abs(h_d - h_d.conj().T).max() < 1e-10
+    assert np.abs(h_d.imag).max() > 1e-3  # genuinely complex, not real
+
+    b_c = _dense_symmetric(n, rng, complex_entries=True)
+    h_c = np.block([[a, b_c], [b_c.conj().T, -a.T]])
+    assert np.abs(h_c - h_c.conj().T).max() < 1e-10
+
+    x1_ci = _dense_symmetric(n, rng, complex_entries=False)
+    x2_ci = _dense_symmetric(n, rng, complex_entries=False)
+    h_ci = np.block([[x1_ci, x2_ci], [x2_ci, -x1_ci]])
+    assert np.abs(h_ci.imag).max() == 0.0  # exactly real
+    assert np.abs(h_ci - h_ci.T).max() < 1e-10
+
+    y1 = _dense_antisymmetric(n, rng, complex_entries=False)
+    y2 = _dense_antisymmetric(n, rng, complex_entries=False)
+    x1_diii, x2_diii = 1j * y1, 1j * y2
+    h_diii = np.block([[x1_diii, x2_diii], [x2_diii, -x1_diii]])
+    assert np.abs(h_diii - h_diii.conj().T).max() < 1e-10
+    assert np.abs(h_diii.real).max() == 0.0  # exactly purely-imaginary entries
+
+    a_real = _dense_hermitian(n, rng, complex_entries=False)
+    assert np.abs(a_real.imag).max() == 0.0  # exactly real
+    assert np.abs(a_real - a_real.T).max() < 1e-10
+
+
+def test_all_four_classes_are_structurally_distinct():
+    # Sanity check that the four classes don't accidentally collapse to
+    # the same construction (a risk given how similar the block forms
+    # look on paper).
+    n = 30
+    spectra = {}
+    for name, cls, _beta, _expect_real in BDG_CLASSES:
+        ens = cls(n=n, seed=8)
+        spectra[name] = np.sort(ens.sample(n_samples=1).eigenvalues[0])
+
+    # Different beta values (D/C share beta=2 but differ in B's symmetry
+    # type; CI and DIII have distinct beta) should generally give
+    # different largest-eigenvalue values for the same seed.
+    largest = {name: spec[-1] for name, spec in spectra.items()}
+    values = list(largest.values())
+    assert len(set(np.round(values, 6))) == len(values)

physicskit/rmt/tests/test_characteristic_polynomial.py

@@ -0,0 +1,50 @@
+"""Tests for CUE characteristic polynomial moments (Keating-Snaith).
+
+The product formula was verified numerically against direct Monte Carlo
+(Haar-random unitary matrices, evaluated at theta=0) at several (n, k)
+pairs before being trusted -- see
+``physicskit.rmt/stats/characteristic_polynomial.py`` module docstring.
+"""
+
+import numpy as np
+import pytest
+from cache_utils import cached_sample
+
+import physicskit.rmt as rmt
+
+
+def test_n1_k1_matches_hand_derivation():
+    # 1x1 case: Z_1 = 1 - e^{i(phi-theta)}, E[|Z_1|^2] = 2 - 2*E[cos] = 2
+    # exactly (uniform phi over a full period).
+    assert rmt.stats.keating_snaith_moment(1, 1) == pytest.approx(2.0)
+
+
+def test_k1_special_case_is_n_plus_1():
+    # Noticed and checked during development: k=1 telescopes to n+1.
+    for n in [1, 2, 3, 4, 8]:
+        assert rmt.stats.keating_snaith_moment(n, 1) == pytest.approx(n + 1)
+
+
+def test_rejects_non_positive_k():
+    with pytest.raises(ValueError):
+        rmt.stats.keating_snaith_moment(5, 0)
+    with pytest.raises(ValueError):
+        rmt.stats.characteristic_polynomial_empirical_moment(np.zeros((1, 3)), 0)
+
+
+@pytest.mark.parametrize("n,k", [(2, 1), (3, 1), (4, 1), (2, 2)])
+def test_moment_matches_empirical_cue_simulation(n, k):
+    ens = rmt.ensembles.CUE(n=n, seed=0)
+    spectrum = cached_sample(ens, n_samples=20000)
+    theory = rmt.stats.keating_snaith_moment(n, k)
+    empirical = rmt.stats.characteristic_polynomial_empirical_moment(spectrum.eigenvalues, k)
+    assert empirical == pytest.approx(theory, rel=0.05)
+
+
+def test_moments_grow_with_k():
+    # Higher moments of a nonnegative random variable are larger (given
+    # the variable isn't a.s. constant, which |Z_n| generically isn't).
+    n = 4
+    m1 = rmt.stats.keating_snaith_moment(n, 1)
+    m2 = rmt.stats.keating_snaith_moment(n, 2)
+    assert m2 > m1