physverify 0.2.0__tar.gz → 0.3.0__tar.gz

{physverify-0.2.0/src/physverify.egg-info → physverify-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: physverify
-Version: 0.2.0
+Version: 0.3.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
@@ -39,7 +39,7 @@ Dynamic: license-file
 
 **A tool that checks whether a physics simulation is solving the right equations correctly, not just running without errors.**
 
-Status: early version (0.2.0). It has been tried on 20 public physics repositories (see below), but nobody besides the author has used it yet, so feedback is very welcome.
+Status: early version (0.3.0). It has been tried on 68 public physics repositories (see below), but nobody besides the author has used it yet, so feedback is very welcome.
 
 ## The problem it addresses
 
@@ -51,7 +51,7 @@ 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).
+3. **Check conserved quantities and budgets.** Energy, mass or momentum should stay constant (or drift in a predictable way), and heat added through a wall or a source should match what went in, exactly, on every grid.
 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.
 6. **Algebraic checks on the method itself.** For a Runge-Kutta method, whether the coefficients really have the order they claim can be settled exactly, with no test problem (the "order conditions").
@@ -74,12 +74,14 @@ The bugs and the checks were written by the same person, so these numbers show t
 
 ## Trying it on other people's code
 
-To see what it does on code it was not written for, 40 public Python physics repositories were drawn at random from GitHub searches (October 2026) and run in a locked-down container: no network, the repository read-only, nothing from it run on the author's computer.
+To see what it does on code it was not written for, public Python physics repositories from GitHub were run in a locked-down container (October 2026): no network, the repository read-only, nothing from it run on the author's computer. 40 were drawn at random from topic searches (batches 1 to 4); another 60 were the newest small repositories whose README says the work is complete (batch 5), and 20 more were picked because they are quick to test (batch 6); batches 5 and 6 are not random.
 
-- **20 of the 40 could be tested.** Most of the others were not numerical solvers (neural networks, apps and games, analysis tools), one needed a recent NVIDIA GPU, and a few need more set-up.
-- **9 confirmed bugs in 6 of the 20.** For example: a measured energy that counts the magnetic-field term twice; backward time-stepping that is only first-order accurate; Runge-Kutta coefficient tables labelled with a higher order than they have; error-estimate weights that do not sum to zero; a spectral derivative that crashes for an odd number of grid points; a crash on NumPy 2.
-- **The other 14 had no confirmed bug.** Most passed every check that applied, often to 1e-13 or better; one raised a question for its authors rather than a bug report.
-- **Our own adapters were wrong about 15 times** before checking (a wrong constant, too-coarse steps, and so on). Every FAIL was checked by hand before being called a bug, and these mistakes are recorded, not hidden.
+- **68 of the 120 could be tested.** Most of the others were not numerical solvers (neural networks, apps and games, analysis tools, finance), one needed a recent NVIDIA GPU, and a few need more set-up.
+- **16 confirmed bugs in 12 of the 68.** For example: a measured energy that counts the magnetic-field term twice; backward time-stepping that is only first-order accurate; Runge-Kutta coefficient tables labelled with a higher order than they have; a spectral derivative that crashes for an odd number of grid points; boundary values applied after the linear solve instead of inside it; an insulated wall that leaks heat; a grid spacing off by one interval; a Kepler solver that fails for negative angles.
+- **The rest had no confirmed bug.** Most passed every check that applied, often to 1e-13 or better.
+- **Our own adapters were wrong about 28 times** before checking (a wrong constant, too-coarse steps, a wrong sign convention, and so on). Every FAIL was checked by hand before being called a bug, and these mistakes are recorded, not hidden.
+
+These counts describe the repositories that were drawn; they are not a bug rate for physics code in general.
 
 Each lesson became a new check or a clearer message in physverify. The testing and write-ups were done with help from an AI assistant; every number comes from running the code. Authors are told about a finding before their project is named, so the repositories are listed by ID: [results/corpus/SUMMARY.md](https://github.com/rcgiri-physics/physverify/blob/main/results/corpus/SUMMARY.md).
 
@@ -120,7 +122,7 @@ pytest my_spec.py                              # each check becomes a pytest tes
 
 ## More
 
-- [results/corpus/SUMMARY.md](https://github.com/rcgiri-physics/physverify/blob/main/results/corpus/SUMMARY.md): the 40 public repositories, what was tested and what was found.
+- [results/corpus/SUMMARY.md](https://github.com/rcgiri-physics/physverify/blob/main/results/corpus/SUMMARY.md): the 120 public repositories, what was tested and what was found.
 - [sandbox/README.md](https://github.com/rcgiri-physics/physverify/blob/main/sandbox/README.md): the locked-down container used to run other people's code.
 - [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.

{physverify-0.2.0 → physverify-0.3.0}/README.md

@@ -2,7 +2,7 @@
 
 **A tool that checks whether a physics simulation is solving the right equations correctly, not just running without errors.**
 
-Status: early version (0.2.0). It has been tried on 20 public physics repositories (see below), but nobody besides the author has used it yet, so feedback is very welcome.
+Status: early version (0.3.0). It has been tried on 68 public physics repositories (see below), but nobody besides the author has used it yet, so feedback is very welcome.
 
 ## The problem it addresses
 
@@ -14,7 +14,7 @@ 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).
+3. **Check conserved quantities and budgets.** Energy, mass or momentum should stay constant (or drift in a predictable way), and heat added through a wall or a source should match what went in, exactly, on every grid.
 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.
 6. **Algebraic checks on the method itself.** For a Runge-Kutta method, whether the coefficients really have the order they claim can be settled exactly, with no test problem (the "order conditions").
@@ -37,12 +37,14 @@ The bugs and the checks were written by the same person, so these numbers show t
 
 ## Trying it on other people's code
 
-To see what it does on code it was not written for, 40 public Python physics repositories were drawn at random from GitHub searches (October 2026) and run in a locked-down container: no network, the repository read-only, nothing from it run on the author's computer.
+To see what it does on code it was not written for, public Python physics repositories from GitHub were run in a locked-down container (October 2026): no network, the repository read-only, nothing from it run on the author's computer. 40 were drawn at random from topic searches (batches 1 to 4); another 60 were the newest small repositories whose README says the work is complete (batch 5), and 20 more were picked because they are quick to test (batch 6); batches 5 and 6 are not random.
 
-- **20 of the 40 could be tested.** Most of the others were not numerical solvers (neural networks, apps and games, analysis tools), one needed a recent NVIDIA GPU, and a few need more set-up.
-- **9 confirmed bugs in 6 of the 20.** For example: a measured energy that counts the magnetic-field term twice; backward time-stepping that is only first-order accurate; Runge-Kutta coefficient tables labelled with a higher order than they have; error-estimate weights that do not sum to zero; a spectral derivative that crashes for an odd number of grid points; a crash on NumPy 2.
-- **The other 14 had no confirmed bug.** Most passed every check that applied, often to 1e-13 or better; one raised a question for its authors rather than a bug report.
-- **Our own adapters were wrong about 15 times** before checking (a wrong constant, too-coarse steps, and so on). Every FAIL was checked by hand before being called a bug, and these mistakes are recorded, not hidden.
+- **68 of the 120 could be tested.** Most of the others were not numerical solvers (neural networks, apps and games, analysis tools, finance), one needed a recent NVIDIA GPU, and a few need more set-up.
+- **16 confirmed bugs in 12 of the 68.** For example: a measured energy that counts the magnetic-field term twice; backward time-stepping that is only first-order accurate; Runge-Kutta coefficient tables labelled with a higher order than they have; a spectral derivative that crashes for an odd number of grid points; boundary values applied after the linear solve instead of inside it; an insulated wall that leaks heat; a grid spacing off by one interval; a Kepler solver that fails for negative angles.
+- **The rest had no confirmed bug.** Most passed every check that applied, often to 1e-13 or better.
+- **Our own adapters were wrong about 28 times** before checking (a wrong constant, too-coarse steps, a wrong sign convention, and so on). Every FAIL was checked by hand before being called a bug, and these mistakes are recorded, not hidden.
+
+These counts describe the repositories that were drawn; they are not a bug rate for physics code in general.
 
 Each lesson became a new check or a clearer message in physverify. The testing and write-ups were done with help from an AI assistant; every number comes from running the code. Authors are told about a finding before their project is named, so the repositories are listed by ID: [results/corpus/SUMMARY.md](https://github.com/rcgiri-physics/physverify/blob/main/results/corpus/SUMMARY.md).
 
@@ -83,7 +85,7 @@ pytest my_spec.py                              # each check becomes a pytest tes
 
 ## More
 
-- [results/corpus/SUMMARY.md](https://github.com/rcgiri-physics/physverify/blob/main/results/corpus/SUMMARY.md): the 40 public repositories, what was tested and what was found.
+- [results/corpus/SUMMARY.md](https://github.com/rcgiri-physics/physverify/blob/main/results/corpus/SUMMARY.md): the 120 public repositories, what was tested and what was found.
 - [sandbox/README.md](https://github.com/rcgiri-physics/physverify/blob/main/sandbox/README.md): the locked-down container used to run other people's code.
 - [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.

{physverify-0.2.0 → physverify-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "physverify"
-version = "0.2.0"
+version = "0.3.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"

{physverify-0.2.0 → physverify-0.3.0}/src/physverify/__init__.py

@@ -6,7 +6,7 @@ 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.2.0"
+__version__ = "0.3.0"
 
 __all__ = [
     "Check",

physverify-0.3.0/src/physverify/loaders.py

@@ -0,0 +1,178 @@
+"""Import a module from a path without touching its folder.
+
+Used by the adapters that test other people's code. Nothing is written next to
+the module (no __pycache__), and optional plotting imports can be stubbed so a
+simulation file can be imported on a machine without matplotlib.
+"""
+
+from __future__ import annotations
+
+import ast
+import importlib
+import importlib.util
+import sys
+import types
+from pathlib import Path
+
+
+class Placeholder:
+    """Stand-in for a name from a module that is not installed.
+
+    Calling it returns another placeholder, except that calling it with a single
+    function returns that function, so stubbed decorators (``@app.route(...)``,
+    ``@jit``) leave the decorated code usable. Attribute access also returns a
+    placeholder. A tested code path that really uses the stub gets a placeholder
+    back instead of a result, which the checks then report.
+    """
+
+    def __init__(self, name: str = "stub"):
+        self._name = name
+
+    def __call__(self, *args, **kwargs):
+        if len(args) == 1 and not kwargs and callable(args[0]) and not isinstance(args[0], Placeholder):
+            return args[0]
+        return Placeholder(f"{self._name}()")
+
+    def __getattr__(self, attr):
+        if attr.startswith("__"):
+            raise AttributeError(attr)
+        return Placeholder(f"{self._name}.{attr}")
+
+    def __repr__(self):
+        return f"<stub {self._name}>"
+
+
+def _stub_module(name: str, attrs=()) -> types.ModuleType:
+    mod = types.ModuleType(name)
+    mod.__dict__["__stub__"] = True
+    for a in attrs:
+        setattr(mod, a, Placeholder(f"{name}.{a}"))
+    return mod
+
+
+def stub_modules(spec, *, force: bool = False) -> list[str]:
+    """Install stub modules for imports a tested code path does not use.
+
+    `spec` is an iterable of module names, or a mapping from a module name to the
+    names it must provide (``{"sklearn.metrics": ["accuracy_score"]}``), so that
+    ``from sklearn.metrics import accuracy_score`` succeeds. Parent packages are
+    created as needed. A module that imports for real is left alone unless
+    `force` is true. Returns the names installed.
+    """
+    items = spec.items() if hasattr(spec, "items") else ((s, ()) for s in spec)
+    installed = []
+    for name, attrs in items:
+        if not force:
+            try:
+                importlib.import_module(name)
+                continue
+            except ImportError:
+                pass
+        parts = name.split(".")
+        for i in range(1, len(parts)):
+            parent = ".".join(parts[:i])
+            if parent not in sys.modules:
+                sys.modules[parent] = _stub_module(parent)
+                installed.append(parent)
+        sys.modules[name] = _stub_module(name, attrs)
+        installed.append(name)
+        parent, _, child = name.rpartition(".")
+        if parent:
+            setattr(sys.modules[parent], child, sys.modules[name])
+    return installed
+
+
+def run_script(path, *, argv=(), stubs=None) -> tuple[dict, str]:
+    """Run a whole script as __main__ and return (its globals, what it printed).
+
+    For scripts whose results are only module-level variables (coursework,
+    notebooks exported to .py, demos). Matplotlib is switched to a non-interactive
+    backend and plt.show() does nothing, so the run never waits for a window.
+    """
+    import contextlib
+    import io
+    import runpy
+
+    if stubs:
+        stub_modules(stubs)
+    try:
+        import matplotlib
+
+        matplotlib.use("Agg")
+        import matplotlib.pyplot as plt
+
+        plt.show = lambda *a, **k: None
+    except ImportError:
+        pass
+    old_argv = sys.argv
+    sys.argv = [str(path), *argv]
+    out = io.StringIO()
+    try:
+        with contextlib.redirect_stdout(out):
+            globs = runpy.run_path(str(path), run_name="__main__")
+    finally:
+        sys.argv = old_argv
+    return globs, out.getvalue()
+
+
+def load_module_from_path(name: str, path, stubs=()):
+    path = Path(path)
+    if not path.is_file():
+        raise FileNotFoundError(path)
+
+    added = stub_modules(stubs)
+
+    old_flag = sys.dont_write_bytecode
+    sys.dont_write_bytecode = True
+    try:
+        spec = importlib.util.spec_from_file_location(name, path)
+        module = importlib.util.module_from_spec(spec)
+        sys.modules[name] = module
+        try:
+            spec.loader.exec_module(module)
+        except BaseException:
+            sys.modules.pop(name, None)  # do not leave a half-initialised module behind
+            raise
+    finally:
+        sys.dont_write_bytecode = old_flag
+        for stub in added:
+            sys.modules.pop(stub, None)
+    return module
+
+
+def load_definitions_from_path(name: str, path, *, keep=(), inner=(), namespace=None, stubs=()):
+    """Load only the definitions of a script whose top level runs a simulation.
+
+    Many research scripts parse argv, open a window or run a long simulation at
+    import. This executes only the top-level imports, functions and classes, and
+    the top-level assignments to the names in `keep` (constants the functions
+    use). `inner` names functions defined inside other functions (for example
+    marimo or Jupyter-exported cells); they are lifted to module level, and
+    their imports must then come from `namespace`.
+
+    Nothing else in the file runs, so a function that relies on a global set by
+    the skipped code fails with NameError; set it on the returned module.
+
+    `stubs` names modules (or maps module names to the names they must provide, see
+    `stub_modules`) to replace with stubs when they are not installed
+    (pygame, IPython, orbax, ...), for imports the tested functions do not use.
+    """
+    path = Path(path)
+    tree = ast.parse(path.read_text(encoding="utf-8"), str(path))
+    body = []
+    for node in tree.body:
+        if isinstance(node, (ast.Import, ast.ImportFrom, ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
+            body.append(node)
+        elif isinstance(node, (ast.Assign, ast.AnnAssign)):
+            targets = node.targets if isinstance(node, ast.Assign) else [node.target]
+            if any(isinstance(t, ast.Name) and t.id in keep for t in targets):
+                body.append(node)
+    if inner:
+        wanted = set(inner)
+        body += [n for n in ast.walk(tree) if isinstance(n, ast.FunctionDef) and n.name in wanted and n not in tree.body]
+    stub_modules(stubs)
+    module = types.ModuleType(name)
+    module.__file__ = str(path)
+    module.__dict__.update(namespace or {})
+    exec(compile(ast.Module(body=body, type_ignores=[]), str(path), "exec"), module.__dict__)
+    return module

{physverify-0.2.0 → physverify-0.3.0}/src/physverify/method_bugs.py

@@ -4,7 +4,9 @@ The problem benchmark (physverify.problems) seeds bugs into five solvers. Some b
 repositories are not bugs of a solver for one problem but of a method or a helper: a Butcher table with
 the wrong order label, error-estimate weights that do not sum to zero, backward time-stepping with
 stage times on the wrong side, a time loop that stops one step late, a spectral derivative that only
-works for even grids. This module seeds each of them, with a bug-free control, and names the check
+works for even grids, Dirichlet values written after the solve instead of inside the linear system, a
+zero-flux wall made by copying the neighbour value, a source term without its factor dt, a grid spacing
+off by one interval. This module seeds each of them, with a bug-free control, and names the check
 meant to catch it. `run_all()` returns one row per case; tests/test_method_bugs.py requires every
 prediction to come true.
 
@@ -21,7 +23,8 @@ import numpy as np
 from .butcher import check_tableau
 from .checks import FAIL, PASS, Result, run_check, Check
 from .mms import ManufacturedODE
-from .studies import backward_mms_study, size_sweep_check, time_grid_check
+from .order import check_order
+from .studies import backward_mms_study, balance_check, size_sweep_check, time_grid_check
 
 # --- Butcher tables ---------------------------------------------------------------------------------
 
@@ -100,6 +103,97 @@ def _spectral_derivative(halves_bug: bool):
     return check_at
 
 
+# --- heat equation boundaries and sources (batch 5) -------------------------------------------------
+
+def _cn_dirichlet_error(n: int, boundary_in_system: bool) -> float:
+    """Crank-Nicolson for u_t = u_xx on [0, 1], u = 0 at both ends, mode sin(pi x), t = 0.05, small dt.
+
+    With the bug the matrix covers all n points, boundary rows included, and the Dirichlet values are
+    written into the solution only after each solve, so the boundary nodes evolve freely meanwhile.
+    """
+    x = np.linspace(0.0, 1.0, n)
+    dx, t_end, steps = x[1] - x[0], 0.05, 2000
+    dt = t_end / steps
+    lam = dt / dx**2
+    u = np.sin(np.pi * x)
+    if boundary_in_system:
+        m = n - 2
+        D = (np.diag(-2.0 * np.ones(m)) + np.diag(np.ones(m - 1), 1) + np.diag(np.ones(m - 1), -1)) * lam
+        A, B = np.eye(m) - D / 2, np.eye(m) + D / 2
+        v = u[1:-1]
+        for _ in range(steps):
+            v = np.linalg.solve(A, B @ v)
+        u = np.concatenate([[0.0], v, [0.0]])
+    else:
+        D = (np.diag(-2.0 * np.ones(n)) + np.diag(np.ones(n - 1), 1) + np.diag(np.ones(n - 1), -1)) * lam
+        A, B = np.eye(n) - D / 2, np.eye(n) + D / 2
+        for _ in range(steps):
+            u = np.linalg.solve(A, B @ u)
+            u[0] = u[-1] = 0.0
+    return float(np.max(np.abs(u - np.exp(-np.pi**2 * t_end) * np.sin(np.pi * x))))
+
+
+def _dirichlet_case(boundary_in_system: bool):
+    ns = (11, 21, 41, 81)
+    return lambda: check_order([1.0 / (n - 1) for n in ns], [_cn_dirichlet_error(n, boundary_in_system) for n in ns], 2.0)
+
+
+def _neumann_heat_change(n: int, mirror: bool) -> float:
+    """Relative change of the total heat for u_t = u_xx on [0, 1] with insulated ends (explicit, 400 steps).
+
+    Control: edge nodes updated with a mirrored ghost value, total heat by the trapezoid rule (exactly
+    conserved). Bug: interior update, then u[0] = u[1], u[-1] = u[-2], total heat as sum(u) dx.
+    """
+    x = np.linspace(0.0, 1.0, n)
+    dx = x[1] - x[0]
+    dt = 0.25 * dx**2
+    u = np.exp(-((x - 0.3) ** 2) / 0.01)
+
+    def total(v):
+        w = np.full(n, dx)
+        if mirror:
+            w[[0, -1]] = dx / 2
+        return float(np.sum(w * v))
+
+    start = total(u)
+    for _ in range(400):
+        new = u.copy()
+        new[1:-1] = u[1:-1] + dt / dx**2 * (u[2:] - 2 * u[1:-1] + u[:-2])
+        if mirror:
+            new[0] = u[0] + dt / dx**2 * 2 * (u[1] - u[0])
+            new[-1] = u[-1] + dt / dx**2 * 2 * (u[-2] - u[-1])
+        else:
+            new[0], new[-1] = new[1], new[-2]
+        u = new
+    return (total(u) - start) / start
+
+
+def _source_gain(n: int, times_dt: bool) -> float:
+    """Gain of u under a constant source S = 2 over T = 1 with no diffusion, in n steps; exactly S T = 2."""
+    dt, u = 1.0 / n, 0.0
+    for _ in range(n):
+        u += 2.0 * dt if times_dt else 2.0
+    return u
+
+
+def _well_energy_error(n: int, spacing_from_intervals: bool) -> float:
+    """Lowest level of the infinite square well [0, 2] (hbar = m = 1) with n - 1 interior points.
+
+    n - 1 interior points split the well into n intervals, so dx = W/n; the bug uses W/(n - 1).
+    """
+    W = 2.0
+    dx = W / n if spacing_from_intervals else W / (n - 1)
+    m = n - 1
+    H = (np.diag(np.full(m, 1.0 / dx**2)) + np.diag(np.full(m - 1, -0.5 / dx**2), 1)
+         + np.diag(np.full(m - 1, -0.5 / dx**2), -1))
+    return float(abs(np.linalg.eigvalsh(H)[0] - np.pi**2 / (2 * W**2)))
+
+
+def _spacing_case(spacing_from_intervals: bool):
+    ns = (50, 100, 200, 400)
+    return lambda: check_order([2.0 / n for n in ns], [_well_energy_error(n, spacing_from_intervals) for n in ns], 2.0)
+
+
 @dataclass(frozen=True)
 class MethodCase:
     name: str
@@ -137,6 +231,27 @@ CASES = [
     MethodCase("spectral_even_only", True, "wavenumbers built from two halves of the array (fails for odd n)", "G10",
                "studies.size_sweep_check", lambda: size_sweep_check(_spectral_derivative(True)),
                missed_by="any study on power-of-two grids"),
+    MethodCase("dirichlet_ok", False, "Crank-Nicolson solving only for interior nodes, Dirichlet values in the system",
+               "-", "order.check_order", _dirichlet_case(True)),
+    MethodCase("dirichlet_after_solve", True,
+               "Crank-Nicolson matrix over all nodes, Dirichlet values written only after each solve", "H01",
+               "order.check_order", _dirichlet_case(False),
+               missed_by="a single run compared with a loose tolerance (the error is small but does not shrink)"),
+    MethodCase("neumann_ok", False, "insulated ends with a mirrored ghost value, trapezoid total", "-",
+               "studies.balance_check",
+               lambda: balance_check(lambda n: _neumann_heat_change(n, True), 0.0, (21, 41, 81), tol=1e-12)),
+    MethodCase("neumann_by_copy", True, "insulated ends made by copying the neighbour value after the update", "H54",
+               "studies.balance_check",
+               lambda: balance_check(lambda n: _neumann_heat_change(n, False), 0.0, (21, 41, 81), tol=1e-12),
+               missed_by="a one-step test with the heat away from the walls"),
+    MethodCase("source_ok", False, "source term multiplied by dt", "-", "studies.balance_check",
+               lambda: balance_check(lambda n: _source_gain(n, True), 2.0, (10, 100), tol=1e-12)),
+    MethodCase("source_without_dt", True, "source term added once per step without the factor dt", "H01",
+               "studies.balance_check", lambda: balance_check(lambda n: _source_gain(n, False), 2.0, (10, 100), tol=1e-12),
+               missed_by="any test with zero source"),
+    MethodCase("spacing_ok", False, "n - 1 interior points with dx = W/n", "-", "order.check_order", _spacing_case(True)),
+    MethodCase("spacing_off_by_one", True, "n - 1 interior points with dx = W/(n - 1)", "H19", "order.check_order",
+               _spacing_case(False), missed_by="a single comparison at n = 100 with a 5% tolerance"),
 ]
 
 

physverify-0.3.0/src/physverify/references.py

@@ -0,0 +1,128 @@
+"""Exact reference solutions that testing public codes needed again and again.
+
+Each one was written by hand in several adapters before it moved here (repository IDs as in
+results/corpus/SUMMARY.md). All are numpy-only and vectorised where that is natural.
+"""
+
+from __future__ import annotations
+
+import math
+
+import numpy as np
+
+# --- statistical mechanics ---------------------------------------------------------------------------
+
+
+def ising2d_exact(L: int, T: float, J: float = 1.0, h: float = 0.0) -> dict:
+    """Exact thermal averages of the periodic L x L Ising model by enumerating all 2^(L*L) states.
+
+    H = -J sum_<ij> s_i s_j - h sum_i s_i, k_B = 1. Returns per-site <e>, <|m|>, <m^2>, <m^4>, the
+    specific heat per site and Z. Practical up to L = 4 (65536 states); used for D04, H06, H55.
+    """
+    n = L * L
+    if n > 20:
+        raise ValueError("enumeration is limited to L*L <= 20 sites (L <= 4)")
+    states = ((np.arange(2**n)[:, None] >> np.arange(n)) & 1) * 2 - 1
+    s = states.reshape(-1, L, L)
+    bonds = np.sum(s * np.roll(s, 1, axis=1), axis=(1, 2)) + np.sum(s * np.roll(s, 1, axis=2), axis=(1, 2))
+    M = s.sum(axis=(1, 2))
+    E = -J * bonds - h * M
+    w = np.exp(-(E - E.min()) / T)
+    Z = w.sum()
+    avg = lambda q: float(np.sum(w * q) / Z)  # noqa: E731
+    e, e2 = avg(E) / n, avg(E**2) / n**2
+    return {"e": e, "m_abs": avg(np.abs(M)) / n, "m2": avg(M**2) / n**2, "m4": avg(M**4) / n**4,
+            "c": n * (e2 - e * e) / T**2, "Z": float(Z * np.exp(-E.min() / T))}
+
+
+def langevin(x):
+    """L(x) = coth x - 1/x, with the series near 0."""
+    x = np.asarray(x, dtype=float)
+    small = np.abs(x) < 1e-3
+    safe = np.where(small, 1.0, x)
+    return np.where(small, x / 3 - x**3 / 45, 1 / np.tanh(safe) - 1 / safe)
+
+
+def heisenberg_open_chain(N: int, J: float, T: float) -> dict:
+    """Classical unit-vector Heisenberg chain with open ends, H = -J sum S_i.S_{i+1}: exact per-site
+    energy and specific heat (each bond is independent). Used for H64."""
+    b = J / T
+    e = -(N - 1) * J * float(langevin(b)) / N
+    c = (N - 1) / N * (1 - b * b / math.sinh(b) ** 2)
+    return {"e": e, "c": c}
+
+
+# --- diffusion and transport -------------------------------------------------------------------------
+
+
+def heat_sine_mode(x, t, L: float = 1.0, kappa: float = 1.0, mode: int = 1):
+    """u_t = kappa u_xx on [0, L], u = 0 at both ends, u(x, 0) = sin(mode pi x / L)."""
+    k = mode * np.pi / L
+    return np.exp(-kappa * k * k * t) * np.sin(k * np.asarray(x, dtype=float))
+
+
+def advection_diffusion_gaussian(x, t, x0: float, sigma0: float, v: float = 0.0, D: float = 0.0):
+    """Gaussian of peak 1 and width sigma0 at x0, carried at speed v and spread by D on the whole line:
+    sigma^2 = sigma0^2 + 2 D t, peak sigma0/sigma. Used for H25."""
+    s = math.sqrt(sigma0**2 + 2 * D * t)
+    return sigma0 / s * np.exp(-((np.asarray(x, dtype=float) - x0 - v * t) ** 2) / (2 * s * s))
+
+
+def semi_infinite_step(x, t, alpha: float, T0: float, Ts: float):
+    """Semi-infinite solid at T0, surface held at Ts from t = 0: T = Ts + (T0 - Ts) erf(x / 2 sqrt(alpha t))."""
+    x = np.asarray(x, dtype=float)
+    return Ts + (T0 - Ts) * np.vectorize(math.erf)(x / (2 * math.sqrt(alpha * t)))
+
+
+# --- mechanics ---------------------------------------------------------------------------------------
+
+
+def double_pendulum_acc(th1, w1, th2, w2, m1, m2, l1, l2, g=9.81):
+    """Angular accelerations of a double pendulum (point masses, massless rods, angles from the downward
+    vertical), from the Lagrangian mass matrix. Used for D01, E01, H03, H27."""
+    d = th1 - th2
+    M = np.array([[(m1 + m2) * l1**2, m2 * l1 * l2 * np.cos(d)], [m2 * l1 * l2 * np.cos(d), m2 * l2**2]])
+    r = np.array([-m2 * l1 * l2 * w2**2 * np.sin(d) - (m1 + m2) * g * l1 * np.sin(th1),
+                  m2 * l1 * l2 * w1**2 * np.sin(d) - m2 * g * l2 * np.sin(th2)])
+    return np.linalg.solve(M, r)
+
+
+def double_pendulum_energy(th1, w1, th2, w2, m1, m2, l1, l2, g=9.81):
+    v1sq = (l1 * w1) ** 2
+    v2sq = v1sq + (l2 * w2) ** 2 + 2 * l1 * l2 * w1 * w2 * np.cos(th1 - th2)
+    return 0.5 * m1 * v1sq + 0.5 * m2 * v2sq - (m1 + m2) * g * l1 * np.cos(th1) - m2 * g * l2 * np.cos(th2)
+
+
+def cantilever_tip(P: float, L: float, E: float, I: float) -> tuple[float, float]:
+    """Euler-Bernoulli cantilever with an end load: tip deflection P L^3/(3EI) and rotation P L^2/(2EI)."""
+    return P * L**3 / (3 * E * I), P * L**2 / (2 * E * I)
+
+
+# --- quantum mechanics -------------------------------------------------------------------------------
+
+
+def infinite_well_energy(n, W: float, hbar: float = 1.0, m: float = 1.0):
+    """E_n = n^2 pi^2 hbar^2 / (2 m W^2), n = 1, 2, ... Used for H19."""
+    n = np.asarray(n, dtype=float)
+    return n * n * np.pi**2 * hbar**2 / (2 * m * W * W)
+
+
+def barrier_transmission(E, V: float, a: float, hbar: float = 1.0, m: float = 1.0):
+    """Transmission probability through a square barrier of height V and width a (E != V). Used for H40."""
+    E = np.asarray(E, dtype=float)
+    k = np.sqrt(2 * m * np.abs(V - E)) / hbar * a
+    s2 = np.where(E < V, np.sinh(k) ** 2, np.sin(k) ** 2)
+    return 1 / (1 + V * V * s2 / (4 * E * np.abs(V - E)))
+
+
+def tfim_open_ground_energy(N: int, J: float, h: float) -> float:
+    """Ground energy of the open transverse-field Ising chain H = J sum Z_i Z_{i+1} + h sum X_i, from the
+    free-fermion (Jordan-Wigner, Bogoliubov-de Gennes) solution; the sign of J does not matter. Used for H22."""
+    A = np.zeros((N, N))
+    B = np.zeros((N, N))
+    np.fill_diagonal(A, 2 * h)
+    for i in range(N - 1):
+        A[i, i + 1] = A[i + 1, i] = J
+        B[i, i + 1], B[i + 1, i] = J, -J
+    eps = np.linalg.eigvalsh(np.block([[A, B], [-B, -A]]))
+    return float(-0.5 * np.sum(eps[eps > 0]))

{physverify-0.2.0 → physverify-0.3.0}/src/physverify/studies.py

@@ -186,6 +186,32 @@ def backward_mms_study(integrate_back: Callable, mms: ManufacturedODE, t_end: fl
     return check_order(hs, errs, expected_order, **kw)
 
 
+def balance_check(measure: Callable, expected: float, resolutions, *, tol: float = 1e-9, label: str = "") -> Result:
+    """Check an exact discrete balance at every resolution: `measure(n)` must equal `expected` to `tol`.
+
+    A conservative scheme keeps a budget exactly on every grid: the total heat with
+    insulated walls, the heat gained from a known boundary flux or source over a run.
+    Three real codes failed such a budget while still converging: a zero-flux wall
+    made by copying the neighbour value lost 8.5% of the heat, a source added
+    without the factor dt depended on the number of steps, and boundary nodes
+    given full cells took in 7% too much heat. A convergence study alone can pass
+    these, so the check reports whether the mismatch shrinks with resolution.
+    """
+    rows = []
+    for n in resolutions:
+        rows.append((n, float(measure(n))))
+    bad = [(n, v) for n, v in rows if not abs(v - expected) <= tol]
+    prefix = f"{label}: " if label else ""
+    listing = ", ".join(f"n={n}: {v:.6g}" for n, v in rows)
+    if not bad:
+        return Result(PASS, f"{prefix}balance {expected:.6g} kept to {tol:g} at every resolution ({listing})")
+    gaps = [abs(v - expected) for _, v in rows]
+    shrinking = len(gaps) > 1 and all(b < a for a, b in zip(gaps, gaps[1:]))
+    hint = ("; the mismatch shrinks with resolution, so the scheme converges but does not conserve"
+            if shrinking else "")
+    return Result(FAIL, f"{prefix}expected {expected:.6g}, got {listing}{hint}")
+
+
 def size_sweep_check(run_at_size: Callable, sizes=(15, 16, 31, 32, 63, 64), *, label: str = "") -> Result:
     """Call `run_at_size(n)` for odd and even sizes; FAIL if it raises for some of them.
 

{physverify-0.2.0 → physverify-0.3.0/src/physverify.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: physverify
-Version: 0.2.0
+Version: 0.3.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
@@ -39,7 +39,7 @@ Dynamic: license-file
 
 **A tool that checks whether a physics simulation is solving the right equations correctly, not just running without errors.**
 
-Status: early version (0.2.0). It has been tried on 20 public physics repositories (see below), but nobody besides the author has used it yet, so feedback is very welcome.
+Status: early version (0.3.0). It has been tried on 68 public physics repositories (see below), but nobody besides the author has used it yet, so feedback is very welcome.
 
 ## The problem it addresses
 
@@ -51,7 +51,7 @@ 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).
+3. **Check conserved quantities and budgets.** Energy, mass or momentum should stay constant (or drift in a predictable way), and heat added through a wall or a source should match what went in, exactly, on every grid.
 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.
 6. **Algebraic checks on the method itself.** For a Runge-Kutta method, whether the coefficients really have the order they claim can be settled exactly, with no test problem (the "order conditions").
@@ -74,12 +74,14 @@ The bugs and the checks were written by the same person, so these numbers show t
 
 ## Trying it on other people's code
 
-To see what it does on code it was not written for, 40 public Python physics repositories were drawn at random from GitHub searches (October 2026) and run in a locked-down container: no network, the repository read-only, nothing from it run on the author's computer.
+To see what it does on code it was not written for, public Python physics repositories from GitHub were run in a locked-down container (October 2026): no network, the repository read-only, nothing from it run on the author's computer. 40 were drawn at random from topic searches (batches 1 to 4); another 60 were the newest small repositories whose README says the work is complete (batch 5), and 20 more were picked because they are quick to test (batch 6); batches 5 and 6 are not random.
 
-- **20 of the 40 could be tested.** Most of the others were not numerical solvers (neural networks, apps and games, analysis tools), one needed a recent NVIDIA GPU, and a few need more set-up.
-- **9 confirmed bugs in 6 of the 20.** For example: a measured energy that counts the magnetic-field term twice; backward time-stepping that is only first-order accurate; Runge-Kutta coefficient tables labelled with a higher order than they have; error-estimate weights that do not sum to zero; a spectral derivative that crashes for an odd number of grid points; a crash on NumPy 2.
-- **The other 14 had no confirmed bug.** Most passed every check that applied, often to 1e-13 or better; one raised a question for its authors rather than a bug report.
-- **Our own adapters were wrong about 15 times** before checking (a wrong constant, too-coarse steps, and so on). Every FAIL was checked by hand before being called a bug, and these mistakes are recorded, not hidden.
+- **68 of the 120 could be tested.** Most of the others were not numerical solvers (neural networks, apps and games, analysis tools, finance), one needed a recent NVIDIA GPU, and a few need more set-up.
+- **16 confirmed bugs in 12 of the 68.** For example: a measured energy that counts the magnetic-field term twice; backward time-stepping that is only first-order accurate; Runge-Kutta coefficient tables labelled with a higher order than they have; a spectral derivative that crashes for an odd number of grid points; boundary values applied after the linear solve instead of inside it; an insulated wall that leaks heat; a grid spacing off by one interval; a Kepler solver that fails for negative angles.
+- **The rest had no confirmed bug.** Most passed every check that applied, often to 1e-13 or better.
+- **Our own adapters were wrong about 28 times** before checking (a wrong constant, too-coarse steps, a wrong sign convention, and so on). Every FAIL was checked by hand before being called a bug, and these mistakes are recorded, not hidden.
+
+These counts describe the repositories that were drawn; they are not a bug rate for physics code in general.
 
 Each lesson became a new check or a clearer message in physverify. The testing and write-ups were done with help from an AI assistant; every number comes from running the code. Authors are told about a finding before their project is named, so the repositories are listed by ID: [results/corpus/SUMMARY.md](https://github.com/rcgiri-physics/physverify/blob/main/results/corpus/SUMMARY.md).
 
@@ -120,7 +122,7 @@ pytest my_spec.py                              # each check becomes a pytest tes
 
 ## More
 
-- [results/corpus/SUMMARY.md](https://github.com/rcgiri-physics/physverify/blob/main/results/corpus/SUMMARY.md): the 40 public repositories, what was tested and what was found.
+- [results/corpus/SUMMARY.md](https://github.com/rcgiri-physics/physverify/blob/main/results/corpus/SUMMARY.md): the 120 public repositories, what was tested and what was found.
 - [sandbox/README.md](https://github.com/rcgiri-physics/physverify/blob/main/sandbox/README.md): the locked-down container used to run other people's code.
 - [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.

{physverify-0.2.0 → physverify-0.3.0}/src/physverify.egg-info/SOURCES.txt

@@ -15,6 +15,7 @@ src/physverify/method_bugs.py
 src/physverify/mms.py
 src/physverify/order.py
 src/physverify/pytest_plugin.py
+src/physverify/references.py
 src/physverify/report.py
 src/physverify/steppers.py
 src/physverify/studies.py
@@ -58,5 +59,6 @@ tests/test_order.py
 tests/test_properties.py
 tests/test_real_projects.py
 tests/test_reference_problems.py
+tests/test_references.py
 tests/test_seeded_bugs.py
 tests/test_studies.py

{physverify-0.2.0 → physverify-0.3.0}/tests/test_corpus_lessons.py

@@ -143,3 +143,48 @@ def test_load_definitions_stubs_missing_imports(tmp_path):
     src.write_text("import not_installed_plotting_pkg\nimport math\ndef f(x):\n    return math.sqrt(x)\n")
     mod = load_definitions_from_path("sim_stub", src, stubs=("not_installed_plotting_pkg",))
     assert mod.f(4.0) == 2.0
+
+
+def test_balance_check_catches_a_converging_but_non_conservative_scheme():
+    from physverify.studies import balance_check
+
+    # a budget that is wrong by 1/n: converges, never conserves (the heat-loss pattern of a real code)
+    r = balance_check(lambda n: 1.0 / n, 0.0, (10, 20, 40), tol=1e-12)
+    assert r.status == FAIL and "converges but does not conserve" in r.message
+    # exact at every resolution
+    assert balance_check(lambda n: 2.0, 2.0, (10, 100)).status == PASS
+    # wrong and growing with n (a source added without dt): FAIL without the converging hint
+    r = balance_check(lambda n: 2.0 * n, 2.0, (10, 100))
+    assert r.status == FAIL and "converges" not in r.message
+
+
+def test_stub_modules_provide_names_and_keep_decorated_functions():
+    import sys
+
+    from physverify.loaders import Placeholder, stub_modules
+
+    names = stub_modules({"no_such_pkg_xyz.metrics": ["score"], "no_such_web_xyz": ["Flask"]})
+    try:
+        from no_such_pkg_xyz.metrics import score  # noqa: F401  (a parent package is created too)
+        import no_such_web_xyz
+
+        app = no_such_web_xyz.Flask(__name__)
+
+        @app.route("/x", methods=["POST"])
+        def view():
+            return 42
+
+        assert view() == 42 and isinstance(score, Placeholder)
+        assert stub_modules(["math"]) == []  # a module that imports for real is left alone
+    finally:
+        for n in names:
+            sys.modules.pop(n, None)
+
+
+def test_run_script_returns_globals_and_output(tmp_path):
+    from physverify.loaders import run_script
+
+    src = tmp_path / "demo.py"
+    src.write_text("import sys\nx = 6 * 7\nprint('hello', sys.argv[1:])\n")
+    g, out = run_script(src, argv=["a"])
+    assert g["x"] == 42 and "hello ['a']" in out

physverify-0.3.0/tests/test_references.py

@@ -0,0 +1,103 @@
+"""Each reference in physverify.references against an independent computation."""
+
+import itertools
+import math
+
+import numpy as np
+
+from physverify import references as R
+
+
+def test_ising_enumeration_matches_a_plain_loop():
+    L, T, J, h = 3, 2.2, 0.8, 0.3
+    Z = Es = Ms = 0.0
+    for spins in itertools.product((-1, 1), repeat=L * L):
+        s = np.array(spins).reshape(L, L)
+        E = 0.0
+        for i in range(L):
+            for j in range(L):
+                E -= J * s[i, j] * (s[(i + 1) % L, j] + s[i, (j + 1) % L]) + h * s[i, j]
+        w = math.exp(-E / T)
+        Z, Es, Ms = Z + w, Es + w * E, Ms + w * abs(s.sum())
+    r = R.ising2d_exact(L, T, J, h)
+    assert abs(r["e"] - Es / Z / L**2) < 1e-12
+    assert abs(r["m_abs"] - Ms / Z / L**2) < 1e-12
+    assert abs(r["Z"] - Z) / Z < 1e-12
+
+
+def test_ising_specific_heat_is_the_temperature_derivative_of_energy():
+    dT = 1e-4
+    e = lambda T: R.ising2d_exact(4, T)["e"]  # noqa: E731
+    c_fd = (e(2.3 + dT) - e(2.3 - dT)) / (2 * dT)
+    assert abs(R.ising2d_exact(4, 2.3)["c"] - c_fd) < 1e-6
+
+
+def test_heisenberg_chain_bond_energy_by_quadrature():
+    # one bond: <cos theta> under exp(b cos theta) on the sphere
+    b = 1.7
+    z = np.linspace(-1, 1, 200001)
+    w = np.exp(b * z)
+    mean = np.trapezoid(z * w, z) / np.trapezoid(w, z)
+    r = R.heisenberg_open_chain(5, 1.7, 1.0)
+    assert abs(r["e"] - (-(4 / 5) * 1.7 * mean)) < 1e-9  # -(N-1)/N J <cos>
+    assert abs(float(R.langevin(1e-5)) - 1e-5 / 3) < 1e-15
+
+
+def test_heat_mode_and_gaussian_satisfy_their_equations():
+    x, t, h = 0.37, 0.05, 1e-4
+    u = lambda x, t: R.heat_sine_mode(x, t, L=2.0, kappa=0.7, mode=3)  # noqa: E731
+    ut = (u(x, t + h) - u(x, t - h)) / (2 * h)
+    uxx = (u(x + h, t) - 2 * u(x, t) + u(x - h, t)) / h**2
+    assert abs(ut - 0.7 * uxx) < 1e-5
+    g = lambda x, t: R.advection_diffusion_gaussian(x, t, 1.0, 0.5, v=0.3, D=0.2)  # noqa: E731
+    x, t = 1.4, 2.0
+    gt = (g(x, t + h) - g(x, t - h)) / (2 * h)
+    gx = (g(x + h, t) - g(x - h, t)) / (2 * h)
+    gxx = (g(x + h, t) - 2 * g(x, t) + g(x - h, t)) / h**2
+    assert abs(gt + 0.3 * gx - 0.2 * gxx) < 1e-5
+
+
+def test_double_pendulum_conserves_its_energy():
+    p = (0.7, 1.9, 1.3, 0.6, 9.81)
+    y = np.array([2.0, 0.0, -0.5, 0.3])
+
+    def f(y):
+        a = R.double_pendulum_acc(y[0], y[1], y[2], y[3], *p)
+        return np.array([y[1], a[0], y[3], a[1]])
+
+    E0 = R.double_pendulum_energy(y[0], y[1], y[2], y[3], *p)
+    dt = 1e-3
+    for _ in range(2000):
+        k1 = f(y); k2 = f(y + dt / 2 * k1); k3 = f(y + dt / 2 * k2); k4 = f(y + dt * k3)
+        y = y + dt / 6 * (k1 + 2 * k2 + 2 * k3 + k4)
+    assert abs(R.double_pendulum_energy(y[0], y[1], y[2], y[3], *p) - E0) < 1e-6 * abs(E0)  # RK4, dt = 1e-3, 2 s: drift about 5e-8
+
+
+def test_quantum_references():
+    # infinite well against a fine finite-difference matrix
+    n, W = 400, 2.0
+    dx = W / n
+    H = np.diag(np.full(n - 1, 1 / dx**2)) + np.diag(np.full(n - 2, -0.5 / dx**2), 1) + np.diag(np.full(n - 2, -0.5 / dx**2), -1)
+    assert abs(np.linalg.eigvalsh(H)[0] / R.infinite_well_energy(1, W) - 1) < 1e-4
+    # barrier: unitarity-free textbook limit, T -> 1 for V -> 0 and the E < V tunnelling formula
+    assert abs(R.barrier_transmission(0.7, 1e-9, 2.0) - 1) < 1e-8
+    k = math.sqrt(2 * 0.3) * 2.0
+    assert abs(R.barrier_transmission(0.7, 1.0, 2.0) - 1 / (1 + math.sinh(k) ** 2 / (4 * 0.7 * 0.3))) < 1e-14
+    # TFIM against dense diagonalisation
+    N, J, h = 6, 1.1, 0.7
+    X, Z, I = np.array([[0, 1], [1, 0]]), np.diag([1, -1]), np.eye(2)
+
+    def op(d):
+        out = np.ones((1, 1))
+        for q in range(N):
+            out = np.kron(out, d.get(q, I))
+        return out
+
+    Hd = sum(J * op({i: Z, i + 1: Z}) for i in range(N - 1)) + sum(h * op({i: X}) for i in range(N))
+    assert abs(np.linalg.eigvalsh(Hd)[0] - R.tfim_open_ground_energy(N, J, h)) < 1e-10
+    assert R.cantilever_tip(10.0, 5.0, 2e8, 1e-4)[0] == 10.0 * 125.0 / (3 * 2e8 * 1e-4)
+
+
+def test_semi_infinite_step_limits():
+    assert abs(R.semi_infinite_step(0.0, 1.0, 1e-5, 300.0, 1000.0) - 1000.0) < 1e-12
+    assert abs(R.semi_infinite_step(1.0, 1.0, 1e-5, 300.0, 1000.0) - 300.0) < 1e-9

physverify-0.2.0/src/physverify/loaders.py

@@ -1,94 +0,0 @@
-"""Import a module from a path without touching its folder.
-
-Used by the adapters that test other people's code. Nothing is written next to
-the module (no __pycache__), and optional plotting imports can be stubbed so a
-simulation file can be imported on a machine without matplotlib.
-"""
-
-from __future__ import annotations
-
-import ast
-import importlib
-import importlib.util
-import sys
-import types
-from pathlib import Path
-
-
-def _stub_module(name: str) -> types.ModuleType:
-    return types.ModuleType(name)
-
-
-def load_module_from_path(name: str, path, stubs=()):
-    path = Path(path)
-    if not path.is_file():
-        raise FileNotFoundError(path)
-
-    added = []
-    for stub in stubs:
-        try:
-            importlib.import_module(stub)
-        except ImportError:
-            sys.modules[stub] = _stub_module(stub)
-            added.append(stub)
-
-    old_flag = sys.dont_write_bytecode
-    sys.dont_write_bytecode = True
-    try:
-        spec = importlib.util.spec_from_file_location(name, path)
-        module = importlib.util.module_from_spec(spec)
-        sys.modules[name] = module
-        try:
-            spec.loader.exec_module(module)
-        except BaseException:
-            sys.modules.pop(name, None)  # do not leave a half-initialised module behind
-            raise
-    finally:
-        sys.dont_write_bytecode = old_flag
-        for stub in added:
-            sys.modules.pop(stub, None)
-    return module
-
-
-def load_definitions_from_path(name: str, path, *, keep=(), inner=(), namespace=None, stubs=()):
-    """Load only the definitions of a script whose top level runs a simulation.
-
-    Many research scripts parse argv, open a window or run a long simulation at
-    import. This executes only the top-level imports, functions and classes, and
-    the top-level assignments to the names in `keep` (constants the functions
-    use). `inner` names functions defined inside other functions (for example
-    marimo or Jupyter-exported cells); they are lifted to module level, and
-    their imports must then come from `namespace`.
-
-    Nothing else in the file runs, so a function that relies on a global set by
-    the skipped code fails with NameError; set it on the returned module.
-
-    `stubs` names modules to replace with empty ones when they are not installed
-    (pygame, IPython, orbax, ...), for imports the tested functions do not use.
-    """
-    path = Path(path)
-    tree = ast.parse(path.read_text(encoding="utf-8"), str(path))
-    body = []
-    for node in tree.body:
-        if isinstance(node, (ast.Import, ast.ImportFrom, ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
-            body.append(node)
-        elif isinstance(node, (ast.Assign, ast.AnnAssign)):
-            targets = node.targets if isinstance(node, ast.Assign) else [node.target]
-            if any(isinstance(t, ast.Name) and t.id in keep for t in targets):
-                body.append(node)
-    if inner:
-        wanted = set(inner)
-        body += [n for n in ast.walk(tree) if isinstance(n, ast.FunctionDef) and n.name in wanted and n not in tree.body]
-    for stub in stubs:
-        try:
-            importlib.import_module(stub)
-        except ImportError:
-            parent, _, child = stub.rpartition(".")
-            sys.modules[stub] = _stub_module(stub)
-            if parent in sys.modules:
-                setattr(sys.modules[parent], child, sys.modules[stub])
-    module = types.ModuleType(name)
-    module.__file__ = str(path)
-    module.__dict__.update(namespace or {})
-    exec(compile(ast.Module(body=body, type_ignores=[]), str(path), "exec"), module.__dict__)
-    return module