physicskit 0.1.0__py3-none-any.whl

physicskit/quantum/tests/test_entanglement.py

@@ -0,0 +1,127 @@
+"""Tests for physicskit.quantum.chapters.entanglement: Bell states, EPR/CHSH
+correlations, Ising-coupling entanglement generation, and the
+Aharonov-Bohm ring -- covering the parts test_physics_checks.py and
+test_animations.py don't already exercise (measurement_probabilities,
+monte_carlo_correlation, the reduced-density-matrix/purity/trajectory
+helpers, and the ring's spectrum/eigenstate/persistent_current).
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import pytest
+
+from physicskit.quantum.chapters.entanglement import (
+    AharonovBohmRing,
+    BellCorrelations,
+    IsingEntangler,
+    bell_state,
+)
+
+
+# --- Bell states -------------------------------------------------------------
+
+
+@pytest.mark.parametrize("kind", ["phi+", "phi-", "psi+", "psi-"])
+def test_bell_state_is_normalized(kind):
+    state = bell_state(kind)
+    assert np.vdot(state, state).real == pytest.approx(1.0)
+
+
+def test_bell_state_rejects_unknown_kind():
+    with pytest.raises(ValueError):
+        bell_state("not-a-bell-state")
+
+
+# --- BellCorrelations ---------------------------------------------------------
+
+
+def test_measurement_probabilities_of_singlet_at_matched_angles_are_anticorrelated():
+    bc = BellCorrelations()
+    probs = bc.measurement_probabilities(0.0, 0.0)
+    assert probs["++"] == pytest.approx(0.0, abs=1e-12)
+    assert probs["--"] == pytest.approx(0.0, abs=1e-12)
+    assert probs["+-"] == pytest.approx(0.5)
+    assert probs["-+"] == pytest.approx(0.5)
+    assert sum(probs.values()) == pytest.approx(1.0)
+
+
+def test_measurement_probabilities_sum_to_one_at_arbitrary_angles():
+    bc = BellCorrelations()
+    probs = bc.measurement_probabilities(0.7, -1.3)
+    assert sum(probs.values()) == pytest.approx(1.0)
+    assert all(0.0 <= p <= 1.0 for p in probs.values())
+
+
+def test_monte_carlo_correlation_converges_to_exact_correlation():
+    bc = BellCorrelations()
+    rng = np.random.default_rng(0)
+    empirical = bc.monte_carlo_correlation(0.0, 0.0, n_trials=20000, rng=rng)
+    assert empirical == pytest.approx(bc.correlation(0.0, 0.0), abs=0.03)
+
+
+# --- IsingEntangler ------------------------------------------------------------
+
+
+def test_reduced_density_matrix_and_purity_of_initial_product_state_are_pure():
+    ising = IsingEntangler(J=1.0)
+    psi0 = ising.initial_state()
+    rho = ising.reduced_density_matrix(psi0)
+    assert rho.shape == (2, 2)
+    assert np.trace(rho).real == pytest.approx(1.0)
+    assert ising.purity(psi0) == pytest.approx(1.0)
+
+
+def test_purity_drops_to_one_half_at_maximal_entanglement():
+    ising = IsingEntangler(J=1.0)
+    t_max_entangle = np.pi / 4
+    psi = ising.state(t_max_entangle)
+    assert ising.purity(psi) == pytest.approx(0.5, abs=1e-9)
+    assert ising.concurrence(psi) == pytest.approx(1.0, abs=1e-9)
+
+
+def test_state_trajectory_matches_pointwise_state_calls():
+    ising = IsingEntangler(J=1.0)
+    t_values = np.linspace(0, 1, 5)
+    trajectory = ising.state_trajectory(t_values)
+    assert trajectory.shape == (5, 4)
+    for i, t in enumerate(t_values):
+        np.testing.assert_allclose(trajectory[i], ising.state(t))
+
+
+def test_concurrence_trajectory_starts_at_zero_and_peaks_at_one():
+    ising = IsingEntangler(J=1.0)
+    t_values = np.array([0.0, np.pi / 4])
+    concurrences = ising.concurrence_trajectory(t_values)
+    assert concurrences[0] == pytest.approx(0.0, abs=1e-9)
+    assert concurrences[1] == pytest.approx(1.0, abs=1e-9)
+
+
+# --- Aharonov-Bohm ring --------------------------------------------------------
+
+
+def test_spectrum_is_sorted_and_minimal_at_n_zero_for_zero_flux():
+    ring = AharonovBohmRing(R=1.0)
+    spectrum = ring.spectrum(Phi=0.0, n_range=5)
+    assert spectrum.shape == (11,)
+    np.testing.assert_allclose(spectrum, np.sort(spectrum))
+    assert spectrum[0] == pytest.approx(0.0)
+
+
+def test_eigenstate_has_constant_magnitude():
+    ring = AharonovBohmRing(R=2.0)
+    phi = np.linspace(0, 2 * np.pi, 50, endpoint=False)
+    psi = ring.eigenstate(n=3, phi=phi)
+    np.testing.assert_allclose(np.abs(psi), 1.0 / np.sqrt(2 * np.pi * ring.R))
+
+
+def test_persistent_current_matches_analytic_derivative_of_energy():
+    ring = AharonovBohmRing(R=1.0, m=1.0, hbar=1.0, q=1.0)
+    n, Phi = 1, 0.0
+    expected = (ring.hbar**2 / (ring.m * ring.R**2 * ring.flux_quantum)) * (n - Phi / ring.flux_quantum)
+    assert ring.persistent_current(n, Phi) == pytest.approx(expected, rel=1e-6)
+
+
+def test_persistent_current_vanishes_by_symmetry_for_n_zero_at_zero_flux():
+    ring = AharonovBohmRing(R=1.0)
+    assert ring.persistent_current(n=0, Phi=0.0) == pytest.approx(0.0, abs=1e-9)

physicskit/quantum/tests/test_harmonic_spin.py

@@ -0,0 +1,140 @@
+"""Tests for physicskit.quantum.chapters.harmonic_spin: the parts of
+HarmonicOscillator/ThermalState not already exercised by
+test_physics_checks.py or test_animations.py -- time-evolved stationary
+states, squeezed states, thermal populations/distributions/variance, and
+the ThermalState convenience wrapper.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import pytest
+
+from physicskit.quantum._compat import trapz
+from physicskit.quantum.chapters.harmonic_spin import HarmonicOscillator, ThermalState
+
+
+@pytest.fixture
+def osc():
+    return HarmonicOscillator(m=1.0, omega=1.0, hbar=1.0)
+
+
+# --- Time-evolved stationary states ---------------------------------------
+
+
+def test_eigenfunction_t_has_time_independent_density(osc):
+    x = np.linspace(-6, 6, 200)
+    psi_t0 = osc.eigenfunction_t(2, x, t=0.0)
+    psi_t1 = osc.eigenfunction_t(2, x, t=1.7)
+    np.testing.assert_allclose(np.abs(psi_t0) ** 2, np.abs(psi_t1) ** 2, atol=1e-10)
+    np.testing.assert_allclose(psi_t0.real, osc.eigenfunction(2, x))
+
+
+def test_eigenfunction_t_accumulates_correct_phase(osc):
+    x = np.linspace(-6, 6, 200)
+    t = 0.3
+    psi_t = osc.eigenfunction_t(1, x, t)
+    expected_phase = np.exp(-1j * osc.energy(1) * t / osc.hbar)
+    np.testing.assert_allclose(psi_t, osc.eigenfunction(1, x) * expected_phase)
+
+
+# --- Squeezed states ---------------------------------------------------------
+
+
+def test_squeezed_vacuum_wavefunction_is_normalized(osc):
+    x = np.linspace(-10, 10, 4000)
+    psi = osc.squeezed_vacuum_wavefunction(x, r=0.5)
+    assert trapz(np.abs(psi) ** 2, x) == pytest.approx(1.0, abs=1e-3)
+
+
+def test_squeezed_vacuum_wavefunction_is_real_when_phi_is_zero(osc):
+    x = np.linspace(-10, 10, 100)
+    psi = osc.squeezed_vacuum_wavefunction(x, r=0.8, phi=0.0)
+    np.testing.assert_allclose(psi.imag, 0.0, atol=1e-12)
+
+
+def test_squeezed_vacuum_wavefunction_has_complex_chirp_when_phi_nonzero(osc):
+    x = np.linspace(-10, 10, 100)
+    psi = osc.squeezed_vacuum_wavefunction(x, r=0.8, phi=0.5)
+    assert np.any(np.abs(psi.imag) > 1e-12)
+
+
+def test_squeezed_uncertainties_matches_variance_formula(osc):
+    r = 0.6
+    dx, dp = osc.squeezed_uncertainties(r)
+    assert dx == pytest.approx(np.sqrt(osc.hbar / (2 * osc.m * osc.omega) * np.exp(-2 * r)))
+    assert dp == pytest.approx(np.sqrt(osc.hbar * osc.m * osc.omega / 2 * np.exp(2 * r)))
+
+
+def test_squeezed_uncertainties_saturates_heisenberg_bound_for_any_r(osc):
+    for r in (0.0, 0.5, 1.5):
+        dx, dp = osc.squeezed_uncertainties(r)
+        assert dx * dp == pytest.approx(osc.hbar / 2)
+
+
+def test_zero_point_uncertainties_matches_squeezed_at_r_zero(osc):
+    assert osc.zero_point_uncertainties() == osc.squeezed_uncertainties(r=0.0)
+
+
+# --- Thermal (mixed) states ---------------------------------------------------
+
+
+def test_thermal_populations_at_zero_temperature_is_ground_state(osc):
+    pops = osc.thermal_populations(T=0.0, n_max=5)
+    np.testing.assert_allclose(pops, [1.0, 0.0, 0.0, 0.0, 0.0, 0.0])
+
+
+def test_thermal_populations_sum_to_one_and_decay_with_n(osc):
+    pops = osc.thermal_populations(T=2.0, n_max=50)
+    assert pops.sum() == pytest.approx(1.0)
+    assert np.all(np.diff(pops) < 0)  # monotonically decreasing Boltzmann weights
+
+
+def test_thermal_position_distribution_is_normalized_and_symmetric(osc):
+    x = np.linspace(-15, 15, 3000)
+    P = osc.thermal_position_distribution(x, T=1.0, n_max=60)
+    assert trapz(P, x) == pytest.approx(1.0, abs=1e-2)
+    np.testing.assert_allclose(P, P[::-1], atol=1e-6)
+
+
+def test_thermal_position_variance_matches_numerical_integral(osc):
+    x = np.linspace(-20, 20, 6000)
+    T = 1.5
+    P = osc.thermal_position_distribution(x, T=T, n_max=80)
+    numeric_var = trapz(x**2 * P, x)
+    assert osc.thermal_position_variance_analytic(T) == pytest.approx(numeric_var, rel=1e-2)
+
+
+def test_thermal_position_variance_reduces_to_zero_point_as_t_to_zero(osc):
+    assert osc.thermal_position_variance_analytic(T=0.0) == pytest.approx(osc.hbar / (2 * osc.m * osc.omega))
+
+
+def test_thermal_position_variance_grows_with_temperature(osc):
+    var_cold = osc.thermal_position_variance_analytic(T=0.1)
+    var_hot = osc.thermal_position_variance_analytic(T=10.0)
+    assert var_hot > var_cold
+
+
+# --- ThermalState convenience wrapper -----------------------------------------
+
+
+def test_thermal_state_populations_delegates_to_oscillator(osc):
+    ts = ThermalState(oscillator=osc, T=2.0, n_max=30)
+    np.testing.assert_allclose(ts.populations(), osc.thermal_populations(2.0, 30, 1.0))
+
+
+def test_thermal_state_position_distribution_delegates_to_oscillator(osc):
+    x = np.linspace(-10, 10, 200)
+    ts = ThermalState(oscillator=osc, T=2.0, n_max=30)
+    np.testing.assert_allclose(ts.position_distribution(x), osc.thermal_position_distribution(x, 2.0, 1.0, 30))
+
+
+def test_thermal_state_variance_delegates_to_oscillator(osc):
+    ts = ThermalState(oscillator=osc, T=2.0)
+    assert ts.variance() == osc.thermal_position_variance_analytic(2.0, 1.0)
+
+
+def test_thermal_state_check_normalization_is_close_to_one(osc):
+    x = np.linspace(-15, 15, 3000)
+    ts = ThermalState(oscillator=osc, T=1.0, n_max=60)
+    assert ts.check_normalization(x) == pytest.approx(1.0, abs=1e-2)

physicskit/quantum/tests/test_hydrogen_am.py

@@ -0,0 +1,48 @@
+"""Tests for physicskit.quantum.chapters.hydrogen_am: the quantum-number
+validation, density, and most_probable_radius paths not already
+exercised by test_physics_checks.py/test_animations.py.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import pytest
+
+from physicskit.quantum.chapters.hydrogen_am import HydrogenOrbital, radial_wavefunction
+
+
+def test_radial_wavefunction_rejects_l_greater_or_equal_n():
+    with pytest.raises(ValueError):
+        radial_wavefunction(n=1, l=1, r=np.array([1.0]))
+
+
+def test_hydrogen_orbital_rejects_invalid_l():
+    with pytest.raises(ValueError):
+        HydrogenOrbital(n=1, l=1, m=0)
+    with pytest.raises(ValueError):
+        HydrogenOrbital(n=2, l=-1, m=0)
+
+
+def test_hydrogen_orbital_rejects_m_out_of_range():
+    with pytest.raises(ValueError):
+        HydrogenOrbital(n=2, l=0, m=1)
+
+
+def test_hydrogen_orbital_density_matches_abs_psi_squared():
+    orbital = HydrogenOrbital(n=2, l=1, m=0)
+    r = np.array([1.0, 2.0, 3.0])
+    theta = np.array([0.3, 1.0, 2.0])
+    phi = np.array([0.1, 0.5, 1.5])
+    np.testing.assert_allclose(orbital.density(r, theta, phi), np.abs(orbital.psi(r, theta, phi)) ** 2)
+
+
+def test_1s_orbital_most_probable_radius_equals_bohr_radius():
+    # The textbook result: the 1s orbital's most probable radius is exactly a0.
+    orbital = HydrogenOrbital(n=1, l=0, m=0, Z=1, a0=1.0)
+    assert orbital.most_probable_radius() == pytest.approx(1.0, rel=1e-3)
+
+
+def test_most_probable_radius_scales_inversely_with_z():
+    orbital_z1 = HydrogenOrbital(n=1, l=0, m=0, Z=1, a0=1.0)
+    orbital_z2 = HydrogenOrbital(n=1, l=0, m=0, Z=2, a0=1.0)
+    assert orbital_z2.most_probable_radius() == pytest.approx(orbital_z1.most_probable_radius() / 2, rel=1e-2)

physicskit/quantum/tests/test_measure.py

@@ -0,0 +1,110 @@
+"""Tests for physicskit.quantum.utils.measure, using a normalized Gaussian
+wavepacket ``psi(x) = (2*pi*sigma^2)^(-1/4) * exp(-(x-x0)^2/(4*sigma^2))
+* exp(i*p0*x/hbar)`` as a fixture with exactly known moments:
+``<x> = x0``, ``Var(x) = sigma^2``, ``<p> = p0``,
+``Var(p) = hbar^2/(4*sigma^2)`` -- the standard minimum-uncertainty
+state, so ``dx*dp`` should equal ``hbar/2`` exactly (to numerical
+precision), not merely satisfy the Heisenberg inequality.
+
+No test in this package previously covered this module at all.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import pytest
+
+from physicskit.quantum.utils.measure import (
+    ExpectationMonitor,
+    expectation_value,
+    momentum_density,
+    momentum_expectation,
+    momentum_variance,
+    position_expectation,
+    position_variance,
+    simulate_position_measurement,
+    uncertainty,
+)
+
+HBAR = 1.0
+X0, P0, SIGMA = 2.0, 3.0, 1.0
+X = np.linspace(-20.0, 20.0, 4000)
+
+
+def _gaussian_wavepacket(x0=X0, p0=P0, sigma=SIGMA):
+    return (2.0 * np.pi * sigma**2) ** -0.25 * np.exp(-((X - x0) ** 2) / (4.0 * sigma**2)) * np.exp(1j * p0 * X / HBAR)
+
+
+def test_expectation_value_of_position_operator_matches_position_expectation():
+    psi = _gaussian_wavepacket()
+    ev = expectation_value(lambda x, p: x * p, X, psi)
+    assert ev.real == pytest.approx(X0, abs=1e-9)
+    assert ev.imag == pytest.approx(0.0, abs=1e-9)
+    assert ev.real == pytest.approx(position_expectation(X, psi))
+
+
+def test_position_expectation_and_variance_match_gaussian_moments():
+    psi = _gaussian_wavepacket()
+    assert position_expectation(X, psi) == pytest.approx(X0, abs=1e-9)
+    assert position_variance(X, psi) == pytest.approx(SIGMA**2, abs=1e-9)
+
+
+def test_momentum_density_is_normalized():
+    psi = _gaussian_wavepacket()
+    p, psi_p = momentum_density(X, psi, HBAR)
+    assert np.all(np.diff(p) > 0)  # returned ascending, per docstring
+    assert np.trapezoid(np.abs(psi_p) ** 2, p) == pytest.approx(1.0, rel=1e-6)
+
+
+def test_momentum_expectation_and_variance_match_gaussian_moments():
+    psi = _gaussian_wavepacket()
+    assert momentum_expectation(X, psi, HBAR) == pytest.approx(P0, rel=1e-6)
+    assert momentum_variance(X, psi, HBAR) == pytest.approx(HBAR**2 / (4.0 * SIGMA**2), rel=1e-4)
+
+
+def test_uncertainty_saturates_heisenberg_bound_for_minimum_uncertainty_gaussian():
+    psi = _gaussian_wavepacket()
+    dx, dp, product = uncertainty(X, psi, HBAR)
+    assert dx == pytest.approx(SIGMA, abs=1e-6)
+    assert dp == pytest.approx(HBAR / (2.0 * SIGMA), rel=1e-4)
+    assert product == pytest.approx(HBAR / 2.0, rel=1e-4)
+    assert product >= HBAR / 2.0 - 1e-9
+
+
+def test_expectation_monitor_record_all_matches_direct_calls_per_frame():
+    times = np.array([0.0, 1.0, 2.0])
+    frames = np.array([_gaussian_wavepacket(x0=X0 + dt) for dt in times])
+
+    monitor = ExpectationMonitor(x=X, hbar=HBAR)
+    monitor.record_all(times, frames)
+    arrays = monitor.as_arrays()
+
+    np.testing.assert_allclose(arrays["t"], times)
+    np.testing.assert_allclose(arrays["x"], X0 + times, atol=1e-9)
+    np.testing.assert_allclose(arrays["norm"], 1.0, atol=1e-6)
+    np.testing.assert_allclose(arrays["dx"], SIGMA, atol=1e-6)
+
+
+def test_expectation_monitor_record_single_snapshot_matches_uncertainty_directly():
+    monitor = ExpectationMonitor(x=X, hbar=HBAR)
+    psi = _gaussian_wavepacket()
+    monitor.record(0.5, psi)
+    dx, dp, _ = uncertainty(X, psi, HBAR)
+    assert monitor.history["t"] == [0.5]
+    assert monitor.history["dx"][0] == pytest.approx(dx)
+    assert monitor.history["dp"][0] == pytest.approx(dp)
+
+
+def test_simulate_position_measurement_samples_match_born_rule_moments():
+    psi = _gaussian_wavepacket()
+    samples = simulate_position_measurement(X, psi, n_samples=200_000, rng=np.random.default_rng(0))
+    assert samples.shape == (200_000,)
+    assert samples.mean() == pytest.approx(X0, abs=0.05)
+    assert samples.var() == pytest.approx(SIGMA**2, rel=0.05)
+
+
+def test_simulate_position_measurement_defaults_to_a_single_sample():
+    psi = _gaussian_wavepacket()
+    sample = simulate_position_measurement(X, psi)
+    assert sample.shape == (1,)
+    assert X.min() <= sample[0] <= X.max()

physicskit/quantum/tests/test_operators.py

@@ -0,0 +1,105 @@
+"""Tests for physicskit.quantum.core.operators, none of which any other
+test in the suite exercises directly (test_physics_checks.py etc. work
+at the wavefunction/solver level, not the operator-algebra level)."""
+
+from __future__ import annotations
+
+import numpy as np
+import pytest
+
+from physicskit.quantum.core.operators import (
+    annihilation_operator,
+    anticommutator,
+    commutator,
+    creation_operator,
+    expectation,
+    is_hermitian,
+    momentum_operator,
+    number_operator,
+    position_operator,
+    sigma_x,
+    sigma_y,
+    sigma_z,
+    spin_operator,
+)
+
+
+def test_spin_operator_half_reduces_to_scaled_pauli_matrices():
+    np.testing.assert_allclose(spin_operator("x", 0.5), 0.5 * sigma_x)
+    np.testing.assert_allclose(spin_operator("y", 0.5), 0.5 * sigma_y)
+    np.testing.assert_allclose(spin_operator("z", 0.5), 0.5 * sigma_z)
+
+
+def test_spin_operator_ladder_operators_reconstruct_x_and_y():
+    s_plus = spin_operator("+", 0.5)
+    s_minus = spin_operator("-", 0.5)
+    np.testing.assert_allclose(0.5 * (s_plus + s_minus), spin_operator("x", 0.5))
+    np.testing.assert_allclose((s_plus - s_minus) / (2j), spin_operator("y", 0.5))
+    np.testing.assert_allclose(s_minus, s_plus.conj().T)
+
+
+@pytest.mark.parametrize("s", [0.5, 1.0, 1.5, 2.0])
+def test_spin_operator_satisfies_angular_momentum_commutation_relations(s):
+    """[Sx, Sy] = i*hbar*Sz (and cyclic permutations), for both integer
+    and half-integer spin, not just the spin-1/2 Pauli case."""
+    sx, sy, sz = spin_operator("x", s), spin_operator("y", s), spin_operator("z", s)
+    np.testing.assert_allclose(commutator(sx, sy), 1j * sz, atol=1e-10)
+    np.testing.assert_allclose(commutator(sy, sz), 1j * sx, atol=1e-10)
+    np.testing.assert_allclose(commutator(sz, sx), 1j * sy, atol=1e-10)
+
+
+def test_spin_operator_rejects_unknown_axis():
+    with pytest.raises(ValueError):
+        spin_operator("q")
+
+
+def test_creation_operator_is_hermitian_conjugate_of_annihilation():
+    a = annihilation_operator(6)
+    a_dagger = creation_operator(6)
+    np.testing.assert_allclose(a_dagger, a.conj().T)
+
+
+def test_number_operator_is_diagonal_with_fock_state_eigenvalues():
+    n_max = 6
+    N = number_operator(n_max)
+    np.testing.assert_allclose(np.diag(N).real, np.arange(n_max))
+    off_diag = N - np.diag(np.diag(N))
+    np.testing.assert_allclose(off_diag, 0.0)
+
+
+def test_position_and_momentum_operators_satisfy_canonical_commutation():
+    """[x, p] = i*hbar*I, except at the last row/column where truncating
+    the Fock basis necessarily breaks the identity (a itself already
+    truncates there)."""
+    n_max = 8
+    x = position_operator(n_max, m=2.0, omega=3.0, hbar=1.0)
+    p = momentum_operator(n_max, m=2.0, omega=3.0, hbar=1.0)
+    comm = commutator(x, p)
+    np.testing.assert_allclose(np.diag(comm)[:-1], 1j * np.ones(n_max - 1), atol=1e-10)
+
+
+def test_commutator_and_anticommutator_of_pauli_matrices():
+    # Standard su(2) identities: [sigma_x, sigma_y] = 2i*sigma_z,
+    # {sigma_x, sigma_y} = 0 (distinct Pauli matrices anticommute).
+    np.testing.assert_allclose(commutator(sigma_x, sigma_y), 2j * sigma_z)
+    np.testing.assert_allclose(anticommutator(sigma_x, sigma_y), np.zeros((2, 2)), atol=1e-12)
+    np.testing.assert_allclose(anticommutator(sigma_x, sigma_x), 2 * np.eye(2))
+
+
+def test_expectation_of_sigma_z_on_basis_states():
+    up = np.array([1.0, 0.0])
+    down = np.array([0.0, 1.0])
+    assert expectation(sigma_z, up) == pytest.approx(1.0)
+    assert expectation(sigma_z, down) == pytest.approx(-1.0)
+
+
+def test_expectation_flattens_non_1d_state_input():
+    up_column = np.array([[1.0], [0.0]])
+    assert expectation(sigma_z, up_column) == pytest.approx(1.0)
+
+
+def test_is_hermitian_true_for_pauli_matrices_false_for_non_hermitian():
+    assert is_hermitian(sigma_x)
+    assert is_hermitian(sigma_y)
+    assert is_hermitian(sigma_z)
+    assert not is_hermitian(np.array([[0.0, 1.0], [0.0, 0.0]]))

physicskit/quantum/tests/test_perturbation.py

@@ -0,0 +1,112 @@
+"""Tests for physicskit.quantum.chapters.perturbation: Zeeman and linear
+Stark shifts (closed-form formulas), and the Floquet-driven infinite box.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import pytest
+
+from physicskit.quantum._compat import trapz
+from physicskit.quantum.chapters.perturbation import (
+    FloquetDrivenBox,
+    linear_stark_shift,
+    stark_n2_quartet,
+    zeeman_splitting,
+    zeeman_spectrum,
+)
+from physicskit.quantum.core.solvers import SplitOperatorSolver1D
+
+
+# --- Zeeman -------------------------------------------------------------
+
+
+def test_zeeman_splitting_matches_formula():
+    # Delta E = mu_B * B * (m_l + g_s * m_s)
+    assert zeeman_splitting(m_l=1, m_s=0.5, B=2.0, mu_B=1.0, g_s=2.0) == pytest.approx(4.0)
+    assert zeeman_splitting(m_l=0, m_s=0.0, B=5.0) == pytest.approx(0.0)
+
+
+def test_zeeman_splitting_zero_field_has_no_shift():
+    assert zeeman_splitting(m_l=3, m_s=-0.5, B=0.0) == pytest.approx(0.0)
+
+
+def test_zeeman_spectrum_has_2_times_2l_plus_1_sorted_sublevels():
+    l = 1
+    shifts = zeeman_spectrum(l, B=1.0, mu_B=1.0, g_s=2.0)
+    assert shifts.shape == (2 * (2 * l + 1),)
+    np.testing.assert_allclose(shifts, np.sort(shifts))
+    np.testing.assert_allclose(shifts, [-2.0, -1.0, 0.0, 0.0, 1.0, 2.0])
+
+
+# --- Linear Stark effect --------------------------------------------------
+
+
+def test_linear_stark_shift_matches_formula():
+    # valid: n1+n2+|m|+1 = n
+    shift = linear_stark_shift(n=2, n1=1, n2=0, m=0, F=1.0, a0=1.0)
+    assert shift == pytest.approx(1.5 * 2 * (1 - 0) * 1.0 * 1.0)
+
+
+def test_linear_stark_shift_rejects_invalid_parabolic_numbers():
+    with pytest.raises(ValueError):
+        linear_stark_shift(n=2, n1=0, n2=0, m=0, F=1.0)
+
+
+def test_stark_n2_quartet_reproduces_classic_minus3_0_0_plus3_pattern():
+    levels = stark_n2_quartet(F=1.0, a0=1.0)
+    shifts = [lv.shift for lv in levels]
+    assert shifts == sorted(shifts)
+    np.testing.assert_allclose(shifts, [-3.0, 0.0, 0.0, 3.0])
+
+
+def test_stark_n2_quartet_scales_linearly_with_field():
+    levels_1 = stark_n2_quartet(F=1.0)
+    levels_2 = stark_n2_quartet(F=2.0)
+    np.testing.assert_allclose([lv.shift for lv in levels_2], [2 * lv.shift for lv in levels_1])
+
+
+# --- Floquet-driven box ---------------------------------------------------
+
+
+@pytest.fixture
+def small_box():
+    return FloquetDrivenBox(L=1.0, V0=5.0, omega=20.0, n_grid=256)
+
+
+def test_box_eigenstate_is_normalized_and_vanishes_outside_well(small_box):
+    psi = small_box.box_eigenstate(1)
+    assert trapz(psi**2, small_box.x) == pytest.approx(1.0, abs=1e-3)
+    outside = (small_box.x < 0) | (small_box.x > small_box.L)
+    np.testing.assert_allclose(psi[outside], 0.0)
+
+
+def test_box_energy_matches_infinite_well_formula(small_box):
+    for n in (1, 2, 3):
+        expected = (n**2 * np.pi**2 * small_box.hbar**2) / (2 * small_box.m * small_box.L**2)
+        assert small_box.box_energy(n) == pytest.approx(expected)
+
+
+def test_make_solver_returns_configured_split_operator_solver(small_box):
+    solver = small_box.make_solver(dt=1e-4)
+    assert isinstance(solver, SplitOperatorSolver1D)
+    np.testing.assert_allclose(solver.x, small_box.x)
+
+
+def test_transition_probability_starts_near_delta_function(small_box):
+    times, probs = small_box.transition_probability(n_initial=1, n_final=1, t_max=1e-3, dt=1e-4)
+    assert times.shape == probs.shape
+    assert probs[0] == pytest.approx(1.0, abs=1e-2)
+    assert np.all(probs >= -1e-9) and np.all(probs <= 1.0 + 1e-9)
+
+
+def test_transition_probability_off_diagonal_starts_near_zero(small_box):
+    _, probs = small_box.transition_probability(n_initial=1, n_final=2, t_max=1e-3, dt=1e-4)
+    assert probs[0] == pytest.approx(0.0, abs=1e-2)
+
+
+def test_floquet_quasienergies_are_real_and_sorted(small_box):
+    quasi_energies = small_box.floquet_quasienergies(n_levels=2, dt=1e-3)
+    assert quasi_energies.shape == (2,)
+    assert np.all(np.isreal(quasi_energies))
+    np.testing.assert_allclose(quasi_energies, np.sort(quasi_energies))