physverify 0.1.0__py3-none-any.whl

physverify/stochastic/stats.py

@@ -0,0 +1,137 @@
+"""Statistics for Monte Carlo checks: error bars, autocorrelation and verdicts.
+
+Design (docs/plan_ising.md, section 4):
+
+* Every estimate is a mean over independent chains (each chain is burned in and
+  then averaged). Chains are independent by construction, so the standard error
+  is the spread of the chain means over sqrt(n_chains), with no
+  autocorrelation model needed. Within one chain, `tau_int` and `blocked_error`
+  give the error bar for codes that report one.
+* A check makes m comparisons with exact values. Each uses a two-sided Student-t
+  test with n_chains - 1 degrees of freedom at level alpha / m (Bonferroni),
+  so the false-alarm rate of a whole check is at most alpha.
+* Verdicts: FAIL when some comparison is significant; INCONCLUSIVE when none is,
+  but the test could not have detected a deviation as large as the stated
+  resolution (critical value times standard error > resolution); PASS otherwise.
+"""
+
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass
+from functools import lru_cache
+
+import numpy as np
+
+from ..checks import FAIL, INCONCLUSIVE, PASS, Result
+
+ALPHA_CHECK = 1e-3  # false-alarm rate of one statistical check
+
+
+def _t_pdf(x, nu):
+    c = math.lgamma((nu + 1) / 2) - math.lgamma(nu / 2) - 0.5 * math.log(nu * math.pi)
+    return np.exp(c - (nu + 1) / 2 * np.log1p(x * x / nu))
+
+
+def t_sf(x: float, nu: float) -> float:
+    """P(T > x) for Student's t with nu degrees of freedom (x >= 0), by Simpson's rule on the pdf."""
+    x = abs(float(x))
+    if nu > 1e6:
+        return 0.5 * math.erfc(x / math.sqrt(2))
+    n = 4000
+    grid = np.linspace(0.0, x, n + 1)
+    w = np.ones(n + 1)
+    w[1:-1:2], w[2:-1:2] = 4, 2
+    integral = float((w * _t_pdf(grid, nu)).sum() * x / (3 * n))
+    return max(0.0, 0.5 - integral)
+
+
+@lru_cache(maxsize=4096)
+def t_critical(alpha_two_sided: float, nu: float) -> float:
+    """x with P(|T| > x) = alpha, by bisection (cached: checks ask for the same few values)."""
+    lo, hi = 0.0, 50.0
+    for _ in range(80):
+        mid = 0.5 * (lo + hi)
+        if 2 * t_sf(mid, nu) > alpha_two_sided:
+            lo = mid
+        else:
+            hi = mid
+    return 0.5 * (lo + hi)
+
+
+def tau_int(series, c: float = 6.0) -> float:
+    """Integrated autocorrelation time with Sokal's automatic window (window W >= c * tau)."""
+    x = np.asarray(series, dtype=float)
+    x = x - x.mean()
+    n = len(x)
+    var = float(np.dot(x, x)) / n
+    if n < 4 or var == 0.0:
+        return 0.5
+    f = np.fft.rfft(x, 2 * n)
+    acf = np.fft.irfft(f * np.conj(f))[:n] / (n * var)
+    tau = 0.5
+    for w in range(1, n):
+        tau += acf[w]
+        if w >= c * tau:
+            break
+    return max(tau, 0.5)
+
+
+def blocked_error(series) -> float:
+    """Standard error of the mean of a correlated series: sqrt(2 tau var / n)."""
+    x = np.asarray(series, dtype=float)
+    return float(np.sqrt(2.0 * tau_int(x) * x.var() / len(x)))
+
+
+@dataclass
+class Comparison:
+    name: str
+    estimate: float
+    se: float
+    exact: float
+    resolution: float
+    dof: float
+
+
+def compare_chain_means(name, per_chain_values, exact, resolution, min_se=0.0) -> Comparison:
+    """Mean over independent chains, with the spread of the chain means as its standard error.
+
+    `min_se` is a floor for the standard error: for the frequency of a rare event the
+    chain-to-chain spread can be zero when the event never happens, which would make
+    any small expected probability look like a certain deviation.
+    """
+    v = np.asarray(per_chain_values, dtype=float)
+    se = float(v.std(ddof=1) / math.sqrt(len(v))) if len(v) > 1 else float("inf")
+    return Comparison(name, float(v.mean()), max(se, float(min_se)), float(exact), float(resolution), len(v) - 1)
+
+
+def verdict(comparisons, alpha: float = ALPHA_CHECK) -> Result:
+    """Bonferroni-corrected t-tests; see the module docstring for PASS, FAIL and INCONCLUSIVE."""
+    m = max(len(comparisons), 1)
+    worst, worst_ratio, unresolved = None, -1.0, []
+    for c in comparisons:
+        if not (np.isfinite(c.estimate) and np.isfinite(c.se)):
+            return Result(FAIL, f"{c.name}: non-finite estimate")
+        crit = t_critical(alpha / m, float(c.dof))
+        dev = abs(c.estimate - c.exact)
+        if c.se == 0.0:
+            ratio = math.inf if dev > 1e-12 * max(1.0, abs(c.exact)) else 0.0
+        else:
+            ratio = dev / (crit * c.se)
+        if ratio > worst_ratio:
+            worst, worst_ratio = c, ratio
+        if crit * c.se > c.resolution:
+            unresolved.append(c.name)
+    w = worst
+    detail = f"{w.name} = {w.estimate:.5g} +- {w.se:.2g}, exact {w.exact:.5g}"
+    level = f"(Bonferroni over {m}, false-alarm rate {alpha:g})"
+    if worst_ratio > 1.0:
+        sigmas = abs(w.estimate - w.exact) / w.se if w.se > 0 else math.inf
+        return Result(FAIL, f"{detail}: off by {sigmas:.1f} standard errors {level}")
+    if unresolved:
+        return Result(
+            INCONCLUSIVE,
+            f"no significant deviation, but the error bars cannot resolve a deviation of the stated size for "
+            f"{len(unresolved)} of {m} comparisons (first: {unresolved[0]}) {level}",
+        )
+    return Result(PASS, f"all {m} comparisons agree; largest: {detail} {level}")

physverify/studies.py

@@ -0,0 +1,146 @@
+"""Order studies other than MMS, and a helper that bundles them for an ODE code."""
+
+from __future__ import annotations
+
+from typing import Callable
+
+import numpy as np
+
+from .checks import FAIL, PASS, Check, OrderResult, Result
+from .mms import ManufacturedODE, max_abs_error, mms_order_study, mms_trajectory_study, zero_source
+from .order import check_exact, check_order
+from .steppers import integrate_fixed, rk4
+
+
+def reference_study(integrate, rhs_ref, y0, t_end, ns, expected_order, ref_factor=16, **kw) -> OrderResult:
+    """Compare with a reference solution from an independent right-hand side.
+
+    The reference is RK4 on `rhs_ref` with ref_factor times the finest step
+    count, so its own error is negligible next to the code under test.
+    """
+    y_ref = integrate_fixed(rhs_ref, y0, 0.0, t_end, ref_factor * max(ns), rk4)
+    kw.setdefault("scale", float(np.max(np.abs(y_ref))))
+    hs, errs = [], []
+    for n in ns:
+        hs.append(t_end / n)
+        errs.append(max_abs_error(integrate(zero_source, y0, t_end, n), y_ref))
+    return check_order(hs, errs, expected_order, **kw)
+
+
+def invariant_study(integrate, quantity, y0, t_end, ns, expected_order, **kw) -> OrderResult:
+    """Relative drift of a conserved quantity at t_end as the step shrinks.
+
+    Drift is only required to shrink at least as fast as the scheme's order.
+    RK4 on a pendulum, for example, drifts in energy at about order 5, so a
+    drift that converges faster than expected is not a failure here.
+    """
+    kw.setdefault("tol_high", float("inf"))
+    q0 = float(quantity(np.asarray(y0, dtype=float)))
+    scale = max(abs(q0), 1.0)
+    hs, errs = [], []
+    for n in ns:
+        with np.errstate(all="ignore"):
+            y_end = np.asarray(integrate(zero_source, y0, t_end, n), dtype=float)
+            drift = abs(float(quantity(y_end)) - q0) / scale
+        hs.append(t_end / n)
+        errs.append(drift)
+    return check_order(hs, errs, expected_order, **kw)
+
+
+def linear_manufactured(rhs_ref: Callable, y0, slope) -> ManufacturedODE:
+    """u(t) = y0 + slope * t, with its forcing taken from the reference operator."""
+    y0 = np.asarray(y0, dtype=float)
+    slope = np.asarray(slope, dtype=float)
+    return ManufacturedODE(lambda t: y0 + slope * t, rhs_ref, du=lambda t: slope)
+
+
+def patch_study(integrate, rhs_ref, y0, slope, t_end, ns, *, floor=1e-11) -> OrderResult:
+    """Exactness test for an ODE code: a manufactured solution linear in t.
+
+    Every consistent explicit Runge-Kutta method (Euler, midpoint, RK4, ...)
+    reproduces u(t) = y0 + slope * t exactly, whatever the step: each stage
+    lands on u at its own stage time, so each stage derivative is exactly
+    `slope`, and weights that sum to one return y0 + slope * (t + h). So any
+    error above round-off is a bug, including bugs whose error shrinks at the
+    scheme's own order (an extra step for Euler, a wrong stage time) that every
+    order-of-convergence check accepts. See docs/patch.md.
+
+    It does not see a wrong but consistent stepper (Euler in place of RK4 is
+    still exact here): the order studies cover that.
+    """
+    mms = linear_manufactured(rhs_ref, y0, slope)
+    exact = mms.value(t_end)
+    hs, errs = [], []
+    for n in ns:
+        y_end = integrate(mms.forcing, mms.value(0.0), t_end, n)
+        hs.append(t_end / n)
+        errs.append(max_abs_error(y_end, exact))
+    return check_exact(hs, errs, floor=floor, scale=float(np.max(np.abs(exact))))
+
+
+def smoke_check(label, integrate, rhs_ref, y0, t_end, n, *, rtol=1e-3) -> Check:
+    """What an ordinary unit test would do: one run, compared with a reference within a tolerance.
+
+    Not one of the verification families. It is here so that the benchmark can
+    report what a plain test would have caught (see physverify.compare).
+    """
+
+    def run():
+        y_ref = integrate_fixed(rhs_ref, y0, 0.0, t_end, 16 * n, rk4)
+        y = np.asarray(integrate(zero_source, y0, t_end, n), dtype=float)
+        return close_result(y, y_ref, rtol)
+
+    return Check("smoke", label, run)
+
+
+def close_result(value, expected, rtol) -> Result:
+    value = np.asarray(value, dtype=float)
+    expected = np.asarray(expected, dtype=float)
+    with np.errstate(all="ignore"):
+        err = float(np.max(np.abs(value - expected)) / max(float(np.max(np.abs(expected))), 1e-300))
+    if np.isfinite(err) and err <= rtol:
+        return Result(PASS, f"relative difference {err:.2g} within {rtol:g}")
+    return Result(FAIL, f"relative difference {err:.3g} exceeds {rtol:g}")
+
+
+def ode_checks(
+    label: str,
+    integrate: Callable,
+    *,
+    rhs_ref: Callable,
+    mms: ManufacturedODE,
+    y0_free,
+    t_end: float,
+    ns,
+    order: float,
+    quantity: Callable | None = None,
+    floor: float = 1e-12,
+    patch: tuple | None = None,
+    integrate_trajectory: Callable | None = None,
+) -> list[Check]:
+    """The standard bundle for an ODE code: MMS, reference solution, invariant.
+
+    patch                 (y0, slope) of a linear manufactured solution; adds the exactness check
+    integrate_trajectory  same contract as `integrate` but returning every state; adds an MMS
+                          check on the largest error over the whole run
+    """
+    checks = [
+        Check("mms", label, lambda: mms_order_study(integrate, mms, t_end, ns, order, floor=floor)),
+        Check("reference", label, lambda: reference_study(integrate, rhs_ref, y0_free, t_end, ns, order, floor=floor)),
+    ]
+    if integrate_trajectory is not None:
+        checks.append(
+            Check(
+                "mms",
+                f"{label} (whole trajectory)",
+                lambda: mms_trajectory_study(integrate_trajectory, mms, t_end, ns, order, floor=floor),
+            )
+        )
+    if quantity is not None:
+        checks.append(
+            Check("invariant", label, lambda: invariant_study(integrate, quantity, y0_free, t_end, ns, order, floor=floor))
+        )
+    if patch is not None:
+        p_y0, p_slope = patch
+        checks.append(Check("patch", label, lambda: patch_study(integrate, rhs_ref, p_y0, p_slope, t_end, ns)))
+    return checks

physverify/symbolic.py

@@ -0,0 +1,89 @@
+"""Manufactured solutions with symbolic derivatives (optional; needs SymPy).
+
+    pip install physverify[symbolic]
+
+Hand-derived source terms are a common place for the verification itself to
+go wrong. Here you write the manufactured solution and the PDE operator once,
+symbolically, and the source term is derived and turned into NumPy functions.
+
+Example, the 1D heat equation u_t = alpha u_xx + s:
+
+    import sympy as sp
+    x, t = sp.symbols("x t")
+    u = sp.exp(-t) * sp.sin(sp.pi * x)
+    ms = manufactured_pde(u, lambda u: sp.diff(u, t) - 0.7 * sp.diff(u, x, 2), (x, t))
+    ms.source(xs, 0.3)   # NumPy array of s at the points xs, time 0.3
+
+The operator must be written independently of the code under test, for the same
+reason as the ODE reference operator (see physverify.mms).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Callable
+
+import numpy as np
+
+
+def _sympy():
+    try:
+        import sympy
+    except ImportError as exc:  # pragma: no cover - exercised only without sympy
+        raise ImportError("physverify.symbolic needs SymPy: pip install physverify[symbolic]") from exc
+    return sympy
+
+
+@dataclass
+class ManufacturedPDE:
+    solution_expr: object
+    source_expr: object
+    solution: Callable
+    source: Callable
+
+
+def _vectorise(f, n_args):
+    """lambdify returns a scalar for a constant expression; broadcast it to the inputs' shape."""
+
+    def g(*args):
+        value = f(*args)
+        shape = np.broadcast(*[np.asarray(a) for a in args[:n_args]]).shape
+        return np.broadcast_to(np.asarray(value, dtype=float), shape).copy() if shape else float(value)
+
+    return g
+
+
+def manufactured_pde(u_expr, operator: Callable, variables) -> ManufacturedPDE:
+    """Source s = operator(u) for a manufactured solution u.
+
+    `operator(u)` returns the PDE residual for u, written with sympy.diff, so that
+    u solves  operator(u) = s  exactly. `variables` is the tuple of SymPy symbols
+    the NumPy functions take, in order (for example (x, t) or (x, y, t)).
+    """
+    sp = _sympy()
+    variables = tuple(variables)
+    source_expr = sp.simplify(operator(u_expr))
+    n = len(variables)
+    return ManufacturedPDE(
+        u_expr,
+        source_expr,
+        _vectorise(sp.lambdify(variables, u_expr, "numpy"), n),
+        _vectorise(sp.lambdify(variables, source_expr, "numpy"), n),
+    )
+
+
+def manufactured_ode(u_exprs, rhs_ref: Callable, t_symbol):
+    """A physverify.ManufacturedODE whose derivative is taken symbolically.
+
+    `u_exprs` is a list of SymPy expressions in `t_symbol`, one per state component.
+    """
+    from .mms import ManufacturedODE
+
+    sp = _sympy()
+    u_f = sp.lambdify(t_symbol, list(u_exprs), "numpy")
+    du_f = sp.lambdify(t_symbol, [sp.diff(e, t_symbol) for e in u_exprs], "numpy")
+    return ManufacturedODE(
+        lambda t: np.array(u_f(t), dtype=float),
+        rhs_ref,
+        du=lambda t: np.array(du_f(t), dtype=float),
+    )

physverify-0.1.0.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,43 @@
+physverify/__init__.py,sha256=viD63SRjqeOtmvyYstDQD-0Ybiq_V6vqAdehw1znImA,657
+physverify/__main__.py,sha256=k1ocEWawweo1qCJWNFAAvyxz3tcY13dzvCenHszij30,48
+physverify/agent.py,sha256=lZKvUYykji8VkFU38mtwsE9XSCKXbPwMnJDnGz4h1qk,11398
+physverify/checks.py,sha256=0BmPL4WRXvcFXGIAhnrWxU284aUjsKGf3WZyb95s3Lo,1699
+physverify/cli.py,sha256=-phU4181-O6lFhIOMEOP2TA7Y0wLO3oQVG-0qWmcjks,3580
+physverify/compare.py,sha256=9dAfKsl5n63VvJPDJ1d9PGqRLumuwMr_Gtg-23kjZN0,3809
+physverify/loaders.py,sha256=pO9p3yzPxZWgVaJr8fw46DQxAtksXl-Ta-cvqlZVzvE,1420
+physverify/matrix.py,sha256=48Eappft-KuHy0DJtJyCbfQPQkLtVQx9f3dyIe-bxAo,6321
+physverify/mms.py,sha256=x7US9wUXCOEPSxja1t1F37crds3b7yFV-kzMV-TGEQY,4145
+physverify/order.py,sha256=x1QKA8rfmbYpCidcQXZvvJ75oYXhMXdJY_XPNPVtPuo,5310
+physverify/pytest_plugin.py,sha256=_cL4iQFIawXPu4WY8n4JtdQ443aa_fntjJ7rxuMLU7c,2539
+physverify/report.py,sha256=uopkT1qP4OVmGp6yDeRcNZe8jc-gXR7SnY3uYbUb_Cs,7672
+physverify/steppers.py,sha256=A2BMgca3_Oq_3kEicblZCGSIaPeq1Da472wrPVcA35c,975
+physverify/studies.py,sha256=bzjmp7zdNBlkWCDqF8V2V4K0cqJ-EfCoYxDWTIJMONw,6105
+physverify/symbolic.py,sha256=8oAuSYzToGKOSseKvjYItQcZKqDSE-J9BWMgJXiOJAo,2955
+physverify/adapters/__init__.py,sha256=jFByVfj91ENm_S6L2BSFd0vpJJQUZi5skCYpPAUJAW0,461
+physverify/adapters/double_pendulum.py,sha256=EUIaimQ4hDcEwi3h3pMKZlBofjinofsjZGjdm8SLAec,1629
+physverify/adapters/lorenz.py,sha256=h5aQLkeS93oUyEJPUa1NduaL74zAxhH6GPOqZqKTZgc,5410
+physverify/adapters/projectile_v1.py,sha256=XSbS6B-gkX0ziEmDEazXILKmR4FUzvyD14_XWfFFg3U,3366
+physverify/adapters/projectile_v2.py,sha256=IJnTfhd9-zdzsD93c0IYekqq0br7KqDs7awZGE95WIg,3579
+physverify/adapters/three_body.py,sha256=Vv7m7uagZtIxGPiQ6ufeZPejcyNPFVFzuhYNbVjTPq0,11028
+physverify/problems/__init__.py,sha256=b0GJzVq3c38csBkDIatyj2Koc3j10Px26uyTXd7cTi8,218
+physverify/problems/_common.py,sha256=3aTKpLUdKKvN5fAJUjNTO-f1DGEFJ57Xu74DftAesP0,2911
+physverify/problems/heat1d.py,sha256=KiZUqJ7FFfiKQK_tGj8PRyytHlLNvh7h7XCq2LQ6k8M,7936
+physverify/problems/kepler.py,sha256=saLS4J9L_0wFPhIc3YYftQjeSGR19BTY67A1P5P2vpI,5626
+physverify/problems/pendulum.py,sha256=s_PCWCBtugBkchmxjHMiR5Sr-t4Uq1314fmBfYaqQkI,7357
+physverify/problems/projectile.py,sha256=3FMjeXYLc36mvApQZC5dviMdbSiT3K3UhBovdoII7yE,9390
+physverify/problems/sod.py,sha256=KyXLbjuHy3d3OFOOYnXSaiNGhepHuNLZpcQDlDHcVo0,11934
+physverify/stochastic/__init__.py,sha256=RrooJVboF5LPwhLTKnf4dezmnNhwaT0wV7ehGV8vkYw,101
+physverify/stochastic/calibrate.py,sha256=1eprgcx0UwoqYoI3fibisUxQF61QJOa07eu_E5FFNMA,8633
+physverify/stochastic/checks.py,sha256=8JS_bvK-MG-zZdJ8uspATPafv4WsvVSLkBCA5yXxSOs,18086
+physverify/stochastic/exact.py,sha256=U7Mg4LmfT__eRLUyTsKHAhPrYKAVU6bQBJK21Y_pEN0,7484
+physverify/stochastic/ising.py,sha256=4LAJ3kKLGzBd_XtjPtb980VU5gsP1YtlYze5CbP-l0U,7936
+physverify/stochastic/matrix.py,sha256=RHHHmWvY5leesSELTLXQ69Sy397blXxsu6VTA-rQKMk,6235
+physverify/stochastic/reference.py,sha256=s3G83INawcnNbv2k1ScHQI3b3-7m2EDxEozegXdqAU4,2264
+physverify/stochastic/sampler.py,sha256=m0jV_qd3G-V2Q4NM653TTbA8QTgz7vj6zKfMX8FSp9c,10548
+physverify/stochastic/stats.py,sha256=G5SEj6iu3BUKQ5hKU89Cj2h201KfGQBexDeGhJUGZ8U,5244
+physverify-0.1.0.dist-info/licenses/LICENSE,sha256=A7qXUpTre2zp1GZSa1XwjM14YGyHnvA2Zh0frie2RKg,1073
+physverify-0.1.0.dist-info/METADATA,sha256=R7V58ro1qXmIcs2pjyblcfYTYtuLJMZK8Fs9rLUBG2U,6664
+physverify-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+physverify-0.1.0.dist-info/entry_points.txt,sha256=PAskhOwukCAo7xzNdJzVBYCwH0j_qck2_LFoCLkzM7k,101
+physverify-0.1.0.dist-info/top_level.txt,sha256=NbSy2myuT-0wT98BIYVvvAWB7Bb6RG9mgo2Y2qGouJw,11
+physverify-0.1.0.dist-info/RECORD,,

physverify-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

physverify-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,5 @@
+[console_scripts]
+physverify = physverify.cli:main
+
+[pytest11]
+physverify = physverify.pytest_plugin

physverify-0.1.0.dist-info/licenses/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.dist-info/top_level.txt

@@ -0,0 +1 @@
+physverify