CompPoly aims to be the premier formally verified library for computable polynomial operations over finite fields, serving as the mathematical foundation for zero-knowledge circuit verification. We aim to provide efficient, proven-correct implementations of univariate, multivariate, and multilinear polynomial arithmetic that seamlessly integrate with the Lean 4/Mathlib ecosystem.
- Zero
sorrys in all shipped modules. - Complete core API for
CPolynomial,CMvPolynomial,CMlPolynomial, including evaluation + interpolation + conversions. - ✅ At least one "fast path" implemented + proven correct (FFT/NTT multiplication OR fast multilinear transforms). (radix-2 NTT /
NTTFastunivariate multiplication) - Benchmarks exist for core ops and are reproducible (
lake exe CompPolyBench; CI runs benchmarks and uploads reports).
- Proof ergonomics baseline: common operations (add, mul, eval) mostly simp/grind-driven, documented.
- At least one real integration example (ArkLib or RT extraction exemplar) demonstrating use as a dependency.
- Minimal docs: README + module docs sufficient for contributors.
- CI stability: all tests pass consistently.
Goal: Establish complete mathematical foundations and close critical gaps.
-
Theoretical completeness
- ✅ Implement
nodalandinterpolatefor Lagrange interpolation - ✅ Implement
AddCommGroup/Semiring/CommSemiring/Ring/CommRinginstances forCPolynomialandQuotientCPolynomial - ✅ Prove isomorphism between
CPolynomialand Mathlib'sPolynomial(ringEquivinUnivariate/ToPoly.lean); prove forQuotientCPolynomialas needed - ✅ Prove
CommSemiringforCMvPolynomialandpolyRingEquiv(ring isomorphism with Mathlib'sMvPolynomial (Fin n) R) - ✅ Complete remaining algebraic structures (
CommRing,Algebra, scalar action /SMulZeroClass)
- ✅ Implement
-
API completeness
- ✅ Add
monomialconstructors for univariate and multivariate polynomials - ✅ Implement monomial-order baseline (
MonomialOrder.degree,leadingMonomial,leadingCoeff,leadingTerm) - ✅
degreeLT,degreeLE: Bounded-degree submodules for univariate polynomials - ✅
mem_degreeLT,mem_degreeLE: Membership characterizations for bounded-degree polynomials - ✅
degreeLTEquiv: Linear equivalence for coefficient access - ✅
restrictDegree: Degree restrictions for multilinear extensions - ✅
vars: Variable set extraction - ✅
aeval,bind₁: Algebra evaluation and substitution - ✅
algebra,module: Algebra and module structures - ✅
degrees; ✅eval₂Hom: Degree utilities and evaluation homomorphisms - ✅
finSuccEquiv: Variable manipulation equivalences (forCMvPolynomial) - ✅
partialEvalFirst: Partial evaluation fixing the first variable, with its evaluation and per-variable degree-bound lemmas - ✅
isEmptyRingEquivforCMvPolynomial 0 R - ✅
smulZeroClass: Scalar multiplication with zero behavior - ✅
sumToIter: Iteration utility with reconstruction/API lemmas - ✅ Implement
rename/renameEquivfor variable renaming
- ✅ Add
-
Further data types
- ✅ Basic field definitions (currently in Arklib) ported into CompPoly (e.g. BabyBear, Goldilocks, BN254, BLS12_381, binary tower)
- ✅ computable field extensions with interface (
CompPoly/Fields/Extension/):F[X]/ffor an arbitrary monicfwithCommRing/Field,Algebra F (Ext P)(henceModule), a base embeddingofBase, the adjoined rootgenwithaeval gen poly = 0, a ring equivalence toAdjoinRoot, and cardinalityq ^ d. BinomialsX^d - Ware the special case viaBinomialParams.toExtensionParams, keepinggen ^ d = ofBase W. Irreducibility comes from a general Rabin criterion (CompPoly/Data/Polynomial/Rabin.lean), collapsed to two base-field exponentiations for binomials and discharged by kernel-checked certificates otherwise (CompPoly/Data/Polynomial/RabinCertificate.lean, generated byscripts/gen_rabin_certificate.py), at prime and composite degree — one coprimality certificate per prime factor ofd. Concrete instances: degree-4 over BabyBear, KoalaBear, and Hachi (2^32 - 99); non-binomial degree-5 (X^5 + X^2 - 1) and degree-6 (X^6 + X^3 + 1 = Φ₉, ~2^186) over KoalaBear, the latter identified with Mathlib'sGaloisFieldinKoalaBear/Ext6/GaloisField.lean.- Tower support (
AlgebraTower) is the main interface gap:F ⊂ Ext F 2 ⊂ Ext F 4does not yet compose. The blocker is notExtensionParams— it is generic over[Field F] [Fintype F], andExt Psupplies both, so a two-level type is well-formed today — but dischargingFact (Irreducible P'.poly)over anExtbase:reduce_mod_charneeds the base asZMod <numeral>and the certificate layer is built ontoPoly : List ℕ → (ZMod p)[X]. Withnative_decideforbidden this needs a certificate layer over a non-prime base - 🔄 Performance: after routing compilation through the
Ext.redreduction table (mul_eq_mulTbl,@[csimp]),mulmeasures ~25us at degree 4 and ~64us at degree 6, withinv~3.5ms and ~15ms (lake exe CompPolyBench --small) — a 3-8x gain over the specification, growing withdas theO(d^5)→O(d^3)change predicts. Still far off a native implementation. In priority order: takeExt.mulfromO(d^3)toO(d^2)with an allocation-free array loop (schoolbook convolution to2d - 1folded throughred, withredhoisted so it is built once perPrather than per multiplication); instantiate over theFastFieldMontgomery carrier instead ofZMod; replace Fermat inversion with a norm-based (Itoh–Tsujii) inverse — neitherExt.frobeniusnorExt.normexists yet, andΦ₉was chosen partly because its Frobenius (θ ↦ θ^2) is sparse - Rebase the GHASH Rabin specialization
(
irreducible_of_rabin_128_passed_over_GF2) onto the generalPolynomial.irreducible_of_rabinso the two soundness proofs do not need parallel maintenance — the Frobenius divisibility step is already shared (irreducible_dvd_X_pow_add_X_iff_natDegree_dvd); the factor-degree argument is what is still duplicated - 64-bit-radix Montgomery layer, so
Hachigets aFastFieldbase
- Tower support (
- ✅ computable field extensions with interface (
- ✅ Polynomial-basis
GF(2^64)and its degree-3 extensionGF(2^192)(Fields/Binary/BF64/), a flat quotient by an irreducible degree-64 pentanomial rather than an iterated quadratic tower - ✅ Implement a specialized Bivariate polynomial type, e.g. as
CPolynomial (CPolynomial R)with specialized polynomial operations (that can then be optimized)
- ✅ Basic field definitions (currently in Arklib) ported into CompPoly (e.g. BabyBear, Goldilocks, BN254, BLS12_381, binary tower)
Success Criteria: Zero sorrys in core operations, all ring structures complete, clean build with no warnings, reasonable proof ergonomics.
Goal: Optimize critical operations for production use in ZK verification.
-
Fast field arithmetic
- ✅ Radix-generic Montgomery reduction shared by every fast prime field
(
Fields/Montgomery/Basic.lean) - ✅ Single-word
UInt32Montgomery carrier for 31-bit primes (Montgomery/Native32.lean,Montgomery/Native32Field.lean,Mont32Field), instantiated byBabyBear/Fast.leanandKoalaBear/Fast.lean - ✅ Eight-limb Montgomery carrier with CIOS multiplication for moduli below
2^255(Montgomery/Native64x8*.lean,Mont64x8Field), instantiated byBN254/Fast.lean,BLS12_381/Fast.lean, andBLS12_377/Fast.lean - ✅ Single-word
UInt64carriers for 64-bit and 31-bit primes outside the Montgomery bounds (Goldilocks/Fast.lean,Mersenne31/Fast.lean), reducing via the modulus identity rather than Montgomery residues - ✅ Checked binary-GCD inversion for the eight-limb fields
(
Montgomery/Native64x8Inv.lean, eprint 2020/972), benchmarked againstZModextended Euclid and Fermat infields-mont64x8-*-inv - 🔄 64-bit-radix Montgomery layer, so Goldilocks and Hachi (
2^32 - 99) gain aFastFieldbase;Mont32Fieldrequires modulus <2^31 - 🔄 Instantiate
Extension.Extover a Montgomery carrier rather thanZMod(see the extension performance notes under Phase 1)
- ✅ Radix-generic Montgomery reduction shared by every fast prime field
(
-
Polynomial multiplication
- ✅ Radix-2 NTT domain, forward/inverse transforms, and reference fast multiply (
Univariate/NTT/) - ✅ NTT-based
fastMulImpl/safeFastMul/withFallbackwith full correctness proofs (NTT/FastMul) - ✅ Concrete NTT domains for BabyBear and KoalaBear (
NTT/BabyBear,NTT/KoalaBear) - ✅ Low-product multiplication via NTT (
NTT/FastMulLow) - ✅ Optimized
NTTFastpath: cached twiddle plans, DIF/radix-4 stages, paired forward transforms, refinement proofs vsNTT(Univariate/NTTFast/) - ✅ Pluggable multiply backends for batch algorithms (
BatchEval/Context:MulContext.ntt,MulContext.nttFast) - 🔄 Additional concrete domains and field-specific tuning beyond BabyBear/KoalaBear
- ✅ Radix-2 NTT domain, forward/inverse transforms, and reference fast multiply (
-
Exponentiation optimization
- ✅ Replace repeated multiplication with repeated squaring
- ✅ Reduce complexity from O(n) to O(log n) multiplications
-
Evaluation optimizations
- ✅ Batch evaluation at multiple points: naive, Horner, and subproduct-tree algorithms (
Univariate/BatchEval/) - ✅ Subproduct-tree batch eval with configurable multiply/remainder backends (naive, NTT, NTTFast)
- ✅ Add Horner's method where beneficial
- ✅ Many-polynomial, one-shared-point evaluation — the common commitment-opening
shape — with correctness proofs (
Univariate/ManyEval/,Multilinear/ManyEval/) - 🔄 Optimize for further common ZK evaluation patterns
- ✅ Batch evaluation at multiple points: naive, Horner, and subproduct-tree algorithms (
-
Complete multilinear transform functions
- ✅ Complete documentation of zeta/Möbius transform formulas
- ✅ Prove equivalence between fast and spec implementations
- 🔄 Add performance guarantees and complexity proofs (done in comments, formal benchmarking still TODO)
-
Benchmarking
- ✅ Basic, reproducible evaluation benchmark executable (
lake exe CompPolyBench; seebench/README.md) - ✅ CI build/run with artifact upload (GitHub Actions
lean_action_ci.yml) - ✅ Operation-level coverage: base-field
mul/add/inv/powover KoalaBear, BabyBear, Mersenne31 and Goldilocks, the eight-limb Montgomery multiply, the binary tower's table-driven kernels, the standalone multiplicative NTT overn = 2^8 … 2^16, Reed-Solomon encoding, and the schoolbook/NTT crossover. Field and kernel rows are chained and reported per operation, latency and throughput separately; seedocs/wiki/benchmarking.md - ✅ Same-machine A/B comparison of two builds (
CompPolyBench --compare, driven byscripts/bench-ab.sh), the measurement behind the optimisation loop indocs/wiki/autoresearch.md - ✅ Published performance baselines:
docs/wiki/benchmark-best-times.mdrecords the current best time of every benchmarked component, refreshed by each optimisation pass - 🔄 A measured comparison against a pinned external implementation
(
docs/bench-audit-2026.md§13)
- ✅ Basic, reproducible evaluation benchmark executable (
-
Bivariate polynomial operations
- ✅ Optimize the existing bivariate polynomial type
CPolynomial (CPolynomial R): Kronecker substitution (Bivariate/Kronecker.lean) turns a bivariate multiplication into a single univariate one (kroneckerPack_mul,kroneckerUnpack_mul), with linear-timekroneckerPackFast/kroneckerUnpackFastproved equal to the spec versions and NTT-backedkroneckerUnpack_withFallback. Benchmarked asbivariate-full-*. The nested representation was kept; no more specialized one proved necessary. - 🔄 Efficient factorization algorithms for bivariate polynomials. What exists
is linear-factor deflation rather than general factorization:
Bivariate/Factor.leandefinesdivByLinearY(the computable factor theorem, over anyCommRing) andBivariate/FactorMonic.leanprovesdivByLinearY_eq_divByMonic, tying it to general monic Euclidean division. Benchmarked asbivariate-deflate-*. - ✅ Integration with existing
CMvPolynomial 2 Rwith equivalence proofs
- ✅ Optimize the existing bivariate polynomial type
-
Error-correcting interpolation algorithms
- ✅ Reed-Solomon encoding through the forward NTT
(
Univariate/ReedSolomon/NTTEncode.lean):forwardImpl_eq_encodeandnttCodeword_eq_encodeidentify theO(n log n)transform withReedSolomon.encodeexactly, with no padding required - ✅ Unique decoding via Gao's key-equation decoder
(
ReedSolomon/GaoDecoder.lean, [Gao02]) withGaoCorrectness.lean:decode_sound,decode_eq_some,decode_eq_none_iff, anddecode_none_farness, which reads decoder refusal as a farness certificate - ✅ Implement Guruswami-Sudan list-decoding algorithm
(
Bivariate/GuruswamiSudan/), following the interpolation-and-root-finding decomposition of [GS99]: a backend-parametricCore/Contextwith dense, Lee-O'Sullivan ([LOS06]), approximant-basis (PM-Basis), and hybrid interpolation, plus Roth-Ruckenstein ([RR00]) and Alekhnovich ([Ale05]) root search, instantiated inImplementationsandExecutable - ✅ Proofs of correctness:
gsCore_sound,gsCore_complete_of_interpolate, andgsCore_complete_of_roots_all_valid_witnessesinCoreCorrectness.lean, stated against the context contracts so they hold for every backend - Berlekamp-Welch decoding. Gao's decoder already covers the same unique-decoding regime, so this is worth adding only as a cross-check, or if a downstream specification asks for it by name.
- Integration with FRI commitments and polynomial commitment schemes
- ✅ Reed-Solomon encoding through the forward NTT
(
-
Univariate root finding
- ✅ Backend-parametric root pipeline (
Univariate/Roots/): theBackend,Context, andSplitterinterfaces, candidate extraction / validation / deduplication (Extraction.lean),RootProduct.lean, andCorrectness.lean - ✅ Smooth multiplicative-subgroup refinement splitting for finite fields whose
multiplicative group admits a smooth schedule ([MOV92],
Roots/SmoothSubgroup/), benchmarked asunivariate-roots-finite-field-* - ✅ Shoup-style small-characteristic trace splitting ([vzGS92],
Roots/Shoup/) and bounded Las Vegas Cantor–Zassenhaus (Roots/LasVegas/, odd-char and char-2 trace branches with probability proofs) for fields without a smooth refinement schedule - 🔄 Named high-width binary-tower
SmallPrimeTraceContextinstances (32/64) and optional GF(2^{48})/GF(2^{72}) carriers for production char-2 benches
- ✅ Backend-parametric root pipeline (
-
Computable linear algebra
- ✅ Dense row-major matrices with row operations, RREF shape and semantics, and
kernel extraction, each with a
*Correctness.leancompanion (LinearAlgebra/Dense/) - ✅ In-place kernel solver (
Dense/KernelInPlace.lean) with correctness, used by the dense Guruswami-Sudan interpolation backend - ✅ Full homogeneous-kernel basis contract: soundness, completeness, and
free-column independence (
Dense/KernelBasisCorrectness.lean), shared with the PM-basis leaf through the row-array kernel (Dense/RowArray*.lean) - ✅ Polynomial matrices with shifted degrees and row spans, plus
Mulders-Storjohann shifted row reduction ([MS03],
LinearAlgebra/PolynomialMatrix/). The fast variants are proved extensionally equal to the direct ones inMuldersStorjohannCorrectness/Fast.lean, so every correctness result transfers. - ✅ Order-basis (approximant) layer over polynomial matrices
(
PolynomialMatrix/Approximant/): modular key equations, the divide-and-conquer PM-Basis recursion with X-adic soundness and kernel-leaf completeness, and partial linearization, alongside supporting row selection, minimal weak-Popov forms, and Strassen multiplication used by the recursion.
- ✅ Dense row-major matrices with row operations, RREF shape and semantics, and
kernel extraction, each with a
Success Criteria: notable speedup for large polynomial operations, verified correctness, benchmarks demonstrating competitive performance with industry-standard implementations.
Goal: Turn CompPoly into an integration-ready, downstream-friendly library by adding interoperability layers, serialization, proof automation, and extraction compatibility.
-
Lowering / interop with LLZK / PrimeIR polynomial dialects
- Explore representing CompPoly structures in the MLIR pipeline
- Evaluate tradeoffs: “fast Lean code” vs “Lean spec + lowering to fast backend”
- Goal: enable verification of PrimeIR/LLZK polynomial implementations against CompPoly semantics
-
Serialization (bytes/JSON/protocol/hashing)
- ✅ Byte formats for every field carrier and polynomial representation
(
docs/wiki/serialization.md):CanonicalNatandByteCodecfor fixed-width types (CompPoly/Data/Bytes/), little-endian canonical integers in the arkworks/plonky3 layout, with every fast carrier proved to encode identically to its spec field;DelimitedCodecfor variable-length types withu64framing, soCPolynomial,CMvPolynomial, andCBivariateserialize and nest, and↥(degreeLT n),CMlPolynomial, andExthave fixed-width codecs for protocol messages - ✅ ArkLib's
Serialize/Deserialize/Serde/HasSizeclasses live inCompPoly/Data/Classes/with instances for every type above, each withdeserialize (serialize x) = some xand injectivity; the reduce-modulo-order challenge decoder comes with its exact fiber count and total-variation bound (CompPoly/Data/Bytes/Bias.lean), from which ArkLib derivesCloseToUniform - JSON (hex strings of the same bytes, via
Lean.Json) only when a consumer asks; no customer today
- ✅ Byte formats for every field carrier and polynomial representation
(
-
FFT-based interpolation variants (post-FFT/NTT)
- ✅ Interpolation on an NTT domain:
NTT.interpolateand the plannedNTTFast.Plan.interpolate, which reuses the plan's cached twiddles, take natural-order values to aCPolynomialinO(n log n).interpolate_eq_interpolatePowproves both equal to the specCLagrange.interpolatePow(Univariate/NTT/Interpolation.lean,NTTFast/Interpolation.lean) - ✅ Coset transforms for low-degree extension on
g·⟨ω⟩(NTT/Coset.lean), andNTTFast.CosetPlanwith the powersgⁱ,g⁻ⁱcached (NTTFast/Coset.lean): forward evaluation, inverse, and interpolation, withinterpolate_eq_interpolateagainst Lagrange on the nodesg·ωᵏ - ✅ Fast barycentric interpolation over a fixed node set:
BarycentricDomain.mk'stores its weights instead of recomputing anO(n)product per access, andevalcompiles to a single-division fold (eval_eq_evalFast,@[csimp]). On an NTT domain the weights have the closed formωⁱ/n(NTT.Domain.barycentric, fromnodal_eq_X_pow_sub_one), so setup isO(n)rather thanO(n²) - ✅ Nodes that are not a power-of-two subgroup:
interpolateSubproductinterpolates on arbitrary distinct nodes through the existing subproduct tree,O(M(n) log n)with an NTT-backedMulContext.interpolateSubproduct_eq_interpolateArraysproves it equal to Lagrange (Univariate/BatchEval/Interpolation.lean). Zero-padding is not an interpolation strategy, since there are no values at the padded points. Domain-size mismatches are type errors, because values are aVector R D.n - ✅ Consumer: Gao's decoder on an NTT domain uses
Xⁿ - 1and the inverse NTT (ReedSolomon/GaoNTT.lean:decodeNTT,decodePlan).decodeNTT_eq_decodetransfers every correctness theorem - ✅ Benchmarked (
univariate-interp-*,univariate-barycentric-*,rs-gao-decode-*). Atn = 2^12planned interpolation takes 0.19 ms against 0.86 ms unplanned and 190 ms through the subproduct tree. At2^8, an off-node barycentric query including setup takes 20 µs against 8 ms throughmk'. At2^6, Gao decoding takes 2.1 ms against 7.7 ms. The same pass replacedbitRevNat's shifts with* 2// 2/% 2in compiled code (bitRevNat_eq_bitRevNatFast). That speeds up the reference radix-2 forward and inverse transforms 7.5× and 3.4×, and the certified RS encoder 6.7× - Mixed-radix NTT for subgroups whose order is not a power of two: not planned without a consumer. The subproduct tree already covers such node sets
- ✅ Interpolation on an NTT domain:
-
Proof ergonomics: simp/grind sets + tactics
- 🔄 Identify rewrite bottlenecks when porting Mathlib poly proofs → CompPoly. Recorded in
docs/wiki/representations-and-bridges.md:CPolynomialnames shadowing Mathlib's insidenamespace CPolynomial,import allexposure fortoPoly/Raw.coeff, theCPolyvsCompPolynamespace split, and coreVectorinstances taking over+onCMlPolynomial - ✅ Univariate simp and grind sets. The push lemmas (
toPoly_add,toPoly_mul,C_toPoly,X_toPoly,derivative_toPoly, …) and a complete evaluation set (eval_zero,eval_add,eval_X,eval_pow, …, withevalHom,eval_sumandeval_prod) are@[simp, grind =], matching the multivariate set. Baresimporgrindnow closes routinetoPolyandevalgoals, andtoPoly_inj.mp (by simp)transfers an equation to Mathlib (tests/CompPolyTests/Univariate/Ergonomics.lean) - ✅ The same for the other families. The bivariate
toPolytransport andbivariateEquiv_*are@[simp, grind =], and multilineareval_{zero,add,smul}are@[simp]for both the coefficient and evaluation forms - ✅
toPolyis the coercionCPolynomial R → Polynomial R, with the push lemmas and cast-orientedeval/coeff/degree/natDegree/leadingCoefflemmas taggednorm_cast. Mathlib'snatDegree_mul,leadingCoeff_mul,degree_add_leandnatDegree_powtransfer toCPolynomialin oneexact_mod_castline. Statements that mentionCorXneed apush_caststep first - ✅ A
CPolynomialdegree API (degree_mul,natDegree_pow,leadingCoeff_mul,degree_X_sub_C, the add/sub/mul/pow bounds, …), each transferred from Mathlib in one line, with Mathlib's@[simp]attributes. It replaces 17 localcpoly_*helpers in the Guruswami-Sudan and Mulders-Storjohann proofs - Goal: “one-liner conversions” (or near) between spec polynomials and computable
polynomials. Met for degree and coefficient facts through
exact_mod_cast; seedocs/wiki/representations-and-bridges.md
- 🔄 Identify rewrite bottlenecks when porting Mathlib poly proofs → CompPoly. Recorded in
-
Integration with ArkLib / Hax + Rust libraries (e.g. plonky3)
- Make CompPoly the canonical polynomial backend for ArkLib specs where applicable
- Add bridging lemmas and conversion utilities across representations (CompPoly ↔ Mathlib ↔ extracted Rust ↔ downstream libs)
- Document and implement invariants required for robust interop (canonical ordering, normalization, domain metadata)
- Ensure hax-extracted Rust polynomial structures can be mapped into CompPoly with minimal proof overhead
- Validate the integration with at least one downstream example (e.g. ArkLib protocol component or plonky3 polynomial routine)
Success criteria: CompPoly is integration-ready—it supports canonical serialization, has strong simp/grind-based proof ergonomics, includes a validated interop pathway with LLZK/PrimeIR-style representations, and demonstrates at least one end-to-end Rust extraction → Lean translation → refinement proof against CompPoly.
Goal: Ensure seamless integration, excellent developer experience, and production readiness.
-
Documentation & examples
- Comprehensive module-level documentation
- Usage examples for common ZK verification patterns
- Performance characteristics guide
- Best practices documentation
-
Performance benchmarking suite
- Property-based tests/proofs of correctness for all operations
- Performance benchmarks and regression tests
- Edge case coverage
-
Integration with ArkLib and other libraries
- Ensure all equivalences are proven and documented
- Add conversion utilities and compatibility layers
- Seamless integration with Verified-zkEVM ecosystem
-
Developer experience & community
- Consistent API design patterns
- Helpful error messages
- Type aliases for common use cases
- Advanced optimizations based on usage patterns
- Community feedback and refinements
Success Criteria: Excellent documentation, comprehensive test coverage, smooth integration with Arklib, active community adoption, etc.
- Mathematical completeness: Zero
sorrys in core operations, all ring structures proven, formal verification of correctness properties - Performance: Competitive with unverified implementations for large polynomials (target: within 2x of optimized C/Rust implementations for degree ≥ 10⁴)
- API completeness: Full feature parity with Mathlib's
PolynomialandMvPolynomialAPIs, plus ZK-specific extensions - Usability: Complete documentation with examples, clear integration guides, beginner-friendly tutorials
- Adoption: Seamless integration with Verified-zkEVM ecosystem, adoption by ZK protocol implementations, community contributions
- Research impact: Foundation for formally verified ZK systems, potential for academic publications on verified polynomial arithmetic
Last updated: September 2026