physverify 0.1.0__tar.gz

physverify-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ram Chandra Giri
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

physverify-0.1.0/PKG-INFO

@@ -0,0 +1,122 @@
+Metadata-Version: 2.4
+Name: physverify
+Version: 0.1.0
+Summary: Verification checks for physics simulation code: manufactured solutions, order-of-accuracy studies and a seeded-bug benchmark.
+Author: Ram Chandra Giri
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/rcgiri-physics/physverify
+Project-URL: Documentation, https://github.com/rcgiri-physics/physverify/blob/main/docs/technical.md
+Project-URL: Issues, https://github.com/rcgiri-physics/physverify/issues
+Project-URL: Changelog, https://github.com/rcgiri-physics/physverify/blob/main/CHANGELOG.md
+Keywords: verification,method of manufactured solutions,numerical methods,physics,simulation,testing
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: Framework :: Pytest
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Education
+Classifier: Topic :: Software Development :: Testing
+Classifier: Development Status :: 3 - Alpha
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.24
+Provides-Extra: symbolic
+Requires-Dist: sympy>=1.12; extra == "symbolic"
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: hypothesis>=6; extra == "dev"
+Requires-Dist: sympy>=1.12; extra == "dev"
+Dynamic: license-file
+
+# physverify
+
+**A tool that checks whether a physics simulation is solving the right equations correctly, not just running without errors.**
+
+Status: early version (0.1.0). Nobody besides the author has used it yet, so feedback is very welcome.
+
+## The problem it addresses
+
+A simulation can run, produce nice plots and still be wrong: a minus sign in the wrong place, a factor of 2 missing, a time step that is off by one. Ordinary tests often miss these, because nobody knows the "right answer" for a real simulation to compare against.
+
+## How it works, in plain words
+
+physverify uses a few standard ideas from numerical analysis:
+
+1. **Make up an answer, then check the code finds it.** Pick a smooth function, work out what extra push (a "source term") would make it an exact solution, give that push to your code, and see if your code reproduces the function. This is called the *Method of Manufactured Solutions*.
+2. **Check the error shrinks at the right speed.** If your method is supposed to be 4th order, halving the time step should make the error about 16 times smaller. If it only gets 2 times smaller, something is wrong, even if the error looked small.
+3. **Check conserved quantities.** Energy, mass or momentum should stay constant (or drift in a predictable way).
+4. **Check known special cases.** For example, a projectile with no air resistance has a range you can write down by hand.
+5. **Exact "patch" tests.** Some solutions should be reproduced to computer precision. This catches small bugs that the other checks let through.
+
+Each check reports **PASS**, **FAIL**, **EXACT** or **INCONCLUSIVE**.
+
+There is also a separate set of checks for random (Monte Carlo) simulations, using the 2D Ising model as the example.
+
+## Does it actually catch bugs?
+
+To test it, 37 bugs were added one at a time to five small solvers (projectile, double pendulum, planet orbit, heat equation, shock tube):
+
+- **35 of 37** bugs were caught. Plain "compare with one answer" tests caught 27.
+- **0 false alarms** on the bug-free versions.
+- The 2 missed bugs are explained in the [technical details](https://github.com/rcgiri-physics/physverify/blob/main/docs/technical.md).
+
+For the Monte Carlo checks, all 20 seeded bugs were caught with no false alarms.
+
+The bugs and the checks were written by the same person, so these numbers show the tool works as designed. They are not a promise about bugs in other people's code.
+
+## Try it
+
+You need Python 3.10 or newer.
+
+```bash
+pip install physverify
+```
+
+The example below lives in the repository, so clone it to follow along:
+
+```bash
+git clone https://github.com/rcgiri-physics/physverify.git
+cd physverify
+physverify run examples/verify_damped_oscillator.py
+```
+
+You should see a list of checks, all passing. Now open `examples/damped_oscillator.py`, change the damping by 10%, and run the same command again: the checks fail.
+
+To check your own code you write a short "spec" file. It tells physverify two things: the equations your code is meant to solve (written independently of your code), and how to run your code. [examples/verify_damped_oscillator.py](https://github.com/rcgiri-physics/physverify/blob/main/examples/verify_damped_oscillator.py) is a complete example to copy.
+
+Other ways to run it:
+
+```bash
+physverify run my_spec.py --html report.html   # a web page with convergence plots
+physverify run my_spec.py --json -             # machine-readable output
+pytest my_spec.py                              # each check becomes a pytest test
+```
+
+## What it can and cannot do
+
+- Works best for ordinary differential equations (orbits, pendulums, projectiles).
+- Partial differential equations: only 1D examples so far (heat equation, shock tube).
+- Your code needs a way to accept an extra source term, or a small wrapper ("adapter") around it. The wrapper can itself contain mistakes.
+- Passing all checks does not prove the code is correct, only that these tests found nothing wrong.
+
+## More
+
+- [results/own_work/SUMMARY.md](https://github.com/rcgiri-physics/physverify/blob/main/results/own_work/SUMMARY.md): results on four of the author's own public physics projects (two real bugs found and fixed).
+- [docs/technical.md](https://github.com/rcgiri-physics/physverify/blob/main/docs/technical.md): full details, benchmark tables, limits and related work.
+- [docs/patch.md](https://github.com/rcgiri-physics/physverify/blob/main/docs/patch.md): what the exact "patch" checks assume.
+- [docs/ising.md](https://github.com/rcgiri-physics/physverify/blob/main/docs/ising.md): checks for Monte Carlo codes.
+- [docs/agent.md](https://github.com/rcgiri-physics/physverify/blob/main/docs/agent.md): using it with an AI coding assistant.
+- [CHANGELOG.md](https://github.com/rcgiri-physics/physverify/blob/main/CHANGELOG.md)
+
+Run the project's own tests with `pip install -e .[dev]` then `python -m pytest -q` (about 1.5 minutes).
+
+## Licence
+
+MIT. Copyright (c) 2026 Ram Chandra Giri.

physverify-0.1.0/README.md

@@ -0,0 +1,85 @@
+# physverify
+
+**A tool that checks whether a physics simulation is solving the right equations correctly, not just running without errors.**
+
+Status: early version (0.1.0). Nobody besides the author has used it yet, so feedback is very welcome.
+
+## The problem it addresses
+
+A simulation can run, produce nice plots and still be wrong: a minus sign in the wrong place, a factor of 2 missing, a time step that is off by one. Ordinary tests often miss these, because nobody knows the "right answer" for a real simulation to compare against.
+
+## How it works, in plain words
+
+physverify uses a few standard ideas from numerical analysis:
+
+1. **Make up an answer, then check the code finds it.** Pick a smooth function, work out what extra push (a "source term") would make it an exact solution, give that push to your code, and see if your code reproduces the function. This is called the *Method of Manufactured Solutions*.
+2. **Check the error shrinks at the right speed.** If your method is supposed to be 4th order, halving the time step should make the error about 16 times smaller. If it only gets 2 times smaller, something is wrong, even if the error looked small.
+3. **Check conserved quantities.** Energy, mass or momentum should stay constant (or drift in a predictable way).
+4. **Check known special cases.** For example, a projectile with no air resistance has a range you can write down by hand.
+5. **Exact "patch" tests.** Some solutions should be reproduced to computer precision. This catches small bugs that the other checks let through.
+
+Each check reports **PASS**, **FAIL**, **EXACT** or **INCONCLUSIVE**.
+
+There is also a separate set of checks for random (Monte Carlo) simulations, using the 2D Ising model as the example.
+
+## Does it actually catch bugs?
+
+To test it, 37 bugs were added one at a time to five small solvers (projectile, double pendulum, planet orbit, heat equation, shock tube):
+
+- **35 of 37** bugs were caught. Plain "compare with one answer" tests caught 27.
+- **0 false alarms** on the bug-free versions.
+- The 2 missed bugs are explained in the [technical details](https://github.com/rcgiri-physics/physverify/blob/main/docs/technical.md).
+
+For the Monte Carlo checks, all 20 seeded bugs were caught with no false alarms.
+
+The bugs and the checks were written by the same person, so these numbers show the tool works as designed. They are not a promise about bugs in other people's code.
+
+## Try it
+
+You need Python 3.10 or newer.
+
+```bash
+pip install physverify
+```
+
+The example below lives in the repository, so clone it to follow along:
+
+```bash
+git clone https://github.com/rcgiri-physics/physverify.git
+cd physverify
+physverify run examples/verify_damped_oscillator.py
+```
+
+You should see a list of checks, all passing. Now open `examples/damped_oscillator.py`, change the damping by 10%, and run the same command again: the checks fail.
+
+To check your own code you write a short "spec" file. It tells physverify two things: the equations your code is meant to solve (written independently of your code), and how to run your code. [examples/verify_damped_oscillator.py](https://github.com/rcgiri-physics/physverify/blob/main/examples/verify_damped_oscillator.py) is a complete example to copy.
+
+Other ways to run it:
+
+```bash
+physverify run my_spec.py --html report.html   # a web page with convergence plots
+physverify run my_spec.py --json -             # machine-readable output
+pytest my_spec.py                              # each check becomes a pytest test
+```
+
+## What it can and cannot do
+
+- Works best for ordinary differential equations (orbits, pendulums, projectiles).
+- Partial differential equations: only 1D examples so far (heat equation, shock tube).
+- Your code needs a way to accept an extra source term, or a small wrapper ("adapter") around it. The wrapper can itself contain mistakes.
+- Passing all checks does not prove the code is correct, only that these tests found nothing wrong.
+
+## More
+
+- [results/own_work/SUMMARY.md](https://github.com/rcgiri-physics/physverify/blob/main/results/own_work/SUMMARY.md): results on four of the author's own public physics projects (two real bugs found and fixed).
+- [docs/technical.md](https://github.com/rcgiri-physics/physverify/blob/main/docs/technical.md): full details, benchmark tables, limits and related work.
+- [docs/patch.md](https://github.com/rcgiri-physics/physverify/blob/main/docs/patch.md): what the exact "patch" checks assume.
+- [docs/ising.md](https://github.com/rcgiri-physics/physverify/blob/main/docs/ising.md): checks for Monte Carlo codes.
+- [docs/agent.md](https://github.com/rcgiri-physics/physverify/blob/main/docs/agent.md): using it with an AI coding assistant.
+- [CHANGELOG.md](https://github.com/rcgiri-physics/physverify/blob/main/CHANGELOG.md)
+
+Run the project's own tests with `pip install -e .[dev]` then `python -m pytest -q` (about 1.5 minutes).
+
+## Licence
+
+MIT. Copyright (c) 2026 Ram Chandra Giri.

physverify-0.1.0/pyproject.toml

@@ -0,0 +1,54 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "physverify"
+version = "0.1.0"
+description = "Verification checks for physics simulation code: manufactured solutions, order-of-accuracy studies and a seeded-bug benchmark."
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Ram Chandra Giri" }]
+keywords = ["verification", "method of manufactured solutions", "numerical methods", "physics", "simulation", "testing"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Topic :: Scientific/Engineering :: Physics",
+    "Framework :: Pytest",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Operating System :: OS Independent",
+    "Intended Audience :: Science/Research",
+    "Intended Audience :: Education",
+    "Topic :: Software Development :: Testing",
+    "Development Status :: 3 - Alpha",
+]
+dependencies = ["numpy>=1.24"]
+
+[project.urls]
+Homepage = "https://github.com/rcgiri-physics/physverify"
+Documentation = "https://github.com/rcgiri-physics/physverify/blob/main/docs/technical.md"
+Issues = "https://github.com/rcgiri-physics/physverify/issues"
+Changelog = "https://github.com/rcgiri-physics/physverify/blob/main/CHANGELOG.md"
+
+[project.optional-dependencies]
+symbolic = ["sympy>=1.12"]
+dev = ["pytest>=8", "hypothesis>=6", "sympy>=1.12"]
+
+[project.scripts]
+physverify = "physverify.cli:main"
+
+[project.entry-points.pytest11]
+physverify = "physverify.pytest_plugin"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]

physverify-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

physverify-0.1.0/src/physverify/__init__.py

@@ -0,0 +1,26 @@
+"""physverify: verification checks for physics simulation code."""
+
+from .checks import Check, OrderResult, Result
+from .mms import ManufacturedODE, mms_order_study, zero_source
+from .order import check_order, fit_order, pairwise_orders
+from .order import check_exact
+from .studies import invariant_study, ode_checks, patch_study, reference_study
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "Check",
+    "ManufacturedODE",
+    "OrderResult",
+    "Result",
+    "check_exact",
+    "check_order",
+    "fit_order",
+    "invariant_study",
+    "mms_order_study",
+    "ode_checks",
+    "pairwise_orders",
+    "patch_study",
+    "reference_study",
+    "zero_source",
+]

physverify-0.1.0/src/physverify/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+raise SystemExit(main())

physverify-0.1.0/src/physverify/adapters/__init__.py

@@ -0,0 +1,14 @@
+"""Adapters that connect physverify to existing simulation code (read-only)."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+
+def sibling_project(env_var: str, folder: str) -> Path:
+    """Folder of another project: $env_var if set, else a sibling of this repository."""
+    if os.environ.get(env_var):
+        return Path(os.environ[env_var])
+    repo_root = Path(__file__).resolve().parents[3]
+    return repo_root.parent / folder

physverify-0.1.0/src/physverify/adapters/double_pendulum.py

@@ -0,0 +1,55 @@
+"""Adapter for double-pendulum-simulation/src/mechanics.py.
+
+Only the right-hand side (get_derivatives) and the energy (calculate_energy)
+are tested. They are stepped with physverify's own RK4, because the project's
+solvers.py needs SciPy. So these checks say nothing about solvers.py.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+from ..checks import Check
+from ..loaders import load_module_from_path
+from ..problems import pendulum as P
+from ..problems._common import make_integrate
+from ..studies import ode_checks
+from . import sibling_project
+
+ENV_VAR = "PHYSVERIFY_PENDULUM_DIR"
+FOLDER = "double-pendulum-simulation"
+
+
+def source_path():
+    return sibling_project(ENV_VAR, FOLDER) / "src" / "mechanics.py"
+
+
+def load():
+    return load_module_from_path("double_pendulum_mechanics_under_test", source_path())
+
+
+def checks(module=None) -> list[Check]:
+    module = module or load()
+    params = dict(P.PARAMS)
+
+    def rhs(t, y):
+        return np.asarray(module.get_derivatives(t, y, params), dtype=float)
+
+    def energy(y):
+        return module.calculate_energy(y, **params)
+
+    out = ode_checks(
+        "mechanics.py RHS + physverify RK4",
+        make_integrate(rhs, frozenset(), "rk4"),
+        rhs_ref=P.rhs_reference(params),
+        mms=P.manufactured(),
+        y0_free=P.Y0_FREE,
+        t_end=P.MMS_T_END,
+        ns=P.NS_RK4,
+        order=4.0,
+        quantity=energy,
+        patch=P.PATCH,
+        integrate_trajectory=make_integrate(rhs, frozenset(), "rk4", trajectory=True),
+    )
+    out.append(P.frequency_check(rhs, label="mechanics.py small-oscillation frequencies"))
+    return out

physverify-0.1.0/src/physverify/adapters/lorenz.py

@@ -0,0 +1,152 @@
+"""Adapter for lorenz-attractor-simulation/src/mechanics.py (lorenz_derivatives).
+
+The project integrates with SciPy's solve_ivp, so only the right-hand side is
+under test here; it is stepped with physverify's own RK4. The flow is chaotic
+(largest Lyapunov exponent about 0.906), so trajectories are compared only up
+to t = 1, well inside one Lyapunov time's worth of growth (exp(0.9) < 3).
+Beyond that the project is checked through exact properties of the flow:
+fixed points, the constant divergence -(sigma + 1 + beta), and the Jacobian
+that scripts/calculate_lyapunov.py writes by hand.
+"""
+
+from __future__ import annotations
+
+import ast
+import math
+from pathlib import Path
+
+import numpy as np
+
+from ..checks import EXACT, FAIL, PASS, Check, Result
+from ..loaders import load_module_from_path
+from ..mms import ManufacturedODE
+from ..problems._common import make_integrate
+from ..studies import ode_checks
+from . import sibling_project
+
+ENV_VAR = "PHYSVERIFY_LORENZ_DIR"
+FOLDER = "lorenz-attractor-simulation"
+PARAMS = {"sigma": 10.0, "rho": 28.0, "beta": 8.0 / 3.0}
+Y0_FREE = np.array([1.0, 1.0, 1.0])
+T_END = 1.0
+NS_RK4 = (100, 200, 400, 800)
+
+
+def source_path():
+    return sibling_project(ENV_VAR, FOLDER) / "src" / "mechanics.py"
+
+
+def lyapunov_path():
+    return sibling_project(ENV_VAR, FOLDER) / "scripts" / "calculate_lyapunov.py"
+
+
+def load():
+    return load_module_from_path("lorenz_mechanics_under_test", source_path())
+
+
+def rhs_reference(p=PARAMS):
+    """From docs/theory.md, written in matrix-free form independently of the code."""
+    s, r, b = p["sigma"], p["rho"], p["beta"]
+
+    def f(t, u):
+        x, y, z = u
+        return np.array([s * y - s * x, r * x - x * z - y, x * y - b * z])
+
+    return f
+
+
+def manufactured() -> ManufacturedODE:
+    def u(t):
+        return np.array([2.0 * np.sin(t), 1.0 + np.cos(1.7 * t), 20.0 + 3.0 * np.sin(0.6 * t)])
+
+    return ManufacturedODE(u, rhs_reference())
+
+
+def fixed_points(p=PARAMS):
+    c = math.sqrt(p["beta"] * (p["rho"] - 1.0))
+    return [np.zeros(3), np.array([c, c, p["rho"] - 1.0]), np.array([-c, -c, p["rho"] - 1.0])]
+
+
+def central_jacobian(f, u, h=1e-3):
+    """Centred differences are exact (to round-off) for a quadratic field like Lorenz."""
+    jac = np.zeros((3, 3))
+    for j in range(3):
+        e = np.zeros(3)
+        e[j] = h
+        jac[:, j] = (np.asarray(f(0.0, u + e)) - np.asarray(f(0.0, u - e))) / (2 * h)
+    return jac
+
+
+SAMPLE_POINTS = [np.array(v) for v in ([1.0, 1.0, 1.0], [-8.3, 4.1, 27.0], [12.0, -3.0, 5.5], [0.0, 0.0, 0.0])]
+
+
+def fixed_point_check(rhs) -> Check:
+    def run():
+        worst = max(float(np.max(np.abs(rhs(0.0, p)))) for p in fixed_points())
+        if worst <= 1e-12 * 30:
+            return Result(EXACT, f"all three fixed points are zeros of the field (largest |f| = {worst:.1e})")
+        return Result(FAIL, f"field is {worst:.3g} at a fixed point")
+
+    return Check("limit", "fixed points 0 and (+-sqrt(beta(rho-1)), ., rho-1)", run)
+
+
+def divergence_check(rhs) -> Check:
+    expected = -(PARAMS["sigma"] + 1.0 + PARAMS["beta"])
+
+    def run():
+        divs = [float(np.trace(central_jacobian(rhs, p))) for p in SAMPLE_POINTS]
+        worst = max(abs(d - expected) for d in divs)
+        if worst <= 1e-9:
+            return Result(EXACT, f"divergence {divs[0]:.12f} = -(sigma+1+beta) at {len(divs)} points")
+        return Result(FAIL, f"divergence differs from {expected:.6f} by {worst:.3g}")
+
+    return Check("invariant", "flow divergence is constant -(sigma+1+beta)", run)
+
+
+def jacobian_check(rhs, jacobian) -> Check:
+    def run():
+        worst = max(
+            float(np.max(np.abs(np.asarray(jacobian(p, PARAMS)) - central_jacobian(rhs, p)))) for p in SAMPLE_POINTS
+        )
+        if worst <= 1e-9:
+            return Result(EXACT, f"hand-written Jacobian matches the field's derivative (max diff {worst:.1e})")
+        return Result(FAIL, f"hand-written Jacobian differs from the field's derivative by {worst:.3g}")
+
+    return Check("limit", "calculate_lyapunov.py Jacobian vs derivative of the field", run)
+
+
+def load_function(path, name):
+    """One top-level function from a script, without running the script's imports.
+
+    The script appends to sys.path and imports SciPy at module level; only the
+    function's own source is executed here, with numpy as np in scope.
+    """
+    tree = ast.parse(Path(path).read_text(encoding="utf-8"))
+    node = next(n for n in tree.body if isinstance(n, ast.FunctionDef) and n.name == name)
+    namespace = {"np": np}
+    exec(compile(ast.Module([node], []), str(path), "exec"), namespace)
+    return namespace[name]
+
+
+def checks(module=None) -> list[Check]:
+    module = module or load()
+
+    def rhs(t, y):
+        return np.asarray(module.lorenz_derivatives(t, y, PARAMS), dtype=float)
+
+    out = ode_checks(
+        "mechanics.py RHS + physverify RK4",
+        make_integrate(rhs, frozenset(), "rk4"),
+        rhs_ref=rhs_reference(),
+        mms=manufactured(),
+        y0_free=Y0_FREE,
+        t_end=T_END,
+        ns=NS_RK4,
+        order=4.0,
+        patch=(np.array([1.0, -2.0, 15.0]), np.array([0.5, 1.5, -2.0])),
+        integrate_trajectory=make_integrate(rhs, frozenset(), "rk4", trajectory=True),
+    )
+    out += [fixed_point_check(rhs), divergence_check(rhs)]
+    if lyapunov_path().is_file():
+        out.append(jacobian_check(rhs, load_function(lyapunov_path(), "lorenz_jacobian")))
+    return out

physverify-0.1.0/src/physverify/adapters/projectile_v1.py

@@ -0,0 +1,92 @@
+"""Adapter for projectile-simulation/src/projectile_sim_v1.py (class Projectile, forward Euler).
+
+simulate() returns only positions and runs until landing, with no source hook,
+so there is no MMS or patch check (row 25 of the audit plan). Positions at a
+fixed time are compared with the closed-form vacuum and linear-drag solutions
+from the README and with an RK4 reference for quadratic drag; the landing range
+is compared with the vacuum formula v0^2 sin(2 angle) / g. Forward Euler is
+first order by design, so order 1 is the pass mark.
+"""
+
+from __future__ import annotations
+
+import math
+
+import numpy as np
+
+from ..checks import Check
+from ..loaders import load_module_from_path
+from ..order import check_order
+from ..steppers import integrate_fixed, rk4
+from . import sibling_project
+
+ENV_VAR = "PHYSVERIFY_PROJECTILE_DIR"
+FOLDER = "projectile-simulation"
+MASS, RADIUS, V0, ANGLE = 0.145, 0.037, 30.0, 45.0
+T_END = 2.0
+NS = (200, 400, 800, 1600)
+
+
+def source_path():
+    return sibling_project(ENV_VAR, FOLDER) / "src" / "projectile_sim_v1.py"
+
+
+def load():
+    return load_module_from_path("projectile_sim_v1_under_test", source_path(), stubs=("matplotlib", "matplotlib.pyplot"))
+
+
+def exact_position(mode, t, k, g=9.81):
+    vx0 = V0 * math.cos(math.radians(ANGLE))
+    vy0 = V0 * math.sin(math.radians(ANGLE))
+    if mode == "vacuum":
+        return np.array([vx0 * t, vy0 * t - 0.5 * g * t * t])
+    if mode == "linear":
+        decay = 1.0 - math.exp(-k * t)
+        return np.array([vx0 / k * decay, (vy0 + g / k) / k * decay - g * t / k])
+    # quadratic: no closed form; RK4 on the README's equations with a fine step
+    def f(_t, z):
+        speed = math.hypot(z[2], z[3])
+        return np.array([z[2], z[3], -k * speed * z[2], -g - k * speed * z[3]])
+
+    return integrate_fixed(f, [0.0, 0.0, vx0, vy0], 0.0, t, 20000, rk4)[:2]
+
+
+def drag_constant(mode, viscosity=1.81e-5, cd=0.47, rho=1.225):
+    if mode == "linear":
+        return 6.0 * math.pi * viscosity * RADIUS / MASS
+    if mode == "quadratic":
+        return 0.5 * rho * math.pi * RADIUS**2 * cd / MASS
+    return 0.0
+
+
+def position_check(module, mode) -> Check:
+    def run():
+        ball = module.Projectile(mass=MASS, radius=RADIUS)
+        expected = exact_position(mode, T_END, drag_constant(mode))
+        hs, errs = [], []
+        for n in NS:
+            _, xs, ys = ball.simulate(V0, ANGLE, mode=mode, dt=T_END / n)
+            hs.append(T_END / n)
+            errs.append(float(np.max(np.abs(np.array([xs[n], ys[n]]) - expected))))
+        return check_order(hs, errs, 1.0, scale=float(np.max(np.abs(expected))))
+
+    return Check("reference", f"v1 {mode}/euler position at t = {T_END:g}", run)
+
+
+def range_check(module) -> Check:
+    def run():
+        ball = module.Projectile(mass=MASS, radius=RADIUS)
+        exact = V0 * V0 * math.sin(math.radians(2 * ANGLE)) / 9.81
+        hs, errs = [], []
+        for dt in (0.02, 0.01, 0.005, 0.0025):
+            _, xs, _ = ball.simulate(V0, ANGLE, mode="vacuum", dt=dt)
+            hs.append(dt)
+            errs.append(abs(xs[-1] - exact))
+        return check_order(hs, errs, 1.0, scale=exact)
+
+    return Check("limit", "v1 vacuum/euler range", run)
+
+
+def checks(module=None) -> list[Check]:
+    module = module or load()
+    return [position_check(module, m) for m in ("vacuum", "linear", "quadratic")] + [range_check(module)]