Skip to content

feat(AdditiveNTT): the additive NTT over a coset, and its inverse - #405

Merged
dhsorens merged 4 commits into
Verified-zkEVM:mainfrom
tcoratger:additive-ntt-coset
Oct 27, 2026
Merged

dhsorens merged 4 commits into
Verified-zkEVM:mainfrom
tcoratger:additive-ntt-coset

Conversation

@tcoratger

Copy link
Copy Markdown
Contributor

The additive NTT here follows Diamond and Posen.

It runs one transform over the subspace S_l, tiled for the rate.

Implementations such as Plonky3's binary-dft also transform over a coset shift + S_l, and invert.

This adds that transform, from Lin, Chung and Han (FOCS 2014).

Results

  • W_i is additive in characteristic 2 (Lemma 1).
  • The butterfly network evaluates sum_k d_k X_k on shift + S_l (Section III).
  • The inverse network undoes it, for any twiddles.
  • The inverse network recovers the coefficients from the values.
  • Coefficients zero from 2^m on split into one transform per coset of S_m.
  • For a Cantor basis, W_j is the j-th iterate of x^2 + x.

Scope

Everything holds over any field of characteristic 2 and any basis.

No Fintype is needed.

The domain may be the whole field, which ℓ + R_rate < r excludes today.

The file imports only Mathlib.

🤖 Generated with Claude Code

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
@github-actions

github-actions Bot commented Oct 23, 2026 •

Copy link
Copy Markdown
Contributor

🤖 PR Summary

Mathematical Formalization

This PR formalizes the additive NTT over an arbitrary coset shift + S_l and its inverse, following Lin, Chung, and Han (FOCS 2014). The development is entirely self-contained within CompPoly/Fields/Binary/AdditiveNTT/Coset.lean (684 lines) and applies to any field of characteristic 2 with any basis indexed by ℕ. No Fintype is required, and the removal of the previous ℓ + R_rate < r constraint means the transform now works over the whole field.

Core definitions and theorems in Coset.lean:

  • point, vanishing, normalized, novel, novelEval – point-indexed functions over a coset.
  • ntt – the additive NTT over a coset.
  • Independent, IsCantor – properties of the basis.
  • butterfly, ibutterfly, stage, istage, network, inetwork, twiddle, sqAddIter – the butterfly network components.
  • network_ntt – the network computes the NTT.
  • inetwork_ntt, inetwork_network/network_inetwork – inverse network recovers coefficients.
  • ntt_pad, novelEval_pad – zero-padding splits into per-coset transforms.
  • vanishing_eq_sqAddIter, normalized_eq_sqAddIter, twiddle_cantor – for Cantor bases, W_j equals the j‑th iterate of x^2 + x.
  • vanishing_add (Lemma 1) – additivity of vanishing in characteristic 2.

Bridge file CosetBridge.lean connects these new definitions to the existing polynomial‑based NTT (which uses a Fin r-indexed basis β). Key theorems:

  • vanishing_eq_eval_W, normalized_eq_eval_normalizedW, novel_eq_eval_Xⱼ – point‑indexed functions equal evaluation of the corresponding polynomials.
  • additiveNTT_eq_ntt – the existing additiveNTT equals the coset ntt for zero shift.
  • inetwork_additiveNTT – the inverse network recovers original coefficients from the existing transform outputs.
  • independent_of_linearIndependent – deduces coset‑independence from linear independence of β.
  • evaluationPointω_eq_point – connects the evaluation point used previously to the coset point when β 0 = 1.

Refactoring

  • CompPoly.lean adds public import statements for both new modules (Coset, CosetBridge), making them part of the public API. This is a straightforward change.

Documentation

  • docs/wiki/binary-fields-and-ntt.md now lists the two new files and adds bullet‑point summaries of their roles, explaining that Coset.lean proves the Lin–Chung–Han transform and CosetBridge.lean provides the equivalence with prior polynomial‑based definitions.

Notes

  • All proofs rely solely on Mathlib; no external dependencies are introduced.
  • The new code does not impose the ℓ + R_rate < r restriction present in the old transform, allowing the domain to be the whole field.
  • No sorry or admit placeholders appear in any of the changed files.

Statistics

Metric Count
📝 Files Changed 4
✅ Lines Added 839
❌ Lines Removed 0

Lean Declarations

✏️ Added: 84 declaration(s)

CompPoly/Fields/Binary/AdditiveNTT/Coset.lean (75)

  • @[simp] theorem point_zero (β : ℕ → F) : point β 0 = 0
  • @[simp] theorem vanishing_zero (x : F) : vanishing β 0 x = x
  • def Independent (β : ℕ → F) (n : ℕ) : Prop
  • def IsCantor (β : ℕ → F) (n : ℕ) : Prop
  • def butterfly (t : F) (u v : V) : V × V
  • def ibutterfly (t : F) (u v : V) : V × V
  • def inetwork (τ : ℕ → ℕ → F) : ℕ → (ℕ → V) → ℕ → V
  • def istage (τ : ℕ → F) (j : ℕ) (x : ℕ → V) : ℕ → V
  • def network (τ : ℕ → ℕ → F) : ℕ → (ℕ → V) → ℕ → V
  • def normalized (β : ℕ → F) (i : ℕ) (x : F) : F
  • def novel (β : ℕ → F) (l k : ℕ) (x : F) : F
  • def novelEval (β : ℕ → F) (l : ℕ) (d : ℕ → V) (x : F) : V
  • def ntt (β : ℕ → F) (l : ℕ) (shift : F) (d : ℕ → V) : ℕ → V
  • def point (β : ℕ → F) (m : ℕ) : F
  • def sqAddIter (j : ℕ) (x : F) : F
  • def stage (τ : ℕ → F) (j : ℕ) (x : ℕ → V) : ℕ → V
  • def twiddle (β : ℕ → F) (shift : F) (j b : ℕ) : F
  • def vanishing (β : ℕ → F) (i : ℕ) (x : F) : F
  • def vanishingHom (i : ℕ) : F →+ F where
  • private theorem partner_down {i j : ℕ} (h : ¬ i % 2 ^ (j + 1) < 2 ^ j) :
  • private theorem partner_lt {i c j : ℕ} (hi : i < c * 2 ^ (j + 1))
  • private theorem partner_up {i j : ℕ} (h : i % 2 ^ (j + 1) < 2 ^ j) :
  • private theorem sum_bits_eq {M : Type _} [AddCommMonoid M] (f : ℕ → M) {m a b : ℕ}
  • theorem IsCantor.independent {n : ℕ} (hβ : IsCantor β n) : Independent β n
  • theorem blocks_succ {c l j : ℕ} (hj : j < l) :
  • theorem inetwork_congr {τ τ' : ℕ → ℕ → F} {l c : ℕ} {x x' : ℕ → V}
  • theorem inetwork_network (τ : ℕ → ℕ → F) (l : ℕ) (x : ℕ → V) :
  • theorem inetwork_ntt (β : ℕ → F) {n l : ℕ} (hβ : Independent β n) (hl : l ≤ n) (shift : F)
  • theorem inetwork_offset (τ : ℕ → ℕ → F) (l c : ℕ) (x : ℕ → V) (i : ℕ) :
  • theorem inetwork_twiddle_congr {τ τ' : ℕ → ℕ → F} {l : ℕ} (h : ∀ j < l, τ j = τ' j)
  • theorem istage_congr {τ τ' : ℕ → F} {j c : ℕ} {x x' : ℕ → V} (hτ : ∀ b < c, τ b = τ' b)
  • theorem istage_offset (τ : ℕ → F) (j c : ℕ) (x : ℕ → V) (i : ℕ) :
  • theorem istage_stage (τ : ℕ → F) (j : ℕ) (x : ℕ → V) : istage τ j (stage τ j x) = x
  • theorem map_point (f : F →+ F) (β : ℕ → F) (m : ℕ) : f (point β m) = point (f ∘ β) m
  • theorem network_congr {τ τ' : ℕ → ℕ → F} {l c : ℕ} {x x' : ℕ → V}
  • theorem network_inetwork (τ : ℕ → ℕ → F) (l : ℕ) (x : ℕ → V) :
  • theorem network_ntt (β : ℕ → F) {n l : ℕ} (hβ : Independent β n) (hl : l ≤ n) (shift : F)
  • theorem network_offset (τ : ℕ → ℕ → F) (l c : ℕ) (x : ℕ → V) (i : ℕ) :
  • theorem network_twiddle_congr {τ τ' : ℕ → ℕ → F} {l : ℕ} (h : ∀ j < l, τ j = τ' j)
  • theorem normalized_add (i : ℕ) (x y : F) :
  • theorem normalized_basis {n i : ℕ} (hβ : Independent β n) (hi : i < n) :
  • theorem normalized_eq_sqAddIter {n : ℕ} (hβ : IsCantor β n) {j : ℕ} (hj : j < n) (x : F) :
  • theorem normalized_point {i m : ℕ} (hm : m < 2 ^ i) : normalized β i (point β m) = 0
  • theorem normalized_shift_high {n l : ℕ} (hβ : Independent β n) (hl : l < n) (shift : F)
  • theorem normalized_shift_low (l : ℕ) (shift : F) {i : ℕ} (hi : i < 2 ^ l) :
  • theorem novelEval_add_smul (β : ℕ → F) (l : ℕ) (a b : ℕ → V) (t x : F) :
  • theorem novelEval_congr (β : ℕ → F) (l : ℕ) {d d' : ℕ → V} (h : ∀ k < 2 ^ l, d k = d' k)
  • theorem novelEval_pad (β : ℕ → F) {m : ℕ} (d : ℕ → V) (hd : ∀ k, 2 ^ m ≤ k → d k = 0) (r : ℕ)
  • theorem novelEval_succ (β : ℕ → F) (l : ℕ) (d : ℕ → V) (x : F) :
  • theorem novel_succ_high (l : ℕ) {k : ℕ} (hk : k < 2 ^ l) (x : F) :
  • theorem novel_succ_low (l : ℕ) {k : ℕ} (hk : k < 2 ^ l) (x : F) :
  • theorem ntt_pad (β : ℕ → F) {m : ℕ} (r : ℕ) (shift : F) (d : ℕ → V)
  • theorem point_add_mul (β : ℕ → F) (a k : ℕ) {b : ℕ} (hb : b < 2 ^ k) :
  • theorem point_add_two_pow (β : ℕ → F) {m k : ℕ} (hm : m < 2 ^ k) :
  • theorem point_congr {β β' : ℕ → F} {m n : ℕ} (hm : m < 2 ^ n) (h : ∀ r < n, β r = β' r) :
  • theorem point_eq_sum (β : ℕ → F) {m n : ℕ} (hm : m < 2 ^ n) :
  • theorem point_mul_two_pow (β : ℕ → F) (m s : ℕ) :
  • theorem point_two_pow (β : ℕ → F) (j : ℕ) : point β (2 ^ j) = β j
  • theorem point_two_pow_sub_one (β : ℕ → F) (t : ℕ) :
  • theorem sqAddIter_basis {n : ℕ} (hβ : IsCantor β n) {i j : ℕ} (hi : i < n) (hj : j ≤ i) :
  • theorem sqAddIter_succ (j : ℕ) (x : F) :
  • theorem stage_congr {τ τ' : ℕ → F} {j c : ℕ} {x x' : ℕ → V} (hτ : ∀ b < c, τ b = τ' b)
  • theorem stage_istage (τ : ℕ → F) (j : ℕ) (x : ℕ → V) : stage τ j (istage τ j x) = x
  • theorem stage_offset (τ : ℕ → F) (j c : ℕ) (x : ℕ → V) (i : ℕ) :
  • theorem stage_top_high (τ : ℕ → F) (l : ℕ) (d : ℕ → V) {k : ℕ} (hk : k < 2 ^ l) :
  • theorem stage_top_low (τ : ℕ → F) (l : ℕ) (d : ℕ → V) {k : ℕ} (hk : k < 2 ^ l) :
  • theorem twiddle_cantor {n : ℕ} (hβ : IsCantor β n) (shift : F) {j b : ℕ} (hj : j < n)
  • theorem twiddle_upper (β : ℕ → F) (shift : F) {l j b : ℕ} (hj : j < l)
  • theorem vanishing_add (i : ℕ) (x y : F) :
  • theorem vanishing_basis_cantor {n : ℕ} (hβ : IsCantor β n) {j : ℕ} (hj : j < n) :
  • theorem vanishing_basis_ne_zero {n i : ℕ} (hβ : Independent β n) (hi : i < n) :
  • theorem vanishing_eq_sqAddIter {n : ℕ} (hβ : IsCantor β n) {j : ℕ} (hj : j ≤ n) (x : F) :
  • theorem vanishing_point {i m : ℕ} (hm : m < 2 ^ i) : vanishing β i (point β m) = 0
  • theorem vanishing_succ (i : ℕ) (x : F) :
  • theorem vanishing_succ' (i : ℕ) (x : F) :

CompPoly/Fields/Binary/AdditiveNTT/CosetBridge.lean (9)

  • theorem additiveNTT_eq_ntt (hb : ∀ i : Fin r, b i = β i) (h : ℓ + R_rate < r)
  • theorem evaluationPointω_eq_point [Fact (β 0 = 1)] {ℓ R_rate : ℕ} (hb : ∀ i : Fin r, b i = β i)
  • theorem independent_of_linearIndependent [Fact (LinearIndependent 𝔽q β)]
  • theorem inetwork_additiveNTT (hb : ∀ i : Fin r, b i = β i) (h : ℓ + R_rate < r)
  • theorem normalized_eq_eval_normalizedW [Fact (LinearIndependent 𝔽q β)]
  • theorem novelEval_eq_eval_polynomialFromNovelCoeffs [Fact (LinearIndependent 𝔽q β)]
  • theorem novel_eq_eval_Xⱼ [Fact (LinearIndependent 𝔽q β)] [Fact (Nat.Prime (ringChar 𝔽q))]
  • theorem point_eq_sum_getBit (hb : ∀ i : Fin r, b i = β i) (i : Fin r) (k : Fin (2 ^ i.val)) :
  • theorem vanishing_eq_eval_W [Fact (LinearIndependent 𝔽q β)] (hb : ∀ i : Fin r, b i = β i)

sorry Tracking

  • No sorrys were added, removed, or affected.

📄 **Per-File Summaries**
  • CompPoly.lean: Added public import statements for CompPoly.Fields.Binary.AdditiveNTT.Coset and CompPoly.Fields.Binary.AdditiveNTT.CosetBridge, making those modules part of the public API of CompPoly.
  • CompPoly/Fields/Binary/AdditiveNTT/Coset.lean: This new file CompPoly/Fields/Binary/AdditiveNTT/Coset.lean (684 lines) introduces the additive NTT over any coset shift + S_l and its inverse, following Lin, Chung, and Han. Key definitions and theorems added include: point, vanishing, normalized, novel, novelEval, ntt, Independent, IsCantor, and the butterfly network (butterfly, ibutterfly, stage, istage, network, inetwork, twiddle, sqAddIter). It proves the network computes the NTT (network_ntt), the inverse network recovers coefficients (inetwork_ntt and inetwork_network/network_inetwork), zero-padding splits into per-coset transforms (ntt_pad, novelEval_pad), and for Cantor bases W_j is the iterate of x^2+x (vanishing_eq_sqAddIter, normalized_eq_sqAddIter, twiddle_cantor). The file also proves additivity of vanishing in characteristic 2 (vanishing_add, Lemma 1), and standard point properties (point_eq_sum, point_add_mul, point_mul_two_pow, etc.). No sorry or admit appears in this diff.
  • CompPoly/Fields/Binary/AdditiveNTT/CosetBridge.lean: This new file CosetBridge.lean adds a collection of theorems that connect the coset-based additive NTT definitions (using a natural-number-indexed basis b and point evaluations) to the existing polynomial-based NTT development (which uses a Fin r-indexed basis β and polynomial evaluation).

Specifically, it proves:

  • point_eq_sum_getBit : rewrites point b k as a sum over Fin i using getBit.
  • vanishing_eq_eval_W, normalized_eq_eval_normalizedW, novel_eq_eval_Xⱼ : show that the point-indexed functions vanishing, normalized, and novel equal the evaluation of the corresponding polynomials W, normalizedW, and Xⱼ.
  • novelEval_eq_eval_polynomialFromNovelCoeffs : extends the equality to sums over the novel basis.
  • independent_of_linearIndependent : deduces that the natural-number basis b is Independent (in the coset sense) from a linearly independent β.
  • evaluationPointω_eq_point : shows that the evaluation point used by the existing transform equals the coset point when β 0 = 1.
  • additiveNTT_eq_ntt : the main bridge — the existing additiveNTT equals the coset ntt with zero shift.
  • inetwork_additiveNTT : the inverse network (inetwork) recovers the original coefficients from the outputs of the existing transform.
  • docs/wiki/binary-fields-and-ntt.md: The documentation now lists two new files in the CompPoly/Fields/Binary/ directory (Coset.lean and CosetBridge.lean) and adds two corresponding bullet points describing their roles. Coset.lean proves the Lin–Chung–Han transform over any coset (and its inverse) using only Mathlib and a field of characteristic 2, indexing the basis by natural numbers. CosetBridge.lean shows that the coset objects agree with the existing definitions W, normalizedW, Xⱼ, and additiveNTT, allowing results proved in either presentation to be cited in the other.

Last updated: 2026-10-27 12:46 UTC.

@dhsorens dhsorens left a comment •

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Superseded by my review below, which has the comments inline.

@dhsorens dhsorens left a comment

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Thanks for this. It's a substantial piece of work, and it's nice to see the coset transform and its inverse proved over any field of characteristic 2, with no Fintype.

Before going through it line by line, I'd like to settle a design question. This file sits next to the existing additive-NTT development in the same directory, but it builds its own point, vanishing, normalized, novel and ntt from scratch against Mathlib alone. NovelPolynomialBasis.lean already defines the subspace polynomial W, its normalisation normalizedW and the novel basis Xⱼ. As it stands we'd have two parallel formalisations of the same objects that know nothing about each other, and a reader can't tell which one to use or whether they agree.

I'd like this PR to either:

  • reuse the existing definitions where they fit, or
  • if this point-indexed, ℕ → F presentation is genuinely the better one to prove the coset results in (which may well be true), add a bridge showing that vanishing/normalized/novel agree with W/normalizedW/Xⱼ on the existing domain, and that ntt β l 0 agrees with the current transform. That ties the new results to the code people already use.

I'd also like to hear what you have in mind downstream (Plonky3's binary-dft?), since that affects which way round the bridge should go.

Smaller points are inline.

Note that CI hasn't run on this yet: workflows on a first PR need a maintainer to approve them.

def point (β : ℕ → F) (m : ℕ) : F := ∑ r ∈ range m, if m.testBit r then β r else 0

/-- The subspace polynomial W_i: the product of x - s over the 2^i points s of S_i. -/
def vanishing (β : ℕ → F) (i : ℕ) (x : F) : F := ∏ m ∈ range (2 ^ i), (x - point β m)

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

This is the design question from my review: vanishing, normalized and novel duplicate W, normalizedW and Xⱼ in NovelPolynomialBasis.lean. Please either reuse those, or prove that these agree with them on the existing domain.

∑ k ∈ range (2 ^ l), novel β l k x • d k

/-- The additive NTT over shift + S_l: entry i is sum_k d_k X_k at shift + point(i). -/
def ntt (β : ℕ → F) (l : ℕ) (shift : F) (d : ℕ → V) : ℕ → V :=

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Likewise, if the bridge goes this way round, I'd like a lemma that ntt β l 0 agrees with the existing transform, so the coset results connect to the code people already use.

public import Mathlib.Algebra.Module.BigOperators
public import Mathlib.Data.Nat.Bitwise
public import Mathlib.Logic.Function.Iterate
public import Mathlib.Tactic.LinearCombination

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

If LinearCombination, Module and Linarith are only used inside proofs, a plain (non-public) import keeps them out of downstream files.

open Finset

variable {F : Type _} [Field F] {V : Type _} [AddCommGroup V] [Module F V]

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Nit: there's a run of blank lines here.


/-! ## Points -/

theorem testBit_of_lt {m r n : ℕ} (hm : m < 2 ^ n) (hr : n ≤ r) : m.testBit r = false :=

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

This follows from core's Nat.testBit_lt_two_pow plus a monotonicity step. Please use that directly, or at least make this private.

Nat.testBit_eq_false_of_lt (lt_of_lt_of_le hm (Nat.pow_le_pow_right two_pos hr))

/-- The sum over the bits of m below a bound stops changing once the bound covers m. -/
theorem sum_bits_eq {M : Type _} [AddCommMonoid M] (f : ℕ → M) {m a b : ℕ} (hab : a ≤ b)

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Generic Nat/Finset helpers like this one (and partner_lt, partner_up, partner_down) would become public API under AdditiveNTT.Coset. Please make them private.


/-! ## Row arithmetic of one stage -/

theorem two_pow_succ' (j : ℕ) : 2 ^ (j + 1) = 2 ^ j + 2 ^ j := by rw [pow_succ]; ring

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

This is core's Nat.two_pow_succ (2 ^ (n + 1) = 2 ^ n + 2 ^ n). Please use that instead.

tcoratger and others added 2 commits October 26, 2026 14:33
…ctic imports in Coset

Replace two_pow_succ' with Nat.two_pow_succ and testBit_of_lt with
Nat.testBit_lt_two_pow, make the generic Nat helpers private, import the
proof-only tactics without public, and drop the runs of blank lines.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…nd additiveNTT

The point-indexed vanishing, normalized and novel evaluate the existing
polynomials W, normalizedW and Xⱼ, for any natural-number basis that agrees
with the Fin r basis. With beta_0 = 1, additiveNTT is ntt with zero shift,
and the inverse network recovers the coefficients from its output.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
@tcoratger

Copy link
Copy Markdown
Contributor Author

Thanks for the careful read!

  • Design. I went with the second option and added a bridge, CosetBridge.lean (1504725).
    I kept the point-indexed presentation for the coset proofs.
    It needs no Fintype, no 𝔽q-algebra and no Fin r casts, and it states the network results over any field of characteristic 2 and any shift.
    Proving them against W, normalizedW and Xⱼ directly would bring all of that back into every butterfly lemma.
    The bridge takes any b : ℕ → L that agrees with β : Fin r → L below r, and proves:

    • vanishing_eq_eval_W, normalized_eq_eval_normalizedW, novel_eq_eval_Xⱼ: the point-indexed W_i, W^_i and X_j are the evaluations of the existing polynomials.
    • novelEval_eq_eval_polynomialFromNovelCoeffs: the same for a polynomial in the novel basis.
    • independent_of_linearIndependent: linear independence gives the Independent hypothesis the coset file uses.
    • additiveNTT_eq_ntt: with β 0 = 1, additiveNTT a j = ntt b ℓ 0 d j for every j < 2^(ℓ + R_rate), where d is any extension of a.
      So the rate tiling is covered too, since ntt is defined at every index.
    • inetwork_additiveNTT: the inverse network recovers the coefficients from additiveNTT's output.
      The existing development had no inverse, so this also gives it one.

    All of these reuse the existing evalWAt_eq_W and additiveNTT_correctness, so the bridge is short (about 140 lines).

    On downstream: yes, it's Plonky3's p3-binary-dft.
    We are verifying its LCH transform (forward, inverse, round trip) over a coset shift + S_l.
    That's why the coset version and its inverse come first.
    With the bridge, those results can be stated against either presentation, so they connect to additiveNTT and Xⱼ as well.
    I also listed both files in docs/wiki/binary-fields-and-ntt.md.

  • Duplicated helpers (62c96e1). two_pow_succ' is gone in favour of Nat.two_pow_succ.
    testBit_of_lt is gone too, with its three uses now Nat.testBit_lt_two_pow plus Nat.pow_le_pow_right.
    sum_bits_eq, partner_lt, partner_up and partner_down are now private.

  • Imports (62c96e1). Linarith, LinearCombination and Module are only used in proofs, so they are plain imports now.

  • Blank lines (62c96e1). Removed that run, along with the similar ones further down the file.

@dhsorens
dhsorens merged commit 9be21b0 into Verified-zkEVM:main Oct 27, 2026
5 checks passed
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

2 participants