scikit-verify 0.1.0__py3-none-any.whl

scikit_verify-0.1.0.dist-info/METADATA

@@ -0,0 +1,145 @@
+Metadata-Version: 2.4
+Name: scikit-verify
+Version: 0.1.0
+Summary: Lift NumPy/SciPy code to the mathematics it implements, and verify it.
+Author: Aadya Chinubhai
+License: BSD-3-Clause
+Project-URL: Homepage, https://github.com/aadya940/scikit-verify
+Project-URL: Issues, https://github.com/aadya940/scikit-verify/issues
+Keywords: verification,symbolic,sympy,numpy,scipy,numerical-analysis,scientific-computing
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python :: 3
+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: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.26
+Requires-Dist: sympy>=1.12
+Provides-Extra: mcp
+Requires-Dist: mcp<2,>=1.2; extra == "mcp"
+Provides-Extra: hypothesis
+Requires-Dist: hypothesis>=6; extra == "hypothesis"
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: hypothesis>=6; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: scipy>=1.12; extra == "dev"
+Dynamic: license-file
+
+<p align="center">
+  <img src="doc/logos/scikit-verify-lockup.svg" alt="scikit-verify" width="380">
+</p>
+
+<p align="center">Translate Python and NumPy programs to symbolic mathematics</p>
+
+![CI](https://github.com/aadya940/scikit-verify/actions/workflows/ci.yml/badge.svg)
+
+* [Source code](https://github.com/aadya940/scikit-verify)
+* [Coverage](doc/coverage.md)
+* [License](https://github.com/aadya940/scikit-verify/blob/master/LICENSE)
+* [skverify-mcp](skverify-mcp/) - MCP for mathematical feedback for coding agents
+* [skverify-hypothesis](skverify-hypothesis/) - find every branch, boundary and edge case of your function with Hypothesis
+
+scikit-verify is a tracer for numerical Python. It runs your NumPy
+function once and returns the formula it computed, as an ordinary SymPy
+expression you can read, simplify, compare against a paper, or evaluate
+at any other input. Your code is not modified or annotated. For example:
+
+```python
+import numpy as np
+from skverify import to_sympy
+
+def weighted_rms(x, w):
+    return np.sqrt(np.sum(w * x**2) / np.sum(w))
+
+out = to_sympy(weighted_rms, np.array([1.0, 2.0, 3.0]), np.array([0.5, 0.3, 0.2]))
+
+out.formula
+# sqrt(Sum(w[j]*x[j]**2, (j, 0, 2))/Sum(w[j], (j, 0, 2)))
+```
+
+Every formula comes as a certificate: the expression, plus the
+assumptions it was derived under. When code branches on your data, the
+branch taken becomes a stated hypothesis instead of a hidden one:
+
+```python
+out = to_sympy(np.median, np.array([3.0, 1.0, 4.0, 1.5]))
+print(out.pretty())
+
+# formula    = a[0]/2 + a[3]/2
+# assumes[0] = a[0] <= a[2]
+# assumes[1] = a[1] <= a[3]
+# assumes[2] = a[3] <= a[0]
+```
+
+The contract is exact-or-refuse. If an operation has no faithful
+symbolic form, scikit-verify raises instead of guessing:
+
+```python
+to_sympy(lambda a: a.astype(int).mean(), np.array([1.4, 2.6]))
+# NotImplementedError: astype to non-float would change the math
+```
+
+This works on real library code, not just kernels: scikit-learn metrics
+come back as their defining formulas (precision as its ratio of counting
+sums), fitted estimators as their closed forms, iterative solvers as
+held recurrences, and compiled routines (LAPACK, FFT, Cython) as named
+terms that are checked against their defining equations on every call:
+svd against U diag(S) Vh = A, fft against the DFT sum itself.
+
+Randomness stays honest too. A draw like ``rng.normal(0, s)`` enters
+the formula as a random variable with that distribution, so
+``sympy.stats.E`` and ``variance`` of the result compute in closed
+form, while the concrete run keeps the exact numbers drawn.
+
+Tested against numpy, scipy, scikit-learn, statsmodels, cvxpy and
+random research code from GitHub; the boards in [coverage](coverage/)
+regenerate every number.
+
+## Installation
+
+```bash
+pip install scikit-verify
+```
+
+Requires Python >= 3.11, `numpy`, and `sympy`. The import name is
+`skverify`. The companion layers install as extras:
+
+```bash
+pip install "scikit-verify[mcp]"          # MCP server for coding agents
+pip install "scikit-verify[hypothesis]"   # testing helpers
+```
+
+Pre-alpha; the API may change. Iterative solvers at real sizes can be
+slow to trace (minutes, not wrong); the boards in coverage/ carry
+timings.
+
+## Lineage
+
+The ideas here are old and good. Pairing a concrete execution with a
+symbolic one is King's symbolic execution (CACM 1976), run in the
+concolic style of Cadar and Sen. Checking a compiled routine's answer
+against its defining equation, instead of trusting its name, is
+Blum and Kannan's result checking (1989). Folding a long trace back
+into its loop structure follows Larus's whole-program paths (PLDI
+1999), with templates recovered by Plotkin's anti-unification (1970).
+The stance that code verification means checking code against the
+mathematics it claims to implement is Oberkampf and Roy's (2010).
+Verified lifting of stencils to summaries was developed by Kamil et
+al. (PLDI 2016) for performance; scikit-verify lifts for correctness.
+Converting NumPy to SymPy was wished for in
+[sympy#2810](https://github.com/sympy/sympy/issues/2810) (2014).
+
+## License
+
+BSD-3-Clause. scikit-verify is an independent project and is not affiliated
+with the SciPy developers.

scikit_verify-0.1.0.dist-info/RECORD

@@ -0,0 +1,35 @@
+scikit_verify-0.1.0.dist-info/licenses/LICENSE,sha256=PuQljKseyk67tsP3H2NWZde8x0cqWpDFbqR9A2u1LmE,1502
+skverify/__init__.py,sha256=3KIYG8yyWOGZSr4m0M0cFCl97wMT2KEYYlQ8Yp3_Xhk,2773
+skverify/api.py,sha256=wVxXr4ZdV6d5NxMvLL2qBYoXegKVxXmvShq8ZYHwOVk,19920
+skverify/atoms.py,sha256=SbWrvuQ_96pQvsoB2OeSltF9IZoOmYQHUXxg5z0zPc8,16146
+skverify/checks.py,sha256=PI1MaDcq9N-m8jGypYuHGc-baHn6vpZ7eRBF6p-PLsM,6640
+skverify/coercion.py,sha256=7QNQh5FP2A90hpuezNsQksyWkvyO8cxRgB7yH2LOBKI,7736
+skverify/contracts.py,sha256=9xZ5KdeWis67RxWpqITeCNMYorpYjOVWcPTsBLMEJPY,11330
+skverify/derivation.py,sha256=9TjsziXvLTtNYaKcBWbzHeChctsTzyK7j8l-0D1sS2Y,14538
+skverify/dialect.py,sha256=jXCGqwCsNGp4wnYYvA-Zg9igVr0GHmxBwUYJ2DAq0H4,3882
+skverify/helpers.py,sha256=1WGhIf1aArFBf7oofkgjMVNGJUwHZgWaVs9OxlpfeLw,2592
+skverify/pair.py,sha256=n8fp0LSyQQUTWNv62jZ5ZLPzFPrAeWa9oETWsbITw3U,88023
+skverify/recurrence.py,sha256=L2E6vOg5TG74FhqtCDNMDxB-AB2cs3uBL2b3GeS2Lp8,26044
+skverify/registry.py,sha256=TK5dhpO_SZsjONTeTys_qX1qHeLhuM752y-zEH5D6P0,37
+skverify/session.py,sha256=UO3qKWdQe2mc3Xq7HPFS90nBlQ0R2qfZEi9_ebp-F1Q,3339
+skverify/sets.py,sha256=7a_TqBfdEOKSXAH_87QDrrQn9ykzcYwA9xCPxv28RLE,4827
+skverify/instrument/__init__.py,sha256=W9_L_p2MlI1f5MSxNU12rDv60lavUzKTrZWhvKdJV3g,1445
+skverify/instrument/registries.py,sha256=RJdGO9iVUaWP7bM94BuKbu61lij-7i2BdlK3zS_VMcc,3094
+skverify/instrument/rewriter.py,sha256=tZN3VbvUaThMfqRd2rM73JZdRdNiurF0G3x_XlrO5QQ,13342
+skverify/instrument/runtime.py,sha256=6swR4saMzIZ6tO3-9rT8W7nScp1RnhTFWFZyl1Xr8-s,19948
+skverify/instrument/triage.py,sha256=WEYCv4zjpeFgLvk-cgOeAf4ZMTlghcZOSDEBExoambE,17916
+skverify/instrument/twins.py,sha256=H_T5AbRMgnN8c8A_6lSiHnsfhm8lgM5STuBfq1RipJY,18938
+skverify/maps/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+skverify/maps/numpy.py,sha256=0EftOMKwSEq-3Du7vkVbs-BVeVwG3Fqxm_ujD0M9FrY,59858
+skverify/maps/special.py,sha256=UZjlSbgBa6rq_ZtxcmpD2hmQ39901poaTOI0C6aqwCo,2972
+skverify_hypothesis/README.md,sha256=KJccL1DsAO4Yl5IsKTBndwHjbMqN0mHyMAuVLPI9Xqs,1443
+skverify_hypothesis/__init__.py,sha256=sKp8v3Ib7tdrY2UCVWfI7NvWT5C-gm3w48a_PVQMZvw,108
+skverify_hypothesis/skverify_hypothesis.py,sha256=aj0L60OX7LDW6CgXG6iyj1RA8uFPJMyYAjKao7XlGYc,8550
+skverify_mcp/README.md,sha256=QSy_BhOiFsVw8NDjiWI61IAjEHyjsBEJkGKtkKou3_s,656
+skverify_mcp/__init__.py,sha256=X_DkAxeoLMiV8MCzKuiVNJNm9zHeeoQmyU9_Ncv732U,99
+skverify_mcp/server.py,sha256=bN9931WFrkTQEtJ147aesOpPa7RFK1kZeiHjjZJ9mbY,4394
+scikit_verify-0.1.0.dist-info/METADATA,sha256=lt9u9igkBZLFmBFlgveLVQzmK1duFcP3xsgXlTP4CB8,5692
+scikit_verify-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+scikit_verify-0.1.0.dist-info/entry_points.txt,sha256=OfM7m0AvFJtCPaxs535y3dgI9fzD_zPRMGzywuKp5vA,58
+scikit_verify-0.1.0.dist-info/top_level.txt,sha256=IGlBt1JgJ4ez8taijPuXPWvTVKwituO0-edDGALIqiA,42
+scikit_verify-0.1.0.dist-info/RECORD,,

scikit_verify-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
+

scikit_verify-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+skverify-mcp = skverify_mcp.server:main

scikit_verify-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, Aadya Chinubhai
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

scikit_verify-0.1.0.dist-info/top_level.txt

@@ -0,0 +1,3 @@
+skverify
+skverify_hypothesis
+skverify_mcp

skverify/__init__.py

@@ -0,0 +1,73 @@
+from skverify.pair import Pair, IDX
+from skverify.maps import numpy as _numpy_map
+from skverify.maps import special as _special_map
+from .api import to_sympy
+
+
+def _tidy(expr):
+    """Print-tier cleanups that change nothing mathematically:
+    collapse sum axes of extent one, and state negated comparisons
+    positively (-a/n > -b/n becomes a/n < b/n)."""
+    import sympy as _sym
+
+    def collapse(s):
+        fun, limits = s.function, []
+        for v, lo, hi in s.limits:
+            if lo == hi:
+                # the axis has one slot: drop the dummy from indexed
+                # terms outright (a dead index position), substitute
+                # anywhere it appears in arithmetic
+                fun = fun.replace(
+                    lambda x: isinstance(x, _sym.Indexed) and v in x.indices,
+                    lambda x: x.base[
+                        tuple(i for i in x.indices if i != v)
+                    ] if len(x.indices) > 1 else x.base[lo],
+                )
+                fun = fun.subs(v, lo)
+            else:
+                limits.append((v, lo, hi))
+        if fun.could_extract_minus_sign():
+            # a sum of negated terms IS the negated sum: pull the sign
+            # out so comparisons can read positively
+            inner = _sym.Sum(-fun, *limits) if limits else -fun
+            return -inner
+        return _sym.Sum(fun, *limits) if limits else fun
+
+    expr = expr.replace(lambda x: isinstance(x, _sym.Sum), collapse)
+    rel_flip = {
+        _sym.Lt: _sym.Gt, _sym.Le: _sym.Ge,
+        _sym.Gt: _sym.Lt, _sym.Ge: _sym.Le,
+    }
+    if type(expr) in rel_flip:
+        lhs, rhs = expr.lhs, expr.rhs
+        if lhs.could_extract_minus_sign() and rhs.could_extract_minus_sign():
+            expr = rel_flip[type(expr)](-lhs, -rhs)
+    return expr
+
+
+def latex(expr, aliases=None):
+    """sympy.latex with readable defaults for certificates: code-ish
+    names render upright, sum axes of extent one collapse, negated
+    comparisons read positively. Pass a dict as `aliases` to shorten
+    long names to T1, T2, ...; the dict fills with alias -> full name
+    so you can print a legend."""
+    import sympy as _sym
+
+    if not isinstance(expr, _sym.Basic):
+        return str(expr)
+    expr = _tidy(expr)
+    names = {}
+    for s in sorted(expr.atoms(_sym.Symbol), key=str):
+        n = str(s)
+        if "_" not in n:
+            continue
+        if aliases is not None and len(n) > 14:
+            short = next(
+                (k for k, v in aliases.items() if v == n),
+                f"T{len(aliases) + 1}",
+            )
+            aliases[short] = n
+            names[s] = r"\mathtt{%s}" % short
+        else:
+            names[s] = r"\mathtt{%s}" % n.replace("_", r"\_")
+    return _sym.latex(expr, symbol_names=names)