physicskit 0.1.0__py3-none-any.whl

physicskit/rmt/tests/test_chiral.py

@@ -0,0 +1,273 @@
+"""Tests for the chiral ensembles (chGOE, chGUE, chGSE) -- Altland-
+Zirnbauer classes BDI, AIII, CII: block off-diagonal Hamiltonians with
+an anticommuting chiral symmetry, the QCD-type Dirac operator random
+matrix ensembles of Verbaarschot and Zahed.
+
+Two independent layers of verification, mirroring the bar set by
+``physicskit.rmt/ensembles/wishart.py`` for the underlying Laguerre machinery:
+(1) the fast production sampler's structural contract (beta, shape,
++-pairing, exact zero-mode count, reproducibility) -- trivially true by
+construction, but worth asserting as documentation; and (2) an
+independent, direct check on the actual dense block matrix
+H = [[0, W], [W^dagger, 0]] (Hermiticity, exact chiral-symmetry
+anticommutation with Gamma = diag(I, -I), and that its eigenvalues are
+exactly +-singular-values-of-W plus exact zeros) -- confirming the
+"reuse the Laguerre machinery" shortcut actually represents the linear
+algebra it claims to, not merely trusting the module docstring's
+derivation.
+"""
+
+import numpy as np
+import pytest
+from cache_utils import cached_sample
+
+import physicskit.rmt as rmt
+
+CHIRAL = [
+    ("chGOE", rmt.ensembles.chGOE, 1),
+    ("chGUE", rmt.ensembles.chGUE, 2),
+    ("chGSE", rmt.ensembles.chGSE, 4),
+]
+
+
+@pytest.mark.parametrize("name,cls,beta", CHIRAL)
+def test_beta_is_correct(name, cls, beta):
+    ens = cls(n=30, seed=0)
+    assert ens.beta == beta
+
+
+@pytest.mark.parametrize("name,cls,beta", CHIRAL)
+def test_gamma_property(name, cls, beta):
+    ens = cls(n=30, nu=10, seed=0)
+    assert ens.gamma == pytest.approx(30.0 / 40.0)
+
+
+@pytest.mark.parametrize("name,cls,beta", CHIRAL)
+def test_produces_2n_plus_nu_eigenvalues(name, cls, beta):
+    ens = cls(n=40, nu=5, seed=1)
+    spectrum = cached_sample(ens, n_samples=5)
+    assert spectrum.eigenvalues.shape == (5, 85)
+
+
+@pytest.mark.parametrize("name,cls,beta", CHIRAL)
+def test_eigenvalues_are_real(name, cls, beta):
+    ens = cls(n=35, nu=3, 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", CHIRAL)
+def test_reproducibility(name, cls, beta):
+    ens_a = cls(n=40, nu=4, seed=42)
+    ens_b = cls(n=40, nu=4, 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", CHIRAL)
+def test_spectrum_symmetric_about_zero(name, cls, beta):
+    # Chiral symmetry forces exact +-lambda pairing, like BdG -- but via
+    # an anticommuting (not commuting) operator; see module docstring.
+    ens = cls(n=50, nu=6, 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
+
+
+@pytest.mark.parametrize("name,cls,beta", CHIRAL)
+def test_exact_zero_modes_match_nu(name, cls, beta):
+    ens = cls(n=45, nu=7, seed=4)
+    spectrum = cached_sample(ens, n_samples=5)
+    for row in spectrum.eigenvalues:
+        n_zeros = np.sum(np.abs(row) < 1e-10)
+        assert n_zeros == 7
+
+
+@pytest.mark.parametrize("name,cls,beta", CHIRAL)
+def test_nonzero_eigenvalues_are_nonnegative_singular_values(name, cls, beta):
+    # +-sigma_k by construction: exactly half (rounding for nu>0's
+    # zeros) of the nonzero eigenvalues are strictly positive, the rest
+    # their exact negatives -- already covered by the pairing test, but
+    # additionally check the magnitudes are genuinely nonzero (not
+    # spuriously landing on/near zero beyond the nu exact zero modes).
+    ens = cls(n=30, nu=0, seed=5)
+    spectrum = cached_sample(ens, n_samples=5)
+    nonzero = spectrum.eigenvalues[np.abs(spectrum.eigenvalues) > 1e-10]
+    assert len(nonzero) == 5 * 60  # nu=0 -> no exact zeros
+    assert np.all(np.abs(nonzero) > 1e-6)
+
+
+def test_invalid_parameters_rejected():
+    with pytest.raises(ValueError):
+        rmt.ensembles.ChiralBetaEnsemble(n=10, beta=0, seed=0)
+    with pytest.raises(ValueError):
+        rmt.ensembles.chGUE(n=10, nu=-1, seed=0)
+
+
+def test_continuum_beta_also_produces_valid_spectrum():
+    ens = rmt.ensembles.ChiralBetaEnsemble(n=200, beta=1.7, nu=3, seed=6)
+    spectrum = cached_sample(ens, n_samples=10)
+    assert spectrum.eigenvalues.shape == (10, 403)
+    for row in spectrum.eigenvalues:
+        assert np.sum(np.abs(row) < 1e-10) == 3
+
+
+# --- Direct, un-cached structural verification of the actual block
+# matrix (independent of the fast Laguerre-reuse sampler above) ---
+
+
+@pytest.mark.parametrize("name,cls,beta", CHIRAL)
+def test_dense_construction_hermitian_and_chiral_symmetric(name, cls, beta):
+    from physicskit.rmt.ensembles.chiral import _dense_chiral_hamiltonian
+
+    rng = np.random.default_rng(7)
+    n, nu = 10, 3
+    h = _dense_chiral_hamiltonian(n, nu, rng, beta)
+    assert np.abs(h - h.conj().T).max() < 1e-10
+
+    n_dim = n if beta != 4 else 2 * n
+    m_dim = (n + nu) if beta != 4 else 2 * (n + nu)
+    gamma5 = np.diag(np.concatenate([np.ones(n_dim), -np.ones(m_dim)]))
+    anticommutator_residual = gamma5 @ h @ gamma5 + h
+    assert np.abs(anticommutator_residual).max() < 1e-10
+
+
+@pytest.mark.parametrize("name,cls,beta", CHIRAL)
+def test_dense_construction_eigenvalues_are_singular_values_plus_zeros(name, cls, beta):
+    from physicskit.rmt.ensembles.chiral import _dense_chiral_hamiltonian, _sample_block
+
+    rng = np.random.default_rng(8)
+    n, nu = 10, 3
+    rng_for_w = np.random.default_rng(8)
+    w = _sample_block(n, n + nu, rng_for_w, beta)
+    singular_values = np.linalg.svd(w, compute_uv=False)
+
+    h = _dense_chiral_hamiltonian(n, nu, rng, beta)
+    eigs = np.sort(np.linalg.eigvalsh(h))
+
+    n_dim, m_dim = w.shape
+    n_zero_modes = m_dim - n_dim  # rank deficiency of W (>= 0 for nu >= 0)
+    positive_eigs = eigs[eigs > 1e-8]
+    zero_eigs = eigs[np.abs(eigs) <= 1e-8]
+    negative_eigs = eigs[eigs < -1e-8]
+
+    assert len(zero_eigs) == n_zero_modes
+    np.testing.assert_allclose(
+        np.sort(positive_eigs),
+        np.sort(singular_values[singular_values > 1e-8]),
+        atol=1e-8,
+    )
+    np.testing.assert_allclose(np.sort(-negative_eigs), np.sort(positive_eigs), atol=1e-8)
+
+
+@pytest.mark.parametrize(
+    "name,cls,beta",
+    [("chGOE", rmt.ensembles.chGOE, 1), ("chGUE", rmt.ensembles.chGUE, 2)],
+)
+def test_fast_sampler_matches_dense_construction_statistically(name, cls, beta):
+    # Two-sample KS test between the fast (Laguerre-reuse) sampler's
+    # pooled nonzero |eigenvalue|s and the literal dense block matrix's
+    # singular values -- the same cross-check standard
+    # ``physicskit.rmt/ensembles/wishart.py`` already applies to the underlying
+    # bidiagonal trick, done here explicitly for the chiral wrapper
+    # rather than just trusted transitively. beta=4 is excluded because
+    # the dense construction's explicit quaternion embedding doubles its
+    # dimension relative to the fast sampler's generalized-beta n (see
+    # module docstring), so the two are not directly comparable sample-
+    # for-sample at matched n.
+    #
+    # Scale note: the fast sampler reuses ``sample_laguerre_beta_eigenvalues``,
+    # which returns Marchenko-Pastur-*normalized* eigenvalues -- despite
+    # dividing the raw bidiagonal-model product by (beta*m) internally
+    # (see ``physicskit.rmt/utils/tridiagonal.py``), it matches dense X^dagger @ X / m
+    # for unit-variance X at every beta (confirmed directly here, and
+    # already the standard this repo verifies against -- see
+    # ``physicskit.rmt/ensembles/wishart.py``'s module docstring), i.e. the
+    # beta-dependence is absorbed into the bidiagonal model's chi
+    # degrees of freedom, not left over as an extra factor in the
+    # normalization. So the dense construction's raw singular values
+    # (built from literal unit-variance entries) need only be divided by
+    # sqrt(m), not sqrt(beta*m), to land on the same footing.
+    from scipy.stats import ks_2samp
+
+    from physicskit.rmt.ensembles.chiral import _dense_chiral_hamiltonian
+
+    n, nu = 12, 2
+    m = n + nu
+    fast_ens = cls(n=n, nu=nu, seed=9)
+    fast_spectrum = fast_ens.sample(n_samples=400)
+    fast_nonzero = np.abs(fast_spectrum.eigenvalues[np.abs(fast_spectrum.eigenvalues) > 1e-10])
+
+    rng = np.random.default_rng(10)
+    dense_singular_values = []
+    for _ in range(400):
+        h = _dense_chiral_hamiltonian(n, nu, rng, beta)
+        eigs = np.linalg.eigvalsh(h)
+        dense_singular_values.append(np.abs(eigs[np.abs(eigs) > 1e-8]))
+    dense_nonzero = np.concatenate(dense_singular_values) / np.sqrt(m)
+
+    ks = ks_2samp(fast_nonzero, dense_nonzero)
+    assert ks.statistic < 0.05, f"{name}: fast sampler diverges from dense construction, {ks}"
+
+
+# --- QCD Dirac operator convention (D = i*H, purely imaginary spectrum) ---
+
+QCD_DIRAC = [
+    ("QCDDiracGOE", rmt.ensembles.QCDDiracGOE, rmt.ensembles.chGOE, 1),
+    ("QCDDiracGUE", rmt.ensembles.QCDDiracGUE, rmt.ensembles.chGUE, 2),
+    ("QCDDiracGSE", rmt.ensembles.QCDDiracGSE, rmt.ensembles.chGSE, 4),
+]
+
+
+@pytest.mark.parametrize("name,cls,ch_cls,beta", QCD_DIRAC)
+def test_qcd_dirac_beta_is_correct(name, cls, ch_cls, beta):
+    ens = cls(n=30, seed=0)
+    assert ens.beta == beta
+
+
+@pytest.mark.parametrize("name,cls,ch_cls,beta", QCD_DIRAC)
+def test_qcd_dirac_eigenvalues_are_purely_imaginary(name, cls, ch_cls, beta):
+    ens = cls(n=40, nu=3, seed=1)
+    spectrum = cached_sample(ens, n_samples=5)
+    assert np.iscomplexobj(spectrum.eigenvalues)
+    assert np.abs(spectrum.eigenvalues.real).max() < 1e-10
+
+
+@pytest.mark.parametrize("name,cls,ch_cls,beta", QCD_DIRAC)
+def test_qcd_dirac_is_exactly_i_times_chiral_ensemble(name, cls, ch_cls, beta):
+    # Thin-wrapper contract from the module docstring: D = i*H exactly,
+    # for the SAME underlying random draw (matched seed) -- not just
+    # matching in distribution.
+    dirac_ens = cls(n=25, nu=2, seed=7)
+    chiral_ens = ch_cls(n=25, nu=2, seed=7)
+    dirac_spectrum = dirac_ens.sample(n_samples=4)
+    chiral_spectrum = chiral_ens.sample(n_samples=4)
+    np.testing.assert_allclose(dirac_spectrum.eigenvalues, 1j * chiral_spectrum.eigenvalues)
+
+
+@pytest.mark.parametrize("name,cls,ch_cls,beta", QCD_DIRAC)
+def test_qcd_dirac_exact_zero_modes_match_nu(name, cls, ch_cls, beta):
+    ens = cls(n=45, nu=6, seed=2)
+    spectrum = cached_sample(ens, n_samples=5)
+    for row in spectrum.eigenvalues:
+        assert np.sum(np.abs(row) < 1e-10) == 6
+
+
+@pytest.mark.parametrize("name,cls,ch_cls,beta", QCD_DIRAC)
+def test_qcd_dirac_reproducibility(name, cls, ch_cls, beta):
+    ens_a = cls(n=30, nu=3, seed=42)
+    ens_b = cls(n=30, nu=3, 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_sample_block_rejects_invalid_beta():
+    from physicskit.rmt.ensembles.chiral import _sample_block
+
+    with pytest.raises(ValueError):
+        _sample_block(5, 6, np.random.default_rng(0), beta=3)

physicskit/rmt/tests/test_circular.py

@@ -0,0 +1,225 @@
+"""Tests for COE, CUE, CSE and the sine kernel benchmark.
+
+Circular ensembles are structurally different from the Gaussian/Wishart
+families: COE is NOT "eigenvalues of a Haar-random orthogonal matrix"
+and CSE is NOT "eigenvalues of a Haar-random symplectic matrix" (see the
+warning in the ``physicskit.rmt.ensembles.circular`` module docstring for why).
+These tests check both the structural correctness of each construction
+(unitarity, symmetry/self-duality, exact degeneracy for CSE) and the
+resulting spacing statistics against the already-validated Wigner
+surmise -- an independent cross-family check, since spacing statistics
+are universal in beta across the Gaussian and circular families.
+"""
+
+import numpy as np
+import pytest
+from cache_utils import cached_sample
+
+import physicskit.rmt as rmt
+from physicskit.rmt.utils.haar import haar_unitary, symplectic_form
+
+CIRCULAR = [
+    ("COE", rmt.ensembles.COE, 1),
+    ("CUE", rmt.ensembles.CUE, 2),
+    ("CSE", rmt.ensembles.CSE, 4),
+]
+
+
+def test_haar_unitary_is_unitary():
+    rng = np.random.default_rng(0)
+    u = haar_unitary(150, rng)
+    identity_error = np.abs(u.conj().T @ u - np.eye(150)).max()
+    assert identity_error < 1e-9
+
+
+def test_haar_unitary_eigenvalues_on_unit_circle():
+    rng = np.random.default_rng(1)
+    u = haar_unitary(150, rng)
+    eigs = np.linalg.eigvals(u)
+    assert np.abs(np.abs(eigs) - 1.0).max() < 1e-9
+
+
+@pytest.mark.parametrize("name,cls,beta", CIRCULAR)
+def test_beta_is_correct(name, cls, beta):
+    ens = cls(n=30, seed=0)
+    assert ens.beta == beta
+
+
+@pytest.mark.parametrize("name,cls,beta", CIRCULAR)
+def test_phases_in_valid_range(name, cls, beta):
+    ens = cls(n=100, seed=2)
+    spectrum = cached_sample(ens, n_samples=5)
+    assert np.all(spectrum.eigenvalues >= 0.0)
+    assert np.all(spectrum.eigenvalues < 2 * np.pi + 1e-9)
+
+
+@pytest.mark.parametrize("name,cls,beta", CIRCULAR)
+def test_reproducibility(name, cls, beta):
+    ens_a = cls(n=80, seed=42)
+    ens_b = cls(n=80, 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", CIRCULAR)
+def test_mean_spacing_is_exactly_unity(name, cls, beta):
+    # Unlike Gaussian/Wishart, circular ensembles have EXACT rotational
+    # invariance at any finite n, so mean spacing should be unity to
+    # floating-point precision, not just asymptotically.
+    ens = cls(n=200, seed=3)
+    spectrum = cached_sample(ens, n_samples=15)
+    spacings = rmt.stats.circular_spacings(spectrum)
+    assert spacings.mean() == pytest.approx(1.0, abs=1e-9)
+
+
+@pytest.mark.parametrize("name,cls,beta", CIRCULAR)
+def test_spacing_matches_wigner_surmise_at_matching_beta(name, cls, beta):
+    ens = cls(n=250, seed=4)
+    spectrum = cached_sample(ens, n_samples=25)
+    spacings = rmt.stats.circular_spacings(spectrum)
+    benchmark = rmt.validation.WignerSurmise(beta=beta)
+    result = benchmark.validate(spacings, seed=4)
+    assert result.ks_statistic < 0.02
+
+
+def test_coe_matrix_is_symmetric():
+    rng = np.random.default_rng(5)
+    v = haar_unitary(100, rng)
+    u = v.T @ v
+    assert np.abs(u - u.T).max() < 1e-9
+    identity_error = np.abs(u.conj().T @ u - np.eye(100)).max()
+    assert identity_error < 1e-9  # still unitary
+
+
+def test_cse_dual_matrix_is_self_dual_unitary():
+    rng = np.random.default_rng(6)
+    n2 = 60
+    v = haar_unitary(n2, rng)
+    z = symplectic_form(n2)
+    v_dual = (-z) @ v.T @ z
+    u = v_dual @ v
+    identity_error = np.abs(u.conj().T @ u - np.eye(n2)).max()
+    assert identity_error < 1e-9
+    # Self-duality: U^R == U, where U^R = Z U^T Z^{-1}
+    u_dual = (-z) @ u.T @ z
+    assert np.abs(u_dual - u).max() < 1e-8
+
+
+def test_cse_eigenvalues_are_doubly_degenerate():
+    # inspect the raw (pre-dedup) construction directly
+    rng = np.random.default_rng(7)
+    from physicskit.rmt.utils.haar import haar_unitary, symplectic_form
+
+    n2 = 80
+    v = haar_unitary(n2, rng)
+    z = symplectic_form(n2)
+    v_dual = (-z) @ v.T @ z
+    u = v_dual @ v
+    eigs = np.linalg.eigvals(u)
+    theta = np.sort(np.angle(eigs) % (2 * np.pi))
+    pair_gaps = np.diff(theta)[0::2]  # gaps WITHIN each claimed degenerate pair
+    assert np.max(np.abs(pair_gaps)) < 1e-6
+
+
+def test_sine_kernel_matches_cue_correlations():
+    ens = rmt.ensembles.CUE(n=400, seed=8)
+    spectrum = cached_sample(ens, n_samples=60)
+    benchmark = rmt.validation.SineKernel()
+    result = benchmark.validate(spectrum)
+    assert result.rmse < 0.05
+
+
+def test_sine_kernel_rejects_non_cue_beta():
+    ens = rmt.ensembles.COE(n=100, seed=0)
+    spectrum = cached_sample(ens, n_samples=5)
+    benchmark = rmt.validation.SineKernel()
+    with pytest.raises(ValueError):
+        benchmark.validate(spectrum)
+
+
+def test_sine_kernel_zero_at_origin_and_one_at_large_separation():
+    r = np.array([0.0, 0.01, 2.0, 5.0])
+    r2 = rmt.stats.sine_kernel_r2(r)
+    assert r2[0] == pytest.approx(0.0, abs=1e-9)
+    assert r2[1] < 0.01  # strong level repulsion near r=0
+    assert r2[3] == pytest.approx(1.0, abs=1e-2)
+
+
+# --- Pfaffian kernel building blocks (S, D, I) ---
+# See physicskit.rmt/stats/correlations.py module docstring: only these three
+# individually-exact building blocks are implemented, NOT their
+# combination into a beta=1/4 two-point correlation function (an
+# attempted reconstruction was checked and ruled out structurally --
+# see that docstring for the Taylor-expansion argument).
+
+
+def test_kernel_s_matches_sine_kernel_component():
+    r = np.array([0.0, 0.3, 1.0, 2.5])
+    np.testing.assert_allclose(rmt.stats.kernel_s(r) ** 2, 1.0 - rmt.stats.sine_kernel_r2(r), atol=1e-12)
+
+
+def test_kernel_d_is_derivative_of_kernel_s():
+    r = np.linspace(0.05, 3.0, 20)
+    h = 1e-6
+    finite_diff = (rmt.stats.kernel_s(r + h) - rmt.stats.kernel_s(r - h)) / (2 * h)
+    np.testing.assert_allclose(rmt.stats.kernel_d(r), finite_diff, atol=1e-4)
+
+
+def test_kernel_i_is_antiderivative_of_kernel_s():
+    from scipy.integrate import quad
+
+    for r in [0.3, 1.0, 2.0]:
+        expected, _ = quad(lambda t: rmt.stats.kernel_s(np.array([t]))[0], 0, r)
+        assert rmt.stats.kernel_i(np.array([r]))[0] == pytest.approx(expected, abs=1e-6)
+
+
+def test_kernel_d_is_odd_and_kernel_s_is_even():
+    r = np.array([0.2, 0.7, 1.5])
+    np.testing.assert_allclose(rmt.stats.kernel_s(-r), rmt.stats.kernel_s(r))
+    np.testing.assert_allclose(rmt.stats.kernel_d(-r), -rmt.stats.kernel_d(r))
+
+
+# --- general k-point determinantal correlation function (CUE) ---
+
+
+def test_k_point_correlation_reduces_to_sine_kernel_r2_at_k_2():
+    r = 0.7
+    value = rmt.stats.k_point_correlation(np.array([0.0, r]))
+    assert value == pytest.approx(rmt.stats.sine_kernel_r2(np.array([r]))[0])
+
+
+def test_k_point_correlation_vanishes_at_coincident_points():
+    # Level repulsion at all orders: a determinant with two identical
+    # rows (coincident positions) is exactly zero.
+    value = rmt.stats.k_point_correlation(np.array([0.0, 0.0, 1.5]))
+    assert value == pytest.approx(0.0, abs=1e-12)
+
+
+def test_k_point_correlation_factorizes_at_large_separation():
+    # Cluster decomposition: R_3(x1, x2, x3) -> R_2(x1, x2) as x3 -> infinity.
+    r = 0.7
+    r2 = rmt.stats.sine_kernel_r2(np.array([r]))[0]
+    r3_near = rmt.stats.k_point_correlation(np.array([0.0, r, 5.0]))
+    r3_far = rmt.stats.k_point_correlation(np.array([0.0, r, 500.0]))
+    assert abs(r3_far - r2) < abs(r3_near - r2)
+    assert r3_far == pytest.approx(r2, abs=1e-4)
+
+
+def test_level_repulsion_strength_orders_cse_cue_coe():
+    # Robust, exponent-free qualitative check (see correlations.py
+    # module docstring for why the exact beta=1/4 exponents/kernels are
+    # not asserted here): near a fixed small separation, the two-point
+    # correlation (level repulsion) should order CSE << CUE << COE,
+    # matching beta=4 > beta=2 > beta=1 repulsion strength.
+    n = 300
+    r_probe = 0.1
+    values = {}
+    ensembles = [("COE", rmt.ensembles.COE), ("CUE", rmt.ensembles.CUE), ("CSE", rmt.ensembles.CSE)]
+    for name, cls in ensembles:
+        ens = cls(n=n, seed=0)
+        spectrum = cached_sample(ens, n_samples=60)
+        centers, empirical = rmt.stats.pair_correlation_estimate(spectrum, r_max=1.0, n_bins=50)
+        idx = np.argmin(np.abs(centers - r_probe))
+        values[name] = empirical[idx]
+    assert values["CSE"] < values["CUE"] < values["COE"]

physicskit/rmt/tests/test_crossover.py

@@ -0,0 +1,72 @@
+"""Tests for GOEGUECrossoverEnsemble.
+
+The natural_scale formula sqrt(n*(1+lambda^2)) and the crossover
+behavior in level statistics (ratio statistic KS distance to the GOE
+and GUE surmises) were both verified numerically during development
+before being used here -- see module docstring in
+``physicskit.rmt/ensembles/crossover.py``.
+"""
+
+import numpy as np
+import pytest
+from cache_utils import cached_sample
+from scipy.stats import kstest
+
+import physicskit.rmt as rmt
+
+
+def test_lambda_0_recovers_goe_natural_scale():
+    ens = rmt.ensembles.GOEGUECrossoverEnsemble(n=200, lam=0.0, seed=0)
+    assert ens.natural_scale() == pytest.approx(np.sqrt(200))
+
+
+def test_natural_scale_matches_verified_formula():
+    n, lam = 300, 0.5
+    ens = rmt.ensembles.GOEGUECrossoverEnsemble(n=n, lam=lam, seed=0)
+    assert ens.natural_scale() == pytest.approx(np.sqrt(n * (1 + lam**2)))
+
+
+def test_negative_lambda_rejected():
+    with pytest.raises(ValueError):
+        rmt.ensembles.GOEGUECrossoverEnsemble(n=10, lam=-1.0, seed=0)
+
+
+def test_reproducibility():
+    ens_a = rmt.ensembles.GOEGUECrossoverEnsemble(n=40, lam=0.3, seed=42)
+    ens_b = rmt.ensembles.GOEGUECrossoverEnsemble(n=40, lam=0.3, 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_lambda_0_matches_goe_ratio_statistics():
+    ens = rmt.ensembles.GOEGUECrossoverEnsemble(n=400, lam=0.0, seed=1)
+    spectrum = cached_sample(ens, n_samples=20)
+    ratios = rmt.stats.ratio_statistics(spectrum)
+    ks = kstest(ratios, rmt.stats.RatioSurmise(beta=1).cdf).statistic
+    assert ks < 0.03
+
+
+def test_large_lambda_matches_gue_ratio_statistics():
+    ens = rmt.ensembles.GOEGUECrossoverEnsemble(n=400, lam=1.0, seed=2)
+    spectrum = cached_sample(ens, n_samples=20)
+    ratios = rmt.stats.ratio_statistics(spectrum)
+    ks = kstest(ratios, rmt.stats.RatioSurmise(beta=2).cdf).statistic
+    assert ks < 0.03
+
+
+def test_crossover_is_monotonic_between_goe_and_gue():
+    # As lambda grows from 0, KS distance to GOE should grow while KS
+    # distance to GUE should shrink -- the defining crossover behavior.
+    goe_model = rmt.stats.RatioSurmise(beta=1)
+    gue_model = rmt.stats.RatioSurmise(beta=2)
+    ks_goe = []
+    ks_gue = []
+    for lam in [0.0, 0.05, 1.0]:
+        ens = rmt.ensembles.GOEGUECrossoverEnsemble(n=400, lam=lam, seed=3)
+        spectrum = cached_sample(ens, n_samples=20)
+        ratios = rmt.stats.ratio_statistics(spectrum)
+        ks_goe.append(kstest(ratios, goe_model.cdf).statistic)
+        ks_gue.append(kstest(ratios, gue_model.cdf).statistic)
+    assert ks_goe[0] < ks_goe[1] < ks_goe[2]
+    assert ks_gue[0] > ks_gue[1] > ks_gue[2]

physicskit/rmt/tests/test_density.py

@@ -0,0 +1,23 @@
+"""Coverage for physicskit.rmt.stats.density.empirical_density (previously
+never called anywhere in the codebase)."""
+
+from __future__ import annotations
+
+import numpy as np
+
+import physicskit.rmt as rmt
+from physicskit.rmt.stats.density import empirical_density
+
+
+def test_empirical_density_rescaled_and_raw():
+    ens = rmt.ensembles.GOE(n=20, seed=0)
+    spectrum = ens.sample(n_samples=5)
+
+    centers_r, counts_r = empirical_density(spectrum, bins=20, rescaled=True)
+    assert centers_r.shape == counts_r.shape == (20,)
+    assert np.all(np.isfinite(counts_r))
+
+    centers_raw, counts_raw = empirical_density(spectrum, bins=20, rescaled=False)
+    assert centers_raw.shape == counts_raw.shape == (20,)
+    assert np.all(np.isfinite(counts_raw))
+    assert not np.allclose(centers_r, centers_raw)  # genuinely different scale