Skip to content

feat: completeness and rbrKnowledgeSoundness of FRI-Binius protocols#383

Draft
chung-thai-nguyen wants to merge 30 commits intomainfrom
completeness-of-binius
Draft

feat: completeness and rbrKnowledgeSoundness of FRI-Binius protocols#383
chung-thai-nguyen wants to merge 30 commits intomainfrom
completeness-of-binius

Conversation

@chung-thai-nguyen
Copy link
Copy Markdown
Collaborator

@chung-thai-nguyen chung-thai-nguyen commented Mar 3, 2026

[x] Completeness/Soundness unfolding tools & snippets - mainly tools for converting the monadic defs into the logical defs (Completeness.lean, ReductionLogic.lean, Simulation.lean, Lemmas.lean) + new cast definition of oracle reduction (OracleReduction/Cast.lean) with completeness/rbrks compatibility
[x] Completeness & rbrKnowledgeSoundness for all FRI-Binius protocols: Binary Basefold, Ring-switching, FRI-Binius, simple ring-switching construction (BBFSmallFieldIOPCS), completeness of BBFSmallFieldIOPCS
[x] Minor changes: reintroduce AdditiveNTT.lean with index changes, will be migrated to CompPoly later

Status: Fully proved (no sorrys remaining)

Built with the help of Codex, Claude, Cursor, Gemini.

@github-actions
Copy link
Copy Markdown

github-actions bot commented Mar 3, 2026

🤖 Gemini PR Summary

Formalizes completeness and round-by-round knowledge soundness (RBRKS) for the FRI-Binius protocol suite, including Binary Basefold and Ring-switching constructions.

Mathematical Formalization

  • Additive NTT & Coding Theory: Implements the FRI-Binius variant of the Additive NTT algorithm. Adds properties for Reed-Solomon codes, multilinear weight decompositions, and the relationship between fiberwise agreement and folded codeword distance.
  • Security Invariants: Formalizes results from Diamond and Posen (2024), specifically Lemma 4.22 (interleaved-distance lower bounds) and Lemma 4.25 (disagreement transfer).
  • Core Propositions: Establishes Proposition 4.21 (bad folding event probability) and Proposition 4.24 (query phase soundness), yielding a concrete scalar knowledge soundness bound for Binary Basefold.
  • Probability & Folding: Adds Schwartz-Zippel bounds for univariate polynomials and product rules for independent repetitions. Formalizes butterflyMatrix and the connection between pointwise folding and polynomial evaluation.

Infrastructure & Oracle Reductions

  • Monadic-to-Logical Translation: Introduces tools in Completeness.lean and ReductionLogic.lean to convert monadic oracle definitions into logical predicates for property verification.
  • Modular Reductions: Adds OracleReduction/Cast.lean to enable oracle statement routing and type-safe transformations while preserving security properties.
  • Simulation Framework: Implements simulation oracles based on deterministic transcript lookups and refactors OracleVerifier.run to establish equivalences between oracle-based and non-oracle reductions.
  • Indexing Utilities: Introduces OracleFrontierIndex for mapping oracle positions to evaluation domain indices and provides general utilities for block matrix determinants and vector reindexing.

Protocol Implementations

  • Establishes completeness and RBRKS for Binary Basefold, Ring-switching, and FRI-Binius.
  • Formalizes the BBFSmallFieldIOPCS ring-switching construction and its completeness proof.
  • Sequentially composes Fold, Commit, and Sumcheck steps to prove aggregate security properties.

Proof Status & Placeholders

Note: A discrepancy exists between the PR body ("Fully proved") and the actual source code. The following sorry placeholders remain:

  • ArkLib/OracleReduction/Security/RoundByRound.lean: Incomplete proof for rbrKnowledgeSoundnessOneShot_implies_rbrKnowledgeSoundness.
  • ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean: The theorem iterated_fold_transitivity remains unproven.

Refactoring

  • Architecture: Decomposes the Binary Basefold implementation into a structured Steps/ directory, isolating logic for folding, commitment, and sum-check rounds.
  • Proof Maintenance: Refactors high-level proofs in DivergenceOfSets.lean and AffineSpaces.lean to use structured calc blocks and explicit tactics over fragile automation.
  • NTT Migration: Reintroduces AdditiveNTT.lean with updated indexing in preparation for CompPoly migration.

Note: The diff was too large and was truncated.


Statistics

Metric Count
📝 Files Changed 53
Lines Added 39876
Lines Removed 3935

Lean Declarations

✏️ **Removed:** 77 declaration(s)
  • theorem relayOracleReduction_perfectCompleteness (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps.lean
  • def oracleFoldingConsistencyProp (i : Fin (ℓ + 1)) (challenges : Fin i → L) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • def foldKnowledgeStateFunction (i : Fin ℓ) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps.lean
  • def extractNextSuffixFromChallenge (v : sDomain 𝔽q β h_ℓ_add_R_rate ⟨0, by omega⟩) in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean
  • def foldPrvState (i : Fin ℓ) : Fin (2 + 1) → Type in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps.lean
  • def getNextOracle (i : Fin (ℓ + 1)) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • theorem finalSumcheckOracleReduction_perfectCompleteness {σ : Type} in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps.lean
  • def finalNonDoomedFoldingProp {h_le : ϑ ≤ ℓ} in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • def roundRelationProp (i : Fin (ℓ + 1)) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • abbrev MultilinearPoly (L : Type) [CommSemiring L] (ℓ : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • theorem foldOracleVerifier_rbrKnowledgeSoundness (i : Fin ℓ) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps.lean
  • def witnessStructuralInvariant {i : Fin (ℓ + 1)} (stmt : Statement (L in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • lemma nonDoomedFoldingProp_relay_preserved (i : Fin ℓ) (hNCR : ¬ isCommitmentRound ℓ ϑ i) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • def finalSumcheckRelOutProp in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • def foldKStateProp {i : Fin ℓ} (m : Fin (2 + 1)) in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps.lean
  • def queryCodeword (j : Fin (toOutCodewordsCount ℓ ϑ (Fin.last ℓ))) in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean
  • theorem relayOracleVerifier_rbrKnowledgeSoundness (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps.lean
  • def proximityChecksSpec (γ_challenges : in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean
  • def badEventExistsProp in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • def fiberwiseDistance (i : Fin ℓ) (steps : ℕ) [NeZero steps] (h_i_add_steps : i.val + steps ≤ ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • abbrev fullInputRelation in ArkLib/ProofSystem/Binius/RingSwitching/General.lean
  • def finalSumcheckRelOut : in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • def challengeTensorProduct (steps : ℕ) (r_challenges : Fin steps → L) : Vector L (2 ^ steps) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • def nonDoomedFoldingProp (i : Fin (ℓ + 1)) (challenges : Fin i → L) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • abbrev fullOutputRelation in ArkLib/ProofSystem/Binius/RingSwitching/General.lean
  • def foldStepRelOut (i : Fin ℓ) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • def queryRbrKnowledgeError in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean
  • theorem foldOracleReduction_perfectCompleteness (i : Fin ℓ) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps.lean
  • def BBF_eq_multiplier (r : Fin ℓ → L) : MultilinearPoly L ℓ in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • lemma getFoldingChallenges_init_succ_eq (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • def getMidCodewords {i : Fin (ℓ + 1)} (t : L⦃≤ 1⦄[X Fin ℓ]) -- original polynomial t in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • def BBF_SumcheckMultiplierParam : SumcheckMultiplierParam L ℓ (SumcheckBaseContext L ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • def fiberwiseDisagreementSet (i : Fin ℓ) (steps : ℕ) [NeZero steps] in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • lemma oracleWitnessConsistency_relay_preserved in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • def localized_fold_eval (i : Fin ℓ) (steps : ℕ) (h_i_add_steps : i + steps ≤ ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • def finalSumcheckRbrKnowledgeError : ℝ≥0 in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean
  • lemma oracle_block_k_next_le (i : Fin (ℓ + 1)) (j : Fin (toOutCodewordsCount ℓ ϑ i)) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • def foldingBadEvent (i : Fin ℓ) (steps : ℕ) [NeZero steps] (h_i_add_steps : i + steps ≤ ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • lemma firstOracleWitnessConsistencyProp_relay_preserved (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • def fiberEvaluationMapping (i : Fin r) (steps : ℕ) (h_i_add_steps : i.val + steps < ℓ + 𝓡) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • theorem commitOracleVerifier_rbrKnowledgeSoundness (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps.lean
  • def BBF_CodeDistance (ℓ 𝓡 : ℕ) (i : Fin (ℓ + 1)) : ℕ in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • def commitKState (i : Fin ℓ) (hCR : isCommitmentRound ℓ ϑ i) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps.lean
  • def fiberwiseClose (i : Fin ℓ) (steps : ℕ) [NeZero steps] (h_i_add_steps : i.val + steps ≤ ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • def oracleWitnessConsistency in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • def foldKnowledgeError (i : Fin ℓ) (_ : (pSpecFold (L in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps.lean
  • def baseFoldMatrix (i : Fin r) (h_i : i + 1 < ℓ + 𝓡) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • def finalSumcheckKnowledgeError (m : pSpecFinalSumcheckStep (L in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps.lean
  • def hammingClose (i : Fin (ℓ + 1)) (f : OracleFunction 𝔽q β in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • theorem commitOracleReduction_perfectCompleteness (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps.lean
  • def nonLastBlockOracleReduction (bIdx : Fin (ℓ / ϑ - 1)) in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
  • abbrev MultiquadraticPoly (L : Type) [CommSemiring L] (ℓ : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • def commitKStateProp (i : Fin ℓ) (m : Fin (1 + 1)) in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps.lean
  • def foldStepRelOutProp (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • def BBF_Code (i : Fin (ℓ + 1)) : Submodule L ((sDomain 𝔽q β h_ℓ_add_R_rate) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • theorem finalSumcheckOracleVerifier_rbrKnowledgeSoundness [Fintype L] {σ : Type} in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps.lean
  • def finalSumcheckKStateProp {m : Fin (1 + 1)} (tr : Transcript m (pSpecFinalSumcheckStep (L in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps.lean
  • def uniqueClosestCodeword in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • def NBlockMessages in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
  • def getCommitProverFinalOutput (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps.lean
  • def relayKStateProp (i : Fin ℓ) (hNCR : ¬ isCommitmentRound ℓ ϑ i) in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps.lean
  • def masterKStateProp (stmtIdx : Fin (ℓ + 1)) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • lemma farness_implies_non_compliance (i : Fin ℓ) (steps : ℕ) [NeZero steps] in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • def commitPrvState (i : Fin ℓ) : Fin (1 + 1) → Type in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps.lean
  • def relayKnowledgeStateFunction (i : Fin ℓ) (hNCR : ¬ isCommitmentRound ℓ ϑ i) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps.lean
  • def getFoldingChallenges (i : Fin (ℓ + 1)) (challenges : Fin i → L) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • def commitKnowledgeError {i : Fin ℓ} in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps.lean
  • theorem fiberwise_dist_lt_imp_dist_lt_unique_decoding_radius (i : Fin ℓ) (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • abbrev MLPEvalStatement in ArkLib/ProofSystem/Binius/RingSwitching/Prelude.lean
  • def relayPrvState (i : Fin ℓ) : Fin (0 + 1) → Type in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps.lean
  • def nonLastBlockOracleVerifier (bIdx : Fin (ℓ / ϑ - 1)) in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
  • def FinalSumcheckWit in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps.lean
  • def roundRelation (i : Fin (ℓ + 1)) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • def disagreementSet (i : Fin ℓ) (steps : ℕ) [NeZero steps] (h_i_add_steps : i.val + steps ≤ ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • def relayKnowledgeError (m : pSpecRelay.ChallengeIdx) : ℝ≥0 in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps.lean
  • def sumcheckConsistencyProp {k : ℕ} (sumcheckTarget : L) (H : L⦃≤ 2⦄[X Fin (k)]) : Prop in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • def isCompliant (i : Fin (ℓ)) (steps : ℕ) [NeZero steps] in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
✏️ **Added:** 869 declaration(s)
  • lemma qMap_eval_mem_sDomain_succ (i : Fin r) {destIdx : Fin r} in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • lemma prop_4_21_case_1_fiberwise_close (i : Fin ℓ) (steps : ℕ) [NeZero steps] in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/Proposition4_21.lean
  • lemma getFoldingChallenges_init_succ_eq (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Relations.lean
  • abbrev queryBlockIdx (j : Fin (nBlocks (ℓ in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/QueryPhasePrelims.lean
  • def commitStepLogic (i : Fin ℓ) (hCR : isCommitmentRound ℓ ϑ i) : in ArkLib/ProofSystem/Binius/BinaryBasefold/ReductionLogic.lean
  • lemma not_jointProximityNat_of_not_jointProximityNat_split in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/Incremental.lean
  • lemma simulateQ_simOracle2_lift_liftComp_query_T1 in ArkLib/ToVCVio/Simulation.lean
  • theorem run'_pure_lib [Monad m] [LawfulMonad m] (x : α) (s : σ) : in ArkLib/ToVCVio/Lemmas.lean
  • theorem simulateQ_preserves_safety_stateful in ArkLib/ToVCVio/Simulation.lean
  • lemma simulateQ_simOracle2_liftM in ArkLib/ToVCVio/Simulation.lean
  • lemma mem_support_bind_iff {m : Type u → Type v} [Monad m] [HasEvalSPMF m] in ArkLib/ToVCVio/Lemmas.lean
  • theorem fullOracleVerifier_knowledgeSoundness_sum : in ArkLib/ProofSystem/Binius/RingSwitching/General.lean
  • def relayPrvState (i : Fin ℓ) : Fin (0 + 1) → Type in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/Relay.lean
  • lemma foldStep_doom_escape_probability_bound (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/Fold.lean
  • lemma AbstractOStmtIn.toStrictRelInput_subset_toRelInput (aOStmtIn : AbstractOStmtIn L ℓ') : in ArkLib/ProofSystem/Binius/RingSwitching/Prelude.lean
  • lemma challengeTensorExpansionMatrix_mulVec_F₂_eq_Fin_merge_PO2 [CommRing L] (n : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • lemma not_jointProximityNat_of_not_jointProximityNat_evenOdd_split in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/Incremental.lean
  • lemma probFailure_vector_mapM_eq_zero in ArkLib/ToVCVio/Simulation.lean
  • def foldStepRelOut (i : Fin ℓ) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Relations.lean
  • theorem probFailure_simulateQ_iff_stateful in ArkLib/ToVCVio/Simulation.lean
  • lemma lemma_4_24_dist_folded_ge_of_last_noncompliant (i_star : Fin ℓ) (steps : ℕ) [NeZero steps] in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/FoldDistance.lean
  • theorem neverFails_simOracle {ι : Type u} (oSpec : OracleSpec ι) in ArkLib/OracleReduction/OracleInterface.lean
  • def nonLastBlocksOracleReduction : in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
  • lemma incrementalBadEventExistsProp_fold_step_backward (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/Fold.lean
  • def sumcheckVerifierStmtOut (stmtIn : Statement (L in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean
  • instance instInhabitedPSpecBatchingChallenge : in ArkLib/ProofSystem/Binius/RingSwitching/Spec.lean
  • def relayKnowledgeStateFunction (i : Fin ℓ) (hNCR : ¬ isCommitmentRound ℓ ϑ i) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/Relay.lean
  • lemma dist_to_UDRCodeword_le_uniqueDecodingRadius (i : Fin r) (h_i : i ≤ ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
  • lemma fold_eq_multilinearCombine_preTensorCombine_step1 in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/Incremental.lean
  • lemma mem_support_queryFiberPoints in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean
  • lemma Fin.reindex_reindex_symm {R n m : Type*} [Fintype n] [Fintype m] in ArkLib/Data/Fin/BigOperators.lean
  • lemma point_disagreement_mem_fiberwiseDisagreement in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/QueryPhaseSoundness.lean
  • def AbstractOStmtIn.toStrictRelInput (aOStmtIn : AbstractOStmtIn L ℓ') : in ArkLib/ProofSystem/Binius/RingSwitching/Prelude.lean
  • def strictFoldStepRelOutProp (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Relations.lean
  • theorem run'_bind_pure [Monad m] [LawfulMonad m] {s : σ} (x : α) (f : α → StateT σ m β) : in ArkLib/ToVCVio/Lemmas.lean
  • theorem unroll_1_message_reduction_perfectCompleteness_V_to_P in ArkLib/OracleReduction/Completeness.lean
  • lemma prop_4_21_bad_event_probability (i : Fin ℓ) (steps : ℕ) [NeZero steps] in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/Proposition4_21.lean
  • theorem unroll_0_message_reduction_perfectCompleteness in ArkLib/OracleReduction/Completeness.lean
  • theorem intermediateNormVpoly_comp_qmap (i : Fin r) in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • lemma extractMLP_eq_some_iff_pair_UDRClose (f : (sDomain 𝔽q β h_ℓ_add_R_rate) ⟨0, by omega⟩ → L) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • lemma lemma_4_21_interleaved_word_UDR_far (i : Fin ℓ) (steps : ℕ) [NeZero steps] in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/Lift.lean
  • lemma mem_support_run_mk_iff {m : Type u → Type v} [Monad m] [HasEvalSPMF m] in ArkLib/ToVCVio/Lemmas.lean
  • lemma fiberwiseClose_congr_sourceDomain_index (sourceIdx₁ sourceIdx₂ : Fin r) {destIdx : Fin r} (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
  • theorem sDomainFin_bijective (i : Fin r) (h_i : i < ℓ + R_rate) in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • lemma incrementalBadEventExistsProp_relay_preserved (i : Fin ℓ) (hNCR : ¬ isCommitmentRound ℓ ϑ i) in ArkLib/ProofSystem/Binius/BinaryBasefold/Relations.lean
  • lemma roundRelation.of_fin_eq {i j : Fin (ℓ + 1)} (h : i = j) : in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
  • lemma OptionT.probOutput_none_bind_eq_zero_iff in ArkLib/ToVCVio/Simulation.lean
  • theorem soundness_unroll_runToRound_2_pSpec_2 in ArkLib/OracleReduction/Completeness.lean
  • theorem commitOracleReduction_perfectCompleteness (hInit : NeverFail init) (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/Commit.lean
  • theorem probEvent_soundness_goal_unroll_log' in ArkLib/OracleReduction/Completeness.lean
  • lemma run_liftM_run {α} {ι₁ ι₂ : Type} {spec₁ : OracleSpec ι₁} in ArkLib/ToVCVio/Lemmas.lean
  • theorem sumcheckFoldKnowledgeError_le : in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
  • lemma Matrix.from4Blocks_mul_from4Blocks {mTop mBot pLeft pRight nLeft nRight : ℕ} {α : Type*} in ArkLib/Data/Fin/BigOperators.lean
  • def finTwoPowAddTwoPowEquiv (n : ℕ) : Fin (2 ^ n + 2 ^ n) ≃ Fin (2 ^ (n + 1)) in ArkLib/Data/Fin/BigOperators.lean
  • def badSumcheckEventProp (r_i' : L) (h_i h_star : L⦃≤ 2⦄[X]) in ArkLib/ProofSystem/Binius/BinaryBasefold/Relations.lean
  • lemma natDegree_intermediateNormVpoly (i : Fin r) {k : ℕ} (h_k : i.val + k ≤ ℓ) : in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • lemma no_foldingBadEvent_of_no_bad_global in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/QueryPhaseSoundness.lean
  • def extractUDRCodeword in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
  • theorem oddRefinement_eq_novel_poly_of_1_leading_suffix (i : Fin r) (h_i : i < ℓ) (v : Fin (2 ^ i.val)) in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • lemma goodBlock_last_isCompliant in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/QueryPhaseSoundness.lean
  • theorem finalSumcheckOracleReduction_perfectCompleteness {σ : Type} in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/FinalSumcheck.lean
  • def extractSuffixFromChallenge (v : sDomain 𝔽q β h_ℓ_add_R_rate ⟨0, by omega⟩) in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/QueryPhasePrelims.lean
  • theorem bbf_fullOracleVerifier_rbrKnowledgeSoundness : in ArkLib/ProofSystem/Binius/RingSwitching/BBFSmallFieldIOPCS.lean
  • def bbfMLIOPCS : MLIOPCS L ℓ' where in ArkLib/ProofSystem/Binius/RingSwitching/BBFSmallFieldIOPCS.lean
  • lemma polyToOracleFunc_eq_getFirstOracle in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/QueryPhasePrelims.lean
  • lemma BBF_CodeDistance_eq (i : Fin r) (h_i : i ≤ ℓ) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
  • lemma support_OptionT_pure {m : Type u → Type v} [Monad m] [HasEvalSPMF m] in ArkLib/ToVCVio/Lemmas.lean
  • def BBF_SumcheckMultiplierParam : SumcheckMultiplierParam L ℓ (SumcheckBaseContext L ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Relations.lean
  • lemma probOutput_none_pure_eq_zero {m : Type u → Type v} [Monad m] [HasEvalSPMF m] in ArkLib/ToVCVio/Lemmas.lean
  • instance instFintypePspecCommitChallenge {i : Fin ℓ} : in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean
  • theorem castInOut_completeness in ArkLib/OracleReduction/Cast.lean
  • lemma qMap_total_fiber_congr_steps in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • lemma firstOracleWitnessConsistency_unique (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/Fold.lean
  • theorem QueryImpl_append_impl_inr_stateful in ArkLib/ToVCVio/Simulation.lean
  • lemma run_liftComp_eq {ι' : Type w} {spec : OracleSpec ι} {superSpec : OracleSpec ι'} in ArkLib/ToVCVio/Lemmas.lean
  • def queryCodeword (j : Fin (toOutCodewordsCount ℓ ϑ (Fin.last ℓ))) in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/QueryPhasePrelims.lean
  • lemma incrementalBadEventExistsProp_commit_step_backward (i : Fin ℓ) (hCR : isCommitmentRound ℓ ϑ i) in ArkLib/ProofSystem/Binius/BinaryBasefold/Relations.lean
  • lemma extractMLP_some_of_oracleFoldingConsistency in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/FinalSumcheck.lean
  • def foldKnowledgeStateFunction (i : Fin ℓ) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/Fold.lean
  • lemma lt_r_of_lt_ℓ {h_ℓ_add_R_rate : ℓ + 𝓡 < r} {x : ℕ} (h : x < ℓ) : x < r in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • lemma projectToMidSumcheckPoly_succ (t : MultilinearPoly L ℓ) (m : MultilinearPoly L ℓ) (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • lemma mem_ite_singleton {α : Type*} {c : Prop} [Decidable c] {a b x : α} : in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/Fold.lean
  • lemma probFailure_liftComp {ι' : Type w} {superSpec : OracleSpec ι'} in ArkLib/ToVCVio/Lemmas.lean
  • theorem simulateQ_preserves_safety in ArkLib/ToVCVio/Simulation.lean
  • lemma hammingDist_le_fiberwiseDistance_mul_two_pow_steps (i : Fin r) {destIdx : Fin r} (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
  • theorem lastBlockOracleVerifier_rbrKnowledgeSoundness : in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
  • lemma index_bound_check {ℓ i steps : ℕ} (j m : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • theorem probEvent_StateT_run_ignore_state {α : Type} in ArkLib/OracleReduction/Completeness.lean
  • lemma support_simulateQ_eq_OracleComp_of_superSpec {ι' : Type} {superSpec : OracleSpec ι'} in ArkLib/ToVCVio/Simulation.lean
  • lemma liftComp_forIn {ι ι' : Type} {spec : OracleSpec ι} {superSpec : OracleSpec ι'} in ArkLib/ToVCVio/Simulation.lean
  • def mkVerifierOStmtOut in ArkLib/OracleReduction/Basic.lean
  • instance instNeZeroNatToOutCodewordsCount : ∀ i, NeZero (toOutCodewordsCount ℓ ϑ i) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • def fiberwiseClose (i : Fin r) {destIdx : Fin r} (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
  • def roundRelation (i : Fin (ℓ + 1)) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Relations.lean
  • theorem probFailure_simulateQ_iff_stateful_run' in ArkLib/ToVCVio/Simulation.lean
  • lemma commitStep_j_is_last (i : Fin ℓ) (hCR : isCommitmentRound ℓ ϑ i) in ArkLib/ProofSystem/Binius/BinaryBasefold/ReductionLogic.lean
  • lemma foldingBadEventAtBlock_snoc_castSucc_eq (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Relations.lean
  • lemma mem_support_OptionT_pure_run_some_iff {m : Type u → Type v} [Monad m] [HasEvalSPMF m] in ArkLib/ToVCVio/Lemmas.lean
  • lemma extracted_t_poly_eval_eq_final_constant in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/FinalSumcheck.lean
  • def finalSumcheckRelOutProp in ArkLib/ProofSystem/Binius/BinaryBasefold/Relations.lean
  • lemma map_eval_sumToIter_rename_finSum_zero in ArkLib/ProofSystem/Binius/RingSwitching/BBFSmallFieldIOPCS.lean
  • lemma iterated_fold_to_level_ℓ_eval in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • example ϑ = 1 yields (2^{ℓ+𝓡} - 2^{𝓡})/|L| in the bad-event part alone). The one-sided inequality in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
  • def strictOracleFoldingConsistencyProp (t : MultilinearPoly L ℓ) (i : Fin (ℓ + 1)) in ArkLib/ProofSystem/Binius/BinaryBasefold/Relations.lean
  • theorem castOutSimple_id in ArkLib/OracleReduction/Cast.lean
  • lemma probFailure_simulateQ_liftQuery_add_none_eq in ArkLib/ToVCVio/Lemmas.lean
  • lemma projectToNextSumcheckPoly_eval_eq (i : Fin ℓ) (Hᵢ : MultiquadraticPoly L (ℓ - i)) (rᵢ : L) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • def fold_single_matrix_mul_form (i : Fin r) {destIdx : Fin r} in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • theorem nonLastSingleBlockOracleVerifier_rbrKnowledgeSoundness in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
  • lemma probFailure_liftM {ι' : Type w} {superSpec : OracleSpec ι'} in ArkLib/ToVCVio/Lemmas.lean
  • lemma constFunc_mem_BBFCode {i : Fin r} (h_i : i ≤ ℓ) (c : L) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
  • lemma OptionT.exists_rel_path_of_mem_support_forIn_stateful {ι : Type} {spec : OracleSpec ι} in ArkLib/ToVCVio/Simulation.lean
  • lemma Matrix.reindex_vecMul {m n l : Type*} [Fintype m] [Fintype l] in ArkLib/Data/Fin/BigOperators.lean
  • lemma probFailure_liftComp_of_OracleComp_Option {ι' : Type w} {spec : OracleSpec ι} in ArkLib/ToVCVio/Lemmas.lean
  • lemma mem_support_OptionT_map_some {m : Type u → Type v} [Monad m] [HasEvalSPMF m] [LawfulMonad m] in ArkLib/ToVCVio/Lemmas.lean
  • def projTranscriptChallengeInner {T C L : Type} : (T × C × L) → T × C in ArkLib/OracleReduction/Completeness.lean
  • lemma OptionT.probFailure_vector_mapM_eq_zero in ArkLib/ToVCVio/Simulation.lean
  • lemma sDomainBasisVectors_mem_sDomain (i : Fin r) (k : Fin (ℓ + R_rate - i)) : in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • def strictFinalSumcheckRelOutProp in ArkLib/ProofSystem/Binius/BinaryBasefold/Relations.lean
  • theorem nonLastBlocksOracleVerifier_rbrKnowledgeSoundness : in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
  • lemma mem_support_vector_mapM {n} {f : α → OracleComp spec β} {vec : Vector α n} {x : Vector β n} : in ArkLib/ToVCVio/Simulation.lean
  • def bitsOfIndex {n : ℕ} (k : Fin (2 ^ n)) : Fin n → L in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • lemma strictBatchingInputRelation_subset_batchingInputRelation : in ArkLib/ProofSystem/Binius/RingSwitching/BatchingPhase.lean
  • lemma blockDiagMatrix_mulVec_F₂_eq_Fin_merge_PO2 (n : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • lemma batching_compute_eq_from_hafter in ArkLib/ProofSystem/Binius/RingSwitching/BatchingPhase.lean
  • def single_point_localized_fold_matrix_form (i : Fin r) {destIdx : Fin r} (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • def oraclePositionToDomainIndex {i : Fin (ℓ + 1)} in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • lemma getBit_eq_testBit (n k : ℕ) : Nat.getBit k n = 1 ↔ Nat.testBit n k = true in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean
  • def foldStepLogic (i : Fin ℓ) : in ArkLib/ProofSystem/Binius/BinaryBasefold/ReductionLogic.lean
  • def sumcheckProverComputeMsg (witIn : SumcheckWitness L ℓ' i.castSucc) : L⦃≤ 2⦄[X] in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean
  • lemma Prover.processRound_P_to_V (j : Fin n) in ArkLib/ToVCVio/Simulation.lean
  • def getBBF_Codeword_poly (i : Fin r) in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
  • def largeFieldInvocationCtxLens : OracleContext.Lens in ArkLib/ProofSystem/Binius/RingSwitching/BBFSmallFieldIOPCS.lean
  • theorem castOutSimple_perfectCompleteness in ArkLib/OracleReduction/Cast.lean
  • def foldRelayKnowledgeError (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
  • lemma mem_support_bind_bind_map_iff [LawfulMonad m] in ArkLib/ToVCVio/Lemmas.lean
  • theorem simulateQ_preserves_safety_stateful_run'_mk in ArkLib/ToVCVio/Simulation.lean
  • lemma extractMLP_some_of_isCompliant_at_zero in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • theorem probEvent_StateT_run'_eq_tsum in ArkLib/OracleReduction/Completeness.lean
  • lemma single_point_localized_fold_matrix_form_congr_dest_index in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • lemma query_phase_final_fold_eq_constant in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean
  • lemma get_sDomain_first_basis_eq_1 (i : Fin r) (h_i : i < ℓ + R_rate) : in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • theorem Pr_or_le {α : Type} (D : PMF α) in ArkLib/Data/Probability/Instances.lean
  • def commitKStateProp (i : Fin ℓ) (m : Fin (1 + 1)) in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/Commit.lean
  • theorem castOutSimple_completeness in ArkLib/OracleReduction/Cast.lean
  • lemma strictOracleFoldingConsistency_commitStep in ArkLib/ProofSystem/Binius/BinaryBasefold/ReductionLogic.lean
  • lemma mem_support_simulateQ_id'_liftM_query {ι : Type*} {spec : OracleSpec ι} in ArkLib/ToVCVio/Simulation.lean
  • def QueryImpl.lift {ι₁ ι₂ : Type u} {spec₁ : OracleSpec ι₁} {spec₂ : OracleSpec ι₂} in ArkLib/ToVCVio/Simulation.lean
  • def finalSumcheckStepFoldingStateProp {h_le : ϑ ≤ ℓ} in ArkLib/ProofSystem/Binius/BinaryBasefold/Relations.lean
  • lemma Reduction_run_def (reduction : Reduction oSpec StmtIn WitIn StmtOut WitOut pSpec) in ArkLib/ToVCVio/Simulation.lean
  • lemma Transcript.equiv_eval (tr : pSpec.FullTranscript) : in ArkLib/ToVCVio/Simulation.lean
  • def masterStrictKStateProp (aOStmtIn : AbstractOStmtIn L ℓ') (stmtIdx : Fin (ℓ' + 1)) in ArkLib/ProofSystem/Binius/RingSwitching/Prelude.lean
  • lemma simulateQ_forIn {ι ι' : Type} {spec : OracleSpec ι} {superSpec : OracleSpec ι'} in ArkLib/ToVCVio/Simulation.lean
  • lemma foldingBadEventAtBlock_imp_incrementalBadEvent_last in ArkLib/ProofSystem/Binius/BinaryBasefold/Relations.lean
  • instance instInhabitedPSpecFinalSumcheckStepChallenge : in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean
  • theorem prob_pow_bound_of_forall in ArkLib/Data/Probability/Instances.lean
  • def bbfAbstractOStmtIn : AbstractOStmtIn L ℓ' where in ArkLib/ProofSystem/Binius/RingSwitching/BBFSmallFieldIOPCS.lean
  • def badBatchingEventProp (y : Fin κ → L) (msg0 s_bar : TensorAlgebra K L) : Prop in ArkLib/ProofSystem/Binius/RingSwitching/BatchingPhase.lean
  • lemma OptionT.simulateQ_vector_mapM_eq {ι ι' : Type} {spec : OracleSpec ι} in ArkLib/ToVCVio/Simulation.lean
  • lemma intermediateNormVpoly_eval_is_linear_map (i : Fin r) {k : ℕ} (h_k : i.val + k ≤ ℓ) : in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • def disagreementSet (i : Fin r) in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
  • lemma finalSumcheckStep_verifierCheck_passed in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean
  • lemma Witness.of_fin_eq {i j : Fin (ℓ + 1)} (h : i = j) : in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
  • theorem tsum_uniform_Pr_eq_Pr in ArkLib/OracleReduction/Completeness.lean
  • lemma batching_pack_unpack_id (t' : MultilinearPoly L ℓ') : in ArkLib/ProofSystem/Binius/RingSwitching/BatchingPhase.lean
  • theorem basis_repr_of_sDomain_lift (i j : Fin r) (h_j : j < ℓ + R_rate) (h_le : i ≤ j) in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • lemma ne_none_of_mem_support_of_probOutput_none_eq_zero in ArkLib/ToVCVio/Lemmas.lean
  • def logical_computeFoldedValue in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/QueryPhasePrelims.lean
  • lemma Matrix.map_neg {m n : Type*} {R S : Type*} [Ring R] [Ring S] in ArkLib/Data/Fin/BigOperators.lean
  • theorem soundness_unroll_runToRound_1_V_to_P_pSpec_2 in ArkLib/OracleReduction/Completeness.lean
  • lemma simulateQ_forIn_stateful_run_eq {ι : Type} {spec : OracleSpec ι} in ArkLib/ToVCVio/Simulation.lean
  • theorem soundness_unroll_runToRound_0_pSpec_1_V_to_P in ArkLib/OracleReduction/Completeness.lean
  • lemma OptionT.support_run_simulateQ_eq_of_superSpec {ι' : Type} in ArkLib/ToVCVio/Simulation.lean
  • lemma innerPowSum_add_two_pow_eq_mul_sum_range {ℓ ϑ 𝓡 B : ℕ} [NeZero ℓ] in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
  • def largeFieldInvocationStmtLens : OracleStatement.Lens in ArkLib/ProofSystem/Binius/RingSwitching/BBFSmallFieldIOPCS.lean
  • lemma mem_support_run_bind_some_iff {α β : Type u} in ArkLib/ToVCVio/Lemmas.lean
  • def mkFromStmtIdxCastSuccOfSucc {ℓ : ℕ} (i : Fin ℓ) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • lemma support_forIn_subset_rel in ArkLib/ToVCVio/Simulation.lean
  • def ForInStep.state : ForInStep σ → σ in ArkLib/ToVCVio/Simulation.lean
  • def fiberwiseDisagreementSet (i : Fin r) {destIdx : Fin r} (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
  • theorem unroll_2_message_reduction_perfectCompleteness in ArkLib/OracleReduction/Completeness.lean
  • lemma OptionT.simulateQ_forIn_stateful_comp {ι : Type} {spec : OracleSpec ι} in ArkLib/ToVCVio/Simulation.lean
  • lemma fun_eta_expansion {α β : Type*} (f : α → β) : f = (fun x => f x) in ArkLib/Data/Misc/Basic.lean
  • lemma OptionT.support_failure_run in ArkLib/ToVCVio/Simulation.lean
  • theorem probOutput_eq_PMF_apply in ArkLib/OracleReduction/Completeness.lean
  • theorem iterated_fold_advances_evaluation_poly in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • instance instFintypePSpecQueryMessage : in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean
  • lemma sumcheckConsistency_MLPEvalWitness_to_BBF_Witness_of_eval in ArkLib/ProofSystem/Binius/RingSwitching/BBFSmallFieldIOPCS.lean
  • instance instOracleInterfaceMessagePSpecSumcheckRound : in ArkLib/ProofSystem/Binius/RingSwitching/Spec.lean
  • lemma challengeTensorExpansion_one [CommRing L] (r : L) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • abbrev liftComp_self [spec.Fintype] [spec.Inhabited] in ArkLib/ToVCVio/Lemmas.lean
  • theorem sumcheckLoopOracleVerifier_rbrKnowledgeSoundness : in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean
  • def Matrix.from4Blocks {mTop nLeft mBot nRight : ℕ} {α : Type*} in ArkLib/Data/Fin/BigOperators.lean
  • instance instInhabitedPSpecSumcheckRoundChallenge : in ArkLib/ProofSystem/Binius/RingSwitching/Spec.lean
  • lemma OptionT.simulateQ_liftComp in ArkLib/ToVCVio/Simulation.lean
  • lemma simulateQ_simOracle2_lift_liftComp_query_T2 in ArkLib/ToVCVio/Simulation.lean
  • theorem castInOut_id in ArkLib/OracleReduction/Cast.lean
  • lemma not_badBlock_of_lt_highest in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/BadBlocks.lean
  • def extractMLP (i : Fin ℓ) (f : (sDomain 𝔽q β h_ℓ_add_R_rate) ⟨i, by omega⟩ → L) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • def finalSumcheckVerifierStmtOut in ArkLib/ProofSystem/Binius/FRIBinius/CoreInteractionPhase.lean
  • lemma simulateQ_liftComp in ArkLib/ToVCVio/Simulation.lean
  • lemma multilinearCombine_recursive_form_first {ϑ : ℕ} in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/Incremental.lean
  • lemma fun_eta_expansion_apply {α β : Type*} (f : α → β) (x : α) : (f x) = (fun x => f x) x in ArkLib/Data/Misc/Basic.lean
  • def projTranscriptChallenge {T C L S : Type} : ((T × C × L) × S) → T × C in ArkLib/OracleReduction/Completeness.lean
  • lemma simulateQ_simOracle2_liftM_query_T1 in ArkLib/ToVCVio/Simulation.lean
  • theorem foldOracleReduction_perfectCompleteness (hInit : NeverFail init) (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/Fold.lean
  • theorem Polynomial.foldl_comp (n : ℕ) (f : Fin n → L[X]) : ∀ initInner initOuter: L[X], in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • def strictFinalSumcheckRelOut : in ArkLib/ProofSystem/Binius/BinaryBasefold/Relations.lean
  • lemma k_succ_mul_ϑ_le_ℓ_₂ {k : Fin (ℓ / ϑ)} : k.val * ϑ + ϑ ≤ ℓ in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • abbrev queryBlockSourceIdx (j : Fin (nBlocks (ℓ in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/QueryPhasePrelims.lean
  • lemma singleton_mapM_gen in ArkLib/ToVCVio/Simulation.lean
  • def getNextOracle (i : Fin (ℓ + 1)) in ArkLib/ProofSystem/Binius/BinaryBasefold/Relations.lean
  • instance instFintypePSpecBatchingChallenge : in ArkLib/ProofSystem/Binius/RingSwitching/Spec.lean
  • lemma coe_fin_pow_two_eq_bitsOfIndex {n : ℕ} (k : Fin (2 ^ n)) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • def foldStepRelOutProp (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Relations.lean
  • def relayKnowledgeError (m : pSpecRelay.ChallengeIdx) : ℝ≥0 in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/Relay.lean
  • lemma fixFirstVariablesOfMQP_zero_eq in ArkLib/ProofSystem/Binius/RingSwitching/BBFSmallFieldIOPCS.lean
  • def strictRoundRelation (i : Fin (ℓ + 1)) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Relations.lean
  • abbrev Stateless {ι ι' : Type*} (spec : OracleSpec ι) (superSpec : OracleSpec ι') in ArkLib/ToVCVio/Simulation.lean
  • lemma support_bind_simulateQ_run'_eq_mk in ArkLib/ToVCVio/Simulation.lean
  • lemma queryBlockDestSuffix_eq_queryBlockSourceSuffix_succ in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/QueryPhasePrelims.lean
  • def pair_fiberwiseDistance (i : Fin r) {destIdx : Fin r} (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
  • lemma even_index_intermediate_novel_basis_decomposition (i : Fin r) in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • lemma OptionT.support_ite_run in ArkLib/ToVCVio/Simulation.lean
  • lemma foldCommitKnowledgeError_eq (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
  • lemma multilinearWeight_succ_upper_half {n : ℕ} in ArkLib/Data/CodingTheory/Prelims.lean
  • lemma OptionT.exists_path_of_mem_support_forIn_unit {σ α : Type} [spec.Fintype] in ArkLib/ToVCVio/Simulation.lean
  • lemma foldStep_rbrExtractionFailureEvent_imply_sumcheck_or_badEvent (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/Fold.lean
  • lemma projectToMidSumcheckPoly_at_last_eq in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • lemma OptionT.mem_support_vector_mapM {ι : Type} {spec : OracleSpec ι} in ArkLib/ToVCVio/Simulation.lean
  • def largeFieldInvocationExtractorLens : Extractor.Lens in ArkLib/ProofSystem/Binius/RingSwitching/BBFSmallFieldIOPCS.lean
  • def additiveNTTInvariant (evaluation_buffer : Fin (2 ^ (ℓ + R_rate)) → L) in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • lemma finalSumcheckKnowledgeError_sum_eq_zero : in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
  • def getLastOracle {oracleFrontierIdx : Fin (ℓ + 1)} {destIdx : Fin r} in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • lemma iterated_fold_congr_dest_index in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • def splitEvenOddRowWiseInterleavedWords {ϑ : ℕ} in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/Incremental.lean
  • theorem commitOracleVerifier_rbrKnowledgeSoundness (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/Commit.lean
  • lemma iterated_fold_to_const_strict in ArkLib/ProofSystem/Binius/FRIBinius/CoreInteractionPhase.lean
  • def batchingVerifierCheck (stmtIn : BatchingStmtIn L ℓ) (msg0 : TensorAlgebra K L) : Prop in ArkLib/ProofSystem/Binius/RingSwitching/BatchingPhase.lean
  • lemma probFailure_forIn_of_relations_simplified in ArkLib/ToVCVio/Simulation.lean
  • lemma qMap_comp_normalizedW (i : Fin r) (h_i_add_1 : i + 1 < r) : in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • abbrev nBlocks : ℕ in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/QueryPhasePrelims.lean
  • lemma getSDomainBasisCoeff_of_iteratedQuotientMap in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • lemma oracle_block_k_le_i (i : Fin (ℓ + 1)) (j : Fin (toOutCodewordsCount ℓ ϑ i)) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • lemma val_le_i {ℓ : ℕ} (i : Fin (ℓ + 1)) (oracleIdx : OracleFrontierIndex i) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • theorem qMap_maps_sDomain (i : Fin r) (h_i_add_1 : i + 1 < r) : in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • lemma fin_zero_mul_eq (h : 0 * ϑ < ℓ + 1) : (⟨0 * ϑ, h⟩ : Fin (ℓ + 1)) = 0 in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
  • lemma single_point_localized_fold_matrix_form_congr_steps_index in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • lemma neverFail_map_iff' [spec.Fintype] [spec.Inhabited] in ArkLib/ToVCVio/Lemmas.lean
  • def foldVerifierCheck (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Relations.lean
  • def getChallengeSuffix (k : Fin (ℓ / ϑ)) (v : sDomain 𝔽q β h_ℓ_add_R_rate ⟨0, by omega⟩) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/QueryPhasePrelims.lean
  • lemma snoc_oracle_eq_mkVerifierOStmtOut_commitStep in ArkLib/ProofSystem/Binius/BinaryBasefold/ReductionLogic.lean
  • lemma Transcript_get_message (tr : pSpec.FullTranscript) (j : Fin n) (h : pSpec.dir j = .P_to_V) : in ArkLib/ToVCVio/Simulation.lean
  • lemma mem_support_OptionT_run_map_some in ArkLib/ToVCVio/Lemmas.lean
  • def Nat.boundedRecOn {r : ℕ} {motive : (k : ℕ) → k < r → Sort _} in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • lemma probFailure_simulateQ_iff_mk in ArkLib/ToVCVio/Simulation.lean
  • lemma nonLastSingleBlockOracleReduction_perfectCompleteness in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
  • def incrementalFoldingBadEvent in ArkLib/ProofSystem/Binius/BinaryBasefold/Compliance.lean
  • lemma strictRoundRelation.of_fin_eq {i j : Fin (ℓ + 1)} (h : i = j) : in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
  • def fullRbrKnowledgeError in ArkLib/ProofSystem/Binius/FRIBinius/General.lean
  • lemma simOracle2_impl_inr_inr in ArkLib/ToVCVio/Simulation.lean
  • lemma support_OptionT_pure_run {m : Type u → Type v} [Monad m] [HasEvalSPMF m] in ArkLib/ToVCVio/Lemmas.lean
  • theorem qMap_is_linear_map (i : Fin r) : in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • lemma instOracleStatementBinaryBasefold_heq_of_fin_eq {i₁ i₂ : Fin (ℓ + 1)} (h : i₁ = i₂) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean
  • theorem probFailure_simulateQ_iff_stateful_run'_mk in ArkLib/ToVCVio/Simulation.lean
  • lemma OptionT.simulateQ_vector_mapM {ι ι' : Type} {spec : OracleSpec ι} {superSpec : OracleSpec ι'} in ArkLib/ToVCVio/Simulation.lean
  • lemma batchingMismatchPoly_nonzero_of_embed_ne in ArkLib/ProofSystem/Binius/RingSwitching/BatchingPhase.lean
  • lemma support_simulateQ_bind_run_eq in ArkLib/ToVCVio/Simulation.lean
  • lemma foldBadEventCardSum_eq_displaySums in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
  • lemma iteratedQuotientMap_eq_qMap_total_fiber_extractMiddleFinMask in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean
  • instance instMonadLift_left_right {ι₁ ι₂ ι₃ : Type} in ArkLib/ToVCVio/Simulation.lean
  • instance instInhabitedPSpecFoldChallenge : in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean
  • theorem probEvent_proj_transcript_challenge in ArkLib/OracleReduction/Completeness.lean
  • lemma fold_error_containment_of_UDRClose (i : Fin r) {destIdx : Fin r} (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Compliance.lean
  • theorem Polynomial.comp_same_inner_eq_if_same_outer (f g : L[X]) (h_f_eq_g : f = g) : in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • def getRowPoly (i : Fin ℓ) (steps : ℕ) {destIdx : Fin r} in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/Lift.lean
  • def nonLastSingleBlockFoldRelayRbrKnowledgeError (bIdx : Fin (ℓ / ϑ - 1)) in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
  • theorem evenRefinement_eq_novel_poly_of_0_leading_suffix (i : Fin r) (h_i : i < ℓ) (v : Fin (2 ^ i.val)) in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • lemma projectToMidSumcheckPoly_eq_prod (t : MultilinearPoly L ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • def getLiftPoly (i : Fin ℓ) (steps : ℕ) {destIdx : Fin r} in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/Lift.lean
  • instance instInhabitedPSpecFinalSumcheckMessage : in ArkLib/ProofSystem/Binius/RingSwitching/Spec.lean
  • lemma oracle_index_le_ℓ (i : Fin (ℓ + 1)) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • lemma probFailure_bind_pure_comp_eq_zero_iff {m : Type u → Type v} [Monad m] [HasEvalSPMF m] in ArkLib/ToVCVio/Lemmas.lean
  • instance instFintypePspecCommit_AllChallenges {i : Fin ℓ} : in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean
  • def coeffsBySuffix (a : Fin (2 ^ ℓ) → L) (i : Fin r) (h_i : i ≤ ℓ) (v : Fin (2 ^ i.val)) : in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • lemma simOracle2_impl_inl in ArkLib/ToVCVio/Simulation.lean
  • lemma eval_point_ω_eq_next_twiddleFactor_comp_qmap in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • lemma finalSumcheckStep_is_logic_complete : in ArkLib/ProofSystem/Binius/BinaryBasefold/ReductionLogic.lean
  • lemma logical_checkSingleRepetition_guard_eq in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/QueryPhasePrelims.lean
  • lemma simulateQ_simOracle2_liftM_query_T2 in ArkLib/ToVCVio/Simulation.lean
  • lemma support_liftComp {ι' : Type w} {superSpec : OracleSpec ι'} in ArkLib/ToVCVio/Lemmas.lean
  • lemma Matrix.reindex_mul_eq_prod_of_reindex {l m n o p q : Type*} in ArkLib/Data/Fin/BigOperators.lean
  • lemma qMap_total_fiber_congr_source in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • lemma probFailure_liftComp_eq {ι' : Type} {superSpec : OracleSpec ι'} in ArkLib/ToVCVio/Lemmas.lean
  • theorem intermediateChangeOfBasisMatrix_lower_triangular (i : Fin r) (h_i : i ≤ ℓ) : in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • def Fin.reindex {R n m : Type*} [Fintype n] [Fintype m] (e : n ≃ m) (v : n → R) in ArkLib/Data/Fin/BigOperators.lean
  • lemma sumcheckConsistency_at_last_simplifies in ArkLib/ProofSystem/Binius/FRIBinius/CoreInteractionPhase.lean
  • def logical_checkSingleFoldingStep in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/QueryPhasePrelims.lean
  • def finalSumcheckKnowledgeError (m : pSpecFinalSumcheckStep (L in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/FinalSumcheck.lean
  • lemma prop_4_21_2_incremental_bad_event_probability in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/Incremental.lean
  • instance instNontrivial {F ι : Type*} {n : ℕ} [Field F] [Fintype ι] {α : ι ↪ F} in ArkLib/Data/CodingTheory/ReedSolomon.lean
  • theorem fullOracleVerifier_knowledgeSoundness : in ArkLib/ProofSystem/Binius/FRIBinius/General.lean
  • instance instInhabitedPSpecSumcheckRoundMessage : in ArkLib/ProofSystem/Binius/RingSwitching/Spec.lean
  • lemma eval_eqPolynomial_bitsOfIndex [DecidableEq L] [IsDomain L] in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • lemma Matrix.reindex_vecMul_reindex {m n o l : Type*} [Fintype n] [Fintype l] [Fintype m] in ArkLib/Data/Fin/BigOperators.lean
  • abbrev queryBlockDestSuffix in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/QueryPhasePrelims.lean
  • lemma OptionT.simulateQ_list_mapM {ι ι' : Type} {spec : OracleSpec ι} {superSpec : OracleSpec ι'} in ArkLib/ToVCVio/Simulation.lean
  • abbrev queryBlockDestIdx (j : Fin (nBlocks (ℓ in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/QueryPhasePrelims.lean
  • lemma sum_powers (x B : ℕ) (hB : 1 ≤ B) : in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
  • theorem intermediateChangeOfBasisMatrix_det_ne_zero (i : Fin r) (h_i : i ≤ ℓ) : in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • theorem relayOracleVerifier_rbrKnowledgeSoundness (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/Relay.lean
  • def FullTranscript.mk1 {pSpec : ProtocolSpec 1} (msg0 : pSpec.«Type» 0) : in ArkLib/OracleReduction/Basic.lean
  • lemma base_coeffsBySuffix (a : Fin (2 ^ ℓ) → L) : in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • lemma probFailure_forIn_eq_zero_of_body_safe in ArkLib/ToVCVio/Simulation.lean
  • lemma support_vector_mapM_gen in ArkLib/ToVCVio/Simulation.lean
  • theorem singleRepetition_proximityCheck_bound in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean
  • lemma get_sDomain_basis (i : Fin r) (h_i : i < ℓ + R_rate) : in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • lemma getMidCodewords_succ (t : L⦃≤ 1⦄[X Fin ℓ]) (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Relations.lean
  • lemma lastRoundChallengeSlice_heq in ArkLib/ProofSystem/Binius/BinaryBasefold/Relations.lean
  • def finalSumcheckRelOut : in ArkLib/ProofSystem/Binius/BinaryBasefold/Relations.lean
  • lemma probOutput_none_pure_some_eq_zero in ArkLib/ToVCVio/Lemmas.lean
  • def sBasis (i : Fin r) (h_i : i < ℓ + R_rate) : Fin (ℓ + R_rate - i) → L in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • def foldingBadEvent (i : Fin r) {destIdx : Fin r} (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Compliance.lean
  • lemma iteratedSumcheck_rbrExtractionFailureEvent_imply_badSumcheck (i : Fin ℓ') in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean
  • lemma neverFails_of_simulateQ_stateful in ArkLib/ToVCVio/Simulation.lean
  • def finalSumcheckStepLogic : in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean
  • abbrev IntermediateCoeffVecSpace (i : Fin r) in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • lemma mem_support_StateT_bind_run {σ α β : Type} in ArkLib/ToVCVio/Simulation.lean
  • lemma logical_checkSingleRepetition_of_mem_support_forIn_body {σ : Type} in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean
  • lemma goodBlockCodeword_eq_of_fiberwiseClose in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/QueryPhaseSoundness.lean
  • lemma probFailure_mk_do_bind_bind_eq_zero_iff {m : Type u → Type v} [Monad m] [HasEvalSPMF m] in ArkLib/ToVCVio/Lemmas.lean
  • def strictBatchingInputRelation : in ArkLib/ProofSystem/Binius/RingSwitching/BatchingPhase.lean
  • def splitFinMap_PO2_right {L : Type*} {n : ℕ} (v : Fin (2 ^ (n + 1)) → L) in ArkLib/Data/Fin/BigOperators.lean
  • lemma mem_support_map_iff_generic {m : Type u → Type v} [Monad m] [HasEvalSPMF m] [LawfulMonad m] in ArkLib/ToVCVio/Lemmas.lean
  • instance instInhabitedOracleStatement {i : Fin (ℓ + 1)} : in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean
  • lemma foldStep_oracleWitnessConsistency_unique_witMid (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/Fold.lean
  • def splitPointIntoCoeffs (i : Fin r) (h_i : i < ℓ + R_rate) in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • def foldKStateProp {i : Fin ℓ} (m : Fin (2 + 1)) in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/Fold.lean
  • def badBlockProp in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/BadBlocks.lean
  • instance instOracleInterfacePSpecRelay_AllChallenges in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean
  • theorem support_nonempty_of_neverFails in ArkLib/ToVCVio/Simulation.lean
  • lemma fold_eval_fiber₂_eq_mat_mat_vec_mul (i : Fin r) {midIdx destIdx : Fin r} (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • theorem fullOracleVerifier_rbrKnowledgeSoundness : in ArkLib/ProofSystem/Binius/FRIBinius/General.lean
  • lemma sDomain_card (i : Fin r) (h_i : i < ℓ + R_rate) : in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • lemma mergeFinMap_PO2_of_split_left_right {L : Type*} {n : ℕ} (v : Fin (2 ^ (n + 1)) → L) : in ArkLib/Data/Fin/BigOperators.lean
  • def isCompliant (i : Fin r) {destIdx : Fin r} (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Compliance.lean
  • abbrev MultiquadraticPoly (L : Type) [CommSemiring L] (ℓ : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • def logical_checkSingleRepetition in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/QueryPhasePrelims.lean
  • theorem base_intermediateNormVpoly in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • lemma fiberwiseClose_steps_zero_iff_UDRClose in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
  • lemma val_mkFromStmtIdx {ℓ : ℕ} (stmtIdx : Fin (ℓ + 1)) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • instance instFintypePSpecFold_AllChallenges : ∀ i, Fintype ((pSpecFold (L in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean
  • lemma Polynomial.toMvPolynomial_ne_zero_iff (p : Polynomial R) (i : σ) : in ArkLib/ToMathlib/MvPolynomial/Equiv.lean
  • lemma probOutput_none_bind_eq_zero_iff in ArkLib/ToVCVio/Simulation.lean
  • lemma batchingMismatchPoly_totalDegree_le in ArkLib/ProofSystem/Binius/RingSwitching/BatchingPhase.lean
  • lemma preTensorCombine_of_lift_interleavedCodeword_eq_self (i : Fin ℓ) (steps : ℕ) {destIdx : Fin r} in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/Lift.lean
  • lemma commitStep_j_bound (i : Fin ℓ) (hCR : isCommitmentRound ℓ ϑ i) in ArkLib/ProofSystem/Binius/BinaryBasefold/ReductionLogic.lean
  • lemma butterflyMatrix_zero_apply (z₀ z₁ : L) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • def MLPEvalWitness_to_BBF_Witness (stmt : MLPEvalStatement (L in ArkLib/ProofSystem/Binius/RingSwitching/BBFSmallFieldIOPCS.lean
  • lemma disagreement_fold_subset_fiberwiseDisagreement (i : Fin ℓ) (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/FoldDistance.lean
  • lemma k_succ_mul_ϑ_le_ℓ {k : Fin (ℓ / ϑ)} : (k.val + 1) * ϑ ≤ ℓ in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • lemma fiberwiseClose_fold_implies_affineLineEval_close in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/Incremental.lean
  • lemma extractSuffixFromChallenge_congr_destIdx in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/QueryPhasePrelims.lean
  • def querySingleRepetitionError : ℝ≥0 in ArkLib/ProofSystem/Binius/FRIBinius/General.lean
  • lemma h_oracle_size_eq_relay (i : Fin ℓ) (hNCR : ¬ isCommitmentRound ℓ ϑ i) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/Relay.lean
  • lemma map_pure (f : α → β) (a : α) : in ArkLib/ToVCVio/Simulation.lean
  • lemma mkLastOracleIndex_eq_getLastOraclePositionIndex (i : Fin (ℓ + 1)) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • def foldKnowledgeError (i : Fin ℓ) (_ : (pSpecFold (L in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/Fold.lean
  • lemma OptionT.simulateQ_simOracle2_liftM_query_T1 in ArkLib/ToVCVio/Simulation.lean
  • lemma foldStep_is_logic_complete (i : Fin ℓ) : in ArkLib/ProofSystem/Binius/BinaryBasefold/ReductionLogic.lean
  • lemma highestBadBlock_is_bad in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/BadBlocks.lean
  • lemma getSumcheckRoundPoly_sum_eq (i : Fin ℓ) (h : ↥L⦃≤ 2⦄[X Fin (ℓ - ↑i.castSucc)]) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • lemma odd_index_intermediate_novel_basis_decomposition in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • def strictSumcheckRoundRelationProp (aOStmtIn : AbstractOStmtIn L ℓ') (i : Fin (ℓ' + 1)) in ArkLib/ProofSystem/Binius/RingSwitching/Prelude.lean
  • lemma incrementalFoldingBadEvent_of_k_eq_0_is_false in ArkLib/ProofSystem/Binius/BinaryBasefold/Compliance.lean
  • lemma neverFails_of_simulateQ_mk in ArkLib/ToVCVio/Simulation.lean
  • def intermediateToCoeffsVec (i : Fin r) : -- (h_i : i ≤ ℓ) in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • def reindexVecTwoPowAddTwoPow {L : Type*} {n : ℕ} (v : Fin (2 ^ n + 2 ^ n) → L) in ArkLib/Data/Fin/BigOperators.lean
  • lemma simOracle2_impl_inr_inl in ArkLib/ToVCVio/Simulation.lean
  • instance instFintypePSpecSumcheckRoundChallenge : in ArkLib/ProofSystem/Binius/RingSwitching/Spec.lean
  • theorem run_liftM_lib [Monad m] [LawfulMonad m] (ma : m α) (s : σ) : in ArkLib/ToVCVio/Lemmas.lean
  • lemma Matrix.vecMul_reindex {m n o l : Type*} [Fintype m] [Fintype o] [Fintype n] [Fintype l] in ArkLib/Data/Fin/BigOperators.lean
  • lemma fixFirstVariablesOfMQP_full_eval_eq_eval {deg : ℕ} {challenges : Fin (Fin.last ℓ) → L} in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • lemma sDomain_eq_of_eq {i j : Fin r} (h : i = j) : in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • lemma UDRCodeword_constFunc_eq_self (i : Fin r) (h_i : i ≤ ℓ) (c : L) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
  • lemma mem_support_bind_some_iff {α β : Type u} in ArkLib/ToVCVio/Lemmas.lean
  • def iteratedSumcheckWitMid (i : Fin ℓ') : Fin (2 + 1) → Type in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean
  • instance instFintypePSpecFinalSumcheckStepMessage : in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean
  • lemma OptionT.simulateQ_array_mapM {ι ι' : Type} {spec : OracleSpec ι} {superSpec : OracleSpec ι'} in ArkLib/ToVCVio/Simulation.lean
  • instance instFintypeOracleSpecEmpty : (([]ₒ : OracleSpec PEmpty).Fintype) where in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean
  • lemma mkVerifierOStmtOut_inr in ArkLib/OracleReduction/Basic.lean
  • def getLastOraclePositionIndex (i : Fin (ℓ + 1)) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • def getCommitProverFinalOutput (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/Commit.lean
  • instance instMonadLift_right_left {ι₁ ι₂ ι₃ : Type} in ArkLib/ToVCVio/Simulation.lean
  • lemma snoc_oracle_dest_eq_j {i : Fin ℓ} {destIdx : Fin r} in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • lemma iteratedQuotientMap_eq_qMap_total_fiber_extractMiddleFinMask in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/QueryPhasePrelims.lean
  • def pair_UDRClose (i : Fin r) (h_i : i ≤ ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
  • theorem fullOracleVerifier_knowledgeSoundness (ε_pcs : ℝ≥0) in ArkLib/ProofSystem/Binius/RingSwitching/General.lean
  • instance instMonadLift_left_left {ι₁ ι₂ ι₃ : Type} in ArkLib/ToVCVio/Simulation.lean
  • theorem prop_4_23_singleRepetition_proximityCheck_bound in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/QueryPhaseSoundness.lean
  • def hEq {ιₒᵢ ιₒₒ : Type} {OracleIn : ιₒᵢ → Type} in ArkLib/ProofSystem/Binius/BinaryBasefold/ReductionLogic.lean
  • theorem fullRbrKnowledgeError_sum_eq_concrete (ε_pcs : ℝ≥0) in ArkLib/ProofSystem/Binius/RingSwitching/General.lean
  • lemma probOutput_none_run_eq_zero_of_probFailure_eq_zero in ArkLib/ToVCVio/Lemmas.lean
  • lemma getFiberPoint_eq_qMap_total_fiber in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/QueryPhasePrelims.lean
  • lemma support_challengeQueryImpl_run_eq {n : ℕ} {pSpec : ProtocolSpec n} {σ : Type} in ArkLib/ToVCVio/Simulation.lean
  • def fold_error_containment (i : Fin r) {destIdx : Fin r} (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Compliance.lean
  • theorem relayOracleReduction_perfectCompleteness (hInit : NeverFail init) (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/Relay.lean
  • lemma pair_fiberwiseDistance_steps_zero_eq_hammingDist in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
  • lemma exists_eq_some_of_mem_support_run_of_probFailure_eq_zero in ArkLib/ToVCVio/Lemmas.lean
  • theorem probEvent_soundness_goal_unroll_log in ArkLib/OracleReduction/Completeness.lean
  • lemma mem_support_mk {m : Type u → Type v} [Monad m] [HasEvalSPMF m] in ArkLib/ToVCVio/Lemmas.lean
  • lemma iterated_fold_zero_steps (i : Fin r) {destIdx : Fin r} in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • lemma getLastOracleDomainIndex_add_ϑ_le (i : Fin (ℓ + 1)) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • def roundRelationProp (i : Fin (ℓ + 1)) in ArkLib/ProofSystem/Binius/BinaryBasefold/Relations.lean
  • lemma getSDomainBasisCoeff_of_sum_repr [NeZero R_rate] (i : Fin r) (h_i : i ≤ ℓ) in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • lemma neverFail_vector_mapM in ArkLib/ToVCVio/Simulation.lean
  • lemma compute_A_MLE_eval_eq_final_eq_value in ArkLib/ProofSystem/Binius/RingSwitching/Prelude.lean
  • instance instFintypePSpecFoldChallenge : in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean
  • def foldStepWitBeforeFromWitMid (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/Fold.lean
  • lemma probability_bound_badBatchingEventProp in ArkLib/ProofSystem/Binius/RingSwitching/BatchingPhase.lean
  • def strictRoundRelationProp (i : Fin (ℓ + 1)) in ArkLib/ProofSystem/Binius/BinaryBasefold/Relations.lean
  • lemma previousSuffix_eq_getFiberPoint_extractMiddleFinMask in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/QueryPhasePrelims.lean
  • def largeFieldInvocationOracleReduction : in ArkLib/ProofSystem/Binius/RingSwitching/BBFSmallFieldIOPCS.lean
  • theorem forall_eq_lift_mem_2 {α β γ} {S : Set α} {T : α → Set β} in ArkLib/OracleReduction/Completeness.lean
  • lemma logical_computeFoldedValue_eq_iterated_fold in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/QueryPhasePrelims.lean
  • def pair_fiberwiseClose (i : Fin r) {destIdx : Fin r} (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
  • def finalSumcheckVerifierCheck in ArkLib/ProofSystem/Binius/FRIBinius/CoreInteractionPhase.lean
  • theorem castInOut_perfectCompleteness in ArkLib/OracleReduction/Cast.lean
  • lemma Matrix.det_from4Blocks_of_squareSubblocks_commute {n : ℕ} {R : Type*} in ArkLib/Data/Fin/BigOperators.lean
  • def nonLastBlocksRbrKnowledgeError in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
  • lemma query_phase_consistency_guard_safe in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean
  • lemma OptionT.simulateQ_bind_stateful {ι : Type} {spec : OracleSpec ι} in ArkLib/ToVCVio/Simulation.lean
  • lemma projectToMidSumcheckPoly_at_last_eval in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • def commitStepLogic_embed_inj (i : Fin ℓ) (hCR : isCommitmentRound ℓ ϑ i) : in ArkLib/ProofSystem/Binius/BinaryBasefold/ReductionLogic.lean
  • def strictfinalSumcheckStepFoldingStateProp (t : MultilinearPoly L ℓ) {h_le : ϑ ≤ ℓ} in ArkLib/ProofSystem/Binius/BinaryBasefold/Relations.lean
  • theorem prob_pow_of_forall_finFun in ArkLib/Data/Probability/Instances.lean
  • def strictFoldStepRelOut (i : Fin ℓ) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Relations.lean
  • lemma MLPEvalRelation_of_round0_local_and_structural in ArkLib/ProofSystem/Binius/RingSwitching/BBFSmallFieldIOPCS.lean
  • lemma Matrix.from4Blocks_eq_fromBlocks {m n : ℕ} {α : Type*} in ArkLib/Data/Fin/BigOperators.lean
  • lemma UDRClose_of_fin_eq {i j : Fin r} (hij : i = j) in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
  • lemma multilinearWeight_bitsOfIndex_eq_indicator {n : ℕ} (j k : Fin (2 ^ n)) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/Lift.lean
  • lemma probFailure_challengeQueryImpl_run {n : ℕ} {pSpec : ProtocolSpec n} {σ : Type} in ArkLib/ToVCVio/Simulation.lean
  • lemma prob_uniform_suffix_mem in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/BadBlocks.lean
  • lemma successor_codeword_eval_eq in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/QueryPhasePrelims.lean
  • lemma mapOStmtOut_eq_mkVerifierOStmtOut_relayStep in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/Relay.lean
  • def OracleFrontierIndex {ℓ : ℕ} (stmtIdx : Fin (ℓ + 1)) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • lemma queryBlockDestIdx_eq_queryBlockSourceIdx_succ in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/QueryPhasePrelims.lean
  • theorem fullRbrKnowledgeError_sum_eq_front_add_pcs : in ArkLib/ProofSystem/Binius/RingSwitching/General.lean
  • def witnessStructuralInvariant {i : Fin (ℓ + 1)} (stmt : Statement (L in ArkLib/ProofSystem/Binius/BinaryBasefold/Relations.lean
  • def strictSumcheckRoundRelation (aOStmtIn : AbstractOStmtIn L ℓ') (i : Fin (ℓ' + 1)) : in ArkLib/ProofSystem/Binius/RingSwitching/Prelude.lean
  • lemma OptionT.mem_support_run_vector_mapM_some {ι : Type} {spec : OracleSpec ι} in ArkLib/ToVCVio/Simulation.lean
  • instance instInhabitedPSpecRelayChallenge : in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean
  • lemma prop_4_21_2_case_2_fiberwise_far_incremental in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/Incremental.lean
  • theorem soundness_error_mono in ArkLib/OracleReduction/Security/Basic.lean
  • lemma strictSumcheckRoundRelation_subset_sumcheckRoundRelation (aOStmtIn : AbstractOStmtIn L ℓ') in ArkLib/ProofSystem/Binius/RingSwitching/Prelude.lean
  • lemma queryBlockDestIdx_le in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/QueryPhasePrelims.lean
  • lemma degree_intermediateNormVpoly (i : Fin r) {k : ℕ} (h_k : i.val + k ≤ ℓ) : in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • def finalSumcheckProverComputeMsg in ArkLib/ProofSystem/Binius/FRIBinius/CoreInteractionPhase.lean
  • lemma probFailure_mk_do_bindT_eq_zero_iff {m : Type u → Type v} [Monad m] [HasEvalSPMF m] in ArkLib/ToVCVio/Lemmas.lean
  • lemma goodBlock_intermediate_isCompliant in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/QueryPhaseSoundness.lean
  • def nonLastSingleBlockOracleVerifier (bIdx : Fin (ℓ / ϑ - 1)) in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
  • theorem probOutput_uniform_eq_Pr in ArkLib/OracleReduction/Completeness.lean
  • def logical_queryFiberPoints in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/QueryPhasePrelims.lean
  • lemma exists_path_of_mem_support_forIn_unit {σ α : Type} [spec.Fintype] in ArkLib/ToVCVio/Simulation.lean
  • lemma batching_compute_s0_eq_eval_MLE in ArkLib/ProofSystem/Binius/RingSwitching/BatchingPhase.lean
  • lemma UDRCodeword_mem_BBF_Code (i : Fin r) (h_i : i ≤ ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
  • instance instFintypePSpecRelay_AllChallenges : ∀ i, Fintype ((pSpecRelay).Challenge i) in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean
  • lemma simulateQ_list_mapM {ι ι' : Type} {spec : OracleSpec ι} {superSpec : OracleSpec ι'} in ArkLib/ToVCVio/Simulation.lean
  • lemma fixFirstVariablesOfMQP_eq_bind₁ (v : Fin (ℓ + 1)) (poly : MvPolynomial (Fin ℓ) L) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • lemma preTensorCombine_row_eq_fold_with_binary_row_challenges in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/Lift.lean
  • lemma incrementalFoldingBadEvent_eq_foldingBadEvent_of_k_eq_ϑ in ArkLib/ProofSystem/Binius/BinaryBasefold/Compliance.lean
  • instance instFintypePSpecFinalSumcheckChallenge : in ArkLib/ProofSystem/Binius/RingSwitching/Spec.lean
  • def finalSumcheckStepOracleConsistencyProp {h_le : ϑ ≤ ℓ} in ArkLib/ProofSystem/Binius/BinaryBasefold/Relations.lean
  • lemma getLastOracleDomainIndex_last : getLastOracleDomainIndex ℓ ϑ (Fin.last ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • def OracleAwareReductionLogicStep.IsStronglyCompleteUnderSimulation in ArkLib/ProofSystem/Binius/BinaryBasefold/ReductionLogic.lean
  • lemma exists_eq_some_of_mem_support_of_probOutput_none_eq_zero in ArkLib/ToVCVio/Lemmas.lean
  • lemma affineProximityGap_RS_interleaved_contrapositive in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/Incremental.lean
  • lemma 𝔽q_element_eq_zero_or_eq_one : ∀ c: 𝔽q, c = 0 ∨ c = 1 in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • lemma oracleFoldingConsistencyProp_relay_preserved (i : Fin ℓ) (hNCR : ¬ isCommitmentRound ℓ ϑ i) in ArkLib/ProofSystem/Binius/BinaryBasefold/Relations.lean
  • theorem intermediateNormVpoly_comp (i : Fin r) {destIdx : Fin r} in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • lemma preTensorCombine_jointProximityNat_of_fiberwiseClose (i : Fin ℓ) (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/Lift.lean
  • theorem qMap_total_fiber_injective (i : Fin r) {destIdx : Fin r} (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • abbrev goodBlockCodeword in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/QueryPhaseSoundness.lean
  • lemma mem_support_simulateQ_id'_liftM_query {ι : Type*} {spec : OracleSpec ι} in ArkLib/ToVCVio/Lemmas.lean
  • lemma folded_lifted_IC_eq_IC_row_polyToOracleFunc (i : Fin ℓ) (steps : ℕ) {destIdx : Fin r} in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/Lift.lean
  • lemma sumcheckConsistency_at_last_simplifies in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean
  • lemma exists_BBF_poly_of_codeword (i : Fin r) in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
  • def sumcheckStepLogic : in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean
  • lemma mem_support_run_iff {m : Type u → Type v} [Monad m] [HasEvalSPMF m] in ArkLib/ToVCVio/Lemmas.lean
  • lemma foldStepHStarFromWitMid_eq_of_oracleWitnessConsistency (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/Fold.lean
  • lemma challengeTensorExpansion_decompose_succ [CommRing L] (n : ℕ) (r : Fin (n + 1) → L) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • lemma support_simulateQ_eq (so : QueryImpl spec ProbComp) (oa : OracleComp spec α) in ArkLib/ToVCVio/Simulation.lean
  • lemma simulateQ_array_mapM {ι ι' : Type} {spec : OracleSpec ι} {superSpec : OracleSpec ι'} in ArkLib/ToVCVio/Simulation.lean
  • lemma strictRoundRelation_relay_preserved (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/Relay.lean
  • lemma UDRCodeword_eval_eq_of_fin_eq in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/QueryPhasePrelims.lean
  • lemma sum_range_pred_eq_sum_Icc {B : ℕ} (f : ℕ → ℕ) (hB : 1 ≤ B) : in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
  • instance instInhabitedOracleSpecEmpty : (([]ₒ : OracleSpec PEmpty).Inhabited) where in ArkLib/ProofSystem/Binius/RingSwitching/Spec.lean
  • lemma Matrix.det_map_ringHom {n : Type*} [Fintype n] [DecidableEq n] {R S : Type*} in ArkLib/Data/Fin/BigOperators.lean
  • theorem soundness_unroll_runToRound_1_P_to_V_pSpec_2 in ArkLib/OracleReduction/Completeness.lean
  • lemma mem_sDomain_of_eq {i j : Fin r} (h : i.val = j.val) in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • lemma Matrix.reindex_mulVec {m n o l : Type*} [Fintype n] [Fintype l] [Fintype m] [Fintype o] in ArkLib/Data/Fin/BigOperators.lean
  • def UDRClose (i : Fin r) (h_i : i ≤ ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
  • def strictOracleWitnessConsistency in ArkLib/ProofSystem/Binius/BinaryBasefold/Relations.lean
  • lemma Transcript_get_challenge (tr : pSpec.FullTranscript) (j : Fin n) (h : pSpec.dir j = .V_to_P) : in ArkLib/ToVCVio/Simulation.lean
  • lemma eq_split_finMap_PO2_iff_merge_finMap_PO2_eq {L : Type*} {n : ℕ} (v : Fin (2 ^ (n + 1)) → L) in ArkLib/Data/Fin/BigOperators.lean
  • lemma Prover.run_succ (prover : Prover oSpec StmtIn WitIn StmtOut WitOut pSpec) in ArkLib/ToVCVio/Simulation.lean
  • def tileCoeffs (a : Fin (2 ^ ℓ) → L) : Fin (2^(ℓ + R_rate)) → L in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • def foldProverComputeMsg (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Relations.lean
  • lemma finalSumcheck_honest_message_eq_t'_eval in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean
  • lemma probFailure_mk_bind_eq_zero_iff {m : Type u → Type v} [Monad m] [HasEvalSPMF m] in ArkLib/ToVCVio/Lemmas.lean
  • lemma Prover.processRound_V_to_P (j : Fin n) in ArkLib/ToVCVio/Simulation.lean
  • lemma mem_support_OptionT_bind_some {m : Type u → Type v} [Monad m] [HasEvalSPMF m] [LawfulMonad m] in ArkLib/ToVCVio/Lemmas.lean
  • lemma foldl_NTTStage_inductive_aux (h_ℓ : ℓ ≤ r) (k : Fin (ℓ + 1)) in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • def finalSumcheckVerifierCheck in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean
  • lemma probFailure_mk_do_bind_eq_zero_iff {m : Type u → Type v} [Monad m] [HasEvalSPMF m] in ArkLib/ToVCVio/Lemmas.lean
  • lemma probFailure_simulateQ_iff (so : QueryImpl spec ProbComp) (oa : OracleComp spec α) : in ArkLib/ToVCVio/Simulation.lean
  • lemma Matrix.reindex_mulVec_reindex {m n o l : Type*} [Fintype n] [Fintype l] [Fintype m] in ArkLib/Data/Fin/BigOperators.lean
  • lemma probFailure_simulateQ_liftQuery_eq in ArkLib/ToVCVio/Lemmas.lean
  • lemma queryBlockSourceIdx_le in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/QueryPhasePrelims.lean
  • lemma OptionT.probFailure_forIn_eq_zero_of_body_safe in ArkLib/ToVCVio/Simulation.lean
  • lemma simulateQ_forIn_stateful_comp {ι : Type} {spec : OracleSpec ι} in ArkLib/ToVCVio/Simulation.lean
  • def sumcheckProverWitOut (_stmtIn : Statement (L in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean
  • lemma sum_fin_eq_sum_Icc_pred {B : ℕ} (f : ℕ → ℕ) (hB : 1 ≤ B) : in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
  • def commitStepHEq (i : Fin ℓ) (hCR : isCommitmentRound ℓ ϑ i) : in ArkLib/ProofSystem/Binius/BinaryBasefold/ReductionLogic.lean
  • instance instInhabitedPSpecFold_AllChallenges : ∀ i, Inhabited ((pSpecFold (L in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean
  • abbrev MultilinearPoly (L : Type) [CommSemiring L] (ℓ : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • lemma support_run_simulateQ_run_fst_eq {ι : Type} in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean
  • theorem probEvent_simulateQ_run_ignore_state {α : Type} in ArkLib/OracleReduction/Completeness.lean
  • instance instFintypePSpecFinalSumcheckStepChallenge : in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean
  • lemma probFailure_run_simulateQ_liftQuery_eq in ArkLib/ToVCVio/Lemmas.lean
  • lemma support_StateT_ite_apply {σ α : Type} in ArkLib/ToVCVio/Simulation.lean
  • lemma goodBlock_implies_currentUDRClose in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/QueryPhaseSoundness.lean
  • lemma lt_r_of_le_ℓ {h_ℓ_add_R_rate : ℓ + 𝓡 < r} {x : ℕ} (h : x ≤ ℓ) : x < r in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • lemma OptionT.bind_pure_simulateQ_comp in ArkLib/ToVCVio/Simulation.lean
  • theorem castOutSimple_rbrKnowledgeSoundness in ArkLib/OracleReduction/Cast.lean
  • lemma badEventExistsProp_iff_incrementalBadEventExistsProp_last in ArkLib/ProofSystem/Binius/BinaryBasefold/Relations.lean
  • lemma OracleComp.liftM_query_eq_liftM_liftM.{u, v, z} in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean
  • instance instFintypePSpecRelayChallenge : in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean
  • lemma mem_support_OptionT_run_bind_some in ArkLib/ToVCVio/Lemmas.lean
  • def nonLastBlocksOracleVerifier : in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
  • def finalSumcheckKnowledgeError (m : pSpecFinalSumcheckStep (L in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean
  • theorem bbf_fullOracleReduction_perfectCompleteness (hInit : NeverFail init) : in ArkLib/ProofSystem/Binius/RingSwitching/BBFSmallFieldIOPCS.lean
  • lemma natDegree_qMap (i : Fin r) : (qMap 𝔽q β i).natDegree = 2 in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • lemma multilinearWeight_succ_lower_half {n : ℕ} in ArkLib/Data/CodingTheory/Prelims.lean
  • lemma liftComp_id in ArkLib/ToVCVio/Lemmas.lean
  • instance instInhabitedPSpecRelayMessage : [(pSpecRelay).Message]ₒ.Inhabited where in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean
  • theorem fullOracleVerifier_knowledgeSoundness : in ArkLib/ProofSystem/Binius/BinaryBasefold/General.lean
  • lemma degree_qMap (i : Fin r) : (qMap 𝔽q β i).degree = 2 in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • lemma firstOracleWitnessConsistencyProp_unique (t₁ t₂ : MultilinearPoly L ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Relations.lean
  • def logical_proximityChecksSpec in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/QueryPhasePrelims.lean
  • lemma probEvent_mk {m : Type u → Type v} [Monad m] [HasEvalSPMF m] in ArkLib/ToVCVio/Lemmas.lean
  • lemma val_mkFromStmtIdxCastSuccOfSucc {ℓ : ℕ} (i : Fin ℓ) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • def reducedMLPEvalStatement_to_BBF_Statement (stmt : MLPEvalStatement (L in ArkLib/ProofSystem/Binius/RingSwitching/BBFSmallFieldIOPCS.lean
  • def getFoldingChallenges (i : Fin (ℓ + 1)) (challenges : Fin i → L) in ArkLib/ProofSystem/Binius/BinaryBasefold/Relations.lean
  • lemma oracleFoldingConsistencyProp_commit_step_backward (i : Fin ℓ) (hCR : isCommitmentRound ℓ ϑ i) in ArkLib/ProofSystem/Binius/BinaryBasefold/Relations.lean
  • lemma neverFails_of_simulateQ_stateful_run'_mk in ArkLib/ToVCVio/Simulation.lean
  • theorem prop_4_23_singleRepetition_proximityCheck_bound in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean
  • lemma OracleStatement.heq_of_fin_eq {i j : Fin (ℓ + 1)} (h : i = j) : in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
  • def batchingStepLogic : in ArkLib/ProofSystem/Binius/RingSwitching/BatchingPhase.lean
  • def finTwoPowSumEquiv (n : ℕ) : Fin (2 ^ n) ⊕ Fin (2 ^ n) ≃ Fin (2 ^ (n + 1)) in ArkLib/Data/Fin/BigOperators.lean
  • def finToBinaryCoeffs (i : Fin r) (idx : Fin (2 ^ (ℓ + R_rate - i.val))) : in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • def fiberwiseDistance (i : Fin r) {destIdx : Fin r} (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
  • theorem splitSum_embedSum_fst {m : ℕ} {n : Fin m → ℕ} (i : Fin m) (j : Fin (n i)) : in ArkLib/Data/Fin/Sigma.lean
  • def foldPrvState (i : Fin ℓ) : Fin (2 + 1) → Type in ArkLib/ProofSystem/Binius/BinaryBasefold/Relations.lean
  • lemma simulateQ_vector_mapM {ι ι' : Type} {spec : OracleSpec ι} {superSpec : OracleSpec ι'} in ArkLib/ToVCVio/Simulation.lean
  • theorem unroll_1_message_reduction_perfectCompleteness_P_to_V in ArkLib/OracleReduction/Completeness.lean
  • def getMidCodewords {i : Fin (ℓ + 1)} (t : L⦃≤ 1⦄[X Fin ℓ]) in ArkLib/ProofSystem/Binius/BinaryBasefold/Relations.lean
  • def batchingCoreRbrKnowledgeError in ArkLib/ProofSystem/Binius/FRIBinius/General.lean
  • lemma mkVerifierOStmtOut_inl in ArkLib/OracleReduction/Basic.lean
  • lemma iterated_fold_first (i : Fin r) {midIdx destIdx : Fin r} (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • lemma checkSingleRepetition_inner_forIn_probFailure_eq_zero in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean
  • lemma queryBlockSourceSuffix_maps_to_destSuffix in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/QueryPhasePrelims.lean
  • lemma batching_doom_escape_probability_bound in ArkLib/ProofSystem/Binius/RingSwitching/BatchingPhase.lean
  • def masterKStateProp (stmtIdx : Fin (ℓ + 1)) in ArkLib/ProofSystem/Binius/BinaryBasefold/Relations.lean
  • lemma getFirstOracle_mapOStmtOutRelayStep_eq (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/Relay.lean
  • lemma probFailure_forIn_of_invariant in ArkLib/ToVCVio/Simulation.lean
  • def finalSumcheckProverComputeMsg in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean
  • lemma Matrix.mulVec_reindex {m n l : Type*} [Fintype n] [Fintype l] in ArkLib/Data/Fin/BigOperators.lean
  • def queryRbrKnowledgeError_singleRepetition in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/QueryPhasePrelims.lean
  • def strictBatchingInputRelationProp (stmt : BatchingStmtIn L ℓ) in ArkLib/ProofSystem/Binius/RingSwitching/BatchingPhase.lean
  • lemma support_mk {m : Type u → Type v} [Monad m] [HasEvalSPMF m] in ArkLib/ToVCVio/Lemmas.lean
  • def reindexSquareMatrix {n m : Type} (e : n ≃ m) (M : Matrix n n L) : Matrix m m L in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • def commitPrvState (i : Fin ℓ) : Fin (1 + 1) → Type in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/Commit.lean
  • lemma Statement.of_fin_eq {i j : Fin (ℓ + 1)} (h : i = j) : in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
  • def commitKState (i : Fin ℓ) (hCR : isCommitmentRound ℓ ϑ i) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/Commit.lean
  • lemma OptionT.simulateQ_ite in ArkLib/ToVCVio/Simulation.lean
  • lemma batching_rbrExtractionFailureEvent_imply_badBatchingEvent in ArkLib/ProofSystem/Binius/RingSwitching/BatchingPhase.lean
  • def challengeSuffixToFin (k : Fin (ℓ / ϑ)) in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/QueryPhasePrelims.lean
  • lemma fixFirstVariablesOfMQP_eval_eq (v : Fin (ℓ + 1)) {challenges : Fin v → L} in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • lemma support_run_eq_iff {m : Type u → Type v} [Monad m] [HasEvalSPMF m] in ArkLib/ToVCVio/Lemmas.lean
  • lemma witnessStructuralInvariant_MLPEvalWitness_to_BBF_Witness in ArkLib/ProofSystem/Binius/RingSwitching/BBFSmallFieldIOPCS.lean
  • def ReductionLogicStep.IsStronglyComplete in ArkLib/ProofSystem/Binius/BinaryBasefold/ReductionLogic.lean
  • def foldOracleVerifier (i : Fin ℓ) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/Fold.lean
  • lemma challengeTensorExpansion_bitsOfIndex_is_eq_indicator {n : ℕ} (k : Fin (2 ^ n)) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/Lift.lean
  • lemma firstOracleWitnessConsistency_unique in ArkLib/ProofSystem/Binius/RingSwitching/BBFSmallFieldIOPCS.lean
  • lemma oracle_block_k_next_le_i (i : Fin (ℓ + 1)) (j : Fin (toOutCodewordsCount ℓ ϑ i)) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • lemma finalSumcheck_honest_message_eq_f_zero in ArkLib/ProofSystem/Binius/FRIBinius/CoreInteractionPhase.lean
  • instance instInhabitedPspecCommitChallenge {i : Fin ℓ} : in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean
  • lemma logical_consistency_checks_passed_of_mem_support_V_run {σ : Type} in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean
  • lemma qMap_ne_zero (i : Fin r) : (qMap 𝔽q β i) ≠ 0 in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • lemma Sdomain_bound {x : ℕ} (h_x : x ≤ ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • theorem iNovelToMonomial_monomialToINovel_inverse (i : Fin r) (h_i : i ≤ ℓ) in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • instance instFintypePSpecBatching_AllChallenges : in ArkLib/ProofSystem/Binius/RingSwitching/Spec.lean
  • lemma lastBlockOracleReduction_perfectCompleteness (hInit : NeverFail init) : in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
  • instance instInhabitedPSpecFinalSumcheck_AllChallenges : ∀ i, Inhabited ((pSpecFinalSumcheck (L in ArkLib/ProofSystem/Binius/RingSwitching/Spec.lean
  • def foldCommitKnowledgeError (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
  • def FinalSumcheckWit in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/FinalSumcheck.lean
  • lemma OptionT.simulateQ_list_mapM_eq {ι ι' : Type} {spec : OracleSpec ι} in ArkLib/ToVCVio/Simulation.lean
  • lemma fiberwiseDisagreementSet_congr_sourceDomain_index (sourceIdx₁ sourceIdx₂ : Fin r) {destIdx : Fin r} (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
  • def challengeTensorExpansionMatrix [CommRing L] (n : ℕ) (r : Fin n → L) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • lemma support_forIn_subset_rel_yield_only in ArkLib/ToVCVio/Simulation.lean
  • lemma sumcheckFoldKnowledgeError_displayMass_le in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
  • lemma pairUDRClose_of_pairFiberwiseClose (i : Fin r) {destIdx : Fin r} (steps : ℕ) [NeZero steps] in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
  • def sumcheckConsistencyProp {k : ℕ} (sumcheckTarget : L) (H : L⦃≤ 2⦄[X Fin (k)]) : Prop in ArkLib/ProofSystem/Binius/BinaryBasefold/Relations.lean
  • lemma val_mkFromStmtIdxCastSuccOfSucc_eq_mkFromStmtIdx {ℓ : ℕ} (i : Fin ℓ) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • lemma finalSumcheckStep_verifierCheck_passed in ArkLib/ProofSystem/Binius/FRIBinius/CoreInteractionPhase.lean
  • def oracleFoldingConsistencyProp (i : Fin (ℓ + 1)) (challenges : Fin i → L) in ArkLib/ProofSystem/Binius/BinaryBasefold/Relations.lean
  • lemma support_bind {m : Type u → Type v} [Monad m] [HasEvalSPMF m] in ArkLib/ToVCVio/Lemmas.lean
  • lemma sDomain_eq_image_of_upper_span (i : Fin r) (h_i : i < ℓ + R_rate) : in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • theorem neverFails_simOracle2 {ι : Type u} (oSpec : OracleSpec ι) in ArkLib/OracleReduction/OracleInterface.lean
  • lemma challengeIdx_pSpecFinalSumcheckStep_isEmpty : in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
  • lemma normalizedW_eq_qMap_composition (ℓ R_rate : ℕ) (i : Fin r) : in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • def batchingMismatchPoly (msg0 s_bar : TensorAlgebra K L) : MvPolynomial (Fin κ) L in ArkLib/ProofSystem/Binius/RingSwitching/BatchingPhase.lean
  • theorem probEvent_runWithLogToRound_ignore_log in ArkLib/OracleReduction/Completeness.lean
  • theorem castInOut_rbrKnowledgeSoundness in ArkLib/OracleReduction/Cast.lean
  • theorem qMap_eval_𝔽q_eq_0 (i : Fin r) : in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • lemma OptionT.simulateQ_bind in ArkLib/ToVCVio/Simulation.lean
  • def getBBF_Codeword_of_poly (i : Fin r) (h_i : i ≤ ℓ) (P : L⦃< 2 ^ (ℓ - i)⦄[X]) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
  • def nonLastSingleBlockCommitIdx (bIdx : Fin (ℓ / ϑ - 1)) : Fin ℓ in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
  • lemma mem_support_map_prod_mk_iff [LawfulMonad m] in ArkLib/ToVCVio/Lemmas.lean
  • def checkSingleRepetition_foldRel in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean
  • def blockBadEventExistsProp in ArkLib/ProofSystem/Binius/BinaryBasefold/Relations.lean
  • lemma getNextOracle_eq_oracleStatement in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/QueryPhasePrelims.lean
  • lemma fiberEvaluations_eq_merge_fiberEvaluations_of_one_step_fiber in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • lemma UDRCodeword_eq_of_close in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
  • lemma intermediateEvaluationPoly_from_inovel_coeffs_eq_self in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • theorem evaluation_poly_split_identity (i : Fin r) (h_i : i < ℓ) in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • def foldStepFreshDoomPreservationEvent (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/Fold.lean
  • lemma iterated_fold_congr_source_index in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • lemma OptionT.probFailure_mk_forIn_eq_zero_of_body_safe in ArkLib/ToVCVio/Simulation.lean
  • instance instOracleInterfaceMessagePSpecFold : in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean
  • lemma butterflyMatrix_det_ne_zero (n : ℕ) (z₀ z₁ : L) (h_ne : z₀ ≠ z₁) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • lemma sBasis_range_eq (i : Fin r) (h_i : i < ℓ + R_rate) : in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • theorem largeFieldInvocationOracleReduction_perfectCompleteness (hInit : NeverFail init) : in ArkLib/ProofSystem/Binius/RingSwitching/BBFSmallFieldIOPCS.lean
  • instance instFintypePSpecQueryChallenge : [(pSpecQuery 𝔽q β γ_repetitions in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean
  • lemma incrementalBadEvent_last_imp_foldingBadEventAtBlock in ArkLib/ProofSystem/Binius/BinaryBasefold/Relations.lean
  • lemma intermediateNovelBasisX_zero_eq_one (i : Fin r) (h_i : i ≤ ℓ) : in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • lemma iterated_fold_last (i : Fin r) {midIdx destIdx : Fin r} (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • lemma probFailure_mk {m : Type u → Type v} [Monad m] [HasEvalSPMF m] in ArkLib/ToVCVio/Lemmas.lean
  • theorem fullRbrKnowledgeError_sum_le_concrete : in ArkLib/ProofSystem/Binius/BinaryBasefold/General.lean
  • def foldKStateProps {i : Fin ℓ} (m : Fin (2 + 1)) in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/Fold.lean
  • theorem UDRClose_of_fiberwiseClose (i : Fin r) {destIdx : Fin r} (steps : ℕ) [NeZero steps] in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
  • lemma mem_support_vector_mapM_pure {α β : Type} {n : ℕ} in ArkLib/ToVCVio/Simulation.lean
  • lemma fold_preserves_BBF_Code_membership (i : Fin r) {destIdx : Fin r} in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
  • lemma not_mem_support_run_none_of_probFailure_eq_zero in ArkLib/ToVCVio/Lemmas.lean
  • theorem forall_eq_bind_pure_iff {α β γ} in ArkLib/OracleReduction/Completeness.lean
  • lemma sum_range_eq_Icc_add_zero {B : ℕ} (f : ℕ → ℕ) (hB : 1 ≤ B) : in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
  • lemma iterated_fold_to_const_strict in ArkLib/ProofSystem/Binius/BinaryBasefold/ReductionLogic.lean
  • lemma logical_queryFiberPoints_eq_fiberEvaluations in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/QueryPhasePrelims.lean
  • instance instFintypeOracleStatementFinLast : in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean
  • lemma OptionT.support_run_simulateQ_run'_eq in ArkLib/ToVCVio/Simulation.lean
  • lemma initial_tiled_coeffs_correctness (h_ℓ : ℓ ≤ r) (a : Fin (2 ^ ℓ) → L) : in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • theorem finalSumcheckOracleVerifier_rbrKnowledgeSoundness {σ : Type} in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/FinalSumcheck.lean
  • def relayKStateProp (i : Fin ℓ) (hNCR : ¬ isCommitmentRound ℓ ϑ i) in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/Relay.lean
  • def finalSumcheckKStateProp {m : Fin (1 + 1)} (tr : Transcript m (pSpecFinalSumcheckStep (L in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/FinalSumcheck.lean
  • lemma farness_implies_non_compliance (i : Fin r) {destIdx : Fin r} (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Compliance.lean
  • theorem bbf_fullOracleVerifier_knowledgeSoundness : in ArkLib/ProofSystem/Binius/RingSwitching/BBFSmallFieldIOPCS.lean
  • lemma batching_check_correctness in ArkLib/ProofSystem/Binius/RingSwitching/Prelude.lean
  • lemma commitStep_is_logic_complete (i : Fin ℓ) (hCR : isCommitmentRound ℓ ϑ i) : in ArkLib/ProofSystem/Binius/BinaryBasefold/ReductionLogic.lean
  • lemma fold_eval_single_matrix_mul_form (i : Fin r) {destIdx : Fin r} in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • lemma OptionT.simulateQ_array_mapM_eq {ι ι' : Type} {spec : OracleSpec ι} in ArkLib/ToVCVio/Simulation.lean
  • lemma support_bind_simulateQ_run'_eq in ArkLib/ToVCVio/Simulation.lean
  • lemma qMap_total_fiber_congr_source_apply in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • lemma prob_poly_agreement_degree_one {R : Type} [CommRing R] [IsDomain R] [Fintype R] in ArkLib/Data/Probability/Instances.lean
  • lemma getBBF_Codeword_poly_spec (i : Fin r) in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
  • lemma butterflyMatrix0_mul_matrixCTensor_eq_matrixCTensor_mul_butterflyMatrix (n : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • lemma probFailure_OptionT_pure {m : Type u → Type v} [Monad m] [HasEvalSPMF m] in ArkLib/ToVCVio/Lemmas.lean
  • lemma OptionT.simulateQ_failure in ArkLib/ToVCVio/Simulation.lean
  • lemma fold_preTensorCombine_eq_affineLineEvaluation_split in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/Incremental.lean
  • theorem monomialToINovel_iNovelToMonomial_inverse (i : Fin r) (h_i : i ≤ ℓ) in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • def commitStepLogic_embedFn (i : Fin ℓ) : in ArkLib/ProofSystem/Binius/BinaryBasefold/ReductionLogic.lean
  • lemma exists_rel_path_of_mem_support_forIn_stateful {ι : Type} {spec : OracleSpec ι} [spec.Fintype] in ArkLib/ToVCVio/Simulation.lean
  • lemma single_point_localized_fold_matrix_form_eq_iterated_fold in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • theorem imp_comm {P Q R : Prop} : (P → Q → R) ↔ (Q → P → R) in ArkLib/ToVCVio/Lemmas.lean
  • lemma Matrix.det_fromBlocks_of_squareSubblocks_commute {n : ℕ} {R : Type*} [CommRing R] in ArkLib/Data/Fin/BigOperators.lean
  • lemma probFailure_simulateQ_simOracle2_eq_zero in ArkLib/ToVCVio/Simulation.lean
  • lemma finTwoPowSumEquiv_apply_right (n : ℕ) (x : Fin (2 ^ n)) : in ArkLib/Data/Fin/BigOperators.lean
  • lemma iterated_fold_congr_steps_index in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • lemma exists_unique_fiberwiseClosestCodeword_within_UDR (i : Fin r) {destIdx : Fin r} in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
  • lemma getLastOraclePositionIndex_last : getLastOraclePositionIndex ℓ ϑ (Fin.last ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • instance instInhabitedOracleSpecEmpty : (([]ₒ : OracleSpec PEmpty).Inhabited) where in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean
  • lemma OracleComp.probFailure_vector_mapM_eq_zero in ArkLib/ToVCVio/Simulation.lean
  • lemma finalSumcheckStep_is_logic_complete : in ArkLib/ProofSystem/Binius/FRIBinius/CoreInteractionPhase.lean
  • lemma batchingStep_is_logic_complete : in ArkLib/ProofSystem/Binius/RingSwitching/BatchingPhase.lean
  • lemma getSumcheckRoundPoly_eval_eq (i : Fin ℓ) (h_poly : ↥L⦃≤ 2⦄[X Fin (ℓ - ↑i.castSucc)]) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • lemma probability_bound_badSumcheckEventProp (h_i h_star : L⦃≤ 2⦄[X]) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness.lean
  • theorem unroll_rbrKnowledgeSoundness in ArkLib/OracleReduction/Completeness.lean
  • lemma qMap_total_fiber_congr_dest in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • def batchingProverComputeMsg (stmtIn : BatchingStmtIn L ℓ) (witIn : BatchingWitIn L K ℓ ℓ') : in ArkLib/ProofSystem/Binius/RingSwitching/BatchingPhase.lean
  • instance instInhabitedPSpecBatching_AllChallenges : in ArkLib/ProofSystem/Binius/RingSwitching/Spec.lean
  • lemma foldRelayKnowledgeError_eq (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
  • theorem unroll_n_message_reduction_perfectCompleteness in ArkLib/OracleReduction/Completeness.lean
  • lemma x_lt_two_pow (x : ℕ) : x < 2 ^ x in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
  • def badBlockSet in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/BadBlocks.lean
  • instance instMonadLift_right_right {ι₁ ι₂ ι₃ : Type} in ArkLib/ToVCVio/Simulation.lean
  • def logical_stepCondition (oStmt : ∀ j, OracleStatement 𝔽q β (h_ℓ_add_R_rate in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/QueryPhasePrelims.lean
  • def incrementalBadEventExistsProp in ArkLib/ProofSystem/Binius/BinaryBasefold/Relations.lean
  • lemma finToBinaryCoeffs_sDomainToFin (i : Fin r) (h_i : i < ℓ + R_rate) in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • instance instOracleStatementFintype {i : Fin (ℓ + 1)} : in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean
  • def mkFromStmtIdx {ℓ : ℕ} (stmtIdx : Fin (ℓ + 1)) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • lemma batching_compute_s0_sub_eq_eval_mismatch in ArkLib/ProofSystem/Binius/RingSwitching/BatchingPhase.lean
  • lemma batching_target_consistency in ArkLib/ProofSystem/Binius/RingSwitching/Prelude.lean
  • lemma support_pure_bind_pure {α β : Type} (x : α) (f : α → ProbComp β) : in ArkLib/ToVCVio/Lemmas.lean
  • lemma probFailure_run_simulateQ_liftQuery_eq_zero_iff in ArkLib/ToVCVio/Lemmas.lean
  • lemma degree_intermediateEvaluationPoly_lt (i : Fin r) (h_i : i ≤ ℓ) in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • def splitFinMap_PO2_left {L : Type*} {n : ℕ} (v : Fin (2 ^ (n + 1)) → L) in ArkLib/Data/Fin/BigOperators.lean
  • def sumcheckVerifierCheck (stmtIn : Statement (L in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean
  • theorem rbrKnowledgeSoundness_of_eq_error in ArkLib/OracleReduction/Security/RoundByRound.lean
  • def fiberDiff (i : Fin ℓ) (steps : ℕ) {destIdx : Fin r} in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/Lift.lean
  • lemma probFailure_simulateQ_liftQuery_eq_zero_iff in ArkLib/ToVCVio/Lemmas.lean
  • def foldStepHStarFromWitMid (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/Fold.lean
  • lemma mem_support_simulateQ_liftQuery_some_iff in ArkLib/ToVCVio/Lemmas.lean
  • lemma OracleStatement.oracle_eval_congr in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • lemma iteratedSumcheck_doom_escape_probability_bound (i : Fin ℓ') in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean
  • lemma OracleStatement.idx_eq {i j : Fin (ℓ + 1)} (h : i = j) : in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
  • lemma hammingDist_fin1_eq [DecidableEq (Fin 1 → A)] {u v : ι → Fin 1 → A} : in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/Incremental.lean
  • theorem coreInteractionOracleRbrKnowledgeError_le : in ArkLib/ProofSystem/Binius/FRIBinius/CoreInteractionPhase.lean
  • lemma sumcheckStep_is_logic_complete (i : Fin ℓ') : in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean
  • theorem probOutput_uniformOfFintype_eq_Pr in ArkLib/OracleReduction/Completeness.lean
  • theorem multilinear_eval_eq_sum_bool_hypercube [DecidableEq L] [IsDomain L] in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • lemma OptionT.simulateQ_pure in ArkLib/ToVCVio/Simulation.lean
  • theorem intermediateChangeOfBasisMatrix_diag_ne_zero (i : Fin r) (h_i : i ≤ ℓ) : in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • lemma not_mem_support_none_of_probOutput_none_eq_zero in ArkLib/ToVCVio/Lemmas.lean
  • lemma finalCodeword_zero_eq_t_eval in ArkLib/ProofSystem/Binius/FRIBinius/CoreInteractionPhase.lean
  • lemma getFirstOracle_snoc_oracle in ArkLib/ProofSystem/Binius/BinaryBasefold/ReductionLogic.lean
  • instance instInhabitedPSpecQueryChallenge : in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean
  • lemma OptionT.simulateQ_map' {α β : Type u} in ArkLib/ToVCVio/Simulation.lean
  • lemma support_simulateQ_run'_eq in ArkLib/ToVCVio/Simulation.lean
  • lemma preTensorCombine_is_interleavedCodeword_of_codeword (i : Fin ℓ) (steps : ℕ) {destIdx : Fin r} in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/Lift.lean
  • theorem additiveNTT_correctness (h_ℓ : ℓ ≤ r) in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • lemma fiberwise_disagreement_isomorphism (i : Fin ℓ) (steps : ℕ) {destIdx : Fin r} in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/Lift.lean
  • def butterflyMatrix (n : ℕ) (z₀ z₁ : L) : Matrix (Fin (2 ^ (n + 1))) (Fin (2 ^ (n + 1))) L in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • def rbrExtractionFailureEvent {ι : Type} {oSpec : OracleSpec ι} {StmtIn WitIn WitOut : Type} {n : ℕ} in ArkLib/ProofSystem/Binius/BinaryBasefold/ReductionLogic.lean
  • lemma iterated_fold_to_level_ℓ_is_constant in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • theorem iteratedQuotientMap_k_eq_1_is_qMap (i : Fin r) {destIdx : Fin r} in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • lemma qCompositionChain_eq_foldl (i : Fin r) : in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • lemma support_liftComp_id in ArkLib/ToVCVio/Lemmas.lean
  • lemma oracle_index_add_steps_le_ℓ (i : Fin (ℓ + 1)) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • lemma bind_pure_simulateQ_comp in ArkLib/ToVCVio/Simulation.lean
  • def polyToOracleFunc {domainIdx : Fin r} (P : L[X]) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • theorem simulateQ_preserves_safety_mk in ArkLib/ToVCVio/Simulation.lean
  • lemma foldMatrix_det_ne_zero (i : Fin r) {destIdx : Fin r} (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • lemma finalSumcheckStep_is_logic_complete : in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean
  • lemma distFromCode_fin1_eq [DecidableEq (Fin 1 → A)] (u : ι → Fin 1 → A) (C : Set (ι → A)) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/Incremental.lean
  • instance instInhabitedPSpecFinalSumcheckStepMessage : in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean
  • lemma fiberwiseDisagreementSet_steps_zero_eq_disagreementSet in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
  • theorem lemma_4_25_reject_if_suffix_in_disagreement in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/QueryPhaseSoundness.lean
  • def finalSumcheckStepLogic : in ArkLib/ProofSystem/Binius/FRIBinius/CoreInteractionPhase.lean
  • lemma degree_intermediateNovelBasisX (i : Fin r) (h_i : i ≤ ℓ) (j : Fin (2 ^ (ℓ - i))) : in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • def queryPhaseProverState : Fin (1 + 1) → Type in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean
  • instance largeFieldInvocationExtractorLens_rbr_knowledge_soundness in ArkLib/ProofSystem/Binius/RingSwitching/BBFSmallFieldIOPCS.lean
  • lemma finalSumcheckStep_verifierCheck_passed in ArkLib/ProofSystem/Binius/BinaryBasefold/ReductionLogic.lean
  • def finalSumcheckVerifierStmtOut in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean
  • theorem QueryImpl_append_impl_inr_stateful_run' in ArkLib/ToVCVio/Simulation.lean
  • theorem intermediateNormVpoly_comp_qmap_helper (i : Fin r) (h_i : i < ℓ) in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • lemma mem_support_simulateQ_liftQuery_iff in ArkLib/ToVCVio/Lemmas.lean
  • lemma probFailure_forIn_of_relations in ArkLib/ToVCVio/Simulation.lean
  • instance instFintypePSpecFinalSumcheck_AllChallenges : ∀ i, Fintype ((pSpecFinalSumcheck (L in ArkLib/ProofSystem/Binius/RingSwitching/Spec.lean
  • def UDRCodeword (i : Fin r) (h_i : i ≤ ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
  • def BBF_eq_multiplier (r : Fin ℓ → L) : MultilinearPoly L ℓ in ArkLib/ProofSystem/Binius/BinaryBasefold/Relations.lean
  • lemma multilinearWeight_succ {ϑ : ℕ} (r : Fin (ϑ + 1) → F) (i : Fin (2 ^ (ϑ + 1))) : in ArkLib/Data/CodingTheory/Prelims.lean
  • theorem FullTranscript.mk1_eq_snoc {pSpec : ProtocolSpec 1} (msg0 : pSpec.«Type» 0) : in ArkLib/OracleReduction/Basic.lean
  • theorem fullRbrKnowledgeError_sum_le_concrete : in ArkLib/ProofSystem/Binius/FRIBinius/General.lean
  • lemma OptionT.mem_support_StateT_bind_run {σ α β : Type} in ArkLib/ToVCVio/Simulation.lean
  • theorem probEvent_PMF_eq_Pr {α : Type} (pmf : PMF α) (P : α → Prop) [DecidablePred P] : in ArkLib/OracleReduction/Completeness.lean
  • lemma iterated_fold_preserves_BBF_Code_membership (i : Fin r) {destIdx : Fin r} (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
  • def foldWitMid (i : Fin ℓ) : Fin (2 + 1) → Type in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/Fold.lean
  • def preTensorCombine_WordStack (i : Fin ℓ) (steps : ℕ) {destIdx : Fin r} in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/Lift.lean
  • def commitKnowledgeError {i : Fin ℓ} in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/Commit.lean
  • lemma prob_poly_agreement_degree_two {R : Type} [CommRing R] [IsDomain R] [Fintype R] in ArkLib/Data/Probability/Instances.lean
  • lemma mem_support_run_map_some_iff [LawfulMonad m] {α β : Type u} in ArkLib/ToVCVio/Lemmas.lean
  • lemma snoc_oracle_impossible {i : Fin ℓ} {j : Fin (toOutCodewordsCount ℓ ϑ i.succ)} in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • def nonLastSingleBlockRbrKnowledgeError (bIdx : Fin (ℓ / ϑ - 1)) in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
  • lemma query_phase_step_preserves_fold in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean
  • lemma checkSingleRepetition_probFailure_eq_zero in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean
  • lemma mem_support_OptionT_bind_run_some_iff [LawfulMonad m] {α β : Type u} in ArkLib/ToVCVio/Lemmas.lean
  • lemma OptionT.liftM_run_getM_bind {α β} {ι₁ ι₂ : Type} {spec₁ : OracleSpec ι₁} in ArkLib/ToVCVio/Simulation.lean
  • lemma UDRClose_iff_within_UDR_radius (i : Fin r) (h_i : i ≤ ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
  • lemma evaluationPointω_eq_twiddleFactor_of_div_2 (i : Fin r) (h_i : i < ℓ) in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • instance instFintypePSpecQuery_AllChallenges : in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean
  • lemma NTTStage_correctness (i : Fin (ℓ)) in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • def concreteFRIBiniusKnowledgeError : ℝ≥0 in ArkLib/ProofSystem/Binius/FRIBinius/General.lean
  • def blockDiagMatrix (n : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • lemma finTwoPowSumEquiv_apply_left (n : ℕ) (x : Fin (2 ^ n)) : in ArkLib/Data/Fin/BigOperators.lean
  • lemma sum_Icc_one_pred_sub_reindex {B ϑ : ℕ} (f : ℕ → ℕ) (hB : 1 ≤ B) : in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
  • theorem run'_bind_lib [Monad m] [LawfulMonad m] (ma : StateT σ m α) (f : α → StateT σ m β) (s : σ) : in ArkLib/ToVCVio/Lemmas.lean
  • lemma OptionT.simulateQ_forIn in ArkLib/ToVCVio/Simulation.lean
  • def incrementalBadEventAtLast in ArkLib/ProofSystem/Binius/BinaryBasefold/Relations.lean
  • theorem queryPhaseLogicStep_isStronglyComplete : in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean
  • def foldVerifierStmtOut (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Relations.lean
  • def challengeTensorExpansion [CommRing L] (n : ℕ) (r : Fin n → L) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • instance instFintypeOracleSpecEmpty : (([]ₒ : OracleSpec PEmpty).Fintype) where in ArkLib/ProofSystem/Binius/RingSwitching/Spec.lean
  • lemma intermediate_poly_P_base (h_ℓ : ℓ ≤ r) (coeffs : Fin (2 ^ ℓ) → L) : in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • lemma cast_fun_eq_fun_cast_arg.{u, v} {A B : Type u} {C : Type v} (h : A = B) (f : A → C) : in ArkLib/Data/Misc/Basic.lean
  • def castInOut in ArkLib/OracleReduction/Cast.lean
  • instance instFintypePSpecFinalSumcheck_AllChallenges : in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean
  • lemma probEvent_pure_iff {α : Type} (p : α → Prop) (x : α) : in ArkLib/ToVCVio/Lemmas.lean
  • def mergeFinMap_PO2_left_right {L : Type*} {n : ℕ} (left : Fin (2 ^ n) → L) in ArkLib/Data/Fin/BigOperators.lean
  • def foldStepWitMidOracleConsistency (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/Fold.lean
  • def getLiftCoeffs (i : Fin ℓ) (steps : ℕ) {destIdx : Fin r} in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/Lift.lean
  • instance instInhabitedPSpecBatchingMessage : [(pSpecBatching κ L K).Message]ₒ.Inhabited in ArkLib/ProofSystem/Binius/RingSwitching/Spec.lean
  • lemma Polynomial.toMvPolynomial_totalDegree_le [Nontrivial R] (p : Polynomial R) (i : σ) : in ArkLib/ToMathlib/MvPolynomial/Equiv.lean
  • theorem iteratedQuotientMap_succ_comp in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • lemma goodBlock_implies_UDRClose in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/BadBlocks.lean
  • lemma probFailure_mk_do_bind_bindT_eq_zero_iff {m : Type u → Type v} [Monad m] [HasEvalSPMF m] in ArkLib/ToVCVio/Lemmas.lean
  • def finalSumcheckStepLogic : in ArkLib/ProofSystem/Binius/BinaryBasefold/ReductionLogic.lean
  • instance instInhabitedPSpecFinalSumcheckChallenge : in ArkLib/ProofSystem/Binius/RingSwitching/Spec.lean
  • lemma prop_4_21_2_case_1_fiberwise_close_incremental in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/Incremental.lean
  • lemma Matrix.reindex_mul_reindex {l m n o p q : Type*} [Fintype n] [Fintype p] in ArkLib/Data/Fin/BigOperators.lean
  • def finalSumcheckProverWitOut : Unit in ArkLib/ProofSystem/Binius/FRIBinius/CoreInteractionPhase.lean
  • lemma OptionT.simulateQ_simOracle2_liftM_query_T2 in ArkLib/ToVCVio/Simulation.lean
  • lemma projectToNextSumcheckPoly_sum_eq (i : Fin ℓ) (Hᵢ : MultiquadraticPoly L (ℓ - i)) (rᵢ : L) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • lemma single_point_localized_fold_matrix_form_congr_source_index in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • lemma OptionT.support_run_eq in ArkLib/ToVCVio/Simulation.lean
  • lemma mem_support_bind_bind_map_generic_iff [LawfulMonad m] in ArkLib/ToVCVio/Lemmas.lean
  • lemma Fin.reindex_reindex {R n m l : Type*} [Fintype n] [Fintype m] [Fintype l] in ArkLib/Data/Fin/BigOperators.lean
  • lemma constantIntermediateEvaluationPoly_eval_eq_const in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • def finalSumcheckProverWitOut (witIn : SumcheckWitness L ℓ' (Fin.last ℓ')) : WitMLP L ℓ' in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean
  • def decomposeChallenge (v : sDomain 𝔽q β h_ℓ_add_R_rate ⟨0, by omega⟩) in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/QueryPhasePrelims.lean
  • def batchingProverWitOut (stmtIn : BatchingStmtIn L ℓ) (witIn : BatchingWitIn L K ℓ ℓ') in ArkLib/ProofSystem/Binius/RingSwitching/BatchingPhase.lean
  • lemma prob_schwartz_zippel_univariate_deg {R : Type} [CommRing R] [IsDomain R] [Fintype R] in ArkLib/Data/Probability/Instances.lean
  • lemma foldBadEventCardSum_le_two_pow : in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
  • lemma goodBlock_point_disagreement_step in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/QueryPhaseSoundness.lean
  • def relayOracleVerifier_embed (i : Fin ℓ) (hNCR : ¬ isCommitmentRound ℓ ϑ i) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/Relay.lean
  • lemma batchingMismatchPoly_nonzero_of_ne in ArkLib/ProofSystem/Binius/RingSwitching/BatchingPhase.lean
  • lemma ENNReal.tsum_mul_le_of_le_of_sum_le_one {α : Type*} {f g : α → ℝ≥0∞} {ε : ℝ≥0∞} in ArkLib/OracleReduction/Completeness.lean
  • instance largeFieldInvocationCtxLens_complete : in ArkLib/ProofSystem/Binius/RingSwitching/BBFSmallFieldIOPCS.lean
  • def liftQuery {spec : OracleSpec ι} {α} (q : OracleQuery spec α) : OracleComp spec α in ArkLib/OracleReduction/Completeness.lean
  • lemma iteratedQuotientMap_congr_k in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • def fiberEvaluations (i : Fin r) {destIdx : Fin r} (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • abbrev BBF_CodeDistance (i : Fin r) : ℕ in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
  • def BBF_Code (i : Fin r) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
  • lemma tsum_mul_le_of_le_of_sum_le_one_nnreal {α : Type*} in ArkLib/OracleReduction/Completeness.lean
  • lemma support_challengeQueryImpl_eq {n : ℕ} {pSpec : ProtocolSpec n} in ArkLib/ToVCVio/Simulation.lean
  • lemma exists_fiberwiseClosestCodeword (i : Fin r) {destIdx : Fin r} (steps : ℕ) [NeZero steps] in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
  • def castOutSimple in ArkLib/OracleReduction/Cast.lean
  • theorem knowledgeSoundness_error_mono in ArkLib/OracleReduction/Security/Basic.lean
  • def queryRbrKnowledgeError in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/QueryPhasePrelims.lean
  • lemma addLift_challengeQueryImpl_input_run_eq_liftM_run in ArkLib/ToVCVio/Simulation.lean
  • def lastBlockRbrKnowledgeError (k : (pSpecLastBlock (L in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
  • abbrev queryBlockSourceSuffix in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/QueryPhasePrelims.lean
  • theorem foldOracleVerifier_rbrKnowledgeSoundness (i : Fin ℓ) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/Fold.lean
  • lemma OptionT.simulateQ_map in ArkLib/ToVCVio/Simulation.lean
  • theorem base_intermediateNovelBasisX (j : Fin (2 ^ ℓ)) : in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
  • def getLastOracleDomainIndex (oracleFrontierIdx : Fin (ℓ + 1)) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • lemma fold_agreement_of_fiber_agreement (i : Fin ℓ) (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/FoldDistance.lean
  • lemma mem_support_map_some_iff [LawfulMonad m] {α β : Type u} in ArkLib/ToVCVio/Lemmas.lean
  • def fold_eval_fiber₂_vec (i : Fin r) {midIdx destIdx : Fin r} (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
  • lemma OptionT.support_map_run in ArkLib/ToVCVio/Simulation.lean
  • lemma support_run {m : Type u → Type v} [Monad m] [HasEvalSPMF m] in ArkLib/ToVCVio/Lemmas.lean
  • lemma k_mul_ϑ_lt_ℓ {k : Fin (ℓ / ϑ)} : in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
  • lemma prop_4_21_case_2_fiberwise_far (i : Fin ℓ) (steps : ℕ) [NeZero steps] in ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/Proposition4_21.lean
  • def nonLastSingleBlockOracleReduction (bIdx : Fin (ℓ / ϑ - 1)) in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
  • lemma probFailure_simulateQ_queryFiberPoints_eq_zero in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean
  • def batchingVerifierStmtOut (stmtIn : BatchingStmtIn L ℓ) in ArkLib/ProofSystem/Binius/RingSwitching/BatchingPhase.lean
  • def commitStepLogic_embed (i : Fin ℓ) (hCR : isCommitmentRound ℓ ϑ i) : in ArkLib/ProofSystem/Binius/BinaryBasefold/ReductionLogic.lean
  • instance instInhabitedPSpecQueryMessage : in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean
  • lemma constFunc_UDRClose {i : Fin r} (h_i : i ≤ ℓ) (c : L) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
  • lemma mem_support_OptionT_bind_pure_comp_run_some_iff [LawfulMonad m] {α β : Type u} in ArkLib/ToVCVio/Lemmas.lean
✏️ **Affected:** 48 declaration(s) (line number changed)
  • theorem is_fiber_iff_generates_quotient_point (i : Fin r) {destIdx : Fin r} (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean moved from L460 to L920
  • theorem sumcheckFoldOracleReduction_perfectCompleteness (hInit : NeverFail init) : in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean moved from L547 to L1105
  • def pSpecFinalSumcheck in ArkLib/ProofSystem/Binius/RingSwitching/Spec.lean moved from L43 to L64
  • theorem coreInteractionOracleReduction_perfectCompleteness (hInit : NeverFail init) in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean moved from L625 to L1672
  • lemma qMap_total_fiber_one_level_eq (i : Fin r) {destIdx : Fin r} in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean moved from L384 to L840
  • def batchingInputRelation : in ArkLib/ProofSystem/Binius/RingSwitching/BatchingPhase.lean moved from L198 to L97
  • theorem iteratedSumcheckOracleReduction_perfectCompleteness (i : Fin ℓ') (hInit : NeverFail init) : in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean moved from L198 to L307
  • def snoc_oracle {i : Fin ℓ} {destIdx : Fin r} (h_destIdx : destIdx = i.val + 1) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean moved from L677 to L1865
  • def take_snoc_oracle (i : Fin ℓ) {destIdx : Fin r} (h_destIdx : destIdx = i.val + 1) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean moved from L748 to L1885
  • def fold (i : Fin r) {destIdx : Fin r} (h_destIdx : destIdx = i.val + 1) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean moved from L751 to L1355
  • def iterated_fold (i : Fin r) (steps : ℕ) {destIdx : Fin r} in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean moved from L789 to L1572
  • theorem fullOracleReduction_perfectCompleteness (hInit : NeverFail init) : in ArkLib/ProofSystem/Binius/FRIBinius/General.lean moved from L175 to L191
  • def BinaryBasefoldAbstractOStmtIn : (RingSwitching.AbstractOStmtIn (L in ArkLib/ProofSystem/Binius/FRIBinius/Prelude.lean moved from L51 to L53
  • lemma qMap_total_fiber_repr_coeff (i : Fin r) {destIdx : Fin r} (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean moved from L343 to L796
  • lemma pointToIterateQuotientIndex_qMap_total_fiber_eq_self (i : Fin r) {destIdx : Fin r} (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean moved from L525 to L980
  • theorem batchingReduction_perfectCompleteness (hInit : NeverFail init) : in ArkLib/ProofSystem/Binius/RingSwitching/BatchingPhase.lean moved from L314 to L710
  • def sumcheckFoldOracleReduction : OracleReduction []ₒ in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean moved from L501 to L821
  • def queryKStateProp (m : Fin (1 + 1)) in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean moved from L359 to L2604
  • theorem iterated_fold_eq_matrix_form (i : Fin r) {destIdx : Fin r} (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean moved from L926 to L2250
  • theorem card_qMap_total_fiber (i : Fin r) {destIdx : Fin r} (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean moved from L597 to L1097
  • theorem fullOracleVerifier_rbrKnowledgeSoundness : in ArkLib/ProofSystem/Binius/RingSwitching/General.lean moved from L145 to L151
  • def projectToMidSumcheckPoly (t : MultilinearPoly L ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean moved from L392 to L672
  • theorem coreInteraction_rbrKnowledgeSoundness : in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean moved from L624 to L1842
  • theorem queryOracleVerifier_rbrKnowledgeSoundness {σ : Type} (init : ProbComp σ) in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean moved from L405 to L2765
  • def foldMatrix (i : Fin r) {destIdx : Fin r} (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean moved from L776 to L1474
  • lemma batchingCore_perfectCompleteness (hInit : NeverFail init) : in ArkLib/ProofSystem/Binius/RingSwitching/General.lean moved from L106 to L110
  • theorem fullOracleReduction_perfectCompleteness (hInit : NeverFail init) : in ArkLib/ProofSystem/Binius/RingSwitching/General.lean moved from L119 to L124
  • theorem finalSumcheckOracleVerifier_rbrKnowledgeSoundness {σ : Type} in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean moved from L525 to L1717
  • def finalSumcheckKStateProp {m : Fin (1 + 1)} (tr : Transcript m (pSpecFinalSumcheckStep (L in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean moved from L476 to L1515
  • lemma oracle_block_k_bound (i : Fin (ℓ + 1)) (j : Fin (toOutCodewordsCount ℓ ϑ i)) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean moved from L802 to L348
  • theorem fullOracleReduction_perfectCompleteness (hInit : NeverFail init) : in ArkLib/ProofSystem/Binius/BinaryBasefold/General.lean moved from L111 to L115
  • theorem coreInteractionOracleReduction_perfectCompleteness (hInit : NeverFail init) : in ArkLib/ProofSystem/Binius/FRIBinius/CoreInteractionPhase.lean moved from L645 to L1656
  • def firstOracleWitnessConsistencyProp (t : MultilinearPoly L ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean moved from L885 to L1154
  • theorem sumcheckFoldOracleReduction_perfectCompleteness (hInit : NeverFail init) : in ArkLib/ProofSystem/Binius/FRIBinius/CoreInteractionPhase.lean moved from L201 to L250
  • instance sumcheckFoldExtractorLens_rbr_knowledge_soundness in ArkLib/ProofSystem/Binius/FRIBinius/CoreInteractionPhase.lean moved from L264 to L316
  • abbrev OracleFunction (domainIdx : Fin r) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean moved from L234 to L592
  • def projectToNextSumcheckPoly (i : Fin (ℓ)) (Hᵢ : MultiquadraticPoly L (ℓ - i)) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean moved from L407 to L687
  • theorem coreInteraction_perfectCompleteness (hInit : NeverFail init) : in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean moved from L592 to L1792
  • def batchingInputRelationProp (stmt : BatchingStmtIn L ℓ) in ArkLib/ProofSystem/Binius/RingSwitching/BatchingPhase.lean moved from L191 to L85
  • lemma qMap_total_fiber_basis_sum_repr (i : Fin r) {destIdx : Fin r} (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean moved from L557 to L1010
  • def computeInitialSumcheckPoly (t : MultilinearPoly L ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean moved from L376 to L655
  • def batchingRBRKnowledgeError : ℝ≥0 in ArkLib/ProofSystem/Binius/RingSwitching/BatchingPhase.lean moved from L227 to L420
  • lemma take_snoc_oracle_eq_oStmtIn (i : Fin ℓ) {destIdx : Fin r} (h_destIdx : destIdx = i.val + 1) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean moved from L761 to L1899
  • def localized_fold_matrix_form (i : Fin r) {destIdx : Fin r} (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean moved from L896 to L2121
  • def getFirstOracle {oracleFrontierIdx : Fin (ℓ + 1)} in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean moved from L771 to L1913
  • def decompose_tensor_algebra_columns {σ : Type*} (β : Basis σ K L) (s_hat : L ⊗[K] L) : σ → L in ArkLib/ProofSystem/Binius/RingSwitching/Prelude.lean moved from L97 to L100
  • def sumcheckFoldKnowledgeError (j : (pSpecSumcheckFold 𝔽q β (ϑ in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean moved from L562 to L1552
  • def pointToIterateQuotientIndex (i : Fin r) {destIdx : Fin r} (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean moved from L367 to L822

sorry Tracking

✅ **Removed:** 38 `sorry`(s)
  • lemma iterated_fold_transitivity in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean (L843)
  • theorem relayOracleReduction_perfectCompleteness (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps.lean (L707)
  • theorem sumcheckFoldOracleReduction_perfectCompleteness (hInit : NeverFail init) : in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean (L558)
  • theorem iteratedSumcheckOracleReduction_perfectCompleteness (i : Fin ℓ') (hInit : NeverFail init) : in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean (L209)
  • def foldKnowledgeStateFunction (i : Fin ℓ) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps.lean (L368)
  • def foldKnowledgeStateFunction (i : Fin ℓ) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps.lean (L369)
  • theorem foldOracleReduction_perfectCompleteness (i : Fin ℓ) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps.lean (L231)
  • theorem iteratedSumcheckOracleVerifier_rbrKnowledgeSoundness (i : Fin ℓ') : in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean (L339)
  • lemma single_point_localized_fold_matrix_form_eq_iterated_fold in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean (L937)
  • def relayKnowledgeStateFunction (i : Fin ℓ) (hNCR : ¬ isCommitmentRound ℓ ϑ i) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps.lean (L759)
  • def relayKnowledgeStateFunction (i : Fin ℓ) (hNCR : ¬ isCommitmentRound ℓ ϑ i) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps.lean (L761)
  • theorem batchingOracleVerifier_rbrKnowledgeSoundness : in ArkLib/ProofSystem/Binius/RingSwitching/BatchingPhase.lean (L343)
  • def commitKState (i : Fin ℓ) (hCR : isCommitmentRound ℓ ϑ i) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps.lean (L596)
  • def commitKState (i : Fin ℓ) (hCR : isCommitmentRound ℓ ϑ i) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps.lean (L598)
  • theorem finalSumcheckOracleReduction_perfectCompleteness {σ : Type} in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps.lean (L923)
  • theorem foldOracleVerifier_rbrKnowledgeSoundness (i : Fin ℓ) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps.lean (L384)
  • theorem batchingReduction_perfectCompleteness (hInit : NeverFail init) : in ArkLib/ProofSystem/Binius/RingSwitching/BatchingPhase.lean (L323)
  • def queryKStateProp (m : Fin (1 + 1)) in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean (L402)
  • theorem fullOracleVerifier_rbrKnowledgeSoundness : in ArkLib/ProofSystem/Binius/RingSwitching/General.lean (L180)
  • theorem fullOracleVerifier_rbrKnowledgeSoundness : in ArkLib/ProofSystem/Binius/RingSwitching/General.lean (L184)
  • lemma nonDoomedFoldingProp_relay_preserved (i : Fin ℓ) (hNCR : ¬ isCommitmentRound ℓ ϑ i) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean (L944)
  • theorem queryOracleVerifier_rbrKnowledgeSoundness {σ : Type} (init : ProbComp σ) in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean (L416)
  • theorem finalSumcheckOracleReduction_perfectCompleteness {σ : Type} in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean (L450)
  • def foldMatrix (i : Fin r) (steps : Fin (ℓ + 1)) (h_i_add_steps : i.val + steps < ℓ + 𝓡) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean (L786)
  • theorem commitOracleReduction_perfectCompleteness (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps.lean (L529)
  • theorem sumcheckFoldOracleVerifier_rbrKnowledgeSoundness : in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean (L580)
  • theorem finalSumcheckOracleVerifier_rbrKnowledgeSoundness {σ : Type} in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean (L535)
  • theorem queryOracleProof_perfectCompleteness {σ : Type} in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean (L341)
  • def finalSumcheckKStateProp {m : Fin (1 + 1)} (tr : Transcript m (pSpecFinalSumcheckStep (L in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean (L520)
  • def finalSumcheckKStateProp {m : Fin (1 + 1)} (tr : Transcript m (pSpecFinalSumcheckStep (L in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean (L522)
  • theorem OracleReduction.id_runWithLog (stmt : StmtIn) (oStmt : ∀ i, OStmtIn i) (wit : WitIn) : in ArkLib/OracleReduction/Execution.lean (L380)
  • lemma oracleWitnessConsistency_relay_preserved in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean (L973)
  • theorem finalSumcheckOracleReduction_perfectCompleteness {σ : Type} in ArkLib/ProofSystem/Binius/FRIBinius/CoreInteractionPhase.lean (L476)
  • def finalSumcheckKStateProp {m : Fin (1 + 1)} (tr : Transcript m (pSpecFinalSumcheckStep (L in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps.lean (L1016)
  • def finalSumcheckKStateProp {m : Fin (1 + 1)} (tr : Transcript m (pSpecFinalSumcheckStep (L in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps.lean (L1018)
  • def sumcheckFoldKnowledgeError in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean (L567)
  • def iteratedSumcheckKnowledgeStateFunction (i : Fin ℓ') : in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean (L327)
  • theorem finalSumcheckOracleVerifier_rbrKnowledgeSoundness [Fintype L] {σ : Type} in ArkLib/ProofSystem/Binius/FRIBinius/CoreInteractionPhase.lean (L597)

🎨 **Style Guide Adherence**

This review identifies extensive style guide violations across the provided changes. Due to the high volume of naming and formatting issues, violations are grouped by rule.

Naming Conventions: Theorems & Proofs

Rule: "Theorems and Proofs: snake_case (e.g., add_comm, list_reverse_id)."
There are approximately 60 violations of this rule where CamelCase or mixed-case identifiers are used for lemmas and theorems.

  • AdditiveNTT.lean Line 24: lemma multilinearWeight_succ should be multilinear_weight_succ.
  • AdditiveNTT.lean Line 83: lemma natDegree_qMap should be nat_degree_q_map.
  • AdditiveNTT.lean Line 756: theorem intermediateNormVpoly_comp_qmap should be intermediate_norm_v_poly_comp_q_map.

Naming Conventions: Functions & Terms

Rule: "Functions and Terms: lowerCamelCase (e.g., binarySearch, isPrime)."

  • AdditiveNTT.lean Line 60: def sDomain_cast should be sDomainCast.
  • AdditiveNTT.lean Line 442: def sDomain_basis should be sDomainBasis.
  • AdditiveNTT.lean Line 1072: def sDomain.lift should be sDomain.lift.

Naming Conventions: Acronyms

Rule: "Acronyms: Treat as words (e.g., HtmlParser not HTMLParser)."

  • AdditiveNTT.lean Line 1708: def NTTStage should be nttStage.
  • BigOperators.lean Line 60: PO2 in splitFinMap_PO2_left should be Po2.
  • Relations.lean Line 589: MLP in extractMLP should be Mlp.

Symbol Naming Dictionary

Rule: "0 -> zero, 1 -> one."

  • AdditiveNTT.lean Line 120: qMap_eval_𝔽q_eq_0 should be q_map_eval_fq_eq_zero.
  • AdditiveNTT.lean Line 518: get_sDomain_first_basis_eq_1 should be get_s_domain_first_basis_eq_one.
  • AdditiveNTT.lean Line 1845: novel_poly_of_1_leading_suffix should be novel_poly_of_one_leading_suffix.

Syntax and Formatting: Line Length

Rule: "Keep lines under 100 characters."
Multiple lines exceed the 100-character limit.

  • AdditiveNTT.lean Line 27: (105 characters)
  • AdditiveNTT.lean Line 131: (104 characters)
  • AdditiveNTT.lean Line 2168: (102 characters)

Syntax and Formatting: Empty Lines

Rule: "Avoid empty lines inside definitions or proofs."

  • AdditiveNTT.lean Line 1611: Empty line inside evaluationPointω_eq_twiddleFactor_of_div_2 proof.
  • AdditiveNTT.lean Line 1660: Empty line inside eval_point_ω_eq_next_twiddleFactor_comp_qmap proof.
  • AdditiveNTT.lean Line 1818: Empty line inside evenRefinement_eq_novel_poly_of_0_leading_suffix proof.

Syntax and Formatting: Tactic Mode

Rule: "Place by at the end of the line preceding the tactic block. Indent the tactic block."

  • AdditiveNTT.lean Line 244-250: The by for theorem qMap_maps_sDomain is placed on a new line (Line 250) rather than at the end of Line 249.

Syntax and Formatting: Binders & Operators

Rule: "Use a space after binders... Put spaces on both sides of : , := , and infix operators."

  • AdditiveNTT.lean Line 1717: 2^i.val missing spaces around ^.
  • AdditiveNTT.lean Line 55: (n + 1) and 2 ^ (n + 1) are correct, but Line 19: 2 ^ ϑ is correct, yet Line 31: ℓ + R_rate uses spaces while Line 545: 2^(ℓ + R_rate - i.val) lacks them.

Syntax and Formatting: Functions

Rule: "Prefer fun x ↦ ... over λ x, ..." (And by extension, prefer over => for anonymous functions in the project style).

  • AdditiveNTT.lean Line 1303: toFun := fun p => fun k => ... should use .
  • AdditiveNTT.lean Line 1785: fun ⟨j, hj⟩ => by should use if not immediately entering a tactic block.

Documentation Standards

Rule: "Every definition and major theorem should have a docstring."
Approximately 15 major declarations are missing docstrings.

  • AdditiveNTT.lean Line 53: sDomain is missing a docstring.
  • AdditiveNTT.lean Line 77: qMap is missing a docstring.
  • AdditiveNTT.lean Line 1104: intermediateNovelBasisX is missing a docstring.

Variable Conventions

Rule: "m, n, k : Natural numbers; u, v, w : Universes."

  • AdditiveNTT.lean Line 31: and R_rate are used as natural number variables; the guide specifies m, n, k.
  • AdditiveNTT.lean Line 19: ϑ is used as a natural number variable.

📄 **Per-File Summaries**
  • ArkLib.lean: This update expands the library's core exports by adding numerous modules related to the Binary Basefold protocol, specifically focusing on its soundness proofs, execution steps, and underlying relations. It also incorporates new components for Additive NTT field theory, oracle reduction completeness, and simulation utilities.
  • ArkLib/Data/CodingTheory/DivergenceOfSets.lean: This PR refactors proofs in the Pr_uniform_equiv and concentration_bounds theorems to be more explicit and maintainable. It replaces high-level tactic calls like simpa and simp with structured calc blocks and direct applications of congr_arg, without introducing new theorems or sorry placeholders.
  • ArkLib/Data/CodingTheory/Prelims.lean: This update introduces several new theorems—multilinearWeight_succ, multilinearWeight_succ_lower_half, and multilinearWeight_succ_upper_half—that provide a recursive decomposition for multilinear weights based on index bit representation. These lemmas facilitate reasoning about tensor combinations by splitting weights into lower and upper halves of the index range. No sorry or admit placeholders are introduced.
  • ArkLib/Data/CodingTheory/ProximityGap/BCIKS20/AffineSpaces.lean: This PR refactors and simplifies the proof of exists_basepoint_with_large_line_prob_aux by replacing complex simpa calls with more direct simp and exact tactics. No new theorems or definitions are introduced, and the changes do not add any sorry or admit placeholders.
  • ArkLib/Data/CodingTheory/ReedSolomon.lean: This change introduces a Nontrivial instance for ReedSolomon.code, proving that the code contains non-zero elements when the evaluation set is nonempty and the degree bound is positive. The proof explicitly constructs a non-zero codeword using the constant code of one and contains no sorry placeholders.
  • ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean: This file implements the FRI-Binius variant of the Additive NTT algorithm, providing formal definitions for intermediate evaluation domains, quotient maps, and subspace vanishing polynomials. It introduces the additiveNTT encoding algorithm and its core butterfly stage, accompanied by a complete formal proof of correctness (additiveNTT_correctness). No sorry or admit placeholders are present in the implementation.
  • ArkLib/Data/Fin/BigOperators.lean: This file introduces new definitions and theorems for reindexing, splitting, and merging vectors and matrices, headlined by a general proof for the determinant of a $2 \times 2$ block matrix with commuting sub-blocks.
  • ArkLib/Data/Fin/Sigma.lean: This update completes the proofs for embedSum_splitSum, splitSum_embedSum, and dflatten_splitSum by removing existing sorry placeholders. It also introduces the new theorem splitSum_embedSum_fst to characterize the index component of a split sum.
  • ArkLib/Data/Misc/Basic.lean: This update introduces new lemmas concerning function η-expansion and the interaction between type casting and function domains. Specifically, the added theorems facilitate reasoning about function equality and simplify casted functions into functions with casted arguments, with no sorry placeholders introduced.
  • ArkLib/Data/Probability/Instances.lean: This file introduces several new probability theorems and lemmas, including the union bound (Pr_or_le), product rules for independent repetitions (prob_pow_of_forall_finFun), and specialized Schwartz-Zippel bounds for univariate polynomials of degree one and two. The changes also include minor proof refactorings and new aliases for existing lemmas. No sorry or admit placeholders were introduced.
  • ArkLib/OracleReduction/Basic.lean: This update introduces the mkVerifierOStmtOut definition and supporting lemmas to modularize the routing of output oracle statements within verifiers. It also adds utility functions and theorems for constructing and reasoning about transcripts in single-round protocols, with no sorry placeholders introduced.
  • ArkLib/OracleReduction/Cast.lean: This file introduces generalized casting definitions for OracleReduction and OracleVerifier and proves theorems showing that security properties, such as completeness and round-by-round knowledge soundness, are preserved under these type transformations.
  • ArkLib/OracleReduction/Completeness.lean: This file introduces a library of reusable theorems and utility lemmas for proving the perfect completeness and round-by-round knowledge soundness of interactive oracle reductions. It provides a generic "unrolling" framework for $n$-message protocols alongside specialized versions for common interaction patterns (0, 1, and 2-message exchanges) and automation for simplifying probabilistic soundness goals. All proofs are complete, and no sorry or admit placeholders are introduced.
  • ArkLib/OracleReduction/Execution.lean: This change refactors the OracleVerifier.run definition to use a helper function and successfully replaces multiple sorry placeholders with complete proofs. These proofs establish key equivalences between oracle-based reductions and their non-oracle counterparts, as well as the correctness of identity reductions.
  • ArkLib/OracleReduction/OracleInterface.lean: This PR introduces the theorems neverFails_simOracle and neverFails_simOracle2 to prove that simulation oracles based on deterministic transcript lookups are guaranteed to never fail.
  • ArkLib/OracleReduction/Security/RoundByRound.lean: This update introduces rbrKnowledgeSoundness_of_eq_error theorems for both Verifier and OracleVerifier to facilitate transferring round-by-round knowledge soundness properties between pointwise equal error functions. The file also contains an existing sorry placeholder in the incomplete proof for rbrKnowledgeSoundnessOneShot_implies_rbrKnowledgeSoundness.
  • ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean: This change refactors the Binary Basefold protocol's formalization by introducing more precise indexing logic, including OracleFrontierIndex and mappings between oracle positions and domain indices. It introduces several new definitions and theorems that rigorously link successful polynomial extraction (extractMLP) to unique decoding radius (UDR) closeness and protocol compliance. Additionally, it refactors sumcheck polynomial projection properties and removes several older, incomplete definitions, effectively eliminating previous sorry placeholders in favor of more granular proofs.
  • ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean: This file defines the Reed-Solomon codes used in the Binary Basefold protocol and establishes their core properties, such as distance calculations and criteria for unique decoding radius (UDR) closeness. It introduces theorems proving that the protocol's folding operations preserve code membership and that "fiberwise" closeness implies Hamming closeness to the code. The implementation also provides a computational method to extract unique codewords using the Berlekamp-Welch decoder and contains no sorry or admit placeholders.
  • ArkLib/ProofSystem/Binius/BinaryBasefold/Compliance.lean: This file defines protocol-level proximity, compliance, and "bad-event" predicates for the Binary Basefold protocol, which are essential for its soundness proof. It introduces several new definitions, including isCompliant and foldingBadEvent, and provides proofs for properties like fold-error containment and the consistency of incremental bad events. The file contains no sorry or admit placeholders.
  • ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean: This update refactors the Binary Basefold prelude to introduce recursive matrix-based folding structures, specifically the butterflyMatrix and foldMatrix, and generalized iterated_fold operations. It introduces new theorems and proofs connecting point-wise folding to matrix-vector multiplication (Lemma 4.9) and polynomial evaluation structure (Lemma 4.14). Note that the theorem iterated_fold_transitivity currently contains a sorry placeholder.
  • ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean: This refactor migrates the query phase to the OracleAwareReductionLogicStep framework, replacing standalone helper definitions with a structured reduction logic. It introduces several new definitions and theorems to formally establish the strong completeness and round-by-round knowledge soundness of the protocol, successfully removing previous placeholders.
  • ArkLib/ProofSystem/Binius/BinaryBasefold/ReductionLogic.lean: This file formalizes the interactive reduction logic for the individual steps of the Binary Basefold protocol, specifically covering the folding round, the commitment round, and the final sum-check. It introduces new structures for modularly defining protocol steps—ReductionLogicStep and OracleAwareReductionLogicStep—and provides complete proofs for the strong completeness of each step without the use of sorry placeholders.
  • ArkLib/ProofSystem/Binius/BinaryBasefold/Relations.lean: This file introduces new formal definitions and theorems defining the protocol relations and security predicates for the Binary Basefold proof system. It establishes core invariants for folding consistency, sumcheck targets, and "bad-event" logic used in the security analysis of the protocol. The changes include several lemmas proving the preservation of these relations across protocol steps, and the file contains no sorry placeholders.
  • ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness.lean: This new file serves as the primary entry point for the Binary Basefold soundness proof, re-exporting various submodules that establish the folding and distance lemmas required for the protocol. It introduces the probability_bound_badSumcheckEventProp lemma, which provides a Schwartz-Zippel-based probability bound for the event where two distinct degree-≤2 polynomials agree at a uniform verifier challenge. The file contains no sorry placeholders.
  • ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/BadBlocks.lean: This file introduces definitions and theorems for "bad block" bookkeeping used in the terminal query-phase soundness analysis of the Binary Basefold protocol. It defines predicates to identify blocks failing folding-compliance, provides lemmas to localize these failures via the highest bad block, and includes a probability helper for uniform suffix challenges.
  • ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/FoldDistance.lean: This new file establishes lemmas and theorems for distance and disagreement transfer from fiber views to folded codewords, which are essential for the soundness analysis of the Binius protocol. It introduces several helper lemmas relating fiber agreement to fold agreement and culminates in a formalization of Lemma 4.25 from [DP24], providing folded-distance lower bounds used in bad-block analysis. All proofs in this file are complete with no sorry or admit placeholders.
  • ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/Incremental.lean: This file introduces new definitions and theorems to formalize the incremental bad-event analysis for the Binary Basefold soundness proof, specifically establishing Proposition 4.21.2. It implements an even/odd splitting technique to bridge Binius folding with affine line proximity gaps and provides a complete formalization of the incremental step for both fiberwise close and far cases. The file contains no sorry or admit placeholders.
  • ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/Lift.lean: This file introduces the lifting and tensor-expansion infrastructure for the Binary Basefold soundness proof, providing definitions for preTensorCombine and lift_interleavedCodeword. It formalizes key results such as the fiberwise disagreement isomorphism and the interleaved-distance lower bound (Lemma 4.22). All new theorems and proofs are complete, containing no sorry or admit placeholders.
  • ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/Proposition4_21.lean: This file formalizes Proposition 4.21 of the Binius protocol, providing a probability bound for the "bad folding event" during a protocol step. It introduces new lemmas for the fiberwise-close case using the Schwartz-Zippel lemma and the fiberwise-far case using tensor product proximity gap results, culminating in the complete proof of the proposition. No sorry or admit placeholders are present in the code.
  • ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/QueryPhasePrelims.lean: This file introduces new definitions and lemmas to establish the foundational infrastructure for the query phase soundness proof of the Binary Basefold protocol. It provides both monadic and logical implementations of the proximity checking logic alongside alignment lemmas for challenge decomposition and oracle folding consistency. No sorry or admit placeholders are included.
  • ArkLib/ProofSystem/Binius/BinaryBasefold/Soundness/QueryPhaseSoundness.lean: This new file formalizes the Query Phase soundness for the Binary Basefold protocol, introducing key theorems that establish probability bounds for the proximity check. It specifically implements Lemma 4.26 and Proposition 4.24 from Diamond and Posen (2024), proving that disagreement on terminal suffixes leads to query rejection and providing the final soundness error bound for a single repetition. The proofs in this file are complete and contain no sorry or admit placeholders.
  • ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean: This module expands the Binary Basefold protocol specification by adding a comprehensive set of OracleInterface, SampleableType, Fintype, and Inhabited instances for various protocol messages and challenges. It refactors several protocol-level definitions using the @[reducible] attribute and introduces a new lemma for oracle statement equality, without adding any sorry placeholders.
  • ArkLib/OracleReduction/Security/Basic.lean: This Lean file introduces two new theorems, soundness_error_mono and knowledgeSoundness_error_mono, which establish that the soundness and knowledge soundness properties of a verifier are monotonic with respect to their error bounds. These proofs ensure that a verifier satisfying a specific error bound also satisfies any larger bound, and no sorry or admit placeholders were added.
  • ArkLib/ProofSystem/Binius/BinaryBasefold/General.lean: This update establishes a concrete scalar knowledge soundness bound for the Binary Basefold protocol, aligning the formalization with the error terms presented in the DP24 paper. It introduces new theorems, including fullOracleVerifier_knowledgeSoundness, and refines the perfect completeness proof by employing stricter relations and requiring non-failing initializations. No sorry or admit placeholders were added.
  • ArkLib/ProofSystem/Binius/BinaryBasefold/Steps.lean: This refactor reorganizes the Binary Basefold protocol steps by moving their monolithic implementation into a new modular subdirectory structure. The logic for the Fold, Commit, Relay, and Final Sumcheck steps has been relocated to separate files, simplifying this file into a central collection of imports.
  • ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean: This update formally completes the Binary Basefold core interaction phase by sequentially composing individual protocol steps into blocks and proving their aggregate security properties. It introduces new definitions and lemmas for block-level verifiers and reductions, replaces previous sorry placeholders with full proofs for perfect completeness and knowledge soundness, and derives a rigorous bound for the aggregate knowledge error.

Last updated: 2026-04-06 12:53 UTC.

@chung-thai-nguyen chung-thai-nguyen force-pushed the completeness-of-binius branch 2 times, most recently from 9edd9d8 to 6de2e83 Compare March 4, 2026 15:57
@chung-thai-nguyen chung-thai-nguyen marked this pull request as ready for review March 6, 2026 12:39
@alexanderlhicks
Copy link
Copy Markdown
Collaborator

/review

External:
https://eprint.iacr.org/2024/504.pdf
https://eprint.iacr.org/2023/1784.pdf

Internal:
ArkLib/Data/CodingTheory/
ArkLib/Data/Polynomial

Comments:
Please review for correctness with respect to ArkLib internals and the external reference papers.

@github-actions
Copy link
Copy Markdown

github-actions bot commented Mar 6, 2026

🤖 AI Review (with external context)

🤖 AI Review

Overall Summary:
As the Lead Synthesis Engineer, I have reviewed the comprehensive reports generated by the specialized AI agents. Below is the Executive Summary of the Pull Request.

1. TL;DR

The PR effectively establishes the architectural framework for the probabilistic monadic oracle reductions and mathematically solidifies key aspects of the Binius protocol, such as the block-matrix determinants and additive NTT domain mappings. However, the presence of widespread incomplete proofs (sorry), several critical compilation failures (including type mismatches and missing variables), a mathematically vacuous completeness predicate, and multiple Lean 4 anti-patterns prevent this PR from being merged in its current state.

2. Checklist Coverage

  • Additive NTT Domains and Quotient Maps [⚠️]: Mostly sound where verified (AdditiveNTT.lean). However, a hardcoded degree-2 assumption currently limits the intended generalization to arbitrary $\mathbb{F}_q$.
  • Novel Polynomial Basis and Evaluation Splitting [✅]: Successfully generalized and safely verified with strict index bound arithmetic in Prelude.lean.
  • Fiber-wise Disagreement Sets and Distance Bounds [❌]: The SoundnessTools section was deleted entirely from BinaryBasefold/Prelude.lean in this diff, inadvertently gutting the definitions necessary for the Proximity Gap and Soundness invariants.
  • Matrix-Vector Representation of Iterated Folding [✅]: Accurately formulated. Distributes mathematically over tensor products without issue.
  • Determinant of $2 \times 2$ Block Matrices [✅]: Rigorously implemented using characteristic polynomial perturbation, safely and beautifully avoiding base-ring pollution.
  • Unique Decoding Radius (UDR) and Codeword Extraction [⚠️]: UDR bounds accurately avoid integer division ambiguity, but usage is currently hampered by the deleted SoundnessTools module.
  • Perfect Completeness of Monadic Oracle Reductions [❌]: Structurally implemented well by threading the NeverFails condition (hInit) across unrolled monadic blocks. However, a major mathematical flaw exists in the formulation of the simulation predicate, rendering the completeness guarantee vacuous (see below).

3. Critical Misformalizations

  • Vacuous "Never Fails" Condition: In BinaryBasefold/ReductionLogic.lean, the definition IsStronglyCompleteUnderSimulation attempts to verify safety by asserting Pr[⊥ | OptionT.mk ...] = 0. This is mathematically vacuous (the probability of False is always 0 for any computation) and technically misaligned with the monad stack. You must evaluate (· = none) on the fully executed ProbComp base oracle to formally guarantee the computation does not fail.
  • Deleted Protocol Security Definitions: The SoundnessTools section was stripped from BinaryBasefold/Prelude.lean, removing crucial definitions like fiberwiseDisagreementSet and uniqueClosestCodeword required to prove the soundness of the Binary Basefold protocol.
  • Pervasive Compilation Errors & Type Mismatches:
    • Domain Type Mismatches: BinaryBasefold/Code.lean contains severe type mismatches attempting to mix Fin r, Fin (ℓ + 1), Set, Finset, and , along with invalid position arguments passed to iterated_fold.
    • Unknown Identifiers / Copy-Paste Artifacts: BatchingPhase.lean fails to compile because show blocks reference 𝔽q, β, and pSpecFold copied from FoldPhase, which don't exist in the batching context. It also wrongly uses pSpecFold instead of pSpecBatching for index checks. BinaryBasefold/General.lean references undefined relations (strictRoundRelation, strictFinalSumcheckRelOut) and passes hInit to functions that do not accept it.
    • Unresolvable HEq Substitutions: In OracleReduction/Cast.lean, subst_vars fails compilation because it strictly requires Eq and ignores the HEq hypotheses mapping the relations.
  • Wrong Theorem Statements: OracleReduction.runWithLog_eq_runWithLog_reduction (Execution.lean) asserts equivalence over .run instead of .runWithLog, rendering the lemma statement factually incorrect relative to its name.

4. Key Lean 4 / Mathlib Issues

  • Unfinished Proofs (sorry / admit) (18 files): This is a hard-rule violation. There are over 50 instances of sorry or commented-out proofs spread across the PR (most notably 20+ in BinaryBasefold/Spec.lean, 11 in RingSwitching/Spec.lean, and heavily affecting Simulation.lean, Code.lean, and Component-level files).
  • Simp Loops (2 files): In Fin/BigOperators.lean and ToVCVio/Lemmas.lean, you have tagged symmetric lemmas (where the LHS and RHS are exact opposites) with @[simp]. This guarantees infinite simp loops. You must remove @[simp] from the expanding/undesired direction.
  • Invalid / Problematic simp Lemmas (2 files): OracleReduction/Basic.lean defines @[simp] lemmas with variables on the LHS that are not bound, meaning they will silently fail to apply. BinaryBasefold/Spec.lean uses HEq inside @[simp] lemmas conditioned on an equality premise, which the simplifier cannot effectively resolve.
  • Abusive Tactics & Profiler Overrides (2 files): BinaryBasefold/Prelude.lean uses the debugging stop tactic mid-proof, which bypasses kernel verification for the remainder of the block. QueryPhase.lean hardcodes set_option maxHeartbeats 400000, a code smell indicating that the monadic simp/erw state manipulations need proper optimization rather than global limit overrides.
  • Incomplete Tactic Branches (1 file): In BinaryBasefold/ReductionLogic.lean, split_ifs generates 4 subgoals for the embed function, but the proof only supplies 2 bullets (·), failing to handle the contradictory cross-cases. Additionally, a goal is left unclosed because dsimp is used instead of trivial or exact.
  • Brittle Code Duplication (2 files): SumcheckPhase.lean duplicates roughly 75 lines of fragile monadic unrolling conv/simp scripts between the iterated and final sumcheck reductions. This should be abstracted into a generic theorem on ReductionLogicStep. ToVCVio/Lemmas.lean contains literal duplicate lemma definitions.

5. Overall Verdict

Changes Requested

(Note: The hard rule requires any PR containing sorry or admit to be rejected. Please complete all proofs, fix the compilation errors/type mismatches, and reformulate the vacuous safety condition before requesting re-review.)


📄 **Review for `ArkLib.lean`**

Verdict: Approved

Checklist Verification:

  • Additive NTT Domains and Quotient Maps [Critical]: ⚠️ Cannot determine. The diff only contains import statements for the top-level ArkLib.lean file. The actual definitions (likely in ArkLib.Data.FieldTheory.AdditiveNTT.AdditiveNTT) are not included in the diff.
  • Novel Polynomial Basis and Evaluation Splitting Identity [Major]: ⚠️ Cannot determine. The implementation files are not present in the diff.
  • Fiber-wise Disagreement Sets and Distance Bounds [Critical]: ⚠️ Cannot determine. The implementation files (likely ArkLib.ProofSystem.Binius.BinaryBasefold.Code) are not present in the diff.
  • Matrix-Vector Representation of Iterated Folding [Major]: ⚠️ Cannot determine. The implementation files are not present in the diff.
  • Determinant of $2 \times 2$ Block Matrices [Minor]: ⚠️ Cannot determine. The implementation files are not present in the diff.
  • Unique Decoding Radius (UDR) and Codeword Extraction [Critical]: ⚠️ Cannot determine. The implementation files are not present in the diff.
  • Perfect Completeness of Monadic Oracle Reductions [Major]: ⚠️ Cannot determine. The implementation files (likely ArkLib.OracleReduction.Completeness and ArkLib.ProofSystem.Binius.BinaryBasefold.ReductionLogic) are not present in the diff.

Critical Misformalizations:
None

Lean 4 / Mathlib Issues:
None

Nitpicks:
None

📄 **Review for `ArkLib/Data/CodingTheory/Prelims.lean`**

Verdict: Needs Minor Revisions

Checklist Verification:

  • Matrix-Vector Representation of Iterated Folding: ⚠️ The PR adds fundamental recursive lemmas for the tensor product weights of the folding challenges (multilinearWeight_succ, multilinearWeight_succ_lower_half, multilinearWeight_succ_upper_half). While these correctly reflect the mathematical splitting of the tensor product over bit halves, they only lay the foundation; the actual matrix-vector distribution checks are not fully realized in this diff alone.

Critical Misformalizations:
None. The statements of the upper/lower half recursive formulations for the multilinear weights correctly correspond to standard tensor product splitting across boolean hypercubes.

Lean 4 / Mathlib Best Practices:
None.

Nitpicks:

  • let vs have for proofs: In both multilinearWeight_succ_lower_half and multilinearWeight_succ_upper_half, you use let to bind a proof to a local identifier (e.g., let i_mod_2_pow_n : i.val % (2 ^ n) = i.val := by ...). While this compiles, it is unidiomatic. In Lean, let is meant for binding data/definitions (which preserves their evaluation body in the context), whereas have is used for propositions/proofs.
    Recommendation: Change these to have i_mod_2_pow_n : i.val % (2 ^ n) = i.val := by ...
  • Redundant by exact: In multilinearWeight_succ_lower_half, ⟨i.val, by exact h_lt⟩ can be simplified directly to ⟨i.val, h_lt⟩.
  • Extraneous parentheses: (if i.val.testBit (ϑ) then (r (Fin.last ϑ)) else (1 - r (Fin.last ϑ))) contains several pairs of redundant parentheses around terms like ϑ and the then/else branches.
📄 **Review for `ArkLib/Data/CodingTheory/ReedSolomon.lean`**

Verdict: Approved

Checklist Verification:

  • Additive NTT Domains and Quotient Maps [Critical]: ⚠️ Not applicable to this diff.
  • Novel Polynomial Basis and Evaluation Splitting Identity [Major]: ⚠️ Not applicable to this diff.
  • Fiber-wise Disagreement Sets and Distance Bounds [Critical]: ⚠️ Not applicable to this diff.
  • Matrix-Vector Representation of Iterated Folding [Major]: ⚠️ Not applicable to this diff.
  • Determinant of $2 \times 2$ Block Matrices [Minor]: ⚠️ Not applicable to this diff.
  • Unique Decoding Radius (UDR) and Codeword Extraction [Critical]: ⚠️ Not applicable to this diff.
  • Perfect Completeness of Monadic Oracle Reductions [Major]: ⚠️ Not applicable to this diff.

Critical Misformalizations:
None

Lean 4 / Mathlib Issues:
None

Nitpicks:

  • Naming: Providing an explicit name like instNontrivial to instances is usually unnecessary in Lean 4. Simply writing instance {F ι : Type*} ... : Nontrivial ... is standard Mathlib style, unless you specifically need to refer to the instance by name later.
  • Typeclass Assumptions: The [Field F] assumption is technically a bit stronger than strictly necessary. Because ReedSolomon.code is defined over a [Semiring F] and constantCode_mem_code only requires a semiring, you could weaken [Field F] to [Semiring F] + [Nontrivial F]. However, keeping Field F is totally acceptable here if you only work with Reed-Solomon codes over fields in practice.
  • Proof Golfing: Your proof is highly explicit and easy to read. If you ever wanted to compress it, you could write it as a single term:
    instance {F ι : Type*} {n : ℕ} [Semiring F] [Nontrivial F] [Fintype ι] {α : ι ↪ F}
      [NeZero n] [Nonempty ι] : Nontrivial (ReedSolomon.code α n) :=
      ⟨⟨0, ⟨constantCode 1 ι, constantCode_mem_code⟩, by
        intro h; apply one_ne_zero (α := F)
        exact constantCode_eq_ofNat_zero_iff.mp (Subtype.ext_iff.mp h)⟩⟩
📄 **Review for `ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean`**

Verdict: Changes Requested

Checklist Verification:

  • Additive NTT Domains and Quotient Maps

    • ✅ Verify that the evaluation domains $S^{(i)}$ are correctly formalized as $\mathbb{F}_q$-linear subspaces of the extension field. (Defined correctly as Subspace 𝔽q L).
    • ⚠️ Check the definition of the quotient map $q^{(i)}(X)$. Ensure its scaling factor and roots properly generalize the characteristic-2 specific formula. The definition qMap correctly generalizes to arbitrary $\mathbb{F}_q$. However, the subsequent lemma natDegree_qMap explicitly hardcodes the degree to 2 using the global assumption [hF₂ : Fact (Fintype.card 𝔽q = 2)]. This limits the theoretical generalization from propagating through the proofs.
    • ✅ Confirm that the algebraic mapping $q^{(i)}(S^{(i)}) = S^{(i+1)}$ rigorously proves surjectivity and correctly identifies the 1-dimensional kernel. (Proven rigorously in qMap_maps_sDomain).
  • Novel Polynomial Basis and Evaluation Splitting Identity

    • ✅ Examine the identity $P^{(i)}(X) = P_0^{(i+1)}(q^{(i)}(X)) + X \cdot P_1^{(i+1)}(q^{(i)}(X))$. Check that the degree bounds for the even and odd refinements are strictly bounded by $2^{\ell-i-1}$. (Proven in evaluation_poly_split_identity, and bounds are enforced by the Fin domain of the sums).
    • ✅ Verify that the index arithmetic linking the coefficients does not overflow or underflow the bounds.
    • ✅ Ensure the algebraic coercion where $X$ is multiplied by the composed polynomial is mathematically well-typed over the polynomial ring $L[X]$.
  • Other Checklist Items:

    • ⚠️ Items pertaining to "Fiber-wise Disagreement Sets", "Matrix-Vector Representation", "Determinant", "UDR", and "Monadic Oracle Reductions" are outside the scope of the AdditiveNTT.lean diff and reside in other files.

Critical Misformalizations:
None. The mathematics are sound and correctly formalized within the constraints of the binary field assumption.

Lean 4 / Mathlib Issues:

  1. Deprecated Typeclass: The use of IsLinearMap (e.g., in qMap_is_linear_map and intermediateNormVpoly_eval_is_linear_map) is a deprecated anti-pattern in Lean 4 / Mathlib. You should use bundled linear maps (L →ₗ[𝔽q] L) instead of unbundled properties.
  2. Dead Code: Nat.boundedRecOn is defined but never used anywhere in the file.
  3. Misuse of Tactic: In 𝔽q_element_eq_zero_or_eq_one, the omega tactic is used to close the goal c = 0 when c : 𝔽q. While this might accidentally close the goal by falling back to assumption, omega is designed for Nat and Int arithmetic, not arbitrary fields. Use exact hc instead.

Nitpicks:

  1. Naming Conventions: The file mixes camelCase and snake_case inconsistently. Standard Lean 4 convention dictates camelCase for definitions (qMap, sDomain) and snake_case for theorems/lemmas (q_map_comp_normalized_w).
  2. Empty simp only: There are several instances of simp only with no arguments. While valid (it performs beta/zeta reduction), using dsimp only or simp is generally preferred for readability if no specific lemmas are being provided.
📄 **Review for `ArkLib/Data/Fin/BigOperators.lean`**

Verdict: Changes Requested

Checklist Verification:

  • Additive NTT Domains and Quotient Maps: Not applicable to this file. (⚠️)
  • Novel Polynomial Basis and Evaluation Splitting Identity: Not applicable to this file. (⚠️)
  • Fiber-wise Disagreement Sets and Distance Bounds: Not applicable to this file. (⚠️)
  • Matrix-Vector Representation of Iterated Folding: Not applicable to this file. (⚠️)
  • Determinant of $2 \times 2$ Block Matrices:
    • [✅] Review the theorem asserting $\det \begin{pmatrix} A & B \ C & D \end{pmatrix} = \det(AD - BC)$ when $C$ and $D$ commute.
    • [✅] Check for hidden assumptions: if the proof relies on $D$ being invertible, it is insufficiently general. If it relies on a formal polynomial perturbation like $D + X \cdot I$ to force non-zero divisors, ensure the base ring transitions from $R$ to $R[X]$ and the subsequent evaluation at $X=0$ are rigorously justified. (The proof rigorously uses $D(X) = D + X \cdot I$, maps matrix computations using the characteristic polynomial matrix to Polynomial R, and safely evaluates back down to $R$ using evalRingHom 0. This avoids assuming invertibility beautifully and correctly).
    • [⚠️] Confirm that the commutativity of the specific blocks generated by the protocol (e.g., scalar multiples of the identity matrix) is explicitly proven. (This file only introduces the generic theorem; the specific application and commutativity proofs will need to be verified in the files where this is used).
  • Unique Decoding Radius (UDR) and Codeword Extraction: Not applicable to this file. (⚠️)
  • Perfect Completeness of Monadic Oracle Reductions: Not applicable to this file. (⚠️)

Critical Misformalizations:
None. The mathematical translation, particularly the characteristic polynomial perturbation for the block determinant, is excellently done and circumvents standard domain-limitation pitfalls without introducing hidden assumptions.

Lean 4 / Mathlib Issues:

  • Simp Loop (Critical): You have tagged both Matrix.reindex_mul_eq_prod_of_reindex and Matrix.reindex_mul_reindex with @[simp]. Since their LHS and RHS are exact opposites of each other, this creates a classic infinite simp loop whenever simp encounters either expression. You must remove the @[simp] tag from at least one of them (typically, the one that expands the expression or runs contrary to your preferred normal form).
  • Unused Typeclasses: Fin.reindex currently demands [Fintype n] and [Fintype m], but these assumptions are completely unused in the body v ∘ e.symm. This creates dummy implicit arguments that force the typeclass synthesizer to do unnecessary work, and unnecessarily restricts the definition from being used on infinite types. You should drop them:
    @[simp]
    def Fin.reindex {R n m : Type*} (e : n ≃ m) (v : n → R) : m → R := v ∘ e.symm

Nitpicks:

  • Fin.reindex has nothing to do with Fin and applies to generic domain rewriting over any types n and m. While the name is slightly misleading (it acts more like a domain-only version of Equiv.arrowCongr), it's harmless if limited to this scope.
  • In Matrix.reindex_vecMul, the assignment (eₘ := id e.symm) is unidiomatic. You can safely drop the id and just write (eₘ := e.symm).
  • In lemmas like Matrix.reindex_mulVec and Matrix.reindex_mulVec_reindex, you have unneeded elaboration directives like (e := by exact e_m) and (e_n). These can be cleaned up to simply (e := e_m) and e_n.
📄 **Review for `ArkLib/Data/Misc/Basic.lean`**

Verdict: Approved

Checklist Verification:

  • Additive NTT Domains and Quotient Maps [Critical]: ⚠️ Not applicable to this file.
  • Novel Polynomial Basis and Evaluation Splitting Identity [Major]: ⚠️ Not applicable to this file.
  • Fiber-wise Disagreement Sets and Distance Bounds [Critical]: ⚠️ Not applicable to this file.
  • Matrix-Vector Representation of Iterated Folding [Major]: ⚠️ Not applicable to this file.
  • Determinant of $2 \times 2$ Block Matrices [Minor]: ⚠️ Not applicable to this file.
  • Unique Decoding Radius (UDR) and Codeword Extraction [Critical]: ⚠️ Not applicable to this file.
  • Perfect Completeness of Monadic Oracle Reductions [Major]: ⚠️ Not applicable to this file.

Critical Misformalizations:
None

Lean 4 / Mathlib Issues:
None

Nitpicks:

  • Sort vs Type: In fun_eta_expansion, you could use Sort _ (or Sort*) instead of Type* for maximum generality (allowing it to apply to functions involving Prop), although Type* is perfectly sufficient for your downstream use cases.
  • Explicit Universes: In cast_fun_eq_fun_cast_arg, the explicit universe annotations .{u, v} and Type u / Type v are valid but slightly unidiomatic for Lean 4. You can typically just write {A B C : Sort*} and let the elaborator unify the universes required for h : A = B.
📄 **Review for `ArkLib/OracleReduction/Basic.lean`**

Verdict: Changes Requested

Checklist Verification:

  • Additive NTT Domains and Quotient Maps: ⚠️ N/A
  • Novel Polynomial Basis and Evaluation Splitting Identity: ⚠️ N/A
  • Fiber-wise Disagreement Sets and Distance Bounds: ⚠️ N/A
  • Matrix-Vector Representation of Iterated Folding: ⚠️ N/A
  • Determinant of $2 \times 2$ Block Matrices: ⚠️ N/A
  • Unique Decoding Radius (UDR) and Codeword Extraction: ⚠️ N/A
  • Perfect Completeness of Monadic Oracle Reductions: ✅ The refactoring of toVerifier cleanly extracts the output oracle statement routing into a separate pure function (mkVerifierOStmtOut), maintaining determinism and preserving the probability support correctly.

Critical Misformalizations:
None

Lean 4 / Mathlib Issues:

  1. Invalid @[simp] lemmas due to unbound variables:
    The lemmas mkVerifierOStmtOut_inl and mkVerifierOStmtOut_inr are tagged with @[simp], but the variable j does not appear in the left-hand side pattern (mkVerifierOStmtOut embed hEq oStmt transcript i). In Lean 4, a simp lemma must bind all its variables in the LHS pattern. Otherwise, the simplifier cannot guess the value of j and the lemma will silently fail to apply. You should remove the @[simp] attribute from these lemmas.

  2. Using simpa for data casts in a def:
    In mkVerifierOStmtOut, you construct the return value of type OStmtOut i (a Type, not a Prop) using by simpa only [hEq, h] using .... Using tactics like simp or simpa to generate proofs for data casts is a known Lean 4 antipattern. It builds bloated Eq.mpr terms that rely on the simplifier's internal behavior, which often leads to slow typechecking and fragile definitional equalities. It is strongly preferred to use cast with a simple rewrite sequence.

Here is the suggested idiomatic refactoring for mkVerifierOStmtOut:

def mkVerifierOStmtOut
    (embed : ιₛₒ ↪ ιₛᵢ ⊕ pSpec.MessageIdx)
    (hEq : ∀ i, OStmtOut i = match embed i with
      | Sum.inl j => OStmtIn j
      | Sum.inr j => pSpec.Message j)
    (oStmt : ∀ i, OStmtIn i) (transcript : FullTranscript pSpec) :
    ∀ i, OStmtOut i :=
  fun i => match h : embed i with
    | Sum.inl j => cast (by rw [hEq, h]) (oStmt j)
    | Sum.inr j => cast (by rw [hEq, h]) (transcript j)

If you make this change, you should adjust the right-hand sides of your lemmas to use cast (by rw [hEq, h]) ... accordingly. The proofs of the lemmas will then become trivial (by simp [mkVerifierOStmtOut, h]).

Nitpicks:
None

📄 **Review for `ArkLib/OracleReduction/Cast.lean`**

Verdict: Changes Requested

Checklist Verification:

  • ⚠️ Additive NTT Domains and Quotient Maps
  • ⚠️ Novel Polynomial Basis and Evaluation Splitting Identity
  • ⚠️ Fiber-wise Disagreement Sets and Distance Bounds
  • ⚠️ Matrix-Vector Representation of Iterated Folding
  • ⚠️ Determinant of $2 \times 2$ Block Matrices
  • ⚠️ Unique Decoding Radius (UDR) and Codeword Extraction
  • ⚠️ Perfect Completeness of Monadic Oracle Reductions

Explanation: All items are marked ⚠️ because this file (ArkLib/OracleReduction/Cast.lean) strictly handles structural type-casting for OracleReduction and OracleVerifier. It does not contain the mathematical algorithms, codes, or domain definitions requested by the checklist.


Critical Misformalizations:
None. The logic behind mapping the structures across equivalent types is conceptually correct.


Lean 4 / Mathlib Issues:

  1. subst_vars Does Not Support HEq (Compilation Failure)
    In castInOut_perfectCompleteness, castInOut_completeness, and OracleVerifier.castInOut_rbrKnowledgeSoundness, the proofs rely entirely on subst_vars:
  subst_vars
  exact hPC

The subst_vars tactic only resolves standard homogeneous equalities (Eq). It will ignore your HEq hypotheses (h_ostmtIn, h_relIn, h_relOut, h_Oₛᵢ). Because these variables are not unified, the expected types will not match, and exact hPC will fail with a type mismatch error.

Fix: You must manually substitute the index equalities to align the types, then convert the HEqs into Eqs so they can be substituted.

  -- Unify the index types first
  subst h_idxIn h_idxOut
  -- Now that index types are unified, HEq becomes Eq
  simp only [heq_iff_eq] at h_ostmtIn h_ostmtOut h_Oₛᵢ h_relIn h_relOut
  -- Substitute everything else
  subst h_stmtIn h_stmtOut h_witIn h_witOut h_ostmtIn h_ostmtOut h_Oₛᵢ h_relIn h_relOut
  exact hPC
  1. Fragile cast usage in Hypothesis Types
    In castOutSimple_perfectCompleteness, castOutSimple_completeness, and castOutSimple_rbrKnowledgeSoundness, the output relation equality is defined using an inline tactic block:
    (h_rel : relOut₁ = cast (by subst_vars; rfl) relOut₂)

This is unidiomatic and fragile. When subst_vars processes the other variables in the proof, it will not automatically reduce the cast term, leaving you with relOut₁ = cast rfl relOut₂ which prevents immediate unification.

Fix: Use HEq just as you did beautifully in castInOut_perfectCompleteness.

    (h_rel : HEq relOut₁ relOut₂)

And in the proof:

    subst h_stmt h_ostmt h_wit
    simp only [heq_iff_eq] at h_rel
    subst h_rel
    exact hPC

Nitpicks:

  1. Unused Typeclasses:
    In the declarations for castOutSimple and its associated theorems (for both OracleReduction and OracleVerifier), you include instances for the output statements:
    [∀ i, OracleInterface (OStmtOut₁ i)] [∀ i, OracleInterface (OStmtOut₂ i)]

Looking at the OracleVerifier and OracleReduction structures, they only require OracleInterface constraints on OStmtIn and Message. The OStmtOut interfaces are completely unused in these functions. Removing them will clean up the signatures.

📄 **Review for `ArkLib/OracleReduction/Completeness.lean`**

Verdict: Approved

Checklist Verification:

  • Perfect Completeness of Monadic Oracle Reductions [Major]:
    • Analyze the lifting of the pure deterministic protocol logic into the probabilistic stateful monadic framework: The theorems in this file (e.g., unroll_n_message_reduction_perfectCompleteness) correctly establish the equivalence between the monadic execution of OracleReduction.perfectCompleteness and the unrolled step-by-step logic, successfully isolating the pure logic via simulateQ.
    • Ensure that the 'NeverFails' condition correctly propagates: Handled flawlessly. The condition hInit : NeverFail init is provided as a hypothesis and correctly propagated into the monadic binds (e.g., via probFailure_simulateQ_iff_stateful_run'_mk).
    • Verify the support preservation properties: Handled beautifully via the hImplSupp assumption (Prod.fst <$> ((QueryImpl.mapQuery impl q).run s).support = (liftQuery q).support). This perfectly asserts that the implementation precisely preserves the support of the ideal specification.

(Note: The other checklist items correspond to other mathematical primitives like Additive NTT, Binius foldings, and Berlekamp-Welch. They are not present/modified in the diff of ArkLib/OracleReduction/Completeness.lean and thus omitted from this specific file review.)

Critical Misformalizations:
None

Lean 4 / Mathlib Issues:
None

Nitpicks:

  • Unused logical helpers: At the top of ArkLib/OracleReduction/Completeness.lean, you define forall_eq_bind_pure_iff and forall_eq_lift_mem_2. Besides having somewhat misleading names (they don't contain bind or pure or lift), they are completely unused in the file's proofs. They can be safely deleted to reduce clutter.
  • Type vs Type u: The file binds variables using variable {ι : Type} {σ : Type}. This restricts the framework to Type 0. While this is consistent with other files in the OracleReduction module (which also hardcode ι : Type), it's generally a better Mathlib idiom to leave these universe polymorphic (Type*) unless there is a specific restriction enforcing Type 0.
  • Duplicated proof script block: In the proof of unroll_n_message_reduction_perfectCompleteness, the intro β q s ... liftM_map] using hq block used to discharge hImplSupp for the challengeQueryImpl is repeated exactly twice across consecutive conv_lhs calls. You could potentially pull this out into a local have lemma to DRY up the proof script.
📄 **Review for `ArkLib/OracleReduction/Execution.lean`**

Verdict: Changes Requested

Checklist Verification:

  • Perfect Completeness of Monadic Oracle Reductions / Lifting deterministic logic: The diff successfully removes the sorrys in OracleVerifier.run by correctly utilizing OracleVerifier.mkVerifierOStmtOut to lift the deterministic extraction of oracle statements into the OptionT monadic context.

Critical Misformalizations:
None.

Lean 4 / Mathlib Issues:

  • Copy-Paste Error in Theorem Statement: The theorem OracleReduction.runWithLog_eq_runWithLog_reduction proves the wrong statement. The statement is identical to the preceding run_eq_run_reduction theorem (it compares .run instead of .runWithLog). The diff updates the proof to close the goal (by just reusing the .run proof), but the lemma itself is factually asserting the wrong equivalence.

    Fix: Update the statement to actually apply runWithLog on both sides (and ensure the simp proof still correctly resolves it):

    @[simp]
    theorem OracleReduction.runWithLog_eq_runWithLog_reduction [∀ i, OracleInterface (pSpec.Message i)]
        {stmt : StmtIn} {oStmt : ∀ i, OStmtIn i} {wit : WitIn}
        {oracleReduction : OracleReduction oSpec StmtIn OStmtIn WitIn StmtOut OStmtOut WitOut pSpec} :
          oracleReduction.runWithLog stmt oStmt wit =
            oracleReduction.toReduction.runWithLog ⟨stmt, oStmt⟩ wit := by
      simp [OracleReduction.runWithLog, Reduction.runWithLog, OracleReduction.toReduction, OracleVerifier.run,
        Verifier.run, OracleVerifier.toVerifier, liftComp]

Nitpicks:

  • Dead Code: You have commented out -- exact fst_map_simulateQ_loggingOracle_run _ in runWithLogToRound_discard_log_eq_runToRound and runWithLog_discard_log_eq_run. If the simp tactic now successfully closes the goal on its own, it is best practice to completely delete the commented-out lines to keep the source tree clean.
📄 **Review for `ArkLib/OracleReduction/OracleInterface.lean`**

Verdict: Approved

Checklist Verification:

  • Additive NTT Domains and Quotient Maps: ⚠️ Not present in this diff.
  • Novel Polynomial Basis and Evaluation Splitting Identity: ⚠️ Not present in this diff.
  • Fiber-wise Disagreement Sets and Distance Bounds: ⚠️ Not present in this diff.
  • Matrix-Vector Representation of Iterated Folding: ⚠️ Not present in this diff.
  • Determinant of $2 \times 2$ Block Matrices: ⚠️ Not present in this diff.
  • Unique Decoding Radius (UDR) and Codeword Extraction: ⚠️ Not present in this diff.
  • Perfect Completeness of Monadic Oracle Reductions:
    • Analyze the lifting of the pure deterministic protocol logic into the probabilistic stateful monadic framework: ✅ Addressed. The new lemmas correctly reason about the deterministic lookup evaluation of simOracle and simOracle2.
    • Ensure that the 'NeverFails' condition correctly propagates: ✅ Addressed. neverFails_simOracle and neverFails_simOracle2 rigorously establish that evaluation into the PMF guarantees zero failure probability.
    • Verify the support preservation properties: ⚠️ Not addressed in this particular diff (but no regressions were introduced).

Critical Misformalizations:
None. The theorem statements for neverFails_simOracle and neverFails_simOracle2 are mathematically sound. Applying HasEvalPMF.probFailure_eq_zero accurately reflects that well-formed PMF evaluations do not inherently fail.

Lean 4 / Mathlib Issues:
None. The typeclass constraints ([oSpec.Fintype], [oSpec.Inhabited], and [∀ i, OracleInterface ...]) properly instantiate the context needed by VCVio's HasEvalPMF. The proof scripts are appropriately idiomatic and make good use of unification via _.

Nitpicks:
None. Variables follow typical standard naming (camelCase parameters, proper implicit usage) and the universe bindings match the rest of the file correctly.

📄 **Review for `ArkLib/OracleReduction/Security/RoundByRound.lean`**

Verdict: Approved

Checklist Verification:

  • Additive NTT Domains and Quotient Maps ⚠️ (Not determinable from this diff)
  • Novel Polynomial Basis and Evaluation Splitting Identity ⚠️ (Not determinable from this diff)
  • Fiber-wise Disagreement Sets and Distance Bounds ⚠️ (Not determinable from this diff)
  • Matrix-Vector Representation of Iterated Folding ⚠️ (Not determinable from this diff)
  • Determinant of $2 \times 2$ Block Matrices ⚠️ (Not determinable from this diff)
  • Unique Decoding Radius (UDR) and Codeword Extraction ⚠️ (Not determinable from this diff)
  • Perfect Completeness of Monadic Oracle Reductions
    • Analyze the lifting of the pure deterministic protocol logic into the probabilistic stateful monadic framework: The changes successfully repair the structural analysis of support when OptionT wraps simulateQ stateful executions.
    • ⚠️ Ensure that the 'NeverFails' condition correctly propagates: (Not determinable from this diff).
    • Verify the support preservation properties: The modified proofs accurately break down the support of the composite monadic bind and OptionT.mk operations using OptionT.mem_support_iff and mem_support_bind_iff.

Critical Misformalizations:
None

Lean 4 / Mathlib Issues:
None

Nitpicks:
None

📄 **Review for `ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean`**

Verdict: Changes Requested

Checklist Verification:

  • Additive NTT Domains and Quotient Maps [Critical]: ⚠️ Not applicable to this diff.
  • Novel Polynomial Basis and Evaluation Splitting Identity [Major]: ⚠️ Not applicable to this diff.
  • Fiber-wise Disagreement Sets and Distance Bounds [Critical]: ⚠️ Not applicable to this diff.
  • Matrix-Vector Representation of Iterated Folding [Major]: ⚠️ Not applicable to this diff.
  • Determinant of $2 \times 2$ Block Matrices [Minor]: ⚠️ Not applicable to this diff.
  • Unique Decoding Radius (UDR) and Codeword Extraction [Critical]: ⚠️ Not applicable to this diff.
  • Perfect Completeness of Monadic Oracle Reductions [Major]: ⚠️ Not applicable to this diff.

Critical Misformalizations:
None found in the mathematical definitions themselves.

Lean 4 / Mathlib Issues:

  • Unfinished Proofs (sorry): There are multiple instances of sorry introduced in this diff. A PR containing sorry cannot be approved.
    lemma projectToNextSumcheckPoly_eval_eq ... := by sorry
    lemma projectToNextSumcheckPoly_sum_eq ... := by sorry
    lemma projectToMidSumcheckPoly_succ ... := by sorry
    lemma projectToMidSumcheckPoly_eq_prod ... := by sorry
    lemma fixFirstVariablesOfMQP_full_eval_eq_eval ... := by sorry
    lemma getMidCodewords_succ ... := by sorry
    lemma oracleWitnessConsistency_relay_preserved ... := by sorry

Nitpicks:

  • Boolean Flags in Propositions: In oracleFoldingConsistencyProp, you use (includeFinalFiberwiseClose : Bool) to conditionally add fiberwiseClose to the Prop via if includeFinalFiberwiseClose then ... else True. It is highly unidiomatic to use Boolean flags to toggle the structure of a Prop. It forces unnecessary split_ifs and evaluation tracking during proofs. Instead, either define two distinct propositions (e.g., oracleFoldingConsistencyProp and oracleFoldingConsistencyProp_withFinal), or factor out the final condition so it can be conjoined explicitly where needed.
  • Use of cast in Theorem Statements: In OracleStatement.oracle_eval_congr, the hypothesis uses (h_x : x = cast (by rw [h_j]) x'). While this works, using cast in equality statements can make rewrites frustrating (due to dependent type mismatches). A common idiom to avoid this is to substitute h_j in the environment first, or use HEq x x', though your current proof subst h_j; simp only [cast_eq] at h_x; subst h_x; rfl resolves it nicely on the creation side.
📄 **Review for `ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean`**

Verdict: Changes Requested

Checklist Verification:

  • Additive NTT Domains and Quotient Maps ⚠️ Not strictly defined in this file (relies on sDomain from AdditiveNTT), but their usages align correctly with the mathematical spec.
  • Novel Polynomial Basis and Evaluation Splitting Identity ⚠️ Implemented in Prelude.lean / AdditiveNTT.lean, not in this diff.
  • Fiber-wise Disagreement Sets and Distance BoundsfiberwiseDisagreementSet accurately reflects the preimage condition. Bounding scaling factors correctly use $2^{\text{steps}}$ taking advantage of the [CharP L 2] scope.
  • Matrix-Vector Representation of Iterated Folding ⚠️ Not present in this diff.
  • Determinant of $2 \times 2$ Block Matrices ⚠️ Not present in this diff.
  • Unique Decoding Radius (UDR) and Codeword ExtractionUDRClose properly verifies distance $&lt; \frac{d}{2}$ by checking 2 * Δ₀ < d, gracefully avoiding integer division ambiguity. extractUDRCodeword correctly instantiates Berlekamp-Welch with degree $k = 2^{\ell - i}$ and distance $e$.
  • Perfect Completeness of Monadic Oracle Reductions ⚠️ Handled elsewhere.

Critical Misformalizations:
None identified mathematically, but the code suffers from pervasive structural type errors (detailed below) that render the mathematical claims currently un-compilable.

Lean 4 / Mathlib Issues:

  • Unfinished Proofs (Hard Rule): The file introduces two sorry flags which must be completed:
    1. constFunc_UDRClose
    2. UDRCodeword_constFunc_eq_self
  • Type Mismatch (Fin r vs Fin (ℓ + 1)): In Prelude.lean, OracleFunction is defined as abbrev OracleFunction (i : Fin (ℓ + 1)). Throughout Code.lean (e.g., in disagreementSet, fiberwiseDisagreementSet, fiberwiseClose), it is applied to i : Fin r. Since these are distinct types, this causes a strict type mismatch.
  • Type Mismatch (Set vs Finset): disagreementSet and fiberwiseDisagreementSet declare their return types as Finset (...). However, their bodies use the set-builder notation {y | ...}, which evaluates to a Set. In standard Mathlib, you must construct a Finset explicitly, e.g.:
    Finset.univ.filter (fun y => ∃ x, ...)
  • Type Mismatch ( vs Fin (ℓ + 1)): In multiple definitions (isCompliant, fold_error_containment, foldingBadEvent), iterated_fold is called passing (steps := steps) where steps : ℕ. However, iterated_fold is defined in Prelude.lean to expect steps : Fin (ℓ + 1). You need to package it as ⟨steps, ...⟩.
  • Invalid Addition (Fin r + ): In fiberwiseDistance, isCompliant, fold_error_containment, and foldingBadEvent, the hypothesis h_destIdx : destIdx = i + steps attempts to add i : Fin r and steps : ℕ. Mathlib does not provide a standard HAdd for this. It should be stated over the values: h_destIdx : destIdx.val = i.val + steps.
  • Invalid Positional Arguments: In iterated_fold_preserves_BBF_Code_membership, h_destIdx and h_destIdx_le are passed positionally to iterated_fold. However, iterated_fold in Prelude.lean expects a single bounding proof h_i_add_steps : i.val + steps < ℓ + 𝓡.

Nitpicks:

  • Mixed Type Inequalities: The hypothesis h_destIdx_le : destIdx ≤ ℓ attempts to compare destIdx : Fin r with ℓ : ℕ. It is safer and more idiomatic to write destIdx.val ≤ ℓ.
  • Redundant Coercions: In UDRClose_iff_within_UDR_radius, there's an unnecessary in ↑(BBF_Code 𝔽q β ...) since BBF_Code returns a Submodule which already coerces cleanly to Set in most contexts.
  • Custom Notations: In extractUDRCodeword, the syntax p ∈ L[X]_k is used. If this is a locally defined notation for degreeLT L k, it's fine, but ensuring standard p ∈ Polynomial.degreeLT L k helps maintain uniformity with the rest of the file.
📄 **Review for `ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean`**

Verdict: Changes Requested

Checklist Verification:

  • Additive NTT Domains and Quotient Maps [Critical]: ⚠️ Not part of this diff.
  • Novel Polynomial Basis and Evaluation Splitting Identity [Major]: ⚠️ Not part of this diff.
  • Fiber-wise Disagreement Sets and Distance Bounds [Critical]: ⚠️ Not part of this diff.
  • Matrix-Vector Representation of Iterated Folding [Major]: ⚠️ Not part of this diff.
  • Determinant of $2 \times 2$ Block Matrices [Minor]: ⚠️ Not part of this diff.
  • Unique Decoding Radius (UDR) and Codeword Extraction [Critical]: ⚠️ Not part of this diff.
  • Perfect Completeness of Monadic Oracle Reductions [Major]: ✅ The changes successfully thread the (hInit : NeverFail init) assumption through the block reductions and their sequential compositions (e.g., foldRelayOracleReduction_perfectCompleteness, foldCommitOracleReduction_perfectCompleteness, nonLastSingleBlockOracleReduction_perfectCompleteness). This rigorously satisfies the checklist requirement to propagate the infallible execution constraint across the F-IOR monadic composition layer.

Critical Misformalizations:
None

Lean 4 / Mathlib Issues:

  • Unfinished Proofs (sorry): The theorem sumcheckFoldOracleVerifier_rbrKnowledgeSoundness still terminates with a sorry. While this sorry was pre-existing in the file, its signature is actively modified in this diff. Per the strict review guidelines, any PR containing sorry or admit MUST receive a "Changes Requested" verdict.

Nitpicks:

  • Pi-type Typeclass Syntax: In the perfectCompleteness theorems, you use explicit dependent function arrows for typeclass constraints, e.g.:

    [(i : pSpecFold.ChallengeIdx) → Fintype ((pSpecFold (L := L)).Challenge i)]

    While Lean 4's parser accepts this and elaborates it identically to , the universally established Mathlib convention is to use the symbol directly for quantified instance assumptions:

    [∀ i : pSpecFold.ChallengeIdx, Fintype ((pSpecFold (L := L)).Challenge i)]

    Consider updating these across the file to match the standard idiomatic style.

  • Trivial Fin Equality: The lemma fin_zero_mul_eq is proven using ext and simp:

    lemma fin_zero_mul_eq (h : 0 * ϑ < ℓ + 1) : (⟨0 * ϑ, h⟩ : Fin (ℓ + 1)) = 0 := by
      ext; simp only [zero_mul, Fin.coe_ofNat_eq_mod, Nat.zero_mod]

    Because 0 * ϑ evaluates to 0 and (0 : Fin (ℓ + 1)) is definitionally ⟨0 % (ℓ + 1), _⟩ (which definitionally simplifies to ⟨0, _⟩), this lemma can likely be closed by definitional equality:

    lemma fin_zero_mul_eq (h : 0 * ϑ < ℓ + 1) : (⟨0 * ϑ, h⟩ : Fin (ℓ + 1)) = 0 := rfl
📄 **Review for `ArkLib/ProofSystem/Binius/BinaryBasefold/General.lean`**

Verdict: Changes Requested

Checklist Verification:

  • Additive NTT Domains and Quotient Maps: ⚠️ Not present in this diff.
  • Novel Polynomial Basis and Evaluation Splitting Identity: ⚠️ Not present in this diff.
  • Fiber-wise Disagreement Sets and Distance Bounds: ⚠️ Not present in this diff.
  • Matrix-Vector Representation of Iterated Folding: ⚠️ Not present in this diff.
  • Determinant of $2 \times 2$ Block Matrices: ⚠️ Not present in this diff.
  • Unique Decoding Radius (UDR) and Codeword Extraction: ⚠️ Not present in this diff.
  • Perfect Completeness of Monadic Oracle Reductions: ✅ The diff correctly propagates the NeverFail init condition through fullOracleReduction_perfectCompleteness and transitions the completeness relations to their strict counterparts (strictRoundRelation and strictFinalSumcheckRelOut) to ensure exact support preservation. However, it references missing arguments and identifiers (detailed below).

Critical Misformalizations:
None.

Lean 4 / Mathlib Issues:

  • Unknown Arguments: In fullOracleReduction_perfectCompleteness, the diff adds (hInit := hInit) to the invocations of CoreInteraction.coreInteractionOracleReduction_perfectCompleteness and QueryPhase.queryOracleProof_perfectCompleteness. However, based on the provided global context for CoreInteractionPhase.lean and QueryPhase.lean, neither of these theorems currently accepts an hInit argument in their signatures. This will cause an unknown argument 'hInit' compilation error unless those upstream files are also updated in this PR.
  • Undefined Identifiers: The relations strictRoundRelation and strictFinalSumcheckRelOut are introduced in fullOracleReduction_perfectCompleteness but are not defined in the Basic.lean context. This will cause an unknown identifier error. Ensure these strict relations are properly formalized and exported in Basic.lean.

Nitpicks:

  • Dangling Parentheses: In fullOracleVerifier_rbrKnowledgeSoundness, the line break for rel₂ leaves a dangling parenthesis on its own line. Consider closing it on the same line for cleaner formatting:
        (rel₂ := finalSumcheckRelOut 𝔽q β (ϑ:=ϑ) (h_ℓ_add_R_rate := h_ℓ_add_R_rate))
📄 **Review for `ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean`**

Verdict: Changes Requested

Checklist Verification:

  • Additive NTT Domains and Quotient Maps [⚠️] Not modified or introduced in this specific diff.
  • Novel Polynomial Basis and Evaluation Splitting Identity [✅] The diff successfully implements and generalizes polynomial evaluation using the basis refinement polynomials in fold_advances_evaluation_poly. Index bounds are safely verified with the auxiliary index_bound_check.
  • Fiber-wise Disagreement Sets and Distance Bounds [❌] The entire SoundnessTools section, including fiberwiseDisagreementSet and fiberwiseDistance, has been abruptly removed from Prelude.lean in this diff.
  • Matrix-Vector Representation of Iterated Folding [✅] challengeTensorExpansionMatrix and blockDiagMatrix correctly construct the $2^{n+1} \times 2^{n+1}$ matrix from $2^n \times 2^n$ sub-blocks. butterflyMatrix cleanly assigns the coordinate structure for $z_0, z_1$. Matrix distribution over tensor products is proven mathematically via challengeTensorExpansion_decompose_succ and blockDiagMatrix_mulVec_F₂_eq_Fin_merge_PO2.
  • Determinant of $2 \times 2$ Block Matrices [✅] butterflyMatrix_det_ne_zero uses Matrix.det_from4Blocks_of_squareSubblocks_commute securely without any leaky polynomial base ring transitions. Commutativity of the scalar identity blocks is proven seamlessly.
  • Unique Decoding Radius (UDR) and Codeword Extraction [❌] Definitions related to UDR bounds, Berlekamp-Welch extraction (uniqueClosestCodeword), and distance bounds were deleted entirely along with the SoundnessTools section.
  • Perfect Completeness of Monadic Oracle Reductions [⚠️] Not applicable to this Prelude.lean diff.

Critical Misformalizations:

  • Missing Protocol Definitions: The deletion of the SoundnessTools section fundamentally guts the definitions required to state and prove the Proximity Gap and Soundness invariants of Binary Basefold (e.g., fiberwiseDisagreementSet, uniqueClosestCodeword, isCompliant, and foldingBadEvent). If these definitions were merely moved to another file, it should be verified in the wider PR context. If they were intentionally stripped, the formalization of the protocol's security is broken.

Lean 4 / Mathlib Issues:

  • Unfinished Proofs (sorry): There are multiple instances of sorry bypassing proof obligations. Under the hard rules of this review, this mandates a "Changes Requested" state.
    • multilinear_eval_eq_sum_bool_hypercube
    • iterated_fold_transitivity
  • Abusive Use of the stop Tactic: In getSumcheckRoundPoly_eval_eq and getSumcheckRoundPoly_sum_eq, the stop tactic is used mid-proof. stop is exclusively a debugging tool that halts elaboration of the file/block. It leaves the proof essentially unverified by the kernel and masks any remaining goal-state errors. It must be completely removed and the proofs finished natively.
      rw [MvPolynomial.eval_eq_eval_mv_eval_finSuccEquivNth (p := 0)]
      simp only [Polynomial.eval_map]
      stop -- REMOVE THIS
      congr
      ext j

Nitpicks:

  • Redundant Variables: You have duplicate/overlapping typeclass instantiations. You introduce variable {L : Type*} and declare [CommRing L] inside challengeTensorExpansion and challengeTensorExpansionMatrix, but right below it you define variable {L : Type} [Field L] [Fintype L] [DecidableEq L] [CharP L 2]. Try to consolidate the universe variable sets to prevent typeclass inference overlaps.
  • Boolean Coercions: In bitsOfIndex, the construct if Nat.testBit k i then 1 else 0 is completely fine, but you could optionally golf this by leveraging Nat.testBit directly with ZMod cast idioms available in Mathlib, which might simplify algebraic rewriting later.
📄 **Review for `ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean`**

An analysis of the pull request reveals that while the structural approach to modeling the F-IOR and proving completeness via monadic simulations is highly aligned with the project's F-IOR blueprint, there are a number of incomplete proofs and performance hacks that need to be addressed before this can be merged.

Verdict: Changes Requested

Checklist Verification:

  • Additive NTT Domains and Quotient Maps: ⚠️ Not directly verified in this diff, though fibers and domain extractions (extractSuffixFromChallenge) are built correctly on top of the quotient map functionality.
  • Novel Polynomial Basis and Evaluation Splitting Identity: ⚠️ The polynomial from novel coefficients is used (polynomialFromNovelCoeffsF₂), but the degree bounds and index arithmetic are not the primary focus of this diff.
  • Fiber-wise Disagreement Sets and Distance Bounds: ⚠️ Not present in this diff.
  • Matrix-Vector Representation of Iterated Folding: ✅ Evaluated via single_point_localized_fold_matrix_form and related lemmas. The logic nicely aligns with the folding matrix definitions.
  • Determinant of $2 \times 2$ Block Matrices: ⚠️ Not present in this diff.
  • Unique Decoding Radius (UDR) and Codeword Extraction: ⚠️ Not present in this diff.
  • Perfect Completeness of Monadic Oracle Reductions: ❌ Addressed in structure, but incomplete. The diff explicitly models the stateful transition of the verifier's proximity testing into a monadic loop using OptionT and forIn, and introduces robust correctness lemmas like checkSingleRepetition_probFailure_eq_zero and queryPhaseLogicStep_isStronglyComplete. However, there are multiple sorry flags in the proofs mapping the stateful execution support to the ideal specification.

Critical Misformalizations:

  • Unfinished Proofs (sorry): The PR contains several sorrys in critical correctness lemmas, breaking the formal verification guarantee. The affected lemmas and properties are:
    • mem_support_queryFiberPoints (in the h_fiber_vec_get equality)
    • query_phase_consistency_guard_safe (in h_point_eq)
    • query_phase_step_preserves_fold (inside the k > 0 and k = 0 cases, extracting basis vectors)
    • queryKnowledgeStateFunction (specifically toFun_full)
    • queryOracleVerifier_rbrKnowledgeSoundness

Lean 4 / Mathlib Issues:

  • Profiler and Heartbeat Bypasses: The file introduces set_option maxHeartbeats 400000 and set_option profiler true at the very top. This is generally a code smell indicating that some proofs (likely the monadic ones involving simp and erw on simulateQ or forIn loops) are extremely slow or encountering bad simp loops. These directives should not be merged into the master branch. Consider optimizing the slow proofs by creating custom simp sets, extracting massive state manipulations into separate localized Props, or using change / show to strictly guide the elaborator.
  • Explicit Universe Variables: The proofs rely heavily on explicitly provided universe variables like OptionT.probFailure_mk_do_bind_eq_zero_iff.{0, 0} and simulateQ.{0, 0, 0}. This is brittle and suggests that Lean's unifier is struggling with the OptionT (OracleComp ...) monad transformer stack. While sometimes unavoidable, try to see if providing explicit type annotations to bind or the variables themselves avoids the need to hard-code the universe levels.

Nitpicks:

  • Commented-Out Code: There are large blocks of commented-out proof steps (e.g., inside checkSingleRepetition_inner_forIn_probFailure_eq_zero and queryOracleProof_perfectCompleteness). Please clean these up before finalizing the PR.
  • Naming Conventions: The lemma k_succ_mul_ϑ_le_ℓ_₂ contains an unidiomatic trailing _₂. A more descriptive name like k_succ_mul_ϑ_add_ϑ_le_ℓ or mul_add_le_of_lt_div would fit Mathlib naming conventions much better.
  • Implicit Argument Design in decomposeChallenge: The definition decomposeChallenge takes {destIdx : Fin r} implicitly but forces it to be i.val + steps via (h_destIdx : destIdx = i.val + steps). It would be cleaner to drop destIdx as an argument entirely and compute it inside the function body signature as let destIdx : Fin r := ⟨i.val + steps, by omega⟩.
📄 **Review for `ArkLib/ProofSystem/Binius/BinaryBasefold/ReductionLogic.lean`**

Verdict: Changes Requested

Checklist Verification:

  • Additive NTT Domains and Quotient Maps: ⚠️ Not directly addressed in this file's scope.
  • Novel Polynomial Basis and Evaluation Splitting Identity: ⚠️ Not directly addressed in this file's scope.
  • Fiber-wise Disagreement Sets and Distance Bounds: ⚠️ Not directly addressed in this file's scope.
  • Matrix-Vector Representation of Iterated Folding: ⚠️ Not directly addressed in this file's scope.
  • Unique Decoding Radius (UDR) and Codeword Extraction: ⚠️ Not directly addressed in this file's scope.
  • Perfect Completeness of Monadic Oracle Reductions [Major]: ❌ Violated. The formalization attempting to lift the "NeverFails" condition into the probabilistic monadic framework in IsStronglyCompleteUnderSimulation is mathematically vacuous and missing necessary types.

Critical Misformalizations:

  1. Vacuous "Never Fails" Condition (IsStronglyCompleteUnderSimulation):
    The definition OracleAwareReductionLogicStep.IsStronglyCompleteUnderSimulation attempts to state that the verifier never fails with:

    Pr[⊥ | OptionT.mk (simulateQ so (step.verifierCheck stmtIn transcript))] = 0

    This is mathematically and typographically broken for several reasons:

    • Vacuous Predicate: As an event passed to Pr, resolves to the bottom element of α → Prop, which is fun _ => False. The probability of False is always 0 for any computation. This statement trivially evaluates to 0 = 0 and provides no completeness/safety guarantees. If you want to assert the computation never fails (i.e., never outputs none), the predicate should be (· = none) or Option.isNone.
    • Monad Mismatch: Pr cannot evaluate an OptionT. You must evaluate the underlying monadic layer using .run. OptionT.mk does the exact opposite of what you need here.
    • Unsimulated Base Oracles: simulateQ so ... evaluates the interactive oracles but leaves you with an OracleComp oSpec .... Pr evaluates ProbComp or PMF. To compute a probability, you must provide a base oracle implementation (like impl : QueryImpl oSpec ProbComp and init : ProbComp σ) to fully run the computation, exactly as it is done in rbrKnowledgeSoundness.

    Recommended Fix:
    Pass impl and init as parameters to the definition and rewrite the condition as:

    Pr[(· = none) | do (simulateQ so (step.verifierCheck stmtIn transcript).run).run' (← init)] = 0
  2. Incomplete Proof via split_ifs:
    In commitStepLogic_embed_inj:

    split_ifs at h_ab_eq with h_ab_eq_l h_ab_eq_r
    · simp only [Sum.inl.injEq, Fin.mk.injEq] at h_ab_eq; apply Fin.eq_of_val_eq; exact h_ab_eq
    · have ha_lt : a < toOutCodewordsCount ℓ ϑ i.succ := by omega
      ...

    The function commitStepLogic_embedFn uses if expressions for both variables a and b. As a result, split_ifs will generate 4 subgoals (True/True, True/False, False/True, False/False). Providing only 2 bullets (·) leaves unsolved goals and will cause a compilation failure. You must handle the contradictory cross-cases (where Sum.inl = Sum.inr) explicitly (e.g., using cases h_ab_eq).

Lean 4 / Mathlib Issues:

  1. Unclosed Goal with dsimp:
    In commitStep_is_logic_complete:
    let h_VCheck_passed : step.verifierCheck stmtIn transcript := by
      dsimp only [commitStepLogic, Prod.mk.eta, step]
    have hStmtOut_eq : proverStmtOut = verifierStmtOut := by
    The dsimp tactic only simplifies the goal (in this case, reducing it to True); it does not close it (unlike simp). You must end the by block with exact trivial or trivial to properly discharge the goal.

Nitpicks:

  1. Universe Polymorphism: The structure definitions (hEq, ReductionLogicStep, and OracleAwareReductionLogicStep) restrict parameter types (ιₒᵢ, ιₒₒ, StmtIn, etc.) to Type (which implicitly means Type 0). While this might conform to current ArkLib internals, best practices in Lean 4 dictate defining generic structures with Type u to allow future universe polymorphism where possible.
  2. Fragile Tactics: Using split_ifs ... with ... on expressions that branch multiple times is fragile. Consider using by_cases sequentially to make the proof structure robust and easier to read.
📄 **Review for `ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean`**

Verdict: Changes Requested

Checklist Verification:

  • ⚠️ Additive NTT Domains and Quotient Maps: Not applicable to the current diff.
  • ⚠️ Novel Polynomial Basis and Evaluation Splitting Identity: Not applicable to the current diff.
  • ⚠️ Fiber-wise Disagreement Sets and Distance Bounds: Not applicable to the current diff.
  • ⚠️ Matrix-Vector Representation of Iterated Folding: Not applicable to the current diff.
  • ⚠️ Determinant of $2 \times 2$ Block Matrices: Not applicable to the current diff.
  • ⚠️ Unique Decoding Radius (UDR) and Codeword Extraction: Not applicable to the current diff.
  • ⚠️ Perfect Completeness of Monadic Oracle Reductions: This diff defines the typeclass instances (Fintype, Inhabited, OracleInterface, SampleableType) required for the monadic oracle reductions to run and be verified. However, since the instances themselves are largely unfinished (sorry), we cannot verify the support preservation or completeness propagation yet.

Critical Misformalizations:
None. The diff consists primarily of structural definitions and typeclass instances.

Lean 4 / Mathlib Issues:

  1. Unfinished Proofs (sorry flags): The diff introduces over 20 sorrys for Fintype and Inhabited instances. Per the hard rule, these must be resolved before the PR can be accepted. Example:

    instance instFintypePSpecQueryMessage :
      [(pSpecQuery 𝔽q β γ_repetitions (h_ℓ_add_R_rate := h_ℓ_add_R_rate)).Message]ₒ.Fintype := by sorry

    Consider using inferInstance if the underlying types already have the corresponding instances, or deriving them using standard combinators.

  2. Problematic Simp Lemma (HEq):

    @[simp]
    lemma instOracleStatementBinaryBasefold_heq_of_fin_eq {i₁ i₂ : Fin (ℓ + 1)} (h : i₁ = i₂) :
        HEq (instOracleStatementBinaryBasefold 𝔽q β (ϑ:=ϑ) (h_ℓ_add_R_rate := h_ℓ_add_R_rate) (i := i₁))
          (instOracleStatementBinaryBasefold 𝔽q β (ϑ:=ϑ) (h_ℓ_add_R_rate := h_ℓ_add_R_rate)
            (i := i₂)) := by subst h; rfl

    Using HEq in @[simp] lemmas with an equality premise is an anti-pattern in Lean 4. The simplifier struggles to use such lemmas effectively because it has to independently prove i₁ = i₂. It's better to remove @[simp] and apply the lemma manually, use subst, or rely on dependent elimination/congruence where appropriate.

Nitpicks:

  1. Naming Conventions: Several instance names contain underscores and inconsistent casing, which violates Lean 4's UpperCamelCase convention for instances.
    • instFintypePSpecFold_AllChallengesinstFintypePSpecFoldAllChallenges
    • instFintypePspecCommit_AllChallengesinstFintypePSpecCommitAllChallenges (note the capital S in Spec)
    • instFintypePspecCommitChallengeinstFintypePSpecCommitChallenge
  2. abbrev vs @[reducible] def: You have added @[reducible] to multiple definitions like pSpecLastBlock, pSpecNonLastBlocks, etc. If these are only abbreviations meant to be freely unfolded by the typeclass resolution and unifier, consider using the abbrev keyword instead, which naturally enforces this behavior and is the idiomatic standard in Lean 4.
📄 **Review for `ArkLib/ProofSystem/Binius/BinaryBasefold/Steps.lean`**

Verdict: Changes Requested

Checklist Verification:

  • Perfect Completeness of Monadic Oracle Reductions [Major]: ✅ The proofs for perfectCompleteness of the fold, commit, relay, and final sumcheck reductions successfully utilize unrolling lemmas (unroll_2_message_reduction_perfectCompleteness_P_to_V, etc.) to lift the deterministic logic properties into the monadic context. They cleanly split the verification into a "Safety" goal (verifying NeverFails and preventing crashes during monadic binds) and a "Correctness" goal (support preservation mapping back to relational checks).
  • Other items ⚠️: Not directly affected by the changes in this specific file or implemented in other dependencies.

Critical Misformalizations:
None found. The strategy used to link the probabilistic protocol semantics with pure deterministic checks via the generic unrolling theorems is sound.

Lean 4 / Mathlib Issues:

  • Unfinished Proofs: There are multiple sorrys introduced, modified, or remaining in this diff. Because of the hard rule against sorry, this PR requires changes.
    • toFun_empty, toFun_next, and toFun_full in commitKState.
    • toFun_empty, toFun_next, and toFun_full in relayKnowledgeStateFunction.
    • toFun_empty, toFun_next, and toFun_full in finalSumcheckKnowledgeStateFunction.
    • The main theorems foldOracleVerifier_rbrKnowledgeSoundness, commitOracleVerifier_rbrKnowledgeSoundness, relayOracleVerifier_rbrKnowledgeSoundness, and finalSumcheckOracleVerifier_rbrKnowledgeSoundness still end with sorry.

Nitpicks:

  • Conciseness: The lemma mem_ite_singleton could be golfed down to be slightly shorter:
    lemma mem_ite_singleton {α : Type*} {c : Prop} [Decidable c] {a b x : α} :
        (x ∈ (if c then {a} else {b} : Set α)) ↔ (x = if c then a else b) := by
      split_ifs <;> simp
  • Simp configuration: Inside your conv blocks for the perfect completeness proofs, you use constructs like simp only [show OptionT.pure ... = pure by rfl]. While this is valid Lean 4 syntax, it's a bit heavy/unidiomatic. Using change within conv or defining a dedicated generic simp lemma for matching the specific OptionT.pure instantiation might clean up the tactic state without inline shows.
📄 **Review for `ArkLib/ProofSystem/Binius/FRIBinius/CoreInteractionPhase.lean`**

Verdict: Changes Requested

Checklist Verification:

  • ⚠️ Additive NTT Domains and Quotient Maps: Not modified in this diff.
  • ⚠️ Novel Polynomial Basis and Evaluation Splitting Identity: Not modified in this diff.
  • ⚠️ Fiber-wise Disagreement Sets and Distance Bounds: Not modified in this diff.
  • ⚠️ Matrix-Vector Representation of Iterated Folding: Not modified in this diff.
  • ⚠️ Determinant of $2 \times 2$ Block Matrices: Not modified in this diff.
  • ⚠️ Unique Decoding Radius (UDR) and Codeword Extraction: Not modified in this diff.
  • Perfect Completeness of Monadic Oracle Reductions: The diff successfully introduces the hInit : NeverFail init hypothesis to sumcheckFoldOracleReduction_perfectCompleteness and coreInteractionOracleReduction_perfectCompleteness, correctly propagating the non-failing requirement for perfect completeness.

Critical Misformalizations:
None found.

Lean 4 / Mathlib Issues:

  • Unfinished Proofs (sorry flag): The diff explicitly introduces a new sorry in finalSumcheckKnowledgeStateFunction for the toFun_empty field. Per the review instructions, any PR containing sorry must be flagged for changes requested.
  toFun_empty := fun stmt witMid => by
    -- sumcheck consistency is trivial since there is no variables left
    sorry

Please complete this proof or use sorry only if temporarily drafting the PR (which would require resolving before final merge).

Nitpicks:
None.

📄 **Review for `ArkLib/ProofSystem/Binius/FRIBinius/General.lean`**

Verdict: Approved

Checklist Verification:

  • Additive NTT Domains and Quotient Maps [Critical]: ⚠️ Not touched in this diff.
  • Novel Polynomial Basis and Evaluation Splitting Identity [Major]: ⚠️ Not touched in this diff.
  • Fiber-wise Disagreement Sets and Distance Bounds [Critical]: ⚠️ Not touched in this diff.
  • Matrix-Vector Representation of Iterated Folding [Major]: ⚠️ Not touched in this diff.
  • Determinant of $2 \times 2$ Block Matrices [Minor]: ⚠️ Not touched in this diff.
  • Unique Decoding Radius (UDR) and Codeword Extraction [Critical]: ⚠️ Not touched in this diff.
  • Perfect Completeness of Monadic Oracle Reductions [Major]: ✅ The diff successfully introduces and propagates the hInit : NeverFail init hypothesis to the completeness theorem fullOracleReduction_perfectCompleteness and its sub-theorems. This ensures the non-failure condition ($\bot$ probability is 0) is rigorously threaded through the monadic state framework.

Critical Misformalizations:
None

Lean 4 / Mathlib Issues:
None

Nitpicks:

  • Missing Type Signatures: Consider adding explicit return types to batchingCoreVerifier and batchingCoreReduction. While Lean 4 is able to infer them from OracleVerifier.append and OracleReduction.append, explicitly stating the type signature for top-level declarations is a best practice that improves readability, speeds up compilation, and guards against unexpected type inference changes if dependencies are modified.
  • Named Arguments Verbosity: Applying named arguments to what were historically explicit positional variables (e.g., (L := L) (K := K) (β := β)) is perfectly valid in Lean 4 and makes it immune to signature reorderings. However, it can make the function calls quite verbose. If these arguments were recently made implicit in their target definitions, this is exactly the right approach; if they remain explicit, standard positional application might keep the code cleaner.
📄 **Review for `ArkLib/ProofSystem/Binius/RingSwitching/BatchingPhase.lean`**

Verdict: Changes Requested

Checklist Verification:

  • Additive NTT Domains and Quotient Maps: ⚠️ Not modified in this diff.
  • Novel Polynomial Basis and Evaluation Splitting Identity: ⚠️ Not modified in this diff.
  • Fiber-wise Disagreement Sets and Distance Bounds: ⚠️ Not modified in this diff.
  • Matrix-Vector Representation of Iterated Folding: ⚠️ Not modified in this diff.
  • Determinant of $2 \times 2$ Block Matrices: ⚠️ Not modified in this diff.
  • Unique Decoding Radius (UDR) and Codeword Extraction: ⚠️ Not modified in this diff.
  • Perfect Completeness of Monadic Oracle Reductions: ✅
    • "Analyze the lifting of the pure deterministic protocol logic into the probabilistic stateful monadic framework": Successfully accomplished via extracting batchingStepLogic (a ReductionLogicStep instance) and routing the monadic prover and verifier through it.
    • "Ensure that the 'NeverFails' condition correctly propagates": Properly integrated via the (hInit : NeverFail init) hypothesis. The proof successfully unrolls the probabilistic execution and proves safety (no none outputs occur on honest execution) by peeling off the monadic layers and solving the resulting deterministic verification goals.
    • "Verify the support preservation properties": Handled successfully in "GOAL 2: CORRECTNESS" via careful application of OptionT.support_run_eq, support_bind, and simulateQ_pure.

Critical Misformalizations:

  • Compilation Error (Unknown Identifiers in show blocks):
    In batchingReduction_perfectCompleteness, there are two copy-pasted simp only [show ... = pure by rfl] blocks (under GOAL 1 and GOAL 2) from FoldPhase.lean that reference variables entirely absent from the BatchingPhase.lean environment (𝔽q, β, ϑ, i.castSucc, pSpecFold). This completely breaks compilation.

    They must be updated to reference the types pertinent to the Batching Phase:

    simp only [show OptionT.pure (m := (OracleComp ([]ₒ + ([aOStmtIn.OStmtIn]ₒ +
      [pSpecBatching (κ:=κ) (L:=L) (K:=K).Message]ₒ)))) = pure by rfl]

Lean 4 / Mathlib Issues:

  • Type Mismatch Hidden by Definitional Equality:
    In batchingReduction_perfectCompleteness, you construct the challenges for the pure logic step and handle the invalid index 0 using pSpecFold instead of pSpecBatching:

            match j with
            | 0 =>
              have hj_ne : (pSpecFold (L := L)).dir 0 ≠ Direction.V_to_P := by
                simp only [ne_eq, reduceCtorEq, not_false_eq_true, Fin.isValue, Matrix.cons_val_zero,
                  Direction.not_P_to_V_eq_V_to_P]
              exfalso
              exact hj_ne hj

    This is a copy-paste artifact. It only type-checks because pSpecFold.dir 0 and pSpecBatching.dir 0 are definitionally equal (both evaluate to Direction.P_to_V). Using pSpecFold here is conceptually wrong. Please change it to pSpecBatching (κ:=κ) (L:=L) (K:=K).

  • Pre-existing sorry flag:
    The theorem batchingOracleVerifier_rbrKnowledgeSoundness contains a sorry. While the diff merely updates its statement to use the renamed batchingOracleVerifier, the presence of a sorry in the file triggers an automatic "Changes Requested" under the PR review rules.

Nitpicks:

  • Naming artifact: In batchingReduction_perfectCompleteness, you name the sampled verifier challenge r_i' (e.g., intro r_i' h_r_i'_mem_query_1_support). Since this is the batching phase, it would be much more readable to name it r_batching to match the protocol specification and the surrounding code.
📄 **Review for `ArkLib/ProofSystem/Binius/RingSwitching/General.lean`**

Verdict: Changes Requested

Checklist Verification:

  • Additive NTT Domains and Quotient Maps: ⚠️ Not directly addressed or modified in this diff.
  • Novel Polynomial Basis and Evaluation Splitting Identity: ⚠️ Not directly addressed or modified in this diff.
  • Fiber-wise Disagreement Sets and Distance Bounds: ⚠️ Not directly addressed or modified in this diff.
  • Matrix-Vector Representation of Iterated Folding: ⚠️ Not directly addressed or modified in this diff.
  • Determinant of $2 \times 2$ Block Matrices: ⚠️ Not directly addressed or modified in this diff.
  • Unique Decoding Radius (UDR) and Codeword Extraction: ⚠️ Not directly addressed or modified in this diff.
  • Perfect Completeness of Monadic Oracle Reductions: ✅ The changes explicitly thread the hInit : NeverFail init hypothesis through the perfectCompleteness proofs (batchingCore_perfectCompleteness, fullOracleReduction_perfectCompleteness). This directly satisfies the checklist requirement to ensure the NeverFails condition correctly propagates through composed oracle reductions.

Critical Misformalizations:
None. The propagation of NeverFail properly establishes the missing condition for monadic perfection completeness without breaking any mathematical assumptions.

Lean 4 / Mathlib Issues:

  • Unfinished Proofs (sorry): The proof for fullOracleVerifier_rbrKnowledgeSoundness still contains sorry (although it is pre-existing and partially touched by the renaming of BatchingPhase.oracleVerifier in this diff). Per the system's hard rule, any PR containing a sorry must be flagged for Changes Requested until all proofs are completed.

Nitpicks:

  • Inconsistent use of Named Arguments: In the definition of batchingCoreVerifier, the argument (𝓑 := 𝓑) is passed explicitly to both BatchingPhase.batchingOracleVerifier and SumcheckPhase.coreInteractionOracleVerifier. However, in the proof of fullOracleVerifier_rbrKnowledgeSoundness, you instantiate V₁ and V₂ without the explicit (𝓑 := 𝓑). Lean can likely infer this from rel₂ being passed, but it is better to remain consistent within the same file.
  • Typeclass Idioms: You are passing hInit : NeverFail init as an explicit variable. If NeverFail was set up as a typeclass (class NeverFail (init : ProbComp σ)), it should be passed as an instance argument [NeverFail init] rather than an explicit hypothesis. If it is merely a standard def, then the current usage is correct.
📄 **Review for `ArkLib/ProofSystem/Binius/RingSwitching/Prelude.lean`**

Verdict: Changes Requested

Checklist Verification:

  • Additive NTT Domains and Quotient Maps [Critical]: ⚠️ Not applicable to this file (pertains to BBF evaluation domain, not ring-switching).
  • Novel Polynomial Basis and Evaluation Splitting Identity [Major]: ⚠️ Not applicable.
  • Fiber-wise Disagreement Sets and Distance Bounds [Critical]: ⚠️ Not applicable.
  • Matrix-Vector Representation of Iterated Folding [Major]: ⚠️ Not applicable.
  • Determinant of $2 \times 2$ Block Matrices [Minor]: ⚠️ Not applicable.
  • Unique Decoding Radius (UDR) and Codeword Extraction [Critical]: ⚠️ Not applicable.
  • Perfect Completeness of Monadic Oracle Reductions [Major]: ⚠️ Not applicable.

Critical Misformalizations:
None. The lemma statements correctly align with the mathematical expectations of the Binius ring-switching protocol. The definitions utilize the correct algebraic bindings (e.g., MvPolynomial.aeval correctly invoked via dot-notation for cross-algebra evaluation, proper basis decomposition alignments) and the statements correctly relate the batching polynomial A_MLE to the low-degree tensor embeddings.

Lean 4 / Mathlib Issues:

  • Unfinished Proofs (sorry): In accordance with the hard rules, this PR requires a "Changes Requested" verdict because three new central lemmas are left completely unproven (sorry).

    • batching_check_correctness
    • compute_A_MLE_eval_eq_final_eq_value
    • batching_target_consistency

    These are non-trivial mathematical identities bridging tensor products (⊗[K]), multi-linear extensions (MLE), and structural basis decompositions. They must be proven for the formalization to be sound.

Nitpicks:
None. The typeclass abstractions are accurate and the implicit/explicit variable capture through the section environment matches Lean 4's idiomatic expectations nicely.

📄 **Review for `ArkLib/ProofSystem/Binius/RingSwitching/Spec.lean`**

Verdict: Changes Requested

Checklist Verification:
All checklist items are marked as ⚠️ because this diff strictly deals with protocol specifications, OracleInterface declarations, and bounding typeclasses (Fintype, Inhabited) for the Ring-Switching component. It does not implement the mathematical algorithms, domain constructions, decoding radius bounds, or proofs of exact support preservation.

  • Additive NTT Domains and Quotient Maps: ⚠️ Not present in this diff.
  • Novel Polynomial Basis and Evaluation Splitting Identity: ⚠️ Not present in this diff.
  • Fiber-wise Disagreement Sets and Distance Bounds: ⚠️ Not present in this diff.
  • Matrix-Vector Representation of Iterated Folding: ⚠️ Not present in this diff.
  • Determinant of $2 \times 2$ Block Matrices: ⚠️ Not present in this diff.
  • Unique Decoding Radius (UDR) and Codeword Extraction: ⚠️ Not present in this diff.
  • Perfect Completeness of Monadic Oracle Reductions: ⚠️ The diff sets up typeclasses needed for the F-IOR monadic framework, but leaves them sorry'd out. No completeness proofs or support analyses are present here.

Critical Misformalizations:
None found mathematically, as this is purely structural setup. However, leaving structural instances sorry'd undermines the entire Oracle Reduction framework downstream.

Lean 4 / Mathlib Issues:

  • sorry flags: There are 11 sorrys introduced in this diff to admit typeclass instances. This is a hard violation. You must synthesize these instances. For many of these, such as instInhabitedPSpecBatchingMessage, if the underlying response types are genuinely Inhabited or Fintype, you should be able to resolve them via infer_instance (or by using the inferInstanceAs tactic), provided the required sub-instances for the types returned by OracleInterface.Response are registered.
    instance instFintypePSpecSumcheckRoundChallenge :
        ([(pSpecSumcheckRound (L:=L)).Challenge]ₒ).Fintype := by
      sorry -- Must be resolved
    If typeclass inference is failing, it usually means Lean cannot see through the indexed type families. You may need to pattern match on the query indices (e.g., | ⟨0, q⟩ => ... | ⟨1, q⟩ => ...) to supply the exact Fintype or Inhabited instances for each round.

Nitpicks:

  • Redundant Parentheses: In instance instInhabitedOracleSpecEmpty : (([]ₒ : OracleSpec PEmpty).Inhabited) where, the outer parentheses around the type are redundant and unidiomatic. It can just be instance instInhabitedOracleSpecEmpty : ([]ₒ : OracleSpec PEmpty).Inhabited where.
  • Module Docstring Alignment: The module docstring mentions that some instances are provided via sorry. While honest, this should be temporary. Once the sorrys are removed, don't forget to update the docstring.
📄 **Review for `ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean`**

Verdict: Changes Requested

Checklist Verification:

  • Additive NTT Domains and Quotient Maps [Critical]: ⚠️ Not modified in this diff.
  • Novel Polynomial Basis and Evaluation Splitting Identity [Major]: ⚠️ Not modified in this diff.
  • Fiber-wise Disagreement Sets and Distance Bounds [Critical]: ⚠️ Not modified in this diff.
  • Matrix-Vector Representation of Iterated Folding [Major]: ⚠️ Not modified in this diff.
  • Determinant of $2 \times 2$ Block Matrices [Minor]: ⚠️ Not modified in this diff.
  • Unique Decoding Radius (UDR) and Codeword Extraction [Critical]: ⚠️ Not modified in this diff.
  • Perfect Completeness of Monadic Oracle Reductions [Major]: ✅ Handled correctly. The NeverFail init hypothesis was appropriately added to propagate the non-failing condition. The monadic support of the execution trace is explicitly verified against the pure logical steps via unroll_1_message_reduction_perfectCompleteness_P_to_V and unroll_2_message_reduction_perfectCompleteness, successfully preserving the support properties.

Critical Misformalizations:
None. The mathematical logic models the sumcheck verification correctly, including the necessary correction to evaluate the sumcheck polynomial over the mapped boolean hypercube h_i.val.eval (𝓑 0) + h_i.val.eval (𝓑 1) instead of the bare field elements 0 and 1.

Lean 4 / Mathlib Issues:

  • Hard Rule Violation (sorry): The file still contains sorry in the proofs for iteratedSumcheckOracleVerifier_rbrKnowledgeSoundness, finalSumcheckOracleVerifier_rbrKnowledgeSoundness, and coreInteraction_rbrKnowledgeSoundness.
  • Abstraction Leak / Brittle Duplication: The ~75 lines of monadic unrolling inside iteratedSumcheckOracleReduction_perfectCompleteness are almost exactly duplicated in finalSumcheckOracleReduction_perfectCompleteness. This includes highly brittle conv, simp, and erw scripts dealing with internal monadic state (simulateQ_bind, support_bind, OptionT.simulateQ_simOracle2_liftM_query_T2, etc.). This repetitive boilerplate violates the purpose of defining a reusable ReductionLogicStep. You should abstract this unrolling into a generic theorem attached to ReductionLogicStep (e.g., ReductionLogicStep.perfectCompleteness) that directly proves OracleReduction.perfectCompleteness given IsStronglyComplete. If a monolithic theorem is too difficult, consider writing a macro or extracting helper lemmas to compress this unwrapping.

Nitpicks:

  • Commented-out code: Both iteratedSumcheckOracleReduction_perfectCompleteness and finalSumcheckOracleReduction_perfectCompleteness contain commented-out simp blocks (e.g., -- simp [bind_pure_comp, ...). These should be removed to keep the source clean.
  • Unidiomatic Sum Simplification: In sumcheckConsistency_at_last_simplifies, the proof manually invokes Finset.sum_eq_single (a := fun _ => 0) and resolves the other branches using exfalso. Since Fin 0 → L is a Unique type (and thus a Subsingleton), this sum can be solved much more cleanly using Mathlib's Fintype.sum_unique.
📄 **Review for `ArkLib/ProofSystem/Component/CheckClaim.lean`**

Verdict: Changes Requested

Checklist Verification:

  • ⚠️ Perfect Completeness of Monadic Oracle Reductions: The diff modifies the proof of reduction_completeness but leaves it entirely unfinished by commenting out the aesop tactic and relying on sorry. Because the proof is missing, it is impossible to verify if the completeness logic holds correctly.
  • All other checklist items are not applicable to the modifications in this specific diff.

Critical Misformalizations:
None.

Lean 4 / Mathlib Issues:

  • Unfinished Proofs: The PR contains an explicit sorry in reduction_completeness. By the hard rule of this repository, any code containing sorry or admit cannot be merged. Please complete the proof or remove/comment out the theorem if it is not yet ready.

Nitpicks:
None.

📄 **Review for `ArkLib/ProofSystem/Component/ReduceClaim.lean`**

Verdict: Changes Requested

Checklist Verification:

  • Additive NTT Domains and Quotient Maps [Critical]: ⚠️ Not applicable to this diff.
  • Novel Polynomial Basis and Evaluation Splitting Identity [Major]: ⚠️ Not applicable to this diff.
  • Fiber-wise Disagreement Sets and Distance Bounds [Critical]: ⚠️ Not applicable to this diff.
  • Matrix-Vector Representation of Iterated Folding [Major]: ⚠️ Not applicable to this diff.
  • Determinant of $2 \times 2$ Block Matrices [Minor]: ⚠️ Not applicable to this diff.
  • Unique Decoding Radius (UDR) and Codeword Extraction [Critical]: ⚠️ Not applicable to this diff.
  • Perfect Completeness of Monadic Oracle Reductions [Major]: ❌ The diff pertains to the perfect completeness of a reduction (reduction_completeness) but leaves the proof unfinished by commenting out the simp tactic and relying on sorry.

Critical Misformalizations:
None

Lean 4 / Mathlib Issues:

  • Unfinished Proofs: The diff comments out the simp tactic used in the proof of reduction_completeness, effectively abandoning the proof and leaving only a sorry. All sorrys must be removed and the proof completed before the PR can be accepted.

Nitpicks:
None

📄 **Review for `ArkLib/ProofSystem/Component/SendWitness.lean`**

Verdict: Changes Requested

Checklist Verification:

  • Additive NTT Domains and Quotient Maps [Critical]: ⚠️ Not applicable to this diff.
  • Novel Polynomial Basis and Evaluation Splitting Identity [Major]: ⚠️ Not applicable to this diff.
  • Fiber-wise Disagreement Sets and Distance Bounds [Critical]: ⚠️ Not applicable to this diff.
  • Matrix-Vector Representation of Iterated Folding [Major]: ⚠️ Not applicable to this diff.
  • Determinant of $2 \times 2$ Block Matrices [Minor]: ⚠️ Not applicable to this diff.
  • Unique Decoding Radius (UDR) and Codeword Extraction [Critical]: ⚠️ Not applicable to this diff.
  • Perfect Completeness of Monadic Oracle Reductions [Major]: ❌ The reduction_completeness theorem, which aims to establish perfect completeness for the SendWitness reduction, has had its partial proof tactics commented out and is now just a sorry. Therefore, completeness is not formally verified.

Critical Misformalizations:
None

Lean 4 / Mathlib Issues:

  • Unfinished Proofs: The diff explicitly leaves a sorry in reduction_completeness (by commenting out the failing simp and aesop tactics). PRs with sorry cannot be approved.

Nitpicks:
None

📄 **Review for `ArkLib/ToVCVio/Lemmas.lean`**

Verdict: Changes Requested

Checklist Verification:

  • ⚠️ Additive NTT Domains and Quotient Maps: Not applicable to this file.
  • ⚠️ Novel Polynomial Basis and Evaluation Splitting Identity: Not applicable to this file.
  • ⚠️ Fiber-wise Disagreement Sets and Distance Bounds: Not applicable to this file.
  • ⚠️ Matrix-Vector Representation of Iterated Folding: Not applicable to this file.
  • ⚠️ Determinant of $2 \times 2$ Block Matrices: Not applicable to this file.
  • ⚠️ Unique Decoding Radius (UDR) and Codeword Extraction: Not applicable to this file.
  • ✅ Perfect Completeness of Monadic Oracle Reductions [Major]: Validated. The lifting logic using OptionT perfectly captures the underlying failure modes, accurately combining probFailure and probOutput none (e.g., via probFailure_simulateQ_liftQuery_eq and OptionT.probFailure_mk). The support decomposition lemmas for nested do blocks (like mem_support_bind_bind_map_iff) are logically sound and successfully map deterministic logic into the SPMF framework.

Critical Misformalizations:
None. The probability mathematics for OptionT and StateT matches standard SPMF semantics and safely bridges deterministic specifications with monadic executions.

Lean 4 / Mathlib Issues:

  • Simp Loop (Major): You have defined two symmetric lemmas, probFailure_simulateQ_liftQuery_eq and probFailure_simulateQ_liftQuery_add_none_eq, and marked both with @[simp]. Because their LHS and RHS are perfectly swapped, this will cause an infinite simp loop whenever either expression is encountered. You must remove the @[simp] attribute from one of them (usually, we want to simplify the complex simulateQ sum into the simpler liftM expression, so probFailure_simulateQ_liftQuery_add_none_eq should be the active @[simp] lemma).
  • Exact Code Duplication: mem_support_bind_bind_map_generic_iff is a literal copy-paste of mem_support_bind_bind_map_iff with f renamed to g. Please remove the duplicate.
  • Near-Exact Code Duplication: probFailure_liftComp and probFailure_liftComp_eq are identical except that the first uses the universe-polymorphic {ι' : Type w} and the second uses the fixed-universe {ι' : Type} (which means Type 0). The fixed-universe version should be deleted.

Nitpicks:

  • Redundant simp Lemmas:
    • mem_support_run_mk_iff and mem_support_run_iff are identical lemmas up to explicitly named implicit variables. Only one is needed.
    • mem_support_simulateQ_liftQuery_some_iff is fully covered by the broader mem_support_simulateQ_liftQuery_iff (which is already @[simp]). As evidenced by your own proof, simp can automatically apply the general version to some x, making the specialized lemma redundant.
    • support_run_eq_iff is unnecessary as a simp lemma because the existing @[simp] lemma support_run will automatically reduce both sides of the equality independently.
  • Opaque simp behavior: In probFailure_liftComp, the proof simp only [HasEvalPMF.probFailure_eq_zero] works entirely because both sides evaluate to 0 (since OracleComp never fails), allowing simp to close 0 = 0 via a "magic" rfl. While mathematically correct, it's slightly confusing for readers.
  • Reinventing the wheel: theorem imp_comm is a fundamental logic theorem already provided by Mathlib (Mathlib.Logic.Basic). Assuming Mathlib is correctly imported, you should avoid redefining core theorems to prevent namespace clutter.
📄 **Review for `ArkLib/ToVCVio/Simulation.lean`**

Verdict: Changes Requested

Checklist Verification:

  • Perfect Completeness of Monadic Oracle Reductions [Major]
    • Analyze the lifting of the pure deterministic protocol logic into the probabilistic stateful monadic framework (e.g., via simulateQ or OptionT): Handled effectively by protocol unrolling lemmas such as simulateQ_liftComp, Prover.run_succ, and Reduction_run_def (though the latter is currently sorried). The abstractions correctly strip away the monadic structure to reason about protocol steps.
    • Ensure that the 'NeverFails' condition correctly propagates through monadic binds and loops: The file provides a solid suite of lemmas establishing this, particularly probOutput_none_bind_eq_zero_iff, probFailure_forIn_eq_zero_of_body_safe, probFailure_forIn_of_relations, and neverFail_vector_mapM.
    • Verify the support preservation properties: the support of the stateful oracle implementation must perfectly match the support of the ideal specification: Precisely captured and utilized in support_simulateQ_run'_eq and support_bind_simulateQ_run'_eq, which require the exact mapping condition hImplSupp to bridge simulated executions to ideal bounds.

Critical Misformalizations:
None. The simulation and probabilistic semantics logic mathematically models the intended oracle reductions and support/safety tracking perfectly.

Lean 4 / Mathlib Issues:

  • Hard Rule Violation: This file contains several sorrys. You must complete these proofs before the mathematical framework can be trusted for verification:
    • Reduction_run_def (Line 550) - Simplification of Reduction.run.
    • OptionT.liftComp_forIn (Line 795) - Lifting OptionT over forIn.
    • OptionT.simulateQ_forIn (Line 810) - Simulating OptionT over forIn.
    • simulateQ_vector_mapM (Line 816) - As noted in the docstring, Vector.mapM evaluates sequentially and is backed by an Array under the hood in Lean 4. You will likely need a custom induction principle via Array.mapM_eq_mapM_toList to bridge this gap.
    • mem_support_vector_mapM (Line 820)
    • OptionT.simulateQ_vector_mapM (Line 857)
    • OptionT.mem_support_vector_mapM (Line 864)

Nitpicks:

  • Overlapping MonadLift Instances: The instances defined in the NestedMonadLiftLemmas block (e.g., instMonadLift_left_right) explicitly unpack the sum type + associated with OracleSpec. While this might resolve typeclass failures in your specific application, declaring raw structural lifts over binary sums globally is prone to instance resolution loops or overlaps if the spec tree becomes deep. Consider hiding these behind a robust SubSpec typeclass resolution tree rather than standalone + instances.
  • <$> on Sets: In support_challengeQueryImpl_run_eq and support_simulateQ_run'_eq, you frequently use Prod.fst <$> support .... While mathematically valid due to Set's Functor instance, it is vastly more idiomatic in Mathlib to use Set.image Prod.fst (support ...) (which avoids burying operations in typeclass lookups for tactic reasoning).

@chung-thai-nguyen chung-thai-nguyen marked this pull request as draft March 22, 2026 08:31
@chung-thai-nguyen chung-thai-nguyen changed the title feat: completeness of Binary Basefold & ring-switching feat: completeness and rbrKnowledge soundness of FRI-Binius Mar 22, 2026
@chung-thai-nguyen chung-thai-nguyen changed the title feat: completeness and rbrKnowledge soundness of FRI-Binius feat: completeness and rbrKnowledgeSoundness of FRI-Binius Mar 22, 2026
@chung-thai-nguyen chung-thai-nguyen changed the title feat: completeness and rbrKnowledgeSoundness of FRI-Binius feat: completeness and rbrKnowledgeSoundness of FRI-Binius protocols Mar 22, 2026
@chung-thai-nguyen chung-thai-nguyen marked this pull request as ready for review March 22, 2026 17:03
@github-actions
Copy link
Copy Markdown

github-actions bot commented Mar 22, 2026

Build Timing Report

  • Commit: 00ed92d
  • Message: Merge 4e8c9ed into a741e5c
  • Ref: completeness-of-binius
  • Comparison baseline: ef4d9ab from the previous successful PR update.
  • Measured on ubuntu-latest with /usr/bin/time -p.
  • Commands: clean build rm -rf .lake/build && lake build; warm rebuild lake build; validation wrapper ./scripts/validate.sh.
Measurement Baseline (s) Current (s) Delta (s) Status
Clean build 959.36 893.08 -66.28 ok
Warm rebuild 6.06 5.66 -0.40 ok
Validation wrapper 4.16 3.89 -0.27 ok

Incremental Rebuild Signal

  • Warm rebuild saved 887.42s vs clean (157.79x faster).

This compares a clean project build against an incremental rebuild in the same CI job; it is a lightweight variability signal, not a full cross-run benchmark.

Slowest Current Clean-Build Files

Showing 20 slowest current targets, with comparison against the selected baseline when available.

Current (s) Baseline (s) Delta (s) Path
99.00 89.00 +10.00 ArkLib/ProofSystem/Fri/Spec/SingleRound.lean
91.00 96.00 -5.00 ArkLib/ProofSystem/Binius/RingSwitching/BatchingPhase.lean
69.00 63.00 +6.00 ArkLib/Data/CodingTheory/BerlekampWelch/Condition.lean
63.00 63.00 +0.00 ArkLib/Data/CodingTheory/Basic.lean
63.00 63.00 +0.00 ArkLib/ProofSystem/BatchedFri/Security.lean
61.00 60.00 +1.00 ArkLib/Data/CodingTheory/JohnsonBound/Lemmas.lean
58.00 58.00 +0.00 ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean
56.00 60.00 -4.00 ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
56.00 66.00 -10.00 ArkLib/Data/CodingTheory/GuruswamiSudan/Basic.lean
56.00 49.00 +7.00 ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
51.00 62.00 -11.00 ArkLib/Data/CodingTheory/ProximityGap/BCIKS20/AffineLines/BWMatrix.lean
50.00 51.00 -1.00 ArkLib/ProofSystem/Fri/Domain.lean
45.00 50.00 -5.00 ArkLib/ProofSystem/Binius/BinaryBasefold/Steps/Fold.lean
44.00 42.00 +2.00 ArkLib/Data/CodingTheory/JohnsonBound/Basic.lean
44.00 53.00 -9.00 ArkLib/OracleReduction/LiftContext/Reduction.lean
43.00 46.00 -3.00 ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean
40.00 43.00 -3.00 ArkLib/OracleReduction/Security/RoundByRound.lean
37.00 37.00 +0.00 ArkLib/ProofSystem/Binius/RingSwitching/Prelude.lean
35.00 47.00 -12.00 ArkLib/Data/CodingTheory/ProximityGap/DG25.lean
35.00 36.00 -1.00 ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean

@chatgpt-codex-connector
Copy link
Copy Markdown

Codex usage limits have been reached for code reviews. Please check with the admins of this repo to increase the limits by adding credits.
Credits must be used to enable repository wide code reviews.

@chung-thai-nguyen chung-thai-nguyen marked this pull request as draft March 31, 2026 14:57
  - add the Binary Basefold paper-version note to the file header
  - remove duplicate references/commented-out code
  - drop the duplicate OptionT.simulateQ_failure' lemma
  - update downstream callers and verify with full lake build
@chung-thai-nguyen chung-thai-nguyen marked this pull request as ready for review April 6, 2026 12:51
@cursor
Copy link
Copy Markdown

cursor bot commented Apr 6, 2026

You have used all of your free Bugbot PR reviews.

To receive reviews on all of your PRs, visit the Cursor dashboard to activate Pro and start your 14-day free trial.

@chatgpt-codex-connector
Copy link
Copy Markdown

Codex usage limits have been reached for code reviews. Please check with the admins of this repo to increase the limits by adding credits.
Credits must be used to enable repository wide code reviews.

@chung-thai-nguyen chung-thai-nguyen marked this pull request as draft April 6, 2026 12:52
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