feat: completeness of Binary Basefold & ring-switching by chung-thai-nguyen · Pull Request #383 · Verified-zkEVM/ArkLib

chung-thai-nguyen · 2026-03-03T11:58:57Z

Newer version of #270, migrated to latest VCV-io APIs.
[x] Lemma 4.9 & Lemma 4.13 of FRI-Binius (BinaryBasefold/Prelude.lean)
[x] Completeness 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] Perfect completeness for Binary Basefold & ring-switching (+ some loose index refactoring to avoid type checking burden on Fin type)
[x] Reintroduce AdditiveNTT.lean with index changes, will be migrated to CompPoly later
[x] Depend on the latest VCV-io OptionT API: Verified-zkEVM/VCV-io@84822d6

RBR KS relations are not fully correct now but it will be handled in the next PR.
Built with the help of Codex, Claude, Cursor, Gemini.
It's better to run your own review bot to get a reliable summary.

github-actions · 2026-03-03T12:00:49Z

🤖 Gemini PR Summary

Advances the formalization of Binary Basefold and Ring-Switching protocols, focusing on perfect completeness and the underlying oracle reduction infrastructure.

Mathematical Formalization

FRI-Binius Lemmas: Formalizes Lemma 4.9 and Lemma 4.13 from the FRI-Binius paper.
Additive NTT: Reintroduces AdditiveNTT.lean with index refactors, including correctness proofs for butterfly stages.
Coding Theory: Establishes recursive decomposition properties for multilinearWeight, proves nontriviality of Reed-Solomon codes, and defines matrix-vector representations for iterated folding and unique decoding radius properties.
Linear Algebra: Provides a general proof for the determinant of $2 \times 2$ block matrices with commuting sub-blocks and utilities for splitting vectors and matrices.

Infrastructure and Monadic Tooling

Monad-to-Logic Bridge: Introduces ToVCVio tools to translate monadic protocol executions (OptionT, StateT) into logical support relations, facilitating the unrolling of $n$-message structures.
Oracle Reduction Casting: Implements generalized casting for OracleReduction and OracleVerifier in OracleReduction/Cast.lean, allowing type transformations across index sets or field extensions while maintaining completeness and round-by-round knowledge soundness (RBRKS) compatibility.
Verification Automation: Refactors OracleVerifier.run and introduces simulation oracle lemmas to automate reasoning about deterministic transcript lookups.
API Integration: Migrates to the latest VCV-io OptionT API.

Refactoring

Modular Reduction Logic: Refactors Binius interaction phases (Folding, Batching, Sumcheck) into modular ReductionLogicStep instances, separating prover/verifier kernels from monadic plumbing.
Protocol Specification: Updates Binary Basefold and Ring-Switching to use stricter relation definitions and explicit basis parameters (𝓑).
Index Refactoring: Performs refactoring on Fin type indices to reduce type-checking overhead.

Proof Status and Known Gaps

Completed Proofs: Removes sorry placeholders in perfect completeness theorems for the Ring-Switching batching phase and the Binary Basefold sumcheck fold reduction.
⚠️ WARNING (Incomplete Proofs): Significant sorry and admit placeholders remain:
- Knowledge Soundness: RBRKS theorems for most protocol phases are incomplete.
- Instance Stubs: Many Fintype, Inhabited, and OracleInterface instances for protocol challenges remain stubbed.
- Core Components: reduction_completeness proofs for ReduceClaim, SendWitness, and the QueryPhase are unfinished.
- Logic Bridge: Several lemmas in Simulation.lean involving Vector.mapM and reduction unrolling are currently placeholders.

Statistics

Metric	Count
📝 Files Changed	35
✅ Lines Added	17697
❌ Lines Removed	2311

Lean Declarations

✏️ **Removed:** 27 declaration(s)

lemma firstOracleWitnessConsistencyProp_relay_preserved (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
abbrev MultilinearPoly (L : Type) [CommSemiring L] (ℓ : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
def nonDoomedFoldingProp (i : Fin (ℓ + 1)) (challenges : Fin i → L) 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
def finalNonDoomedFoldingProp {h_le : ϑ ≤ ℓ} in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
def extractNextSuffixFromChallenge (v : sDomain 𝔽q β h_ℓ_add_R_rate ⟨0, by omega⟩) in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean
abbrev MultiquadraticPoly (L : Type) [CommSemiring L] (ℓ : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
def fiberwiseClose (i : Fin ℓ) (steps : ℕ) [NeZero steps] (h_i_add_steps : i.val + steps ≤ ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
def fiberEvaluationMapping (i : Fin r) (steps : ℕ) (h_i_add_steps : i.val + steps < ℓ + 𝓡) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
def BBF_CodeDistance (ℓ 𝓡 : ℕ) (i : Fin (ℓ + 1)) : ℕ in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
def fiberwiseDisagreementSet (i : Fin ℓ) (steps : ℕ) [NeZero steps] in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
def localized_fold_eval (i : Fin ℓ) (steps : ℕ) (h_i_add_steps : i + steps ≤ ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
def challengeTensorProduct (steps : ℕ) (r_challenges : Fin steps → L) : Vector L (2 ^ steps) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
theorem fiberwise_dist_lt_imp_dist_lt_unique_decoding_radius (i : Fin ℓ) (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
def uniqueClosestCodeword in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
def BBF_Code (i : Fin (ℓ + 1)) : Submodule L ((sDomain 𝔽q β h_ℓ_add_R_rate) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
def foldingBadEvent (i : Fin ℓ) (steps : ℕ) [NeZero steps] (h_i_add_steps : i + steps ≤ ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
def nonLastBlockOracleVerifier (bIdx : Fin (ℓ / ϑ - 1)) in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
def isCompliant (i : Fin (ℓ)) (steps : ℕ) [NeZero steps] in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
def baseFoldMatrix (i : Fin r) (h_i : i + 1 < ℓ + 𝓡) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
def nonLastBlockOracleReduction (bIdx : Fin (ℓ / ϑ - 1)) in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
lemma oracle_block_k_next_le (i : Fin (ℓ + 1)) (j : Fin (toOutCodewordsCount ℓ ϑ i)) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
lemma nonDoomedFoldingProp_relay_preserved (i : Fin ℓ) (hNCR : ¬ isCommitmentRound ℓ ϑ i) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
def hammingClose (i : Fin (ℓ + 1)) (f : OracleFunction 𝔽q β in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
lemma farness_implies_non_compliance (i : Fin ℓ) (steps : ℕ) [NeZero steps] in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
def foldPrvState (i : Fin ℓ) : Fin (2 + 1) → Type in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps.lean
def disagreementSet (i : Fin ℓ) (steps : ℕ) [NeZero steps] (h_i_add_steps : i.val + steps ≤ ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean

✏️ **Added:** 532 declaration(s)

def castOutSimple in ArkLib/OracleReduction/Cast.lean
lemma probFailure_vector_mapM_eq_zero in ArkLib/ToVCVio/Simulation.lean
lemma finalSumcheckStep_verifierCheck_passed in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean
lemma mem_support_mk {m : Type u → Type v} [Monad m] [HasEvalSPMF m] in ArkLib/ToVCVio/Lemmas.lean
theorem base_intermediateNormVpoly in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
lemma iterated_fold_congr_steps_index in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
lemma simulateQ_vector_mapM {ι ι' : Type} {spec : OracleSpec ι} {superSpec : OracleSpec ι'} in ArkLib/ToVCVio/Simulation.lean
lemma probFailure_simulateQ_simOracle2_eq_zero in ArkLib/ToVCVio/Simulation.lean
lemma simulateQ_simOracle2_liftM_query_T2 in ArkLib/ToVCVio/Simulation.lean
lemma mem_support_OptionT_pure_run_some_iff {m : Type u → Type v} [Monad m] [HasEvalSPMF m] in ArkLib/ToVCVio/Lemmas.lean
def foldPrvState (i : Fin ℓ) : Fin (2 + 1) → Type in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
lemma getMidCodewords_succ (t : L⦃≤ 1⦄[X Fin ℓ]) (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
instance instFintypePSpecQueryMessage : in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean
lemma getLastOracleDomainIndex_last : getLastOracleDomainIndex ℓ ϑ (Fin.last ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
lemma getBBF_Codeword_poly_spec (i : Fin r) in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
def isCompliant (i : Fin r) {destIdx : Fin r} (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
def pair_UDRClose (i : Fin r) (h_i : i ≤ ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
instance instInhabitedPSpecBatching_AllChallenges : in ArkLib/ProofSystem/Binius/RingSwitching/Spec.lean
def fiberwiseDisagreementSet (i : Fin r) {destIdx : Fin r} (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
lemma probFailure_bind_pure_comp_eq_zero_iff {m : Type u → Type v} [Monad m] [HasEvalSPMF m] in ArkLib/ToVCVio/Lemmas.lean
lemma iterated_fold_to_const_strict in ArkLib/ProofSystem/Binius/BinaryBasefold/ReductionLogic.lean
lemma Matrix.reindex_vecMul {m n l : Type*} [Fintype m] [Fintype l] in ArkLib/Data/Fin/BigOperators.lean
abbrev Stateless {ι ι' : Type*} (spec : OracleSpec ι) (superSpec : OracleSpec ι') in ArkLib/ToVCVio/Simulation.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 exists_unique_fiberwiseClosestCodeword_within_UDR (i : Fin r) {destIdx : Fin r} in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
lemma mem_support_OptionT_map_some {m : Type u → Type v} [Monad m] [HasEvalSPMF m] [LawfulMonad m] in ArkLib/ToVCVio/Lemmas.lean
abbrev MultiquadraticPoly (L : Type) [CommSemiring L] (ℓ : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
def mkVerifierOStmtOut in ArkLib/OracleReduction/Basic.lean
lemma exists_fiberwiseClosestCodeword (i : Fin r) {destIdx : Fin r} (steps : ℕ) [NeZero steps] in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
def splitPointIntoCoeffs (i : Fin r) (h_i : i < ℓ + R_rate) in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
lemma probFailure_mk_do_bind_bindT_eq_zero_iff {m : Type u → Type v} [Monad m] [HasEvalSPMF m] in ArkLib/ToVCVio/Lemmas.lean
instance instInhabitedOracleSpecEmpty : (([]ₒ : OracleSpec PEmpty).Inhabited) where in ArkLib/ProofSystem/Binius/RingSwitching/Spec.lean
lemma finalSumcheckStep_is_logic_complete : in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean
lemma single_point_localized_fold_matrix_form_congr_dest_index in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
lemma constFunc_UDRClose {i : Fin r} (h_i : i ≤ ℓ) (c : L) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
lemma hammingDist_le_fiberwiseDistance_mul_two_pow_steps (i : Fin r) {destIdx : Fin r} (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
lemma getLastOracleDomainIndex_add_ϑ_le (i : Fin (ℓ + 1)) : 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
def sumcheckVerifierStmtOut (stmtIn : Statement (L in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean
lemma probFailure_simulateQ_queryFiberPoints_eq_zero in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean
lemma OptionT.probOutput_none_bind_eq_zero_iff in ArkLib/ToVCVio/Simulation.lean
lemma liftComp_id in ArkLib/ToVCVio/Lemmas.lean
def strictOracleFoldingConsistencyProp (t : MultilinearPoly L ℓ) (i : Fin (ℓ + 1)) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
lemma index_bound_check {ℓ i steps : ℕ} (j m : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
lemma val_mkFromStmtIdxCastSuccOfSucc_eq_mkFromStmtIdx {ℓ : ℕ} (i : Fin ℓ) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
lemma mem_support_bind_bind_map_iff [LawfulMonad m] in ArkLib/ToVCVio/Lemmas.lean
lemma mkVerifierOStmtOut_inr in ArkLib/OracleReduction/Basic.lean
def additiveNTTInvariant (evaluation_buffer : Fin (2 ^ (ℓ + R_rate)) → L) in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
lemma coe_fin_pow_two_eq_bitsOfIndex {n : ℕ} (k : Fin (2 ^ n)) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
instance instFintypePSpecBatchingChallenge : in ArkLib/ProofSystem/Binius/RingSwitching/Spec.lean
theorem simulateQ_preserves_safety in ArkLib/ToVCVio/Simulation.lean
theorem Polynomial.foldl_comp (n : ℕ) (f : Fin n → L[X]) : ∀ initInner initOuter: L[X], in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
instance instFintypePSpecSumcheckRoundChallenge : in ArkLib/ProofSystem/Binius/RingSwitching/Spec.lean
lemma exists_BBF_poly_of_codeword (i : Fin r) in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
lemma odd_index_intermediate_novel_basis_decomposition in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
def strictFoldStepRelOut (i : Fin ℓ) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
lemma fold_preserves_BBF_Code_membership (i : Fin r) {destIdx : Fin r} in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
def foldingBadEvent (i : Fin r) {destIdx : Fin r} (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
lemma simulateQ_simOracle2_liftM in ArkLib/ToVCVio/Simulation.lean
lemma probFailure_challengeQueryImpl_run {n : ℕ} {pSpec : ProtocolSpec n} {σ : Type} in ArkLib/ToVCVio/Simulation.lean
lemma intermediate_poly_P_base (h_ℓ : ℓ ≤ r) (coeffs : Fin (2 ^ ℓ) → L) : in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
theorem probFailure_simulateQ_iff_stateful_run'_mk in ArkLib/ToVCVio/Simulation.lean
lemma run_liftComp_eq {ι' : Type w} {spec : OracleSpec ι} {superSpec : OracleSpec ι'} in ArkLib/ToVCVio/Lemmas.lean
def UDRCodeword (i : Fin r) (h_i : i ≤ ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
lemma qMap_total_fiber_congr_steps in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
theorem iterated_fold_advances_evaluation_poly in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
lemma query_phase_final_fold_eq_constant in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean
def hEq {ιₒᵢ ιₒₒ : Type} {OracleIn : ιₒᵢ → Type} in ArkLib/ProofSystem/Binius/BinaryBasefold/ReductionLogic.lean
instance instFintypePSpecBatching_AllChallenges : in ArkLib/ProofSystem/Binius/RingSwitching/Spec.lean
lemma probFailure_forIn_of_relations in ArkLib/ToVCVio/Simulation.lean
theorem simulateQ_preserves_safety_stateful in ArkLib/ToVCVio/Simulation.lean
lemma probOutput_none_bind_eq_zero_iff in ArkLib/ToVCVio/Simulation.lean
theorem run_liftM_lib [Monad m] [LawfulMonad m] (ma : m α) (s : σ) : in ArkLib/ToVCVio/Lemmas.lean
lemma finTwoPowSumEquiv_apply_left (n : ℕ) (x : Fin (2 ^ n)) : in ArkLib/Data/Fin/BigOperators.lean
def commitStepEmbed (i : Fin ℓ) (hCR : isCommitmentRound ℓ ϑ i) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
lemma getSumcheckRoundPoly_eval_eq (i : Fin ℓ) (h_poly : ↥L⦃≤ 2⦄[X Fin (ℓ - ↑i.castSucc)]) (r : L) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
lemma support_challengeQueryImpl_eq {n : ℕ} {pSpec : ProtocolSpec n} in ArkLib/ToVCVio/Simulation.lean
lemma intermediateEvaluationPoly_from_inovel_coeffs_eq_self in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
lemma mem_support_simulateQ_id'_liftM_query {ι : Type*} {spec : OracleSpec ι} in ArkLib/ToVCVio/Lemmas.lean
lemma iterated_fold_to_level_ℓ_is_constant in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
theorem probFailure_simulateQ_iff_stateful in ArkLib/ToVCVio/Simulation.lean
def fold_eval_fiber₂_vec (i : Fin r) {midIdx destIdx : Fin r} (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
def strictOracleWitnessConsistency in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
instance instFintypePSpecRelay_AllChallenges: ∀ i, Fintype ((pSpecRelay).Challenge i) in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean
def sumcheckStepLogic : in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean
def QueryImpl.lift {ι₁ ι₂ : Type u} {spec₁ : OracleSpec ι₁} {spec₂ : OracleSpec ι₂} in ArkLib/ToVCVio/Simulation.lean
def challengeSuffixToFin (k : Fin (ℓ / ϑ)) in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean
lemma farness_implies_non_compliance (i : Fin r) {destIdx : Fin r} (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
def pair_fiberwiseDistance (i : Fin r) {destIdx : Fin r} (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
lemma Matrix.reindex_mulVec_reindex {m n o l : Type*} [Fintype n] [Fintype l] [Fintype m] in ArkLib/Data/Fin/BigOperators.lean
lemma iterated_fold_last (i : Fin r) {midIdx destIdx : Fin r} (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
lemma probFailure_simulateQ_iff_mk in ArkLib/ToVCVio/Simulation.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 batching_check_correctness in ArkLib/ProofSystem/Binius/RingSwitching/Prelude.lean
def commitStepHEq (i : Fin ℓ) (hCR : isCommitmentRound ℓ ϑ i) : in ArkLib/ProofSystem/Binius/BinaryBasefold/ReductionLogic.lean
lemma qCompositionChain_eq_foldl (i : Fin r) : in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
def finToBinaryCoeffs (i : Fin r) (idx : Fin (2 ^ (ℓ + R_rate - i.val))) : in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
def castInOut in ArkLib/OracleReduction/Cast.lean
lemma Fin.reindex_reindex {R n m l : Type*} [Fintype n] [Fintype m] [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 pairUDRClose_of_pairFiberwiseClose (i : Fin r) {destIdx : Fin r} (steps : ℕ) [NeZero steps] in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
def ReductionLogicStep.IsStronglyComplete in ArkLib/ProofSystem/Binius/BinaryBasefold/ReductionLogic.lean
lemma support_liftComp {ι' : Type w} {superSpec : OracleSpec ι'} in ArkLib/ToVCVio/Lemmas.lean
def mkFromStmtIdx {ℓ : ℕ} (stmtIdx : Fin (ℓ + 1)) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
theorem intermediateChangeOfBasisMatrix_lower_triangular (i : Fin r) (h_i : i ≤ ℓ) : in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
lemma probFailure_mk_do_bind_bind_eq_zero_iff {m : Type u → Type v} [Monad m] [HasEvalSPMF m] in ArkLib/ToVCVio/Lemmas.lean
theorem forall_eq_bind_pure_iff {α β γ} in ArkLib/OracleReduction/Completeness.lean
lemma mem_support_run_mk_iff {m : Type u → Type v} [Monad m] [HasEvalSPMF m] in ArkLib/ToVCVio/Lemmas.lean
lemma support_forIn_subset_rel in ArkLib/ToVCVio/Simulation.lean
def butterflyMatrix (n : ℕ) (z₀ z₁ : L) : Matrix (Fin (2 ^ (n + 1))) (Fin (2 ^ (n + 1))) L in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
lemma commitStep_is_logic_complete (i : Fin ℓ) (hCR : isCommitmentRound ℓ ϑ i) : in ArkLib/ProofSystem/Binius/BinaryBasefold/ReductionLogic.lean
lemma probFailure_simulateQ_iff (so : QueryImpl spec ProbComp) (oa : OracleComp spec α) : in ArkLib/ToVCVio/Simulation.lean
instance instInhabitedPSpecFinalSumcheck_AllChallenges : ∀ i, Inhabited ((pSpecFinalSumcheck (L in ArkLib/ProofSystem/Binius/RingSwitching/Spec.lean
def extractSuffixFromChallenge (v : sDomain 𝔽q β h_ℓ_add_R_rate ⟨0, by omega⟩) in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean
lemma simulateQ_simOracle2_liftM_query_T1 in ArkLib/ToVCVio/Simulation.lean
lemma strictOracleFoldingConsistency_commitStep in ArkLib/ProofSystem/Binius/BinaryBasefold/ReductionLogic.lean
lemma Transcript_get_challenge (tr : pSpec.FullTranscript) (j : Fin n) (h : pSpec.dir j = .V_to_P) : in ArkLib/ToVCVio/Simulation.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
lemma commitStep_j_is_last (i : Fin ℓ) (hCR : isCommitmentRound ℓ ϑ i) in ArkLib/ProofSystem/Binius/BinaryBasefold/ReductionLogic.lean
instance instInhabitedPSpecSumcheckLoopMessage : [(pSpecSumcheckLoop (L in ArkLib/ProofSystem/Binius/RingSwitching/Spec.lean
lemma ne_none_of_mem_support_of_probOutput_none_eq_zero in ArkLib/ToVCVio/Lemmas.lean
theorem run'_bind_lib [Monad m] [LawfulMonad m] (ma : StateT σ m α) (f : α → StateT σ m β) (s : σ) : in ArkLib/ToVCVio/Lemmas.lean
def liftQuery {spec : OracleSpec ι} {α} (q : OracleQuery spec α) : OracleComp spec α in ArkLib/OracleReduction/Completeness.lean
instance instMonadLift_right_right {ι₁ ι₂ ι₃ : Type} in ArkLib/ToVCVio/Simulation.lean
lemma base_coeffsBySuffix (a : Fin (2 ^ ℓ) → L) : 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 unroll_1_message_reduction_perfectCompleteness_P_to_V in ArkLib/OracleReduction/Completeness.lean
lemma challengeTensorExpansion_one [CommRing L] (r : L) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
lemma probFailure_simulateQ_liftQuery_eq_zero_iff in ArkLib/ToVCVio/Lemmas.lean
lemma UDRCodeword_mem_BBF_Code (i : Fin r) (h_i : i ≤ ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.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 finToBinaryCoeffs_sDomainToFin (i : Fin r) (h_i : i < ℓ + R_rate) in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
lemma foldStep_is_logic_complete (i : Fin ℓ) : in ArkLib/ProofSystem/Binius/BinaryBasefold/ReductionLogic.lean
lemma mem_sDomain_of_eq {i j : Fin r} (h : i.val = j.val) in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.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
def finalSumcheckStepLogic : in ArkLib/ProofSystem/Binius/BinaryBasefold/ReductionLogic.lean
def nonLastSingleBlockOracleReduction (bIdx : Fin (ℓ / ϑ - 1)) in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
instance instFintypePSpecFinalSumcheckStepChallenge : in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean
def getLastOracle {oracleFrontierIdx : Fin (ℓ + 1)} {destIdx : Fin r} in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
lemma finTwoPowSumEquiv_apply_right (n : ℕ) (x : Fin (2 ^ n)) : in ArkLib/Data/Fin/BigOperators.lean
lemma even_index_intermediate_novel_basis_decomposition (i : Fin r) in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
lemma oracle_index_le_ℓ (i : Fin (ℓ + 1)) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
theorem UDRClose_of_fiberwiseClose (i : Fin r) {destIdx : Fin r} (steps : ℕ) [NeZero steps] in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
theorem unroll_2_message_reduction_perfectCompleteness in ArkLib/OracleReduction/Completeness.lean
theorem simulateQ_preserves_safety_mk in ArkLib/ToVCVio/Simulation.lean
abbrev liftComp_self [spec.Fintype] [spec.Inhabited] in ArkLib/ToVCVio/Lemmas.lean
def challengeTensorExpansion [CommRing L] (n : ℕ) (r : Fin n → L) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
theorem queryPhaseLogicStep_isStronglyComplete : in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean
lemma fold_eval_single_matrix_mul_form (i : Fin r) {destIdx : Fin r} in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
lemma batching_target_consistency in ArkLib/ProofSystem/Binius/RingSwitching/Prelude.lean
lemma mem_support_run_bind_some_iff {α β : Type u} in ArkLib/ToVCVio/Lemmas.lean
lemma evaluationPointω_eq_twiddleFactor_of_div_2 (i : Fin r) (h_i : i < ℓ) in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
lemma simOracle2_impl_inr_inl in ArkLib/ToVCVio/Simulation.lean
instance instInhabitedPSpecRelayChallenge : in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean
theorem castInOut_perfectCompleteness in ArkLib/OracleReduction/Cast.lean
lemma probFailure_run_simulateQ_liftQuery_eq in ArkLib/ToVCVio/Lemmas.lean
lemma Transcript_get_message (tr : pSpec.FullTranscript) (j : Fin n) (h : pSpec.dir j = .P_to_V) : in ArkLib/ToVCVio/Simulation.lean
def UDRClose (i : Fin r) (h_i : i ≤ ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
theorem castOutSimple_rbrKnowledgeSoundness in ArkLib/OracleReduction/Cast.lean
lemma Statement.of_fin_eq {i j : Fin (ℓ + 1)} (h : i = j) : in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
lemma mem_support_simulateQ_liftQuery_some_iff in ArkLib/ToVCVio/Lemmas.lean
lemma sDomain_card (i : Fin r) (h_i : i < ℓ + R_rate) : in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
def strictRoundRelation (i : Fin (ℓ + 1)) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
def commitStepHEq (i : Fin ℓ) (hCR : isCommitmentRound ℓ ϑ i) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
lemma blockDiagMatrix_mulVec_F₂_eq_Fin_merge_PO2 (n : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
lemma val_le_i {ℓ : ℕ} (i : Fin (ℓ + 1)) (oracleIdx : OracleFrontierIndex i) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
def foldOracleVerifier (i : Fin ℓ) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps.lean
def polyToOracleFunc {domainIdx : Fin r} (P : L[X]) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
lemma degree_intermediateNormVpoly (i : Fin r) {k : ℕ} (h_k : i.val + k ≤ ℓ) : in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
lemma OptionT.simulateQ_map in ArkLib/ToVCVio/Simulation.lean
lemma query_phase_step_preserves_fold in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean
lemma support_OptionT_pure_run {m : Type u → Type v} [Monad m] [HasEvalSPMF m] in ArkLib/ToVCVio/Lemmas.lean
theorem intermediateNormVpoly_comp_qmap (i : Fin r) in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
lemma neverFails_of_simulateQ_stateful in ArkLib/ToVCVio/Simulation.lean
lemma support_bind_simulateQ_run'_eq_mk in ArkLib/ToVCVio/Simulation.lean
def OracleFrontierIndex {ℓ : ℕ} (stmtIdx : Fin (ℓ + 1)) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
lemma mkVerifierOStmtOut_inl in ArkLib/OracleReduction/Basic.lean
instance instInhabitedPSpecQueryChallenge : in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean
lemma sDomain_eq_image_of_upper_span (i : Fin r) (h_i : i < ℓ + R_rate) : in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
lemma probOutput_none_run_eq_zero_of_probFailure_eq_zero in ArkLib/ToVCVio/Lemmas.lean
instance instFintypePSpecFinalSumcheck_AllChallenges: ∀ i, Fintype ((pSpecFinalSumcheckStep (L in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean
theorem qMap_is_linear_map (i : Fin r) : in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
def FullTranscript.mk1 {pSpec : ProtocolSpec 1} (msg0 : pSpec.«Type» 0) : in ArkLib/OracleReduction/Basic.lean
lemma mem_support_vector_mapM {n} {f : α → OracleComp spec β} {as : Vector α n} {x : Vector β n} : in ArkLib/ToVCVio/Simulation.lean
def splitFinMap_PO2_left {L : Type*} {n : ℕ} (v : Fin (2 ^ (n + 1)) → L) in ArkLib/Data/Fin/BigOperators.lean
lemma degree_intermediateEvaluationPoly_lt (i : Fin r) (h_i : i ≤ ℓ) in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
lemma commitStep_j_bound (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
lemma finalSumcheckStep_is_logic_complete : in ArkLib/ProofSystem/Binius/BinaryBasefold/ReductionLogic.lean
lemma OracleStatement.heq_of_fin_eq {i j : Fin (ℓ + 1)} (h : i = j) : in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
lemma finalSumcheck_honest_message_eq_t'_eval in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean
def batchingVerifierStmtOut (stmtIn : BatchingStmtIn L ℓ) in ArkLib/ProofSystem/Binius/RingSwitching/BatchingPhase.lean
def strictFinalFoldingStateProp (t : MultilinearPoly L ℓ) {h_le : ϑ ≤ ℓ} in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
lemma support_OptionT_pure {m : Type u → Type v} [Monad m] [HasEvalSPMF m] in ArkLib/ToVCVio/Lemmas.lean
lemma OptionT.simulateQ_simOracle2_liftM_query_T2 in ArkLib/ToVCVio/Simulation.lean
lemma butterflyMatrix_det_ne_zero (n : ℕ) (z₀ z₁ : L) (h_ne : z₀ ≠ z₁) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.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
lemma support_bind_simulateQ_run'_eq in ArkLib/ToVCVio/Simulation.lean
def challengeTensorExpansionMatrix [CommRing L] (n : ℕ) (r : Fin n → L) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
def strictRoundRelationProp (i : Fin (ℓ + 1)) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
lemma OptionT.bind_pure_simulateQ_comp in ArkLib/ToVCVio/Simulation.lean
lemma OptionT.support_run_simulateQ_eq_of_superSpec {ι' : Type} in ArkLib/ToVCVio/Simulation.lean
theorem unroll_1_message_reduction_perfectCompleteness_V_to_P in ArkLib/OracleReduction/Completeness.lean
def single_point_localized_fold_matrix_form (i : Fin r) {destIdx : Fin r} (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
def fold_single_matrix_mul_form (i : Fin r) {destIdx : Fin r} in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
instance instInhabitedPSpecLargeFieldReductionMessage : in ArkLib/ProofSystem/Binius/RingSwitching/Spec.lean
lemma support_liftComp_id in ArkLib/ToVCVio/Lemmas.lean
lemma projectToMidSumcheckPoly_at_last_eval in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
lemma probFailure_run_simulateQ_liftQuery_eq_zero_iff in ArkLib/ToVCVio/Lemmas.lean
lemma support_pure_bind_pure {α β : Type} (x : α) (f : α → ProbComp β) : in ArkLib/ToVCVio/Lemmas.lean
def commitStepLogic_embed (i : Fin ℓ) (hCR : isCommitmentRound ℓ ϑ i) : in ArkLib/ProofSystem/Binius/BinaryBasefold/ReductionLogic.lean
lemma mem_support_run_map_some_iff [LawfulMonad m] {α β : Type u} in ArkLib/ToVCVio/Lemmas.lean
def getBBF_Codeword_poly (i : Fin r) in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
instance instOracleInterfacePSpecRelay_AllChallenges in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean
def getBBF_Codeword_of_poly (i : Fin r) (h_i : i ≤ ℓ) (P : L⦃< 2 ^ (ℓ - i)⦄[X]) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
lemma Matrix.mulVec_reindex {m n l : Type*} [Fintype n] [Fintype l] in ArkLib/Data/Fin/BigOperators.lean
lemma mem_support_OptionT_run_bind_some in ArkLib/ToVCVio/Lemmas.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 𝔽q_element_eq_zero_or_eq_one : ∀ c: 𝔽q, c = 0 ∨ c = 1 in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
theorem iNovelToMonomial_monomialToINovel_inverse (i : Fin r) (h_i : i ≤ ℓ) in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
lemma intermediateNovelBasisX_zero_eq_one (i : Fin r) (h_i : i ≤ ℓ) : in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
lemma probFailure_forIn_eq_zero_of_body_safe in ArkLib/ToVCVio/Simulation.lean
lemma fin_zero_mul_eq (h : 0 * ϑ < ℓ + 1) : (⟨0 * ϑ, h⟩ : Fin (ℓ + 1)) = 0 in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
lemma probFailure_mk_do_bindT_eq_zero_iff {m : Type u → Type v} [Monad m] [HasEvalSPMF m] in ArkLib/ToVCVio/Lemmas.lean
def strictFinalSumcheckRelOutProp in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
lemma simulateQ_simOracle2_lift_liftComp_query_T2 in ArkLib/ToVCVio/Simulation.lean
lemma simulateQ_simOracle2_lift_liftComp_query_T1 in ArkLib/ToVCVio/Simulation.lean
lemma probFailure_OptionT_pure {m : Type u → Type v} [Monad m] [HasEvalSPMF m] in ArkLib/ToVCVio/Lemmas.lean
lemma butterflyMatrix_zero_apply (z₀ z₁ : L) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
lemma butterflyMatrix0_mul_matrixCTensor_eq_matrixCTensor_mul_butterflyMatrix (n : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
def batchingStepLogic : in ArkLib/ProofSystem/Binius/RingSwitching/BatchingPhase.lean
lemma fold_error_containment_of_UDRClose (i : Fin r) {destIdx : Fin r} (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
def sumcheckVerifierCheck (stmtIn : Statement (L in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean
instance instInhabitedPSpecCoreInteractionMessage : in ArkLib/ProofSystem/Binius/RingSwitching/Spec.lean
instance instInhabitedPspecCommitChallenge {i : Fin ℓ}: in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean
lemma constantIntermediateEvaluationPoly_eval_eq_const in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
lemma support_simulateQ_eq_OracleComp_of_superSpec {ι' : Type} {superSpec : OracleSpec ι'} in ArkLib/ToVCVio/Simulation.lean
def batchingVerifierCheck (stmtIn : BatchingStmtIn L ℓ) (msg0 : TensorAlgebra K L) : Prop in ArkLib/ProofSystem/Binius/RingSwitching/BatchingPhase.lean
lemma OracleComp.probFailure_vector_mapM_eq_zero in ArkLib/ToVCVio/Simulation.lean
abbrev BBF_CodeDistance (i : Fin r) : ℕ in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
def strictFoldStepRelOutProp (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
def getChallengeSuffix (k : Fin (ℓ / ϑ)) (v : sDomain 𝔽q β h_ℓ_add_R_rate ⟨0, by omega⟩) : in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean
lemma degree_qMap (i : Fin r) : (qMap 𝔽q β i).degree = 2 in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
def nonLastBlocksOracleReduction : in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
lemma Prover.run_succ (prover : Prover oSpec StmtIn WitIn StmtOut WitOut pSpec) in ArkLib/ToVCVio/Simulation.lean
lemma OptionT.probFailure_vector_mapM_eq_zero in ArkLib/ToVCVio/Simulation.lean
def foldVerifierStmtOut (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
lemma lt_r_of_lt_ℓ {h_ℓ_add_R_rate : ℓ + 𝓡 < r} {x : ℕ} (h : x < ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean
lemma probFailure_forIn_of_relations_simplified in ArkLib/ToVCVio/Simulation.lean
def foldProverComputeMsg (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
lemma OptionT.simulateQ_vector_mapM {ι ι' : Type} {spec : OracleSpec ι} {superSpec : OracleSpec ι'} in ArkLib/ToVCVio/Simulation.lean
instance instNontrivial {F ι : Type*} {n : ℕ} [Field F] [Fintype ι] {α : ι ↪ F} in ArkLib/Data/CodingTheory/ReedSolomon.lean
lemma snoc_oracle_dest_eq_j {i : Fin ℓ} {destIdx : Fin r} in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
lemma get_sDomain_first_basis_eq_1 (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 bind_pure_simulateQ_comp in ArkLib/ToVCVio/Simulation.lean
def nonLastSingleBlockOracleVerifier (bIdx : Fin (ℓ / ϑ - 1)) in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
lemma simulateQ_forIn {ι ι' : Type} {spec : OracleSpec ι} {superSpec : OracleSpec ι'} in ArkLib/ToVCVio/Simulation.lean
def reindexVecTwoPowAddTwoPow {L : Type*} {n : ℕ} (v : Fin (2 ^ n + 2 ^ n) → L) in ArkLib/Data/Fin/BigOperators.lean
lemma OracleComp.liftM_query_eq_liftM_liftM.{u, v, z} in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean
theorem simulateQ_preserves_safety_stateful_run'_mk in ArkLib/ToVCVio/Simulation.lean
def nonLastBlocksOracleVerifier : in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
lemma getSDomainBasisCoeff_of_iteratedQuotientMap in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
instance instFintypePSpecFoldChallenge : [(pSpecFold (L in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean
lemma sBasis_range_eq (i : Fin r) (h_i : i < ℓ + R_rate) : in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
lemma k_mul_ϑ_lt_ℓ {k : Fin (ℓ / ϑ)} : in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean
instance instFintypePSpecQueryChallenge : [(pSpecQuery 𝔽q β γ_repetitions in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean
instance instMonadLift_left_left {ι₁ ι₂ ι₃ : Type} in ArkLib/ToVCVio/Simulation.lean
lemma qMap_eval_mem_sDomain_succ (i : Fin r) {destIdx : Fin r} in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
theorem castOutSimple_perfectCompleteness in ArkLib/OracleReduction/Cast.lean
lemma sDomain_eq_of_eq {i j : Fin r} (h : i = j) : in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
lemma not_mem_support_run_none_of_probFailure_eq_zero in ArkLib/ToVCVio/Lemmas.lean
instance instNeZeroNatToOutCodewordsCount : ∀ i, NeZero (toOutCodewordsCount ℓ ϑ i) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
lemma iterated_fold_zero_steps (i : Fin r) {destIdx : Fin r} in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
lemma Witness.of_fin_eq {i j : Fin (ℓ + 1)} (h : i = j) : in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
lemma OptionT.support_run_eq in ArkLib/ToVCVio/Simulation.lean
lemma single_point_localized_fold_matrix_form_congr_steps_index in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
lemma Matrix.map_neg {m n : Type*} {R S : Type*} [Ring R] [Ring S] in ArkLib/Data/Fin/BigOperators.lean
lemma support_run {m : Type u → Type v} [Monad m] [HasEvalSPMF m] in ArkLib/ToVCVio/Lemmas.lean
def splitFinMap_PO2_right {L : Type*} {n : ℕ} (v : Fin (2 ^ (n + 1)) → L) in ArkLib/Data/Fin/BigOperators.lean
lemma mem_support_bind_some_iff {α β : Type u} in ArkLib/ToVCVio/Lemmas.lean
theorem castOutSimple_completeness in ArkLib/OracleReduction/Cast.lean
instance instInhabitedPSpecFinalSumcheckStepMessage : in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean
lemma OptionT.liftComp_forIn {ι ι' : Type _} {spec : OracleSpec ι} {superSpec : OracleSpec ι'} in ArkLib/ToVCVio/Simulation.lean
lemma lt_r_of_le_ℓ {h_ℓ_add_R_rate : ℓ + 𝓡 < r} {x : ℕ} (h : x ≤ ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean
lemma OracleStatement.idx_eq {i j : Fin (ℓ + 1)} (h : i = j) : in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
lemma UDRClose_iff_within_UDR_radius (i : Fin r) (h_i : i ≤ ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
theorem unroll_n_message_reduction_perfectCompleteness in ArkLib/OracleReduction/Completeness.lean
lemma sDomainBasisVectors_mem_sDomain (i : Fin r) (k : Fin (ℓ + R_rate - i)) : in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
lemma get_sDomain_basis (i : Fin r) (h_i : i < ℓ + R_rate) : in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
lemma projectToNextSumcheckPoly_eval_eq (i : Fin ℓ) (Hᵢ : MultiquadraticPoly L (ℓ - i)) (rᵢ : L) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
lemma fiberEvaluations_eq_merge_fiberEvaluations_of_one_step_fiber in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
lemma mem_support_OptionT_run_map_some in ArkLib/ToVCVio/Lemmas.lean
theorem imp_comm {P Q R : Prop} : (P → Q → R) ↔ (Q → P → R) in ArkLib/ToVCVio/Lemmas.lean
lemma mem_support_bind_bind_map_generic_iff [LawfulMonad m] in ArkLib/ToVCVio/Lemmas.lean
instance instInhabitedPSpecSumcheckRoundChallenge : in ArkLib/ProofSystem/Binius/RingSwitching/Spec.lean
lemma Matrix.reindex_mul_eq_prod_of_reindex {l m n o p q : Type*} in ArkLib/Data/Fin/BigOperators.lean
def fiberwiseDistance (i : Fin r) {destIdx : Fin r} (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
instance instInhabitedOracleStatement {i : Fin (ℓ + 1)} : in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean
instance instFintypePSpecFinalSumcheckChallenge : in ArkLib/ProofSystem/Binius/RingSwitching/Spec.lean
lemma mem_support_vector_mapM_pure {α β : Type} {n : ℕ} in ArkLib/ToVCVio/Simulation.lean
def foldStepLogic (i : Fin ℓ) : in ArkLib/ProofSystem/Binius/BinaryBasefold/ReductionLogic.lean
lemma OptionT.simulateQ_bind in ArkLib/ToVCVio/Simulation.lean
instance instFintypeOracleStatementFinLast : in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean
lemma probFailure_forIn_of_invariant in ArkLib/ToVCVio/Simulation.lean
theorem forall_eq_lift_mem_2 {α β γ} {S : Set α} {T : α → Set β} in ArkLib/OracleReduction/Completeness.lean
instance instInhabitedPSpecSumcheckRoundMessage : [(pSpecSumcheckRound (L in ArkLib/ProofSystem/Binius/RingSwitching/Spec.lean
lemma mem_support_queryFiberPoints in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean
lemma natDegree_qMap (i : Fin r) : (qMap 𝔽q β i).natDegree = 2 in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
instance instOracleStatementFiniteRange {i : Fin (ℓ + 1)} : in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean
def batchingProverWitOut (stmtIn : BatchingStmtIn L ℓ) (witIn : BatchingWitIn L K ℓ ℓ') in ArkLib/ProofSystem/Binius/RingSwitching/BatchingPhase.lean
instance instInhabitedPSpecFinalSumcheckStepChallenge : in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean
def finalSumcheckVerifierCheck in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean
def pair_fiberwiseClose (i : Fin r) {destIdx : Fin r} (steps : ℕ) [NeZero steps] in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
theorem evaluation_poly_split_identity (i : Fin r) (h_i : i < ℓ) in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
lemma checkSingleRepetition_inner_forIn_probFailure_eq_zero in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean
theorem support_nonempty_of_neverFails in ArkLib/ToVCVio/Simulation.lean
def tileCoeffs (a : Fin (2 ^ ℓ) → L) : Fin (2^(ℓ + R_rate)) → L in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
lemma foldMatrix_det_ne_zero (i : Fin r) {destIdx : Fin r} (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
lemma getFirstOracle_snoc_oracle in ArkLib/ProofSystem/Binius/BinaryBasefold/ReductionLogic.lean
instance instFintypePspecCommit_AllChallenges {i : Fin ℓ}: in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean
lemma Fin.reindex_reindex_symm {R n m : Type*} [Fintype n] [Fintype m] in ArkLib/Data/Fin/BigOperators.lean
def strictFinalSumcheckRelOut : in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
lemma Matrix.det_map_ringHom {n : Type*} [Fintype n] [DecidableEq n] {R S : Type*} in ArkLib/Data/Fin/BigOperators.lean
lemma sumcheckStep_is_logic_complete (i : Fin ℓ') : in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean
lemma OptionT.probFailure_forIn_eq_zero_of_body_safe in ArkLib/ToVCVio/Simulation.lean
lemma simOracle2_impl_inl in ArkLib/ToVCVio/Simulation.lean
lemma exists_eq_some_of_mem_support_run_of_probFailure_eq_zero in ArkLib/ToVCVio/Lemmas.lean
theorem castInOut_id in ArkLib/OracleReduction/Cast.lean
lemma OptionT.support_ite_run in ArkLib/ToVCVio/Simulation.lean
lemma Matrix.det_from4Blocks_of_squareSubblocks_commute {n : ℕ} {R : Type*} in ArkLib/Data/Fin/BigOperators.lean
lemma snoc_oracle_impossible {i : Fin ℓ} {j : Fin (toOutCodewordsCount ℓ ϑ i.succ)} in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
lemma batchingStep_is_logic_complete : in ArkLib/ProofSystem/Binius/RingSwitching/BatchingPhase.lean
theorem monomialToINovel_iNovelToMonomial_inverse (i : Fin r) (h_i : i ≤ ℓ) in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
lemma constFunc_mem_BBFCode {i : Fin r} (h_i : i ≤ ℓ) (c : L) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
lemma UDRCodeword_constFunc_eq_self (i : Fin r) (h_i : i ≤ ℓ) (c : L) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
theorem intermediateChangeOfBasisMatrix_diag_ne_zero (i : Fin r) (h_i : i ≤ ℓ) : in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
lemma challengeTensorExpansion_decompose_succ [CommRing L] (n : ℕ) (r : Fin (n + 1) → L) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
def sumcheckProverComputeMsg (witIn : SumcheckWitness L ℓ' i.castSucc) : L⦃≤ 2⦄[X] in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean
lemma degree_intermediateNovelBasisX (i : Fin r) (h_i : i ≤ ℓ) (j : Fin (2 ^ (ℓ - i))) : in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
lemma strictRoundRelation.of_fin_eq {i j : Fin (ℓ + 1)} (h : i = j) : in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
lemma support_mk {m : Type u → Type v} [Monad m] [HasEvalSPMF m] in ArkLib/ToVCVio/Lemmas.lean
instance instInhabitedPSpecFoldChallenge : [(pSpecFold (L in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean
lemma OracleStatement.oracle_eval_congr in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
def finalFoldingStateProp {h_le : ϑ ≤ ℓ} in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
def relayOracleVerifier_embed (i : Fin ℓ) (hNCR : ¬ isCommitmentRound ℓ ϑ i) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps.lean
lemma iterated_fold_congr_source_index in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
def mergeFinMap_PO2_left_right {L : Type*} {n : ℕ} (left : Fin (2 ^ n) → L) in ArkLib/Data/Fin/BigOperators.lean
def finTwoPowSumEquiv (n : ℕ) : Fin (2 ^ n) ⊕ Fin (2 ^ n) ≃ Fin (2 ^ (n + 1)) in ArkLib/Data/Fin/BigOperators.lean
lemma foldl_NTTStage_inductive_aux (h_ℓ : ℓ ≤ r) (k : Fin (ℓ + 1)) in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
def batchingProverComputeMsg (stmtIn : BatchingStmtIn L ℓ) (witIn : BatchingWitIn L K ℓ ℓ') : in ArkLib/ProofSystem/Binius/RingSwitching/BatchingPhase.lean
lemma lastBlockOracleReduction_perfectCompleteness (hInit : NeverFail init) : in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.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
instance instInhabitedPSpecFinalSumcheckChallenge : in ArkLib/ProofSystem/Binius/RingSwitching/Spec.lean
lemma qMap_comp_normalizedW (i : Fin r) (h_i_add_1 : i + 1 < r) : in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
instance instMonadLift_right_left {ι₁ ι₂ ι₃ : Type} in ArkLib/ToVCVio/Simulation.lean
lemma OptionT.simulateQ_failure' {α : Type u} in ArkLib/ToVCVio/Simulation.lean
def commitStepLogic_embedFn (i : Fin ℓ) : in ArkLib/ProofSystem/Binius/BinaryBasefold/ReductionLogic.lean
lemma single_point_localized_fold_matrix_form_eq_iterated_fold in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
lemma getSDomainBasisCoeff_of_sum_repr [NeZero R_rate] (i : Fin r) (h_i : i ≤ ℓ) in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
instance instInhabitedPSpecRelayMessage : [(pSpecRelay).Message]ₒ.Inhabited where in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean
theorem run'_bind_pure [Monad m] [LawfulMonad m] {s : σ} (x : α) (f : α → StateT σ m β) : in ArkLib/ToVCVio/Lemmas.lean
lemma Matrix.reindex_mulVec {m n o l : Type*} [Fintype n] [Fintype l] [Fintype m] [Fintype o] in ArkLib/Data/Fin/BigOperators.lean
lemma probFailure_mk {m : Type u → Type v} [Monad m] [HasEvalSPMF m] in ArkLib/ToVCVio/Lemmas.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
def foldVerifierCheck (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
lemma OptionT.mem_support_vector_mapM {ι : Type} {spec : OracleSpec ι} in ArkLib/ToVCVio/Simulation.lean
def sBasis (i : Fin r) (h_i : i < ℓ + R_rate) : Fin (ℓ + R_rate - i) → L in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
lemma OptionT.simulateQ_pure in ArkLib/ToVCVio/Simulation.lean
lemma mem_support_map_iff_generic {m : Type u → Type v} [Monad m] [HasEvalSPMF m] [LawfulMonad m] in ArkLib/ToVCVio/Lemmas.lean
lemma OptionT.simulateQ_liftComp in ArkLib/ToVCVio/Simulation.lean
def fold_error_containment (i : Fin r) {destIdx : Fin r} (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
lemma multilinearWeight_succ_lower_half {n : ℕ} in ArkLib/Data/CodingTheory/Prelims.lean
theorem intermediateNormVpoly_comp (i : Fin r) {destIdx : Fin r} in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
instance instFintypePSpecFold_AllChallenges: ∀ i, Fintype ((pSpecFold (L in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean
lemma probFailure_liftComp_of_OracleComp_Option {ι' : Type w} {spec : OracleSpec ι} in ArkLib/ToVCVio/Lemmas.lean
lemma OptionT.support_map_run 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 BBF_CodeDistance_eq (i : Fin r) (h_i : i ≤ ℓ) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
instance instFintypeOracleSpecEmpty : (([]ₒ : OracleSpec PEmpty).Fintype) where in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.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 checkSingleRepetition_foldRel in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean
lemma probOutput_none_pure_eq_zero {m : Type u → Type v} [Monad m] [HasEvalSPMF m] in ArkLib/ToVCVio/Lemmas.lean
def finalSumcheckProverWitOut (witIn : SumcheckWitness L ℓ' (Fin.last ℓ')) : WitMLP L ℓ' in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean
instance instFintypeOracleSpecEmpty : (([]ₒ : OracleSpec PEmpty).Fintype) where in ArkLib/ProofSystem/Binius/RingSwitching/Spec.lean
lemma mem_support_OptionT_bind_run_some_iff [LawfulMonad m] {α β : Type u} in ArkLib/ToVCVio/Lemmas.lean
lemma support_run_eq_iff {m : Type u → Type v} [Monad m] [HasEvalSPMF m] in ArkLib/ToVCVio/Lemmas.lean
def extractUDRCodeword in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
def finalSumcheckVerifierStmtOut in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean
lemma probEvent_mk {m : Type u → Type v} [Monad m] [HasEvalSPMF m] in ArkLib/ToVCVio/Lemmas.lean
lemma mem_support_OptionT_bind_pure_comp_run_some_iff [LawfulMonad m] {α β : Type u} in ArkLib/ToVCVio/Lemmas.lean
lemma Matrix.reindex_vecMul_reindex {m n o l : Type*} [Fintype n] [Fintype l] [Fintype m] in ArkLib/Data/Fin/BigOperators.lean
lemma not_mem_support_none_of_probOutput_none_eq_zero in ArkLib/ToVCVio/Lemmas.lean
lemma Matrix.from4Blocks_eq_fromBlocks {m n : ℕ} {α : Type*} in ArkLib/Data/Fin/BigOperators.lean
lemma normalizedW_eq_qMap_composition (ℓ R_rate : ℕ) (i : Fin r) : in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
abbrev MultilinearPoly (L : Type) [CommSemiring L] (ℓ : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
lemma k_succ_mul_ϑ_le_ℓ {k : Fin (ℓ / ϑ)} : (k.val + 1) * ϑ ≤ ℓ in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean
lemma query_phase_consistency_guard_safe in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean
def finTwoPowAddTwoPowEquiv (n : ℕ) : Fin (2 ^ n + 2 ^ n) ≃ Fin (2 ^ (n + 1)) in ArkLib/Data/Fin/BigOperators.lean
lemma strictRoundRelation_relay_preserved (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps.lean
def Matrix.from4Blocks {mTop nLeft mBot nRight : ℕ} {α : Type*} in ArkLib/Data/Fin/BigOperators.lean
lemma mem_support_map_some_iff [LawfulMonad m] {α β : Type u} in ArkLib/ToVCVio/Lemmas.lean
lemma multilinear_eval_eq_sum_bool_hypercube (challenges : Fin ℓ → L) (t : ↥L⦃≤ 1⦄[X Fin ℓ]) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
abbrev IntermediateCoeffVecSpace (i : Fin r) in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
instance instMonadLift_left_right {ι₁ ι₂ ι₃ : Type} in ArkLib/ToVCVio/Simulation.lean
lemma NTTStage_correctness (i : Fin (ℓ)) in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
lemma multilinearWeight_succ {ϑ : ℕ} (r : Fin (ϑ + 1) → F) (i : Fin (2 ^ (ϑ + 1))) : in ArkLib/Data/CodingTheory/Prelims.lean
lemma multilinearWeight_succ_upper_half {n : ℕ} in ArkLib/Data/CodingTheory/Prelims.lean
lemma natDegree_intermediateNormVpoly (i : Fin r) {k : ℕ} (h_k : i.val + k ≤ ℓ) : in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
def blockDiagMatrix (n : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
lemma oracle_index_add_steps_le_ℓ (i : Fin (ℓ + 1)) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
lemma mergeFinMap_PO2_of_split_left_right {L : Type*} {n : ℕ} (v : Fin (2 ^ (n + 1)) → L) : in ArkLib/Data/Fin/BigOperators.lean
lemma mem_support_simulateQ_liftQuery_iff in ArkLib/ToVCVio/Lemmas.lean
def ForInStep.state : ForInStep σ → σ in ArkLib/ToVCVio/Simulation.lean
lemma challengeTensorExpansionMatrix_mulVec_F₂_eq_Fin_merge_PO2 [CommRing L] (n : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
theorem castInOut_rbrKnowledgeSoundness in ArkLib/OracleReduction/Cast.lean
def oraclePositionToDomainIndex {i : Fin (ℓ + 1)} in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
lemma neverFail_vector_mapM in ArkLib/ToVCVio/Simulation.lean
lemma OptionT.probFailure_mk_forIn_eq_zero_of_body_safe in ArkLib/ToVCVio/Simulation.lean
theorem base_intermediateNovelBasisX (j : Fin (2 ^ ℓ)) : in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
lemma getSumcheckRoundPoly_sum_eq (i : Fin ℓ) (h : ↥L⦃≤ 2⦄[X Fin (ℓ - ↑i.castSucc)]) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
lemma val_mkFromStmtIdxCastSuccOfSucc {ℓ : ℕ} (i : Fin ℓ) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
lemma neverFails_of_simulateQ_mk in ArkLib/ToVCVio/Simulation.lean
lemma Sdomain_bound {x : ℕ} (h_x : x ≤ ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
theorem intermediateChangeOfBasisMatrix_det_ne_zero (i : Fin r) (h_i : i ≤ ℓ) : in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
lemma extractSuffixFromChallenge_congr_destIdx in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean
lemma exists_eq_some_of_mem_support_of_probOutput_none_eq_zero in ArkLib/ToVCVio/Lemmas.lean
def getLastOraclePositionIndex (i : Fin (ℓ + 1)) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
lemma simOracle2_impl_inr_inr in ArkLib/ToVCVio/Simulation.lean
instance instInhabitedOracleSpecEmpty : (([]ₒ : OracleSpec PEmpty).Inhabited) where in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean
lemma projectToMidSumcheckPoly_eq_prod (t : MultilinearPoly L ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
theorem sDomainFin_bijective (i : Fin r) (h_i : i < ℓ + R_rate) in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
lemma iterated_fold_congr_dest_index in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
def commitStepLogic (i : Fin ℓ) (hCR : isCommitmentRound ℓ ϑ i) : in ArkLib/ProofSystem/Binius/BinaryBasefold/ReductionLogic.lean
lemma k_succ_mul_ϑ_le_ℓ_₂ {k : Fin (ℓ / ϑ)} : (k.val * ϑ + ϑ) ≤ ℓ in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean
lemma mem_support_map_prod_mk_iff [LawfulMonad m] in ArkLib/ToVCVio/Lemmas.lean
lemma OptionT.support_failure_run in ArkLib/ToVCVio/Simulation.lean
lemma h_oracle_size_eq_relay (i : Fin ℓ) (hNCR : ¬ isCommitmentRound ℓ ϑ i) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps.lean
def OracleAwareReductionLogicStep.IsStronglyCompleteUnderSimulation in ArkLib/ProofSystem/Binius/BinaryBasefold/ReductionLogic.lean
lemma probOutput_none_pure_some_eq_zero in ArkLib/ToVCVio/Lemmas.lean
instance instInhabitedPSpecBatchingMessage : [(pSpecBatching κ L K).Message]ₒ.Inhabited in ArkLib/ProofSystem/Binius/RingSwitching/Spec.lean
def BBF_Code (i : Fin r) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
theorem probFailure_simulateQ_iff_stateful_run' in ArkLib/ToVCVio/Simulation.lean
def sumcheckProverWitOut (_stmtIn : Statement (L in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean
lemma Prover.processRound_P_to_V (j : Fin n) in ArkLib/ToVCVio/Simulation.lean
lemma support_challengeQueryImpl_run_eq {n : ℕ} {pSpec : ProtocolSpec n} {σ : Type} in ArkLib/ToVCVio/Simulation.lean
lemma OptionT.simulateQ_failure in ArkLib/ToVCVio/Simulation.lean
lemma getLastOraclePositionIndex_last : getLastOraclePositionIndex ℓ ϑ (Fin.last ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
lemma oracle_block_k_le_i (i : Fin (ℓ + 1)) (j : Fin (toOutCodewordsCount ℓ ϑ i)) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
def finalSumcheckStepLogic : in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean
def getLastOracleDomainIndex (oracleFrontierIdx : Fin (ℓ + 1)) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
lemma OptionT.mem_support_run_vector_mapM_some {ι : Type} {spec : OracleSpec ι} in ArkLib/ToVCVio/Simulation.lean
lemma nonLastSingleBlockOracleReduction_perfectCompleteness in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean
instance instFintypePSpecQuery_AllChallenges: in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean
theorem unroll_0_message_reduction_perfectCompleteness in ArkLib/OracleReduction/Completeness.lean
lemma probFailure_liftComp_eq {ι' : Type} {superSpec : OracleSpec ι'} in ArkLib/ToVCVio/Lemmas.lean
lemma mem_support_simulateQ_id'_liftM_query {ι : Type*} {spec : OracleSpec ι} in ArkLib/ToVCVio/Simulation.lean
lemma val_mkFromStmtIdx {ℓ : ℕ} (stmtIdx : Fin (ℓ + 1)) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
theorem iteratedQuotientMap_k_eq_1_is_qMap (i : Fin r) {destIdx : Fin r} in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
lemma snoc_oracle_eq_mkVerifierOStmtOut_commitStep in ArkLib/ProofSystem/Binius/BinaryBasefold/ReductionLogic.lean
lemma OptionT.simulateQ_simOracle2_liftM_query_T1 in ArkLib/ToVCVio/Simulation.lean
lemma polyToOracleFunc_eq_getFirstOracle in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean
lemma eval_point_ω_eq_next_twiddleFactor_comp_qmap in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
instance instFintypePspecCommitChallenge {i : Fin ℓ}: [((pSpecCommit 𝔽q β (h_ℓ_add_R_rate in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean
lemma neverFails_of_simulateQ_stateful_run'_mk in ArkLib/ToVCVio/Simulation.lean
lemma support_simulateQ_run'_eq in ArkLib/ToVCVio/Simulation.lean
lemma OptionT.simulateQ_map' {α β : Type u} in ArkLib/ToVCVio/Simulation.lean
instance instInhabitedPSpecQueryMessage : in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean
lemma projectToMidSumcheckPoly_succ (t : MultilinearPoly L ℓ) (m : MultilinearPoly L ℓ) (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
instance instInhabitedFullPSpecMessage : in ArkLib/ProofSystem/Binius/RingSwitching/Spec.lean
lemma mem_support_bind_iff {m : Type u → Type v} [Monad m] [HasEvalSPMF m] in ArkLib/ToVCVio/Lemmas.lean
lemma support_bind {m : Type u → Type v} [Monad m] [HasEvalSPMF m] in ArkLib/ToVCVio/Lemmas.lean
def disagreementSet (i : Fin r) in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
lemma probFailure_simulateQ_liftQuery_eq in ArkLib/ToVCVio/Lemmas.lean
lemma Matrix.from4Blocks_mul_from4Blocks {mTop mBot pLeft pRight nLeft nRight : ℕ} {α : Type*} in ArkLib/Data/Fin/BigOperators.lean
lemma probFailure_mk_do_bind_eq_zero_iff {m : Type u → Type v} [Monad m] [HasEvalSPMF m] in ArkLib/ToVCVio/Lemmas.lean
theorem additiveNTT_correctness (h_ℓ : ℓ ≤ r) in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
def finalSumcheckProverComputeMsg in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean
instance instFintypePSpecFinalSumcheckStepMessage : in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean
lemma mkLastOracleIndex_eq_getLastOraclePositionIndex (i : Fin (ℓ + 1)) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
lemma fun_eta_expansion {α β : Type*} (f : α → β) : f = (fun x => f x) in ArkLib/Data/Misc/Basic.lean
lemma compute_A_MLE_eval_eq_final_eq_value in ArkLib/ProofSystem/Binius/RingSwitching/Prelude.lean
def commitStepLogic_embed_inj (i : Fin ℓ) (hCR : isCommitmentRound ℓ ϑ i) : in ArkLib/ProofSystem/Binius/BinaryBasefold/ReductionLogic.lean
theorem castInOut_completeness in ArkLib/OracleReduction/Cast.lean
lemma single_point_localized_fold_matrix_form_congr_source_index in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
theorem intermediateNormVpoly_comp_qmap_helper (i : Fin r) (h_i : i < ℓ) in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
lemma dist_to_UDRCodeword_le_uniqueDecodingRadius (i : Fin r) (h_i : i ≤ ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
def queryPhaseProverState : Fin (1 + 1) → Type in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean
instance instInhabitedPSpecFinalSumcheckMessage : [(pSpecFinalSumcheck (L in ArkLib/ProofSystem/Binius/RingSwitching/Spec.lean
lemma projectToNextSumcheckPoly_sum_eq (i : Fin ℓ) (Hᵢ : MultiquadraticPoly L (ℓ - i)) (rᵢ : L) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
lemma support_simulateQ_eq (so : QueryImpl spec ProbComp) (oa : OracleComp spec α) 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
lemma probFailure_liftM {ι' : Type w} {superSpec : OracleSpec ι'} in ArkLib/ToVCVio/Lemmas.lean
lemma mem_support_run_iff {m : Type u → Type v} [Monad m] [HasEvalSPMF m] in ArkLib/ToVCVio/Lemmas.lean
theorem run'_pure_lib [Monad m] [LawfulMonad m] (x : α) (s : σ) : in ArkLib/ToVCVio/Lemmas.lean
lemma oracle_block_k_next_le_i (i : Fin (ℓ + 1)) (j : Fin (toOutCodewordsCount ℓ ϑ i)) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
lemma neverFail_map_iff' [spec.Fintype] [spec.Inhabited] in ArkLib/ToVCVio/Lemmas.lean
def mkFromStmtIdxCastSuccOfSucc {ℓ : ℕ} (i : Fin ℓ) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean
lemma probEvent_pure_iff {α : Type} (p : α → Prop) (x : α) : in ArkLib/ToVCVio/Lemmas.lean
theorem castOutSimple_id in ArkLib/OracleReduction/Cast.lean
lemma support_forIn_subset_rel_yield_only in ArkLib/ToVCVio/Simulation.lean
lemma sumcheckConsistency_at_last_simplifies in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean
lemma simulateQ_liftComp in ArkLib/ToVCVio/Simulation.lean
instance instInhabitedPSpecBatchingChallenge : in ArkLib/ProofSystem/Binius/RingSwitching/Spec.lean
lemma OptionT.simulateQ_ite in ArkLib/ToVCVio/Simulation.lean
lemma Matrix.reindex_mul_reindex {l m n o p q : Type*} [Fintype n] [Fintype p] in ArkLib/Data/Fin/BigOperators.lean
def decomposeChallenge (v : sDomain 𝔽q β h_ℓ_add_R_rate ⟨0, by omega⟩) in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean
theorem qMap_eval_𝔽q_eq_0 (i : Fin r) : in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
instance instFintypePSpecRelayChallenge : in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean
def Nat.boundedRecOn {r : ℕ} {motive : (k : ℕ) → k < r → Sort _} in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
theorem neverFails_simOracle {ι : Type u} (oSpec : OracleSpec ι) in ArkLib/OracleReduction/OracleInterface.lean
instance instFintypePSpecFinalSumcheck_AllChallenges : ∀ i, Fintype ((pSpecFinalSumcheck (L in ArkLib/ProofSystem/Binius/RingSwitching/Spec.lean
lemma probFailure_liftComp {ι' : Type w} {superSpec : OracleSpec ι'} in ArkLib/ToVCVio/Lemmas.lean
def intermediateToCoeffsVec (i : Fin r) : -- (h_i : i ≤ ℓ) in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
lemma Reduction_run_def (reduction : Reduction oSpec StmtIn WitIn StmtOut WitOut pSpec) in ArkLib/ToVCVio/Simulation.lean
lemma Prover.processRound_V_to_P (j : Fin n) in ArkLib/ToVCVio/Simulation.lean
def fiberEvaluations (i : Fin r) {destIdx : Fin r} (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean
def bitsOfIndex {n : ℕ} (k : Fin (2 ^ n)) : Fin n → L in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.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 mem_ite_singleton {α : Type*} {c : Prop} [Decidable c] {a b x : α} : in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps.lean
lemma probFailure_mk_bind_eq_zero_iff {m : Type u → Type v} [Monad m] [HasEvalSPMF m] in ArkLib/ToVCVio/Lemmas.lean
lemma OptionT.simulateQ_forIn in ArkLib/ToVCVio/Simulation.lean
lemma iterated_fold_preserves_BBF_Code_membership (i : Fin r) {destIdx : Fin r} (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
lemma liftComp_forIn {ι ι' : Type} {spec : OracleSpec ι} {superSpec : OracleSpec ι'} in ArkLib/ToVCVio/Simulation.lean
lemma checkSingleRepetition_probFailure_eq_zero in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean
lemma initial_tiled_coeffs_correctness (h_ℓ : ℓ ≤ r) (a : Fin (2 ^ ℓ) → L) : in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
lemma finalSumcheckStep_verifierCheck_passed in ArkLib/ProofSystem/Binius/BinaryBasefold/ReductionLogic.lean
lemma Matrix.det_fromBlocks_of_squareSubblocks_commute {n : ℕ} {R : Type*} [CommRing R] in ArkLib/Data/Fin/BigOperators.lean
lemma qMap_ne_zero (i : Fin r) : (qMap 𝔽q β i) ≠ 0 in ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean
def fiberwiseClose (i : Fin r) {destIdx : Fin r} (steps : ℕ) [NeZero steps] in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean
lemma probFailure_simulateQ_liftQuery_add_none_eq in ArkLib/ToVCVio/Lemmas.lean
lemma Transcript.equiv_eval (tr : pSpec.FullTranscript) : in ArkLib/ToVCVio/Simulation.lean

✏️ **Affected:** 38 declaration(s) (line number changed)

theorem iterated_fold_eq_matrix_form (i : Fin r) {destIdx : Fin r} (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean moved from L926 to L1800
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 L816
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 L726
def localized_fold_matrix_form (i : Fin r) {destIdx : Fin r} (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean moved from L896 to L1671
def foldMatrix (i : Fin r) {destIdx : Fin r} (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean moved from L776 to L1285
theorem batchingReduction_perfectCompleteness (hInit : NeverFail init) : in ArkLib/ProofSystem/Binius/RingSwitching/BatchingPhase.lean moved from L314 to L509
def projectToMidSumcheckPoly (t : MultilinearPoly L ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean moved from L392 to L636
abbrev OracleFunction (domainIdx : Fin r) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean moved from L234 to L437
def sumcheckFoldOracleReduction : OracleReduction []ₒ in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean moved from L501 to L773
def iterated_fold (i : Fin r) (steps : ℕ) {destIdx : Fin r} in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean moved from L789 to L1383
def batchingInputRelation : in ArkLib/ProofSystem/Binius/RingSwitching/BatchingPhase.lean moved from L198 to L90
theorem coreInteractionOracleReduction_perfectCompleteness (hInit : NeverFail init) in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean moved from L625 to L1234
lemma qMap_total_fiber_one_level_eq (i : Fin r) {destIdx : Fin r} in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean moved from L384 to L646
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 L786
theorem commitOracleReduction_perfectCompleteness (hInit : NeverFail init) (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps.lean moved from L516 to L651
def projectToNextSumcheckPoly (i : Fin (ℓ)) (Hᵢ : MultiquadraticPoly L (ℓ - i)) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean moved from L407 to L651
theorem foldOracleReduction_perfectCompleteness (hInit : NeverFail init) (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps.lean moved from L217 to L175
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 L1166
theorem sumcheckFoldOracleReduction_perfectCompleteness (hInit : NeverFail init) : in ArkLib/ProofSystem/Binius/FRIBinius/CoreInteractionPhase.lean moved from L201 to L203
def pointToIterateQuotientIndex (i : Fin r) {destIdx : Fin r} (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean moved from L367 to L628
theorem coreInteraction_perfectCompleteness (hInit : NeverFail init) : in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean moved from L592 to L1298
theorem iteratedSumcheckOracleReduction_perfectCompleteness (i : Fin ℓ') (hInit : NeverFail init) : in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean moved from L198 to L323
theorem relayOracleReduction_perfectCompleteness (hInit : NeverFail init) (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps.lean moved from L693 to L1037
def computeInitialSumcheckPoly (t : MultilinearPoly L ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean moved from L376 to L619
theorem fullOracleReduction_perfectCompleteness (hInit : NeverFail init) : in ArkLib/ProofSystem/Binius/FRIBinius/General.lean moved from L175 to L178
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 L1010
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 L990
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 L112
lemma qMap_total_fiber_repr_coeff (i : Fin r) {destIdx : Fin r} (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean moved from L343 to L602
theorem card_qMap_total_fiber (i : Fin r) {destIdx : Fin r} (steps : ℕ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean moved from L597 to L855
def batchingInputRelationProp (stmt : BatchingStmtIn L ℓ) in ArkLib/ProofSystem/Binius/RingSwitching/BatchingPhase.lean moved from L191 to L83
def getFirstOracle {oracleFrontierIdx : Fin (ℓ + 1)} in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean moved from L771 to L1038
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 L1024
theorem sumcheckFoldOracleReduction_perfectCompleteness (hInit : NeverFail init) : in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean moved from L547 to L1064
theorem fullOracleReduction_perfectCompleteness (hInit : NeverFail init) : in ArkLib/ProofSystem/Binius/RingSwitching/General.lean moved from L119 to L121
theorem coreInteractionOracleReduction_perfectCompleteness (hInit : NeverFail init) : in ArkLib/ProofSystem/Binius/FRIBinius/CoreInteractionPhase.lean moved from L645 to L645
lemma batchingCore_perfectCompleteness (hInit : NeverFail init) : in ArkLib/ProofSystem/Binius/RingSwitching/General.lean moved from L106 to L108

sorry Tracking

✅ **Removed:** 13 `sorry`(s)

lemma single_point_localized_fold_matrix_form_congr_dest_index in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean (L937)
def foldMatrix (i : Fin r) (steps : Fin (ℓ + 1)) (h_i_add_steps : i.val + steps < ℓ + 𝓡) in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean (L786)
theorem batchingReduction_perfectCompleteness (hInit : NeverFail init) : in ArkLib/ProofSystem/Binius/RingSwitching/BatchingPhase.lean (L323)
theorem finalSumcheckOracleReduction_perfectCompleteness {σ : Type} in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean (L450)
theorem commitOracleReduction_perfectCompleteness (hInit : NeverFail init) (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps.lean (L530)
theorem foldOracleReduction_perfectCompleteness (hInit : NeverFail init) (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps.lean (L231)
theorem finalSumcheckOracleReduction_perfectCompleteness {σ : Type} in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps.lean (L924)
theorem relayOracleReduction_perfectCompleteness (hInit : NeverFail init) (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps.lean (L708)
theorem iteratedSumcheckOracleReduction_perfectCompleteness (i : Fin ℓ') (hInit : NeverFail init) : in ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean (L209)
theorem queryOracleProof_perfectCompleteness {σ : Type} in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean (L341)
theorem sumcheckFoldOracleReduction_perfectCompleteness (hInit : NeverFail init) : in ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean (L558)
lemma nonDoomedFoldingProp_relay_preserved (i : Fin ℓ) (hNCR : ¬ isCommitmentRound ℓ ϑ i) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean (L944)
theorem OracleReduction.id_runWithLog (stmt : StmtIn) (oStmt : ∀ i, OStmtIn i) (wit : WitIn) : in ArkLib/OracleReduction/Execution.lean (L382)

❌ **Added:** 65 `sorry`(s)

lemma query_phase_consistency_guard_safe in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean (L742)
instance instFintypePSpecFinalSumcheckChallenge : in ArkLib/ProofSystem/Binius/RingSwitching/Spec.lean (L204)
lemma fixFirstVariablesOfMQP_full_eval_eq_eval {deg : ℕ} {challenges : Fin (Fin.last ℓ) → L} in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean (L713)
instance instFintypePSpecBatching_AllChallenges : in ArkLib/ProofSystem/Binius/RingSwitching/Spec.lean (L217)
instance instInhabitedPSpecFoldChallenge : [(pSpecFold (L in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean (L498)
instance : ∀ i, ∀ j, Inhabited in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean (L504)
instance : ([(pSpecFold (L in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean (L511)
instance instFintypePSpecQueryChallenge : [(pSpecQuery 𝔽q β γ_repetitions in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean (L526)
lemma constFunc_UDRClose {i : Fin r} (h_i : i ≤ ℓ) (c : L) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean (L198)
instance instInhabitedPSpecQueryMessage : in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean (L490)
lemma projectToMidSumcheckPoly_eq_prod (t : MultilinearPoly L ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean (L707)
instance instInhabitedPSpecLargeFieldReductionMessage : in ArkLib/ProofSystem/Binius/RingSwitching/Spec.lean (L170)
instance instInhabitedPSpecBatchingChallenge : in ArkLib/ProofSystem/Binius/RingSwitching/Spec.lean (L192)
lemma projectToMidSumcheckPoly_succ (t : MultilinearPoly L ℓ) (m : MultilinearPoly L ℓ) (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean (L699)
instance instInhabitedFullPSpecMessage : in ArkLib/ProofSystem/Binius/RingSwitching/Spec.lean (L174)
lemma multilinear_eval_eq_sum_bool_hypercube (challenges : Fin ℓ → L) (t : ↥L⦃≤ 1⦄[X Fin ℓ]) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean (L416)
instance instFintypePSpecFinalSumcheckStepChallenge : in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean (L520)
instance instFintypeOracleStatementFinLast : in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean (L552)
lemma simulateQ_vector_mapM {ι ι' : Type} {spec : OracleSpec ι} {superSpec : OracleSpec ι'} in ArkLib/ToVCVio/Simulation.lean (L1551)
instance instFintypePSpecRelayChallenge : in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean (L545)
instance instInhabitedPSpecSumcheckRoundMessage : [(pSpecSumcheckRound (L in ArkLib/ProofSystem/Binius/RingSwitching/Spec.lean (L156)
lemma query_phase_step_preserves_fold in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean (L963)
lemma query_phase_step_preserves_fold in ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean (L1153)
instance instOracleStatementFiniteRange {i : Fin (ℓ + 1)} : in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean (L514)
lemma getMidCodewords_succ (t : L⦃≤ 1⦄[X Fin ℓ]) (i : Fin ℓ) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean (L1173)
instance instFintypePSpecQueryMessage : in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean (L555)
instance instInhabitedPSpecFinalSumcheckStepChallenge : in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean (L523)
instance instFintypePSpecFinalSumcheckStepMessage : in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean (L561)
instance instInhabitedPSpecFinalSumcheckChallenge : in ArkLib/ProofSystem/Binius/RingSwitching/Spec.lean (L208)
lemma OptionT.simulateQ_vector_mapM {ι ι' : Type} {spec : OracleSpec ι} {superSpec : OracleSpec ι'} in ArkLib/ToVCVio/Simulation.lean (L1617)
instance instFintypePspecCommitChallenge {i : Fin ℓ}: [((pSpecCommit 𝔽q β (h_ℓ_add_R_rate in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean (L534)
lemma Reduction_run_def (reduction : Reduction oSpec StmtIn WitIn StmtOut WitOut pSpec) in ArkLib/ToVCVio/Simulation.lean (L554)
instance instInhabitedPSpecQueryChallenge : in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean (L529)
lemma compute_A_MLE_eval_eq_final_eq_value in ArkLib/ProofSystem/Binius/RingSwitching/Prelude.lean (L440)
instance instInhabitedPSpecBatchingMessage : [(pSpecBatching κ L K).Message]ₒ.Inhabited in ArkLib/ProofSystem/Binius/RingSwitching/Spec.lean (L153)
instance instFintypePSpecFinalSumcheck_AllChallenges: ∀ i, Fintype ((pSpecFinalSumcheckStep (L in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean (L516)
lemma batching_target_consistency in ArkLib/ProofSystem/Binius/RingSwitching/Prelude.lean (L489)
instance instInhabitedPSpecRelayMessage : [(pSpecRelay).Message]ₒ.Inhabited where in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean (L478)
instance instInhabitedPSpecSumcheckLoopMessage : [(pSpecSumcheckLoop (L in ArkLib/ProofSystem/Binius/RingSwitching/Spec.lean (L159)
lemma mem_support_vector_mapM {n} {f : α → OracleComp spec β} {as : Vector α n} {x : Vector β n} : in ArkLib/ToVCVio/Simulation.lean (L1554)
instance instFintypePSpecRelay_AllChallenges: ∀ i, Fintype ((pSpecRelay).Challenge i) in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean (L539)
instance instFintypePspecCommit_AllChallenges {i : Fin ℓ}: in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean (L532)
instance instFintypePSpecBatchingChallenge : in ArkLib/ProofSystem/Binius/RingSwitching/Spec.lean (L188)
instance instInhabitedPSpecBatching_AllChallenges : in ArkLib/ProofSystem/Binius/RingSwitching/Spec.lean (L224)
lemma OptionT.simulateQ_forIn in ArkLib/ToVCVio/Simulation.lean (L1536)
instance instInhabitedPSpecFold_AllChallenges: ∀ i, Inhabited ((pSpecFold (L in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean (L493)
instance instFintypePSpecSumcheckRoundChallenge : in ArkLib/ProofSystem/Binius/RingSwitching/Spec.lean (L180)
instance instInhabitedPSpecFinalSumcheckStepMessage : in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean (L482)
instance {i : Fin ℓ} : in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean (L486)
instance instInhabitedPSpecRelayChallenge : in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean (L548)
def commitKState (i : Fin ℓ) (hCR : isCommitmentRound ℓ ϑ i) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Steps.lean (L903)
lemma OptionT.liftComp_forIn {ι ι' : Type _} {spec : OracleSpec ι} {superSpec : OracleSpec ι'} in ArkLib/ToVCVio/Simulation.lean (L1494)
lemma OptionT.mem_support_vector_mapM {ι : Type} {spec : OracleSpec ι} in ArkLib/ToVCVio/Simulation.lean (L1626)
instance instInhabitedOracleStatement {i : Fin (ℓ + 1)} : in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean (L475)
instance instInhabitedPSpecFinalSumcheckMessage : [(pSpecFinalSumcheck (L in ArkLib/ProofSystem/Binius/RingSwitching/Spec.lean (L162)
lemma projectToNextSumcheckPoly_eval_eq (i : Fin ℓ) (Hᵢ : MultiquadraticPoly L (ℓ - i)) (rᵢ : L) in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean (L671)
lemma projectToNextSumcheckPoly_sum_eq (i : Fin ℓ) (Hᵢ : MultiquadraticPoly L (ℓ - i)) (rᵢ : L) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean (L693)
instance instFintypePSpecQuery_AllChallenges: in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean (L558)
instance instInhabitedPSpecCoreInteractionMessage : in ArkLib/ProofSystem/Binius/RingSwitching/Spec.lean (L166)
instance instInhabitedPspecCommitChallenge {i : Fin ℓ}: in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean (L537)
lemma batching_check_correctness in ArkLib/ProofSystem/Binius/RingSwitching/Prelude.lean (L346)
lemma UDRCodeword_constFunc_eq_self (i : Fin r) (h_i : i ≤ ℓ) (c : L) : in ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean (L273)
instance instInhabitedPSpecSumcheckRoundChallenge : in ArkLib/ProofSystem/Binius/RingSwitching/Spec.lean (L184)
instance instFintypePSpecFold_AllChallenges: ∀ i, Fintype ((pSpecFold (L in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean (L492)
instance instFintypePSpecFoldChallenge : [(pSpecFold (L in ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean (L496)

🎨 **Style Guide Adherence**

This code review is based on the ArkLib Lean 4 Style Guide.

The provided diff contains several violations of the style guide, particularly regarding naming conventions for terms, theorems, and acronyms, as well as formatting rules for operators and empty lines.

1. Spacing and Operators

The guide requires: "Put spaces on both sides of :, :=, and infix operators. Place them before a line break rather than at the start of the next line." There are more than 20 violations of this rule.

Missing spaces around : (Type ascription):
- ∀ c: 𝔽q (AdditiveNTT.lean:64)
- let v: Fin (2^i.val) (AdditiveNTT.lean:1645)
- let mut c_cur : L := 0 (QueryPhase.lean:337)
- x_1: Fin (AdditiveNTT.lean:1836)
Missing spaces around := (Named arguments/Let-bindings):
- (x:=j.val) (AdditiveNTT.lean:1625)
- (n:=ℓ) (AdditiveNTT.lean:1722)
- (numLowBits:=i.val) (AdditiveNTT.lean:1646)
- (f:= fun (AdditiveNTT.lean:1722)
Missing spaces around infix operators (^, +, *):
- 2^i.val (AdditiveNTT.lean:1645, 1649, 1685)
- (j: Fin (2^(ℓ + R_rate))) (AdditiveNTT.lean:1640, 1720)
- ...)^(Fintype.card 𝔽q) (AdditiveNTT.lean:140)

2. Naming Conventions: Terms and Functions

The guide requires: "Functions and Terms: lowerCamelCase (e.g., binarySearch, isPrime)."

Violation (Snake Case in Terms):
- V_i (AdditiveNTT.lean:400, 422, 432)
- W_i_map (AdditiveNTT.lean:402, 424)
- V_i_basis (AdditiveNTT.lean:447, 475)
- P_i (AdditiveNTT.lean:1599)
- P_even_i_plus_1 (AdditiveNTT.lean:1600)
- P_odd_i_plus_1 (AdditiveNTT.lean:1601)
- q_i (AdditiveNTT.lean:1602)
- h_V_check_is_true (ReductionLogic.lean:1356)

3. Naming Conventions: Theorems and Proofs

The guide requires: "Theorems and Proofs: snake_case (e.g., add_comm, list_reverse_id)."

Violation (Mixed Case):
- qMap_is_linear_map (AdditiveNTT.lean:207) — should be q_map_is_linear_map.
- qMap_comp_normalizedW (AdditiveNTT.lean:172) — should be q_map_comp_normalized_w.
- qMap_maps_sDomain (AdditiveNTT.lean:263) — should be q_map_maps_s_domain.
- base_intermediateNormVpoly (AdditiveNTT.lean:701) — should be base_intermediate_norm_vpoly.
- iteratedQuotientMap_k_eq_1_is_qMap (AdditiveNTT.lean:874)
- getSDomainBasisCoeff_of_sum_repr (AdditiveNTT.lean:893)

4. Acronyms

The guide requires: "Acronyms: Treat as words (HtmlParser not HTMLParser)."

Violation:
- getINovelCoeffs (AdditiveNTT.lean:1152) — should be getInovelCoeffs.
- BBF_Code (Code.lean:16, 21, 33) — should be BbfCode.
- BBF_CodeDistance (Code.lean:45, 51) — should be BbfCodeDistance.

5. Syntax and Formatting

Empty lines inside definitions/proofs:
The guide requires: "Avoid empty lines inside definitions or proofs."
- AdditiveNTT.lean: Lines 80, 131, 566, 906, 1146.
Variable Conventions:
The guide requires: "Natural numbers: m, n, k. Integers/Indices: i, j, k."
- iLeft, iRight (BigOperators.lean:115, 123) — violate standard index conventions.
- mTop, nLeft, mBot, nRight (BigOperators.lean:245) — violate convention.

6. Standardized Inequalities

The guide requires: "In conclusions, use ⊥ < x (more powerful result) ... standardization on ≤ (le) and < (lt). Avoid ≥ (ge) and > (gt) in theorem statements."

Violation:
- ... ≥ 2 (AdditiveNTT.lean:163) — inside a proof, but statements like Fintype.card 𝔽q ≥ 2 should be 2 ≤ Fintype.card 𝔽q.
- ... ≥ (BBF_CodeDistance ...) (Code.lean:941) — in the type definition of h_far.

📄 **Per-File Summaries**

ArkLib/Data/CodingTheory/Prelims.lean: This file introduces new theorems establishing the inductive properties of multilinearWeight, providing lemmas for its recursive decomposition into lower and upper half components based on bitwise structure.
ArkLib/Data/CodingTheory/ReedSolomon.lean: This change introduces a new instance, instNontrivial, which proves that Reed-Solomon codes are nontrivial by demonstrating the existence of a non-zero constant codeword.
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/Misc/Basic.lean: This file introduces new lemmas concerning function eta expansion and the interaction between function casting and argument casting across type equalities.
ArkLib/OracleReduction/Basic.lean: This change refactors oracle statement routing in the toVerifier definition by introducing the mkVerifierOStmtOut helper and associated simp lemmas, while also adding a utility definition for constructing single-round protocol transcripts.
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/Execution.lean: This change refactors the OracleVerifier.run definition using a new helper function and completes several proofs related to the execution of oracle reductions by replacing sorry placeholders with formal simp proofs.
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 Lean file modifies the proofs for Verifier.StateFunction.id and Verifier.KnowledgeStateFunction.id to utilize updated support lemmas for OptionT and monadic binds, improving proof structure and maintainability.
ArkLib/ProofSystem/Binius/BinaryBasefold/Basic.lean: This file introduces new definitions for oracle frontier indexing and sumcheck projections, adds several lemmas for oracle domain bounds, and bifurcates protocol relations into strict versions for perfect completeness and relaxed versions for knowledge soundness.
ArkLib/ProofSystem/Binius/BinaryBasefold/Code.lean: This file introduces the core coding-theoretic foundations for the Binary Basefold protocol, defining the Reed-Solomon code structures, unique decoding radius properties, and codeword folding operations alongside theorems and definitions for protocol compliance and soundness analysis.
ArkLib/ProofSystem/Binius/BinaryBasefold/CoreInteractionPhase.lean: This change refines the compositional structure of the Binary Basefold core interaction phase by introducing helper lemmas and explicit type-casting operations (castInOut) to resolve index-based type mismatches. It provides complete proofs for the perfect completeness of individual protocol blocks and the aggregate sumcheck fold reduction, effectively removing a previous sorry, though sorry placeholders remain in the round-by-round knowledge soundness theorems.
ArkLib/ProofSystem/Binius/BinaryBasefold/General.lean: This change updates the Binary Basefold fullOracleVerifier and its associated security theorems to incorporate missing parameters and transition to strict relation definitions. Specifically, the fullOracleReduction_perfectCompleteness theorem is modified to require a NeverFail assumption and now utilizes strictRoundRelation and strictFinalSumcheckRelOut in its proof.
ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean: This Lean file refines the formalization of the Binary Basefold protocol's folding mechanism by introducing new definitions for fiber-wise evaluations and recursive fold matrices, while proving key theorems regarding the matrix-vector representation of iterated folding and its consistency with polynomial evaluation.
ArkLib/ProofSystem/Binius/BinaryBasefold/Spec.lean: This update expands the Binary Basefold protocol specification by adding numerous OracleInterface, Fintype, and Inhabited instances for various message and challenge types, alongside a new heterogeneous equality lemma. Several protocol definitions are now marked @[reducible] to facilitate type class resolution. Notably, many of the newly introduced instances are currently stubbed with sorry placeholders.
ArkLib/ProofSystem/Binius/BinaryBasefold/Steps.lean: This Lean file refactors the Binary Basefold protocol steps by delegating prover and verifier operations to modular logic instances for improved consistency. It introduces new definitions and theorems regarding the perfect completeness of fold, commit, relay, and final sumcheck reductions; however, several proofs and property specifications currently contain sorry placeholders.
ArkLib/ProofSystem/Binius/FRIBinius/General.lean: This update refines the Binius FRI protocol definitions and proofs by explicitly incorporating basis parameters (𝓑) into the oracle verifiers and reductions. It modifies the fullOracleReduction_perfectCompleteness theorem to require a NeverFail hypothesis and utilize a stricter sumcheck output relation. No sorry or admit placeholders were introduced.
ArkLib/ProofSystem/Binius/RingSwitching/BatchingPhase.lean: This change refactors the batching phase by extracting its core logic into a ReductionLogicStep instance and introducing pure prover/verifier kernels to separate logical steps from monadic operations. It introduces the batchingStep_is_logic_complete lemma and provides a formal proof for batchingReduction_perfectCompleteness, successfully removing a previously existing sorry placeholder.
ArkLib/ProofSystem/Binius/RingSwitching/General.lean: This file updates the Binius ring-switching protocol by explicitly propagating the basis embedding 𝓑 through the verifier and reduction definitions. It also refines the perfect completeness proofs by adding a NeverFail hypothesis for the initialization process and updates internal calls to reflect naming changes in the batching phase. No sorry or admit placeholders were introduced.
ArkLib/ProofSystem/Binius/RingSwitching/Prelude.lean: This update introduces three new lemmas—batching_check_correctness, compute_A_MLE_eval_eq_final_eq_value, and batching_target_consistency—which define the core correctness and consistency properties for the Binius Ring Switching protocol's batching and sumcheck procedures. All three lemmas currently contain sorry placeholders for their underlying mathematical proofs.
ArkLib/ProofSystem/Binius/RingSwitching/Spec.lean: This module expands the protocol specifications for Ring-Switching by adding OracleInterface and SampleableType instances for challenges across the protocol's sub-components. It introduces numerous Inhabited and Fintype instances for oracle specifications and challenge types, many of which are currently implemented with sorry placeholders.
ArkLib/ProofSystem/Binius/RingSwitching/SumcheckPhase.lean: This update refactors the sumcheck and final sumcheck protocol rounds into modular ReductionLogicStep instances, abstracting prover and verifier logic into pure functions. These changes facilitate the formal verification of the protocol, replacing several sorry placeholders in the perfect completeness theorems with complete proofs, though a sorry remains in the round-by-round knowledge soundness theorem.
ArkLib/ProofSystem/Component/CheckClaim.lean: This change modifies the proof of the reduction_completeness theorem in the Lean file ArkLib/ProofSystem/Component/CheckClaim.lean by disabling the aesop tactic.
ArkLib/ProofSystem/Component/ReduceClaim.lean: This change marks the proof of the reduction_completeness theorem as incomplete by commenting out the existing tactic script and introducing a sorry placeholder.
ArkLib/ProofSystem/Component/SendWitness.lean: This change modifies the reduction_completeness theorem by commenting out its automated proof and introducing a sorry placeholder. The primary intent is to mark the completeness property for the witness sending component as an unfinished proof obligation.
ArkLib.lean: This update expands the library's top-level namespace by importing several new modules related to additive NTTs, oracle reduction completeness, and components of the Binius binary basefold proof system. These changes integrate new definitions and theorems concerning field theory and proof system reduction logic into the main library.
ArkLib/ProofSystem/Binius/FRIBinius/CoreInteractionPhase.lean: This update refines the core interaction phase of the Binius FRI protocol by adopting stricter definitions for round and final relations and updating sumcheck folding logic with more precise indexing. The changes modify several completeness and soundness theorems to include additional parameters and a NeverFail precondition for initial states. Notably, a sorry placeholder is introduced in the empty case of the finalSumcheckKnowledgeStateFunction.
ArkLib/ProofSystem/Binius/BinaryBasefold/ReductionLogic.lean: This file defines the interactive reduction logic for the Binary Basefold protocol, introducing formal definitions for the folding, commitment, and final sumcheck steps. It provides comprehensive proofs for the strong completeness of each step, ensuring that honest prover-verifier interactions correctly satisfy the protocol's mathematical relations. No sorry or admit placeholders are present in the implementation.
ArkLib/OracleReduction/Completeness.lean: This file introduces a series of new theorems to simplify perfect completeness proofs for oracle reductions by automating the unrolling of monadic protocol executions for $n$-message structures. It provides a generic $n$-message theorem along with specialized lemmas for 0, 1, and 2-round protocols, all of which are fully proved without any sorry placeholders.
ArkLib/ProofSystem/Binius/BinaryBasefold/QueryPhase.lean: This update refactors the Binius query phase into a modular, oracle-aware reduction framework by introducing the queryPhaseLogicStep and structured helper functions for folding and fiber queries. It adds several new definitions and lemmas for challenge decomposition and index bounds, as well as major completeness and safety theorems for the folding process. The changes include multiple sorry placeholders within the newly introduced proofs for consistency and completeness.
ArkLib/ToVCVio/Simulation.lean: This file establishes a "Monad-to-Logic Bridge" for oracle reductions, providing a suite of definitions and theorems to simplify protocol unrolling, simulation mapping, and safety preservation within the OracleComp framework. It focuses on connecting monadic execution states to logical support relations and includes specialized lemmas for reasoning about OptionT and forIn loop invariants. Several proofs, particularly those involving Vector.mapM and reduction unrolling, are currently incomplete and contain sorry placeholders.
ArkLib/ToVCVio/Lemmas.lean: This file introduces a comprehensive suite of utility theorems and simp lemmas for reasoning about the support and failure probabilities (probFailure) of probabilistic computations involving OptionT and StateT. The changes primarily bridge abstract monad transformer operations with concrete oracle-based simulations (simulateQ) and specification lifting (liftComp), facilitating automated reasoning about successful output paths. No sorry or admit placeholders are introduced.
ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean: This file formalizes the Additive NTT algorithm tailored for the FRI-Binius proof system, introducing definitions for intermediate evaluation domains, quotient maps, and novel polynomial bases. It provides a complete formal proof of correctness for the main encoding algorithm and its individual butterfly stages, and contains no sorry or admit placeholders.

Last updated: 2026-03-06 12:44 UTC.

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 added 6 commits March 6, 2026 12:39

feat: completeness tools and completeness proofs for Binary Basefold

5eff4b7

feat: completeness proofs for ring-switching

07d0658

migrate VCV-io-related completeness lemmas

655f2ec

update Binius completeness proofs

bf49045

fix all completeness errors

cde6a22

fix lint errors

2b6222f

chung-thai-nguyen marked this pull request as ready for review March 6, 2026 12:39

chung-thai-nguyen force-pushed the completeness-of-binius branch from 749ed55 to 2b6222f Compare March 6, 2026 12:42

chung-thai-nguyen requested a review from quangvdao March 6, 2026 12:43

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

feat: completeness of Binary Basefold & ring-switching#383

feat: completeness of Binary Basefold & ring-switching#383
chung-thai-nguyen wants to merge 6 commits intomainfrom
completeness-of-binius

chung-thai-nguyen commented Mar 3, 2026 •

edited

Loading

Uh oh!

github-actions bot commented Mar 3, 2026 •

edited

Loading

1. Spacing and Operators

2. Naming Conventions: Terms and Functions

3. Naming Conventions: Theorems and Proofs

4. Acronyms

5. Syntax and Formatting

6. Standardized Inequalities

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

1 participant

Conversation

chung-thai-nguyen commented Mar 3, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

github-actions bot commented Mar 3, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

🤖 Gemini PR Summary

Mathematical Formalization

Infrastructure and Monadic Tooling

Refactoring

Proof Status and Known Gaps

1. Spacing and Operators

2. Naming Conventions: Terms and Functions

3. Naming Conventions: Theorems and Proofs

4. Acronyms

5. Syntax and Formatting

6. Standardized Inequalities

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

1 participant

chung-thai-nguyen commented Mar 3, 2026 •

edited

Loading

github-actions bot commented Mar 3, 2026 •

edited

Loading