physicskit 0.1.0__py3-none-any.whl

physicskit/quantum/tests/test_physics_checks.py

@@ -0,0 +1,131 @@
+"""Spot-check each chapter against known analytic results, so regressions in
+the underlying physics (not just raw unitarity) get caught."""
+
+import numpy as np
+
+from physicskit.quantum.chapters.entanglement import AharonovBohmRing, BellCorrelations
+from physicskit.quantum.chapters.harmonic_spin import HarmonicOscillator, ThermalState
+from physicskit.quantum.chapters.hydrogen_am import HydrogenOrbital
+from physicskit.quantum.chapters.potentials import FiniteSquareWell, StadiumBilliard2D
+from physicskit.quantum.chapters.wave_packets import QuantumRevival
+from physicskit.quantum.core.eigensolvers import NumerovSolver, harmonic_well, infinite_well
+from physicskit.quantum.visualizers.phase_space import wigner_transform
+
+
+def test_numerov_matches_infinite_well_and_harmonic_oscillator():
+    x = np.linspace(0, 1, 400)
+    energies = NumerovSolver(x, infinite_well()).solve(5).energies
+    analytic = (np.arange(1, 6) ** 2 * np.pi**2) / 2
+    assert np.allclose(energies, analytic, rtol=1e-3)
+
+    x2 = np.linspace(-10, 10, 800)
+    energies2 = NumerovSolver(x2, harmonic_well()).solve(5).energies
+    assert np.allclose(energies2, np.arange(5) + 0.5, atol=1e-4)
+
+
+def test_coherent_state_tracks_classical_trajectory():
+    ho = HarmonicOscillator()
+    x = np.linspace(-15, 15, 3000)
+    alpha = 3 + 1j
+    for t in (0.0, 1.3, 4.0):
+        psi_t = ho.coherent_wavefunction(alpha, x, t=t)
+        x_mean = np.real(np.trapezoid(x * np.abs(psi_t) ** 2, x))
+        x_classical, _ = ho.coherent_trajectory(alpha, np.array([t]))
+        assert abs(x_mean - x_classical[0]) < 1e-6
+
+
+def test_thermal_state_broadens_with_temperature():
+    ho = HarmonicOscillator()
+    var_cold = ThermalState(ho, T=0.1).variance()
+    var_hot = ThermalState(ho, T=5.0).variance()
+    assert var_hot > var_cold
+
+
+def test_hydrogen_orbitals_normalized_with_correct_energy():
+    for n, l, m in [(1, 0, 0), (2, 1, 0), (3, 2, 1)]:
+        orb = HydrogenOrbital(n, l, m)
+        assert abs(orb.check_normalization() - 1.0) < 1e-6
+        assert abs(orb.energy - (-1 / (2 * n**2))) < 1e-12
+
+
+def test_quantum_revival_reassembles_at_revival_time():
+    qr = QuantumRevival(L=1.0, n_max=250)
+    x = np.linspace(0, qr.L, 1500)
+    psi0_func = qr.gaussian_initial_state(x0=0.3, sigma=0.03)
+    psi0 = psi0_func(x)
+    c = qr.eigenbasis_coefficients(psi0_func)
+
+    fidelity_scrambled = qr.fidelity_to_initial(x, 0.1 * qr.revival_time, c, psi0)
+    fidelity_revived = qr.fidelity_to_initial(x, qr.revival_time, c, psi0)
+
+    assert fidelity_revived > 0.999
+    assert fidelity_scrambled < 0.5
+
+
+def test_wigner_transform_matches_ground_state_analytic_form():
+    ho = HarmonicOscillator()
+    x = np.linspace(-8, 8, 250)
+    psi0 = ho.eigenfunction(0, x)
+    xg, p, W = wigner_transform(x, psi0, hbar=1.0, n_p=120)
+    X, P = np.meshgrid(x, p, indexing="ij")
+    analytic = (1 / np.pi) * np.exp(-(X**2) - P**2)
+    assert np.max(np.abs(W - analytic)) < 1e-10
+
+
+def test_bell_singlet_violates_chsh_bound():
+    bc = BellCorrelations()
+    assert abs(bc.chsh_optimal() - 2 * np.sqrt(2)) < 1e-10
+    assert bc.chsh_optimal() > 2.0  # violates the classical (local hidden-variable) bound
+
+
+def test_aharonov_bohm_energy_periodic_in_flux_quantum():
+    ring = AharonovBohmRing(R=1.0)
+    Phi0 = ring.flux_quantum
+    n = np.arange(-3, 4)
+    e0 = ring.energy(n, 0.0)
+    e_shifted = ring.energy(n + 1, Phi0)  # shifting both n and Phi by one quantum is a relabeling
+    assert np.allclose(e0, e_shifted)
+    assert abs(ring.aharonov_bohm_phase(Phi0) - 2 * np.pi) < 1e-12
+
+
+def test_barrier_scattering_matches_sub_barrier_tunneling_formula():
+    # A "well" with negative V0 is a barrier of height |V0|; below the
+    # barrier (E < |V0|) this is the classically forbidden, sub-barrier
+    # tunneling regime, where k2 is purely imaginary.
+    E, Vb, a = 4.5, 6.0, 1.0
+    barrier = FiniteSquareWell(V0=-Vb, width=a)
+    result = barrier.scattering(E)
+
+    kappa = np.sqrt(2 * (Vb - E))
+    T_expected = 1 / (1 + Vb**2 * np.sinh(kappa * a) ** 2 / (4 * E * (Vb - E)))
+    assert abs(result.T - T_expected) < 1e-12
+    assert abs(result.k2.real) < 1e-12  # purely imaginary in the forbidden region
+    assert 0 < result.T < 1
+
+    # Above the barrier (E > |V0|), T should match the ordinary real-k2 formula.
+    E_above = 10.0
+    result_above = barrier.scattering(E_above)
+    k2_expected = np.sqrt(2 * (E_above - Vb))
+    T_expected_above = 1 / (1 + Vb**2 * np.sin(k2_expected * a) ** 2 / (4 * E_above * (E_above - Vb)))
+    assert abs(result_above.T - T_expected_above) < 1e-10
+    assert abs(result_above.k2.imag) < 1e-12
+
+
+def test_stadium_billiard_grid_is_isotropic_and_states_are_normalized():
+    # A mismatched dx/dy staircases the semicircular caps as ellipses
+    # rather than circles, giving resolution-dependent, non-monotonically
+    # converging eigenvalues -- grid() must keep dx == dy.
+    sb = StadiumBilliard2D(L=1.0, R=0.5)
+    for n_points in (50, 90, 150):
+        (X, Y), x, y = sb.grid(n_points)
+        dx, dy = x[1] - x[0], y[1] - y[0]
+        # dy matches dx up to the rounding of n_y to an integer point count
+        assert abs(dx - dy) / dx < 0.02
+
+    energies, wavefunctions, X, Y, mask = sb.solve(n_points=90, n_states=4)
+    assert np.all(np.diff(energies) > 0)
+    assert np.all(energies > 0)
+    dx, dy = X[1, 0] - X[0, 0], Y[0, 1] - Y[0, 0]
+    for psi in wavefunctions:
+        assert abs(np.sum(psi**2) * dx * dy - 1.0) < 1e-6
+        assert np.all(psi[~mask] == 0.0)

physicskit/quantum/tests/test_potentials.py

@@ -0,0 +1,191 @@
+"""Tests for physicskit.quantum.chapters.potentials: the parts
+test_physics_checks.py and test_animations.py don't already exercise --
+the asymmetric step well, the gravitational bouncer (both the Numerov
+solver and its closed-form Airy-function check), DoubleWellSimulator's
+localized_state, FiniteSquareWell's bound_states/transmission_spectrum/
+evanescent_wavefunction, and the 2D rectangular/circular boxes.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import pytest
+
+from physicskit.quantum._compat import trapz
+from physicskit.quantum.chapters.potentials import (
+    Box2DEigenstate,
+    CircularBox2D,
+    DoubleWellSimulator,
+    FiniteSquareWell,
+    RectangularBox2D,
+    airy_bouncer_energies,
+    airy_wavefunction,
+    asymmetric_well_states,
+    gravitational_bouncer_states,
+)
+
+
+# --- Asymmetric step well -----------------------------------------------------
+
+
+def test_asymmetric_well_states_are_bound_below_the_lower_wall():
+    res = asymmetric_well_states(width=2.0, V_left=40.0, V_right=15.0, n_points=800, n_states=3)
+    assert np.all(np.diff(res.energies) > 0)  # ascending
+    assert np.all(res.energies < 15.0)  # below the lower (right) wall
+    for psi in res.wavefunctions:
+        assert trapz(psi**2, res.x) == pytest.approx(1.0, abs=1e-2)
+
+
+# --- Gravitational bouncer -----------------------------------------------------
+
+
+def test_gravitational_bouncer_numerov_matches_airy_analytic_energies():
+    n_states = 4
+    numeric = gravitational_bouncer_states(alpha=1.0, x_extent=12.0, n_points=1500, n_states=n_states)
+    analytic = airy_bouncer_energies(alpha=1.0, n_states=n_states)
+    np.testing.assert_allclose(numeric.energies, analytic, rtol=2e-2)
+
+
+def test_airy_bouncer_energies_are_ascending_and_positive():
+    energies = airy_bouncer_energies(alpha=2.0, n_states=5)
+    assert np.all(energies > 0)
+    assert np.all(np.diff(energies) > 0)
+
+
+def test_airy_wavefunction_is_normalized_and_vanishes_below_floor():
+    x = np.linspace(-2, 30, 4000)
+    psi = airy_wavefunction(x, alpha=1.0, n=0)
+    assert trapz(psi**2, x) == pytest.approx(1.0, abs=1e-3)
+    np.testing.assert_allclose(psi[x < 0], 0.0)
+
+
+def test_airy_wavefunction_overlaps_numerov_ground_state():
+    numeric = gravitational_bouncer_states(alpha=1.0, x_extent=12.0, n_points=1500, n_states=1)
+    analytic_psi = airy_wavefunction(numeric.x, alpha=1.0, n=0)
+    overlap = abs(trapz(analytic_psi * numeric.wavefunctions[0], numeric.x))
+    assert overlap == pytest.approx(1.0, abs=1e-2)
+
+
+# --- Double well: localized_state ---------------------------------------------
+
+
+def test_double_well_localized_state_is_normalized_and_side_asymmetric():
+    dw = DoubleWellSimulator(lam=0.3, a=2.0, n_points=800)
+    result = dw.solve(n_states=2)
+    left = dw.localized_state(result, side="left")
+    right = dw.localized_state(result, side="right")
+    assert trapz(left**2, result.x) == pytest.approx(1.0, abs=1e-2)
+    assert trapz(right**2, result.x) == pytest.approx(1.0, abs=1e-2)
+    left_mask = result.x < 0
+    # a state built to localize on the left should weight the left lobe more
+    assert trapz(left[left_mask] ** 2, result.x[left_mask]) > trapz(right[left_mask] ** 2, result.x[left_mask])
+
+
+# --- Finite square well: bound_states / transmission_spectrum / evanescent ----
+
+
+def test_finite_square_well_bound_states_are_all_negative_energy():
+    well = FiniteSquareWell(V0=20.0, width=2.0)
+    res = well.bound_states(n_points=800, n_states=6)
+    assert res.energies.size > 0
+    assert np.all(res.energies < 0)
+    assert np.all(np.diff(res.energies) > 0)
+
+
+def test_finite_square_well_evanescent_wavefunction_matches_bound_states_entry():
+    well = FiniteSquareWell(V0=20.0, width=2.0)
+    res = well.bound_states(n_points=800, n_states=3)
+    np.testing.assert_allclose(well.evanescent_wavefunction(res, n=1), res.wavefunctions[1])
+
+
+def test_transmission_spectrum_matches_pointwise_scattering():
+    well = FiniteSquareWell(V0=10.0, width=1.0)
+    E_values = np.array([1.0, 5.0, 12.0])
+    spectrum = well.transmission_spectrum(E_values)
+    expected = np.array([well.scattering(E).T for E in E_values])
+    np.testing.assert_allclose(spectrum, expected)
+    assert np.all((spectrum >= 0) & (spectrum <= 1))
+
+
+# --- 2D rectangular box ---------------------------------------------------------
+
+
+def test_rectangular_box_energy_matches_formula():
+    box = RectangularBox2D(Lx=2.0, Ly=3.0, hbar=1.0, m=1.0)
+    nx, ny = 2, 3
+    expected = (np.pi**2 * box.hbar**2 / (2 * box.m)) * ((nx / box.Lx) ** 2 + (ny / box.Ly) ** 2)
+    assert box.energy(nx, ny) == pytest.approx(expected)
+
+
+def test_rectangular_box_spectrum_is_sorted_by_energy():
+    box = RectangularBox2D(Lx=1.0, Ly=1.7)
+    states = box.spectrum(n_max=4)
+    energies = [s.energy for s in states]
+    assert energies == sorted(energies)
+    assert len(states) == 16
+
+
+def test_rectangular_box_square_has_degeneracies():
+    box = RectangularBox2D(Lx=1.0, Ly=1.0)
+    degeneracies = box.degeneracies(n_max=4)
+    # (1,2) and (2,1) are exactly degenerate for a square box (E ~ nx^2+ny^2)
+    assert any({(1, 2), (2, 1)} <= set(pairs) for pairs in degeneracies.values())
+    for pairs in degeneracies.values():
+        assert len(pairs) >= 2
+
+
+def test_rectangular_box_grid_has_expected_shape_and_bounds():
+    box = RectangularBox2D(Lx=2.0, Ly=3.0)
+    X, Y = box.grid(n_points=10)
+    assert X.shape == (10, 10)
+    assert X.min() == pytest.approx(0.0)
+    assert X.max() == pytest.approx(2.0)
+    assert Y.max() == pytest.approx(3.0)
+
+
+def test_box2d_eigenstate_psi_is_normalized_over_the_box():
+    box = RectangularBox2D(Lx=1.0, Ly=1.0)
+    state = Box2DEigenstate(nx=2, ny=1, energy=box.energy(2, 1))
+    X, Y = box.grid(n_points=200)
+    psi = state.psi(X, Y, box.Lx, box.Ly)
+    integral = trapz(trapz(psi**2, Y[0], axis=1), X[:, 0])
+    assert integral == pytest.approx(1.0, abs=1e-2)
+
+
+# --- 2D circular quantum dot ------------------------------------------------------
+
+
+def test_circular_box_eigenstate_energy_matches_bessel_zero_formula():
+    from scipy.special import jn_zeros
+
+    dot = CircularBox2D(R=1.5, hbar=1.0, m_mass=1.0)
+    state = dot.eigenstate(m=1, n=2)
+    expected_k = jn_zeros(1, 2)[-1] / dot.R
+    assert state.k == pytest.approx(expected_k)
+    assert state.energy == pytest.approx(dot.hbar**2 * state.k**2 / (2 * dot.m_mass))
+
+
+def test_circular_box_spectrum_is_sorted_and_ground_state_is_m_zero_n_one():
+    dot = CircularBox2D(R=1.0)
+    states = dot.spectrum(m_max=3, n_max=3)
+    energies = [s.energy for s in states]
+    assert energies == sorted(energies)
+    assert states[0].m == 0
+    assert states[0].n == 1
+
+
+def test_circular_box_polar_grid_spans_radius_and_full_turn():
+    dot = CircularBox2D(R=2.0)
+    r, phi = dot.polar_grid(n_r=20, n_phi=30)
+    assert r.shape == (20, 30)
+    assert r.max() == pytest.approx(2.0)
+    assert phi.max() == pytest.approx(2 * np.pi)
+
+
+def test_circular_eigenstate_psi_vanishes_at_the_boundary():
+    dot = CircularBox2D(R=1.0)
+    state = dot.eigenstate(m=0, n=1)
+    phi = np.linspace(0, 2 * np.pi, 16)
+    r_boundary = np.full_like(phi, dot.R)
+    psi_boundary = state.psi(r_boundary, phi, dot.R)
+    np.testing.assert_allclose(psi_boundary, 0.0, atol=1e-8)

physicskit/quantum/tests/test_solvers.py

@@ -0,0 +1,70 @@
+"""Tests for physicskit.quantum.core.solvers: the time-dependent-potential
+branch of SplitOperatorSolver2D (test_unitarity.py only exercises the
+static-potential path) and _accepts_time's non-introspectable-callable
+fallback.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import pytest
+
+from physicskit.quantum.core.solvers import SplitOperatorSolver2D, _accepts_time
+
+
+def _gaussian_2d(X, Y, x0=0.0, y0=0.0, sigma=1.0):
+    norm = (2 * np.pi * sigma**2) ** (-0.5)
+    return norm * np.exp(-((X - x0) ** 2 + (Y - y0) ** 2) / (2 * sigma**2))
+
+
+def test_accepts_time_detects_three_argument_signature():
+    def V_static(x, y):
+        return x + y
+
+    def V_time_dependent(x, y, t):
+        return x + y + t
+
+    assert _accepts_time(V_static, n_spatial_args=2) is False
+    assert _accepts_time(V_time_dependent, n_spatial_args=2) is True
+
+
+def test_accepts_time_falls_back_to_false_for_non_introspectable_callable():
+    # inspect.signature(min) raises ValueError (no signature metadata for
+    # this builtin), and _accepts_time should fall back to False rather
+    # than propagating the exception.
+    assert _accepts_time(min, n_spatial_args=2) is False
+
+
+def test_split_operator_2d_with_time_dependent_potential_conserves_norm():
+    x = np.linspace(-8, 8, 64)
+    y = np.linspace(-8, 8, 64)
+
+    def V(X, Y, t):
+        return 0.5 * (X**2 + Y**2) * (1.0 + 0.1 * np.sin(t))
+
+    solver = SplitOperatorSolver2D(x, y, V, dt=1e-3)
+    assert solver._time_dependent is True
+
+    X, Y = np.meshgrid(x, y, indexing="ij")
+    psi = _gaussian_2d(X, Y).astype(complex)
+    psi /= np.sqrt(solver.norm(psi))
+
+    t = 0.0
+    for _ in range(50):
+        psi = solver.step(psi, t)
+        t += solver.dt
+
+    assert solver.norm(psi) == pytest.approx(1.0, abs=1e-6)
+
+
+def test_split_operator_2d_time_dependent_potential_actually_varies_with_time():
+    x = np.linspace(-8, 8, 32)
+    y = np.linspace(-8, 8, 32)
+
+    def V(X, Y, t):
+        return t * (X**2 + Y**2)
+
+    solver = SplitOperatorSolver2D(x, y, V, dt=1e-3)
+    phase_t0 = solver._half_potential_phase(0.0)
+    phase_t1 = solver._half_potential_phase(1.0)
+    assert not np.allclose(phase_t0, phase_t1)

physicskit/quantum/tests/test_spin.py

@@ -0,0 +1,22 @@
+"""Tests for physicskit.quantum.chapters.spin: RabiProblem's Omega_R=0
+edge case (no drive, no detuning), not exercised by test_animations.py.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+from physicskit.quantum.chapters.spin import RabiProblem
+from physicskit.quantum.core.operators import identity2
+
+
+def test_rabi_propagator_is_identity_when_undriven_and_on_resonance():
+    rabi = RabiProblem(omega0=1.0, omega_d=1.0, Omega=0.0)
+    assert rabi.generalized_rabi_frequency == 0.0
+    np.testing.assert_allclose(rabi.propagator(t=2.5), identity2)
+
+
+def test_rabi_excited_state_population_stays_zero_when_undriven():
+    rabi = RabiProblem(omega0=1.0, omega_d=1.0, Omega=0.0)
+    t = np.linspace(0, 10, 20)
+    np.testing.assert_allclose(rabi.excited_state_population(t), np.zeros_like(t))

physicskit/quantum/tests/test_unitarity.py

@@ -0,0 +1,84 @@
+"""Verify probability conservation integral |psi(x,t)|^2 dx = 1 +/- 1e-6 over
+10^4 timesteps of the split-operator FFT propagator, across a variety of
+potential shapes (harmonic, double well, finite well, asymmetric well,
+gravitational bouncer, soft infinite box, and a 2D rectangular box).
+"""
+
+import numpy as np
+import pytest
+
+from physicskit.quantum.core.eigensolvers import (
+    asymmetric_step_well,
+    double_well,
+    finite_well,
+    harmonic_well,
+    linear_gravitational_well,
+)
+from physicskit.quantum.core.solvers import SplitOperatorSolver1D, SplitOperatorSolver2D
+
+N_STEPS = 10_000
+TOL = 1e-6
+
+
+def _gaussian(x, x0=0.0, sigma=1.0, k0=0.0):
+    norm = (2 * np.pi * sigma**2) ** (-0.25)
+    return norm * np.exp(-((x - x0) ** 2) / (4 * sigma**2)) * np.exp(1j * k0 * x)
+
+
+def _run_1d(V, x, psi0, dt):
+    solver = SplitOperatorSolver1D(x, V, dt=dt)
+    psi = psi0.astype(complex)
+    psi /= np.sqrt(solver.norm(psi))
+    for _ in range(N_STEPS):
+        psi = solver.step(psi)
+    return solver.norm(psi)
+
+
+@pytest.mark.parametrize(
+    "name,V,x_range,x0,sigma,dt",
+    [
+        ("harmonic", harmonic_well(), (-15, 15), 2.0, 1.0, 1e-3),
+        ("double_well", double_well(lam=0.5, a=2.5), (-8, 8), 2.5, 0.5, 5e-4),
+        ("finite_well", finite_well(V0=30.0, width=3.0), (-10, 10), 0.0, 0.5, 5e-4),
+        ("asymmetric_well", asymmetric_step_well(width=3.0, V_left=40.0, V_right=15.0), (-8, 8), 0.0, 0.5, 5e-4),
+        ("gravitational_bouncer", linear_gravitational_well(alpha=2.0), (-12, 12), 3.0, 0.5, 2e-4),
+    ],
+)
+def test_1d_unitarity(name, V, x_range, x0, sigma, dt):
+    x = np.linspace(*x_range, 2048)
+    psi0 = _gaussian(x, x0=x0, sigma=sigma)
+    final_norm = _run_1d(V, x, psi0, dt)
+    assert abs(final_norm - 1.0) < TOL, f"{name}: norm drifted to {final_norm}"
+
+
+def test_1d_unitarity_soft_infinite_box():
+    L, wall = 1.0, 4000.0
+
+    def V(x):
+        return np.where((x >= 0) & (x <= L), 0.0, wall)
+
+    x = np.linspace(-0.3, 1.3, 2048)
+    psi0 = _gaussian(x, x0=0.5, sigma=0.08)
+    final_norm = _run_1d(V, x, psi0, dt=2e-5)
+    assert abs(final_norm - 1.0) < TOL
+
+
+def test_2d_unitarity_rectangular_box():
+    Lx, Ly, wall = 1.0, 1.0, 3000.0
+
+    def V(x, y):
+        return np.where((x >= 0) & (x <= Lx) & (y >= 0) & (y <= Ly), 0.0, wall)
+
+    x = np.linspace(-0.3, 1.3, 160)
+    y = np.linspace(-0.3, 1.3, 160)
+    solver = SplitOperatorSolver2D(x, y, V, dt=5e-5)
+
+    X, Y = solver.X, solver.Y
+    psi0 = np.exp(-((X - 0.5) ** 2 + (Y - 0.5) ** 2) / (4 * 0.05**2)).astype(complex)
+    psi0 /= np.sqrt(solver.norm(psi0))
+
+    psi = psi0
+    for _ in range(2000):
+        psi = solver.step(psi)
+
+    assert abs(solver.norm(psi) - 1.0) < TOL

physicskit/quantum/tests/test_wave_packets.py

@@ -0,0 +1,53 @@
+"""Tests for physicskit.quantum.chapters.wave_packets: the parts of
+GaussianDispersion (center, density) and TwinSlit not already exercised
+by test_physics_checks.py/test_animations.py.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import pytest
+
+from physicskit.quantum._compat import trapz
+from physicskit.quantum.chapters.wave_packets import GaussianDispersion, TwinSlit
+
+
+def test_gaussian_dispersion_center_moves_ballistically():
+    gd = GaussianDispersion(x0=1.0, k0=3.0, hbar=1.0, m=2.0)
+    t = np.array([0.0, 1.0, 2.5])
+    np.testing.assert_allclose(gd.center(t), gd.x0 + (gd.hbar * gd.k0 / gd.m) * t)
+
+
+def test_gaussian_dispersion_density_matches_abs_psi_squared():
+    gd = GaussianDispersion()
+    x = np.linspace(-10, 10, 200)
+    np.testing.assert_allclose(gd.density(x, t=0.7), np.abs(gd.psi(x, 0.7)) ** 2)
+
+
+def test_gaussian_dispersion_density_stays_normalized_over_time():
+    gd = GaussianDispersion(sigma0=1.0, k0=0.0)  # k0=0 keeps the packet centered at x0
+    x = np.linspace(-40, 40, 4000)
+    for t in (0.0, 5.0, 20.0):
+        assert trapz(gd.density(x, t), x) == pytest.approx(1.0, abs=1e-3)
+
+
+def test_twin_slit_intensity_is_normalized():
+    ts = TwinSlit(slit_separation=4.0, slit_width=0.4, k0=10.0)
+    x = np.linspace(-20, 20, 4000)
+    I = ts.intensity(x, screen_distance=50.0)
+    assert trapz(I, x) == pytest.approx(1.0, abs=1e-6)
+
+
+def test_twin_slit_intensity_is_symmetric_about_the_axis():
+    ts = TwinSlit(slit_separation=4.0, slit_width=0.4, k0=10.0)
+    x = np.linspace(-20, 20, 501)  # ascending and symmetric, so trapz normalization matches
+    I = ts.intensity(x, screen_distance=50.0)
+    np.testing.assert_allclose(I, I[::-1], rtol=1e-10)
+
+
+def test_twin_slit_amplitude_is_complex_and_finite():
+    ts = TwinSlit()
+    x = np.linspace(-10, 10, 50)
+    amp = ts.amplitude(x, screen_distance=30.0)
+    assert np.iscomplexobj(amp)
+    assert np.all(np.isfinite(amp))