scikit-verify 0.1.0__tar.gz

scikit_verify-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,24 @@
+name: CI
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.11", "3.14"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install
+        run: pip install -e .[dev]
+      - name: Test
+        run: pytest -q
+        

scikit_verify-0.1.0/.gitignore

@@ -0,0 +1,10 @@
+__pycache__/
+*.pyc
+*.egg-info/
+dist/
+build/
+.pytest_cache/
+.venv/
+__pycache__/
+*.pyc
+*/__pycache__/*

scikit_verify-0.1.0/FAILURES.md

@@ -0,0 +1,44 @@
+# Coercion break-pass — failure list (lifting only, no fixes)
+~200 adversarial cases, 6 rounds. Verified formulas track perturbed inputs in 24/25 spot checks.
+Scripts: /tmp/break/round{1..6}.py (repro: run any with the scipy-dev python)
+
+## A. SILENT-WRONG (value or formula lies — worst class)
+1. np.add.at(y, [0,0], 1.0)   -> silently NO-OPS on a traced array (got 1.5, expect 3.5)
+2. np.place(y, y<0, [0.0])    -> silently NO-OPS (got 3.25, expect 5.25)
+3. np.nan_to_num(x/0.0)       -> inf NOT clamped: value lane -inf vs numpy's ±1.798e308
+4. pandas Series(x).sum()     -> returns the full array instead of the scalar sum
+5. int scalar input: to_sympy(lambda a: a+1, 3) -> formula "4", input symbol dropped
+   (float scalar input correctly gives a+1; only python ints collapse)
+6. nditer over object array   -> runs but formula constant
+
+## B. DIED (should refuse loudly or work)
+7.  round(pair, n) / round(pair)      TypeError: no __round__
+8.  divmod(pair, 2.0)                 TypeError
+9.  f"{pair:.2f}" / format(pair)      TypeError: unsupported format string
+10. float(str(pair))                  ValueError (repr leaks "Pair(x[0])")
+11. np.interp(t, xs, ys) traced xs    TypeError: cannot cast dtype('O')
+12. np.corrcoef(x, x[::-1])           TypeError: scalar Pair not subscriptable
+13. np.cov(x)                         ValueError: unpack
+14. pair // 2.0 (floor div)           TypeError: no __floordiv__
+15. np.select([conds],[choices])      TypeError: condlist must be bool ndarray
+16. np.linalg.inv / eigvals on Pair   AttributeError: no __array_wrap__
+17. np.putmask(pair, ...)             TypeError: first arg must be array
+18. np.copyto(y, pair)                TypeError
+19. pair.fill(2.0)                    AttributeError: no fill
+20. pair.tolist()                     AttributeError: no tolist
+21. scipy.stats.iqr(x)                ValueError: broadcast remap
+22. varargs signature def f(*arrs)    TypeError: takes 1 arguments, got 2 (api wrapper)
+
+## C. Loud refusals — correct behavior, listed for coverage review
+- np.round (math-changing: right), np.piecewise (bool coercion), np.histogram(raw operand msg misleads: input WAS wrapped)
+- ufunc.accumulate / .outer / .reduceat / out= / frexp / modf (2-output)
+- astype(str), structured arrays (fancy indexing msg misleading)
+- pandas DataFrame ops (data-dependent branch)
+- chained float() in user code (right; message good)
+
+## D. Notes / oddities (not failures, worth eyes)
+- weighted_mean formula contains disclosed const_0 table -> substitution needs table values (by design)
+- np.sort(x)[1] etc: all ordering-guard paths verified correct incl. preconditions gating
+- empty array: Sum(a[j], (j,0,-1)) — correct empty-sum convention, prints oddly
+- f(x, x) same array twice -> named a and b independently (defensible; loses aliasing info)
+- kwarg scalars become symbols (scale*a[i]) — nice, but means kwargs are never constant-folded

scikit_verify-0.1.0/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/LOOP_DOMAINS.md

@@ -0,0 +1,103 @@
+# Loops as domains
+
+A loop is an axis in time. Array axes are already domains: `x[i]` with
+bounds, bound by `Sum(..., (i, 0, n-1))`. An iteration index `k` is the
+same object, bound by a recurrence instead of a reduction. Today the
+tracer unrolls loops into the live formula, so iterative solvers
+(BayesianRidge: 300 iterations, each formula containing the last)
+snowball and never finish. Folding exists (`_fold_runs`,
+`derivation()`) but runs post-hoc on `.steps` -- downstream of the
+blowup. This note moves the fold into the formula lane itself.
+
+Everything below is explicitly sympy: `subs`, `doit`, `lambdify`,
+`free_symbols` work on the certificate with no side-channel records.
+All claims execution-verified on sympy 1.14.
+
+## The three tiers
+
+| loop shape | sympy object | verified behavior |
+|---|---|---|
+| accumulator `t += x[k]` | `Sum` / `Product` | already emitted for np.sum; hand loops should reach it |
+| linear scalar recurrence | `rsolve` -> closed expression | `rsolve(C(k+1)-2C(k)-1, C(k), {C(0):1})` -> `2**(k+1)-1` |
+| linear VECTOR recurrence | `MatPow`: `C[k] = A**k * C[0]` | `(A**k).doit()` diagonalizes symbolically; `subs(k,3)` exact |
+| general scalar recurrence | `RecursiveSeq` | Basic; `subs` traverses; `.coeff(k)` unrolls lazily |
+| general vector / coupled | custom `Iterate` Function (below) | held form, lazy unroll, Tuple state |
+
+## Verified capabilities and limits
+
+RecursiveSeq (sympy.series.sequences):
+- IS `Basic`; `free_symbols` correct; symbolic parameters in the body
+  survive (`coeff(3)` of `y=2y+a` -> `7*a + 8`); `subs` composes.
+- Scalar ONLY: Matrix and MatrixSymbol terms fail (AttributeError /
+  ShapeError). Tuple packing fails. A second Function in the body
+  stays unresolved (`z(0), z(1)` free) -- no coupled systems.
+
+MatPow:
+- `A**k` with symbolic integer `k` is native, `.doit()` produces the
+  closed form via diagonalization, exact under `subs(k, n)`.
+- Covers every CONSTANT-coefficient linear vector recurrence.
+
+Iterate (ours, ~10 lines):
+```python
+class Iterate(sympy.Function):
+    """Iterate(step, init, k): k-fold application of step to init."""
+    @classmethod
+    def eval(cls, step, init, k):
+        if k.is_Integer and k >= 0:
+            out = init
+            for _ in range(int(k)):
+                out = step(*out) if isinstance(out, sympy.Tuple) else step(out)
+            return out
+```
+- Held while `k` is symbolic: `Iterate(Lambda(c, 2c+a), 1, K)`,
+  free symbols `{a, K}`. `subs(K, 3)` unrolls on demand -> `7*a + 8`;
+  after full substitution it is a number (lambdify-able).
+- Vector and COUPLED state as one `Tuple`:
+  `Iterate(Lambda((c1,c2), Tuple(c1+c2, c1*a)), Tuple(1,2), K)`
+  -> `subs(K,2)` -> `(a+3, 3*a)`. This is the BayesianRidge shape
+  (coef and alpha updating each other).
+- A subclass of `sympy.Function` IS sympy: printing, traversal,
+  substitution all come from Basic. No metadata channel.
+
+## Trace-time mechanics
+
+The hooks exist. The rewriter already tags every loop
+(`__skv_loop_iter__` / `__skv_loop_end__`, `session.loop_events`), so
+Pairs are attributable to (loop, iteration) DURING the trace.
+
+1. Run iteration 0 and 1 concretely, formulas eager (today's path).
+2. At iteration 1's end, attempt the fold: do iteration 1's formulas
+   equal iteration 0's under a template with the loop-carried state
+   replaced by a state symbol? This is `_generalize`'s check, applied
+   live. Multiple carried variables pack into one Tuple state.
+3. Fold succeeds: replace the carried Pairs' formulas with the tier
+   object (Sum/rsolve/MatPow/RecursiveSeq/Iterate) and run remaining
+   iterations on the VALUE LANE ONLY, verifying each iteration's
+   concrete values against the template (the per-iteration residual --
+   same role contracts play for atoms). Formula size is now
+   O(template), independent of iteration count.
+4. Fold fails (body not one template -- data-dependent branch inside):
+   keep today's unrolling, with a formula-size budget that refuses
+   loudly instead of hanging.
+
+Data-dependent exits (`while not converged`) are already guards: the
+stopping condition's `__bool__` records the path. `K = 17` enters the
+formula as a concrete bound with the convergence guard in
+preconditions, exactly like searchsorted's counting bound.
+
+## Verification story
+
+- Tier objects evaluate: `.coeff(k)` / `subs(K, k)` reproduce the
+  unrolled formula for any k, so the two-lane fuzzer applies directly.
+- Per-iteration residual at trace time: template instantiated with
+  iteration k's concrete state must equal iteration k+1's concrete
+  state. 300 cheap numeric checks replace one 300-deep expression.
+
+## Refusals (loud, by construction)
+
+- Loop body changes shape between iterations (branch taken differently)
+  and sizes exceed the budget -> "iterative body is not one template".
+- `rsolve` fails and the recurrence is nonlinear scalar -> RecursiveSeq
+  (still exact); vector -> Iterate (still exact). Refusal is only for
+  non-foldable bodies, never for "no closed form" -- a held recurrence
+  IS an exact formula.

scikit_verify-0.1.0/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,108 @@
+<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/coverage/cvxpy_full.out

@@ -0,0 +1,16 @@
+TOTAL 38 | LIFT+match 29 | lift-unverified 0 | refused 9 | died 0
+
+LIFT+match: sum_squares, norm1, norm2, norm_inf, pnorm_3, abs_sum, square_sum, sqrt_sum, power_sum, pos_sum, neg_sum, maximum_elem, max, min, logistic_sum, entr_sum, kl_div_sum, rel_entr_sum, log_sum_exp, geo_mean, harmonic_mean, huber_sum, trace, lambda_max, lambda_min, sigma_max, log_det, tv_1d, residual_norm
+
+REFUSED:
+  quad_form                    [skverify] could not lift this call (ValueEr
+  quad_over_lin                [skverify] could not lift this call (Attribu
+  matrix_frac                  [skverify] could not lift this call (ValueEr
+  normNuc                      np.sum kwargs ['initial'] not supported
+  solve_lstsq                  [skverify] could not lift this call (ValueEr
+  solve_ridge                  [skverify] could not lift this call (ValueEr
+  solve_lasso                  [skverify] could not lift this call (ValueEr
+  solve_nonneg_ls              [skverify] could not lift this call (ValueEr
+  solve_chebyshev              [skverify] could not lift this call (ValueEr
+
+DIED:

scikit_verify-0.1.0/coverage/cvxpy_full.py

@@ -0,0 +1,138 @@
+"""The cvxpy sweep: expression evaluation and small solved problems."""
+import signal
+import warnings
+
+warnings.filterwarnings("ignore")
+import numpy as np
+
+import cvxpy as cp
+from skverify import to_sympy, Pair
+
+rng = np.random.default_rng(7)
+A = rng.standard_normal((6, 3))
+b = rng.standard_normal(6)
+v = rng.standard_normal(5)
+vpos = np.abs(v) + 0.5
+p = vpos / vpos.sum()
+q = np.abs(rng.standard_normal(5)) + 0.5
+q = q / q.sum()
+S = A.T @ A + 0.5 * np.eye(3)
+w = rng.standard_normal(3)
+
+MENU = []
+
+def add(name, fn, *args):
+    MENU.append((name, fn, args))
+
+def val(expr):
+    return expr.value
+
+# ---- atom evaluation: cvxpy expression on data, read the value
+add("sum_squares", lambda a: val(cp.sum_squares(a)), v)
+add("norm1", lambda a: val(cp.norm1(a)), v)
+add("norm2", lambda a: val(cp.norm2(a)), v)
+add("norm_inf", lambda a: val(cp.norm_inf(a)), v)
+add("pnorm_3", lambda a: val(cp.pnorm(a, 3)), vpos)
+add("abs_sum", lambda a: val(cp.sum(cp.abs(a))), v)
+add("square_sum", lambda a: val(cp.sum(cp.square(a))), v)
+add("sqrt_sum", lambda a: val(cp.sum(cp.sqrt(a))), vpos)
+add("power_sum", lambda a: val(cp.sum(cp.power(a, 2))), v)
+add("pos_sum", lambda a: val(cp.sum(cp.pos(a))), v)
+add("neg_sum", lambda a: val(cp.sum(cp.neg(a))), v)
+add("maximum_elem", lambda a, c: val(cp.sum(cp.maximum(a, c))), v, w[0])
+add("max", lambda a: val(cp.max(a)), v)
+add("min", lambda a: val(cp.min(a)), v)
+add("logistic_sum", lambda a: val(cp.sum(cp.logistic(a))), v)
+add("entr_sum", lambda a: val(cp.sum(cp.entr(a))), p)
+add("kl_div_sum", lambda a, c: val(cp.sum(cp.kl_div(a, c))), p, q)
+add("rel_entr_sum", lambda a, c: val(cp.sum(cp.rel_entr(a, c))), p, q)
+add("log_sum_exp", lambda a: val(cp.log_sum_exp(a)), v)
+add("geo_mean", lambda a: val(cp.geo_mean(a)), vpos)
+add("harmonic_mean", lambda a: val(cp.harmonic_mean(a)), vpos)
+add("huber_sum", lambda a: val(cp.sum(cp.huber(a, 1.0))), v)
+add("quad_form", lambda a, s: val(cp.quad_form(a, s)), w, S)
+add("quad_over_lin", lambda a, c: val(cp.quad_over_lin(a, c)), v, vpos[0])
+add("matrix_frac", lambda a, s: val(cp.matrix_frac(a, s)), w, S)
+add("trace", lambda s: val(cp.trace(s)), S)
+add("lambda_max", lambda s: val(cp.lambda_max(s)), S)
+add("lambda_min", lambda s: val(cp.lambda_min(s)), S)
+add("sigma_max", lambda a: val(cp.sigma_max(a)), A)
+add("normNuc", lambda a: val(cp.normNuc(a)), A)
+add("log_det", lambda s: val(cp.log_det(s)), S)
+add("tv_1d", lambda a: val(cp.tv(a)), v)
+add("residual_norm", lambda a, c: val(cp.norm2(a @ np.ones(3) - c)), A, b)
+
+# ---- solved problems: data -> optimizer
+def lstsq(a, c):
+    x = cp.Variable(3)
+    cp.Problem(cp.Minimize(cp.sum_squares(a @ x - c))).solve()
+    return x.value
+
+def ridge(a, c):
+    x = cp.Variable(3)
+    cp.Problem(cp.Minimize(cp.sum_squares(a @ x - c) + cp.sum_squares(x))).solve()
+    return x.value
+
+def lasso(a, c):
+    x = cp.Variable(3)
+    cp.Problem(cp.Minimize(cp.sum_squares(a @ x - c) + 0.1 * cp.norm1(x))).solve()
+    return x.value
+
+def nonneg_ls(a, c):
+    x = cp.Variable(3)
+    cp.Problem(cp.Minimize(cp.sum_squares(a @ x - c)), [x >= 0]).solve()
+    return x.value
+
+def chebyshev(a, c):
+    x = cp.Variable(3)
+    cp.Problem(cp.Minimize(cp.norm_inf(a @ x - c))).solve()
+    return x.value
+
+add("solve_lstsq", lstsq, A, b)
+add("solve_ridge", ridge, A, b)
+add("solve_lasso", lasso, A, b)
+add("solve_nonneg_ls", nonneg_ls, A, b)
+add("solve_chebyshev", chebyshev, A, b)
+
+class TO(Exception):
+    pass
+
+signal.signal(signal.SIGALRM, lambda s, f: (_ for _ in ()).throw(TO()))
+
+lift_ok, lift_unverified, refused, died = [], [], [], []
+for name, fn, args in MENU:
+    signal.alarm(120)
+    try:
+        ref = fn(*args)
+        r = to_sympy(fn, *args)
+        got = r.value if isinstance(r, Pair) else r
+        if isinstance(got, np.ndarray) and got.dtype == object:
+            got = np.asarray(Pair._value_of(got), dtype=float)
+        try:
+            match = np.allclose(
+                np.asarray(got, dtype=float), np.asarray(ref, dtype=float),
+                rtol=1e-7, atol=1e-9, equal_nan=True,
+            )
+        except Exception:
+            match = None
+        (lift_ok if match else lift_unverified).append(name)
+    except TO:
+        died.append((name, "TIMEOUT"))
+    except NotImplementedError as e:
+        refused.append((name, str(e)[:44]))
+    except Exception as e:
+        died.append((name, f"{type(e).__name__} {str(e)[:44]}"))
+    finally:
+        signal.alarm(0)
+
+total = len(MENU)
+print(f"TOTAL {total} | LIFT+match {len(lift_ok)} | lift-unverified {len(lift_unverified)} | refused {len(refused)} | died {len(died)}")
+print("\nLIFT+match:", ", ".join(lift_ok))
+if lift_unverified:
+    print("\nlift-unverified:", ", ".join(lift_unverified))
+print("\nREFUSED:")
+for n_, m in refused:
+    print(f"  {n_:28s} {m}")
+print("\nDIED:")
+for n_, m in died:
+    print(f"  {n_:28s} {m}")