Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
14 changes: 14 additions & 0 deletions CompPoly/Data/Array/Lemmas.lean
Original file line number Diff line number Diff line change
Expand Up @@ -268,3 +268,17 @@ lemma popWhile_nil_or_last_false (p : α → Bool) (as : Array α)
· simp_all +decide [ Array.getLast ]

end Array

namespace Nat

/-- A `Nat.fold` that pushes `e k h` at step `k` appends `e 0 _, …, e (n - 1) _` to its initial
array. The pushed element can depend on the proof `h : k < n`. -/
theorem fold_push_eq_append_ofFn {α : Type*} {n : ℕ} (e : (k : ℕ) → k < n → α)
(init : Array α) :
n.fold (fun k h acc ↦ acc.push (e k h)) init = init ++ Array.ofFn fun k : Fin n ↦ e k k.2 := by
induction n generalizing init with
| zero => simp
| succ n ih =>
rw [Nat.fold_succ, ih (fun k h ↦ e k (by omega)), Array.ofFn_succ, Array.push_append]; rfl

end Nat
2 changes: 1 addition & 1 deletion CompPoly/Univariate/README.md
Original file line number Diff line number Diff line change
Expand Up @@ -19,7 +19,7 @@ on top (root finding and Reed-Solomon coding).

- **Raw.lean** — Umbrella import for the raw array-backed representation and its split implementation files.
- **Raw/Core.lean** — Raw datatype and core operations (`coeff`, `C`, `X`, `monomial`, `trim`, `degree`, `eval`).
- **Raw/Ops.lean** — Raw algebraic operations and related operational lemmas.
- **Raw/Ops.lean** — Raw algebraic operations and related operational lemmas. Compiled code computes `mulRaw` with `mulRawFast`, through the `@[csimp]` lemma `mulRaw_eq_mulRawFast`.
- **Raw/Division.lean** — Raw polynomial division APIs (`divByMonic`, `modByMonic`, `div`, `mod`). Only `[BEq R]` is shared at section scope; the monic-division definitions need just `[CommRing R]`.
- **Raw/Modular.lean** — Raw modular arithmetic.
- **Raw/Context.lean** — Raw-level algorithm dictionaries backing the canonical contexts.
Expand Down
206 changes: 200 additions & 6 deletions CompPoly/Univariate/Raw/Ops.lean
Original file line number Diff line number Diff line change
@@ -1,8 +1,8 @@
/-
Copyright (c) 2025 CompPoly. All rights reserved.
Copyright (c) 2025 CompPoly, 2026 ArkLib Contributors. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Quang Dao, Gregor Mitscha-Baude, Derek Sorensen, Desmond Coles,
Natalie Klaus, Dimitris Mitsios
Natalie Klaus, Dimitris Mitsios, Alexander Hicks
-/
module

Expand All @@ -12,7 +12,14 @@ public import CompPoly.Univariate.Raw.Core
/-!
# Raw Univariate Polynomial Operations

Operations and evaluation lemmas for raw computable univariate polynomials.
Operations and evaluation lemmas for raw computable univariate polynomials. The file also states
the sizes of `smul`, `mulPowX`, `addRaw` and `mulRaw`, and the coefficients of `addRaw`, of a
shifted `smul` and of `mulRaw`. It defines `mulRawFast`, a loop for `mulRaw` that computes each
entry of the result as one sum. The `@[csimp]` lemma `mulRaw_eq_mulRawFast` makes compiled code
compute `mulRaw` with `mulRawFast`.

`size_smul`, `size_mulPowX`, `size_addRaw` and `size_mulRaw` were ported from ArkLib's raw-size
adapter under Apache 2.0. The file header records their copyright.
-/

public section
Expand Down Expand Up @@ -110,15 +117,201 @@ end MulPowXDefs

The partial sums are combined with the untrimmed `addRaw`, so the result may carry
trailing zeros and should be trimmed for canonical form. Deferring the trim to the
end (see `mul`) avoids an `O(size)` scan after every partial sum. -/
end (see `mul`) avoids an `O(size)` scan after every partial sum.

Compiled code computes `mulRaw` with `mulRawFast` (see `mulRaw_eq_mulRawFast`). -/
@[inline, specialize]
def mulRaw [Semiring R] (p q : CPolynomial.Raw R) : CPolynomial.Raw R :=
p.zipIdx.foldl (fun acc ⟨a, i⟩ => acc.addRaw <| (smul a q).mulPowX i) (mk #[])

section SizeCoeffLemmas

/-! ### Sizes and coefficients of the operations in `mulRaw`

The sizes count the stored coefficients, including trailing zeros. -/

/-- Scalar multiplication preserves the stored coefficient count. -/
@[simp]
theorem size_smul [Mul R] (x : R) (p : CPolynomial.Raw R) :
(smul x p).size = p.size := by
simp only [smul, Array.size_map]

/-- Multiplication by `X^i` retains all of the prepended zero coefficients. -/
@[simp]
theorem size_mulPowX [Zero R] (i : Nat) (p : CPolynomial.Raw R) :
(mulPowX i p).size = i + p.size := by
simp only [mulPowX, Array.size_append, Array.size_replicate]

/-- Padded raw addition stores the larger input size. -/
@[simp]
theorem size_addRaw [Zero Q] [Add Q] {p q : CPolynomial.Raw Q} :
(addRaw p q).size = max p.size q.size := by
simp only [addRaw, Array.size_zipWith, Array.size_rightpad]
omega

/-- Coefficient `i` of `addRaw p q` is the sum of coefficient `i` of `p` and of `q`. -/
theorem add_coeff? [AddZeroClass Q] (p q : CPolynomial.Raw Q) (i : ℕ) :
(addRaw p q).coeff i = p.coeff i + q.coeff i := by
by_cases hi : i < (addRaw p q).size
· rw [coeff, ← Array.getElem_eq_getD (h := hi)]
simp only [addRaw, mk, Array.getElem_zipWith, Array.rightpad_getElem_eq_getD]
· rw [size_addRaw, not_lt, max_le_iff] at hi
simp [coeff, Array.getD_eq_getD_getElem?, hi.1, hi.2]

/-- Coefficient `k` of `smul a q` shifted by `i` places: `0` below `i`, and `a * q.coeff (k - i)`
from `i` on. -/
theorem smul_mulPowX_coeff [MulZeroClass R] (a : R) (q : CPolynomial.Raw R) (i k : ℕ) :
((smul a q).mulPowX i).coeff k = if k < i then 0 else a * q.coeff (k - i) := by
simp only [mulPowX, smul, mk, coeff, Array.getD_eq_getD_getElem?, Array.getElem?_append,
Array.size_replicate, Array.getElem?_replicate, Array.getElem?_map]
split_ifs
· rfl
· cases q[k - i]? <;> simp

/-- Raw multiplication retains every shifted row, including padding from an empty right array. -/
theorem size_mulRaw [Semiring R] (p q : CPolynomial.Raw R) :
(mulRaw p q).size = if p.size = 0 then 0 else q.size + p.size - 1 := by
unfold mulRaw
have h := Array.foldl_induction (as := p.zipIdx)
(motive := fun i (acc : CPolynomial.Raw R) ↦ acc.size = if i = 0 then 0 else q.size + i - 1)
(init := mk #[]) (by rfl)
(f := fun acc ai ↦ acc.addRaw ((smul ai.1 q).mulPowX ai.2)) ?_
· simpa only [Array.size_zipIdx] using h
· intro i acc ih
have hz : (p.zipIdx)[i].2 = i.val := by
change ((p.zipIdx)[i.val]'i.isLt).2 = i.val
rw [Array.getElem_zipIdx]
exact Nat.zero_add _
simp only [size_addRaw, size_mulPowX, size_smul]
rw [hz, ih]
by_cases hi : i.val = 0
· simp [hi]
· simp [hi]
omega

/-- Coefficient `k` of `mulRaw p q` is the convolution sum of the coefficients of `p` and `q`. -/
theorem coeff_mulRaw [Semiring R] (p q : CPolynomial.Raw R) (k : ℕ) :
(mulRaw p q).coeff k =
∑ i ∈ Finset.range p.size, if k < i then 0 else p.coeff i * q.coeff (k - i) := by
unfold mulRaw
have h := Array.foldl_induction (as := p.zipIdx)
(motive := fun n (acc : CPolynomial.Raw R) ↦ ∀ k, acc.coeff k =
∑ i ∈ Finset.range n, if k < i then 0 else p.coeff i * q.coeff (k - i))
(init := mk #[]) (fun k ↦ by simp)
(f := fun acc ai ↦ acc.addRaw ((smul ai.1 q).mulPowX ai.2)) ?_
· simpa only [Array.size_zipIdx] using h k
· intro i acc ih k
have hz : (p.zipIdx)[i] = (p.coeff i, i.val) := by
change (p.zipIdx)[i.val]'i.isLt = _
rw [Array.getElem_zipIdx, zero_add, Array.getElem_eq_getD 0]
rw [hz, add_coeff?, ih, smul_mulPowX_coeff, Finset.sum_range_succ]

end SizeCoeffLemmas

section MulRawFast

/-! ### Compiled raw multiplication

`mulRawFast` computes the same array as `mulRaw`. The `@[csimp]` lemma `mulRaw_eq_mulRawFast`
makes compiled code use it. The lemma comes before `mul` and the other definitions in this file
that use `mulRaw`. When the compiler compiles such a definition, it inlines or specializes `mulRaw`
into the code. A `@[csimp]` lemma later in the file would not change that code. -/

/-- Raw multiplication that computes each entry of the result as one sum.

The result is empty when `p` is empty. Otherwise it has `q.size + p.size - 1` entries, as in
`mulRaw`. Entry `k` is the sum of the products `p[i] * q[k - i]` over the indices `i` with
`k + 1 - q.size ≤ i < min (k + 1) p.size`, added to `0` in increasing order of `i`. Each pair
`(i, j)` with `i < p.size` and `j < q.size` occurs in exactly one entry, so the loop makes
`p.size * q.size` multiplications and the same number of additions. -/
@[specialize]
def mulRawFast [inst : Semiring R] (p q : CPolynomial.Raw R) : CPolynomial.Raw R :=
-- Structure projections of `inst`. The default instances construct `Distrib R` and
-- `MulZeroClass R` values. Code specialized at a carrier whose instance the compiler cannot
-- unfold, such as `ZMod n`, would construct them in every iteration of the loop. The proofs
-- do not need these lines. A check in `CompPolyTests.Univariate.RawMul` fails without them.
letI : Zero R := inst.toAddCommMonoid.toAddMonoid.toZero
letI : Add R := inst.toAddCommMonoid.toAddMonoid.toAdd
letI : Mul R := inst.toMonoid.toMul
if p.size = 0 then mk #[] else
(q.size + p.size - 1).fold (fun k _ acc ↦
let lo := k + 1 - q.size
let hi := min (k + 1) p.size
acc.push ((hi - lo).fold
(fun t ht s ↦ s + p[lo + t]'(by omega) * q[k - (lo + t)]'(by omega)) 0))
(Array.emptyWithCapacity (q.size + p.size - 1))

/-- For a nonempty `p`, `mulRawFast p q` is the array of the entry sums. -/
private theorem mulRawFast_eq_ofFn [Semiring R] {p : CPolynomial.Raw R} (q : CPolynomial.Raw R)
(hp : p.size ≠ 0) :
mulRawFast p q = Array.ofFn fun k : Fin (q.size + p.size - 1) ↦
(min (k.val + 1) p.size - (k.val + 1 - q.size)).fold (fun t _ s ↦
s + p.getD (k.val + 1 - q.size + t) 0 *
q.getD (k.val - (k.val + 1 - q.size + t)) 0) 0 := by
simp only [mulRawFast, hp, ↓reduceIte]
rw [Nat.fold_push_eq_append_ofFn, Array.emptyWithCapacity_eq, Array.empty_append]
congr! 3 with k
funext t _ s
rw [Array.getElem_eq_getD 0, Array.getElem_eq_getD 0]

/-- A `Nat.fold` that adds `g t` at step `t`, from `0`, computes the sum of the `g t`. -/
private theorem natFold_add_eq_sum [AddCommMonoid R] (n : ℕ) (g : ℕ → R) :
n.fold (fun t _ acc ↦ acc + g t) 0 = ∑ t ∈ Finset.range n, g t := by
induction n with
| zero => simp
| succ n ih => rw [Nat.fold_succ, ih, Finset.sum_range_succ]

/-- The convolution sum over `i < p.size` is the sum over the indices `i` whose products land in
entry `k`. -/
private theorem sum_range_ite_eq_sum_Ico [Semiring R] (p q : CPolynomial.Raw R) (k : ℕ) :
(∑ i ∈ Finset.range p.size, if k < i then 0 else p.coeff i * q.coeff (k - i)) =
∑ i ∈ Finset.Ico (k + 1 - q.size) (min (k + 1) p.size), p.coeff i * q.coeff (k - i) := by
have hsub : Finset.Ico (k + 1 - q.size) (min (k + 1) p.size) ⊆ Finset.range p.size :=
fun i hi ↦ by simp only [Finset.mem_Ico, Finset.mem_range] at hi ⊢; omega
rw [← Finset.sum_subset hsub]
· refine Finset.sum_congr rfl fun i hi ↦ ?_
simp only [Finset.mem_Ico] at hi
simp [show ¬k < i by omega]
· intro i hi hi'
simp only [Finset.mem_Ico, Finset.mem_range, not_and_or, not_le, not_lt] at hi hi'
split_ifs with hk
· rfl
· have : q.size ≤ k - i := by omega
simp [this]

/-- `mulRawFast p q` is empty when `p` is empty. Otherwise it has `q.size + p.size - 1` entries. -/
@[simp]
theorem size_mulRawFast [Semiring R] (p q : CPolynomial.Raw R) :
(mulRawFast p q).size = if p.size = 0 then 0 else q.size + p.size - 1 := by
by_cases hp : p.size = 0
· simp [mulRawFast, hp]
· simp [mulRawFast_eq_ofFn q hp, hp]

/-- Entry `k` of `mulRawFast p q` is the convolution sum of the coefficients of `p` and `q`. -/
@[simp]
theorem getElem_mulRawFast [Semiring R] (p q : CPolynomial.Raw R) (k : ℕ)
(hk : k < (mulRawFast p q).size) :
(mulRawFast p q)[k] =
∑ i ∈ Finset.range p.size, if k < i then 0 else p.coeff i * q.coeff (k - i) := by
have hp : p.size ≠ 0 := by rw [size_mulRawFast] at hk; split_ifs at hk <;> omega
simp only [mulRawFast_eq_ofFn q hp, Array.getElem_ofFn]
rw [natFold_add_eq_sum, sum_range_ite_eq_sum_Ico, Finset.sum_Ico_eq_sum_range]

/-- `mulRaw` equals `mulRawFast`. As a `@[csimp]` lemma, it makes compiled code use
`mulRawFast`. -/
@[csimp]
theorem mulRaw_eq_mulRawFast : @mulRaw = @mulRawFast := by
funext R _ p q
refine Array.ext (by simp only [size_mulRaw, size_mulRawFast]) fun k h _ ↦ ?_
simp only [← Trim.coeff_eq_getElem h, coeff_mulRaw, getElem_mulRawFast]

end MulRawFast

/-- Multiplication using the naive `O(n²)` algorithm: `Σᵢ (aᵢ * q) * X^i`.

Trims only once, at the end of the convolution fold, rather than after every
partial sum (`mulRaw` does the untrimmed accumulation). -/
partial sum (`mulRaw` does the untrimmed accumulation). Compiled code computes the product with
`mulRawFast` (see `mulRaw_eq_mulRawFast`). -/
@[inline, specialize]
def mul [Semiring R] [BEq R] (p q : CPolynomial.Raw R) : CPolynomial.Raw R :=
(mulRaw p q).trim
Expand All @@ -131,7 +324,8 @@ def pow [Semiring R] [BEq R] (p : CPolynomial.Raw R) (n : Nat) : CPolynomial.Raw

/-- Repeated-squaring core that accumulates with the untrimmed `mulRaw`, deferring
the canonicalization trim to the outer `powBySq` wrapper. The output may carry
trailing zeros and is not in canonical form.
trailing zeros and is not in canonical form. Compiled code computes each product with
`mulRawFast`.

For $ n > 0 $, computes $ p ^ n $ by recursing on $ n / 2 $:
* If $ n $ is even: $ (p ^ {n/2})^2 $
Expand Down
15 changes: 0 additions & 15 deletions CompPoly/Univariate/Raw/Proofs.lean
Original file line number Diff line number Diff line change
Expand Up @@ -78,16 +78,6 @@ theorem add_coeff {p q : CPolynomial.Raw Q} {i : ℕ} (hi : i < (addRaw p q).siz
by_cases hi' : i < p.size <;> by_cases hi'' : i < q.size <;>
simp_all [Array.rightpad_getElem_eq_getD]

theorem add_coeff? (p q : CPolynomial.Raw Q) (i : ℕ) :
(addRaw p q).coeff i = p.coeff i + q.coeff i := by
rcases (Nat.lt_or_ge i (addRaw p q).size) with h_lt | h_ge
· rw [← add_coeff h_lt]
exact (Array.getElem_eq_getD (h := h_lt) 0).symm
have h_lt' : i ≥ max p.size q.size := by simpa only [size_addRaw] using h_ge
have h_p : i ≥ p.size := by omega
have h_q : i ≥ q.size := by omega
simp [h_p, h_q]

lemma add_coeff_trimmed [LawfulBEq R] (p q : CPolynomial.Raw R) (i : ℕ) :
(p + q).coeff i = p.coeff i + q.coeff i := by
have h_add : p + q = (p.addRaw q).trim := by rfl
Expand Down Expand Up @@ -731,11 +721,6 @@ lemma smul_monomial_one_trim [DecidableEq R] [LawfulBEq R]
(trim_replicate_zero (R := R) (n + 1))
· exact Trim.push_trim (Array.replicate n 0) r h

lemma smul_mulPowX_coeff [LawfulBEq R] (a : R) (q : CPolynomial.Raw R) (i k : ℕ) :
((smul a q).mulPowX i).coeff k = if k < i then 0 else a * q.coeff (k - i) := by
convert mulPowX_coeff' (smul a q) i k using 1
rw [ smul_coeff ]

lemma mul_coeff_list [LawfulBEq R] (p q : CPolynomial.Raw R) (k : ℕ) :
(p * q).coeff k = (p.zipIdx.toList.map
(fun ⟨a, i⟩ => if k < i then 0 else a * q.coeff (k - i))).sum := by
Expand Down
46 changes: 4 additions & 42 deletions CompPoly/Univariate/Raw/Size.lean
Original file line number Diff line number Diff line change
Expand Up @@ -13,8 +13,10 @@ public import CompPoly.Univariate.Raw.Ops

These bounds concern stored coefficient arrays, including trailing zero coefficients.
Raw multiplication retains the padding of its shifted rows even when the right input is empty.
The scalar, shift and product facts were ported from ArkLib's raw-size adapter under Apache 2.0;
its original copyright attribution is retained.
`CompPoly.Univariate.Raw.Ops` states the size equations of `smul`, `mulPowX`, `addRaw` and
`mulRaw`, next to the operations. This module imports it publicly. The product bound
`size_mulRaw_le` was ported from ArkLib's raw-size adapter under Apache 2.0. The file header keeps
its original copyright attribution.
-/

public section
Expand All @@ -26,50 +28,10 @@ namespace CompPoly.CPolynomial.Raw
theorem size_C {R : Type*} (x : R) : (C x).size = 1 := by
rfl

/-- Scalar multiplication preserves the stored coefficient count. -/
@[simp]
theorem size_smul {R : Type*} [Mul R] (x : R) (p : Raw R) :
(smul x p).size = p.size := by
simp only [smul, Array.size_map]

/-- Multiplication by `X^i` retains all of the prepended zero coefficients. -/
@[simp]
theorem size_mulPowX {R : Type*} [Zero R] (i : Nat) (p : Raw R) :
(mulPowX i p).size = i + p.size := by
simp only [mulPowX, Array.size_append, Array.size_replicate]

/-- Padded raw addition stores the larger input size. -/
@[simp]
theorem size_addRaw {Q : Type*} [Zero Q] [Add Q] {p q : Raw Q} :
(addRaw p q).size = max p.size q.size := by
simp only [addRaw, Array.size_zipWith, Array.size_rightpad]
omega

/-- Compatibility name for the public theorem previously provided by `Raw.Proofs`. -/
@[deprecated (since := "2026-11-03")]
alias add_size := size_addRaw

/-- Raw multiplication retains every shifted row, including padding from an empty right array. -/
theorem size_mulRaw {R : Type*} [Semiring R] (p q : Raw R) :
(mulRaw p q).size = if p.size = 0 then 0 else q.size + p.size - 1 := by
unfold mulRaw
have h := Array.foldl_induction (as := p.zipIdx)
(motive := fun i (acc : Raw R) ↦ acc.size = if i = 0 then 0 else q.size + i - 1)
(init := mk #[]) (by rfl)
(f := fun acc ai ↦ acc.addRaw ((smul ai.1 q).mulPowX ai.2)) ?_
· simpa only [Array.size_zipIdx] using h
· intro i acc ih
have hz : (p.zipIdx)[i].2 = i.val := by
change ((p.zipIdx)[i.val]'i.isLt).2 = i.val
rw [Array.getElem_zipIdx]
exact Nat.zero_add _
simp only [size_addRaw, size_mulPowX, size_smul]
rw [hz, ih]
by_cases hi : i.val = 0
· simp [hi]
· simp [hi]
omega

/-- The raw product's stored size is at most the sum of the input sizes minus one. -/
theorem size_mulRaw_le {R : Type*} [Semiring R] (p q : Raw R) :
(mulRaw p q).size ≤ p.size + q.size - 1 := by
Expand Down
1 change: 1 addition & 0 deletions docs/wiki/autoresearch.md
Original file line number Diff line number Diff line change
Expand Up @@ -196,6 +196,7 @@ its rows there.
| Base-field arithmetic | `fields-{koalabear,babybear,mersenne31,goldilocks}-{mul,add,inv,pow}`, `fields-{bn254,bls12-381,bls12-377}-{mul,add}`, `fields-secp256k1-{scalar,base}-{mul,add}` | `CompPoly/Fields/Montgomery/Native32Field.lean`, `CompPoly/Fields/Goldilocks/Fast.lean`, `CompPoly/Fields/Mersenne31/Fast.lean`, `CompPoly/Fields/Montgomery/Native64x8Mul.lean` | `toField_*`, `ringEquiv`, `instField` | two to four digest-cross-checked rows per group; the best-behaved targets |
| Eight-limb inversion | `fields-mont64x8-{bn254,bls12-381,bls12-377,secp256k1-scalar,secp256k1-base}-inv` | `CompPoly/Fields/Montgomery/Native64x8InvDefs.lean` | `invGcdRaw_eq_inv` and its bounds chain in `CompPoly/Fields/Montgomery/Native64x8Inv.lean` | three algorithms in one group, one digest class |
| Many-polynomial evaluation | `univariate-many-one-point-koalabear`, `univariate-dense-*` | `CompPoly/Univariate/ManyEval/Basic.lean`, `CompPoly/Univariate/Raw/Ops.lean` | `evalManyHorner_eq_map_eval`, `evalManySharedPowers_eq_map_eval`, `eval₂_horner_eq_eval₂` | plain array loops with short refinement proofs |
| Raw multiplication | `univariate-raw-mul-short-*`, `univariate-raw-mul-balanced-*`, `univariate-mul-crossover-*` | `CompPoly/Univariate/Raw/Ops.lean` (`mulRawFast`) | `mulRaw_eq_mulRawFast` (`@[csimp]`) | first loop run (#422, for #419): the loop computes each output entry as one sum and reads the inputs with proved indices. It does `p.size * q.size` multiplications and as many additions. With a short factor on either side, that count is linear in the stored length of the long factor. Next: the inner `Nat.fold` counts down, so every term recomputes its index from the remaining count. Each sum also starts from `0`, so every entry does one addition `0 + x`. Seed each sum with its first product to remove it |
| Tower scalar arithmetic | `fields-tower-bt{8,64}-mul`, `fields-tower-bt64-inv-word`, `fields-tower-bt128-{mul,inv}` | `CompPoly/Fields/Binary/Tower/FastDefs.lean` | `mul64T_eq_mul64`, `inv64T_eq_inv64`, `toConcrete_*` in `CompPoly/Fields/Binary/Tower/Fast.lean` | table twins already close to optimal; low headroom |
| Additive NTT | `additive-ntt-btf3-l2-r2`, `additive-ntt-btf3-l4-r2`, `additive-ntt-btf4-l7-r2` | `CompPoly/Fields/Binary/AdditiveNTT/Impl.lean` | `computableAdditiveNTTFast_eq_computableAdditiveNTT` | the `btf4` group is fast-only; rely on the build |
| NTTFast stages | `ntt-{koalabear,babybear}-l{8,10,12,14,16}`, `ntt-plan-koalabear` | `CompPoly/Univariate/NTTFast/Plan.lean` | `CompPoly/Univariate/NTTFast/Correctness/Pipeline.lean` | largest surface and largest proof burden; last |
Expand Down
Loading
Loading