physverify 0.1.0__py3-none-any.whl

physverify/problems/_common.py

@@ -0,0 +1,89 @@
+"""Pieces shared by the seeded-bug problems."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import numpy as np
+
+from ..steppers import euler, rk4
+
+
+@dataclass(frozen=True)
+class BugInfo:
+    description: str  # what is changed in the code
+    # Families of check that should flag this bug, from reasoning about what
+    # each check can see. An empty set documents a deliberate blind spot.
+    expected: frozenset
+    symptom: str = ""  # what the error should look like, written before running the checks
+
+
+def families(*names: str) -> frozenset:
+    return frozenset(names)
+
+
+# Stepper bugs apply to every ODE problem.
+STEPPER_BUGS = {
+    "euler_instead_of_rk4": BugInfo(
+        "stepper silently falls back to forward Euler while claiming RK4",
+        families("mms", "reference", "invariant"),
+        "order 1 instead of 4. Euler is consistent, so the linear patch solution is still exact",
+    ),
+    "rk4_weights": BugInfo(
+        "RK4 final combination uses weights 1,1,1,1 instead of 1,2,2,1 (inconsistent scheme)",
+        families("mms", "reference", "invariant", "patch"),
+        "weights sum to 2/3, so the step is too short: the error does not shrink",
+    ),
+    "rk4_full_step_stage2": BugInfo(
+        "RK4 stage 2 uses a full step instead of a half step",
+        families("mms", "reference", "patch"),
+        "order drops (to 2 here); the linear patch solution is not reproduced",
+    ),
+}
+
+
+def rk4_with_bugs(f, t, y, h, bugs):
+    if "euler_instead_of_rk4" in bugs:
+        return euler(f, t, y, h)
+    k1 = f(t, y)
+    if "rk4_full_step_stage2" in bugs:
+        k2 = f(t + 0.5 * h, y + h * k1)
+    else:
+        k2 = f(t + 0.5 * h, y + 0.5 * h * k1)
+    k3 = f(t + 0.5 * h, y + 0.5 * h * k2)
+    t4 = t + 0.5 * h if "rk4_stage4_time" in bugs else t + h
+    k4 = f(t4, y + h * k3)
+    if "rk4_weights" in bugs:
+        return y + (h / 6.0) * (k1 + k2 + k3 + k4)
+    return y + (h / 6.0) * (k1 + 2.0 * k2 + 2.0 * k3 + k4)
+
+
+def make_integrate(rhs, bugs, method="rk4", trajectory=False):
+    """Build an `integrate(source, y0, t_end, n)` for a solver with an optional source hook.
+
+    With trajectory=True it returns all n + 1 states instead of the last one.
+    """
+
+    def integrate(source, y0, t_end, n):
+        h = t_end / n
+        y = np.array(y0, dtype=float)
+        states = [y]
+
+        def forced(t, state):
+            return rhs(t, state) + source(t)
+
+        steps = n + 1 if (method == "euler" and "euler_extra_step" in bugs) else n
+        for i in range(steps):
+            t = i * h
+            if method == "rk4":
+                y = rk4_with_bugs(forced, t, y, h, bugs)
+            elif method == "euler":
+                y = euler(forced, t, y, h)
+            else:
+                raise ValueError(method)
+            states.append(y)
+        if trajectory:
+            return np.array(states)
+        return y
+
+    return integrate

physverify/problems/heat1d.py

@@ -0,0 +1,217 @@
+"""1D heat equation u_t = alpha u_xx on [0, 1] with u = 0 at both ends, explicit (FTCS) scheme.
+
+Time step and grid are refined in several ways, because each way can hide
+different bugs:
+
+coupled      dt = r dx^2 / alpha with r = 0.25 (the usual stable choice); the
+             expected order in dx is 2 (second order in space, first in time).
+time-only    grid fixed, dt refined. The manufactured solution is cubic in x,
+             which the three-point stencil differentiates exactly, so the grid
+             adds no error of its own. Expected order 1. (To leading order: the
+             time-stepping error is itself smoothed by the discrete Laplacian,
+             a cross term of order dt * dx^2.)
+space-only   the manufactured solution is linear in t, which forward Euler
+             integrates exactly, so the time stepping adds no error of its own.
+             Expected order 2, with the same kind of small cross term.
+patch        cubic in x and linear in t: FTCS must reproduce it to round-off
+             for any dx and dt. Any error at all is a bug.
+"""
+
+from __future__ import annotations
+
+import math
+
+import numpy as np
+
+from ..checks import Check
+from ..order import check_exact, check_order
+from ..studies import close_result
+from ._common import BugInfo, families
+
+NAME = "heat1d"
+ALPHA = 0.7
+T_END = 0.1
+R = 0.25
+LEVELS = (9, 17, 33, 65, 129)  # nodes; dx = 1 / (N - 1)
+TIME_ONLY_NODES = 33
+TIME_ONLY_STEPS = (160, 320, 640, 1280, 2560)  # r = alpha dt / dx^2 from 0.45 down to 0.03
+PATCH_NODES = (9, 17, 33)
+
+BUGS = {
+    "dx_off_by_one": BugInfo(
+        "grid spacing taken as 1/N instead of 1/(N-1) for N nodes",
+        families("mms", "reference", "patch"),
+        "the grid is stretched by N/(N-1); error plateaus",
+    ),
+    "alpha_ignored": BugInfo(
+        "diffusivity left out of the diffusion term (alpha = 1 used)",
+        families("mms", "reference", "patch"),
+        "solution decays at the wrong rate; error plateaus",
+    ),
+    "extra_time_step": BugInfo(
+        "one more time step than needed",
+        families("patch"),
+        "an O(dt) error, the same order as FTCS's own, so no convergence-order check can tell it "
+        "from truncation error",
+    ),
+    "unstable_dt": BugInfo(
+        "time step uses r = 0.6, beyond the FTCS stability limit of 0.5",
+        families("mms", "reference", "patch"),
+        "the finest grids blow up (non-finite or huge errors); the patch check's coupled runs use the same dt",
+    ),
+    "source_time_shift": BugInfo(
+        "the source term is evaluated at the end of the step, t + dt, instead of t",
+        families("patch"),
+        "an O(dt) error like FTCS's own, so the order studies pass; the exact patch solution is lost",
+    ),
+}
+
+
+# Sources are differentiated by hand; the tests check them against finite differences.
+# Coupled and space-only studies use smooth sine modes; time-only and patch use cubics in x.
+def _sines(x):
+    return np.sin(math.pi * x) + 0.5 * np.sin(3.0 * math.pi * x)
+
+
+def _sines_xx(x):
+    return -(math.pi**2) * np.sin(math.pi * x) - 0.5 * (3.0 * math.pi) ** 2 * np.sin(3.0 * math.pi * x)
+
+
+def _cubic(x):
+    return x - x**3  # zero at x = 0 and x = 1; second derivative -6x
+
+
+def u_manufactured(x, t):
+    return np.exp(-t) * _sines(x)
+
+
+def source_manufactured(x, t, alpha=ALPHA):
+    """u_t - alpha u_xx for u_manufactured."""
+    return np.exp(-t) * (-_sines(x) - alpha * _sines_xx(x))
+
+
+def u_time_only(x, t):
+    return np.exp(-t) * _cubic(x)
+
+
+def source_time_only(x, t, alpha=ALPHA):
+    return np.exp(-t) * (-_cubic(x) + 6.0 * alpha * x)
+
+
+def u_space_only(x, t):
+    return (1.0 + t) * _sines(x)
+
+
+def source_space_only(x, t, alpha=ALPHA):
+    return _sines(x) - alpha * (1.0 + t) * _sines_xx(x)
+
+
+def u_patch(x, t):
+    return (1.0 + t) * _cubic(x)
+
+
+def source_patch(x, t, alpha=ALPHA):
+    return _cubic(x) + 6.0 * alpha * (1.0 + t) * x
+
+
+def steps_for_coupled_dt(n_nodes, r=R):
+    dx = 1.0 / (n_nodes - 1)
+    return math.ceil(T_END / (r * dx**2 / ALPHA))
+
+
+def solve(n_nodes, bugs, u0, source=None, n_steps=None):
+    """FTCS to T_END; returns the nodal values at the end.
+
+    With n_steps=None the time step follows the grid (the coupled choice).
+    Passing n_steps fixes dt = T_END / n_steps independently of the grid.
+    """
+    x = np.linspace(0.0, 1.0, n_nodes)
+    dx_nominal = 1.0 / (n_nodes - 1)
+    if n_steps is None:
+        r_used = 0.6 if "unstable_dt" in bugs else R
+        n_steps = math.ceil(T_END / (r_used * dx_nominal**2 / ALPHA))
+    dt = T_END / n_steps
+    if "extra_time_step" in bugs:
+        n_steps += 1
+    dx = 1.0 / n_nodes if "dx_off_by_one" in bugs else dx_nominal
+    alpha_used = 1.0 if "alpha_ignored" in bugs else ALPHA
+    r = alpha_used * dt / dx**2
+    u = u0(x).copy()
+    with np.errstate(all="ignore"):
+        for i in range(n_steps):
+            lap = u[2:] - 2.0 * u[1:-1] + u[:-2]
+            new = u.copy()
+            new[1:-1] = u[1:-1] + r * lap
+            if source is not None:
+                t_source = (i + 1) * dt if "source_time_shift" in bugs else i * dt
+                new[1:-1] += dt * source(x[1:-1], t_source)
+            new[0] = new[-1] = 0.0
+            u = new
+    return x, u
+
+
+def _error(u_fun, source, n_nodes, bugs, n_steps=None):
+    x, u = solve(n_nodes, bugs, lambda xx: u_fun(xx, 0.0), source=source, n_steps=n_steps)
+    with np.errstate(all="ignore"):
+        return float(np.max(np.abs(u - u_fun(x, T_END))))
+
+
+def checks(bugs=frozenset()) -> list[Check]:
+    def run_coupled():
+        hs = [1.0 / (n - 1) for n in LEVELS]
+        errs = [_error(u_manufactured, source_manufactured, n, bugs) for n in LEVELS]
+        return check_order(hs, errs, 2.0)
+
+    def run_time_only():
+        hs = [T_END / m for m in TIME_ONLY_STEPS]
+        errs = [_error(u_time_only, source_time_only, TIME_ONLY_NODES, bugs, n_steps=m) for m in TIME_ONLY_STEPS]
+        return check_order(hs, errs, 1.0)
+
+    def run_space_only():
+        hs = [1.0 / (n - 1) for n in LEVELS]
+        errs = [_error(u_space_only, source_space_only, n, bugs) for n in LEVELS]
+        return check_order(hs, errs, 2.0)
+
+    def run_reference():
+        hs, errs = [], []
+        for n in LEVELS:
+            x, u = solve(n, bugs, lambda xx: np.sin(math.pi * xx))
+            exact = np.sin(math.pi * x) * math.exp(-ALPHA * math.pi**2 * T_END)
+            hs.append(1.0 / (n - 1))
+            with np.errstate(all="ignore"):
+                errs.append(float(np.max(np.abs(u - exact))))
+        return check_order(hs, errs, 2.0)
+
+    def run_patch():
+        # The grid and the time step are varied separately: the coupled choice on three grids,
+        # then three time steps on one grid.
+        errs = [_error(u_patch, source_patch, n, bugs) for n in PATCH_NODES]
+        hs = [T_END / steps_for_coupled_dt(n) for n in PATCH_NODES]
+        base = steps_for_coupled_dt(17)
+        for factor in (1, 2, 4):
+            errs.append(_error(u_patch, source_patch, 17, bugs, n_steps=factor * base))
+            hs.append(T_END / (factor * base))
+        return check_exact(hs, errs)
+
+    return [
+        Check("mms", "FTCS coupled dt ~ dx^2", run_coupled),
+        Check("mms", "FTCS time-only refinement", run_time_only),
+        Check("mms", "FTCS space-only refinement", run_space_only),
+        Check("reference", "FTCS eigenmode decay", run_reference),
+        Check("patch", "FTCS cubic in x, linear in t", run_patch),
+    ]
+
+
+SMOKE_NODES = 33
+SMOKE_RTOL = 1e-2  # FTCS on 33 nodes is accurate to a few parts in a thousand here
+
+
+def smoke_checks(bugs=frozenset()) -> list[Check]:
+    """A plain unit test: one grid, the decaying sine mode, within 1%."""
+
+    def run():
+        x, u = solve(SMOKE_NODES, bugs, lambda xx: np.sin(math.pi * xx))
+        exact = np.sin(math.pi * x) * math.exp(-ALPHA * math.pi**2 * T_END)
+        return close_result(u, exact, SMOKE_RTOL)
+
+    return [Check("smoke", "eigenmode decay on 33 nodes", run)]

physverify/problems/kepler.py

@@ -0,0 +1,176 @@
+"""Kepler problem: a body in the inverse-square field of a fixed mass. State: [x, y, vx, vy].
+
+Two invariants (energy and angular momentum) and a limit (Kepler's third law:
+after one period the orbit closes) give checks that tell bugs apart. A force
+that is central but not inverse-square keeps angular momentum and loses energy;
+a force that is not central loses both.
+
+The reference operator uses the vector form -GM r / |r|^3; the solver below
+writes it as a magnitude times a unit vector, as many codes do.
+"""
+
+from __future__ import annotations
+
+import math
+
+import numpy as np
+
+from ..checks import Check
+from ..mms import ManufacturedODE
+from ..order import check_order
+from ..studies import close_result, invariant_study, ode_checks, smoke_check
+from ._common import STEPPER_BUGS, BugInfo, families, make_integrate
+
+NAME = "kepler"
+GM = 1.0
+ECC = 0.5  # orbit for the free runs: semi-major axis 1, released at periapsis
+SOFTENING = 1e-3
+
+BUGS = {
+    "inverse_r_force": BugInfo(
+        "force magnitude GM/r instead of GM/r^2",
+        families("mms", "reference", "invariant", "limit", "patch"),
+        "wrong orbit; energy drifts, angular momentum is still conserved (the force is still central)",
+    ),
+    "y_force_sign": BugInfo(
+        "the y component of the force has the wrong sign",
+        families("mms", "reference", "invariant", "limit", "patch"),
+        "force no longer central: energy and angular momentum both drift",
+    ),
+    "gm_one_percent": BugInfo(
+        "GM is 1% too large in the force (for example a unit-conversion constant)",
+        families("mms", "reference", "invariant", "limit", "patch"),
+        "error plateaus; the energy computed with the true GM drifts; the orbit does not close",
+    ),
+    "softening_left_on": BugInfo(
+        f"gravitational softening r^2 + eps^2 with eps = {SOFTENING:g} left on",
+        families("mms", "reference", "patch"),
+        "a small plateau (relative size about eps^2 / r^2 = 1e-6); visible only once the "
+        "truncation error is smaller than that",
+    ),
+    **STEPPER_BUGS,
+}
+
+
+def rhs_reference(gm=GM):
+    def f(t, z):
+        x, y, vx, vy = z
+        r3 = (x * x + y * y) ** 1.5
+        return np.array([vx, vy, -gm * x / r3, -gm * y / r3])
+
+    return f
+
+
+def rhs_seeded(bugs, gm=GM):
+    gm_used = gm * 1.01 if "gm_one_percent" in bugs else gm
+    eps2 = SOFTENING**2 if "softening_left_on" in bugs else 0.0
+
+    def f(t, z):
+        x, y, vx, vy = z
+        r = math.sqrt(x * x + y * y + eps2)
+        magnitude = gm_used / r if "inverse_r_force" in bugs else gm_used / (r * r)
+        ux, uy = x / r, y / r
+        ay = magnitude * uy if "y_force_sign" in bugs else -magnitude * uy
+        return np.array([vx, vy, -magnitude * ux, ay])
+
+    return f
+
+
+def energy(z, gm=GM):
+    x, y, vx, vy = z
+    return 0.5 * (vx * vx + vy * vy) - gm / math.sqrt(x * x + y * y)
+
+
+def angular_momentum(z):
+    x, y, vx, vy = z
+    return x * vy - y * vx
+
+
+def periapsis_state(ecc=ECC, a=1.0, gm=GM):
+    rp = a * (1.0 - ecc)
+    return np.array([rp, 0.0, 0.0, math.sqrt(gm * (1.0 + ecc) / rp)])
+
+
+def period(a=1.0, gm=GM):
+    return 2.0 * math.pi * math.sqrt(a**3 / gm)
+
+
+def manufactured() -> ManufacturedODE:
+    """A smooth path that stays between r = 0.7 and r = 1.3, away from the singularity."""
+
+    def u(t):
+        return np.array(
+            [
+                np.cos(t) + 0.2 * np.sin(2.0 * t),
+                0.9 * np.sin(t),
+                -np.sin(t) + 0.3 * np.cos(1.5 * t),
+                0.8 * np.cos(t) + 0.1 * t,
+            ]
+        )
+
+    return ManufacturedODE(u, rhs_reference())
+
+
+MMS_T_END = 1.0
+NS_RK4 = (20, 40, 80, 160, 320)
+Y0_FREE = periapsis_state()
+PATCH = (np.array([1.0, 0.5, 0.2, -0.3]), np.array([0.3, 0.4, -0.2, 0.1]))
+ORBIT_NS = (100, 200, 400, 800, 1600)  # steps per period for the closure check
+
+
+def closure_check(integrate, label="orbit closes after one period") -> Check:
+    """Kepler's third law: after T = 2 pi sqrt(a^3 / GM) the state returns to the start."""
+
+    def run():
+        y0, t = periapsis_state(), period()
+        hs = [t / n for n in ORBIT_NS]
+        errs = [float(np.max(np.abs(integrate(lambda s: 0.0, y0, t, n) - y0))) for n in ORBIT_NS]
+        return check_order(hs, errs, 4.0, scale=float(np.max(np.abs(y0))))
+
+    return Check("limit", label, run)
+
+
+def checks(bugs=frozenset()) -> list[Check]:
+    rhs = rhs_seeded(bugs)
+    integrate = make_integrate(rhs, bugs, "rk4")
+    out = ode_checks(
+        "rk4",
+        integrate,
+        rhs_ref=rhs_reference(),
+        mms=manufactured(),
+        y0_free=Y0_FREE,
+        t_end=MMS_T_END,
+        ns=NS_RK4,
+        order=4.0,
+        quantity=energy,
+        patch=PATCH,
+        integrate_trajectory=make_integrate(rhs, bugs, "rk4", trajectory=True),
+    )
+    out.append(
+        Check(
+            "invariant",
+            "rk4 angular momentum",
+            lambda: invariant_study(integrate, angular_momentum, Y0_FREE, MMS_T_END, NS_RK4, 4.0),
+        )
+    )
+    out.append(closure_check(integrate))
+    return out
+
+
+SMOKE_N = 200
+SMOKE_RTOL = 1e-3
+
+
+def smoke_checks(bugs=frozenset()) -> list[Check]:
+    """Plain tests: one run against a reference, energy conserved, each within 0.1%."""
+    rhs = rhs_seeded(bugs)
+    integrate = make_integrate(rhs, bugs, "rk4")
+
+    def run_energy():
+        y = integrate(lambda t: 0.0, Y0_FREE, MMS_T_END, SMOKE_N)
+        return close_result(energy(y), energy(Y0_FREE), SMOKE_RTOL)
+
+    return [
+        smoke_check("rk4", integrate, rhs_reference(), Y0_FREE, MMS_T_END, SMOKE_N, rtol=SMOKE_RTOL),
+        Check("smoke", "energy conserved", run_energy),
+    ]

physverify/problems/pendulum.py

@@ -0,0 +1,201 @@
+"""Planar double pendulum. State: [theta1, theta2, omega1, omega2], angles from the downward vertical.
+
+The reference operator uses the explicit closed-form accelerations (no matrix
+solve) so that it is written differently from a typical mass-matrix solver.
+"""
+
+from __future__ import annotations
+
+import math
+
+import numpy as np
+
+from ..checks import FAIL, PASS, Check, Result
+from ..mms import ManufacturedODE
+from ..studies import close_result, ode_checks, smoke_check
+from ._common import STEPPER_BUGS, BugInfo, families, make_integrate
+
+NAME = "pendulum"
+PARAMS = dict(m1=1.0, m2=0.8, L1=1.0, L2=0.7, g=9.81)
+
+BUGS = {
+    "coupling_sign": BugInfo(
+        "centripetal coupling term of the first equation has the wrong sign",
+        families("mms", "reference", "invariant", "patch"),
+        "error plateaus; energy not conserved",
+    ),
+    "mass_matrix_missing_cos": BugInfo(
+        "mass matrix entry m2*L2*cos(theta1-theta2) is missing its cosine",
+        families("mms", "reference", "invariant", "patch"),
+        "error plateaus; energy not conserved",
+    ),
+    "gravity_mass_missing": BugInfo(
+        "gravity on the first equation uses m1 instead of m1+m2",
+        families("mms", "reference", "invariant", "limit", "patch"),
+        "error plateaus; energy not conserved; normal-mode frequencies wrong",
+    ),
+    "rk4_stage4_time": BugInfo(
+        "RK4 evaluates its fourth stage at t + h/2 instead of t + h",
+        families("mms", "patch"),
+        "visible only when the right-hand side depends on time: the free pendulum is autonomous, "
+        "so the reference and invariant checks cannot see it; the forced (MMS) runs drop to order 1",
+    ),
+    "swapped_lengths": BugInfo(
+        "second equation uses L2 where L1 belongs in the omega1^2 term",
+        families("mms", "reference", "invariant", "patch"),
+        "error plateaus; energy not conserved",
+    ),
+    "small_angle_gravity": BugInfo(
+        "gravity on the second pendulum uses theta2 instead of sin(theta2)",
+        families("mms", "reference", "invariant", "patch"),
+        "error plateaus at large angles; small-oscillation frequencies unchanged",
+    ),
+    **STEPPER_BUGS,
+}
+
+
+def rhs_reference(p=PARAMS):
+    m1, m2, L1, L2, g = p["m1"], p["m2"], p["L1"], p["L2"], p["g"]
+
+    def f(t, y):
+        t1, t2, w1, w2 = y
+        d = t1 - t2
+        den = 2.0 * m1 + m2 - m2 * math.cos(2.0 * d)
+        a1 = (
+            -g * (2.0 * m1 + m2) * math.sin(t1)
+            - m2 * g * math.sin(t1 - 2.0 * t2)
+            - 2.0 * math.sin(d) * m2 * (w2 * w2 * L2 + w1 * w1 * L1 * math.cos(d))
+        ) / (L1 * den)
+        a2 = (
+            2.0
+            * math.sin(d)
+            * (w1 * w1 * L1 * (m1 + m2) + g * (m1 + m2) * math.cos(t1) + w2 * w2 * L2 * m2 * math.cos(d))
+        ) / (L2 * den)
+        return np.array([w1, w2, a1, a2])
+
+    return f
+
+
+def energy_reference(y, p=PARAMS):
+    m1, m2, L1, L2, g = p["m1"], p["m2"], p["L1"], p["L2"], p["g"]
+    t1, t2, w1, w2 = y
+    kinetic = 0.5 * m1 * (L1 * w1) ** 2 + 0.5 * m2 * (
+        (L1 * w1) ** 2 + (L2 * w2) ** 2 + 2.0 * L1 * L2 * w1 * w2 * math.cos(t1 - t2)
+    )
+    potential = -(m1 + m2) * g * L1 * math.cos(t1) - m2 * g * L2 * math.cos(t2)
+    return kinetic + potential
+
+
+def rhs_seeded(bugs, p=PARAMS):
+    """Mass-matrix form M(theta) alpha = f(theta, omega), with optional bugs."""
+    m1, m2, L1, L2, g = p["m1"], p["m2"], p["L1"], p["L2"], p["g"]
+
+    def f(t, y):
+        t1, t2, w1, w2 = y
+        d = t1 - t2
+        c = 1.0 if "mass_matrix_missing_cos" in bugs else math.cos(d)
+        mass = np.array([[(m1 + m2) * L1, m2 * L2 * c], [L1 * math.cos(d), L2]])
+        sign = 1.0 if "coupling_sign" in bugs else -1.0
+        gravity_mass = m1 if "gravity_mass_missing" in bugs else (m1 + m2)
+        L_w1 = L2 if "swapped_lengths" in bugs else L1
+        sin_t2 = t2 if "small_angle_gravity" in bugs else math.sin(t2)
+        force = np.array(
+            [
+                sign * m2 * L2 * w2 * w2 * math.sin(d) - gravity_mass * g * math.sin(t1),
+                L_w1 * w1 * w1 * math.sin(d) - g * sin_t2,
+            ]
+        )
+        a1, a2 = np.linalg.solve(mass, force)
+        return np.array([w1, w2, a1, a2])
+
+    return f
+
+
+def manufactured() -> ManufacturedODE:
+    def u(t):
+        return np.array(
+            [
+                0.8 * np.sin(t),
+                -0.5 + 0.6 * np.cos(1.3 * t),
+                0.2 + 0.7 * np.cos(0.9 * t),
+                0.4 * np.sin(1.1 * t),
+            ]
+        )
+
+    return ManufacturedODE(u, rhs_reference())
+
+
+def small_oscillation_omegas(p=PARAMS):
+    """Normal-mode angular frequencies about the hanging equilibrium (closed form)."""
+    m1, m2, L1, L2, g = p["m1"], p["m2"], p["L1"], p["L2"], p["g"]
+    s = (m1 + m2) * (L1 + L2)
+    disc = math.sqrt(s * s - 4.0 * m1 * (m1 + m2) * L1 * L2)
+    w_sq = [g * (s - disc) / (2.0 * m1 * L1 * L2), g * (s + disc) / (2.0 * m1 * L1 * L2)]
+    return [math.sqrt(x) for x in w_sq]
+
+
+def linearized_omegas(rhs, eps=1e-6):
+    """Angular frequencies from a finite-difference Jacobian of `rhs` at rest at the bottom."""
+    jac = np.zeros((4, 4))
+    for j in range(4):
+        step = np.zeros(4)
+        step[j] = eps
+        jac[:, j] = (np.asarray(rhs(0.0, step), float) - np.asarray(rhs(0.0, -step), float)) / (2 * eps)
+    eig = np.linalg.eigvals(jac)
+    return sorted(abs(eig.imag))[::2], max(abs(eig.real))
+
+
+def frequency_check(rhs, label="small-oscillation frequencies", tol=1e-5) -> Check:
+    def run():
+        omegas, growth = linearized_omegas(rhs)
+        expected = small_oscillation_omegas()
+        if growth > 1e-6:
+            return Result(FAIL, f"equilibrium is not neutrally stable (growth rate {growth:.3g})")
+        err = max(abs(a - b) / b for a, b in zip(omegas, expected))
+        if err > tol:
+            return Result(FAIL, f"frequencies {omegas} differ from {expected} (relative error {err:.2g})")
+        return Result(PASS, f"frequencies match the closed form (relative error {err:.1e})")
+
+    return Check("limit", label, run)
+
+
+MMS_T_END = 1.0
+NS_RK4 = (10, 20, 40, 80, 160)
+Y0_FREE = np.array([0.4, 0.3, 0.0, 0.0])  # moderate amplitude, released from rest
+PATCH = (np.array([0.3, -0.2, 0.5, -0.4]), np.array([0.5, -0.4, 0.3, 0.6]))
+SMOKE_N = 80
+SMOKE_RTOL = 1e-3
+
+
+def checks(bugs=frozenset()) -> list[Check]:
+    rhs = rhs_seeded(bugs)
+    out = ode_checks(
+        "rk4",
+        make_integrate(rhs, bugs, "rk4"),
+        rhs_ref=rhs_reference(),
+        mms=manufactured(),
+        y0_free=Y0_FREE,
+        t_end=MMS_T_END,
+        ns=NS_RK4,
+        order=4.0,
+        quantity=energy_reference,
+        patch=PATCH,
+        integrate_trajectory=make_integrate(rhs, bugs, "rk4", trajectory=True),
+    )
+    out.append(frequency_check(rhs))
+    return out
+
+
+def smoke_checks(bugs=frozenset()) -> list[Check]:
+    """Plain unit tests: one run against a reference, and energy conserved, each within 0.1%."""
+    rhs = rhs_seeded(bugs)
+    integrate = make_integrate(rhs, bugs, "rk4")
+
+    def run_energy():
+        y = integrate(lambda t: 0.0, Y0_FREE, MMS_T_END, SMOKE_N)
+        return close_result(energy_reference(y), energy_reference(Y0_FREE), SMOKE_RTOL)
+
+    return [
+        smoke_check("rk4", integrate, rhs_reference(), Y0_FREE, MMS_T_END, SMOKE_N, rtol=SMOKE_RTOL),
+        Check("smoke", "energy conserved", run_energy),
+    ]