physicskit 0.1.0__py3-none-any.whl

physicskit/rmt/tests/test_pt_symmetric.py

@@ -0,0 +1,178 @@
+"""Tests for PTSymmetricEnsemble and the real-eigenvalue-fraction
+statistic.
+
+The pseudo-Hermiticity relation P H P = H^dagger (P the fixed +-1
+signature matrix) was verified numerically to machine precision during
+development for both beta=1 and beta=2 before this construction was
+trusted -- see module docstring in
+``physicskit.rmt/ensembles/pt_symmetric.py``.
+"""
+
+import numpy as np
+import pytest
+from cache_utils import cached_sample
+
+import physicskit.rmt as rmt
+
+
+@pytest.mark.parametrize("beta", [1, 2])
+def test_pseudo_hermiticity_holds_exactly(beta):
+    p, q = 8, 6
+    ens = rmt.ensembles.PTSymmetricEnsemble(p=p, q=q, g=0.7, beta=beta, seed=0)
+    h = ens._sample_matrix(np.random.default_rng(0))
+    signature = np.diag(np.concatenate([np.ones(p), -np.ones(q)]))
+    residual = signature @ h @ signature - h.conj().T
+    assert np.abs(residual).max() < 1e-10
+
+
+@pytest.mark.parametrize("beta", [1, 2])
+def test_zero_coupling_gives_fully_real_spectrum(beta):
+    ens = rmt.ensembles.PTSymmetricEnsemble(p=10, q=10, g=0.0, beta=beta, seed=1)
+    spectrum = cached_sample(ens, n_samples=10)
+    frac = rmt.stats.real_eigenvalue_fraction(spectrum.eigenvalues)
+    np.testing.assert_allclose(frac, 1.0, atol=1e-6)
+
+
+@pytest.mark.parametrize("beta", [1, 2])
+def test_real_fraction_decreases_as_coupling_grows(beta):
+    # The PT-symmetry-breaking transition: increasing coupling g should
+    # drive the spectrum from fully real toward mostly complex.
+    fracs = []
+    for g in [0.0, 0.3, 1.0, 3.0]:
+        ens = rmt.ensembles.PTSymmetricEnsemble(p=15, q=15, g=g, beta=beta, seed=2)
+        spectrum = cached_sample(ens, n_samples=20)
+        fracs.append(rmt.stats.real_eigenvalue_fraction(spectrum.eigenvalues).mean())
+    assert fracs == sorted(fracs, reverse=True)
+    assert fracs[0] == pytest.approx(1.0, abs=1e-6)
+    assert fracs[-1] < 0.3
+
+
+def test_eigenvalues_are_real_or_conjugate_pairs():
+    # Pseudo-Hermiticity forces the eigenvalue SET to be closed under
+    # complex conjugation: every non-real eigenvalue has a partner at
+    # its complex conjugate (matched here via nearest-neighbor distance,
+    # not a naive sort, since floating-point noise can break exact ties
+    # between a conjugate pair's real parts).
+    ens = rmt.ensembles.PTSymmetricEnsemble(p=10, q=10, g=1.0, beta=2, seed=3)
+    spectrum = ens.sample(n_samples=1)
+    eigs = spectrum.eigenvalues[0]
+    non_real = eigs[np.abs(eigs.imag) > 1e-6]
+    for lam in non_real:
+        nearest_dist = np.min(np.abs(eigs - np.conj(lam)))
+        assert nearest_dist < 1e-8
+
+
+def test_invalid_parameters_rejected():
+    with pytest.raises(ValueError):
+        rmt.ensembles.PTSymmetricEnsemble(p=5, q=5, g=-1.0, seed=0)
+    with pytest.raises(ValueError):
+        rmt.ensembles.PTSymmetricEnsemble(p=5, q=5, g=1.0, beta=4, seed=0)
+
+
+def test_reproducibility():
+    ens_a = rmt.ensembles.PTSymmetricEnsemble(p=6, q=6, g=0.5, seed=42)
+    ens_b = rmt.ensembles.PTSymmetricEnsemble(p=6, q=6, g=0.5, 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)
+
+
+# --- exceptional-point detection ---
+
+
+def test_find_exceptional_points_finds_real_count_drops():
+    eps = rmt.stats.find_exceptional_points(p=6, q=6, beta=2, seed=0, g_max=3.0, n_grid=3000)
+    assert len(eps) > 0
+    assert np.all(eps > 0.0)
+    assert np.all(eps < 3.0)
+
+
+def test_eigenvector_condition_number_spikes_near_exceptional_point():
+    # The defining structural signature distinguishing a genuine
+    # exceptional point (eigenvector coalescence) from an incidental
+    # level crossing (eigenvectors stay independent): the right-
+    # eigenvector matrix's condition number should grow sharply as g
+    # approaches a detected transition.
+    eps = rmt.stats.find_exceptional_points(p=6, q=6, beta=2, seed=0, g_max=3.0, n_grid=3000)
+    g_star = eps[0]
+    cond_far = rmt.stats.eigenvector_condition_number(6, 6, 2, 0, g=max(g_star - 0.01, 0.0))
+    cond_near = rmt.stats.eigenvector_condition_number(6, 6, 2, 0, g=g_star + 5e-4)
+    assert cond_near > 2 * cond_far
+
+
+@pytest.mark.slow
+def test_mean_exceptional_point_count_grows_with_system_size():
+    # Ensemble-level statistic: mean EP count over many independent
+    # realizations should grow with system size, roughly linearly in
+    # min(p, q) -- verified during development (p=q=4,8,12 gave ~4.2,
+    # 8.7, 13.1 over g in [0, 2]).
+    mean_small, err_small = rmt.stats.mean_exceptional_point_count(p=4, q=4, beta=2, g_max=2.0, n_realizations=8, n_grid=500, seed=0)
+    mean_large, err_large = rmt.stats.mean_exceptional_point_count(p=12, q=12, beta=2, g_max=2.0, n_realizations=8, n_grid=500, seed=1)
+    assert mean_small > 0
+    assert mean_large > 2 * mean_small
+    assert err_small >= 0 and err_large >= 0
+
+
+def test_fixed_realization_reconstruction_only_rescales_coupling_block():
+    # The trick find_exceptional_points/eigenvector_condition_number rely
+    # on: rebuilding the ensemble with a different g but the same seed
+    # reproduces the same A, D blocks, only rescaling the coupling block.
+    from physicskit.rmt.stats.pt_symmetric import _fixed_realization_matrix
+
+    p, q = 5, 5
+    h1 = _fixed_realization_matrix(p, q, 2, 42, g=0.1)
+    h2 = _fixed_realization_matrix(p, q, 2, 42, g=0.5)
+    np.testing.assert_allclose(h1[:p, :p], h2[:p, :p])
+    np.testing.assert_allclose(h1[p:, p:], h2[p:, p:])
+    np.testing.assert_allclose(h1[:p, p:] / 0.1, h2[:p, p:] / 0.5)
+
+
+# --- intermediate (semi-Poisson) spacing statistics ---
+
+
+def test_semi_poisson_is_normalized_with_unit_mean_spacing():
+    from scipy.integrate import quad
+
+    norm, _ = quad(rmt.stats.semi_poisson_pdf, 0, np.inf)
+    mean, _ = quad(lambda s: s * rmt.stats.semi_poisson_pdf(np.array([s]))[0], 0, np.inf)
+    assert norm == pytest.approx(1.0, abs=1e-8)
+    assert mean == pytest.approx(1.0, abs=1e-8)
+
+
+def test_semi_poisson_cdf_is_derivative_consistent_with_pdf():
+    s = np.linspace(0.01, 5.0, 50)
+    h = 1e-6
+    finite_diff = (rmt.stats.semi_poisson_cdf(s + h) - rmt.stats.semi_poisson_cdf(s - h)) / (2 * h)
+    np.testing.assert_allclose(finite_diff, rmt.stats.semi_poisson_pdf(s), atol=1e-4)
+
+
+def test_real_axis_spacings_matches_semi_poisson_better_than_poisson_or_goe():
+    # Verified during development: at small-to-moderate coupling g, the
+    # surviving real eigenvalues' spacing statistic is closest to
+    # semi-Poisson, not pure Poisson or pure GOE -- the "intermediate
+    # statistics" signature the design plan calls for.
+    ens = rmt.ensembles.PTSymmetricEnsemble(p=25, q=25, g=0.3, beta=2, seed=0)
+    spectrum = cached_sample(ens, n_samples=200)
+    spacings = rmt.stats.real_axis_spacings(spectrum.eigenvalues)
+
+    from scipy.stats import kstest
+
+    ks_semi_poisson = kstest(spacings, rmt.stats.semi_poisson_cdf).statistic
+    ks_poisson = kstest(spacings, lambda s: 1.0 - np.exp(-s)).statistic
+    ks_goe = kstest(spacings, lambda s: rmt.stats.wigner_surmise_cdf(s, beta=1)).statistic
+
+    assert ks_semi_poisson < ks_poisson
+    assert ks_semi_poisson < ks_goe
+
+
+def test_real_axis_spacings_skips_samples_with_too_few_real_eigenvalues():
+    # All-complex sample (no real eigenvalues at all) should not crash
+    # and should be skipped, not contribute spurious spacings.
+    eigenvalues = np.array(
+        [
+            [1.0 + 2.0j, 1.0 - 2.0j, 3.0 + 1.0j, 3.0 - 1.0j],
+            [0.0 + 0j, 1.0 + 0j, 2.0 + 0j, 3.0 + 0j],
+        ]
+    )
+    spacings = rmt.stats.real_axis_spacings(eigenvalues)
+    np.testing.assert_allclose(spacings, [1.0, 1.0, 1.0])

physicskit/rmt/tests/test_random_state.py

@@ -0,0 +1,19 @@
+"""Coverage for physicskit.rmt.utils.random_state.as_generator: the
+existing-Generator passthrough branch (every ensemble test seeds with a
+plain int, so this was never exercised)."""
+
+from __future__ import annotations
+
+import numpy as np
+
+from physicskit.rmt.utils.random_state import as_generator
+
+
+def test_as_generator_returns_an_existing_generator_unchanged():
+    rng = np.random.default_rng(42)
+    assert as_generator(rng) is rng
+
+
+def test_as_generator_coerces_an_int_seed():
+    rng = as_generator(7)
+    assert isinstance(rng, np.random.Generator)

physicskit/rmt/tests/test_real_ginibre.py

@@ -0,0 +1,112 @@
+"""Tests for the real-Ginibre real-eigenvalue-count statistic and
+benchmark.
+
+The asymptotic formula sqrt(2n/pi) + 1/2 was fit against, and confirmed
+by, direct Monte Carlo real-eigenvalue counts at n = 2..128 during
+development (see ``physicskit.rmt.stats.real_ginibre`` module docstring) -- it
+is NOT the exact Edelman-Kostlan-Shub finite-n closed form, so tests use
+a loose tolerance and larger n rather than expecting near-exact
+agreement.
+"""
+
+import numpy as np
+import pytest
+from cache_utils import cached_sample
+
+import physicskit.rmt as rmt
+
+
+def test_real_eigenvalue_count_empirical_on_known_matrix():
+    # A diagonal (all-real-eigenvalue) "spectrum": every eigenvalue
+    # should be counted as real.
+    eigenvalues = np.array([[1.0 + 0j, 2.0 + 0j, -3.0 + 0j]])
+    counts = rmt.stats.real_eigenvalue_count_empirical(eigenvalues)
+    np.testing.assert_array_equal(counts, [3])
+
+
+def test_real_eigenvalue_count_empirical_mixed():
+    eigenvalues = np.array([[1.0 + 0j, 2.0 + 3.0j, 2.0 - 3.0j, -1.0 + 0j]])
+    counts = rmt.stats.real_eigenvalue_count_empirical(eigenvalues)
+    np.testing.assert_array_equal(counts, [2])
+
+
+def test_asymptotic_matches_n2_exact_value():
+    # n=2 has a well-known exact closed form: E[N_real] = sqrt(2)
+    # (P(both eigenvalues real) = 1/sqrt(2)). The asymptotic formula is
+    # not expected to be exact this low, but should be in the right
+    # ballpark.
+    theory = rmt.stats.real_eigenvalue_count_asymptotic(2)
+    assert theory == pytest.approx(np.sqrt(2), abs=0.3)
+
+
+def test_asymptotic_matches_monte_carlo_at_moderate_n():
+    n = 64
+    ens = rmt.ensembles.GinOE(n=n, seed=0)
+    spectrum = cached_sample(ens, n_samples=2000)
+    counts = rmt.stats.real_eigenvalue_count_empirical(spectrum.eigenvalues)
+    empirical_mean = counts.mean()
+    theory = rmt.stats.real_eigenvalue_count_asymptotic(n)
+    assert empirical_mean == pytest.approx(theory, rel=0.1)
+
+
+def test_real_ginibre_eigenvalue_count_benchmark():
+    n = 100
+    ens = rmt.ensembles.GinOE(n=n, seed=1)
+    spectrum = cached_sample(ens, n_samples=2000)
+    benchmark = rmt.validation.RealGinibreEigenvalueCount()
+    result = benchmark.validate(spectrum)
+    assert result.n == n
+    assert result.relative_error < 0.1
+
+
+def test_mean_real_count_grows_like_sqrt_n():
+    # The qualitative signature: E[N_real] should grow much slower than
+    # n itself (like sqrt(n)), unlike a generic extensive quantity.
+    small = rmt.stats.real_eigenvalue_count_asymptotic(25)
+    large = rmt.stats.real_eigenvalue_count_asymptotic(100)
+    # n quadruples (25->100); sqrt(n) doubles, so the count should
+    # roughly double too, not quadruple.
+    assert 1.5 < large / small < 2.5
+
+
+# --- real-eigenvalue density (not just count) ---
+
+
+def test_density_asymptotic_is_zero_outside_unit_disk():
+    n = 100
+    x = np.array([-1.5, -1.01, 1.01, 1.5])
+    density = rmt.stats.real_eigenvalue_density_asymptotic(x, n)
+    np.testing.assert_array_equal(density, 0.0)
+
+
+def test_density_asymptotic_integrates_to_the_count():
+    # The uniform-box density's total integral (height * width 2) should
+    # equal the already-verified total count formula.
+    n = 200
+    x = np.linspace(-1.0, 1.0, 20001)
+    density = rmt.stats.real_eigenvalue_density_asymptotic(x, n)
+    integral = np.trapezoid(density, x)
+    assert integral == pytest.approx(rmt.stats.real_eigenvalue_count_asymptotic(n), rel=1e-3)
+
+
+def test_density_empirical_matches_asymptotic_in_the_bulk():
+    n = 300
+    ens = rmt.ensembles.GinOE(n=n, seed=0)
+    spectrum = cached_sample(ens, n_samples=2000)
+    centers, density = rmt.stats.real_eigenvalue_density_empirical(spectrum.eigenvalues, n)
+    theory = rmt.stats.real_eigenvalue_density_asymptotic(centers, n)
+
+    bulk = np.abs(centers) < 0.8
+    assert density[bulk].mean() == pytest.approx(theory[bulk].mean(), rel=0.15)
+
+
+def test_density_empirical_drops_near_the_edge():
+    # Qualitative edge-cutoff check: density well outside the unit disk
+    # (after rescaling by sqrt(n)) should be much smaller than in the bulk.
+    n = 300
+    ens = rmt.ensembles.GinOE(n=n, seed=0)
+    spectrum = cached_sample(ens, n_samples=2000)
+    centers, density = rmt.stats.real_eigenvalue_density_empirical(spectrum.eigenvalues, n, x_max=1.3)
+    bulk_density = density[np.abs(centers) < 0.5].mean()
+    edge_density = density[np.abs(centers) > 1.15].mean()
+    assert edge_density < 0.1 * bulk_density

physicskit/rmt/tests/test_rigidity_universality.py

@@ -0,0 +1,167 @@
+"""Tests for spectral rigidity (number variance) and universality
+testing.
+
+The GUE number variance formula is *exact* (derived directly from the
+already-validated sine kernel, not an approximation), so it's tested
+against a tight tolerance. The GOE formula is confirmed by two
+independent secondary sources; the GSE formula follows the same
+commonly-cited pattern but was verified only empirically here (against
+Monte Carlo GSE) before being trusted -- both are large-L asymptotic,
+so tested with a looser tolerance and only at moderately large L.
+"""
+
+import numpy as np
+import pytest
+from cache_utils import cached_sample
+
+import physicskit.rmt as rmt
+
+
+def test_poisson_number_variance_is_exactly_l():
+    l_values = [1, 5, 10, 50]
+    np.testing.assert_allclose(rmt.stats.number_variance_poisson(l_values), l_values)
+
+
+def test_gue_number_variance_much_smaller_than_poisson():
+    # The defining qualitative signature of spectral rigidity: GUE's
+    # number variance grows logarithmically, Poisson's linearly, so at
+    # any reasonably large L, GUE's variance is far smaller.
+    l_values = [10, 50, 100]
+    gue = rmt.stats.number_variance_gue_exact(l_values)
+    poisson = rmt.stats.number_variance_poisson(l_values)
+    assert np.all(gue < poisson / 3)
+
+
+def test_gue_exact_matches_empirical_window_counting():
+    ens = rmt.ensembles.GUE(n=4000, seed=1)
+    spectrum = cached_sample(ens, n_samples=15)
+    l_values = [2, 5, 10, 20]
+    theory = rmt.stats.number_variance_gue_exact(l_values)
+    empirical = rmt.stats.number_variance_empirical(spectrum, rmt.stats.semicircle_cdf, l_values, n_windows=200, seed=0)
+    np.testing.assert_allclose(theory, empirical, atol=0.05)
+
+
+def test_goe_asymptotic_matches_empirical_at_large_l():
+    ens = rmt.ensembles.GOE(n=4000, seed=2)
+    spectrum = cached_sample(ens, n_samples=15)
+    l_values = [5, 10, 20]
+    theory = rmt.stats.number_variance_goe_asymptotic(l_values)
+    empirical = rmt.stats.number_variance_empirical(spectrum, rmt.stats.semicircle_cdf, l_values, n_windows=300, seed=0)
+    np.testing.assert_allclose(theory, empirical, atol=0.06)
+
+
+def test_gse_asymptotic_matches_empirical_at_large_l():
+    ens = rmt.ensembles.GSE(n=4000, seed=3)
+    spectrum = cached_sample(ens, n_samples=15)
+    l_values = [5, 10, 20]
+    theory = rmt.stats.number_variance_gse_asymptotic(l_values)
+    empirical = rmt.stats.number_variance_empirical(spectrum, rmt.stats.semicircle_cdf, l_values, n_windows=300, seed=0)
+    np.testing.assert_allclose(theory, empirical, atol=0.03)
+
+
+def test_number_variance_theory_dispatch():
+    l_values = [10]
+    np.testing.assert_allclose(
+        rmt.stats.number_variance_theory(l_values, beta=1),
+        rmt.stats.number_variance_goe_asymptotic(l_values),
+    )
+    np.testing.assert_allclose(
+        rmt.stats.number_variance_theory(l_values, beta=2),
+        rmt.stats.number_variance_gue_exact(l_values),
+    )
+    np.testing.assert_allclose(
+        rmt.stats.number_variance_theory(l_values, beta=4),
+        rmt.stats.number_variance_gse_asymptotic(l_values),
+    )
+    with pytest.raises(ValueError):
+        rmt.stats.number_variance_theory(l_values, beta=3)
+
+
+# --- spectral rigidity (Delta_3) ---
+
+
+def test_poisson_delta3_is_exactly_l_over_15():
+    l_values = [3, 15, 30, 60]
+    np.testing.assert_allclose(rmt.stats.spectral_rigidity_poisson(l_values), np.array(l_values) / 15.0)
+
+
+def test_poisson_delta3_empirical_matches_exact():
+    ens = rmt.ensembles.PoissonEnsemble(n=4000, seed=21)
+    spectrum = cached_sample(ens, n_samples=8)
+    l_values = [5, 10, 20, 40]
+
+    def identity_cdf(x):
+        return x / spectrum.n
+
+    empirical = rmt.stats.spectral_rigidity_empirical(spectrum, identity_cdf, l_values, n_windows=300, seed=0)
+    theory = rmt.stats.spectral_rigidity_poisson(l_values)
+    np.testing.assert_allclose(theory, empirical, rtol=0.08)
+
+
+@pytest.mark.slow
+def test_gue_delta3_theory_matches_empirical():
+    ens = rmt.ensembles.GUE(n=150, seed=22)
+    spectrum = cached_sample(ens, n_samples=20)
+    l_values = [3, 5, 8, 12]
+    theory = rmt.stats.spectral_rigidity_theory(l_values, beta=2)
+    empirical = rmt.stats.spectral_rigidity_empirical(spectrum, rmt.stats.semicircle_cdf, l_values, n_windows=200, seed=0)
+    np.testing.assert_allclose(theory, empirical, rtol=0.05)
+
+
+@pytest.mark.slow
+def test_goe_delta3_theory_matches_empirical_at_large_l():
+    ens = rmt.ensembles.GOE(n=200, seed=23)
+    spectrum = cached_sample(ens, n_samples=20)
+    l_values = [8, 12, 16, 20]
+    theory = rmt.stats.spectral_rigidity_theory(l_values, beta=1)
+    empirical = rmt.stats.spectral_rigidity_empirical(spectrum, rmt.stats.semicircle_cdf, l_values, n_windows=250, seed=0)
+    np.testing.assert_allclose(theory, empirical, rtol=0.1)
+
+
+@pytest.mark.slow
+def test_gue_delta3_much_smaller_than_poisson():
+    l_values = [10, 50, 100]
+    gue = rmt.stats.spectral_rigidity_theory(l_values, beta=2)
+    poisson = rmt.stats.spectral_rigidity_poisson(l_values)
+    assert np.all(gue < poisson / 3)
+
+
+# --- universality ---
+
+
+@pytest.mark.slow
+@pytest.mark.parametrize("beta", [1, 2])
+def test_universality_holds_across_entry_distributions(beta):
+    result = rmt.validation.check_universality(n=300, beta=beta, n_samples=10, seed=5)
+    assert set(result.per_distribution.keys()) == set(rmt.validation.DEFAULT_ENTRY_DISTRIBUTIONS.keys())
+    assert result.max_ks_statistic < 0.035
+
+
+@pytest.mark.parametrize("beta", [1, 2])
+def test_general_wigner_ensemble_matches_semicircle_directly(beta):
+    ens = rmt.ensembles.GeneralWignerEnsemble(n=1000, entry_sampler=rmt.ensembles.rademacher, beta=beta, seed=7)
+    spectrum = cached_sample(ens, n_samples=20)
+    benchmark = rmt.validation.WignerSemicircle()
+    result = benchmark.validate(spectrum, seed=7)
+    assert result.ks_statistic < 0.01
+
+
+def test_general_wigner_ensemble_rejects_beta_4():
+    with pytest.raises(ValueError):
+        rmt.ensembles.GeneralWignerEnsemble(n=100, entry_sampler=rmt.ensembles.rademacher, beta=4, seed=0)
+
+
+def test_asymmetric_exponential_entries_still_converge():
+    # The strongest universality stress test in the default set: a
+    # skewed, unbounded entry distribution should still give the
+    # symmetric semicircle law.
+    ens = rmt.ensembles.GeneralWignerEnsemble(
+        n=1000,
+        entry_sampler=rmt.ensembles.exponential_centered_unit_variance,
+        beta=2,
+        seed=11,
+    )
+    spectrum = cached_sample(ens, n_samples=20)
+    benchmark = rmt.validation.WignerSemicircle()
+    result = benchmark.validate(spectrum, seed=11)
+    assert result.ks_statistic < 0.01

physicskit/rmt/tests/test_single_ring.py

@@ -0,0 +1,132 @@
+"""Tests for the single ring theorem and NonHermitianWishartEnsemble.
+
+The exact Marchenko-Pastur moment identities E[X] = 1 and
+E[1/X] = 1/(1-gamma) (gamma < 1), which give the theoretical ring radii
+r_out=1, r_in=sqrt(1-gamma), were verified numerically against direct
+Monte Carlo before being used here (see
+``physicskit.rmt.stats.single_ring`` and ``physicskit.rmt.ensembles.single_ring`` module
+docstrings). Like every other limiting-law benchmark in this package,
+the single ring theorem is an N -> infinity result, so tests check that
+KS distance to the theoretical annulus SHRINKS with increasing N, not
+that it passes a fixed small-N threshold (confirmed during development:
+KS went from 0.046 at n=150 to 0.015 at n=1200 for a fixed gamma).
+"""
+
+import numpy as np
+import pytest
+from cache_utils import cached_sample
+from scipy.stats import linregress
+
+import physicskit.rmt as rmt
+
+
+def test_wishart_moment_identities():
+    # E[X] = 1 and E[1/X] = 1/(1-gamma) for the Marchenko-Pastur
+    # distribution -- the exact facts the theoretical ring radii rest
+    # on. Checked directly here against a fresh Monte Carlo sample,
+    # independent of the ensemble/benchmark machinery.
+    from physicskit.rmt.utils.tridiagonal import sample_laguerre_beta_eigenvalues
+
+    rng = np.random.default_rng(0)
+    n, m = 500, 1000
+    gamma = n / m
+    eigs = sample_laguerre_beta_eigenvalues(m, n, 2.0, rng)
+    assert eigs.mean() == pytest.approx(1.0, rel=0.02)
+    assert np.mean(1.0 / eigs) == pytest.approx(1.0 / (1.0 - gamma), rel=0.02)
+
+
+def test_single_ring_radii_from_uniform_singular_values():
+    # Constant singular values s=1 for everything -> a genuine circle
+    # (r_in = r_out = 1), the trivial sanity check of the raw formula.
+    r_in, r_out = rmt.stats.single_ring_radii(np.ones(50))
+    assert r_in == pytest.approx(1.0)
+    assert r_out == pytest.approx(1.0)
+
+
+def test_single_ring_radii_matches_wishart_theory():
+    gamma = 0.4
+    r_in, r_out = rmt.stats.single_ring_radii_wishart_theory(gamma)
+    assert r_out == 1.0
+    assert r_in == pytest.approx(np.sqrt(0.6))
+
+
+def test_single_ring_radii_rejects_invalid_gamma():
+    with pytest.raises(ValueError):
+        rmt.stats.single_ring_radii_wishart_theory(1.0)
+    with pytest.raises(ValueError):
+        rmt.stats.single_ring_radii_wishart_theory(0.0)
+
+
+def test_nonhermitian_wishart_rejects_gamma_geq_1():
+    with pytest.raises(ValueError):
+        rmt.ensembles.NonHermitianWishartEnsemble(n=100, m=100, seed=0)
+
+
+def test_nonhermitian_wishart_rejects_nonpositive_beta():
+    with pytest.raises(ValueError):
+        rmt.ensembles.NonHermitianWishartEnsemble(n=10, m=20, beta=0.0, seed=0)
+
+
+def test_single_ring_ensemble_and_nonhermitian_wishart_fresh_samples_are_finite():
+    # Fresh (uncached) direct .sample() calls, to actually exercise
+    # _sample_eigenvalues/natural_scale rather than risk a cache hit.
+    ens1 = rmt.ensembles.SingleRingEnsemble(n=6, singular_value_sampler=lambda rng, n: np.ones(n), seed=321)
+    spectrum1 = ens1.sample(n_samples=2)
+    assert np.all(np.isfinite(spectrum1.eigenvalues))
+    assert ens1.natural_scale() == 1.0
+
+    ens2 = rmt.ensembles.NonHermitianWishartEnsemble(n=6, m=12, seed=321)
+    spectrum2 = ens2.sample(n_samples=2)
+    assert np.all(np.isfinite(spectrum2.eigenvalues))
+    assert ens2.natural_scale() == 1.0
+
+
+def test_nonhermitian_wishart_eigenvalue_radii_stay_within_ring_edges():
+    n, m = 400, 1000
+    ens = rmt.ensembles.NonHermitianWishartEnsemble(n=n, m=m, seed=1)
+    spectrum = cached_sample(ens, n_samples=5)
+    r_in, r_out = rmt.stats.single_ring_radii_wishart_theory(ens.gamma)
+    radii = np.abs(spectrum.eigenvalues.ravel())
+    # A modest margin for finite-n boundary fluctuation (the theorem is
+    # an n -> infinity statement about the support, not a hard bound at
+    # finite n).
+    assert radii.min() > r_in - 0.15
+    assert radii.max() < r_out + 0.15
+
+
+def test_single_ring_theorem_convergence_shrinks_with_n():
+    gamma_fixed = 0.5
+    n_values = [100, 300, 900]
+    r_in, r_out = rmt.stats.single_ring_radii_wishart_theory(gamma_fixed)
+    benchmark = rmt.validation.SingleRingTheorem(r_in=r_in, r_out=r_out)
+
+    results = []
+    for n in n_values:
+        m = int(n / gamma_fixed)
+        ens = rmt.ensembles.NonHermitianWishartEnsemble(n=n, m=m, seed=5)
+        spectrum = cached_sample(ens, n_samples=max(2, 3000 // n))
+        results.append(benchmark.validate(spectrum, seed=5))
+
+    ks_stats = np.array([r.ks_statistic for r in results])
+    slope = linregress(np.log(n_values), np.log(ks_stats)).slope
+    assert slope < -0.2, f"expected shrinking KS distance, slope={slope}"
+
+
+def test_single_ring_theorem_rejects_invalid_radii():
+    with pytest.raises(ValueError):
+        rmt.validation.SingleRingTheorem(r_in=1.0, r_out=0.5)
+
+
+def test_balanced_gamma_one_collapses_to_filled_disk():
+    # gamma -> 1 (e.g. via a plain SingleRingEnsemble with Wishart-type
+    # singular values at m=n) should give r_in ~ 0, consistent with the
+    # ordinary (Ginibre) circular law rather than a genuine ring.
+    from physicskit.rmt.utils.tridiagonal import sample_laguerre_beta_eigenvalues
+
+    def wishart_singular_values(rng, n):
+        return np.sqrt(sample_laguerre_beta_eigenvalues(n, n, 2.0, rng))
+
+    ens = rmt.ensembles.SingleRingEnsemble(n=300, singular_value_sampler=wishart_singular_values, seed=2)
+    spectrum = cached_sample(ens, n_samples=5)
+    radii = np.abs(spectrum.eigenvalues.ravel())
+    assert radii.min() < 0.1  # close to 0, not bounded away like a genuine ring