Skip to content

Roadmap

Planned work, release by release, following docs/spec.md (Section 13). Each release ships only when its gate passes. Finished work moves to CHANGELOG.md; decisions that change the spec are logged at the end of this file.

Status: [x] done · [~] in progress or partly done · [ ] not started

0.1 — core and 1D

Done

  • [x] C API with try/catch boundary, opaque handles, workspaces, fp_options/fp_info
  • [x] Separable convex maps: soft thresholding (weighted), elastic net, Huber, group ℓ2 and ℓ2 norm
  • [x] Projections: box, nonnegative orthant, ℓ2 ball, simplex and weighted ℓ1 ball (Condat), ℓ∞ prox
  • [x] Monotone cone by pool-adjacent-violators, weighted
  • [x] 1D TV: Condat's algorithm, taut string (segment chains in local coordinates), weights with zero-weight splitting, automatic fallback
  • [x] JVP/VJP in x, γ and parameters for all of the above; conjugate prox via Moreau
  • [x] Batching over any axis and stride, an internal thread pool with bit-identical results (OpenMP until 0.1.0rc1), no allocation with a workspace
  • [x] nanobind bindings, abi3 wheel built locally with uv and scikit-build-core
  • [x] C/C++ tests (certificates, finite differences, adjointness, determinism, allocation counter) and Python tests (references, properties)

  • [x] Benchmarks against proxTV and Condat's C code (bench/compare_external.py, fetched and built at run time, fresh input per call); results in docs/benchmarks.md

  • [x] Condat backtracking budget tuned from measured work per sample (now 3n + 1024 rescanned steps; typical signals rescan 0–3n, ramps up to 3000n); ramp regression test
  • [x] Fuzz harness fuzz/fuzz_ops.cpp: libFuzzer target where available plus a standalone driver; 400k inputs clean under ASan/UBSan; nightly workflow .github/workflows/fuzz.yml
  • [x] CVXPY + Clarabel fixtures (180 problems, n ≤ 200) in tests/fixtures/; agreement within 4.2e-10
  • [x] Valgrind job in CI
  • [x] Single source for the version (project() in CMakeLists.txt; header macros checked at configure time)
  • [x] fastprox is free on conda-forge (no package, feedstock or staged-recipes PR, 2026-10-14) and on PyPI
  • [x] API reference: docs/api.md
  • [x] Examples in examples/ (2026-10-15), run by the Python tests

Open

  • [x] Reach the speed gate on 1D TV (docs/benchmarks.md) on Apple M5: fastest or within 2% in all 9 uniform and all 9 weighted float64 settings. Weighted white noise at λ = 10, which trailed by 8%, went to 0.43–0.45 of proxTV's time with the running-sum Condat kernel (2026-10-15), so on Apple M5 every float64 setting is now ahead. Remaining: float32 at λ = 0.1 (1–5% behind Condat's single-precision code, was 6–12%; accepted as a deviation on 2026-10-15, see the decisions table)
  • [~] Simplex and ℓ1 ball: finiteness test folded into the pivot pass (0.81× the previous time), and blocks at or below the running pivot skipped whole (2026-10-15). On Apple M5 now faster than Condat's code on Gaussian input and with one large entry at every size from 10³ to 10⁷ (0.50 against 0.56 and 0.48 against 0.60 ns per sample at 10⁶), tied on uniform input at 10⁶ (7% behind at 10⁵, ahead at 10³ and 10⁷). On the CI runners (n = 10⁵) 0.71–1.01 of Condat's time on Neoverse-N2 and 0.70–0.73 on x86_64
  • [x] Benchmarks on homogeneous cores: a manual bench workflow runs both benchmark scripts on GitHub's x86_64 and arm64 runners (docs/benchmarks.md). Python overhead confirmed (1.6–3.4 µs at n = 100, target 5 µs). Parallel scaling confirmed at 4 physical cores (3.90×, efficiency 0.97 on Neoverse-N2, 2026-10-15, now that the public repository gets 4-vCPU runners); at 16 physical cores on a Google Cloud c4a-standard-16 (Neoverse-V2, 2026-10-16): 15.86× on 64 rows of 10⁴ (efficiency 0.99, target 0.7), 0.97–1.02 on larger batches
  • [~] Tune for Linux arm64 / GCC: on Neoverse-N2 with GCC 13, fastprox trailed at λ = 0.1 (9–17%), weighted at λ = 10 (about 20%) and on the simplex (24–31%). Found (2026-10-15): GCC compiled the short-segment selects of Condat's algorithm as branches, and the range pass as a scalar chain twice as slow as Clang's; with both fixed, the arm64 runner went from 10 to 20 of 30 comparisons won or within 2% (docs/benchmarks.md). Remaining on Neoverse-N2: weighted white noise at λ = 10 (25%), uniform random walk at λ = 10 (20%, where GCC's branches had helped), λ = 0.1 on noise and random walk (6–9%), and the simplex (22–23%; it compiles as well with GCC as with Clang on Apple M5, so this is the core or GCC 13). Per-architecture or per-λ tuning of kBranchFree was set aside (2026-10-15) as not a clean fix; the remaining gaps need a kernel-level change instead. That change (2026-10-15): long segments of Condat's algorithm are tracked by their running sum, with the bounds as a running max/min of candidates; on Apple M5 weighted white noise at λ = 10 went from 1.03–1.09 of proxTV's time to 0.43–0.45 and uniform random walk at λ = 10 from 0.99 to 0.64. On the runners: weighted white noise at λ = 10 now 0.92 on Neoverse-N2, 0.73–0.78 on Intel and 0.55–0.62 on AMD; still behind on Neoverse-N2: uniform random walk at λ = 10 (1.04–1.06, was 1.19; against proxTV's classic taut string, 0.74 against its linearized one) and λ = 0.1 (1.03–1.12). For the random walk (2026-10-16, variants workflow) the kernel alone is at 0.95–0.96; starting the running sum at the first sample of a segment reaches 0.82 but is 13–29% slower at λ = 0.1, and no variant tried kept both (docs/benchmarks.md). λ = 0.1 (1.03–1.13 on Neoverse-N2, 1.01–1.12 on Intel) set aside for now (2026-10-16) after two attempts that did not hold on the runners (docs/benchmarks.md); next time, compare variants side by side in one binary on the runners rather than on Apple M5
  • [~] 1D TV on Intel x86_64: on Xeon runners (GCC 13.3) fastprox trailed proxTV by 7–24% in most settings at λ ≤ 1 while it led on AMD EPYC. The profile workflow showed GCC compiling the branch-free bound updates into compare-and-branch; with SSE2 minsd/maxsd (2026-10-15) it is fastest or within 2% in 12–13 of 18 settings on Intel (was 3–6) and 0.82–1.03 of proxTV's time at λ = 1. With the running-sum Condat kernel (2026-10-15) every λ ≥ 1 setting is ahead on Intel (uniform random walk at λ = 10 0.83–0.84, weighted white noise 0.73–0.78); still behind: λ = 0.1 random walk and white noise, uniform 1.06–1.09 and weighted 1.04–1.12 (docs/benchmarks.md)
  • [x] CI matrix green on GitHub (private repo dvillacis/fastprox, 2026-10-14): Linux GCC/Clang with and without threads, sanitizers (ASan/UBSan and ThreadSanitizer), Valgrind, Windows MSVC, macOS arm64 and x86_64, Python on all three. The first Windows run hung on a "DLL not found" dialog; executables and DLLs now share an output directory there, and ctest has a 300 s timeout.
  • [x] Wheels with cibuildwheel (manual dispatch or tags): abi3 for CPython ≥ 3.12 on manylinux_2_28 x86_64/aarch64, macOS arm64 (11.0) and x86_64 (10.15), Windows amd64; built and tested in CI. Since 0.1.0rc2 no OpenMP runtime is bundled; the repair tools (delocate, auditwheel, delvewheel) still run
  • [x] Published 0.1.0rc1 to PyPI (2026-10-15): https://pypi.org/project/fastprox/0.1.0rc1/, 5 abi3 wheels and the sdist, uploaded by trusted publishing from the v0.1.0rc1 tag after a TestPyPI dry run; the pypi environment accepts only v* tags and needs approval. The repository is public
  • [x] Published 0.1.0rc2 to PyPI (2026-10-15): thread pool instead of OpenMP, which fixes the abort next to PyTorch on macOS; checked by installing from TestPyPI and PyPI next to PyTorch 2.14 and JAX 0.11
  • [x] Document the kink choices per operator in docs/api.md (2026-10-15, "Derivatives at kinks"), with their justification: every choice is an element of the B-subdifferential (Scholtes, Introduction to Piecewise Differentiable Equations, Prop. 2.4.3–2.4.5 and 4.3.1; Clason–Valkonen Ex. 14.10, where soft thresholding at |x| = τ admits both 0 and 1), and x, γ and θ derivatives come from one saved structure, so they form a joint B-element and a VJP composed with a smooth loss is a Clarke subgradient. Note that the ℓ∞ prox treats |xᵢ| = τ as unclipped (the Moreau identity flips the ℓ1-ball rule), unlike soft thresholding
  • [x] Final 0.1.0 once the gate passes (set FASTPROX_VERSION_SUFFIX to empty)
  • [x] Published 0.1.0 to PyPI (2026-10-16): https://pypi.org/project/fastprox/0.1.0/, 5 abi3 wheels and the sdist, uploaded by trusted publishing from the v0.1.0 tag after a TestPyPI dry run; checked by installing from TestPyPI and from PyPI into fresh environments and running the examples

Gate (proposed, from spec Section 10): all accuracy, determinism, special-value and allocation requirements pass on the full CI matrix; 1D TV, simplex and ℓ1 ball no slower than proxTV and Condat's code on one thread; overhead and scaling targets confirmed or revised; wheels install and pass tests on Linux, macOS (arm64, x86_64) and Windows.

0.2 — images

  • [x] Anisotropic TV in 2D and 3D (2026-10-16): fp_op_tv_aniso, TVAniso, tv_aniso. Two active axes: Beck's accelerated dual block method (ADBPG, §12.5.4, Thm 12.19; Chambolle–Pock 2015) with exact 1D TV steps; three: Beck's fast dual proximal gradient for three blocks (Algorithm 9), which beat parallel proximal Dykstra at every accuracy. Certified gap stopping, warm starts through the workspace dual, polish to the exact solution on the identified regions, and O(n) derivatives from those regions. On Apple M5 fastest from 1e-3 relative error on in 2D against proxTV's DR2, Kolmogorov2, Yang2 and parallel Dykstra, 3.0–3.7× faster than the best proxTV solver at 1e-6 (docs/benchmarks.md)
  • [x] Anisotropic TV in 3D at high accuracy (2026-10-17): gradient restarts (O'Donoghue and Candès) in both solvers, and the polish rebuilt to take its regions from the dual (edges whose 1D dual is strictly inside its bound are flat at the solution). It now runs at the gap checks and stops the solve once the polished point certifies, with a gap at most 1/100 of the iterate's. On 64³ the time to 1e-6 relative error fell 4.7–5.6×, and fastprox is now 1.8× (λ = 0.1) and 4.8× (λ = 0.5) faster than Yang's ADMM, fastest at every accuracy. 2D to 1e-6 is 2.3–2.8× faster than before. The nested split (exact 1D on one axis, warm-started 2D ADBPG on the other two, as in Barbero–Sra's proximity stacking) was tried first and lost to the restarted three-block method at every accuracy (docs/benchmarks.md)
  • [x] Feasible warm starts for anisotropic TV (2026-10-17): a starting dual is checked fiber by fiber and rebuilt from its clipped running sums where it is infeasible; before, a seed such as q₀ = x − mean(x) certified the constant image at 0 iterations
  • [x] Anisotropic TV to 1e-2 in 2D at small λ (2026-10-17): the gap is checked on the second block step of an iteration, one sweep instead of a 1D pass, at iterations scheduled from the gap's rate of fall, and 2D polishes are retried early only on a promising ratio. At λ = 0.1, 1e-2 is reached 1.8–2.0× sooner and 1.6–1.7× faster than DR2; fastprox is now fastest at every accuracy on every benchmark image. 1e-3 is up to 22% faster than before; 1e-4 at λ = 0.1 is still 11–12% slower than with z(y) as the iterate (docs/benchmarks.md)
  • [x] Parallel polish for anisotropic TV (2026-10-17): union-find in fixed slabs along axis 0 (at most 64, of at least 4 planes or rows), each joined by its own thread, then the crossing edges serially; labels and region sums per slab, the crossing components serially. The output is bit-identical to the serial polish. The edge pass had not vectorised (its pointers lost restrict through a lambda) and is 5.6× faster. One polish on 64³: 7.1 → 6.5 ms on one thread, 3.9 → 1.8 ms on eight; whole solves to 1e-12 gain 1–6% on one thread and 3–15% on eight (docs/benchmarks.md)
  • [x] Isotropic TV in 2D and 3D (2026-10-16): fp_op_tv_iso, TVIso, tv_iso. Fast gradient projection on the dual (Beck–Teboulle 2009; Beck 2017, §12.4.4) with step 1/L, L = 4 Σ wₐ² (8 in 2D, 12 in 3D), primal from the last dual iterate (12.19), gap stopping certifying ‖z − z*‖² ≤ 2·gap (Lemma 12.7), dual returned and accepted for warm starts. Per-axis weights inside the norm. Derivatives by conjugate gradients on the flat regions, with the residual reported. Against scikit-image's Chambolle projection on Apple M5: 2.6–11× faster from 1e-3 relative error on, and the only one of the two to reach 1e-6; scikit-image is 25–45% faster to 1e-2 at small γ (docs/benchmarks.md)
  • [x] Isotropic TV at high accuracy (2026-10-17): gradient restarts (O'Donoghue and Candès, Found. Comput. Math. 15, 2015), tested every 4th iteration with a non-shrinking interval, take up to 15× fewer iterations to 1e-8 and below; the derivative CG is Jacobi-preconditioned (1.4–3× fewer iterations where it is expensive). The rate does not become linear, because the dual is degenerate. A Newton polish on the flat regions was tried and was worse than z(u) (docs/benchmarks.md)
  • [x] 1D TV with ℓ2 of differences (2026-10-17): fp_op_tv1d_l2, TV1DL2, tv1d_l2. Newton on the secular equation of the dual trust-region problem (Moré–Sorensen; Nocedal–Wright Alg. 4.4) instead of projected Newton, exact to rounding in 2–8 tridiagonal steps, with closed-form derivatives; 1.0–1.3× faster than proxTV's more_TV2, which hits its iteration cap on many large rows (docs/benchmarks.md)
  • [x] Nonconvex pointwise maps (2026-10-16): ℓ0, ℓq (closed forms for q = 1/2 and 2/3, Newton from |x| otherwise, monotone on the nonzero branch), SCAD and MCP for any step (a > 1 + γ, b > γ, else FP_EPARAM), log penalty. Verified against minimisation on a refined grid in tests/python/test_nonconvex.py
  • [x] Tie rule (fp_options.tie, nonzero branch by default) and tie counts in fp_info.ties (2026-10-16): exact at the double-precision threshold, the same for any thread count
  • [x] Derivatives for the nonconvex maps (diagonal, support-restricted, from the scalar equation; the selected branch at ties) (2026-10-16)
  • [x] Cheap exact operators found in the literature review of 2026-10-15, each reusing an existing kernel or closed form with a simple Jacobian (pages are the book's printed pages):
  • [x] prox of max(x) as x − λ P_Δ(x/λ) (Beck Ex. 6.49, p. 162; Parikh and Boyd, Proximal Algorithms, §6.4.1, whose bisection interval is right only for λ = 1), and of the sum of the k largest entries or absolute values through the capped simplex (Beck Ex. 6.50–6.51) (2026-10-16: Max, SumLargest, on the set scaled by γλ)
  • [x] projection onto a hyperplane intersected with a box, P_Box(x − μa) with μ a root of a monotone piecewise-linear function (Beck Thm 6.27, pp. 147–148), which contains the simplex and the capped simplex; Jacobian I_F − a_F a_Fᵀ/‖a_F‖² on the free set (2026-10-16: Hyperplane, HalfSpace; Newton steps in a bracket with a median fallback, 3–9 ns per entry)
  • [x] projection onto a level set {f ≤ α}, e.g. a 1D TV ball, as prox_{γf} with γ the root of f(prox_{γf}(x)) = α (Beck Thm 6.30), using ∂z/∂γ for Newton steps and the implicit derivative (2026-10-16: TV1DBall, 4–15 1D TV solves per row; other level sets when a need appears)
  • [x] group Huber, (1 − λ / max(‖x‖, μ + λ)) x (Beck Ex. 6.66), and radial lifting of any scalar prox to a group one (Beck Thm 6.18), e.g. group SCAD and MCP (2026-10-16: GroupHuber, GroupSCAD, GroupMCP, one kernel around the scalar operator)
  • [x] half-space, hyperplane, second-order cone (Beck Ex. 6.37), −λ Σ log xᵢ as (x + √(x² + 4λ))/2 (Beck Lemma 6.5), ℓ1 over a box (Beck Ex. 6.23) (half-space and hyperplane done 2026-10-16, with an optional box; SOC, LogBarrier, L1Box 2026-10-16)
  • [x] sparse group lasso and tree-structured group norms by composing soft thresholding and group proxes in tree order (Bach, Jenatton, Mairal and Obozinski, Optimization with Sparsity-Inducing Penalties, (3.8)) (2026-10-16: TreeL2 and TreeL2.sparse_group, groups in any order)
  • [x] Python: fp.lq, fp.tv_iso returning (z, info) with info.gap and info.dual, and the other new operators (2026-10-16; fp.tv_aniso, TVAniso, TVIso, L0, Lq, SCAD, MCP, LogPenalty and their one-shot functions)
  • [x] Check the citations marked "to check" in the spec (2026-10-16): Beck–Teboulle against Beck (2017), Appendix D; Xu et al., Cao–Sun–Xu, Fan–Li and Zhang against the bibliographies of Wen et al. (IEEE Access 2018) and a second citing paper, now listed as checked in docs/spec.md with volume and pages. The originals were not opened, so the kernel derives every closed form (SCAD and MCP also for γ ≠ 1) and the tests verify it against grid minimisation
  • [x] Per-entry weights for SCAD and MCP (2026-10-17): g(z) = Σ wᵢ φ(zᵢ) with fp_op_scad(λ, a, w), fp_op_mcp(λ, b, w), SCAD(lam, a, weights), MCP(lam, b, weights). Entry i is the unweighted map at the step γwᵢ (SCAD is not a reparametrised SCAD, but its prox depends on the step only through γwᵢ; for MCP this is w·MCP_{λ,b} = MCP_{wλ,b/w}), with the checks b > γ max w and a > 1 + γ max w. θ = (λ, a or b, w…) with weights and (λ, a or b) without, so unweighted callers and the group penalties keep their layout; the VJP in w is the hypergradient for edge weights. Unweighted maps are bit-identical and as fast as before; weighted ones cost 1.0–1.3 ns per entry. ElemDeriv now carries three parameter derivatives per entry
  • [x] Kink mask for the elementwise operators (2026-10-17), the first part of the 0.3 kink and tie mask item, brought forward for the SCD paper: soft thresholding, ℓ1 over a box, SCAD and MCP. fp_workspace_kinks(ws, tol, mask, &count) gives an int8 code per entry (new dtype FP_I8): which breakpoint lies within tol, absolute in the input's units. fp_workspace_set_branch(ws, side, tol) makes fp_jvp/fp_vjp take the piece on the x − ε or x + ε side of it, with the piece's formula at x. In Python: ctx.kinks(tol), and branch=/kink_tol= on jvp/vjp. Gate met: the mask is the same for any thread count, and each side's JVP matches the one-sided finite difference from its side, in x and along the piece in γ and θ. Each map gained explicit pieces; default derivatives are bit-identical and as fast as before
  • [x] Jacobian diagonal of the elementwise operators in Python, ctx.jacobian_diag(branch=None, kink_tol=0.0) (2026-10-17): the same as jvp(ctx, dx=ones) but named, and honouring the branch override. A semismooth* Newton step reads the SCD subspace of each entry from it (0: entry fixed at zero; 1: no curvature; otherwise the slope of the concave branch, b/(b − γwᵢ) for MCP). Operators that are not elementwise raise ValueError; the elementwise Python classes carry _elementwise, and the CASES test checks jvp(ctx, dx) = diag · dx for each of them
  • [x] Example examples/weighted_glasso.py (2026-10-17): weighted graphical lasso by ADMM, with the −log det step as eigh plus LogBarrier on the eigenvalues and the penalty step as weighted Soft or weighted MCP on the packed upper triangle (each pair counted twice in the penalty and in the Frobenius term, so the per-entry prox at step 1/r solves the usual Σ_{i≠j} form). The graphical lasso, adaptive weights from a first estimate and weighted MCP compared on edge recovery and error, with the KKT residual of the convex solves; run by the Python tests

  • [x] Gate met (2026-10-17): the iterative operators meet gap ≤ tol · ½‖x‖² with the gap recomputed independently in tests/python/test_tv_aniso.py, test_tv_iso.py and the C tests; the nonconvex maps are verified against a refined grid in tests/python/test_nonconvex.py, with exact tie flags

  • [x] Published 0.2.0 to PyPI (2026-10-17): https://pypi.org/project/fastprox/0.2.0/, 5 abi3 wheels and the sdist, uploaded by trusted publishing from the v0.2.0 tag after a TestPyPI dry run; checked by installing from TestPyPI and from PyPI into fresh environments and running the examples

Gate: iterative operators meet gap ≤ tol · ½‖x‖² with the gap recomputed independently in tests; nonconvex maps verified against a dense grid with refinement, tie flags exact at thresholds.

0.3 — graph TV

  • [x] Max-flow engine (2026-10-17): src/maxflow/maxflow.hpp, two search trees with growth, augmentation and adoption written from Section 3 of Boykov and Kolmogorov (TPAMI 2004), first in first out with the distance marks of Section 3.3; the trees and the flow survive changes of terminal and edge residuals (add_terminal, set_edge), repaired as in Kohli and Torr (TPAMI 2007). The graph is built once; solves run in caller memory and never allocate. Tested in tests/c/test_maxflow.cpp by a full certificate after every solve (feasible flow, conservation, the trees equal to the residual reachability sets, cut capacity equal to the flow), against Dinic's algorithm, and reused solves against fresh ones node for node, including the graph TV level pattern. On TV cut problems one cut is 1.6–11× faster than Dinic, except 64³ at γ = 0.5 (0.7×) (bench/bench_maxflow.cpp, docs/benchmarks.md)
  • [x] Graph TV by parametric max-flow (2026-10-17): fp_op_graph_tv, fp.GraphTV; each part cut at the mean of its solution (exact when the cut is trivial), clamped into the middle half of its interval, all parts in one solve per round with the flow and trees reused; exact to rounding at tol = 0, else within tol·(max x − min x). Gap from the flow as the dual; exact region derivatives. Tested by an independent KKT check, against 1D TV on chains, anisotropic TV on grids (to 1e-7, the iterative solver's own accuracy) and CVXPY fixtures. On 512² 4-neighbour grids it takes about 20 solves, 0.13 s at γ = 0.02 to 3–4 s at γ = 0.5 on one thread, against 0.09–1.7 s for TVAniso at a gap tolerance of 1e-10 (errors up to 1e-5); exact graph TV is faster than that at γ = 0.1, slower at γ = 0.02 and 0.5. The time is in max-flow, which re-routes flow through the flat regions every round. kNN graphs of 10⁵ points take 0.15–0.65 s. Starting the rounds from the exact dual takes the max-flow part from 5.5 s to 0.12 s, but approximate duals (up to 400 FISTA iterations) gave nothing: the dual is far from unique and a flow close in value is not close in shape (docs/benchmarks.md)
  • [x] TV on trees and chains (2026-10-18): fp_op_tree_tv, fp.TreeTV, graph TV's arguments for edges that form a forest; Algorithm 2 and Section 4.2 of Kolmogorov, Pock and Rolínek (SIAM J. Imaging Sci. 9, 2016), the breakpoints of the messages in two pairing heaps (O(n log n)), or a sorted deque when every tree is a path (Section 4.1, O(n)); values recomputed as region means, the dual flow from the subtree sums, graph TV's gap and derivatives (shared in src/ops/edge_tv.hpp). Tested against exact graph TV, against 1D TV on shuffled paths, by the KKT check and CVXPY fixtures. On 10⁶ nodes: 70–190 ms for random trees, 35–75 ms for a comb spanning tree of a 1000² image, 4–8× faster than graph TV; paths 22–27 ms, 3.5–4× the time of TV1D on the ordered signal (docs/benchmarks.md)
  • [x] VJPs for the iterative operators by conjugate gradients on the dual active set, returning the residual. Choose the active set from the strict support of the computed primal and handle ties within the tolerance explicitly: picking an index set by rule can give a matrix outside the generalised Jacobian (Outrata, Kočvara and Zowe, Nonsmooth Approach to Optimization Problems with Equilibrium Constraints, Ex. 7.3) — Done in substance (2026-10-18), and closed: isotropic TV's VJP solves its system by conjugate gradients on the flat regions read off the dual and reports the residual (fp_workspace_deriv_info, ctx.deriv), stopped by default at the certified error of z; anisotropic, graph and tree TV have exact region averages; ties within a tolerance are reported by the kink masks and resolved explicitly by the branch overrides (item below)
  • [x] Kink and tie mask (the elementwise part with kinks is done, see 0.2; ties, the other operators and the image operators remain): report which entries sat at a kink of the prox or on a tie, not only the count in fp_info.ties. The elementwise operators come first, in 0.2 (see there). Kinks are the biactive entries of each operator: |xᵢ| = γλ for soft thresholding, the breakpoints of SCAD and MCP, an entry exactly on a bound of the box, an entry at the simplex threshold, a 1D TV edge whose dual sits exactly at ±γwₑ, a group whose norm equals its threshold; for the image operators, the pixels where the dual is on the boundary of its ball with a zero jump. An optional tolerance flags near-kinks as well, since exact equality is rare in floating point; the iterative VJPs above need the same rule for ties within the tolerance. It crosses the C API through the workspace like fp_workspace_deriv_info, written only with keep_structure (fp_prox keeps its signature), and in Python as ctx.kinks. jvp and vjp take an optional branch override for the flagged entries, so a caller can build the other B-Jacobian elements: the other subspaces of the SCD derivative (Gfrerer and Outrata, Variational inequalities of the second kind, 2022: for a Lipschitz map these subspaces are the graphs of the B-Jacobian matrices) and both branches of the limiting coderivative in nonsmooth adjoint inclusions (Suonperä and Valkonen, Single-loop approaches to nonsmooth bilevel optimisation, 2026, where the constraint set of the adjoint is a union of two convex sets). Gate: the mask is the same for any thread count, and for every flagged entry each branch's JVP matches the one-sided finite difference from its side — Progress (2026-10-18): ties of ℓ0, ℓq and the log penalty as kinks (masks and branch overrides), and masks for 1D, anisotropic and isotropic TV (biactive edges and pixels, from the saved solution and dual). Then (2026-10-18) branch overrides for 1D and anisotropic TV: side −1 joins a kink's edge and +1 keeps it apart, by rewriting the saved codes (1D) or rebuilding the saved regions from the kept z and dual (anisotropic). Remaining: isotropic TV's overrides (apart, a pixel with zero gradient has infinite curvature γ/‖g_p‖, a constraint the conjugate gradient system would hold only through its cap), and masks for the box, simplex, ℓ1 ball, group and graph operators. The rest moves to 0.4
  • [x] Spatially varying weights for the image operators: one weight per pixel for isotropic TV, Σ_p α_p ‖(wₐ Dₐ z)_p‖₂, and one per pixel and axis for anisotropic TV (per edge, as 1D TV already has), on top of the per-axis weights. The operator is built for one image shape, so θ has a fixed length as for weighted 1D TV, and the VJP returns a gradient per pixel or edge. Needed for learning spatially dependent regularization parameters in bilevel problems, and for iteratively reweighted ℓ1 (Ochs, Dosovitskiy, Brox and Pock, SIAM J. Imaging Sci. 8, 2015, 331–372), whose convex majorizers of TV^q are weighted TV problems. Isotropic: the weights enter only the dual constraint ‖u_p‖₂ ≤ γα_p, so the step and the warm-start projection carry over; zero weights decouple pixels. Anisotropic: the 1D steps use the weighted Condat kernel, and the region derivatives take the weight of each boundary edge. New constructors, so the existing ones keep their meaning. Gate: CVXPY fixtures with random weights, finite differences on the weight gradients, and an example that runs reweighted ℓ1 for TV^q to a stationary point — Done (2026-10-18) in the C kernels and NumPy: fp_op_tv_iso_weighted / TVIso(pixel_weights=) and fp_op_tv_aniso_weighted / TVAniso(edge_weights=) (shape (ndim, *img), the last entries along each axis unused), with gradients per pixel or edge, also through the PyTorch and JAX prox wrappers. 1D TV gained a row prox with per-call edge weights for the fibers. Isotropic TV with one active axis runs the 2D method when weighted. 14–33% more time per solve than unweighted on 512²; pixel weights near zero slow FISTA to very tight tolerances (one CVXPY fixture certifies only 2e-11 in 10⁶ iterations). examples/reweighted_tv.py: TV^q with q = 1/2, 42.6 dB against 36.7 for TV. Still open: the two items below
  • [x] Spatial weights in the device-native fastprox.torch.tv_iso/tv_aniso and fastprox.jax.tv_iso/tv_aniso: per-pixel radii in the projection and the gap, the flat test and the backward, and per-edge bounds for anisotropic TV, with gradients in the weights; until then fastprox.torch.prox(fp.TVIso, x, gamma, pixel_weights=a) runs the C kernel — Done (2026-10-18): pixel_weights / edge_weights, one map for all images or one per image (broadcast to x.shape), as the per-image γ. Matches the C kernel image by image (z and every gradient, to 1e-11; anisotropic exactly), and found a sign error in the C kernel's gradient at zero edge weights (fixed). 7–12% more per forward on MPS (8 × 512²), backward unchanged
  • [x] Fuzz the weighted image constructors (fuzz/fuzz_ops.cpp picks the image shape after the operator, so the weights need the shape first) — Done (2026-10-18): the array shape is drawn first after all, so fp_op_tv_iso_weighted and fp_op_tv_aniso_weighted get weights of the array's image shape, or a wrong shape, rank or leading axis, float32, zeros and raw bit patterns. 300 000 inputs of each kind and 400 000 over all kinds under ASan/UBSan; the first run found that 2D anisotropic TV (weighted or not, since 0.2) returned an unwritten z when ‖x‖² overflowed (fixed)
  • [x] PyTorch (torch.autograd.Function) and JAX (custom_vjp + pure_callback) wrappers, checked with gradcheck (2026-10-18): fastprox.torch.prox and fastprox.jax.prox (and prox_conj) take an operator, or an operator class with its parameters, and route each parameter's gradient by its Grads name; PyTorch also forward mode through the JVP. Tested by gradcheck in both modes, check_grads, jit, vmap and agreement with the NumPy API on eleven cases from elementwise to tree TV; examples/autodiff_frameworks.py
  • [x] Device-native image TV in those wrappers: isotropic and anisotropic TV in 2D and 3D written in framework tensor operations, so it runs on the input's device, GPU included, with no change to the C API. Dual fast gradient projection with the C kernels' gap stopping and warm starts (ℓ2-ball projection of the dual for isotropic TV, clamping for anisotropic), and a backward by conjugate gradients on the flat regions, so memory does not grow with the iteration count. The exact 1D TV steps and region averaging of the anisotropic C kernel stay on the CPU. Reproducible run to run on one device and build, not bit-identical to the CPU (see the decisions table). Gate: gradcheck, the gap recomputed in tests, agreement with the C kernels within the gap tolerance (2026-10-18): fastprox.torch.tv_iso/tv_aniso and fastprox.jax.tv_iso/tv_aniso. The forward is FISTA on the dual with the C kernels' step, restarts and gap stopping (isotropic TV takes the C kernel's iterations; anisotropic is a plain dual method, without the C kernel's 1D steps and polish). The backward is the C kernels' derivative on the flat regions, which are found on the device by hooking and pointer jumping and summed by a sort and a segmented scan, with no atomic adds: exact region averages for anisotropic TV, region-space conjugate gradients for isotropic. A label-free conjugate gradient method in the dual came first and needed 2000+ iterations on 512² images against 26–200 in region space. Tested by gradcheck and check_grads, the gap recomputed from the returned dual, agreement with the C kernels within the gaps, derivatives against the C kernels (to 1e-10, exact for anisotropic), warm starts from either side, and run-to-run repeats on MPS. On an Apple M5 Pro GPU, eight 512² images to a gap of 1e-6: isotropic 1.0 s (C: 4.4 s on one thread, 0.9–1.3 s on 15), backward 0.25–0.5 s; anisotropic backward 60 ms
  • [x] Flat pixels and edges of image TV from the dual in the derivatives (2026-10-18), in the C kernels and on the device: an entry strictly inside its dual bound (‖u_p‖ < γ(1 − δ) for isotropic TV, |p_e| < γwₐ(1 − δ) for anisotropic TV, δ = 10⁻⁹, max(10⁻⁹, 64 ε) on the device) is flat at the solution, replacing the test |Dz| ≤ 8·rms(gap), which also flattened entries with small true jumps. Anisotropic TV takes the regions and boundary signs of its polish, so its derivative is exact once the dual identifies them (from a gap tolerance of 1e-10 on 128² images; the device's at 1e-8). Isotropic TV's system became stiff (pixels on the sphere with gradients far below the certified error; at a gap of 1e-13 the reference needs 18 548 iterations), so its curvature γ/‖g_p‖ is capped at γ/μ, μ = 0.1 w_max rms(gap), a Huber smoothing at the level of the certified error (Hintermüller and Stadler 2006; De los Reyes, Schönlieb and Valkonen 2017), and the device backward uses the C kernel's Jacobi preconditioner. On 2 × 128² images the isotropic error against the exact derivative fell from 18–57% to 4% at 1e-6 and from 5–24% to 0.5–0.7% at 1e-8, at 3–8× the iterations; a cap at μ = rms, or flat entries below it, lost accuracy, and taking the direction from the projected dual u/max(γ, ‖u‖) (Hintermüller and Stadler's globalisation) changed errors by ±15%. On the DeepInverse comparison (8 × 256², float32, MPS) the gradient error at 1e-6 fell from 0.66 to 0.065, level with DeepInverse at 400 unrolled iterations, at 612 ms against 131 ms before (docs/benchmarks.md)
  • [x] One step per image in the device-native image TV (2026-10-18): gamma broadcasts to the batch shape, the contract of DeepInverse's denoisers (one σ per sample, deepinv/deepinv#336) and a prerequisite for a fastprox backend there. Checked image by image against scalar calls (values, gaps and gradients), with gradcheck and check_grads in the step vector. Equal steps keep the scalar projections; distinct steps cost 6% (isotropic) to 24% (anisotropic) more per iteration on MPS, where clamping to a tensor of bounds is 3× slower than to a number
  • [x] Cheaper isotropic TV backward: the dual's flat pixels left a stiffer system, 3.6–4.8× the old backward time on 8 × 512² (MPS: 0.95 s at a gap tolerance of 1e-4, 2.5 s at 1e-6). Try a better preconditioner (incomplete Cholesky in region space, or multigrid over the regions) or deflating the near-flat pixels on the sphere — Done (2026-10-18) without a new preconditioner: the conjugate gradients stop by default at the relative error of z that the gap certifies, √(2 gap)/‖x‖ (in the C kernel and on the device; the gradient did not change below √tol, and the C kernel takes 2–5× fewer iterations), and the device's region sums scan in two levels (6× faster on MPS; 73% of an iteration before). On 8 × 512² the backward takes 137 and 546 ms on MPS (6.9× and 4.6× faster), 269 and 1062 ms with PyTorch on the CPU and 635 and 3111 ms with JAX; on the DeepInverse comparison, 166 ms at 1e-6 against 612. Preconditioners measured on one 128² system (docs/benchmarks.md): multigrid cuts iterations 6–9× but costs 3–4 products per cycle (at most 2× net), and ILU with fill needs 3–7 iterations but sequential triangular solves
  • [x] Release 0.3.0rc1: version 0.3.0rc1, a TestPyPI dry run, then the v0.3.0rc1 tag, so that the DeepInverse issue can point to an installable version — Released (2026-10-18): v0.3.0rc1 on 2ad4f64, on PyPI with wheels for macOS (arm64, x86_64), Linux (x86_64, aarch64) and Windows and the sdist; pip install --pre fastprox. The wheels were checked from the CI artifacts before the tag and from PyPI after it (TestPyPI already held an rc1 from the first dry run, so it was not re-uploaded)
  • [~] Benchmark the device-native path against DeepInverse's TV denoiser (Chambolle–Pock, autograd through the iterations) on CPU and GPU: time to a given accuracy, the cost of host transfers for the C path, and memory of a backward pass through an unrolled network. With the numbers, open an issue upstream proposing an optional backend; if transfers dominate at typical image sizes, move the 1.x CUDA kernels for image TV forward — Measured (2026-10-18, bench/compare_deepinv.py, CPU and MPS; no CUDA device here): to a given accuracy the device path is 3–17× faster than DeepInverse's denoiser on MPS and 3–7× on the CPU; the host round trip is 0.9 ms against solves of 50–2100 ms, so transfers do not dominate on this machine and the CUDA kernels stay in 1.x; the unrolled backward keeps 10 MiB per iteration of 8 × 256² (4 GiB at 400) against 6 MiB for the implicit one. The gradients were then made accurate (the item on flat pixels from the dual): at a gap tolerance of 1e-6 the implicit backward's error is 0.065, level with 400 unrolled iterations (0.062), with 6 MiB kept against 4 GiB. Open: the upstream issue, held back until the proposal is mature (decided 2026-10-18). Before it is posted:
  • [x] 0.3.0 final on PyPI, after some use of the rc: an optional backend should not depend on a pre-release, and it already raises DeepInverse's Python floor from 3.10 to 3.12 — Released (2026-10-19): v0.3.0 on b5ef7ff, on PyPI with the same wheels as rc1 and the sdist, after a TestPyPI dry run; pip install fastprox gets it. Every milestone is now met: the issue waits only for its text to be approved
  • [x] The cheaper isotropic TV backward (above): at matched gradient accuracy the backward is 612 ms against DeepInverse's 729 ms, so today the case rests on memory alone — Done (2026-10-18): 166 ms against 712, and forward plus backward 397 against 1473 ms
  • [x] CUDA numbers from bench/compare_deepinv.py, since most DeepInverse users are on CUDA and every figure so far is from Apple MPS and CPU — Done (2026-10-19, Colab Tesla T4, docs/benchmarks.md): to 1e-2 the device path is 6–8× faster, to 1e-3–1e-4 1.1–1.4×; the backward at matched gradient accuracy 281 ms against 1002 (isotropic, forward plus backward 560 against 1381 ms) and 9 ms against 843 (anisotropic), with 6–10 MiB kept against 1.6–4 GiB. On CUDA the case rests on the backward more than on the forward
  • [x] A comparison of tv_aniso against TVL1Denoiser — Done (2026-10-18, bench/compare_deepinv.py 256 8 aniso): 2.2–12× faster on MPS and 1.4–8× on the CPU to the same accuracy, a backward of 45–52 ms against 630 ms for 400 unrolled iterations, with 10 MiB kept against 1.6 GiB and gradient errors of 0.04–0.10 against 0.16 (docs/benchmarks.md)
  • [x] A docs page in fastprox showing fastprox.torch.tv_iso as a drop-in for TVDenoiser, to link from the issue — Done (2026-10-18): docs/deepinv.md maps the two APIs (steps per sample, stopping, warm starts, gradients) for both denoisers, checked by examples/deepinv_tv.py

0.4 — performance and the remaining derivatives

Moved from 0.3 on 2026-10-18, when 0.3 was released: work that 0.3's features do not depend on.

  • [x] A faster engine for graph TV on large grids: an excess-based max-flow (EIBFS, Goldberg, Hed, Kaplan, Kohli, Tarjan and Werneck, ESA 2015) or Hochbaum's pseudoflow (Oper. Res. 56, 2008), which solves the parametric problem for all levels at about the cost of one max-flow; measure against the BK engine on the 512² cuts of bench/compare_graph_tv.py. The BK engine is also quadratic around a node of high degree: graph TV on a star with 10⁵ leaves takes 30–60 s (tree TV: 10 ms), as the hub's arcs are rescanned each time it loses its parent in the search tree; add a star and a hub-heavy graph to the measurements — The hub part is done (2026-10-18): scan positions at nodes of degree above 32 and freed nodes rejoining their tree after adoption, 24.6 s to 53 ms on that star and 1.7–5× on a grid with five hubs, grids unchanged; stars and a grid with hubs are in bench/compare_graph_tv.py. The faster engine for large grids remains — Done (2026-10-19): EIBFS (src/maxflow/eibfs.hpp), from the ESA 2011 and 2015 papers, solving each round on the active parts only; 1.9–2.7× at γ = 0.5 and 1.2–1.9× at γ = 0.1 on 512² grids, within 12% of BK at γ = 0.02 and on kNN graphs, stars unchanged (docs/benchmarks.md). Push-relabel on the same pseudoflow was 20–200× slower and local cancellation before BK gained nothing; pseudoflow (Hochbaum) was not tried
  • [x] Kink masks and branch overrides for the remaining operators: masks for the box, simplex, ℓ1 ball, group and graph operators, and branch overrides for isotropic TV (apart, a pixel with zero gradient has infinite curvature γ/‖g_p‖, a constraint that its conjugate gradient system holds only through the curvature cap) and for graph and tree TV — Progress (2026-10-19): the box, the orthant, the simplex, the ℓ1 ball and group ℓ2 (masks and overrides; row-level kinks take the side at the row's or group's first entry). Then tree TV (masks of shape (..., m) through the same functions, its flows unique on a forest). Then graph TV (2026-10-19), on the solver's flow saved with the structure. Isotropic TV keeps masks without overrides (decisions table)
  • [x] Release 0.4.0: the version, a TestPyPI dry run, the v0.4.0 tag and a GitHub release — Released (2026-10-19): v0.4.0 on 7e550fa, on PyPI with wheels for macOS (arm64, x86_64), Linux (x86_64, aarch64) and Windows and the sdist, after a TestPyPI dry run whose wheels installed and ran in a clean environment; pip install fastprox gets it

If needed

Moved from 0.4 on 2026-10-19, when 0.4 was released: both are wanted only if a user needs them (the device path already covers fast backwards on GPUs, and beats DeepInverse's TVL1Denoiser at every accuracy). Planned for 0.5 at first; 0.5.0 became the release of the 1.0 work so far (below), which conda-forge needed, so these wait for a user who needs them, before or after 1.0.

  • [ ] ILU-preconditioned conjugate gradients for the C kernel's isotropic TV derivative, if a CPU backward needs it: ILU with a drop tolerance of 1e-3 took 3–7 iterations against Jacobi's 154–398 on a 128² system (IC(0) broke down: the system is not an M-matrix). Needs the region-space matrix assembled and its fill bounded in build_workspace
  • [ ] Faster anisotropic TV on the device: the dual method needs about 10× the iterations of the C kernel's 1D steps (624 against 59 to a gap of 1e-6 on 512²); try the polish from the regions (now available on the device) or a block method with batched 1D TV steps. Not needed to beat DeepInverse's TVL1Denoiser, which the device path already does at every accuracy (2026-10-18) — The polish from the regions, tried on 2026-10-19 (8 × 256², CPU), does not pay on the device: accepted on the target alone it halves the iterations (50 against 100 to 1e-4, 330 against 570 to 1e-6) but from wrong regions, with 2–4× the iterate's error, so no faster to a given error; with the C kernel's guard (gap at most 1/100 of the iterate's) it succeeds only at about 520 iterations for every tolerance, under 10% before its cost (25–40 iterations per attempt). Plain FISTA on the dual identifies the regions only near the end, where the C kernel's exact 1D steps find them early; the open route is a block method with batched 1D steps

1.0 — stable

In this order (decided 2026-10-19): the API settled first, then the documentation that describes it, the adapters and packages, and the freeze last. The conda-forge and BenchOpt submissions are posted only once their text is approved. BenchOpt moved past 1.0 on 2026-10-20 (After 1.0).

  • [x] API review before the freeze (2026-10-19): the C header exports exactly its 53 fp_* functions (C++ symbols hidden), its handles are opaque, and new options go through new functions such as the workspace setters (spec Section 9), so 1.x can grow without touching a struct. Changed: fp_op_log is fp_op_log_penalty (next to fp_op_log_barrier, and as Python's LogPenalty); the device comment now reserves the other values for 1.x. Kept: the Python names (soft_threshold, project_simplex, prox_linf, tv1d, ...), each clear on its own, rather than aliases and deprecations for a single pattern
  • [x] Documentation: a site built with MkDocs Material from the Markdown in docs/ and the examples, the Python reference from the docstrings (mkdocstrings), deployed to GitHub Pages by a workflow on each release — Built (2026-10-19): mkdocs.yml, the README, changelog and roadmap included with their links rewritten and the examples page made from examples/README.md (docs/hooks/include.py), formulas in LaTeX (KaTeX) in docs/api.md and the docstrings, docs.yml building strictly on every pull request. Live (2026-10-19) at https://dvillacis.github.io/fastprox/, deployed from master by docs.yml (the account's custom domain serves it at david.villacis.net/fastprox; the links keep the GitHub address)
  • [x] PyProximal adapter (ProxOperator subclass) — Done (2026-10-19): fastprox.pyproximal.ProxOp, checked against PyProximal's L1, its moreau test and a lasso through ProximalGradient, and shown in examples/pyproximal_tv.py (same PSNR as pyproximal.TV, about 6× faster). The adapter needs \(g(x)\), which fastprox could not compute, so fp_value (C) and Operator.value (Python) came first, for every operator. PyProximal is LGPL-3.0, so the adapter is written from its documentation (subclassing is use of its interface), with PyProximal as an optional dependency
  • [~] conda-forge packages for the C library and the Python package — Progress (2026-10-19): the recipe is packaging/conda/recipe.yaml, built in CI by the conda workflow. It has two outputs from one source: libfastprox, with run_exports pinned to the minor version before 1.0, and fastprox, an abi3 build for CPython 3.12 and later. libstdc++ is not linked statically there (FASTPROX_STATIC_LIBSTDCXX=OFF), so the submission waits for the first release with that option
  • [x] Release 0.5.0, the first with that option: the version, a TestPyPI dry run, the v0.5.0 tag and a GitHub release. It also carries the rest of the 1.0 work so far (fp_value, the PyProximal adapter, the fp_op_log_penalty rename); a minor version, since the rename breaks the C API — Released (2026-10-19): v0.5.0 on d897bd6, on PyPI with the same five wheels as 0.4.0 and the sdist, after a TestPyPI dry run whose wheel installed and ran in a clean environment. The tag's tarball (sha256 920e2685e9eff1dc9c465bfa54defb82fc2414a835c53c6e194abc70f8aec429) is the staged recipe's source. The docs deploy on the release was refused, since the github-pages environment admits only master, so the site was deployed from master (the same commit) by hand
  • [~] The pull request to conda-forge/staged-recipes, with the release tarball as the source; its text is to be approved before posting — Posted (2026-10-19): conda-forge/staged-recipes#35260, libfastprox and fastprox 0.5.0 from the v0.5.0 tarball. Linux failed at first (no make in conda-forge's image; the recipe now uses Ninja there, #63), macOS on conda-forge's SDK download (fixed upstream). All green and in review with the Python-C team since 2026-10-20. Once merged, conda-forge creates fastprox-feedstock, and its bot opens a PR for each new release
  • [~] ABI freeze; after this, only additions that keep the ABI until 2.0: an ABI check in CI (abidiff from libabigail against the 1.0 library), then 1.0.0rc1
  • [x] The check (2026-10-20): the abi CI job compares the library, built with debug information, against the last release (rc tags excluded; 0.5.0 until 1.0 is out) with abidiff --no-added-syms, on the types of fastprox.h; publishing waits for it. CMake requires FP_ABI_VERSION to equal the major version, which is the soname's. The policy is written in docs/api.md ("ABI stability"). Probed with a throwaway commit (#64): an added function passed, and a field added to fp_info failed the job (size 192 → 256 bits, through fp_prox)
  • [x] 1.0.0rc1: the version (FP_VERSION_MAJOR and FP_ABI_VERSION 1, soname libfastprox.so.1), a TestPyPI dry run, the tag and a GitHub release — Released (2026-10-20): v1.0.0rc1 on cda044a, on PyPI as a pre-release (pip install --pre fastprox; plain pip install still gets 0.5.0) with the same five wheels and the sdist, after a TestPyPI dry run whose wheel installed and ran in a clean environment. The abi job passed against v0.5.0
  • [x] 1.0.0rc2 from master, with the spectral operators, fp_prox_steps, the device API, the audit's fixes and the feedback items U1 and U2 (A11, U7): the version, the "since 1.1" markers made "since 1.0", a TestPyPI dry run, the v1.0.0rc2 tag and a GitHub release — Released (2026-10-23): v1.0.0rc2 on 6857cb7, on PyPI as a pre-release with the five wheels and the sdist, and a GitHub release; the docs deployed with it. The first TestPyPI dry run failed on the aarch64 wheel, whose tests found results that depended on the thread count (GCC's FMA contraction, fixed by -ffp-contract=off, #105); the second passed, and its wheel installed in a clean environment ran all 13 examples with ConvergenceWarning as an error
  • [x] 1.0.0rc3 from master, with the feedback items U3–U5 and the audit's speed items (U7): the version, a TestPyPI dry run, the v1.0.0rc3 tag and a GitHub release — Released (2026-10-24): v1.0.0rc3 on 76e1ad4, on PyPI as a pre-release with the five wheels and the sdist, and a GitHub release; the abi job passed against 0.5.0. The TestPyPI dry run passed, and both its wheel and PyPI's, installed in clean environments with PyTorch, JAX, DeepInverse and PyProximal, ran all 13 examples with ConvergenceWarning as an error (set through warnings.simplefilter in a wrapper: python -W error::fastprox.ConvergenceWarning is ignored, as Python cannot import fastprox when it parses the option)
  • [x] 1.0.0 after some use of the rc and once the 1.0.0 items of the audit and of the user feedback below have landed (through 1.0.0rc2, A11, and an rc3 if the feedback items land after it), as for 0.3: the version without the suffix, the README's pre-release line removed, a TestPyPI dry run, the tag and a GitHub release — Released (2026-10-24): v1.0.0 on a5f2c86, on PyPI with the five wheels and the sdist (plain pip install fastprox gets it), and a GitHub release marked latest; the abi job passed against 0.5.0, the last release it compares with. The TestPyPI dry run passed, and its wheel ran all 13 examples with ConvergenceWarning as an error in a clean environment, with every dependency from PyPI and fastprox alone from TestPyPI (--no-deps): mixing the two indexes with uv's unsafe-best-match had pulled python-dateutil 3.9.0, a TestPyPI-only upload (PyPI's newest is 3.0.0)
  • [~] At 1.0.0, in the conda-forge feedstock: run_exports from x.x to x, as the ABI then holds for every 1.x — Progress (2026-10-24): packaging/conda/recipe.yaml pins x. There is no feedstock yet, since conda-forge/staged-recipes#35260 (0.5.1) is still in review, so the change goes into that pull request, updated to 1.0.0
  • [x] Release 0.5.1, a patch on 0.5.0 with the tv1d_l2 fix (#76), for pip install fastprox while 1.0 is a release candidate — Released (2026-10-21): v0.5.1 on c636d21 of the release/0.5.x branch (cut from v0.5.0, the two fix commits cherry-picked), on PyPI with the same five wheels and the sdist, after a TestPyPI dry run whose wheel installed and passed the fuzz case in a clean environment; pip install fastprox gets it. The fix reaches 1.0.0 from master

1.0 — audit of 2026-10-22

An audit of master at d67de78 for robustness and speed found 56 items (57 with A12, added the same day), each reproduced and specified (problem, design, constraints, tests, acceptance) in docs/audit-2026-10.md, with the decisions that span items and the decisions on its open questions (2026-10-22). The correctness, safety and scaling items and the documentation items gate 1.0.0, released through 1.0.0rc2 (A11); the speed items follow in 1.0.x. An item whose design departs from the spec adds its row to the decisions table when it lands.

Correctness, safety and scaling (gate 1.0.0)

  • [x] A1: Conjugate prox at small σ, and steps that overflow inside the kernels — spec
  • [x] A2: Shape-product and offset overflow in to_arr / Arr::numel — spec
  • [x] A3: Kept calls that do no work leave derivatives unavailable — spec
  • [x] A5: Image operators validate and compare fp_options.axis, which they claim to ignore — spec
  • [x] A7: Size errors reported as FP_EINTERNAL (std::length_error) — spec
  • [x] A8: NaN images: the certificate they report, and a dual that cannot be set back — spec
  • [x] A9: A failed fp_workspace_set_branch treats the earlier override differently by operator kind — spec
  • [x] A12: Enum arguments and fields outside their enumeration (added 2026-10-22) — spec
  • [x] C1: Reject overlapping outputs other than exact aliasing; reject stride-0 outputs — spec
  • [x] C2: Size per-thread scratch for the threads a row operator can use — spec
  • [x] C3: Cap fp_options.threads — spec
  • [x] C10: Guard against a nested parallel_run from inside a job — spec
  • [x] K1: Jacobian 0 instead of 1 where the threshold is 0 and x = 0 — spec
  • [x] K2: Squared norms overflow or underflow (L2Ball, GroupL2, TreeL2, GroupRadial, SOC) — spec
  • [x] K3: Log penalty: overflow of (|x|+ε)² and cancellation in the root — spec
  • [x] K4: tv1d_l2 derivatives are not scaled, so they fail outside about 1e±103 — spec
  • [x] K5: TreeL2 jvp and vjp: τ/s³ goes to inf for groups with ‖w_g‖ < 1e-103 — spec
  • [x] K7: Hyperplane and half-space: Σ aᵢxᵢ overflows — spec
  • [x] K8: Isotonic: block sums overflow; keep block means instead — spec
  • [x] K9: TV1D constant_mean overflows — spec
  • [x] K10: Huber derivative: c² underflows — spec
  • [x] K11: A degenerate bound lo = hi is treated as free — spec
  • [x] T1: Anisotropic TV: flat edges at tiny bounds λ_e — spec
  • [x] T5: Image TV: overflow of ‖x‖² and of the gap (power-of-two rescaling) — spec
  • [x] T6: Graph TV: dual and gap lost to cancellation at large γ·w — spec
  • [x] T7: Spectral derivatives: near-ties chained into one wide cluster — spec
  • [x] T9: Graph and tree TV: overflow of the value range — spec
  • [x] P1, first step: the PyTorch backwards raise under create_graph=True instead of returning a wrong Hessian — spec
  • [x] P2: Python side of overlapping out/dx/g buffers — spec
  • [x] P3: Serialise calls on one Context — spec
  • [x] P4: Release the GIL in operator constructors and other data-sized C calls — spec
  • [x] P5: Keep float32 for non-ndarray array-likes — spec
  • [x] P6: Reject unknown names and wrong sizes in dparams — spec
  • [x] P7: Clear error messages at the Python boundary (target: 1.0.0 (a), (b), (d); 1.1 (c-parity)) — spec
  • [x] P8: Empty batches and NaN or Inf images: one contract across the C, PyTorch and JAX paths — spec

Documentation (1.0.0)

  • [x] A4: Docs: a prox call without keep_structure discards the kept point — spec
  • [x] A6: An operator must outlive its workspaces (header text) — spec
  • [x] A10: Derivative calls write the "const" workspace: one call per workspace at a time — spec
  • [x] A11: Versioning: "since 1.1" notes on a tree versioned 1.0.0rc1 — spec
  • [x] T10: Docs: graph TV derivatives with tol > 0 — spec
  • [ ] P12: Free-threaded CPython (3.13t, 3.14t) (target: 1.1 (wheels), 1.0.0 (a docs line): the docs line is in) — spec

Speed (1.0.x)

  • [x] C4: Vectorise the elementwise prox loops, contiguous and in place — spec
  • [x] C5: Elementwise jvp and vjp: register accumulators, branch-free pieces, skip unrequested sums — spec
  • [x] C6: Pool: close the job when its pieces are done, instead of waiting for every worker — spec
  • [x] C7: Grain: pieces scaled to the thread count for prox and jvp — spec
  • [x] C8: Strided operator axis: gather and scatter rows in tiles — spec
  • [x] C9: Spin time as an environment knob — spec
  • [x] C11: A core section in bench/profile_kernels.cpp — spec
  • [x] K6: Lq: Newton stalls near the threshold (speed) — spec
  • [x] K12: L2Ball jvp and vjp: fuse the passes and hoist the division (speed) — spec
  • [x] T2: Isotropic TV: threaded derivative solves — spec
  • [x] T3: Isotropic TV: integer divisions in the derivative loops — spec
  • [x] T4: Graph and tree TV: small batches run serially — spec
  • [x] T8: Anisotropic TV: serial structure() — spec
  • [x] P9: JAX: compile once per operator instead of dispatching eagerly — spec
  • [x] P10: Keep the derivative structure only when a derivative can follow (PyTorch and JAX forward) — spec
  • [x] P11: Trim per-call Python overhead — spec

Second order in PyTorch (1.0.x)

  • [ ] P1: exact second-order reverse mode through the linear part and where the Jacobian is locally constant, NaN elsewhere — spec

1.0 — user feedback of 2026-10-23

Specs in docs/feedback-2026-10.md, from reproducing paper experiments with the library. Every item gates 1.0.0 (decided 2026-10-23), with the decisions recorded at the end of the doc.

  • [x] U1: Accuracy in the units of z: the √tol bound in the docs, ztol= and IterInfo.zerr — spec
  • [x] U2: Unconverged and too-loose calls are silent: ConvergenceWarning, the fp.inner_accuracy context — spec
  • [x] U3: One set of derivative keywords (tol, max_iter) on every operator's jvp/vjp — spec
  • [x] U4: Derivatives of iterative TV at loose gaps: ctx.deriv.exact, ctx.refine — spec
  • [x] U5: Weighted nuclear norm through a sorted ℓ1 (OWL/SLOPE) operator — spec
  • [x] U6: Spectral MCP divergence: get the reproducer, then test or fix — Done (2026-10-24): the reproducer, MovieLens matrix completion with spectral MCP (experiment 8 of the report's project), has no minimiser, and the iterates of FISTA and of proximal gradient grow without bound while the objective falls, as the report's own notes said; the library is not at fault. bench/repro_u6_spectral_mcp.py reproduces it. The checks made before it turned up (ties and kinks, the gain b/(b − γ), the outer step) are documented and tested — spec
  • [x] U7: Releases: 1.0.0rc2 (with the spectral operators) on PyPI, an rc3 if U1–U5 land after it, then 1.0.0 — Progress (2026-10-23): 1.0.0rc2 is on PyPI with the spectral operators, and the README gives the install paths; rc3 follows U3–U5; (2026-10-24) 1.0.0rc3 is on PyPI with U3–U5 and the speed items, and 1.0.0 followed the same day, after U6 — spec

1.0.1 — mathematical audit of 2026-10-25

Two audits of 1.0.0's mathematics are docs/mathematical-audit-2026-10-25.md (M1–M7, D1–D2) and docs/theoretical-audit-2026-10-25.md (T1–T9). Every finding reproduced on master at 8daf8fa. Their claims were checked against the literature (sources in the spec). The specs are in docs/math-audit-2026-10.md, and every item gates 1.0.1. That release adds no C function and changes no signature.

Wrong results

  • [x] M1: Spectral near ties across a breakpoint. Use the mean of the branch derivatives only where it agrees with the divided difference within the quotient's rounding bound; X = diag(1 + δ, 1 − 2δ) gives 1/3, not 1/2 — spec
  • [x] M2: Weighted isotonic regression has no Euclidean conjugate. fp_prox_conj returns FP_EINVAL for unequal weights (decided 2026-10-25), in C, Python and the framework wrappers — spec
  • [x] M3: ℓ0 threshold overflow. γλw rounded as written, from the mantissas where γλ would leave the range (bitwise unchanged elsewhere), for ℓ0 and ℓq; reciprocal-scaling tests bit for bit — spec
  • [x] M4: Log barrier leaves its domain. Bounded scale s = √γ·√λ; an underflowing root returns the dtype's smallest positive value — spec
  • [x] M5: 1D TV with ℓ2 drops edges whose squared weight underflows. Weights stored over a power of two, with the factor folded into γ; positive weights below 2⁻⁵¹¹·max w rejected — spec
  • [x] M6: SCAD and MCP overflow. Bounded-ratio forms for the values and every derivative, scalar and group — spec
  • [x] M7: Certificates and output rounding. zerr adds the output dtype's unit roundoff; a ztol below it warns; the docs say "to working precision" — spec

Guarantees in the spec and the docs

  • [x] C1: Three classes of prox maps: Lipschitz, Hölder-½ (log penalty at γλ = ε²) and discontinuous (ℓ0, ℓq, log above it). Clarke and B-subdifferential claims are limited to the first class; elsewhere the derivative is a named branch convention — spec
  • [x] C2: Nonconvex penalties. Only SCAD, MCP and ℓ0 are bounded; existence is stated as what was observed; the README's conjugate claim gets the caveat (g* = δ{0}, the returned map is the Moreau residual) — spec
  • [x] C3: Composed and bilevel gradients. A section "What the derivatives guarantee": chain rules off switching sets, Clarke 2.6.6 for a C¹ loss applied directly, and the caller's regularity for implicit differentiation — spec
  • [x] C4: A small gap does not certify a derivative. deriv.exact and refine describe the regions, not a bound in the gap — spec
  • [x] C5: Graph TV kinks describe the saved flow, a superset of the prox's kinks on graphs with cycles — spec
  • [x] C6: Outer-method statements. Hypotheses and "sufficient" for forward–backward, FISTA, nonconvex descent and error summability, each checked in its source — spec
  • [x] A1: Commit both audits with errata (Ky Fan index in T9, T3's equality, T5's scaling, T7's strict complementarity, T8's prox-bound), the scripts under reports/, and the three pages in mkdocs.yml — spec
  • [ ] R1: Every M item's counterexample as an assertion in the suite (fixtures, no CVXPY or mpmath at test time); full suites, the sanitizer build and a fuzz run with the extreme ranges seeded (an hour locally, one CI dispatch on the branch; decision of 2026-10-25); then 1.0.1 on PyPI — Progress (2026-10-25): the counterexamples are in the suite; the full suites, the sanitizer build, and two hours of the fuzz harness locally (with the shorter runs before them, eight defects, fixed in #129; the second hour, 292 million inputs, none) passed, and #129 is merged; the version is 1.0.1. A TestPyPI dry run and the tag follow — spec

1.x — GPU backend

  • [x] CUDA kernels in the C core behind fp_array.device, added after the ABI freeze without breaking it: new fp_device values, a function that reports which operators support a device, and FP_EINVAL from an operator given a device it does not implement — Design (2026-10-20): docs/spec.md, Section 8, "GPU backend", after a literature check (Notability and outside). FP_DEVICE_CUDA (2, DLPack's value), fp_device_available, fp_op_device_check, the stream bound to the workspace (fp_workspace_set_stream), all device scratch allocated in fp_workspace_create, asynchronous results (fp_workspace_info, fp_vjp_device), FP_EDEVICE, and one step per image (fp_prox_steps, CPU too). The kernels live in a plugin, libfastprox_cuda, loaded on first use. The device API ships in 1.0 (A11, 2026-10-23); the kernel stages below stay in 1.x — Landed (2026-10-20): the enum values, FP_EDEVICE, fp_device_available, fp_op_device_check, the stream setters, fp_workspace_info, fp_vjp_device, and the plugin loader with its private table, tested against a stub plugin. fp_prox_steps (2026-10-21), on the CPU for every operator. The device paths are the stages below
  • [ ] Stage 1: elementwise maps, group and radial operators, simplex and ℓ1-ball projections (a sort in shared memory, long rows filtered in chunks as in Dai and Chen 2024), and exact 1D TV by taut string with one thread per row. Gate: faster than the C kernel through the host on a T4 for batches of 64 × 512², and the row count below which 1D TV stays on the CPU measured
  • [ ] Stage 2: anisotropic image TV by the CPU's accelerated block method with the stage-1 1D TV step (Chambolle and Pock 2015: about a tenth of the 0.3 path's iterations), isotropic TV by the CPU's dual FISTA in fused kernels, and the region derivatives with canonical labels. Gate: faster than the 0.3 device path at every tolerance from 1e-2 to 1e-6 on bench/compare_deepinv.py, on a T4 and one datacenter GPU
  • [ ] Stage 3: B and r of the spectral operators on the device, isotonic regression and the remaining row operators. Graph and tree TV stay on the CPU (Jensen et al., TPAMI 2023)
  • [ ] Determinism on the device: no floating-point atomics, fixed-shape reduction trees over reduction_blocks, launch geometry from the shape alone; bit-identical run to run on one device model, toolkit and build. Contraction off on both sides (--fmad=false, and -ffp-contract=off on the CPU), so the elementwise maps built from correctly rounded operations match the CPU bit for bit
  • [ ] Packaging: CUDA builds as a separate package rather than in the main wheel, and through conda-forge — Design: fastprox-cuda12 and fastprox-cuda13 plugin wheels (pip install fastprox[cuda12]), a libfastprox-cuda conda-forge output, the CUDA runtime linked statically; Windows after Linux
  • [x] One step per row in the PyTorch and JAX wrappers (fastprox.torch.prox, fastprox.jax.prox), through fp_prox_steps, with each row's step gradient from a JVP in γ (the device-native image TV already takes one per image) — Done (2026-10-21): gamma broadcasts to the batch shape (rows, images or matrices); each step's gradient is \(\langle g, \partial z/\partial\gamma \rangle\) over its rows from fp_jvp with dgamma = 1, summed back to gamma's shape, so a gradient costs one more JVP; PyTorch's forward mode moves each row's step by its tangent. prox_conj keeps a scalar σ, as in C
  • [ ] Bindings and CI for the device: nanobind device arrays on the framework's current stream, torch.library.custom_op for PyTorch, an XLA FFI handler for JAX; compile-only CUDA CI on every pull request, and the GPU suite (against the C kernels, repeat runs, graph capture, compute-sanitizer) from a Colab T4 before each release

1.x — candidates

Additions the frozen ABI allows, not yet scheduled.

  • [ ] Graph TV kinks independent of the saved flow (from audit item C5, 2026-10-25): for a region with flagged edges, a max-flow over its circulations looks for a flow strictly inside the bounds, and unflags the edges where one exists (De los Reyes and Meyer, Algorithm 1, step 6) — spec

  • [x] Spectral prox maps on matrices: the nuclear norm, the spectral-norm ball, projection onto positive semidefinite matrices, and any elementwise operator applied to the singular values or eigenvalues (moved from version 2 on 2026-10-20). The caller supplies the decomposition (NumPy, PyTorch or JAX svd/eigh, on the CPU or the GPU), so the C core stays free of LAPACK and BLAS (spec Section 8). The core applies an existing scalar prox to the spectrum and gives the JVP and VJP of the spectral map by the Daleckii–Krein divided differences: repeated singular values and values at a kink, where autograd through an SVD returns infinite or wrong gradients, are handled exactly. The Python API gets fp.Spectral(op) and fp.NuclearNorm(lam), and PyTorch and JAX wrappers as for image TV. — Design (2026-10-20): docs/spec.md, Section 5, "Spectral operators". The core returns only k × k results: from the spectrum s, its prox z and A = Uᵀ H V it gives B and the complement ratio r. The caller reassembles U B Vᵀ with its own BLAS and on its own device. The calls are fp_op_spectral_check and fp_spectral_jvp; the map is self-adjoint, so the same call gives the VJP. Ties and zeros take their limits from one JVP per tie group. The formula was checked numerically before review: central differences agree to 1e-9 on square, tall, tied and rank-deficient matrices, and adjointness holds to 1e-15. Autograd through torch.linalg.svd returns NaN at the tie. Progress (2026-10-20): the C core and the NumPy layer, fp.Spectral with NuclearNorm, SpectralNormBall and PSD, checked against finite differences at ties and zeros and against Candès et al.'s divergence. Then fastprox.torch.prox and fastprox.jax.prox on spectral operators, with the decomposition and products on the input's device and the k × k core on the CPU, checked by gradcheck and finite differences, at ties too. Later, if needed: a closed-form 2 × 2 and 3 × 2 SVD in the core for batches of tiny matrices (total nuclear variation), and a device path for B.

  • [ ] Free-threaded CPython wheels (cp313t/cp314t): FREE_THREADED in nanobind_add_module, cibuildwheel for the free-threaded targets, a PYTHON_GIL=0 test job (the suite, the context-lock test, an 8-thread scaling check), then the classifier. The C side already serves concurrent callers with the GIL released (audit P12, docs/audit-2026-10.md#p12)

Analysis priors (design 2026-10-23: docs/spec.md, Section 5, "Analysis priors: smoothed TV, second-order TV and learned potentials"), in stage order:

  • [ ] Stage 1, Huber-smoothed TV: fp_op_tv_iso_huber, fp_op_tv_aniso_huber, TVIsoHuber, TVAnisoHuber. Sum of α_p h_δ(‖(W D z)_p‖), with h_δ the Huber function of fp_op_huber, 2D and 3D, with pixel or edge weights and θ ending in δ. The isotropic kernel's dual with a strongly convex conjugate, by V-FISTA (Beck, Section 10.7.7) at κ = 1 + γ α_max L / δ, so the rate is linear. The same gap certificate, ‖z − z*‖² ≤ 2·gap. Derivatives by conjugate gradients on (I + Gᵀ H G) with H bounded by γα/δ: no flat regions, no union-find, the H-apply kernel shared with the isotropic derivative's cap. δ can be learned. Device path in the PyTorch and JAX wrappers. Gate: the gap recomputed independently; ‖z_δ − z_TV‖² ≤ γδΣα_p against TVIso and TVAniso; iterations within a constant of √κ log(1/tol); finite differences in x, γ, the weights and δ; faster than TVIso to every tolerance at δ ≥ 1e-3 on the 0.2 benchmark images
  • [ ] Stage 2, spline potentials: fp_op_spline, fp_op_group_spline, Spline, GroupSpline. φ′ continuous piecewise linear through given knots, plus an optional ℓ1 kink at 0, so Huber, the elastic net and learned ridge potentials are special cases. The prox is exact by a binary search over the pieces. Weakly convex potentials need γρ max w < 1 (FP_EPARAM otherwise, as MCP). Derivatives in x, γ, the weights, the knot values and the kink, with kink masks and branches. Gate: grid minimisation as for the nonconvex maps, Huber and the elastic net reproduced to rounding, an entry in CASES
  • [ ] Stage 3, filter-bank analysis prior and second-order TV: fp_op_analysis, fp_op_tv2, Analysis, TV2. Groups of small filters (up to 9 taps per axis) with a potential per group (|t|, Huber, elastic net, convex spline) and pixel weights. The same dual method with L = Σ‖w_f‖₁² and the same gap. Derivatives in the filters, the pixel weights and the potentials' parameters. With flat entries, MINRES on the constrained system, measured against the capped system first. Second-order TV is the Frobenius Hessian norm by forward second differences (L = 64 in 2D, 144 in 3D). Gate: forward differences as filters reproduce TVIso and TVAniso within the gaps; second-order TV matches CVXPY, and affine images are fixed points; finite differences in the filters and coefficients
  • [ ] Stage 4, weakly convex potentials in the analysis prior (WCRR): the primal accelerated gradient on the m-strongly convex prox objective, m = 1 − γρα_max L > 0, reporting gap = ‖∇P‖²/(2m) (so ‖z − z*‖² ≤ 2·gap/m). Gate: against a long reference solve; derivatives by conjugate gradients against finite differences

Coderivatives for nonsmooth bilevel methods (design 2026-10-23: docs/spec.md, Section 7, "Coderivatives for nonsmooth bilevel methods"), for single-loop methods and for adjoint methods that choose an element at kinks:

  • [ ] Family 1, balls of a dual or a conjugate: fp_workspace_multipliers and fp_project_coderiv (ctx.multipliers, op.project_coderivative). After fp_prox_conj of group ℓ2 and soft thresholding, and after fp_prox of isotropic, anisotropic and analysis-prior TV. The multiplier ν (g = ν u at the solution; y = (1 + ν) u for a conjugate projection, Suonperä and Valkonen 2026, Remark 6.2), the codes inside, active and degenerate, and the projection onto the Fréchet (5.21) or limiting (5.22) set per ball. Before implementing: settle the difference between (5.18) and (5.22) on {λ = 0, ⟨w, u⟩ < 0} (spec Section 7). Gate: the sets against the case analysis of Lemma 5.5, the variational inequality of each projection, determinism
  • [ ] Family 2, elementwise prox maps at kinks: soft thresholding, the elastic net, Huber, box and orthant, ℓ1 over a box, SCAD, MCP and splines, and their group forms. The regular coderivative is the segment between the two one-sided pieces' adjoints, jointly in x, γ and θ, and empty when (b − a) y < 0 (Rockafellar and Wets, Proposition 8.37). The limiting one adds the endpoints. The projection onto its graph per entry also returns the mixture weight s, and fp_workspace_set_branch_weights (branch_weights= in Python) makes fp_jvp and fp_vjp differentiate the mixture, parameter gradients included. ℓ0, ℓq and the log penalty are refused at ties (unbounded coderivative). Gate: the sets against 8(26) on one-sided differences; the mixture's VJP between the one-sided VJPs; the empty case
  • [ ] Family 3, polyhedral rows with interacting kinks (simplex, ℓ1 ball, hyperplane with box, isotonic regression, 1D, anisotropic, graph and tree TV): a small active-set QP per row over its m kink entries. Design only, scheduled when a user needs more than isolated kinks; an isolated kink is already family 2's segment

After 1.0

  • [ ] Isotropic TV at γ ≥ 1 to 1e-10 (deferred from 0.2 on 2026-10-17): most 2D test images need over 100 000 restarted FISTA iterations (128² blocks at γ = 1: 116 568). Prototypes showed that the roadmap's candidates do not help: SSNAL took 1.7× FISTA's operator applications, ADMM with an exact DCT step has the same sublinear tail, and barrier Newton-CG took 5.6×; the dual is degenerate. An interior-point method on the SOCP with a sparse direct factorisation (Clarabel as a stand-in) was 5–34× faster in 2D at γ ≥ 1, level at γ = 0.3, and 18× slower on 32³. Building one needs a nested-dissection Cholesky for grid matrices and 34–670 MB of factor at 256²–1024², so it would be opt-in and 2D only
  • [ ] Julia bindings (ccall through a JLL package) and a ProximalOperators.jl adapter
  • [ ] MATLAB mex gateways, with a gate that they load on Linux next to MATLAB's own libstdc++
  • [ ] Rust fastprox-sys plus a thin safe crate
  • [ ] BenchOpt solvers for TV-1D and TV-2D, and a new simplex-projection benchmark (moved from 1.0 on 2026-10-20, optional) — Both solvers are written and pass the benchmarks' solver tests locally (2026-10-19), but are not submitted: the two benchmarks are dormant (last commits May and November 2024) and their own baselines no longer run with current SciPy and BenchOpt. To submit if one becomes active again, or as a solver for a more active benchmark such as the lasso; the speed comparison stays in docs/benchmarks.md meanwhile

Version 2 and later

Nothing planned. Matrix prox maps moved to the 1.x candidates on 2026-10-20.

Decisions and deviations from the spec

Date Decision Where
2026-10-14 fp_jvp takes a dparams argument, so JVPs cover the parameters as the spec requires fastprox.h
2026-10-14 fp_op_tv1d takes an fp_tv1d_method (auto, Condat, taut string) for the manual override fastprox.h
2026-10-14 Every operator has a parameter vector θ (fp_op_nparams); for soft thresholding θ is the weights, and Python also reports grads.lam fastprox.h, Python
2026-10-14 At the end of the signal, Condat's algorithm restarts after a jump with the plain post-jump bounds instead of the paper's tightened ones (measured: identical work over 200k signals, and simpler) src/ops/tv1d.cpp
2026-10-14 OpenMP uses dynamic scheduling over rows (balances performance and efficiency cores); determinism holds because rows are independent and vjp reductions use fixed blocks. The thread pool that replaced OpenMP (2026-10-15) keeps this scheduling src/core/driver.hpp
2026-10-14 The automatic 1D TV path lets Condat's algorithm rescan at most 3n + 1024 steps before switching to the taut string (measured: typical signals rescan 0–3n, ramps up to 3000n; past that the taut string is also faster) src/ops/tv1d.cpp
2026-10-14 Condat's bound updates use branch-free selects and a static table of 2¹⁵ reciprocals: faster on noisy signals, about 4% slower on smooth ones at large λ; an adaptive switch on clamp frequency was tried and mispredicts src/ops/tv1d.cpp
2026-10-14 Weighted 1D TV runs Condat's algorithm generalised to per-edge radii, precomputed per piece (evaluating them inside the scan doubled its cost) (new segment after a jump at edge e starts from y_k + σ r_e ∓ r_k; the last sample has radius 0), checked against the taut string on 40k problems src/ops/tv1d.cpp
2026-10-14 1D TV clamps radii above twice the dual bound min(e+1, n−1−e)·(max x − min x), which are never active, and returns the constant mean when every radius exceeds the bound; this keeps the 10 n ε ‖x‖∞ accuracy for extreme weights and steps src/ops/tv1d.cpp
2026-10-14 The taut string stores its chains as segments in coordinates local to the current knot (after proxTV's classic taut string, credited in the kernel header) instead of absolute double-double heights: 17–26% faster, error at most 4e-4 of the spec bound src/ops/tv1d.cpp
2026-10-14 macOS wheels target the macOS version of the build runner's Homebrew libomp (14.0 arm64 on macos-14, 15.0 x86_64 on macos-15-intel, which replaced the retired macos-13 runners), since delocate refuses older targets. Superseded on 2026-10-15: with no libomp bundled, the wheels target 11.0 (arm64) and 10.15 (x86_64) pyproject.toml, CI
2026-10-14 Condat's 1D TV uses branch-free bound updates only in the first 8 samples of a segment and branches after (bounds settle in long segments and branches predict well); 1/m is fetched only when a clamp happens in long segments src/ops/tv1d.cpp
2026-10-14 Weighted ℓ1-ball weights are stored normalised by their maximum, and weight ratios below 1e-100 are rejected with FP_EPARAM (their squares underflow; found by fuzzing) src/ops/projections.cpp, fastprox.h
2026-10-15 The first PyPI upload is the release candidate 0.1.0rc1, before the 0.1 gate passes (open speed items), so users can install it with --pre while 0.1.0 stays reserved for the gated release; the repository is made public CMakeLists.txt, CI
2026-10-15 Rows run on fastprox's own thread pool instead of OpenMP (spec: "OpenMP over rows"). Each wheel had to bundle an OpenMP runtime, and two copies of LLVM's libomp in one process abort it; 0.1.0rc1 crashed next to PyTorch on macOS. The pool keeps dynamic scheduling and bit-identical results, spins 50 µs before sleeping (since 1.0 the spin time is FASTPROX_SPIN_US, default 50), runs concurrent callers serially, and rebuilds itself after fork; since 1.0 a call waits only for the workers that entered it (audit C6). threads = 0 reads FASTPROX_NUM_THREADS, then OMP_NUM_THREADS, then the available CPUs. fp_has_openmp became fp_default_threads (the ABI is not frozen before 1.0) src/core/parallel.cpp, fastprox.h
2026-10-15 float32 1D TV may trail Condat's single-precision TV1D_denoise by a few percent at small λ (1–5% at λ = 0.1 on Apple M5, n = 10⁶) and still meets the 0.1 speed gate. fastprox keeps its running sums in float64 (spec Section 10: "float32 accumulates sums in float64 where a sum spans a row"), which costs a conversion per sample; single-precision sums would lose the accuracy bound on long rows src/ops/tv1d.cpp, gate
2026-10-16 Uniform 1D TV on random walks at λ = 10 may be about even with proxTV's classic taut string on Neoverse-N2 (0.97 estimated from the kernel, 1.04–1.06 in bench, n = 10⁵) and still meets the 0.1 speed gate; it is ahead on every other machine (0.64 on Apple M5, 0.73 on AMD EPYC, 0.80–0.84 on Intel) and ahead of proxTV's other solvers there (0.74). The classic taut string makes one pass where Condat's algorithm visits each sample about 3 times in this setting; the kernel variants that win it lose 13–29% at λ = 0.1 (docs/benchmarks.md). Beating it needs fewer rescans, an algorithmic change gate, src/ops/tv1d.cpp
2026-10-16 1D TV at λ = 0.1 may trail proxTV by up to 13% on Neoverse-N2 and Intel Xeon (1.01–1.13 of its time at n = 10⁵, GCC 13) and still meets the 0.1 speed gate; it is ahead on Apple M5 and AMD EPYC. Segments there are mostly 1 to 3 samples long and the time goes to mispredicted jumps; two attempts did not hold on the runners (docs/benchmarks.md). To be revisited with the variants workflow gate, src/ops/tv1d.cpp
2026-10-16 Derivatives of anisotropic TV come from the constant regions of the solution (averaging per region, γ and weight terms from the jump signs on its boundary), exact for the identified structure and O(n), instead of implicit differentiation of the dual conditions by conjugate gradients (spec Section 7). Anisotropic TV is an ℓ1 norm of differences, so its prox Jacobian has this closed form; CG stays the plan for isotropic TV src/ops/tv_aniso.cpp, docs/api.md
2026-10-16 The dual of iterative image operators crosses the C API through the workspace: fp_workspace_get_dual, fp_workspace_set_dual (seed the next call) and fp_workspace_set_warm (every call starts from the previous dual). fp_prox keeps its signature (the spec's ABI rule), and the spec's sketch did not say how the dual is passed fastprox.h
2026-10-16 Image operators act on the last 2 or 3 axes and ignore fp_options.axis (the spec says "the last two axes" for 2D TV; 3D takes the last three) fastprox.h
2026-10-16 Iterative operators return an IterInfo (gap, iters, ties, converged, dual) in Python instead of extending Info, which 0.1 code may unpack as a 3-tuple; reaching max_iter sets converged = False rather than raising, since the iterate is written Python package
2026-10-16 Isotropic TV takes one weight per axis inside the norm, Σ_p ‖(wₐ Dₐ z)_p‖₂ (the spec's Σ‖(∇z)_i‖₂ with unit weights), so anisotropic voxel spacing is expressible and θ has one entry per axis as for anisotropic TV fastprox.h
2026-10-16 The tolerance and the residual of the derivative solves (spec Section 7: CG "stopped at a user tolerance", "the returned residual") cross the C API through the workspace, fp_workspace_set_deriv_tol and fp_workspace_deriv_info, since fp_jvp and fp_vjp have no options or info argument and their signatures stay fixed fastprox.h
2026-10-16 For the nonconvex maps fp_prox_conj returns the Moreau formula y − σ prox_{g/σ}(y/σ), which is not the prox of g* when g is not convex (spec Section 4 states the identity for every operator). The SCAD and MCP conditions "concavity parameter large enough relative to γ" are a > 1 + γ and b > γ, checked against the kernel's step (1/σ after fp_prox_conj) fastprox.h, docs/api.md
2026-10-16 Operators beyond the spec's catalogue of 20 (Section 5) join 0.2 from the literature review of 2026-10-15: the maximum, the sum of the k largest entries or absolute values, and the hyperplane and half-space projections with an optional box. Each is exact and reuses the simplex kernel or one plane solver. An empty constraint set for the axis length is FP_EPARAM at call time, since it depends on n fastprox.h, docs/api.md
2026-10-16 More operators beyond the catalogue: the log barrier, ℓ1 over a box (any interval, not only Beck's [−α, α]), the second-order cone, and group Huber, SCAD and MCP. The cone puts t first in the row, as conic solvers do (Beck's Example 6.37 puts it last). Group SCAD and MCP are nonconvex but single-valued under their step conditions, so they take no tie rule fastprox.h, docs/api.md
2026-10-16 The level-set projection of Beck's Theorem 6.30 lands as the 1D TV ball only, with θ = (α, w…). It is the one level set the roadmap named, and a generic form would need the value of f in the operator interface. Its cost is several 1D TV solves (4–15 in measurements), the price of exactness without a closed form. Tree-structured group norms take groups in any order and sort them by size, which is a valid composition order for nested or disjoint groups fastprox.h, docs/api.md
2026-10-16 GPU support moves from version 2 to two earlier steps (spec: no GPU kernels in version 1, device values other than CPU rejected in 1.x). In 0.3 the PyTorch and JAX wrappers get a device-native path for image TV, written in framework tensor operations with the same gap stopping and an implicit backward, so GPU users avoid host transfers and the memory cost of differentiating through iterations. In 1.x the C core gets CUDA kernels behind the reserved fp_device field, an addition that keeps the ABI. Bit-identical results across thread counts stay a CPU guarantee; on a GPU the output is reproducible run to run on one device and build, and agrees with the CPU within the gap tolerance docs/spec.md, Python package, fastprox.h (1.x)
2026-10-17 1D TV with ℓ2 of differences uses Newton's method on Moré and Sorensen's secular equation of the dual trust-region problem (Nocedal and Wright, Algorithm 4.4) instead of projected Newton on the dual (spec Section 5): the dual constraint is a single ℓ2 ball, so there is no active set to identify, and the root is reached to rounding in 2–8 steps of one tridiagonal factorisation (measured). The operator is therefore exact like the TV ball (fp_info.gap is 0, tol is not used), and its derivatives are in closed form (Sherman–Morrison on the tridiagonal Hessian) rather than conjugate gradients. Weights enter inside the norm, (Σ wᵢ² (zᵢ₊₁ − zᵢ)²)^½, and a weight whose square underflows counts as zero fastprox.h, docs/api.md
2026-10-17 Anisotropic TV is solved by dual block methods with exact 1D TV steps (ADBPG for two axes, the three-block FDPG for three), with gradient restarts and a polish from the dual's regions, instead of parallel Douglas–Rachford or Dykstra over the axes (spec Sections 5 and 6). Measured against proxTV's parallel Dykstra, parallel DR, DR2 and Yang's ADMM, it is fastest at every accuracy in 3D and from 1e-3 on in 2D src/ops/tv_aniso.cpp, docs/benchmarks.md
2026-10-17 SCAD and MCP take per-entry weights as a new argument of fp_op_scad/fp_op_mcp (NULL for the unweighted maps; both operators are new in 0.2, so no deprecation). θ = (λ, a or b) without weights, as before, and (λ, a or b, w…) with them; unlike fp_op_soft and fp_op_l0, whose θ is the weight vector even when NULL, so that unweighted callers and the group penalties built on these maps keep their θ fastprox.h, src/ops/nonconvex.cpp
2026-10-17 The elementwise maps with kinks (soft thresholding, ℓ1 over a box, SCAD, MCP) let the caller choose the piece differentiated at a kink, through fp_workspace_set_branch, so that every element of their B-subdifferential is available; spec Section 7 keeps one documented choice and puts the full generalised Jacobian out of scope. Kinks are reported through fp_workspace_kinks, with an absolute tolerance in the input's units, and the side is in signed x. A new dtype FP_I8 serves only these two arrays fastprox.h, src/core/op.hpp, docs/api.md
2026-10-17 Graph TV: fp_op_graph_tv takes its weights as an fp_array (NULL, length 1 or m, as 1D TV) rather than the spec sketch's const double *w; it acts on the last axis like the image operators (fp_options.axis ignored), so it reports the gap and the number of max-flow solves; tol is a precision on the values, tol·(max x − min x) at every node, not a relative gap (the Python methods default to 0, exact). Derivatives are exact averages over the regions of constant z, not conjugate gradients on the dual (spec Section 7): for the ℓ1 graph TV the regions determine the Jacobian fastprox.h, src/ops/graph_tv.cpp
2026-10-18 Tree TV is a separate operator, fp_op_tree_tv, with graph TV's arguments (an edge list in any order and orientation, weights NULL, one or one per edge) rather than a parent array, and rejects edge lists that are not forests with FP_EPARAM; graph TV does not switch to it on forests by itself, so each keeps one algorithm. The heaps of the paper's Section 4.2 (two Fibonacci heaps) are pairing heaps, measured 1.3–1.6× faster than leftist heaps here; values are recomputed as region means after the pass down, so the output satisfies the derivative formula to rounding fastprox.h, src/ops/tree_tv.cpp
2026-10-18 The PyTorch and JAX wrappers are two generic functions, prox(op, x, gamma, **params) and prox_conj, taking an operator or an operator class with its constructor arguments, instead of one wrapper per operator as the spec sketch (fastprox.torch.tv1d) shows: every operator is covered at once, and a parameter's gradient is the Grads field of its name. JAX's backward recomputes the prox to rebuild the structure (a callback cannot hold it between the passes under jit), so a gradient costs two prox calls; parameters without a gradient field get NaN cotangents in JAX, which cannot tell which cotangents are wanted, and raise in PyTorch. vmap runs one call per batch element fastprox/torch.py, fastprox/jax.py, docs/api.md
2026-10-18 The device-native image TV computes its derivatives on regions found on the device, rather than by conjugate gradients on the flat regions without labels as the roadmap item put it. The label-free system (in the dual) took 2000+ iterations on 512² images; one unknown per region, as in the C kernels, takes 26–200. To keep results the same run to run, the regions use only operations that do not depend on scheduling: hooking with a scatter of minima, pointer jumping, a stable sort, and segmented scans. index_add_ on MPS gave different sums run to run. Anisotropic TV on the device is plain FISTA on the dual, without the C kernel's exact 1D steps and polish fastprox/_tv_torch.py, fastprox/_tv_jax.py
2026-10-18 Isotropic TV's derivatives cap the curvature γ/‖g_p‖ of their system at γ/μ, μ = 0.1 w_max √(2 gap / N), so they are the derivatives of a Huber-smoothed problem at the level of the certified error, exact only as the gap goes to 0 (spec Section 7 asks for the derivative on the identified structure). Uncapped, pixels on the sphere with gradients far below that error made the system stiffer as the gap shrank (18 548 iterations at a gap of 1e-13, 12 832 at a tolerance of 1e-10 on 128²); the cap cut them 1.8–3.6× with errors against the exact derivative within the ambiguity at degenerate pixels src/ops/tv_iso.cpp, fastprox/_tv_torch.py, fastprox/_tv_jax.py
2026-10-18 Isotropic TV's derivative solves default to the relative error of z that the gap certifies, √(2 gap)/‖x‖ (floor 1e-10, or max(1e-10, 100 ε) on the device), rather than a fixed residual; fp_workspace_set_deriv_tol takes 0 for this default, which is now its initial value (it was 1e-10 and 0 was rejected). Spec Section 7 asks for a user tolerance, which stays available; the default follows the accuracy of the solution being differentiated, since tighter residuals did not change the gradient fastprox.h, src/ops/tv_iso.cpp, fastprox/__init__.py, fastprox/torch.py, fastprox/jax.py
2026-10-19 Tree TV's kink masks and branch overrides go through fp_workspace_kinks and fp_workspace_set_branch with arrays of the shape of x with the last axis of length m (one entry per edge, in the edge list's order), rather than a new pair of edge functions: its kinks are edges, which have no entry of x to sit on, and the shape follows from the operator (fp_op::kink_sites). Graph TV has none yet, since on a graph with cycles the flow, which decides a kink, is not unique fastprox.h, src/ops/tree_tv.cpp, src/api/api.cpp
2026-10-19 Graph TV's kinks are judged on the flow its solver found, saved with the structure (8 bytes per edge and image), since on a graph with cycles the flow is not unique and an edge can be on its bound for one optimal flow and not another; on a forest this is tree TV's unique flow. Isotropic TV gets kink masks but no branch overrides (FP_EINVAL), which the 0.4 roadmap item listed: keeping a pixel with zero gradient apart has infinite curvature γ/‖g_p‖, which its derivative system holds only through the curvature cap, so the +1 side is not well defined there fastprox.h, src/ops/graph_tv.cpp, docs/api.md
2026-10-19 Graph TV's max-flow engine is EIBFS (Goldberg, Hed, Kaplan, Kohli, Tarjan and Werneck, ESA 2015) rather than the Boykov–Kolmogorov style engine of spec Section 4: 1.9–2.7× faster where graph TV was slowest, within 12% elsewhere. Each solve rebuilds the forests from the flow's excesses and deficits on the active parts (the paper's reset, not its incremental repair of the forests). The BK engine stays in src/maxflow/maxflow.hpp, tested and built into graph TV with -DFASTPROX_GRAPH_BK, for comparisons src/maxflow/eibfs.hpp, src/ops/graph_tv.cpp
2026-10-19 Before the freeze, fp_op_log became fp_op_log_penalty, a break in 0.x so that 1.0 does not carry both names. The documentation site is MkDocs Material on GitHub Pages rather than Sphinx: the docs are already Markdown, and mkdocstrings reads the Python docstrings fastprox.h, ROADMAP 1.0
2026-10-19 fp_value, the value \(g(x)\), is added to the C API before the freeze. The spec's API has only proxes and derivatives. The PyProximal adapter needs the value for its objective, and so does anyone monitoring a solver. The projections return their indicator, with a tolerance relative to \(\max(1, \max_i \lvert x_i \rvert)\), so that their own rounded outputs count as feasible fastprox.h, src/core/op.hpp, tests/python/test_value.py
2026-10-20 The BenchOpt solvers (spec Sections 11 and 12) move from 1.0 to after it, as optional. The TV-1D and TV-2D benchmarks have had no commits since 2024, and their own baselines no longer run with current SciPy and BenchOpt, so a contribution would likely go unreviewed and unseen. The public speed comparison of spec goal 7 is docs/benchmarks.md, against proxTV and Condat's code.
2026-10-20 Matrix prox maps (spec Section 2: "no matrix-valued prox maps", deferred to version 2 because they need an SVD) become a 1.x candidate. The caller supplies the SVD or eigendecomposition, from the framework it already uses, so the core still needs no LAPACK, BLAS or Eigen. What fastprox adds is the scalar prox on the spectrum and its exact derivatives, which autograd through an SVD gets wrong at repeated singular values. As new functions, they keep the 1.0 ABI.
2026-10-20 fp_spectral_jvp sizes its scratch (about 8k doubles per thread) on its first call and keeps it in the workspace, instead of in fp_workspace_create as the first design said. Sizing it at creation would add 16 bytes per entry to the workspace of every qualifying operator, soft thresholding on a long vector included; later calls still allocate nothing. The call also takes dparams, as fp_jvp does.
2026-10-20 The device API's details, which the spec's sketch left open. The plugin is found through FASTPROX_CUDA_PLUGIN (a path; empty turns it off), then next to the library, then on the system's search path, and is accepted only when its table's version and build string match the library's. fp_op_device_check also takes FP_DEVICE_CPU, where row_parallel_only is 1 for every operator with rows except the elementwise maps and anisotropic TV. fp_workspace_info returns the call's status as well as its fp_info, so a device call can report FP_ENOTCONV without waiting. fp_vjp_device takes a float32 or float64 scalar. The stream functions return FP_EINVAL on CPU workspaces.
2026-10-21 fp_prox_steps defines the derivatives that the spec left open. After it, fp_jvp's scalar dgamma moves every step and fp_vjp's ggamma is the sum over rows, so neither signature changes. A row's own step gradient comes from fp_jvp with dgamma = 1, summed against \(g\) over the row. The steps are saved in a buffer of one double per row, sized with the saved structure when a workspace keeps it, so prox calls still never allocate. There is no conjugate form. Elementwise maps along an axis that is not the last run one entry at a time under per-row steps, since consecutive entries belong to different rows.
2026-10-22 out may alias the input only exactly (the same data, shape and strides): any other overlap of an output's byte range with an input's, or a stride-0 output dimension of extent > 1, returns FP_EINVAL before any work (spec Section 4: "out may alias x"). The test is conservative, so disjoint interleaved views are rejected too. The same rule holds for dx/dout, g/gx, the steps of fp_prox_steps and fp_value's out. The Python package retries with a copy of the input instead, so Python callers see no change fastprox.h, src/core/layout.hpp, src/api/api.cpp, docs/api.md
2026-10-22 fp_prox_conj evaluates y − prox_g(y) for positively homogeneous g and cone indicators: exact for every σ > 0, σ-derivative 0, image duals at unit step. For the other operators it returns FP_EPARAM when 1/σ overflows or leaves the step range, or when some y_i/σ overflows: always checked in float32 for σ < 1, and in float64 only for σ < 2^-64, since a check for every σ < 1 cost 15–30% on cheap conjugates (above 2^-64, float64 entries beyond ~1e289 may give ±inf/NaN). Every call returns FP_EPARAM when γ·step_scale() > 2^960 src/api/api.cpp, src/core/op.hpp, src/core/driver.hpp, src/ops/*, fastprox.h, docs/api.md
2026-10-22 Weighted isotonic regression rejects weights with min/max below 1e-100 (FP_EPARAM), as the weighted ℓ1 ball does: the weights are stored scaled by their largest power of two, and such ratios would underflow src/ops/isotonic.cpp, fastprox.h
2026-10-23 After fp_prox_conj with σ = 0 and keep_structure, derivatives are those of the identity and the σ-derivative is NaN; kept empty batches give empty derivatives (spec: derivatives need a saved structure) src/api/api.cpp, fastprox.h, docs/api.md
2026-10-23 std::length_error is reported as FP_ENOMEM (spec: any exception other than bad_alloc is FP_EINTERNAL); integer counts of the group constructors and of tree l2 above 2^60 − 1 are FP_EPARAM src/api/api.cpp, fastprox.h, docs/spec.md
2026-10-23 fp_options.threads and the thread environment variables are capped at min(4096, 4 × the available CPUs) src/core/parallel.cpp, src/api/api.cpp, fastprox.h, docs/api.md
2026-10-23 The Python bindings release the GIL in every C call whose cost grows with its data (prox, derivatives, value, operator constructors, workspace creation, dual and kink copies); constant-time getters keep it, since releasing costs as much as the call (spec: every call into the C API) bindings/python/src/module.cpp, docs/spec.md
2026-10-23 Iterative operators on an empty batch return an empty result with gap 0 and converged true; a NaN image reports gap NaN and 0 iterations and counts as finished on every path (A8); under jax.jit an image with ±Inf is treated as a NaN image, since values cannot be checked there (the CPU, PyTorch and eager JAX paths reject it) fastprox/torch.py, fastprox/jax.py, fastprox/_tv_torch.py, fastprox/_tv_jax.py, src/api/api.cpp, docs/api.md
2026-10-23 Huber-smoothed TV, second-order TV (the Frobenius Hessian norm) and filter-bank priors with learned potentials enter the 1.x candidates, with a duality gap as for isotropic TV (spec Section 5 listed Hessian-Schatten norms as deliberately missing). TGV, ICTV and the Schatten-1 Hessian norm stay out: their prox needs a primal–dual solver whose iterates are not dual-feasible, so the certificate would not hold. The Huber function keeps the convention of fp_op_huber (Beck's H_μ, δ = μ). ICNN regularisers are not planned: they have no structure for a kernel, and DeepInverse ships one docs/spec.md (Sections 5 and 15), ROADMAP.md
2026-10-23 Bilevel algorithms (implicit, MAID-type, single-loop) are not part of fastprox: they go in a separate package built on the public API, which keeps to the cells DeepInverse's planned bilevel module leaves out (nonsmooth lower levels, single-loop coderivative adjoints, certified accuracy). fastprox adds only what needs the kernels: multipliers, structure codes, coderivative sets and their projections, and mixtures of the one-sided derivatives (spec Section 7) docs/spec.md (Sections 2 and 7), ROADMAP.md
2026-10-23 A prox call rejected for its arguments leaves the workspace's saved point; any other prox call on the workspace replaces it, or discards it when it has no keep_structure or fails during its work (the spec read "the last call with keep_structure"; the audit's A4 text had every failed call discard it, which the code did only for some arguments) src/api/api.cpp, docs/spec.md, docs/api.md, fastprox.h
2026-10-23 For graph TV, ztol maps to tol = ztol min_i ‖x_i‖ / (√n (max x_i − min x_i)), not ztol², because graph TV's tol bounds each node rather than the gap; the guarantee ‖z − z*‖ ≤ ztol ‖x‖ is the same (feedback U1 had tol = ztol² for every operator) fastprox/__init__.py, docs/api.md
2026-10-23 fp_workspace_image_info takes plain contiguous double *gaps, int *iters, double *zerrs with a count, rather than FP_F64 and FP_I32 arrays: fastprox has no FP_I32 dtype, and adding one for this call would widen the dtype enum. It also returns each image's certified error, computed in C at the scale the image was solved at, which holds where the gap overflows and costs Python no pass over x (feedback U1 had gaps and iterations only) src/api/api.cpp, src/core/driver.hpp, fastprox.h
2026-10-23 The spectral operators, fp_prox_steps and the device API (FP_DEVICE_CUDA, FP_EDEVICE, fp_device_available, fp_op_device_check, the stream setters, fp_workspace_info, fp_vjp_device), planned and documented as 1.1, ship in 1.0.0 after a second release candidate, marked "since 1.0" like the other additions since 0.5; device arrays still return FP_EINVAL until the 1.x kernels (spec Section 9 placed the device values in 1.x) CMakeLists.txt, fastprox.h, docs/api.md, CHANGELOG.md, ROADMAP.md
2026-10-23 The library builds with -ffp-contract=off on GCC and Clang from 1.0.0rc2, not from the release with the CUDA stage 1 (spec Section 8): GCC's default contraction made aarch64 Linux results depend on the thread count. On arm64 kernels cost 0–12% more; x86 is unchanged CMakeLists.txt, docs/spec.md
2026-10-23 Derivatives at a loose tolerance (feedback U4): the exactness of each image's derivative is a per-image workspace result reported by the kernel (ImageCall.exact, smoothing), not a byte in anisotropic TV's saved structure, so that graph TV reports it too; fp_workspace_refine takes an optional out and fp_info so that the caller gets the refined z; and the warning covers every inexact derivative (anisotropic and graph TV too), not isotropic TV alone. The acceptance target, a refine at under half the cost of a tight solve, holds for anisotropic TV (34 against 66 iterations) but not for isotropic TV, whose FISTA converges like 1/k²: a refine costs about a tight solve. The docs say so src/core/driver.hpp, src/api/api.cpp, fastprox.h, fastprox/__init__.py, docs/api.md, docs/spec.md
2026-10-23 The sorted ℓ1 norm reports no kinks (spec of feedback U5: "the existing kink machinery, as for isotonic regression", but isotonic regression has none): blocks with equal values stay apart and a block at 0 is thresholded, documented with the other kink rules src/ops/sorted_l1.cpp, docs/api.md
2026-10-25 Weighted isotonic regression has no conjugate (math audit M2): fp_prox_conj returns FP_EINVAL for unequal weights, against the spec's "the prox of the conjugate is computed from the prox of g" for every operator. Its fit is the projection in the metric W, where y − P(y) is not the Euclidean conjugate's prox; the Euclidean conjugate, which ignores the weights, would silently drop them. Equal weights keep it src/ops/isotonic.cpp, src/api/api.cpp, Python