Skip to content

feat: computable FRI-Binius protocols#455

Draft
chung-thai-nguyen wants to merge 5 commits intocompleteness-of-biniusfrom
CompBinius
Draft

feat: computable FRI-Binius protocols#455
chung-thai-nguyen wants to merge 5 commits intocompleteness-of-biniusfrom
CompBinius

Conversation

@chung-thai-nguyen
Copy link
Copy Markdown
Collaborator

Summary

  • Refactor oracle spec in Binius protocols into computable version

Status

  • Spec migration: Oracle reductions and security statements
  • Proof migration

Build

Ran targeted builds for migrated surfaces:

  • ArkLib.ProofSystem.Binius.BinaryBasefold.Spec
  • ArkLib.ProofSystem.Binius.BinaryBasefold.General
  • ArkLib.ProofSystem.Binius.FRIBinius.General
  • ArkLib.ProofSystem.Binius.RingSwitching.General
  • ArkLib.ProofSystem.Binius.RingSwitching.BBFSmallFieldIOPCS

@github-actions
Copy link
Copy Markdown

github-actions bot commented Apr 11, 2026

🤖 Gemini PR Summary

Refactors the Binius protocol suite to transition from noncomputable mathematical specifications to computable, executable implementations. This migration focuses on the oracle specifications and protocol structures for FRI-Binius, Binary Basefold, and Ring Switching.

Computable Polynomials & Additive NTT

  • Computable Carriers: Introduces CMvPolynomial and CPoly, computable subtypes for multivariate polynomials with bounded degrees.
  • Additive NTT Refactor: Moves Additive NTT and "novel polynomial basis" theory into the AdditiveNTT.Comp namespace, providing executable primitives like evalNormalizedWAt and bitsToUValue.
  • Theory Bridging: Establishes bridge lemmas (e.g., MLE'_eval_zeroOne) to connect computable definitions like CMLE' with existing noncomputable multilinear extension (MLE') theory.

Protocol & Oracle Refactoring

  • Specification Migration: Refactors Binary Basefold, Ring Switching, and FRI-Binius protocols to utilize the OracleFunction abstraction and computable polynomial types.
  • Executable Variants: Introduces "Exec" variants for provers, verifiers, and oracle reductions that accept explicit basis functions and multiplier parameters.
  • Query Phase Transition: Updates the Query Phase logic from abstract domain point queries to deterministic, index-based verification.
  • Sumcheck Integration: Standardizes Sumcheck specifications using FoldMessage aliases to ensure consistency across protocol layers.

Proof State and Sorries

  • CRITICAL: Proof Regression: In accordance with the "Proof migration: [ ]" status in the PR body, this refactor adds significant sorry and admit placeholders.
  • Impacted Proofs: Core security properties—including perfect completeness, knowledge soundness, and round-by-round extraction—are currently unproven in the new computable framework.
  • Technical Gaps: Deferred proofs include the Affine Proximity Gap bounds, fiberwise closeness results, and the formal correctness of the computable Additive NTT implementation.

Infrastructure & Typeclasses

  • Decidability Support: Implements Decidable and SampleableType instances for protocol components to enable execution within Lean.
  • Library Integration: Updates ArkLib.lean and module documentation for Sumcheck protocols to reflect the new computable architectural requirements and security theorem applications.

Statistics

Metric Count
📝 Files Changed 39
Lines Added 6762
Lines Removed 13615

Lean Declarations

✏️ **Removed:** 37 declaration(s)
  • def fiberEvaluations (i : Fin r) {destIdx : Fin r} (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • def nonLastBlocksRbrKnowledgeError in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
  • def dummyLastWitness : in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • def pointToIterateQuotientIndex (i : Fin r) {destIdx : Fin r} (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • def foldMatrix (i : Fin r) {destIdx : Fin r} (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • def iteratedSumcheckRoundKnowledgeError (_ : Fin ℓ') : ℝ≥0 in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean
  • def querySingleRepetitionError : ℝ≥0 in ArkLib/ProofSystem/Binius/FRIBinius/General.lean
  • def fold_single_matrix_mul_form (i : Fin r) {destIdx : Fin r} in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • instance instInhabitedPSpecSumcheckRoundMessage : in ArkLib/ProofSystem/Binius/RingSwitching/Spec.lean
  • def single_point_localized_fold_matrix_form (i : Fin r) {destIdx : Fin r} (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • def foldKnowledgeError (i : Fin ℓ) (_ : (pSpecFold (L in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/Fold.lean
  • def coreInteractionOracleRbrKnowledgeError (j : (BinaryBasefold.pSpecCoreInteraction K β (ϑ in ArkLib/ProofSystem/Binius/FRIBinius/CoreInteractionPhase.lean
  • def extractMiddleFinMask (v : (sDomain 𝔽q β h_ℓ_add_R_rate) ⟨0, by exact pos_of_neZero r⟩) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • def batchingMismatchPoly (msg0 s_bar : TensorAlgebra K L) : MvPolynomial (Fin κ) L in ArkLib/ProofSystem/Binius/RingSwitching/BatchingPhase.lean
  • instance instSDomain {i : Fin r} (h_i : i < ℓ + 𝓡) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean
  • def batchingCoreRbrKnowledgeError in ArkLib/ProofSystem/Binius/RingSwitching/General.lean
  • def fullRbrKnowledgeError in ArkLib/ProofSystem/Binius/FRIBinius/General.lean
  • def componentWise_φ₁_embed_MLE (t' : MultilinearPoly L ℓ') : in ArkLib/ProofSystem/Binius/RingSwitching/Prelude.lean
  • def coreInteractionRbrKnowledgeError (_ : (pSpecCoreInteraction L ℓ').ChallengeIdx) : ℝ≥0 in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean
  • def sumcheckFoldKnowledgeError (j : (pSpecSumcheckFold 𝔽q β (ϑ in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
  • def localized_fold_matrix_form (i : Fin r) {destIdx : Fin r} (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • def packMLE (β : Basis (Fin κ → Fin 2) K L) (t : MultilinearPoly K ℓ) : in ArkLib/ProofSystem/Binius/RingSwitching/Prelude.lean
  • def fold_eval_fiber₂_vec (i : Fin r) {midIdx destIdx : Fin r} (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • def lastBlockRbrKnowledgeError (k : (pSpecLastBlock (L in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
  • def foldCommitKnowledgeError (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
  • def coreInteractionOracleRbrKnowledgeError (j : (pSpecCoreInteraction 𝔽q β (ϑ in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
  • def nonLastSingleBlockFoldRelayRbrKnowledgeError (bIdx : Fin (ℓ / ϑ - 1)) in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
  • def foldRelayKnowledgeError (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
  • def batchingRBRKnowledgeError : ℝ≥0 in ArkLib/ProofSystem/Binius/RingSwitching/BatchingPhase.lean
  • def batchingCoreRbrKnowledgeError in ArkLib/ProofSystem/Binius/FRIBinius/General.lean
  • def nonLastSingleBlockRbrKnowledgeError (bIdx : Fin (ℓ / ϑ - 1)) in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
  • def fullRbrKnowledgeError (i : (fullPspec κ L K ℓ' mlIOPCS).ChallengeIdx) : ℝ≥0 in ArkLib/ProofSystem/Binius/RingSwitching/General.lean
  • def extractMLP (i : Fin ℓ) (f : (sDomain 𝔽q β h_ℓ_add_R_rate) ⟨i, by omega⟩ → L) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • def concreteFRIBiniusKnowledgeError : ℝ≥0 in ArkLib/ProofSystem/Binius/FRIBinius/General.lean
  • lemma foldCommitKnowledgeError_eq (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
  • def fold (i : Fin r) {destIdx : Fin r} (h_destIdx : destIdx = i.val + 1) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • def iterated_fold (i : Fin r) (steps : ℕ) {destIdx : Fin r} in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
✏️ **Added:** 243 declaration(s)
  • theorem W_linearity (i : Fin r) : in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • def computableXⱼ (𝔽q : Type u) [Field 𝔽q] [Fintype 𝔽q] in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • def queryOracleProof : OracleProof in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean
  • def singleEqCM (r : Fin 2) (j : Fin n) : CMvPolynomial n R in ArkLib/Data/MvPolynomial/MultilinearComputational.lean
  • theorem val_C (c : L) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • def Array.toFinVec {α : Type _} (n : ℕ) (arr : Array α) (h : arr.size = n) : Fin n → α in ArkLib/Data/FieldTheory/AdditiveNTT/Impl.lean
  • theorem sDomainFin_bijective (i : Fin r) (h_i : i < ℓ + R_rate) : in ArkLib/Data/FieldTheory/AdditiveNTT/Impl.lean
  • def relayOracleReduction (i : Fin ℓ) (hNCR : ¬ isCommitmentRound ℓ ϑ i) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/Relay.lean
  • def fixFirstVariablesOfDegreeLE [BEq L] [LawfulBEq L] (d : ℕ) (v : Fin (ℓ + 1)) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • def bitsToUValue (i : Fin r) (k : Fin (2 ^ i.val)) : L in ArkLib/Data/FieldTheory/AdditiveNTT/Impl.lean
  • lemma comp_X_sub_C_eq_zero_iff (p : L[X]) (a : L) : in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • instance sumcheckFoldBetaFun_linearIndependent : in ArkLib/ProofSystem/Binius/FRIBinius/CoreInteractionPhase.lean
  • theorem novelPolynomialBasis_is_basisVectors (ℓ : Nat) (h_ℓ : ℓ ≤ r) : in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • def finalSumcheckKnowledgeStateFunction {σ : Type} (init : ProbComp σ) in ArkLib/ProofSystem/Binius/FRIBinius/CoreInteractionPhase.lean
  • instance coreInteractionBetaFun_linearIndependent : in ArkLib/ProofSystem/Binius/FRIBinius/CoreInteractionPhase.lean
  • lemma degree_normalizedW (i : Fin r) : in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • lemma fintype_card_gt_one_of_field (K : Type*) [Field K] [Fintype K] : in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • lemma normalizedW₀_eq_1_div_β₀ : normalizedW (𝔽q in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • def foldOracleReduction (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/Fold.lean
  • def evalNormalizedWLinearMap (i : Fin r) : L →ₗ[𝔽q] L in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • def finalSumcheckRbrExtractor : in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean
  • def batchingRbrExtractor : in ArkLib/ProofSystem/Binius/RingSwitching/BatchingPhase.lean
  • def iteratedSumcheckOracleProver (i : Fin ℓ') : in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean
  • theorem monomialToNovel_novelToMonomial_inverse in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • def ofCMvPolynomial [BEq R] [LawfulBEq R] (d : ℕ) (p : CPoly.CMvPolynomial n R) : in ArkLib/Data/MvPolynomial/ComputableDegreeLE.lean
  • def foldBadEventCardSum (ℓ ϑ 𝓡 : ℕ) : ℕ in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
  • def eqCM (x : Fin n → Fin 2) : CMvPolynomial n R in ArkLib/Data/MvPolynomial/MultilinearComputational.lean
  • def MultilinearPoly.toCMvPoly {L : Type} [CommRing L] [BEq L] [LawfulBEq L] {ℓ : ℕ} in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • def twiddleFactor (i : Fin r) (h_i : i < ℓ) in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • theorem root_U_lift_down in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • lemma sDomain_eq_of_eq {i j : Fin r} (h : i = j) : in ArkLib/Data/FieldTheory/AdditiveNTT/Impl.lean
  • def commitRbrExtractor (i : Fin ℓ) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/Commit.lean
  • theorem fromCMvPolynomial_CMLE'_eq_MLE' (evals : Fin (2 ^ n) → R) : in ArkLib/Data/MvPolynomial/MultilinearComputational.lean
  • theorem MultilinearPoly.ofCMLEEvals_val {L : Type} [CommRing L] [DecidableEq L] [BEq L] in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • def projectToMidSumcheckPoly (t : CPoly.CMvPolynomial ℓ' L) in ArkLib/ProofSystem/Binius/RingSwitching/Prelude.lean
  • abbrev degreeLE : Type _ in ArkLib/Data/MvPolynomial/ComputableDegreeLE.lean
  • lemma evalNormalizedWAt_eq_normalizedW (i : Fin r) (x : L) : in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • def additiveNTT (a : Fin (2 ^ ℓ) → L) : Fin (2 ^ (ℓ + R_rate)) → L in ArkLib/Data/FieldTheory/AdditiveNTT/Impl.lean
  • lemma normalizedWᵢ_vanishing (i : Fin r) : in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • def computableAdditiveNTT (β : Fin r → L) (h_ℓ_add_R_rate : ℓ + R_rate < r) in ArkLib/Data/FieldTheory/AdditiveNTT/Impl.lean
  • def additiveNTT (β' : Fin r → L) (h_ℓ_add_R_rate' : ℓ + R_rate < r) in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • lemma eval_W_eq_zero_iff_in_U (i : Fin r) (a : L) : in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • lemma roots_comp_X_sub_C (p : L[X]) (a : L) : in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • lemma Wᵢ_vanishing (i : Fin r) : in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • abbrev SumcheckRoundMessage : Type in ArkLib/ProofSystem/Binius/RingSwitching/Spec.lean
  • lemma eval_eq_val_eval (msg : FoldMessage L) (r : L) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • def finalSumcheckKnowledgeStateFunction {σ : Type} (init : ProbComp σ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/FinalSumcheck.lean
  • def finalSumcheckOracleReduction in ArkLib/ProofSystem/Binius/FRIBinius/CoreInteractionPhase.lean
  • def fixFirstVariablesOfCMvPoly [BEq L] [LawfulBEq L] (v : Fin (ℓ + 1)) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • lemma rootMultiplicity_W (i : Fin r) (a : L) : in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • instance instFintypeCompSDomainZero : in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean
  • def MultilinearPoly.ofHypercubeEvals {L : Type} [CommRing L] [BEq L] [LawfulBEq L] {ℓ : ℕ} in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • lemma computablePolynomialFromNovelCoeffs_eval_eq [BEq L] [LawfulBEq L] in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • def getSumcheckRoundPoly [BEq L] [LawfulBEq L] (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • theorem property (p : MultiquadraticPoly L ℓ) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • def finalSumcheckOracleReduction : in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/FinalSumcheck.lean
  • def innerPowSum (B ϑ 𝓡 ℓ : ℕ) : ℕ in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
  • def fullOracleReduction in ArkLib/ProofSystem/Binius/FRIBinius/General.lean
  • lemma finToBinaryCoeffs_sDomainToFin (i : Fin r) (h_i : i < ℓ + R_rate) in ArkLib/Data/FieldTheory/AdditiveNTT/Impl.lean
  • lemma Xⱼ_zero_eq_one (ℓ : ℕ) (h_ℓ : ℓ ≤ r) : in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • def eval (msg : FoldMessage L) (r : L) : L in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • def finalSumcheckOracleReduction : in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean
  • def finalSumcheckProver : in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean
  • theorem changeOfBasisMatrix_det_ne_zero in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • def fullOracleProof : in ArkLib/ProofSystem/Binius/BinaryBasefold/General.lean
  • def sDomainPointToLocalIndex (i : Fin r) (h_i : i < ℓ + R_rate) in ArkLib/Data/FieldTheory/AdditiveNTT/Impl.lean
  • lemma computablePolynomialFromNovelCoeffs_toPoly_eq [BEq L] [LawfulBEq L] in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • lemma evalNormalizedWLinearMap_zero_apply (x : L) : in ArkLib/Data/FieldTheory/AdditiveNTT/Impl.lean
  • def getUElements (i : Fin r) : List L in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • def finalSumcheckProver : in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/FinalSumcheck.lean
  • def queryRbrExtractor : in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean
  • lemma W₀_eq_X : W 𝔽q β 0 = X in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • def queryOracleVerifier : in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean
  • def getFoldProverFinalOutput (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Relations.lean
  • instance instCompSDomainZero : in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean
  • theorem property [BEq R] [LawfulBEq R] (p : CPoly.CMvPolynomial.degreeLE n R d) : in ArkLib/Data/MvPolynomial/ComputableDegreeLE.lean
  • theorem mem_sDomainComp_of_mem_sDomain {i : Fin r} {x : L} in ArkLib/Data/FieldTheory/AdditiveNTT/Impl.lean
  • def MultilinearPoly.ofCMLEEvals {L : Type} [CommRing L] [BEq L] [LawfulBEq L] {ℓ : ℕ} in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • def finalSumcheckKnowledgeStateFunction {σ : Type} (init : ProbComp σ) in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean
  • instance foldStepLogic_verifierCheck_decidable (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/Fold.lean
  • def U (i : Fin r) : Subspace 𝔽q L in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • def ofCoeffVec (coeffs : Fin (d + 1) → R) : CPoly.CMvPolynomial.degreeLE 1 R d in ArkLib/Data/MvPolynomial/ComputableDegreeLE.lean
  • def fullOracleProof in ArkLib/ProofSystem/Binius/FRIBinius/General.lean
  • def projectToNextSumcheckPoly (i : Fin ℓ') in ArkLib/ProofSystem/Binius/RingSwitching/Prelude.lean
  • lemma goodBlock_point_disagreement_step in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/QueryPhaseSoundness.lean
  • def CMLE' (evals : Fin (2 ^ n) → R) : CMvPolynomial n R in ArkLib/Data/MvPolynomial/MultilinearComputational.lean
  • def twiddleFactor (i : Fin r) (_h_i : i < ℓ) in ArkLib/Data/FieldTheory/AdditiveNTT/Impl.lean
  • lemma evalWAt_eq_W (i : Fin r) (x : L) : in ArkLib/Data/FieldTheory/AdditiveNTT/Impl.lean
  • lemma normalizedWᵢ_eval_βᵢ_eq_1 {i : Fin r} : in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • lemma fromCMvPolynomial_finset_sum {ι : Type*} (s : Finset ι) in ArkLib/Data/MvPolynomial/MultilinearComputational.lean
  • lemma fixFirstVariablesOfCMvPoly_eval_eq [BEq L] [LawfulBEq L] (v : Fin (ℓ + 1)) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • lemma β_lt_mem_U (i : Fin r) (j : Fin i) : in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • lemma βᵢ_not_in_Uᵢ (i : Fin r) : in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • lemma computablePolynomialFromNovelCoeffsF₂_eval [LawfulBEq L] (x : L) (ℓ : ℕ) (h_ℓ : ℓ ≤ r) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • def MultiquadraticPoly.ofCMvPoly {L : Type} [CommRing L] [BEq L] [LawfulBEq L] {ℓ : ℕ} in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • def batchingOracleVerifier : in ArkLib/ProofSystem/Binius/RingSwitching/BatchingPhase.lean
  • instance finalSumcheckStepLogic_verifierCheck_decidable in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/FinalSumcheck.lean
  • def upperDomainIndex : Fin r in ArkLib/Data/FieldTheory/AdditiveNTT/Impl.lean
  • lemma degree_W (i : Fin r) : (W 𝔽q β i).degree = (Fintype.card 𝔽q)^i.val in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • lemma computableNormalizedW_toPoly_eq_normalizedW [BEq L] [LawfulBEq L] (i : Fin r) : in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • theorem root_U_lift_up (i : Fin r) (h_i_add_1 : i + 1 < r) (a : L) (x : 𝔽q) : in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • theorem sDomainComp_eq_sDomain (i : Fin r) : in ArkLib/Data/FieldTheory/AdditiveNTT/Impl.lean
  • lemma comp_sub_C_of_linear_eval (p : L[X]) in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • lemma get_sDomain_basis (i : Fin r) (h_i : i < ℓ + R_rate) : in ArkLib/Data/FieldTheory/AdditiveNTT/Impl.lean
  • def sDomain (i : Fin r) : Subspace 𝔽q L in ArkLib/Data/FieldTheory/AdditiveNTT/Impl.lean
  • def finalSumcheckVerifier : in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean
  • def relayOracleProver (i : Fin ℓ) (hNCR : ¬ isCommitmentRound ℓ ϑ i) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/Relay.lean
  • def fullOracleReduction : in ArkLib/ProofSystem/Binius/BinaryBasefold/General.lean
  • lemma evalWAt_eq_W (i : Fin r) (x : L) : in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • def extractMiddleFinMaskFromIndex (vIdx : Fin (2 ^ (ℓ + 𝓡))) (i : Fin r) (steps : ℕ) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • theorem novelToMonomial_monomialToNovel_inverse in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • lemma W_monic (i : Fin r) : (W 𝔽q β i).Monic in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • abbrev multiquadratic (n : ℕ) (R : Type) [CommSemiring R] : Type _ in ArkLib/Data/MvPolynomial/ComputableDegreeLE.lean
  • def toCoeffsVec (ℓ : Nat) : L⦃<2^ℓ⦄[X] →ₗ[L] CoeffVecSpace L ℓ where in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • lemma inductive_rec_form_W_comp (i : Fin r) (h_i_add_1 : i + 1 < r) in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • lemma fromCMvPolynomial_singleEqCM (r : Fin 2) (j : Fin n) : in ArkLib/Data/MvPolynomial/MultilinearComputational.lean
  • def batchingKnowledgeStateFunction : in ArkLib/ProofSystem/Binius/RingSwitching/BatchingPhase.lean
  • def fiberPointIndexFromIndex in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • def getFiberPointCompFromIndex in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • def computableNovelToMonomialCoeffs (𝔽q : Type u) [Field 𝔽q] [Fintype 𝔽q] in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • def toCanonicalSDomain (i : Fin r) in ArkLib/Data/FieldTheory/AdditiveNTT/Impl.lean
  • def sumcheckConsistencyProp {k : ℕ} (sumcheckTarget : L) in ArkLib/ProofSystem/Binius/RingSwitching/Prelude.lean
  • def evalWAt (i : Fin r) (x : L) : L in ArkLib/Data/FieldTheory/AdditiveNTT/Impl.lean
  • lemma Prod_W_comp_X_sub_C_ne_zero (i : Fin r) : in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • lemma W_ne_zero (i : Fin r) : (W 𝔽q β i) ≠ 0 in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • def foldRbrExtractor (i : Fin ℓ) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/Fold.lean
  • theorem changeOfBasisMatrix_lower_triangular in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • def commitOracleVerifier (i : Fin ℓ) (hCR : isCommitmentRound ℓ ϑ i) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/Commit.lean
  • theorem mem_sDomain_of_mem_sDomainComp {i : Fin r} {x : L} in ArkLib/Data/FieldTheory/AdditiveNTT/Impl.lean
  • def finalSumcheckProver : in ArkLib/ProofSystem/Binius/FRIBinius/CoreInteractionPhase.lean
  • def val [BEq R] [LawfulBEq R] (p : CPoly.CMvPolynomial.degreeLE n R d) : MvPolynomial (Fin n) R in ArkLib/Data/MvPolynomial/ComputableDegreeLE.lean
  • def computableW (𝔽q : Type u) [Field 𝔽q] [Fintype 𝔽q] in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • lemma evalNormalizedWAt_eq_normalizedW (i : Fin r) (x : L) : in ArkLib/Data/FieldTheory/AdditiveNTT/Impl.lean
  • lemma eval_normalizedW_succ_at_beta_prev (i : Fin r) (h_i_add_1 : i + 1 < r) : in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • def decodeQueryChallenges {γ : ℕ} (challenges : Fin γ → Fin (2 ^ (ℓ + R_rate))) : in ArkLib/Data/FieldTheory/AdditiveNTT/Impl.lean
  • def fullOracleVerifier in ArkLib/ProofSystem/Binius/FRIBinius/General.lean
  • theorem indexToSDomainZero_bijective : in ArkLib/Data/FieldTheory/AdditiveNTT/Impl.lean
  • def canonicalPointToLocalIndex? (i : Fin r) in ArkLib/Data/FieldTheory/AdditiveNTT/Impl.lean
  • lemma decompose_tensor_algebra_rows_sum {σ ι : Type*} (β : Basis σ K L) in ArkLib/ProofSystem/Binius/RingSwitching/Prelude.lean
  • lemma degree_Xⱼ (ℓ : ℕ) (h_ℓ : ℓ ≤ r) (j : Fin (2 ^ ℓ)) : in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • def batchingOracleProver : in ArkLib/ProofSystem/Binius/RingSwitching/BatchingPhase.lean
  • def queryOracleReduction : in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean
  • lemma sDomainZero_eq_upperDomain : in ArkLib/Data/FieldTheory/AdditiveNTT/Impl.lean
  • def queryKnowledgeStateFunction {σ : Type} (init : ProbComp σ) in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean
  • theorem normalizedW_is_additive (i : Fin r) : in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • theorem MultilinearPoly.ofCMLEEvals_cmEval_eq_val_eval {L : Type} [CommRing L] [DecidableEq L] in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • lemma rootMultiplicity_comp_X_sub_C (p : L[X]) (a x : L) : in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • theorem bitsToU_bijective (i : Fin r) : in ArkLib/Data/FieldTheory/AdditiveNTT/Impl.lean
  • theorem W_linear_comp_decomposition (i : Fin r) (h_i_add_1 : i + 1 < r) : in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • def coeffEquiv : CPoly.CMvPolynomial.degreeLE 1 R d ≃ (Fin (d + 1) → R) where in ArkLib/Data/MvPolynomial/ComputableDegreeLE.lean
  • theorem CMLE'_eval_eq_MLE'_eval (x : Fin n → Fin 2) (evals : Fin (2 ^ n) → R) : in ArkLib/Data/MvPolynomial/MultilinearComputational.lean
  • def NTTStage (β : Fin r → L) (h_ℓ_add_R_rate : ℓ + R_rate < r) in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • lemma W_is_additive in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • def getSumcheckRoundPoly (i : Fin ℓ') in ArkLib/ProofSystem/Binius/RingSwitching/Prelude.lean
  • def queryOracleProver : in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean
  • lemma eqTilde_eq_mvpoly_eval {L : Type} [CommRing L] {ℓ : ℕ} in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • theorem basisVectors_linear_independent (ℓ : Nat) (h_ℓ : ℓ ≤ r) : in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • def evalNormalizedWAt (i : Fin r) (x : L) : L in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • def computableNTTStage (β : Fin r → L) (h_ℓ_add_R_rate : ℓ + R_rate < r) (i : Fin ℓ) in ArkLib/Data/FieldTheory/AdditiveNTT/Impl.lean
  • theorem computableAdditiveNTT_eq_additiveNTT in ArkLib/Data/FieldTheory/AdditiveNTT/Impl.lean
  • def batchingOracleReduction : OracleReduction (oSpec in ArkLib/ProofSystem/Binius/RingSwitching/BatchingPhase.lean
  • def relayOracleVerifier (i : Fin ℓ) (hNCR : ¬ isCommitmentRound ℓ ϑ i) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/Relay.lean
  • lemma roots_W (i : Fin r) : -- converts root Multiset into (univ: Uᵢ.val.map) in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • lemma computableXⱼ_toPoly_eq_Xⱼ [BEq L] [LawfulBEq L] in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • instance sumcheckFoldBetaFun_zero_eq_one : in ArkLib/ProofSystem/Binius/FRIBinius/CoreInteractionPhase.lean
  • lemma rootMultiplicity_prod_W_comp_X_sub_C in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • def tileCoeffs (a : Fin (2 ^ ℓ) → L) : Fin (2 ^ (ℓ + R_rate)) → L in ArkLib/Data/FieldTheory/AdditiveNTT/Impl.lean
  • lemma inductive_linear_map_W (i : Fin r) (h_i_add_1 : i + 1 < r) in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • lemma W_add_U_invariant in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • def foldOracleProver (i : Fin ℓ) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/Fold.lean
  • def ofDegreeLE [BEq R] [LawfulBEq R] (d : ℕ) (p : CPoly.CMvPolynomial n R) : in ArkLib/Data/MvPolynomial/ComputableDegreeLE.lean
  • def iteratedSumcheckRbrExtractor (i : Fin ℓ') : in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean
  • theorem kernel_W_eq_U (i : Fin r) : in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • def bitsToUValue (i : Fin r) (k : Fin (2 ^ i.val)) : L in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • def val (p : MultiquadraticPoly L ℓ) : MvPolynomial (Fin ℓ) L in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • lemma decompose_tensor_algebra_columns_sum {σ ι : Type*} (β : Basis σ K L) in ArkLib/ProofSystem/Binius/RingSwitching/Prelude.lean
  • def evalWAt (i : Fin r) (x : L) : L in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • def getUElements (i : Fin r) : List L in ArkLib/Data/FieldTheory/AdditiveNTT/Impl.lean
  • def indexToSDomainZero (k : Fin (2 ^ (ℓ + R_rate))) : in ArkLib/Data/FieldTheory/AdditiveNTT/Impl.lean
  • def computablePolynomialFromNovelCoeffs (𝔽q : Type u) [Field 𝔽q] [Fintype 𝔽q] in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • theorem changeOfBasisMatrix_diag_ne_zero in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • def relayRbrExtractor (i : Fin ℓ) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/Relay.lean
  • def decodeQueryChallengesToCanonical {γ : ℕ} (challenges : Fin γ → Fin (2 ^ (ℓ + R_rate))) : in ArkLib/Data/FieldTheory/AdditiveNTT/Impl.lean
  • def C (c : L) : MultiquadraticPoly L ℓ in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • instance [BEq R] [LawfulBEq R] : Inhabited (CPoly.CMvPolynomial.degreeLE n R d) in ArkLib/Data/MvPolynomial/ComputableDegreeLE.lean
  • def canonicalPointToGlobalIndex? (i : Fin r) in ArkLib/Data/FieldTheory/AdditiveNTT/Impl.lean
  • lemma computableNovelToMonomialCoeffs_eq_novelToMonomialCoeffs [BEq L] [LawfulBEq L] in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • lemma embedded_MLP_eval_of_pack_eq_rs_embedded_packMLE in ArkLib/ProofSystem/Binius/RingSwitching/Prelude.lean
  • def challengeSuffixIndexFromIndex in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • def evalNormalizedWAt (i : Fin r) (x : L) : L in ArkLib/Data/FieldTheory/AdditiveNTT/Impl.lean
  • lemma Wᵢ_eval_βᵢ_neq_zero in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • def coeffVec (p : CPoly.CMvPolynomial.degreeLE 1 R d) : Fin (d + 1) → R in ArkLib/Data/MvPolynomial/ComputableDegreeLE.lean
  • def queryPhaseLogicStep : in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean
  • theorem normalizedW_is_linear_map (i : Fin r) : in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • theorem MultilinearPoly.ofHypercubeEvals_val {L : Type} [CommRing L] [DecidableEq L] [BEq L] in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • lemma U_i_is_union_of_cosets (i : Fin r) (hi : 0 < i) : in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • lemma U_card (i : Fin r) : in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • lemma W_prod_comp_decomposition in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • instance coreInteractionBetaFun_zero_eq_one : in ArkLib/ProofSystem/Binius/FRIBinius/CoreInteractionPhase.lean
  • theorem MultilinearPoly.ofCMLEEvals_eval_zeroOne {L : Type} [CommRing L] [DecidableEq L] in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • def bitsToU (i : Fin r) (k : Fin (2 ^ i.val)) : in ArkLib/Data/FieldTheory/AdditiveNTT/Impl.lean
  • theorem CMLE'_eval_zeroOne (x : Fin n → Fin 2) (evals : Fin (2 ^ n) → R) : in ArkLib/Data/MvPolynomial/MultilinearComputational.lean
  • instance betaFun_zero_eq_one : Fact ((fun i => β i) 0 = 1) in ArkLib/ProofSystem/Binius/FRIBinius/General.lean
  • def iteratedSumcheckOracleVerifier (i : Fin ℓ') : in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean
  • theorem basisVectors_span (ℓ : Nat) (h_ℓ : ℓ ≤ r) : in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • instance betaFun_linearIndependent : Fact (LinearIndependent K (fun i => β i)) in ArkLib/ProofSystem/Binius/FRIBinius/General.lean
  • lemma sDomain_card (i : Fin r) (h_i : i < ℓ + R_rate) : in ArkLib/Data/FieldTheory/AdditiveNTT/Impl.lean
  • theorem MLE'_eval_zeroOne {n : ℕ} (x : Fin n → Fin 2) (evals : Fin (2 ^ n) → R) : in ArkLib/Data/MvPolynomial/Multilinear.lean
  • abbrev multilinear (n : ℕ) (R : Type) [CommSemiring R] : Type _ in ArkLib/Data/MvPolynomial/ComputableDegreeLE.lean
  • lemma List.prod_finRange_eq_finset_prod {M : Type*} [CommMonoid M] {n : ℕ} in ArkLib/Data/FieldTheory/AdditiveNTT/Impl.lean
  • abbrev CoeffVecSpace (L : Type u) (ℓ : Nat) in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • def NTTStage (i : Fin r) (h_i : i < ℓ) in ArkLib/Data/FieldTheory/AdditiveNTT/Impl.lean
  • abbrev FoldMessage (L : Type) [CommSemiring L] in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • lemma fromCMvPolynomial_finset_prod {ι : Type*} (s : Finset ι) in ArkLib/Data/MvPolynomial/MultilinearComputational.lean
  • instance instDecidableIsCommitmentRound (i : Fin ℓ) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • def computablePolynomialFromNovelCoeffsF₂ (ℓ : ℕ) (h_ℓ : ℓ ≤ r) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • lemma finrank_U (i : Fin r) : in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • def finalSumcheckVerifier in ArkLib/ProofSystem/Binius/FRIBinius/CoreInteractionPhase.lean
  • lemma indexToSDomainZero_val_eq_bitsToU_val (k : Fin (2 ^ (ℓ + R_rate))) : in ArkLib/Data/FieldTheory/AdditiveNTT/Impl.lean
  • def NTTStageCore in ArkLib/Data/FieldTheory/AdditiveNTT/Impl.lean
  • theorem kernel_normalizedW_eq_U (i : Fin r) : in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • theorem NTTStage_eq_NTTStage in ArkLib/Data/FieldTheory/AdditiveNTT/Impl.lean
  • def computableTwiddleFactor (i : Fin ℓ) (u : Fin (2 ^ (ℓ + R_rate - i - 1))) : L in ArkLib/Data/FieldTheory/AdditiveNTT/Impl.lean
  • def sDomainComp (i : Fin r) : Subspace 𝔽q L in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • def finalSumcheckVerifier : in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/FinalSumcheck.lean
  • def indexToSDomain (i : Fin r) (k : Fin (2 ^ (ℓ + R_rate))) : in ArkLib/Data/FieldTheory/AdditiveNTT/Impl.lean
  • theorem twiddleFactor_eq_twiddleFactor in ArkLib/Data/FieldTheory/AdditiveNTT/Impl.lean
  • lemma fromCMvPolynomial_eqCM (x : Fin n → Fin 2) : in ArkLib/Data/MvPolynomial/MultilinearComputational.lean
  • lemma linearIndependent_rows_of_lower_triangular_ne_zero_diag in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • lemma coeff_vectors_linear_independent in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • def localIndexToSDomain (i : Fin r) (h_i : i < ℓ + R_rate) in ArkLib/Data/FieldTheory/AdditiveNTT/Impl.lean
  • def fullOracleVerifier : in ArkLib/ProofSystem/Binius/BinaryBasefold/General.lean
  • lemma computableW_toPoly_eq_W [BEq L] [LawfulBEq L] (i : Fin r) : in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • def commitOracleReduction (i : Fin ℓ) (hCR : isCommitmentRound ℓ ϑ i) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/Commit.lean
  • lemma W_splits (i : Fin r) : (W 𝔽q β i).Splits in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • def commitOracleProver (i : Fin ℓ) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/Commit.lean
  • def MultilinearPoly.ofCMvPoly {L : Type} [CommRing L] [BEq L] [LawfulBEq L] {ℓ : ℕ} in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • def computableNormalizedW (𝔽q : Type u) [Field 𝔽q] [Fintype 𝔽q] in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean
  • def localIndexFunctionToCanonical (i : Fin r) in ArkLib/Data/FieldTheory/AdditiveNTT/Impl.lean
  • theorem ext {p q : MultiquadraticPoly L ℓ} in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • def localIndexToGlobalIndex (i : Fin r) (h_i : i < ℓ + R_rate) in ArkLib/Data/FieldTheory/AdditiveNTT/Impl.lean
  • lemma fixFirstVariablesOfCMvPoly_val_eq [BEq L] [LawfulBEq L] (v : Fin (ℓ + 1)) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • def iteratedSumcheckOracleReduction (i : Fin ℓ') : in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean
✏️ **Affected:** 54 declaration(s) (line number changed)
  • def sumcheckFoldOracleReduction in ArkLib/ProofSystem/Binius/FRIBinius/CoreInteractionPhase.lean moved from L150 to L194
  • def getChallengeSuffix (k : Fin (ℓ / ϑ)) in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/QueryPhasePrelims.lean moved from L156 to L161
  • abbrev OracleFunction (domainIdx : Fin r) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean moved from L592 to L629
  • lemma checkSingleRepetition_probFailure_eq_zero : True in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean moved from L1286 to L466
  • def FinalSumcheckWit (m : Fin (1 + 1)) : Type in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/FinalSumcheck.lean moved from L1609 to L1630
  • def decompose_tensor_algebra_columns {σ : Type*} (β : Basis σ K L) in ArkLib/ProofSystem/Binius/RingSwitching/Prelude.lean moved from L100 to L172
  • lemma query_phase_consistency_guard_safe : True in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean moved from L398 to L454
  • def sumcheckProverComputeMsg (witIn : SumcheckWitness L ℓ' i.castSucc) : in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean moved from L85 to L87
  • def batchingCoreVerifier in ArkLib/ProofSystem/Binius/FRIBinius/General.lean moved from L77 to L174
  • def badSumcheckEventProp in ArkLib/ProofSystem/Binius/BinaryBasefold/Relations.lean moved from L512 to L581
  • lemma getSumcheckRoundPoly_eval_eq [BEq L] [LawfulBEq L] (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean moved from L407 to L549
  • theorem coreInteractionOracleReduction_perfectCompleteness in ArkLib/ProofSystem/Binius/FRIBinius/CoreInteractionPhase.lean moved from L1656 to L1278
  • def fullPspec in ArkLib/ProofSystem/Binius/FRIBinius/General.lean moved from L54 to L103
  • def coreInteractionOracleReduction : in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean moved from L1652 to L1005
  • def batchingProverWitOut (stmtIn : BatchingStmtIn L ℓ) in ArkLib/ProofSystem/Binius/RingSwitching/BatchingPhase.lean moved from L156 to L150
  • lemma extractMLP_eq_some_iff_pair_UDRClose in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean moved from L1462 to L1235
  • def checkSingleRepetition_foldRel in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean moved from L1068 to L337
  • def sumcheckFoldOracleVerifier in ArkLib/ProofSystem/Binius/FRIBinius/CoreInteractionPhase.lean moved from L144 to L185
  • def iteratedSumcheckKnowledgeStateFunction (i : Fin ℓ') : in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean moved from L590 to L534
  • lemma query_phase_final_fold_eq_constant : True in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean moved from L902 to L460
  • def batchingCorePspec in ArkLib/ProofSystem/Binius/FRIBinius/General.lean moved from L51 to L97
  • theorem fullOracleVerifier_rbrKnowledgeSoundness : in ArkLib/ProofSystem/Binius/FRIBinius/General.lean moved from L266 to L444
  • def decomposeChallenge (v : AdditiveNTT.Comp.sDomain (𝔽q in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/QueryPhasePrelims.lean moved from L122 to L122
  • def pSpecFold : ProtocolSpec 2 in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean moved from L225 to L226
  • lemma getMidCodewords_succ (t : MultilinearPoly L ℓ) (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Relations.lean moved from L105 to L165
  • def MLPEvalWitness_to_BBF_Witness in ArkLib/ProofSystem/Binius/RingSwitching/BBFSmallFieldIOPCS.lean moved from L98 to L98
  • lemma batching_pack_unpack_id (t' : CPoly.CMvPolynomial ℓ' L) : in ArkLib/ProofSystem/Binius/RingSwitching/BatchingPhase.lean moved from L915 to L638
  • def embedded_MLP_eval (t' : CPoly.CMvPolynomial ℓ' L) (r : Fin ℓ → L) : TensorAlgebra K L in ArkLib/ProofSystem/Binius/RingSwitching/Prelude.lean moved from L345 to L451
  • def coreInteractionOracleReduction in ArkLib/ProofSystem/Binius/FRIBinius/CoreInteractionPhase.lean moved from L1634 to L1237
  • def pSpecCoreInteraction in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean moved from L278 to L280
  • def sumcheckConsistencyProp {k : ℕ} (sumcheckTarget : L) (H : MultiquadraticPoly L k) : Prop in ArkLib/ProofSystem/Binius/BinaryBasefold/Relations.lean moved from L220 to L285
  • def batchingCoreReduction in ArkLib/ProofSystem/Binius/FRIBinius/General.lean moved from L95 to L224
  • theorem coreInteractionOracleReduction_perfectCompleteness (hInit : NeverFail init) : in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean moved from L1672 to L1034
  • def sumcheckFoldCtxLens in ArkLib/ProofSystem/Binius/FRIBinius/CoreInteractionPhase.lean moved from L87 to L104
  • abbrev MultilinearPoly (L : Type) [CommSemiring L] (ℓ : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean moved from L180 to L183
  • lemma logical_checkSingleRepetition_of_mem_support_forIn_body {σ : Type} : True in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean moved from L1461 to L488
  • def pSpecSumcheckRound : ProtocolSpec 2 in ArkLib/ProofSystem/Binius/RingSwitching/Spec.lean moved from L59 to L61
  • def extractSuffixFromChallenge (v : AdditiveNTT.Comp.sDomain (𝔽q in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/QueryPhasePrelims.lean moved from L64 to L66
  • def coreInteractionOracleVerifier in ArkLib/ProofSystem/Binius/FRIBinius/CoreInteractionPhase.lean moved from L1615 to L1213
  • abbrev MultiquadraticPoly (L : Type) [CommSemiring L] (ℓ : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean moved from L181 to L184
  • theorem fullOracleReduction_perfectCompleteness in ArkLib/ProofSystem/Binius/FRIBinius/General.lean moved from L191 to L424
  • def unpackMLE (β : Basis (Fin κ → Fin 2) K L) in ArkLib/ProofSystem/Binius/RingSwitching/Prelude.lean moved from L138 to L249
  • def performCheckOriginalEvaluation (s : L) (r : Fin ℓ → L) in ArkLib/ProofSystem/Binius/RingSwitching/Prelude.lean moved from L356 to L475
  • def queryPhaseProverState : Fin (1 + 1) → Type in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean moved from L104 to L57
  • def bbfMLIOPCS : MLIOPCS L ℓ' in ArkLib/ProofSystem/Binius/RingSwitching/BBFSmallFieldIOPCS.lean moved from L678 to L395
  • theorem foldOracleReduction_perfectCompleteness in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/Fold.lean moved from L150 to L157
  • def coreInteractionOracleVerifier : in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean moved from L1636 to L983
  • lemma getSumcheckRoundPoly_sum_eq [BEq L] [LawfulBEq L] (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean moved from L458 to L559
  • lemma checkSingleRepetition_inner_forIn_probFailure_eq_zero : True in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean moved from L1105 to L463
  • def fullPSpec in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean moved from L290 to L295
  • lemma query_phase_step_preserves_fold : True in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean moved from L495 to L457
  • lemma probability_bound_badSumcheckEventProp (h_i h_star : FoldMessage L) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness.lean moved from L49 to L49
  • def getMidCodewords {i : Fin (ℓ + 1)} (t : MultilinearPoly L ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Relations.lean moved from L93 to L106
  • def polyToOracleFunc (domainIdx : Fin r) (P : L[X]) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean moved from L2375 to L2250

sorry Tracking

✅ **Removed:** 1 `sorry`(s)
  • def oracleVerifier : OracleVerifier oSpec (StmtIn R) (OStmtIn R deg) (StmtOut R) (OStmtOut R deg) in ArkLib/ProofSystem/Sumcheck/Spec/SingleRound.lean (L435)
❌ **Added:** 134 `sorry`(s)
  • theorem property [BEq R] [LawfulBEq R] (p : CPoly.CMvPolynomial.degreeLE n R d) : in ArkLib/Data/MvPolynomial/ComputableDegreeLE.lean (L63)
  • theorem foldRelayOracleVerifier_rbrKnowledgeSoundness in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean (L176)
  • lemma preTensorCombine_is_interleavedCodeword_of_codeword (i : Fin ℓ) (steps : ℕ) {destIdx : Fin r} in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/Lift.lean (L156)
  • lemma computableNovelToMonomialCoeffs_eq_novelToMonomialCoeffs [BEq L] [LawfulBEq L] in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean (L1681)
  • lemma embedded_MLP_eval_of_pack_eq_rs_embedded_packMLE in ArkLib/ProofSystem/Binius/RingSwitching/Prelude.lean (L472)
  • lemma finalSumcheck_honest_message_eq_t'_eval in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean (L788)
  • theorem is_fiber_iff_generates_quotient_point (i : Fin r) {destIdx : Fin r} (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean (L936)
  • def dummyLastWitness : in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean (L1268)
  • lemma sumcheckConsistency_at_last_simplifies in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean (L774)
  • def finalSumcheckKnowledgeStateFunction {σ : Type} (init : ProbComp σ) in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean (L1188)
  • def finalSumcheckKnowledgeStateFunction {σ : Type} (init : ProbComp σ) in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean (L1190)
  • lemma BBF_CodeDistance_eq (i : Fin r) (h_i : i ≤ ℓ) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean (L100)
  • def ofCoeffVec (coeffs : Fin (d + 1) → R) : CPoly.CMvPolynomial.degreeLE 1 R d in ArkLib/Data/MvPolynomial/ComputableDegreeLE.lean (L95)
  • def ofCoeffVec (coeffs : Fin (d + 1) → R) : CPoly.CMvPolynomial.degreeLE 1 R d in ArkLib/Data/MvPolynomial/ComputableDegreeLE.lean (L99)
  • theorem val_C (c : L) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean (L255)
  • lemma extractMLP_eq_some_iff_pair_UDRClose in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean (L1246)
  • theorem coreInteractionOracleVerifier_rbrKnowledgeSoundness : in ArkLib/ProofSystem/Binius/FRIBinius/CoreInteractionPhase.lean (L1334)
  • lemma sumcheckConsistency_MLPEvalWitness_to_BBF_Witness_of_eval in ArkLib/ProofSystem/Binius/RingSwitching/BBFSmallFieldIOPCS.lean (L247)
  • theorem sDomainFin_bijective (i : Fin r) (h_i : i < ℓ + R_rate) : in ArkLib/Data/FieldTheory/AdditiveNTT/Impl.lean (L337)
  • lemma previousSuffix_eq_getFiberPoint_extractMiddleFinMask in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/QueryPhasePrelims.lean (L607)
  • theorem MultilinearPoly.ofHypercubeEvals_val {L : Type} [CommRing L] [DecidableEq L] [BEq L] in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean (L678)
  • theorem fullOracleVerifier_rbrKnowledgeSoundness : in ArkLib/ProofSystem/Binius/FRIBinius/General.lean (L458)
  • def coreInteractionOracleRbrKnowledgeError (j : (BinaryBasefold.pSpecCoreInteraction K β (ϑ in ArkLib/ProofSystem/Binius/FRIBinius/CoreInteractionPhase.lean (L1303)
  • lemma iterated_fold_to_level_ℓ_eval in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean (L2511)
  • def extractMiddleFinMask (v : (sDomain 𝔽q β h_ℓ_add_R_rate) ⟨0, by exact pos_of_neZero r⟩) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean (L2541)
  • theorem sumcheckLoopOracleVerifier_rbrKnowledgeSoundness : in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean (L1287)
  • theorem nonLastBlocksOracleVerifier_rbrKnowledgeSoundness : in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean (L948)
  • theorem queryOracleProof_perfectCompleteness {σ : Type} in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean (L529)
  • theorem queryOracleProof_perfectCompleteness {σ : Type} in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean (L530)
  • theorem foldCommitOracleVerifier_rbrKnowledgeSoundness in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean (L253)
  • def finalSumcheckKnowledgeStateFunction {σ : Type} (init : ProbComp σ) in ArkLib/ProofSystem/Binius/FRIBinius/CoreInteractionPhase.lean (L1180)
  • def finalSumcheckKnowledgeStateFunction {σ : Type} (init : ProbComp σ) in ArkLib/ProofSystem/Binius/FRIBinius/CoreInteractionPhase.lean (L1182)
  • theorem finalSumcheckOracleVerifier_rbrKnowledgeSoundness [Fintype L] {σ : Type} in ArkLib/ProofSystem/Binius/FRIBinius/CoreInteractionPhase.lean (L1197)
  • lemma finalSumcheckStep_is_logic_complete : in ArkLib/ProofSystem/Binius/FRIBinius/CoreInteractionPhase.lean (L998)
  • lemma batching_pack_unpack_id (t' : CPoly.CMvPolynomial ℓ' L) : in ArkLib/ProofSystem/Binius/RingSwitching/BatchingPhase.lean (L642)
  • theorem MultilinearPoly.ofCMLEEvals_eval_zeroOne {L : Type} [CommRing L] [DecidableEq L] in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean (L699)
  • theorem fullOracleVerifier_rbrKnowledgeSoundness : in ArkLib/ProofSystem/Binius/BinaryBasefold/General.lean (L155)
  • lemma logical_queryFiberPoints_eq_fiberEvaluations in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/QueryPhasePrelims.lean (L509)
  • def getLiftCoeffs (i : Fin ℓ) (steps : ℕ) {destIdx : Fin r} in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/Lift.lean (L177)
  • def foldCommitKnowledgeError (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean (L231)
  • def bitsToU (i : Fin r) (k : Fin (2 ^ i.val)) : in ArkLib/Data/FieldTheory/AdditiveNTT/Impl.lean (L52)
  • lemma UDRCodeword_constFunc_eq_self (i : Fin r) (h_i : i ≤ ℓ) (c : L) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean (L386)
  • def coreInteractionOracleRbrKnowledgeError (j : (pSpecCoreInteraction 𝔽q β (ϑ in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean (L1044)
  • theorem fullRbrKnowledgeError_sum_le_concrete : in ArkLib/ProofSystem/Binius/BinaryBasefold/General.lean (L198)
  • theorem fullRbrKnowledgeError_sum_le_concrete : in ArkLib/ProofSystem/Binius/FRIBinius/General.lean (L464)
  • def queryKnowledgeStateFunction {σ : Type} (init : ProbComp σ) in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean (L795)
  • def queryKnowledgeStateFunction {σ : Type} (init : ProbComp σ) in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean (L797)
  • theorem fullOracleReduction_perfectCompleteness in ArkLib/ProofSystem/Binius/FRIBinius/General.lean (L440)
  • lemma foldl_NTTStage_inductive_aux (h_ℓ : ℓ ≤ r) (k : Fin (ℓ + 1)) in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean (L3002)
  • theorem MultilinearPoly.ofCMLEEvals_cmEval_eq_val_eval {L : Type} [CommRing L] [DecidableEq L] in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean (L705)
  • lemma sDomain_card (i : Fin r) (h_i : i < ℓ + R_rate) : in ArkLib/Data/FieldTheory/AdditiveNTT/Impl.lean (L278)
  • theorem bitsToU_bijective (i : Fin r) : in ArkLib/Data/FieldTheory/AdditiveNTT/Impl.lean (L58)
  • theorem additiveNTT_correctness (h_ℓ : ℓ ≤ r) in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean (L3042)
  • lemma getSumcheckRoundPoly_sum_eq (i : Fin ℓ) (h : ↥L⦃≤ 2⦄[X Fin (ℓ - ↑i.castSucc)]) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean (L557)
  • lemma getSumcheckRoundPoly_sum_eq [BEq L] [LawfulBEq L] (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean (L564)
  • lemma sDomain_eq_of_eq {i j : Fin r} (h : i = j) : in ArkLib/Data/FieldTheory/AdditiveNTT/Impl.lean (L255)
  • abbrev FoldMessage (L : Type) [CommSemiring L] in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean (L202)
  • theorem foldOracleVerifier_rbrKnowledgeSoundness (i : Fin ℓ) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/Fold.lean (L1263)
  • theorem generates_quotient_point_if_is_fiber_of_y in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean (L915)
  • lemma query_phase_step_preserves_fold : True in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean (L458)
  • lemma qMap_total_fiber_one_level_eq (i : Fin r) {destIdx : Fin r} in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean (L893)
  • lemma computablePolynomialFromNovelCoeffsF₂_eval [LawfulBEq L] (x : L) (ℓ : ℕ) (h_ℓ : ℓ ≤ r) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean (L645)
  • theorem MultilinearPoly.ofCMLEEvals_val {L : Type} [CommRing L] [DecidableEq L] [BEq L] in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean (L667)
  • lemma getFiberPoint_eq_qMap_total_fiber in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/QueryPhasePrelims.lean (L469)
  • lemma projectToMidSumcheckPoly_eq_prod (t : MultilinearPoly L ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean (L878)
  • lemma evalNormalizedWAt_eq_normalizedW (i : Fin r) (x : L) : in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean (L131)
  • theorem coreInteractionOracleVerifier_rbrKnowledgeSoundness : in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean (L1061)
  • def getRowPoly (i : Fin ℓ) (steps : ℕ) {destIdx : Fin r} in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/Lift.lean (L171)
  • lemma checkSingleRepetition_probFailure_eq_zero : True in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean (L467)
  • theorem NTTStage_eq_NTTStage in ArkLib/Data/FieldTheory/AdditiveNTT/Impl.lean (L505)
  • lemma query_phase_consistency_guard_safe : True in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean (L455)
  • theorem queryPhaseLogicStep_isStronglyComplete : in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean (L515)
  • lemma computableNormalizedW_toPoly_eq_normalizedW [BEq L] [LawfulBEq L] (i : Fin r) : in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean (L1654)
  • lemma fiberwise_disagreement_isomorphism (i : Fin ℓ) (steps : ℕ) {destIdx : Fin r} in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/Lift.lean (L260)
  • theorem computableAdditiveNTT_eq_additiveNTT in ArkLib/Data/FieldTheory/AdditiveNTT/Impl.lean (L530)
  • lemma get_sDomain_basis (i : Fin r) (h_i : i < ℓ + R_rate) : in ArkLib/Data/FieldTheory/AdditiveNTT/Impl.lean (L263)
  • lemma finalSumcheckStep_is_logic_complete : in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean (L845)
  • lemma computableXⱼ_toPoly_eq_Xⱼ [BEq L] [LawfulBEq L] in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean (L1660)
  • def iteratedSumcheckKnowledgeStateFunction (i : Fin ℓ') : in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean (L551)
  • def iteratedSumcheckKnowledgeStateFunction (i : Fin ℓ') : in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean (L553)
  • lemma strictBatchingInputRelation_subset_batchingInputRelation : in ArkLib/ProofSystem/Binius/RingSwitching/BatchingPhase.lean (L111)
  • lemma query_phase_final_fold_eq_constant : True in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean (L461)
  • lemma eval_point_ω_eq_next_twiddleFactor_comp_qmap in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean (L2240)
  • lemma projectToNextSumcheckPoly_sum_eq (i : Fin ℓ) (Hᵢ : MultiquadraticPoly L (ℓ - i)) (rᵢ : L) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean (L792)
  • lemma evalWAt_eq_W (i : Fin r) (x : L) : in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean (L125)
  • lemma finalSumcheckStep_is_logic_complete : in ArkLib/ProofSystem/Binius/BinaryBasefold/ReductionLogic.lean (L686)
  • theorem twiddleFactor_eq_twiddleFactor in ArkLib/Data/FieldTheory/AdditiveNTT/Impl.lean (L439)
  • lemma getMidCodewords_succ (t : MultilinearPoly L ℓ) (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Relations.lean (L177)
  • lemma prob_uniform_suffix_mem in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/BadBlocks.lean (L260)
  • theorem sumcheckFoldOracleVerifier_rbrKnowledgeSoundness : in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean (L973)
  • lemma batchingStep_is_logic_complete : in ArkLib/ProofSystem/Binius/RingSwitching/BatchingPhase.lean (L239)
  • lemma computablePolynomialFromNovelCoeffs_eval_eq [BEq L] [LawfulBEq L] in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean (L1674)
  • lemma MLPEvalRelation_of_round0_local_and_structural in ArkLib/ProofSystem/Binius/RingSwitching/BBFSmallFieldIOPCS.lean (L329)
  • lemma lastBlockOracleReduction_perfectCompleteness (hInit : NeverFail init) : in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean (L845)
  • theorem property (p : MultilinearPoly L ℓ) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean (L231)
  • theorem property (p : MultiquadraticPoly L ℓ) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean (L251)
  • lemma foldStep_is_logic_complete (i : Fin ℓ) : in ArkLib/ProofSystem/Binius/BinaryBasefold/ReductionLogic.lean (L305)
  • lemma witnessStructuralInvariant_MLPEvalWitness_to_BBF_Witness in ArkLib/ProofSystem/Binius/RingSwitching/BBFSmallFieldIOPCS.lean (L236)
  • def computeInitialSumcheckPoly (t : MultilinearPoly L ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean (L721)
  • lemma computableW_toPoly_eq_W [BEq L] [LawfulBEq L] (i : Fin r) : in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean (L1649)
  • theorem queryOracleVerifier_rbrKnowledgeSoundness {σ : Type} (init : ProbComp σ) in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean (L896)
  • def lastBlockRbrKnowledgeError (k : (pSpecLastBlock (L in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean (L866)
  • theorem fullOracleReduction_perfectCompleteness (hInit : NeverFail init) : in ArkLib/ProofSystem/Binius/BinaryBasefold/General.lean (L132)
  • theorem largeFieldInvocationOracleReduction_perfectCompleteness (hInit : NeverFail init) : in ArkLib/ProofSystem/Binius/RingSwitching/BBFSmallFieldIOPCS.lean (L316)
  • lemma sumcheckStep_is_logic_complete (i : Fin ℓ') : in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean (L231)
  • lemma finToBinaryCoeffs_sDomainToFin (i : Fin r) (h_i : i < ℓ + R_rate) in ArkLib/Data/FieldTheory/AdditiveNTT/Impl.lean (L307)
  • lemma finToBinaryCoeffs_sDomainToFin (i : Fin r) (h_i : i < ℓ + R_rate) in ArkLib/Data/FieldTheory/AdditiveNTT/Impl.lean (L330)
  • theorem fullOracleVerifier_knowledgeSoundness : in ArkLib/ProofSystem/Binius/FRIBinius/General.lean (L481)
  • lemma prop_4_21_case_2_fiberwise_far (i : Fin ℓ) (steps : ℕ) [NeZero steps] in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/Proposition4_21.lean (L397)
  • lemma logical_checkSingleRepetition_of_mem_support_forIn_body {σ : Type} : True in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean (L489)
  • lemma hammingDist_le_fiberwiseDistance_mul_two_pow_steps (i : Fin r) {destIdx : Fin r} (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean (L603)
  • theorem iteratedSumcheckOracleVerifier_rbrKnowledgeSoundness (i : Fin ℓ') : in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean (L605)
  • lemma batching_target_consistency in ArkLib/ProofSystem/Binius/RingSwitching/Prelude.lean (L1318)
  • lemma commitStep_is_logic_complete (i : Fin ℓ) (hCR : isCommitmentRound ℓ ϑ i) : in ArkLib/ProofSystem/Binius/BinaryBasefold/ReductionLogic.lean (L500)
  • def batchingKnowledgeStateFunction : in ArkLib/ProofSystem/Binius/RingSwitching/BatchingPhase.lean (L408)
  • def batchingKnowledgeStateFunction : in ArkLib/ProofSystem/Binius/RingSwitching/BatchingPhase.lean (L410)
  • lemma evaluationPointω_eq_twiddleFactor_of_div_2 (i : Fin r) (h_i : i < ℓ) in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean (L2229)
  • lemma logical_computeFoldedValue_eq_iterated_fold in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/QueryPhasePrelims.lean (L558)
  • lemma batchingMismatchPoly_nonzero_of_embed_ne in ArkLib/ProofSystem/Binius/RingSwitching/BatchingPhase.lean (L718)
  • def bbfMLIOPCS : MLIOPCS L ℓ' in ArkLib/ProofSystem/Binius/RingSwitching/BBFSmallFieldIOPCS.lean (L416)
  • def bbfMLIOPCS : MLIOPCS L ℓ' in ArkLib/ProofSystem/Binius/RingSwitching/BBFSmallFieldIOPCS.lean (L419)
  • def bbfMLIOPCS : MLIOPCS L ℓ' in ArkLib/ProofSystem/Binius/RingSwitching/BBFSmallFieldIOPCS.lean (L423)
  • theorem lastBlockOracleVerifier_rbrKnowledgeSoundness : in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean (L878)
  • def extractMLP (i : Fin ℓ) (f : (sDomain 𝔽q β h_ℓ_add_R_rate) ⟨i, by omega⟩ → L) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean (L1053)
  • lemma checkSingleRepetition_inner_forIn_probFailure_eq_zero : True in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean (L464)
  • theorem multilinear_eval_eq_sum_bool_hypercube [DecidableEq L] [IsDomain L] in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean (L608)
  • lemma computablePolynomialFromNovelCoeffs_toPoly_eq [BEq L] [LawfulBEq L] in ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean (L1667)
  • lemma iterated_fold_to_level_ℓ_is_constant in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean (L2532)
  • lemma foldMatrix_det_ne_zero (i : Fin r) {destIdx : Fin r} (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean (L1399)
  • theorem ext {p q : MultilinearPoly L ℓ} in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean (L235)
  • theorem ext {p q : MultiquadraticPoly L ℓ} in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean (L259)
  • lemma probability_bound_badSumcheckEventProp (h_i h_star : FoldMessage L) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness.lean (L54)
  • lemma batching_check_correctness in ArkLib/ProofSystem/Binius/RingSwitching/Prelude.lean (L802)
  • lemma fixFirstVariablesOfCMvPoly_val_eq [BEq L] [LawfulBEq L] (v : Fin (ℓ + 1)) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean (L464)

🎨 **Style Guide Adherence**

This review follows the ArkLib style guide. There are more than 20 violations, so they have been grouped by rule.

Naming Conventions

  • Rule: "Treat acronyms as words (e.g., HtmlParser not HTMLParser)." (Found throughout the project; >20 instances)
    • ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean: Namespace AdditiveNTT should be AdditiveNtt.
    • ArkLib/Data/MvPolynomial/MultilinearComputational.lean: CMLE' should be Cmle'.
    • ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean: MultilinearPoly and MultiquadraticPoly are fine, but MLE and MLE' should be Mle and Mle'.
    • ArkLib/ProofSystem/Binius/RingSwitching/BBFSmallFieldIOPCS.lean: bbfMLIOPCS should be bbfMliopcs.

Syntax and Formatting

  • Rule: "Keep lines under 100 characters." (Found throughout the project; >50 instances)

    • ArkLib/Data/FieldTheory/AdditiveNTT/Impl.lean:87: Line length is 102 characters.
    • ArkLib/Data/FieldTheory/AdditiveNTT/Impl.lean:201: Line length is 105 characters.
    • ArkLib/Data/FieldTheory/AdditiveNTT/Impl.lean:454: Line length is 106 characters.
  • Rule: "Prefer fun x ↦ ... over λ x, ...." (Note: Also applies to => in function definitions; >100 instances)

    • ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean:101: fun j => should be fun j ↦
    • ArkLib/Data/FieldTheory/AdditiveNTT/Impl.lean:25: fun i => arr[i] should be fun i ↦ arr[i]
    • ArkLib/Data/MvPolynomial/MultilinearComputational.lean:62: fun j _ => ?_ should be fun j _ ↦ ?_
  • Rule: "Put spaces on both sides of :, :=, and infix operators." (>20 instances)

    • ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean:94: ∀ c: 𝔽q, (missing space before :)
    • ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean:2130: (⟨k, hk⟩: Fin ...) (missing space before :)
    • ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean:2136: (x.val % 2: ℕ) (missing space before :)
  • Rule: "Place by at the end of the line preceding the tactic block." (>15 instances)

    • ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean:2226: ... x = on line 2225, by on 2226.
    • ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean:2608: ... i) := on line 2607, by on 2608.
    • ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean:406: ... 2] msgPoly on 405, CPoly... on 406.
  • Rule: "Avoid empty lines inside definitions or proofs." (>10 instances)

    • ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean:98: Empty line inside lemma 𝔽q_element_eq_zero_or_eq_one.
    • ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean:102: Empty line inside bitsToUValue.
    • ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean:516: Empty line inside roots_W.
  • Rule: "Use the where syntax for defining instances and structures." (>10 instances)

    • ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean:372: instance instOracleStatementBinaryBasefold ... := fun j => { ... } should use where.
    • ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean:547: instance {i : Fin ℓ} : ... := by ... should use where.

Documentation Standards

  • Rule: "Every definition and major theorem should have a docstring." (>30 instances)
    • ArkLib/Data/FieldTheory/AdditiveNTT/Impl.lean:24: Array.toFinVec is missing a docstring.
    • ArkLib/Data/FieldTheory/AdditiveNTT/Impl.lean:28: List.prod_finRange_eq_finset_prod is missing a docstring.
    • ArkLib/Data/MvPolynomial/ComputableDegreeLE.lean:31: abbrev degreeLE is missing a docstring.
    • ArkLib/Data/MvPolynomial/ComputableDegreeLE.lean:40: def val is missing a docstring.

Variable Conventions

  • Rule: "α, β, γ, ... : Generic types" (>10 instances)
    • ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean:100: (β : Fin r → L) uses β for a function/basis term rather than a generic type.
    • ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean:181: (𝓑 : Fin 2 ↪ L) uses 𝓑 (similar to β) for a term.
    • ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean:279: γ_repetitions is used as a term, which is fine, but the rule suggests γ should be a type.

📄 **Per-File Summaries**
  • ArkLib.lean: This change updates the top-level ArkLib.lean file to import new modules related to Additive NTT implementations, novel polynomial bases, and computational multivariate polynomial properties. These additions integrate recent developments in efficient field theory and multilinear polynomial representations into the library’s main entry point.
  • ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean: The changes introduce a set of executable primitives (such as evalNormalizedWAt and bitsToUValue) to transition the Additive NTT implementation from noncomputable definitions toward a computable version. While new definitions and "bridge" theorems are added to link computable functions with their mathematical counterparts, several core correctness proofs—including NTTStage_correctness and additiveNTT_correctness—have been commented out or replaced with sorry placeholders during this refactoring.
  • ArkLib/Data/FieldTheory/AdditiveNTT/Impl.lean: This file introduces computable implementations of the Additive NTT algorithm and its associated domain indexing primitives under the AdditiveNTT.Comp namespace. It establishes bridge theorems to link these executable definitions with the library's existing canonical theory, though several proofs and definitions currently contain sorry placeholders.
  • ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean: This file introduces the definition and theory of the "novel polynomial basis" for Additive NTTs, formalizing subspace vanishing polynomials ($W_i$) and proving their $\mathbb{F}_q$-linearity and basis properties. It provides change-of-basis functions between this and the monomial basis, as well as "computable" executable versions for use in implementations. Notably, several lemmas linking the non-computable definitions to their computable counterparts currently contain sorry placeholders.
  • ArkLib/Data/MvPolynomial/ComputableDegreeLE.lean: This file introduces CPoly.CMvPolynomial.degreeLE, a computable subtype for multivariate polynomials with variable degrees bounded by a constant, and provides specialized aliases for multilinear and multiquadratic types. It establishes a bridge to Mathlib's MvPolynomial carrier and defines an equivalence between bounded-degree univariate polynomials and coefficient vectors. Several proofs regarding the degree restriction and the univariate equivalence currently contain sorry placeholders.
  • ArkLib/Data/MvPolynomial/Multilinear.lean: This change introduces the MLE'_eval_zeroOne theorem, a new simp lemma that characterizes the evaluation of the MLE' multilinear extension on binary inputs. The theorem proves that evaluating MLE' at a point in ${0, 1}^n$ matches the original evaluations indexed by the finFunctionFinEquiv mapping.
  • ArkLib/Data/MvPolynomial/MultilinearComputational.lean: This file introduces a computable multilinear extension CMLE' using the CMvPolynomial carrier, providing several new definitions and theorems to support the Binius protocol. It establishes evaluation parity between CMLE' and the standard MLE' via the fromCMvPolynomial_CMLE'_eq_MLE' theorem. No sorry or admit placeholders are included.
  • ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean: This refactor migrates the sumcheck and oracle consistency definitions to use computable multivariate polynomial types (CMvPolynomial) and the OracleFunction abstraction. The changes introduce several new theorems and definitions for converting between polynomial representations, but notably replace many previously detailed proofs with sorry placeholders.
  • ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean: This refactor updates the BBF_Code definitions and related Hamming distance properties to utilize refined domain types from AdditiveNTT.Comp. The changes include structural updates to fiberwise disagreement sets and unique decoding radius lemmas, but significantly, many proofs and the extractUDRCodeword implementation have been replaced with sorry placeholders.
  • ArkLib/ProofSystem/Binius/BinaryBasefold/Compliance.lean: This refactors the fold_error_containment definition and associated lemmas to use the OracleFunction abstraction and removes several redundant omit directives for typeclass constraints. The changes also simplify the proof of fold_error_containment_of_UDRClose by streamlining intermediate steps and variable handling.
  • ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean: This refactor updates the composition of oracle verifiers and reductions for the Binius core interaction phase, specifically modifying how prover arguments are passed through the fold, relay, and commit rounds. While it refines the structural definitions and type signatures of the protocol's recursive blocks, it replaces nearly all complex proofs for perfect completeness and knowledge soundness with sorry placeholders.
  • ArkLib/ProofSystem/Binius/BinaryBasefold/General.lean: This PR refactors the core Binary Basefold protocol definitions (fullOracleVerifier, fullOracleReduction, and fullOracleProof) to be computable and updates their documentation. Notably, it removes the existing proofs for perfect completeness and knowledge soundness, replacing them with sorry placeholders.
  • ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean: This update transitions the Binary Basefold prelude from abstract multivariate polynomials to computable representations (using CPoly and CMvPolynomial) and introduces new definitions for message folding and fiber point indexing. It adds several lemmas and theorems to support this computable framework, though many proofs—including those for evaluations and variable substitutions—currently contain sorry placeholders.
  • ArkLib/ProofSystem/Binius/BinaryBasefold/ReductionLogic.lean: The changes refactor the foldStepLogic and commitStepLogic definitions to improve the routing of prover-side fields and remove the noncomputable section requirement. Notably, the update modifies several proofs by replacing extensive formal logic with sorry placeholders, effectively deferring proof obligations for the completeness and consistency lemmas of the folding and sumcheck steps.
  • ArkLib/ProofSystem/Binius/BinaryBasefold/Relations.lean: This file refactors the Binary Basefold relations by transitioning from generic polynomials to more specific types like FoldMessage, MultiquadraticPoly, and CPolynomial to improve definition structure and computability. The folding logic in getMidCodewords and prover state transitions was rewritten to use explicit index mapping and Fin.dfoldl, moving away from high-level iterated folding. Several proofs and lemmas, including getMidCodewords_succ and consistency preservation properties, were modified or replaced with sorry placeholders during this refactor.
  • ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness.lean: This change refactors the probability_bound_badSumcheckEventProp lemma to utilize the FoldMessage type instead of raw degree-2 polynomials. The update modifies the lemma's signature and replaces the existing proof with a sorry placeholder.
  • ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/BadBlocks.lean: Replaces the proof of the lemma prob_uniform_suffix_mem with a sorry placeholder and updates several type signatures to use fully qualified names. The change also reduces the maxHeartbeats limit for the file.
  • ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/FoldDistance.lean: This file modifies existing lemmas and proofs related to fold distance soundness by refining the representation of fibers and domains. It replaces general sDomain types with AdditiveNTT.Comp.sDomain and updates fiber-agreement logic to use qMap_total_fiber, simplifying the proofs and removing redundant typeclass omissions. No new sorry or admit placeholders were introduced.
  • ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/Incremental.lean: This refactor updates type signatures to use AdditiveNTT.Comp.sDomain and removes several unnecessary typeclass omissions. Most significantly, the changes replace the proofs for several key theorems—including the affine proximity gap bound and the fiberwise closeness results for incremental folding—with sorry placeholders.
  • ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/Lift.lean: This update stubs out several core definitions and theorems related to the Binius Binary Basefold lifting mechanism and distance properties, replacing their implementations and proofs with sorry placeholders. Additionally, it refines the fiberDiff definition to utilize qMap_total_fiber and reduces the maxHeartbeats configuration for the file.
  • ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/Proposition4_21.lean: This update refactors the definitions used in the soundness proof for Proposition 4.21, specifically namespacing sDomain and adding set coercions to disagreement sets. Notably, the proofs for the three primary lemmas in this file have been commented out and replaced with sorry placeholders, indicating an ongoing revision of the formalization.
  • ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/QueryPhasePrelims.lean: This refactor updates the Query Phase helper functions and lemmas to utilize the AdditiveNTT.Comp domain types, aligning the formal soundness definitions with the migrated computable verifier. The changes modify several core definitions and logical specifications for folding consistency, but introduce multiple sorry placeholders, replacing many previously established proofs during the transition.
  • ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/QueryPhaseSoundness.lean: This refactor updates several query phase soundness theorems and lemmas to use more specific domain types and explicit folding parameters (ϑ). Crucially, the changes introduce multiple sorry placeholders, stubbing out the previously complete proofs for Lemma 4.25 and Proposition 4.23.
  • ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean: This update refines the Binary Basefold protocol specification by replacing manual polynomial degree bounds with the FoldMessage type and integrating domain definitions from the additive NTT implementation. It introduces several SampleableType and Fintype instances to support these updated types, shifting several declarations to be noncomputable. No sorry or admit placeholders were added.
  • ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/Commit.lean: The changes refactor core "Commit" step definitions and the extractor to be computable by removing noncomputable modifiers and transitioning to the OracleFunction type. Notably, the proofs for commitOracleReduction_perfectCompleteness and commitOracleVerifier_rbrKnowledgeSoundness have been replaced with sorry placeholders.
  • ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/FinalSumcheck.lean: This update refactors the final sumcheck step to improve computability by introducing a Decidable instance for verifier checks and removing several noncomputable markers. While it updates polynomial types and internal logic for consistency, it introduces multiple sorry placeholders in the completeness theorem and the round-by-round knowledge soundness proofs that require further implementation.
  • ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/Fold.lean: This file refactors the prover, verifier, and extraction logic for the Binius Binary Basefold "Fold" step to utilize the FoldMessage type and improve the computability of the protocol's components. While it introduces a decidability instance for verifier checks, it significantly modifies several core proofs for perfect completeness and knowledge soundness by replacing their implementations with sorry placeholders.
  • ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/Relay.lean: This update makes several core definitions for the Binius relay step computable, including the oracle prover, verifier, reduction, and extractor. It also refines proof dependencies by removing unnecessary omit statements across several lemmas and theorems. No sorry or admit placeholders were added.
  • ArkLib/ProofSystem/Binius/RingSwitching/BBFSmallFieldIOPCS.lean: This change refactors the Binary Basefold (BBF) multilinear polynomial commitment scheme to integrate with computable multilinear polynomial representations and updates context lenses for the ring-switching protocol. Crucially, the update stubs out a significant portion of the formal verification logic, replacing several complex proofs for completeness, structural invariants, and knowledge soundness with sorry placeholders.
  • ArkLib/ProofSystem/Binius/RingSwitching/BatchingPhase.lean: This update refactors the BatchingPhase infrastructure for the Binius Ring Switching protocol, updating definitions for the prover, verifier, and round-by-round extractor to align with new polynomial representations. The changes modify existing logic for completeness and soundness but introduce several sorry placeholders, leaving the primary theorems and helper lemmas—including knowledge soundness and perfect completeness—unproven in this version.
  • ArkLib/ProofSystem/Binius/RingSwitching/General.lean: This change updates the fullOracleVerifier_rbrKnowledgeSoundness proof by explicitly passing required basis and implementation parameters to the sub-verifiers and their corresponding soundness lemmas. Additionally, it refines the scope of the noncomputable attribute, moving it from the section level to specific knowledge error definitions.
  • ArkLib/ProofSystem/Binius/RingSwitching/Prelude.lean: This file refactors the Binius ring-switching preliminaries to transition from abstract multilinear polynomials to computable CPoly.CMvPolynomial representations. It introduces new definitions for tensor algebra decomposition and computable sumcheck witness utilities, alongside several supporting simp lemmas. Notably, multiple complex proofs (such as batching_target_consistency and unpack_pack_id) have been modified and currently contain sorry placeholders following this architectural migration.
  • ArkLib/ProofSystem/Binius/RingSwitching/Spec.lean: This change refines the Binius ring-switching protocol specification by introducing the SumcheckRoundMessage type abbreviation to replace hardcoded polynomial types, improving consistency with other sumcheck implementations. It updates the pSpecSumcheckRound definition and its associated Inhabited instance to use this new alias, while also narrowing the scope of noncomputable declarations. No sorry or admit placeholders were added.
  • ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean: This refactor updates the sumcheck phase of the Binius ring-switching protocol by adopting FoldMessage and CPoly abstractions for polynomial handling and evaluation. While the changes clean up namespacing and transition several definitions from noncomputable to computable, they also introduce numerous sorry placeholders that stub out previously established proofs for completeness and knowledge soundness.
  • ArkLib/ProofSystem/Sumcheck/Spec/General.lean: This change updates the module documentation to describe the security theorems for the sum-check protocol, specifically perfect completeness and knowledge soundness. It also clarifies how these theorems are utilized by downstream extraction and verification tools.
  • ArkLib/ProofSystem/Sumcheck/Spec/SingleRound.lean: This update completes the definition of oracleVerifier by implementing the logic to query message and statement oracles and verify the sum-check property. Crucially, it replaces a sorry placeholder with a concrete implementation that returns the new target and challenge.
  • ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean: This refactor introduces executable, index-based verification logic for the query phase, replacing abstract domain point queries with deterministic search-based decoding. It adds several new definitions for index-based folding checks and updates the prover and verifier structures accordingly. Numerous complex proofs for soundness and completeness have been replaced with sorry placeholders.
  • ArkLib/ProofSystem/Binius/FRIBinius/General.lean: This refactor modularizes the FRI-Binius protocol stack by introducing "executable" variants of verifiers, reductions, and proofs that accept explicit basis and sumcheck multiplier parameters. The update refines the protocol specifications and knowledge error definitions to accommodate these changes, but it replaces several complex security proofs—including completeness and round-by-round knowledge soundness—with sorry placeholders.
  • ArkLib/ProofSystem/Binius/FRIBinius/CoreInteractionPhase.lean: This file refactors the Binius FRI core interaction phase to use explicit basis functions and multiplier parameters in new executable ("Exec") versions of the verifiers, provers, and oracle reductions. While these changes introduce more flexible definitions and lenses for the protocol, the majority of the file's proofs—including those for perfect completeness and round-by-round knowledge soundness—have been replaced with sorry placeholders.

Last updated: 2026-04-12 14:44 UTC.

@chung-thai-nguyen
Copy link
Copy Markdown
Collaborator Author

@codex

chatgpt-codex-connector[bot]

This comment was marked as outdated.

Copy link
Copy Markdown

@chatgpt-codex-connector chatgpt-codex-connector bot left a comment

Choose a reason for hiding this comment

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

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: a12e702613

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

  • Open a pull request for review
  • Mark a draft as ready
  • Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

Comment on lines +1069 to +1071
(pSpec := pSpecCoreInteraction 𝔽q β (ϑ := ϑ) (h_ℓ_add_R_rate := h_ℓ_add_R_rate)) := by
let _ := 𝓑
sorry
Copy link
Copy Markdown

Choose a reason for hiding this comment

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

P1 Badge Restore concrete core-interaction verifier composition

coreInteractionOracleVerifier is now an opaque placeholder (sorry) instead of the previous OracleVerifier.append composition of sumcheck-fold and final-sumcheck verifiers. This removes the actual verifier control flow from the executable protocol surface, so downstream constructions that rely on this verifier no longer enforce the intended transcript/message sequence at runtime.

Useful? React with 👍 / 👎.

Copy link
Copy Markdown
Collaborator Author

Choose a reason for hiding this comment

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

@cursor check if this is fixed now?

Copy link
Copy Markdown

Choose a reason for hiding this comment

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

Taking a look!

Open in Web Open in Cursor 

Comment on lines +86 to +87
| some vIdx => vIdx
| none => 0
Copy link
Copy Markdown

Choose a reason for hiding this comment

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

P2 Badge Fail closed when query-point decoding has no index match

The new index-based query verifier path silently defaults to index 0 when queryPointToIndex cannot find a matching preimage. That changes control flow from a decoding failure into querying the first codeword point, which can make verification depend on unrelated oracle values instead of rejecting malformed/unmapped challenges. This branch should return failure (e.g., Option.none) and propagate rejection.

Useful? React with 👍 / 👎.

Copy link
Copy Markdown
Collaborator Author

Choose a reason for hiding this comment

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

@cursor check again whether all oracle defs in Binius and their dependencies have been migrated? No hidden sorrys & no remaining non-computable oracle defs? All security statements are migrated too?

Copy link
Copy Markdown

@cursor cursor bot Apr 12, 2026

Choose a reason for hiding this comment

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

Here is a fresh pass over ArkLib/ProofSystem/Binius/ (and the thread’s scope).

Oracle definitions: not fully “migrated” in the strong sense

  • Across Binius there are sorry / admit in many .lean files (BinaryBasefold, FRIBinius, RingSwitching, plus Soundness/). A single grep run lists well over 100 occurrences spread across those modules. So the story is not “everything is migrated with no gaps.”
  • A few files under Binius have no sorry (e.g. Compliance.lean, Relay.lean, FoldDistance.lean, FRIBinius/Prelude.lean, RingSwitching/Spec.lean, RingSwitching/General.lean), but that is not true for the subtree as a whole.

So: oracle specs and many executable definitions are in place, but proofs and some glue are still explicitly incomplete (sorry).

“Hidden” sorrys

  • There is no evidence of hidden axioms: gaps are open sorry in normal source (plus comments like “Original proof sorry’d for migration” in places such as Fold.lean / Commit.lean). Nothing suggests concealed sorry beyond ordinary repo search.

Non-computable pieces

  • Main oracle verifiers / reductions are generally computable defs where that matters.
  • Remaining noncomputable items are mostly not the core protocol gadgets but things like:
    • coreInteractionOracleRbrKnowledgeError (and the FRIBinius copy): ℝ≥0 error bookkeeping (analysis-style).
    • FinalSumcheck.lean: private noncomputable def finalOracleDecoded* (legacy / abstract decoding helpers).
    • Spec.lean: a noncomputable instance for Fintype on a query type (often unavoidable with classical finiteness).
  • So: some noncomputable remains, but it is not “the whole oracle layer is still abstract”; it is localized (errors, some helpers, classical instances).

Security statements

  • Not fully migrated. Examples of unfinished security surface:
    • BinaryBasefold/General.lean, CoreInteractionPhase.lean, Soundness/*.lean, FRIBinius/General.lean, FRIBinius/CoreInteractionPhase.lean, large parts of RingSwitching and Query soundness, etc., still contain sorry on completeness / knowledge / soundness theorems.
  • That matches the PR checklist: “Spec migration” checked, “Proof migration” unchecked.

Bottom line: No — you cannot honestly claim “all oracle defs and dependencies migrated, no sorrys, no leftover noncomputable oracle defs, and all security statements migrated.” The repo state is explicitly partial: executable protocol structure is largely there; proofs and some analysis/error paths are still admitted or noncomputable where noted above. If you want this tracked for reviewers, the PR Status section is already accurate; the only “action” from an audit is to keep “Proof migration” unchecked until those sorrys are reduced or replaced.

Open in Web Open in Cursor 

  computable-only

  - rename coreInteractionOracleReductionExec ->
  coreInteractionOracleReduction
  - remove noncomputable coreInteractionOracleReduction
  - define explicit computable core-interaction reduction
  composition in CoreInteractionPhase
  - remove threaded coreInteractionProver workaround from
  FRIBinius/General wrappers/theorem
chatgpt-codex-connector[bot]

This comment was marked as low quality.

chatgpt-codex-connector[bot]

This comment was marked as low quality.

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.

1 participant