VeriSoftBench: Repository-Scale Formal Verification Benchmarks for Lean
Paper
• 2602.18307 • Published
id int64 1 500 | thm_name stringlengths 5 86 | thm_stmt stringlengths 30 2.63k | lean_root stringclasses 23 values | rel_path stringlengths 13 61 | imports listlengths 0 35 | used_lib_defs listlengths 1 144 | used_repo_defs listlengths 1 251 | lib_lemmas listlengths 1 172 | repo_lemmas listlengths 1 148 | used_local_defs listlengths 0 85 | used_local_lemmas listlengths 0 57 | local_ctx stringlengths 35 30.7k | target_theorem stringlengths 33 1.57k | ground_truth_proof stringlengths 6 26.5k | nesting_depth int64 1 27 | transitive_dep_count int64 1 480 | subset_aristotle bool 2 classes | category stringclasses 5 values |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
1 | Binius.BinaryBasefold.fiberwise_dist_lt_imp_dist_lt_unique_decoding_radius | theorem fiberwise_dist_lt_imp_dist_lt_unique_decoding_radius (i : Fin ℓ) (steps : ℕ)
[NeZero steps] (h_i_add_steps : i.val + steps ≤ ℓ)
(f : OracleFunction 𝔽q β (h_ℓ_add_R_rate := h_ℓ_add_R_rate) ⟨i, by omega⟩)
(h_fw_dist_lt : fiberwiseClose 𝔽q β (h_ℓ_add_R_rate := h_ℓ_add_R_rate)
(i := i) (steps := steps) (h_i_add_steps := h_i_add_steps) (f := f)) :
hammingClose 𝔽q β (h_ℓ_add_R_rate := h_ℓ_add_R_rate) ⟨i, by omega⟩ f | ArkLib | ArkLib/ProofSystem/Binius/BinaryBasefold/Prelude.lean | [
"import ArkLib.Data.MvPolynomial.Multilinear",
"import ArkLib.Data.CodingTheory.Basic",
"import ArkLib.Data.FieldTheory.AdditiveNTT.AdditiveNTT",
"import ArkLib.Data.Nat.Bitwise",
"import ArkLib.Data.CodingTheory.ReedSolomon",
"import ArkLib.Data.Vector.Basic",
"import ArkLib.ProofSystem.Sumcheck.Spec.SingleRound",
"import ArkLib.Data.FieldTheory.AdditiveNTT.NovelPolynomialBasis",
"import ArkLib.Data.CodingTheory.BerlekampWelch.BerlekampWelch"
] | [
{
"name": "Fin",
"module": "Init.Prelude"
},
{
"name": "Subspace",
"module": "Mathlib.Algebra.Module.Submodule.Basic"
},
{
"name": "Set",
"module": "Mathlib.Data.Set.Defs"
},
{
"name": "Set.Ico",
"module": "Mathlib.Order.Interval.Set.Defs"
},
{
"name": "Submodule",
"module": "Mathlib.Algebra.Module.Submodule.Defs"
},
{
"name": "Submodule.span",
"module": "Mathlib.LinearAlgebra.Span.Defs"
},
{
"name": "Polynomial.C",
"module": "Mathlib.Algebra.Polynomial.Basic"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "Algebra",
"module": "Mathlib.Algebra.Algebra.Defs"
},
{
"name": "Field",
"module": "Mathlib.Algebra.Field.Defs"
},
{
"name": "IsLinearMap",
"module": "Mathlib.Algebra.Module.LinearMap.Defs"
},
{
"name": "toFun",
"module": "ToMathlib.Control.Monad.Hom"
},
{
"name": "Submodule.map",
"module": "Mathlib.Algebra.Module.Submodule.Map"
},
{
"name": "Finset",
"module": "Mathlib.Data.Finset.Defs"
},
{
"name": "Finset.univ",
"module": "Mathlib.Data.Fintype.Defs"
},
{
"name": "Ne",
"module": "Init.Core"
},
{
"name": "NeZero",
"module": "Init.Data.NeZero"
},
{
"name": "Module.Basis",
"module": "Mathlib.LinearAlgebra.Basis.Defs"
},
{
"name": "Disjoint",
"module": "Mathlib.Order.Disjoint"
},
{
"name": "Fact",
"module": "Mathlib.Logic.Basic"
},
{
"name": "LinearEquiv",
"module": "Mathlib.Algebra.Module.Equiv.Defs"
},
{
"name": "LinearEquiv.ofBijective",
"module": "Mathlib.Algebra.Module.Submodule.Equiv"
},
{
"name": "LinearIndependent",
"module": "Mathlib.LinearAlgebra.LinearIndependent.Defs"
},
{
"name": "LinearMap",
"module": "Mathlib.Algebra.Module.LinearMap.Defs"
},
{
"name": "LinearMap.codRestrict",
"module": "Mathlib.Algebra.Module.Submodule.LinearMap"
},
{
"name": "LinearMap.ker",
"module": "Mathlib.Algebra.Module.Submodule.Ker"
},
{
"name": "Module.Basis.span",
"module": "Mathlib.LinearAlgebra.Basis.Basic"
},
{
"name": "Set.range",
"module": "Mathlib.Data.Set.Operations"
},
{
"name": "Submodule.subtype",
"module": "Mathlib.Algebra.Module.Submodule.LinearMap"
},
{
"name": "Subtype",
"module": "Init.Prelude"
},
{
"name": "Fintype",
"module": "Mathlib.Data.Fintype.Defs"
},
{
"name": "Fintype.card",
"module": "Mathlib.Data.Fintype.Card"
},
{
"name": "algebraMap",
"module": "Mathlib.Algebra.Algebra.Defs"
},
{
"name": "Fin.foldl",
"module": "Init.Data.Fin.Fold"
},
{
"name": "context",
"module": "Examples.FrankingProtocol"
},
{
"name": "Polynomial",
"module": "Mathlib.Algebra.Polynomial.Basic"
},
{
"name": "Polynomial.X",
"module": "Mathlib.Algebra.Polynomial.Basic"
},
{
"name": "Semiring",
"module": "Mathlib.Algebra.Ring.Defs"
},
{
"name": "Polynomial.degreeLT",
"module": "Mathlib.RingTheory.Polynomial.Basic"
},
{
"name": "Set.univ",
"module": "Mathlib.Data.Set.Defs"
},
{
"name": "hammingDist",
"module": "Mathlib.InformationTheory.Hamming"
},
{
"name": "Finset.max",
"module": "Mathlib.Data.Finset.Max"
},
{
"name": "Module",
"module": "Mathlib.Algebra.Module.Defs"
},
{
"name": "Module.finrank",
"module": "Mathlib.LinearAlgebra.Dimension.Finrank"
},
{
"name": "ENat",
"module": "Mathlib.Data.ENat.Defs"
},
{
"name": "ENat.toNat",
"module": "Mathlib.Data.ENat.Basic"
},
{
"name": "Eq",
"module": "Init.Prelude"
},
{
"name": "Finset.biUnion",
"module": "Mathlib.Data.Finset.Union"
},
{
"name": "Finset.filter",
"module": "Mathlib.Data.Finset.Filter"
},
{
"name": "Fintype.ofFinite",
"module": "Mathlib.Data.Fintype.EquivFin"
},
{
"name": "Function.onFun",
"module": "Mathlib.Logic.Function.Defs"
},
{
"name": "Nonempty",
"module": "Init.Prelude"
},
{
"name": "Polynomial.eval",
"module": "Mathlib.Algebra.Polynomial.Eval.Defs"
},
{
"name": "SetLike",
"module": "Mathlib.Data.SetLike.Basic"
},
{
"name": "WithTop",
"module": "Mathlib.Order.TypeTags"
},
{
"name": "id",
"module": "Init.Prelude"
},
{
"name": "Finsupp",
"module": "Mathlib.Data.Finsupp.Defs"
},
{
"name": "Finsupp.equivFunOnFinite",
"module": "Mathlib.Data.Finsupp.Defs"
},
{
"name": "CharP",
"module": "Mathlib.Algebra.CharP.Defs"
},
{
"name": "DecidableEq",
"module": "Init.Prelude"
},
{
"name": "Set.image",
"module": "Mathlib.Data.Set.Defs"
},
{
"name": "Decidable",
"module": "Init.Prelude"
},
{
"name": "reduceDIte",
"module": "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Core"
},
{
"name": "Inhabited",
"module": "Init.Prelude"
},
{
"name": "Repr",
"module": "Init.Data.Repr"
},
{
"name": "Fin.cast",
"module": "Init.Data.Fin.Basic"
},
{
"name": "Nat.succ",
"module": "Init.Prelude"
}
] | [
{
"name": "hammingDist",
"content": "notation \"Δ₀(\" u \", \" v \")\" => hammingDist u v"
},
{
"name": "distFromCode",
"content": "notation \"Δ₀(\" u \", \" C \")\" => distFromCode u C"
},
{
"name": "scoped macro_rules",
"content": "scoped macro_rules\n | `(ρ $t:term) => `(LinearCode.rate $t)"
},
{
"name": "sDomain",
"content": "noncomputable def sDomain (i : Fin r) : Subspace 𝔽q L :=\n let W_i_norm := normalizedW 𝔽q β i\n let h_W_i_norm_is_additive : IsLinearMap 𝔽q (fun x : L => W_i_norm.eval x) :=\n AdditiveNTT.normalizedW_is_additive 𝔽q β i\n Submodule.map (polyEvalLinearMap W_i_norm h_W_i_norm_is_additive)\n (U 𝔽q β ⟨ℓ + R_rate, h_ℓ_add_R_rate⟩)"
},
{
"name": "normalizedW",
"content": "noncomputable def normalizedW (i : Fin r) : L[X] :=\n C (1 / (W 𝔽q β i).eval (β i)) * W 𝔽q β i"
},
{
"name": "W",
"content": "noncomputable def W (i : Fin r) : L[X] :=\n ∏ u : U 𝔽q β i, (X - C u.val)"
},
{
"name": "U",
"content": "def U (i : Fin r) : Subspace 𝔽q L := Submodule.span 𝔽q (β '' (Set.Ico 0 i))"
},
{
"name": "getBit",
"content": "def getBit (k n : Nat) : Nat := (n >>> k) &&& 1"
},
{
"name": "polyEvalLinearMap",
"content": "noncomputable def polyEvalLinearMap {L 𝔽q : Type*} [Field L] [Field 𝔽q] [Algebra 𝔽q L]\n (p : L[X]) (hp_add : IsLinearMap 𝔽q (fun x : L => p.eval x)) : L →ₗ[𝔽q] L :=\n{\n toFun := fun x => p.eval x,\n map_add' := hp_add.map_add,\n map_smul' := hp_add.map_smul\n}"
},
{
"name": "binaryFinMapToNat",
"content": "def binaryFinMapToNat {n : ℕ} (m : Fin n → ℕ) (h_binary : ∀ j: Fin n, m j ≤ 1) : Fin (2^n) :="
},
{
"name": "sDomain_basis",
"content": "noncomputable def sDomain_basis (i : Fin r) (h_i : i < ℓ + R_rate) :\n Basis (Fin (ℓ + R_rate - i)) 𝔽q (\n sDomain 𝔽q β h_ℓ_add_R_rate i) :="
},
{
"name": "sBasis",
"content": "def sBasis (i : Fin r) (h_i : i < ℓ + R_rate) : Fin (ℓ + R_rate - i) → L :=\n fun k => β ⟨i + k.val, by admit /- proof elided -/\n ⟩"
},
{
"name": "iteratedQuotientMap",
"content": "noncomputable def iteratedQuotientMap (i : Fin ℓ) (k : ℕ)\n (h_bound : i.val + k ≤ ℓ) (x : (sDomain 𝔽q β\n h_ℓ_add_R_rate) ⟨i, by omega⟩) :\n (sDomain 𝔽q β h_ℓ_add_R_rate) ⟨i.val + k, by omega⟩ :="
},
{
"name": "intermediateNormVpoly",
"content": "noncomputable def intermediateNormVpoly\n \n (i: Fin (ℓ+1)) (k : Fin (ℓ - i + 1)) : L[X] :=\n \n Fin.foldl (n:=k) (fun acc j =>\n (qMap 𝔽q β ⟨(i : ℕ) + (j : ℕ), by admit /- proof elided -/\n ⟩).comp acc) (X)"
},
{
"name": "qMap",
"content": "noncomputable def qMap (i : Fin r) : L[X] :=\n let constMultiplier := ((W 𝔽q β i).eval (β i))^(Fintype.card 𝔽q)\n / ((W 𝔽q β (i + 1)).eval (β (i + 1)))\n C constMultiplier * ∏ c: 𝔽q, (X - C (algebraMap 𝔽q L c))"
},
{
"name": "code",
"content": "def code (deg : ℕ) [Semiring F]: Submodule F (ι → F) :=\n (Polynomial.degreeLT F deg).map (evalOnPoints domain)"
},
{
"name": "evalOnPoints",
"content": "def evalOnPoints [Semiring F] : F[X] →ₗ[F] (ι → F) where\n toFun := fun p => fun x => p.eval (domain x)\n map_add' := fun x y => by admit /- proof elided -/"
},
{
"name": "distFromCode",
"content": "noncomputable def distFromCode (u : n → R) (C : Set (n → R)) : ℕ∞ :=\n sInf {d | ∃ v ∈ C, hammingDist u v ≤ d}"
},
{
"name": "toFinset",
"content": "def toFinset (domain : ι ↪ F) (deg : ℕ) : Finset (ι → F) :=\n (RScodeSet domain deg).toFinset"
},
{
"name": "RScodeSet",
"content": "abbrev RScodeSet (domain : ι ↪ F) (deg : ℕ) : Set (ι → F) := (ReedSolomon.code domain deg).carrier"
},
{
"name": "minDist",
"content": "noncomputable def minDist (C : Set (n → R)) : ℕ :=\n sInf {d | ∃ u ∈ C, ∃ v ∈ C, u ≠ v ∧ hammingDist u v = d}"
},
{
"name": "rate",
"content": "noncomputable def rate [Semiring F] (LC : LinearCode ι F) : ℚ≥0 :=\n (dim LC : ℚ≥0) / length LC"
},
{
"name": "dim",
"content": "noncomputable def dim [Semiring F] (LC : LinearCode ι F) : ℕ :=\n Module.finrank F LC"
},
{
"name": "LinearCode.{u,",
"content": "abbrev LinearCode.{u, v} (ι : Type u) [Fintype ι] (F : Type v) [Semiring F] : Type (max u v) :=\n Submodule F (ι → F)"
},
{
"name": "length",
"content": "def length [Semiring F] (_ : LinearCode ι F) : ℕ := Fintype.card ι"
},
{
"name": "symm",
"content": "def symm (eqv : Equiv pSpec pSpec') : Equiv pSpec' pSpec where\n round_eq := eqv.round_eq.symm\n dir_eq := fun i => by admit /- proof elided -/"
},
{
"name": "Equiv",
"content": "@[ext]\nstructure Equiv {m n : ℕ} (pSpec : ProtocolSpec m) (pSpec' : ProtocolSpec n) where\n round_eq : m = n\n dir_eq : ∀ i, pSpec.dir i = pSpec'.dir (Fin.cast round_eq i)\n typeEquiv : ∀ i, pSpec.«Type» i ≃ pSpec'.«Type» (Fin.cast round_eq i)"
},
{
"name": "ProtocolSpec",
"content": "@[ext]\nstructure ProtocolSpec (n : ℕ) where\n \n dir : Fin n → Direction\n \n «Type» : Fin n → Type\nderiving Inhabited"
},
{
"name": "Direction",
"content": "inductive Direction where\n | P_to_V \n | V_to_P \nderiving DecidableEq, Inhabited, Repr"
},
{
"name": "qCompositionChain",
"content": "noncomputable def qCompositionChain (i : Fin r) : L[X] :=\n match i with\n | ⟨0, _⟩ => X\n | ⟨k + 1, h_k_add_1⟩ => (qMap 𝔽q β ⟨k, by admit /- proof elided -/\n ⟩).comp (qCompositionChain ⟨k, by admit /- proof elided -/\n ⟩)"
},
{
"name": "Fin.succRecOnSameFinType",
"content": "@[elab_as_elim] def Fin.succRecOnSameFinType {motive : Fin r → Sort _}\n (zero : motive (0 : Fin r))\n (succ : ∀ i : Fin r, i + 1 < r → motive i → motive (i + 1)) : ∀ (i : Fin r), motive i\n | ⟨0, _⟩ => by admit /- proof elided -/\n | ⟨Nat.succ i_val, h⟩ => by admit /- proof elided -/"
},
{
"name": "trans",
"content": "def trans (eqv : Equiv pSpec pSpec') (eqv' : Equiv pSpec' pSpec'') : Equiv pSpec pSpec'' where\n round_eq := eqv.round_eq.trans eqv'.round_eq\n dir_eq := fun i => by admit /- proof elided -/"
},
{
"name": "minDist",
"content": "notation \"Δ\" IC => minDist IC"
},
{
"name": "distFromCode",
"content": "notation \"Δ₀(\" u \", \" C \")\" => distFromCode u C"
}
] | [
{
"name": "Fin.is_le",
"module": "Init.Data.Fin.Lemmas"
},
{
"name": "Nat.lt_of_add_right_lt",
"module": "Init.Data.Nat.Basic"
},
{
"name": "Nat.lt_of_le_of_lt",
"module": "Init.Prelude"
},
{
"name": "Fin.eta",
"module": "Init.Data.Fin.Lemmas"
},
{
"name": "add_zero",
"module": "Mathlib.Algebra.Group.Defs"
},
{
"name": "Module.Basis.repr_linearCombination",
"module": "Mathlib.LinearAlgebra.Basis.Defs"
},
{
"name": "Module.Basis.repr_symm_apply",
"module": "Mathlib.LinearAlgebra.Basis.Defs"
},
{
"name": "Nat.add_zero",
"module": "Init.Core"
},
{
"name": "cast_eq",
"module": "Init.Core"
},
{
"name": "eq_mp_eq_cast",
"module": "Init.PropLemmas"
},
{
"name": "not_lt_zero'",
"module": "Mathlib.Algebra.Order.GroupWithZero.Canonical"
},
{
"name": "tsub_zero",
"module": "Mathlib.Algebra.Order.Sub.Defs"
},
{
"name": "Decidable.not_not",
"module": "Init.PropLemmas"
},
{
"name": "Fin.eq_of_val_eq",
"module": "Init.Prelude"
},
{
"name": "Fin.is_lt",
"module": "Init.Data.Fin.Lemmas"
},
{
"name": "Fintype.card_fin",
"module": "Mathlib.Data.Fintype.Card"
},
{
"name": "Fintype.card_setUniv",
"module": "Mathlib.Data.Fintype.Card"
},
{
"name": "Set.card_image_of_injective",
"module": "Mathlib.Data.Set.Finite.Basic"
},
{
"name": "false_or",
"module": "Init.SimpLemmas"
},
{
"name": "imp_false",
"module": "Init.Core"
},
{
"name": "left_eq_ite_iff",
"module": "Init.PropLemmas"
},
{
"name": "one_ne_zero",
"module": "Mathlib.Algebra.NeZero"
},
{
"name": "right_eq_ite_iff",
"module": "Init.PropLemmas"
},
{
"name": "zero_ne_one",
"module": "Mathlib.Algebra.NeZero"
},
{
"name": "nonpos_iff_eq_zero",
"module": "Mathlib.Algebra.Order.Monoid.Canonical.Defs"
},
{
"name": "not_lt",
"module": "Mathlib.Order.Defs.LinearOrder"
},
{
"name": "Polynomial.ext",
"module": "Mathlib.Algebra.Polynomial.Basic"
},
{
"name": "add_lt_iff_neg_right",
"module": "Mathlib.Algebra.Order.Monoid.Unbundled.Basic"
},
{
"name": "add_tsub_cancel_right",
"module": "Mathlib.Algebra.Order.Sub.Defs"
},
{
"name": "Nat.le_of_not_lt",
"module": "Init.Data.Nat.Basic"
},
{
"name": "Nat.sub_lt_sub_right",
"module": "Init.Data.Nat.Basic"
},
{
"name": "Nat.sub_sub",
"module": "Init.Data.Nat.Basic"
},
{
"name": "dite_eq_right_iff",
"module": "Init.PropLemmas"
},
{
"name": "forall_const",
"module": "Init.PropLemmas"
},
{
"name": "ite_eq_left_iff",
"module": "Init.PropLemmas"
},
{
"name": "Finset.disjoint_iff_inter_eq_empty",
"module": "Mathlib.Data.Finset.Lattice.Lemmas"
},
{
"name": "Finset.mem_of_mem_inter_left",
"module": "Mathlib.Data.Finset.Lattice.Basic"
},
{
"name": "Finset.mem_of_mem_inter_right",
"module": "Mathlib.Data.Finset.Lattice.Basic"
},
{
"name": "Finset.nonempty_of_ne_empty",
"module": "Mathlib.Data.Finset.Empty"
},
{
"name": "Set.mem_image",
"module": "Mathlib.Data.Set.Operations"
},
{
"name": "Set.mem_toFinset",
"module": "Mathlib.Data.Fintype.Sets"
},
{
"name": "ENat.coe_le_coe",
"module": "Mathlib.Data.ENat.Basic"
},
{
"name": "ENat.coe_lt_coe",
"module": "Mathlib.Data.ENat.Basic"
},
{
"name": "ENat.coe_mul",
"module": "Mathlib.Data.ENat.Basic"
},
{
"name": "ENat.coe_toNat",
"module": "Mathlib.Data.ENat.Basic"
},
{
"name": "Finset.card_biUnion",
"module": "Mathlib.Algebra.BigOperators.Group.Finset.Basic"
},
{
"name": "Finset.card_le_card",
"module": "Mathlib.Data.Finset.Card"
},
{
"name": "Finset.coe_univ",
"module": "Mathlib.Data.Fintype.Defs"
},
{
"name": "Finset.mem_biUnion",
"module": "Mathlib.Data.Finset.Union"
},
{
"name": "Finset.mem_filter",
"module": "Mathlib.Data.Finset.Filter"
},
{
"name": "Finset.mem_image",
"module": "Mathlib.Data.Finset.Image"
},
{
"name": "Finset.mem_univ",
"module": "Mathlib.Data.Fintype.Defs"
},
{
"name": "Finset.sum_congr",
"module": "Mathlib.Algebra.BigOperators.Group.Finset.Basic"
},
{
"name": "Finset.sum_const",
"module": "Mathlib.Algebra.BigOperators.Group.Finset.Basic"
},
{
"name": "Fintype.card_ofFinset",
"module": "Mathlib.Data.Fintype.Card"
},
{
"name": "Nat.add_sub_cancel",
"module": "Init.Data.Nat.Basic"
},
{
"name": "Nat.card_coe_set_eq",
"module": "Mathlib.Data.Set.Card"
},
{
"name": "Nat.card_eq_fintype_card",
"module": "Mathlib.SetTheory.Cardinal.Finite"
},
{
"name": "Nat.le_of_lt_succ",
"module": "Init.Prelude"
},
{
"name": "Nat.lt_add_of_pos_right",
"module": "Init.Data.Nat.Basic"
},
{
"name": "Nat.lt_of_le_pred",
"module": "Init.Data.Nat.Basic"
},
{
"name": "Nat.ofNat_pos",
"module": "Mathlib.Data.Nat.Cast.Order.Ring"
},
{
"name": "Nat.pos_of_neZero",
"module": "Init.Data.Nat.Basic"
},
{
"name": "Nat.pow_add",
"module": "Init.Data.Nat.Lemmas"
},
{
"name": "Nat.pow_lt_pow_right",
"module": "Init.Data.Nat.Lemmas"
},
{
"name": "Nat.sInf_mem",
"module": "Mathlib.Data.Nat.Lattice"
},
{
"name": "Nat.sub_mul",
"module": "Init.Data.Nat.Basic"
},
{
"name": "Set.image_nonempty",
"module": "Mathlib.Data.Set.Image"
},
{
"name": "Set.image_univ",
"module": "Mathlib.Data.Set.Image"
},
{
"name": "Set.nonempty_iff_ne_empty'",
"module": "Mathlib.Data.Set.Basic"
},
{
"name": "Set.toFinset_card",
"module": "Mathlib.Data.Fintype.Card"
},
{
"name": "Set.toFinset_range",
"module": "Mathlib.Data.Fintype.Sets"
},
{
"name": "Set.toFinset_setOf",
"module": "Mathlib.Data.Fintype.Sets"
},
{
"name": "Set.univ_nonempty",
"module": "Mathlib.Data.Set.Basic"
},
{
"name": "SetLike.mem_coe",
"module": "Mathlib.Data.SetLike.Basic"
},
{
"name": "Submodule.coe_mem",
"module": "Mathlib.Algebra.Module.Submodule.Defs"
},
{
"name": "Submodule.nonempty",
"module": "Mathlib.Algebra.Module.Submodule.Defs"
},
{
"name": "Subtype.coe_eta",
"module": "Mathlib.Data.Subtype"
},
{
"name": "WithTop.coe_lt_coe",
"module": "Mathlib.Order.WithBot"
},
{
"name": "and_self",
"module": "Init.SimpLemmas"
},
{
"name": "ge_iff_le",
"module": "Init.Core"
},
{
"name": "le_of_eq_of_le",
"module": "Init.Core"
},
{
"name": "le_refl",
"module": "Mathlib.Order.Defs.PartialOrder"
},
{
"name": "le_trans",
"module": "Mathlib.Order.Defs.PartialOrder"
},
{
"name": "mul_assoc",
"module": "Mathlib.Algebra.Group.Defs"
},
{
"name": "mul_le_mul_right",
"module": "Mathlib.Algebra.Order.Monoid.Unbundled.Basic"
},
{
"name": "ne_eq",
"module": "Init.SimpLemmas"
},
{
"name": "nonempty_subtype",
"module": "Mathlib.Logic.Nonempty"
},
{
"name": "not_false_eq_true",
"module": "Init.SimpLemmas"
},
{
"name": "pow_pos",
"module": "Mathlib.Algebra.Order.GroupWithZero.Unbundled.Basic"
},
{
"name": "sInf_le",
"module": "Mathlib.Order.CompleteLattice.Defs"
},
{
"name": "smul_eq_mul",
"module": "Mathlib.Algebra.Group.Action.Defs"
},
{
"name": "true_and",
"module": "Init.SimpLemmas"
}
] | [
{
"name": "Xⱼ_zero_eq_one",
"content": "lemma Xⱼ_zero_eq_one (ℓ : ℕ) (h_ℓ : ℓ ≤ r) :\n Xⱼ 𝔽q β ℓ h_ℓ ⟨0, by exact Nat.two_pow_pos ℓ⟩ = 1"
},
{
"name": "lt_add_of_pos_right_of_le",
"content": "@[simp]\nlemma lt_add_of_pos_right_of_le (a b c : ℕ) [NeZero c] (h : a ≤ b) : a < b + c"
},
{
"name": "eq_iff_eq_all_getBits",
"content": "lemma eq_iff_eq_all_getBits {n m : ℕ} : n = m ↔ ∀ k, getBit k n = getBit k m"
},
{
"name": "getBit_of_lt_two_pow",
"content": "lemma getBit_of_lt_two_pow {n: ℕ} (a: Fin (2^n)) (k: ℕ) :\n getBit k a = if k < n then getBit k a else 0"
},
{
"name": "getBit_eq_testBit",
"content": "lemma getBit_eq_testBit (k n : Nat) : getBit k n = if n.testBit k then 1 else 0"
},
{
"name": "getBit_lt_2",
"content": "lemma getBit_lt_2 {k n : Nat} : getBit k n < 2"
},
{
"name": "getBit_eq_zero_or_one",
"content": "lemma getBit_eq_zero_or_one {k n : Nat} :\n getBit k n = 0 ∨ getBit k n = 1"
},
{
"name": "getSDomainBasisCoeff_of_iteratedQuotientMap",
"content": "omit [DecidableEq 𝔽q] hF₂ in\nlemma getSDomainBasisCoeff_of_iteratedQuotientMap\n [NeZero R_rate] (i : Fin ℓ) (k : ℕ)\n (h_bound : i.val + k ≤ ℓ) (x : (sDomain 𝔽q β\n h_ℓ_add_R_rate) ⟨i, by omega⟩) :\n let y"
},
{
"name": "base_intermediateNormVpoly",
"content": "theorem base_intermediateNormVpoly\n (k : Fin (ℓ + 1)) :\n intermediateNormVpoly 𝔽q β h_ℓ_add_R_rate ⟨0, by\n by_contra ht\n simp only [not_lt, nonpos_iff_eq_zero] at ht\n contradiction\n ⟩ ⟨k, by simp only [tsub_zero]; omega⟩ =\n normalizedW 𝔽q β ⟨k, by omega⟩"
},
{
"name": "normalizedW_eq_qMap_composition",
"content": "lemma normalizedW_eq_qMap_composition (ℓ R_rate : ℕ) (i : Fin r) :\n normalizedW 𝔽q β i = qCompositionChain 𝔽q β (ℓ:=ℓ) (R_rate:=R_rate) i"
},
{
"name": "qMap_comp_normalizedW",
"content": "lemma qMap_comp_normalizedW (i : Fin r) (h_i_add_1 : i + 1 < r) :\n (qMap 𝔽q β i).comp (normalizedW 𝔽q β i) = normalizedW 𝔽q β (i + 1)"
},
{
"name": "qCompositionChain_eq_foldl",
"content": "lemma qCompositionChain_eq_foldl (i : Fin r) :\n qCompositionChain 𝔽q β (ℓ:=ℓ) (R_rate:=R_rate) i =\n Fin.foldl (n:=i) (fun acc j =>\n (qMap 𝔽q β ⟨j, by omega⟩).comp acc) (X)"
},
{
"name": "getSDomainBasisCoeff_of_sum_repr",
"content": "omit [DecidableEq 𝔽q] hF₂ h_β₀_eq_1 in\nlemma getSDomainBasisCoeff_of_sum_repr [NeZero R_rate] (i : Fin (ℓ + 1))\n (x : (sDomain 𝔽q β h_ℓ_add_R_rate) ⟨i, by omega⟩)\n (x_coeffs : Fin (ℓ + R_rate - i) → 𝔽q)\n (hx : x = ∑ j_x, (x_coeffs j_x) • (sDomain_basis 𝔽q β\n h_ℓ_add_R_rate (i := ⟨i, by omega⟩) (h_i := by\n simp only; apply Nat.lt_add_of_pos_right_of_le; omega) j_x).val) :\n ∀ (j: Fin (ℓ + R_rate - i)), ((sDomain_basis 𝔽q β\n h_ℓ_add_R_rate (i := ⟨i, by omega⟩) (h_i := by\n simp only; apply Nat.lt_add_of_pos_right_of_le; omega)).repr x) j = x_coeffs j"
},
{
"name": "get_sDomain_basis",
"content": "omit [DecidableEq 𝔽q] hF₂ h_β₀_eq_1 in\nlemma get_sDomain_basis (i : Fin r) (h_i : i < ℓ + R_rate) :\n ∀ (k : Fin (ℓ + R_rate - i)),\n (sDomain_basis 𝔽q β h_ℓ_add_R_rate\n i (by omega)) k = eval (β ⟨i + k.val, by omega⟩) (normalizedW 𝔽q β i)"
},
{
"name": "intermediateNormVpoly_comp",
"content": "omit [DecidableEq L] [DecidableEq 𝔽q] h_Fq_char_prime hF₂ hβ_lin_indep h_β₀_eq_1 in\ntheorem intermediateNormVpoly_comp (i : Fin ℓ) (k : Fin (ℓ - i + 1))\n (l : Fin (ℓ - (i.val + k.val) + 1)) :\n intermediateNormVpoly 𝔽q β h_ℓ_add_R_rate (i := ⟨i, by omega⟩) (k:=⟨k + l, by\n simp only; omega⟩) =\n (intermediateNormVpoly 𝔽q β h_ℓ_add_R_rate (i := ⟨i+k, by omega⟩) (k:=⟨l, by\n simp only; omega⟩)).comp (\n intermediateNormVpoly 𝔽q β h_ℓ_add_R_rate (i := ⟨i, by omega⟩) (k:=⟨k, by\n simp only; omega⟩)\n )"
},
{
"name": "intermediateNormVpoly_eval_is_linear_map",
"content": "omit [DecidableEq L] [DecidableEq 𝔽q] hF₂ hβ_lin_indep h_β₀_eq_1 in\nlemma intermediateNormVpoly_eval_is_linear_map (i : Fin (ℓ + 1)) (k : Fin (ℓ - i + 1)) :\n IsLinearMap 𝔽q (fun x : L =>\n (intermediateNormVpoly 𝔽q β h_ℓ_add_R_rate i k).eval x)"
},
{
"name": "qMap_is_linear_map",
"content": "theorem qMap_is_linear_map (i : Fin r) :\n IsLinearMap 𝔽q (f:=fun inner_p ↦ (qMap 𝔽q β i).comp inner_p)"
},
{
"name": "𝔽q_element_eq_zero_or_eq_one",
"content": "omit h_Fq_char_prime in\nlemma 𝔽q_element_eq_zero_or_eq_one : ∀ c: 𝔽q, c = 0 ∨ c = 1"
},
{
"name": "getBit_of_binaryFinMapToNat",
"content": "lemma getBit_of_binaryFinMapToNat {n : ℕ} (m : Fin n → ℕ) (h_binary: ∀ j: Fin n, m j ≤ 1) :\n ∀ k: ℕ, Nat.getBit k (binaryFinMapToNat m h_binary).val\n = if h_k: k < n then m ⟨k, by omega⟩ else 0"
},
{
"name": "and_two_pow_eq_zero_of_getBit_0",
"content": "lemma and_two_pow_eq_zero_of_getBit_0 {n i : ℕ} (h_getBit : getBit i n = 0)\n : n &&& (2 ^ i) = 0"
},
{
"name": "and_eq_zero_iff_and_each_getBit_eq_zero",
"content": "lemma and_eq_zero_iff_and_each_getBit_eq_zero {n m : ℕ} :\n n &&& m = 0 ↔ ∀ k, Nat.getBit k n &&& Nat.getBit k m = 0"
},
{
"name": "shiftRight_and_one_distrib",
"content": "lemma shiftRight_and_one_distrib {n m k : ℕ} :\n Nat.getBit k (n &&& m) = Nat.getBit k n &&& Nat.getBit k m"
},
{
"name": "getBit_two_pow",
"content": "lemma getBit_two_pow {i k : ℕ} : (getBit k (2^i) = if i == k then 1 else 0)"
},
{
"name": "getBit_of_xor",
"content": "lemma getBit_of_xor {n m k: ℕ} : getBit k (n ^^^ m) = getBit k n ^^^ getBit k m"
},
{
"name": "getBit_zero_eq_zero",
"content": "lemma getBit_zero_eq_zero {k : Nat} : getBit k 0 = 0"
},
{
"name": "sum_of_and_eq_zero_is_xor",
"content": "lemma sum_of_and_eq_zero_is_xor {n m : ℕ} (h_n_AND_m : n &&& m = 0) : n + m = n ^^^ m"
},
{
"name": "sum_eq_xor_plus_twice_and",
"content": "lemma sum_eq_xor_plus_twice_and (n : Nat) : ∀ m : ℕ, n + m = (n ^^^ m) + 2 * (n &&& m)"
},
{
"name": "and_by_split_lowBits",
"content": "lemma and_by_split_lowBits {n m n1 m1 bn bm : ℕ} (h_bn : bn < 2) (h_bm : bm < 2)\n (h_n : n = n1 * 2 + bn) (h_m : m = m1 * 2 + bm):\n n &&& m = (n1 &&& m1) * 2 + (bn &&& bm)"
},
{
"name": "div_2_form",
"content": "lemma div_2_form {nD2 b : ℕ} (h_b : b < 2):\n (nD2 * 2 + b) / 2 = nD2"
},
{
"name": "or_by_split_lowBits",
"content": "lemma or_by_split_lowBits {n m n1 m1 bn bm : ℕ} (h_bn : bn < 2) (h_bm : bm < 2)\n (h_n : n = n1 * 2 + bn) (h_m : m = m1 * 2 + bm):\n n ||"
},
{
"name": "xor_by_split_lowBits",
"content": "lemma xor_by_split_lowBits {n m n1 m1 bn bm : ℕ} (h_bn : bn < 2) (h_bm : bm < 2)\n (h_n : n = n1 * 2 + bn) (h_m : m = m1 * 2 + bm):\n n ^^^ m = (n1 ^^^ m1) * 2 + (bn ^^^ bm)"
},
{
"name": "distFromCode_eq_top_iff_empty",
"content": "theorem distFromCode_eq_top_iff_empty (u : n → R) (C : Set (n → R)) : Δ₀(u, C) = ⊤ ↔ C = ∅"
},
{
"name": "sub_add_eq_sub_sub_rev",
"content": "theorem sub_add_eq_sub_sub_rev (a b c : Nat) (h1 : c ≤ b) (h2 : b ≤ a) :\n a - b + c = a - (b - c)"
}
] | [
{
"name": "Binius.BinaryBasefold.OracleFunction",
"content": "abbrev OracleFunction (i : Fin (ℓ + 1)) : Type _ := sDomain 𝔽q β h_ℓ_add_R_rate ⟨i, by admit /- proof elided -/\n ⟩ → L"
},
{
"name": "Binius.BinaryBasefold.fiber_coeff",
"content": "noncomputable def fiber_coeff\n (i : Fin r) (steps : ℕ)\n (j : Fin (ℓ + 𝓡 - i)) (elementIdx : Fin (2 ^ steps))\n (y_coeffs : Fin (ℓ + 𝓡 - (i + steps)) →₀ 𝔽q) : 𝔽q :=\n if hj : j.val < steps then\n if Nat.getBit (k := j) (n := elementIdx) = 0 then 0 else 1\n else y_coeffs ⟨j.val - steps, by admit /- proof elided -/\n ⟩"
},
{
"name": "Binius.BinaryBasefold.qMap_total_fiber",
"content": "noncomputable def qMap_total_fiber\n \n (i : Fin r) (steps : ℕ) (h_i_add_steps : i.val + steps < ℓ + 𝓡)\n (y : sDomain 𝔽q β h_ℓ_add_R_rate (i := ⟨i.val + steps, by admit /- proof elided -/\n ⟩)) :\n Fin (2 ^ steps) → sDomain 𝔽q β h_ℓ_add_R_rate i :=\n if h_steps : steps = 0 then by\n \n subst h_steps\n simp only [add_zero, Fin.eta] at y\n exact fun _ => y\n else by\n \n let basis_y := sDomain_basis 𝔽q β h_ℓ_add_R_rate (i := ⟨i+steps,by admit /- proof elided -/\n ⟩) (by admit /- proof elided -/\n )\n let y_coeffs : Fin (ℓ + 𝓡 - (↑i + steps)) →₀ 𝔽q := basis_y.repr y\n\n let basis_x := sDomain_basis 𝔽q β h_ℓ_add_R_rate ⟨i, by admit /- proof elided -/\n ⟩ (by admit /- proof elided -/\n )\n exact fun elementIdx => by admit /- proof elided -/"
},
{
"name": "Binius.BinaryBasefold.pointToIterateQuotientIndex",
"content": "def pointToIterateQuotientIndex (i : Fin (ℓ + 1)) (steps : ℕ) (h_i_add_steps : i.val + steps ≤ ℓ)\n (x : sDomain 𝔽q β h_ℓ_add_R_rate (i := ⟨i, by omega⟩)) : Fin (2 ^ steps) :="
},
{
"name": "Binius.BinaryBasefold.BBF_Code",
"content": "def BBF_Code (i : Fin (ℓ + 1)) : Submodule L ((sDomain 𝔽q β h_ℓ_add_R_rate)\n ⟨i, by admit /- proof elided -/\n ⟩ → L) :=\n let domain : (sDomain 𝔽q β h_ℓ_add_R_rate) ⟨i, by admit /- proof elided -/\n ⟩ ↪ L :=\n ⟨fun x => x.val, fun x y h => by admit /- proof elided -/\n ⟩\n ReedSolomon.code (domain := domain) (deg := 2^(ℓ - i.val))"
},
{
"name": "Binius.BinaryBasefold.BBF_CodeDistance",
"content": "def BBF_CodeDistance (ℓ 𝓡 : ℕ) (i : Fin (ℓ + 1)) : ℕ :=\n 2^(ℓ + 𝓡 - i.val) - 2^(ℓ - i.val) + 1"
},
{
"name": "Binius.BinaryBasefold.fiberwiseDisagreementSet",
"content": "def fiberwiseDisagreementSet (i : Fin ℓ) (steps : ℕ) [NeZero steps]\n (h_i_add_steps : i.val + steps ≤ ℓ) (f g : OracleFunction 𝔽q β (h_ℓ_add_R_rate :=\n h_ℓ_add_R_rate) ⟨i, by admit /- proof elided -/\n ⟩) :\n Set ((sDomain 𝔽q β h_ℓ_add_R_rate) ⟨i.val + steps, by admit /- proof elided -/\n ⟩) :=\n \n \n {y | ∃ x, iteratedQuotientMap 𝔽q β h_ℓ_add_R_rate (i := i)\n (k := steps) (h_bound := by admit /- proof elided -/\n ) x = y ∧ f x ≠ g x}"
},
{
"name": "Binius.BinaryBasefold.fiberwiseDistance",
"content": "def fiberwiseDistance (i : Fin ℓ) (steps : ℕ) [NeZero steps] (h_i_add_steps : i.val + steps ≤ ℓ)\n (f : OracleFunction 𝔽q β (h_ℓ_add_R_rate := h_ℓ_add_R_rate) ⟨i.val, by admit /- proof elided -/\n ⟩) : ℕ :=\n \n \n let C_i := BBF_Code 𝔽q β (h_ℓ_add_R_rate := h_ℓ_add_R_rate) ⟨i.val, by admit /- proof elided -/\n ⟩\n let disagreement_sizes := (fun (g : C_i) =>\n (fiberwiseDisagreementSet 𝔽q β i steps h_i_add_steps f g).ncard) '' Set.univ\n sInf disagreement_sizes"
},
{
"name": "Binius.BinaryBasefold.fiberwiseClose",
"content": "def fiberwiseClose (i : Fin ℓ) (steps : ℕ) [NeZero steps] (h_i_add_steps : i.val + steps ≤ ℓ)\n (f : OracleFunction 𝔽q β (h_ℓ_add_R_rate := h_ℓ_add_R_rate)\n ⟨i, by admit /- proof elided -/\n ⟩) : Prop :=\n 2 * fiberwiseDistance 𝔽q β (h_ℓ_add_R_rate := h_ℓ_add_R_rate) (i := i) steps\n (h_i_add_steps := h_i_add_steps) (f := f) < (BBF_CodeDistance ℓ 𝓡 ⟨i + steps, by admit /- proof elided -/\n ⟩ : ℕ∞)"
},
{
"name": "Binius.BinaryBasefold.hammingClose",
"content": "def hammingClose (i : Fin (ℓ + 1)) (f : OracleFunction 𝔽q β\n (h_ℓ_add_R_rate := h_ℓ_add_R_rate) i) : Prop :=\n 2 * Code.distFromCode (u := f)\n (C := BBF_Code 𝔽q β (h_ℓ_add_R_rate := h_ℓ_add_R_rate) i) <\n (BBF_CodeDistance ℓ 𝓡 i : ℕ∞)"
}
] | [
{
"name": "Binius.BinaryBasefold.fin_ℓ_steps_lt_ℓ_add_R",
"content": "omit [NeZero ℓ] in\nlemma fin_ℓ_steps_lt_ℓ_add_R (i : Fin ℓ) (steps : ℕ) (h : i.val + steps ≤ ℓ)\n : i.val + steps < ℓ + 𝓡"
},
{
"name": "Binius.BinaryBasefold.qMap_total_fiber_repr_coeff",
"content": "lemma qMap_total_fiber_repr_coeff (i : Fin ℓ) (steps : ℕ) (h_i_add_steps : i.val + steps ≤ ℓ)\n (y : sDomain 𝔽q β h_ℓ_add_R_rate (i := ⟨i.val + steps, by omega⟩))\n (k : Fin (2 ^ steps)) :\n let x := qMap_total_fiber 𝔽q β (i := ⟨i, by omega⟩)\n (steps := steps)\n (h_i_add_steps := by simp only; exact fin_ℓ_steps_lt_ℓ_add_R i steps h_i_add_steps) (y := y) k\n let basis_y := sDomain_basis 𝔽q β h_ℓ_add_R_rate (i := ⟨i.val + steps, by omega⟩)\n (h_i := by simp only; exact fin_ℓ_steps_lt_ℓ_add_R i steps h_i_add_steps)\n let y_coeffs := basis_y.repr y\n ∀ j, -- j refers to bit index of the fiber point x\n ((sDomain_basis 𝔽q β h_ℓ_add_R_rate (i := ⟨i, by omega⟩) (by simp only; omega)).repr x) j\n = fiber_coeff (i := i) (steps := steps) (j := j) (elementIdx := k)\n (y_coeffs := y_coeffs)"
},
{
"name": "Binius.BinaryBasefold.generates_quotient_point_if_is_fiber_of_y",
"content": "theorem generates_quotient_point_if_is_fiber_of_y\n (i : Fin ℓ) (steps : ℕ) (h_i_add_steps : i.val + steps ≤ ℓ)\n (x : sDomain 𝔽q β h_ℓ_add_R_rate (i := ⟨i, by omega⟩))\n (y : sDomain 𝔽q β h_ℓ_add_R_rate (i := ⟨i.val + steps, by omega⟩))\n (hx_is_fiber : ∃ (k : Fin (2 ^ steps)), x = qMap_total_fiber 𝔽q β (i := ⟨i, by omega⟩)\n (steps := steps) (h_i_add_steps := by\n simp only; exact fin_ℓ_steps_lt_ℓ_add_R i steps h_i_add_steps) (y := y) k) :\n y = iteratedQuotientMap 𝔽q β h_ℓ_add_R_rate i (k := steps) (h_bound := h_i_add_steps) x"
},
{
"name": "Binius.BinaryBasefold.is_fiber_iff_generates_quotient_point",
"content": "theorem is_fiber_iff_generates_quotient_point (i : Fin ℓ) (steps : ℕ)\n (h_i_add_steps : i.val + steps ≤ ℓ)\n (x : sDomain 𝔽q β h_ℓ_add_R_rate (i := ⟨i, by omega⟩))\n (y : sDomain 𝔽q β h_ℓ_add_R_rate (i := ⟨i.val + steps, by omega⟩)) :\n let qMapFiber := qMap_total_fiber 𝔽q β (i := ⟨i, by omega⟩) (steps := steps)\n (h_i_add_steps := by simp only; exact fin_ℓ_steps_lt_ℓ_add_R i steps h_i_add_steps) (y := y)\n let k := pointToIterateQuotientIndex (i := ⟨i, by omega⟩) (steps := steps)\n (h_i_add_steps := h_i_add_steps) (x := x)\n y = iteratedQuotientMap 𝔽q β h_ℓ_add_R_rate i (k := steps) (h_bound := h_i_add_steps) x ↔\n qMapFiber k = x"
},
{
"name": "Binius.BinaryBasefold.card_qMap_total_fiber",
"content": "omit [CharP L 2] [DecidableEq 𝔽q] hF₂ h_β₀_eq_1 [NeZero ℓ] in\ntheorem card_qMap_total_fiber (i : Fin ℓ) (steps : ℕ) (h_i_add_steps : i.val + steps ≤ ℓ)\n (y : sDomain 𝔽q β h_ℓ_add_R_rate (i := ⟨i.val + steps, by omega⟩)) :\n Fintype.card (Set.image (qMap_total_fiber 𝔽q β (i := ⟨i, by omega⟩) (steps := steps)\n (h_i_add_steps := by simp only; exact fin_ℓ_steps_lt_ℓ_add_R i steps h_i_add_steps)\n (y := y)) Set.univ) = 2 ^ steps"
},
{
"name": "Binius.BinaryBasefold.qMap_total_fiber_disjoint",
"content": "theorem qMap_total_fiber_disjoint\n (i : Fin ℓ) (steps : ℕ) (h_i_add_steps : i + steps ≤ ℓ)\n {y₁ y₂ : sDomain 𝔽q β h_ℓ_add_R_rate ⟨i.val + steps, by omega⟩}\n (hy_ne : y₁ ≠ y₂) :\n Disjoint\n ((qMap_total_fiber 𝔽q β (i := ⟨i, by omega⟩) (steps := steps)\n (h_i_add_steps := fin_ℓ_steps_lt_ℓ_add_R i steps h_i_add_steps) y₁ '' Set.univ).toFinset)\n ((qMap_total_fiber 𝔽q β (i := ⟨i, by omega⟩) (steps := steps)\n (h_i_add_steps := fin_ℓ_steps_lt_ℓ_add_R i steps h_i_add_steps) y₂ '' Set.univ).toFinset)"
}
] | import ArkLib.Data.CodingTheory.BerlekampWelch.BerlekampWelch
import ArkLib.Data.CodingTheory.ReedSolomon
import ArkLib.Data.FieldTheory.AdditiveNTT.AdditiveNTT
import ArkLib.Data.MvPolynomial.Multilinear
import ArkLib.Data.Vector.Basic
import ArkLib.ProofSystem.Sumcheck.Spec.SingleRound
namespace Binius.BinaryBasefold
open OracleSpec OracleComp ProtocolSpec Finset AdditiveNTT Polynomial MvPolynomial
Binius.BinaryBasefold
open scoped NNReal
open ReedSolomon Code BerlekampWelch
open Finset AdditiveNTT Polynomial MvPolynomial Nat Matrix
section Preliminaries
variable {L : Type} [CommRing L] (ℓ : ℕ) [NeZero ℓ]
variable (𝓑 : Fin 2 ↪ L)
end Preliminaries
noncomputable section -- expands with 𝔽q in front
variable {r : ℕ} [NeZero r]
variable {L : Type} [Field L] [Fintype L] [DecidableEq L] [CharP L 2]
variable (𝔽q : Type) [Field 𝔽q] [Fintype 𝔽q] [DecidableEq 𝔽q]
[h_Fq_char_prime : Fact (Nat.Prime (ringChar 𝔽q))] [hF₂ : Fact (Fintype.card 𝔽q = 2)]
variable [Algebra 𝔽q L]
variable (β : Fin r → L) [hβ_lin_indep : Fact (LinearIndependent 𝔽q β)]
[h_β₀_eq_1 : Fact (β 0 = 1)]
variable {ℓ 𝓡 ϑ : ℕ} (γ_repetitions : ℕ) [NeZero ℓ] [NeZero 𝓡] [NeZero ϑ] -- Should we allow ℓ = 0?
variable {h_ℓ_add_R_rate : ℓ + 𝓡 < r} -- ℓ ∈ {1, ..., r-1}
variable {𝓑 : Fin 2 ↪ L}
section Essentials
abbrev OracleFunction (i : Fin (ℓ + 1)) : Type _ := sDomain 𝔽q β h_ℓ_add_R_rate ⟨i, by admit /- proof elided -/
⟩ → L
noncomputable def fiber_coeff
(i : Fin r) (steps : ℕ)
(j : Fin (ℓ + 𝓡 - i)) (elementIdx : Fin (2 ^ steps))
(y_coeffs : Fin (ℓ + 𝓡 - (i + steps)) →₀ 𝔽q) : 𝔽q :=
if hj : j.val < steps then
if Nat.getBit (k := j) (n := elementIdx) = 0 then 0 else 1
else y_coeffs ⟨j.val - steps, by admit /- proof elided -/
⟩
noncomputable def qMap_total_fiber
(i : Fin r) (steps : ℕ) (h_i_add_steps : i.val + steps < ℓ + 𝓡)
(y : sDomain 𝔽q β h_ℓ_add_R_rate (i := ⟨i.val + steps, by admit /- proof elided -/
⟩)) :
Fin (2 ^ steps) → sDomain 𝔽q β h_ℓ_add_R_rate i :=
if h_steps : steps = 0 then by
subst h_steps
simp only [add_zero, Fin.eta] at y
exact fun _ => y
else by
let basis_y := sDomain_basis 𝔽q β h_ℓ_add_R_rate (i := ⟨i+steps,by admit /- proof elided -/
⟩) (by admit /- proof elided -/
)
let y_coeffs : Fin (ℓ + 𝓡 - (↑i + steps)) →₀ 𝔽q := basis_y.repr y
let basis_x := sDomain_basis 𝔽q β h_ℓ_add_R_rate ⟨i, by admit /- proof elided -/
⟩ (by admit /- proof elided -/
)
exact fun elementIdx => by admit /- proof elided -/
def pointToIterateQuotientIndex (i : Fin (ℓ + 1)) (steps : ℕ) (h_i_add_steps : i.val + steps ≤ ℓ)
(x : sDomain 𝔽q β h_ℓ_add_R_rate (i := ⟨i, by omega⟩)) : Fin (2 ^ steps) :=
end Essentials
section SoundnessTools
def BBF_Code (i : Fin (ℓ + 1)) : Submodule L ((sDomain 𝔽q β h_ℓ_add_R_rate)
⟨i, by admit /- proof elided -/
⟩ → L) :=
let domain : (sDomain 𝔽q β h_ℓ_add_R_rate) ⟨i, by admit /- proof elided -/
⟩ ↪ L :=
⟨fun x => x.val, fun x y h => by admit /- proof elided -/
⟩
ReedSolomon.code (domain := domain) (deg := 2^(ℓ - i.val))
def BBF_CodeDistance (ℓ 𝓡 : ℕ) (i : Fin (ℓ + 1)) : ℕ :=
2^(ℓ + 𝓡 - i.val) - 2^(ℓ - i.val) + 1
def fiberwiseDisagreementSet (i : Fin ℓ) (steps : ℕ) [NeZero steps]
(h_i_add_steps : i.val + steps ≤ ℓ) (f g : OracleFunction 𝔽q β (h_ℓ_add_R_rate :=
h_ℓ_add_R_rate) ⟨i, by admit /- proof elided -/
⟩) :
Set ((sDomain 𝔽q β h_ℓ_add_R_rate) ⟨i.val + steps, by admit /- proof elided -/
⟩) :=
{y | ∃ x, iteratedQuotientMap 𝔽q β h_ℓ_add_R_rate (i := i)
(k := steps) (h_bound := by admit /- proof elided -/
) x = y ∧ f x ≠ g x}
def fiberwiseDistance (i : Fin ℓ) (steps : ℕ) [NeZero steps] (h_i_add_steps : i.val + steps ≤ ℓ)
(f : OracleFunction 𝔽q β (h_ℓ_add_R_rate := h_ℓ_add_R_rate) ⟨i.val, by admit /- proof elided -/
⟩) : ℕ :=
let C_i := BBF_Code 𝔽q β (h_ℓ_add_R_rate := h_ℓ_add_R_rate) ⟨i.val, by admit /- proof elided -/
⟩
let disagreement_sizes := (fun (g : C_i) =>
(fiberwiseDisagreementSet 𝔽q β i steps h_i_add_steps f g).ncard) '' Set.univ
sInf disagreement_sizes
def fiberwiseClose (i : Fin ℓ) (steps : ℕ) [NeZero steps] (h_i_add_steps : i.val + steps ≤ ℓ)
(f : OracleFunction 𝔽q β (h_ℓ_add_R_rate := h_ℓ_add_R_rate)
⟨i, by admit /- proof elided -/
⟩) : Prop :=
2 * fiberwiseDistance 𝔽q β (h_ℓ_add_R_rate := h_ℓ_add_R_rate) (i := i) steps
(h_i_add_steps := h_i_add_steps) (f := f) < (BBF_CodeDistance ℓ 𝓡 ⟨i + steps, by admit /- proof elided -/
⟩ : ℕ∞)
def hammingClose (i : Fin (ℓ + 1)) (f : OracleFunction 𝔽q β
(h_ℓ_add_R_rate := h_ℓ_add_R_rate) i) : Prop :=
2 * Code.distFromCode (u := f)
(C := BBF_Code 𝔽q β (h_ℓ_add_R_rate := h_ℓ_add_R_rate) i) <
(BBF_CodeDistance ℓ 𝓡 i : ℕ∞) | theorem fiberwise_dist_lt_imp_dist_lt_unique_decoding_radius (i : Fin ℓ) (steps : ℕ)
[NeZero steps] (h_i_add_steps : i.val + steps ≤ ℓ)
(f : OracleFunction 𝔽q β (h_ℓ_add_R_rate := h_ℓ_add_R_rate) ⟨i, by omega⟩)
(h_fw_dist_lt : fiberwiseClose 𝔽q β (h_ℓ_add_R_rate := h_ℓ_add_R_rate)
(i := i) (steps := steps) (h_i_add_steps := h_i_add_steps) (f := f)) :
hammingClose 𝔽q β (h_ℓ_add_R_rate := h_ℓ_add_R_rate) ⟨i, by omega⟩ f := | := by
unfold fiberwiseClose at h_fw_dist_lt
unfold hammingClose
-- 2 * Δ₀(f, ↑(BBF_Code 𝔽q β ⟨↑i, ⋯⟩)) < ↑(BBF_CodeDistance ℓ 𝓡 ⟨↑i, ⋯⟩)
let d_fw := fiberwiseDistance 𝔽q β (i := i) steps h_i_add_steps f
let C_i := (BBF_Code 𝔽q β (h_ℓ_add_R_rate := h_ℓ_add_R_rate) ⟨i, by omega⟩)
let d_H := Code.distFromCode f C_i
let d_i := BBF_CodeDistance ℓ 𝓡 (⟨i, by omega⟩)
let d_i_plus_steps := BBF_CodeDistance ℓ 𝓡 ⟨i.val + steps, by omega⟩
have h_d_i_gt_0 : d_i > 0 := by
dsimp [d_i, BBF_CodeDistance] -- ⊢ 2 ^ (ℓ + 𝓡 - ↑i) - 2 ^ (ℓ - ↑i) + 1 > 0
have h_exp_lt : ℓ - i.val < ℓ + 𝓡 - i.val := by
exact Nat.sub_lt_sub_right (a := ℓ) (b := ℓ + 𝓡) (c := i.val) (by omega) (by
apply Nat.lt_add_of_pos_right; exact pos_of_neZero 𝓡)
have h_pow_lt : 2 ^ (ℓ - i.val) < 2 ^ (ℓ + 𝓡 - i.val) := by
exact Nat.pow_lt_pow_right (by norm_num) h_exp_lt
omega
have h_C_i_nonempty : Nonempty C_i := by
simp only [nonempty_subtype, C_i]
exact Submodule.nonempty (BBF_Code 𝔽q β (h_ℓ_add_R_rate := h_ℓ_add_R_rate) ⟨i.val, by omega⟩)
-- 1. Relate Hamming distance `d_H` to fiber-wise distance `d_fw`.
obtain ⟨g', h_g'_mem, h_g'_min_card⟩ : ∃ g' ∈ C_i, d_fw
= (fiberwiseDisagreementSet 𝔽q β i steps h_i_add_steps f g').ncard := by
-- Let `S` be the set of all possible fiber-wise disagreement sizes.
let S := (fun (g : C_i) => (fiberwiseDisagreementSet 𝔽q β i steps h_i_add_steps
f g).ncard) '' Set.univ
-- The code `C_i` (a submodule) is non-empty, so `S` is also non-empty.
have hS_nonempty : S.Nonempty := by
refine Set.image_nonempty.mpr ?_
exact Set.univ_nonempty
-- For a non-empty set of natural numbers, `sInf` is an element of the set.
have h_sInf_mem : sInf S ∈ S := Nat.sInf_mem hS_nonempty
-- By definition, `d_fw = sInf S`.
unfold d_fw at h_sInf_mem
-- Since `sInf S` is in the image set `S`, there must be an element `g_subtype` in the domain
-- (`C_i`) that maps to it. This `g_subtype` is the codeword we're looking for.
rw [Set.mem_image] at h_sInf_mem
rcases h_sInf_mem with ⟨g_subtype, _, h_eq⟩
-- Extract the codeword and its membership proof.
exact ⟨g_subtype.val, g_subtype.property, by exact id (Eq.symm h_eq)⟩
-- The Hamming distance to any codeword `g'` is bounded by `d_fw * 2 ^ steps`.
have h_dist_le_fw_dist_times_fiber_size : (hammingDist f g' : ℕ∞) ≤ d_fw * 2 ^ steps := by
-- This proves `dist f g' ≤ (fiberwiseDisagreementSet ... f g').ncard * 2 ^ steps`
-- and lifts to ℕ∞. We prove the `Nat` version `hammingDist f g' ≤ ...`,
-- which is equivalent.
change (Δ₀(f, g') : ℕ∞) ≤ ↑d_fw * ((2 ^ steps : ℕ) : ℕ∞)
rw [←ENat.coe_mul, ENat.coe_le_coe, h_g'_min_card]
-- Let ΔH be the finset of actually bad x points where f and g' disagree.
set ΔH := Finset.filter (fun x => f x ≠ g' x) Finset.univ
have h_dist_eq_card : hammingDist f g' = ΔH.card := by
simp only [hammingDist, ne_eq, ΔH]
rw [h_dist_eq_card]
-- Y_bad is the set of quotient points y that THERE EXISTS a bad fiber point x
set Y_bad := fiberwiseDisagreementSet 𝔽q β i steps h_i_add_steps f g'
simp only at * -- simplify domain indices everywhere
-- ⊢ #ΔH ≤ Y_bad.ncard * 2 ^ steps
have hFinType_Y_bad : Fintype Y_bad := by exact Fintype.ofFinite ↑Y_bad
-- Every point of disagreement `x` must belong to a fiber over some `y` in `Y_bad`,
-- BY DEFINITION of `Y_bad`. Therefore, `ΔH` is a subset of the union of the fibers
-- of `Y_bad`
have h_ΔH_subset_bad_fiber_points : ΔH ⊆ Finset.biUnion Y_bad.toFinset
(t := fun y => ((qMap_total_fiber 𝔽q β (i := ⟨i, by omega⟩) (steps := steps)
(h_i_add_steps := by apply Nat.lt_add_of_pos_right_of_le; omega) (y := y)) ''
(Finset.univ : Finset (Fin ((2:ℕ)^steps)))).toFinset) := by
-- ⊢ If any x ∈ ΔH, then x ∈ Union(qMap_total_fiber(y), ∀ y ∈ Y_bad)
intro x hx_in_ΔH; -- ⊢ x ∈ Union(qMap_total_fiber(y), ∀ y ∈ Y_bad)
simp only [ΔH, Finset.mem_filter] at hx_in_ΔH
-- Now we actually apply iterated qMap into x to get y_of_x,
-- then x ∈ qMap_total_fiber(y_of_x) by definition
let y_of_x := iteratedQuotientMap 𝔽q β h_ℓ_add_R_rate i steps h_i_add_steps x
apply Finset.mem_biUnion.mpr; use y_of_x
-- ⊢ y_of_x ∈ Y_bad.toFinset ∧ x ∈ qMap_total_fiber(y_of_x)
have h_elemenet_Y_bad : y_of_x ∈ Y_bad.toFinset := by
-- ⊢ y ∈ Y_bad.toFinset
simp only [fiberwiseDisagreementSet, iteratedQuotientMap, ne_eq, Subtype.exists,
Set.toFinset_setOf, mem_filter, mem_univ, true_and, Y_bad]
-- one bad fiber point of y_of_x is x itself
let X := x.val
have h_X_in_source : X ∈ sDomain 𝔽q β h_ℓ_add_R_rate (i := ⟨i, by omega⟩) := by
exact Submodule.coe_mem x
use X
use h_X_in_source
-- ⊢ Ŵ_steps⁽ⁱ⁾(X) = y (iterated quotient map) ∧ ¬f ⟨X, ⋯⟩ = g' ⟨X, ⋯⟩
have h_forward_iterated_qmap : Polynomial.eval X
(intermediateNormVpoly 𝔽q β h_ℓ_add_R_rate ⟨↑i, by omega⟩
⟨steps, by simp only; omega⟩) = y_of_x := by
simp only [iteratedQuotientMap, X, y_of_x];
have h_eval_diff : f ⟨X, by omega⟩ ≠ g' ⟨X, by omega⟩ := by
unfold X
simp only [Subtype.coe_eta, ne_eq, hx_in_ΔH, not_false_eq_true]
simp only [h_forward_iterated_qmap, Subtype.coe_eta, h_eval_diff,
not_false_eq_true, and_self]
simp only [h_elemenet_Y_bad, true_and]
set qMapFiber := qMap_total_fiber 𝔽q β (i := ⟨i, by omega⟩) (steps := steps)
(h_i_add_steps := by apply Nat.lt_add_of_pos_right_of_le; omega) (y := y_of_x)
simp only [coe_univ, Set.image_univ, Set.toFinset_range, mem_image, mem_univ, true_and]
use (pointToIterateQuotientIndex (i := ⟨i, by omega⟩) (steps := steps)
(h_i_add_steps := by omega) (x := x))
have h_res := is_fiber_iff_generates_quotient_point 𝔽q β i steps (by omega)
(x := x) (y := y_of_x).mp (by rfl)
exact h_res
-- ⊢ #ΔH ≤ Y_bad.ncard * 2 ^ steps
-- The cardinality of a subset is at most the cardinality of the superset.
apply (Finset.card_le_card h_ΔH_subset_bad_fiber_points).trans
-- The cardinality of a disjoint union is the sum of cardinalities.
rw [Finset.card_biUnion]
· -- The size of the sum is the number of bad fibers (`Y_bad.ncard`) times
-- the size of each fiber (`2 ^ steps`).
simp only [Set.toFinset_card]
have h_card_fiber_per_quotient_point := card_qMap_total_fiber 𝔽q β
(h_ℓ_add_R_rate := h_ℓ_add_R_rate) i steps h_i_add_steps
simp only [Set.image_univ, Fintype.card_ofFinset,
Subtype.forall] at h_card_fiber_per_quotient_point
have h_card_fiber_of_each_y : ∀ y ∈ Y_bad.toFinset,
Fintype.card ((qMap_total_fiber 𝔽q β (i := ⟨↑i, by omega⟩) (steps := steps)
(h_i_add_steps := by apply Nat.lt_add_of_pos_right_of_le; omega) (y := y)) ''
↑(Finset.univ : Finset (Fin ((2:ℕ)^steps)))) = 2 ^ steps := by
intro y hy_in_Y_bad
have hy_card_fiber_of_y := h_card_fiber_per_quotient_point (a := y) (b := by
exact Submodule.coe_mem y)
simp only [coe_univ, Set.image_univ, Fintype.card_ofFinset, hy_card_fiber_of_y]
rw [Finset.sum_congr rfl h_card_fiber_of_each_y]
-- ⊢ ∑ x ∈ Y_bad.toFinset, 2 ^ steps ≤ Y_bad.encard.toNat * 2 ^ steps
simp only [sum_const, Set.toFinset_card, smul_eq_mul, ofNat_pos, pow_pos,
_root_.mul_le_mul_right, ge_iff_le]
conv_rhs => rw [←_root_.Nat.card_coe_set_eq] -- convert .ncard back to .card
-- ⊢ Fintype.card ↑Y_bad ≤ Nat.card ↑Y_bad
simp only [card_eq_fintype_card, le_refl]
· -- Prove that the fibers for distinct quotient points y₁, y₂ are disjoint.
intro y₁ hy₁ y₂ hy₂ hy_ne
have h_disjoint := qMap_total_fiber_disjoint (i := ⟨↑i, by omega⟩) (steps := steps)
(h_i_add_steps := by omega) (y₁ := y₁) (y₂ := y₂) (hy_ne := hy_ne)
simp only [Function.onFun, coe_univ]
exact h_disjoint
-- The minimum distance `d_H` is bounded by the distance to this specific `g'`.
have h_dist_bridge : d_H ≤ d_fw * 2 ^ steps := by
-- exact h_dist_le_fw_dist_times_fiber_size
apply le_trans (a := d_H) (c := d_fw * 2 ^ steps) (b := hammingDist f g')
· -- ⊢ d_H ≤ ↑Δ₀(f, g')
simp only [distFromCode, SetLike.mem_coe, hammingDist, ne_eq, d_H];
-- ⊢ Δ₀(f, C_i) ≤ ↑Δ₀(f, g')
-- ⊢ sInf {d | ∃ v ∈ C_i, ↑(#{i | f i ≠ v i}) ≤ d} ≤ ↑(#{i | f i ≠ g' i})
apply sInf_le
use g'
· exact h_dist_le_fw_dist_times_fiber_size
-- 2. Use the premise : `2 * d_fw < d_{i+steps}`.
-- As a `Nat` inequality, this is equivalent to `2 * d_fw ≤ d_{i+steps} - 1`.
have h_fw_bound : 2 * d_fw ≤ d_i_plus_steps - 1 := by
-- Convert the ENat inequality to a Nat inequality using `a < b ↔ a + 1 ≤ b`.
exact Nat.le_of_lt_succ (WithTop.coe_lt_coe.1 h_fw_dist_lt)
-- 3. The Algebraic Identity.
-- The core of the proof is the identity : `(d_{i+steps} - 1) * 2 ^ steps = d_i - 1`.
have h_algebraic_identity : (d_i_plus_steps - 1) * 2 ^ steps = d_i - 1 := by
dsimp [d_i, d_i_plus_steps, BBF_CodeDistance]
rw [Nat.sub_mul, ←Nat.pow_add, ←Nat.pow_add];
have h1 : ℓ + 𝓡 - (↑i + steps) + steps = ℓ + 𝓡 - i := by
rw [Nat.sub_add_eq_sub_sub_rev (h1 := by omega) (h2 := by omega),
Nat.add_sub_cancel (n := i) (m := steps)]
have h2 : (ℓ - (↑i + steps) + steps) = ℓ - i := by
rw [Nat.sub_add_eq_sub_sub_rev (h1 := by omega) (h2 := by omega),
Nat.add_sub_cancel (n := i) (m := steps)]
rw [h1, h2]
-- 4. Conclusion : Chain the inequalities to prove `2 * d_H < d_i`.
-- We know `d_H` is finite, since `C_i` is nonempty.
have h_dH_ne_top : d_H ≠ ⊤ := by
simp only [ne_eq, d_H]
rw [Code.distFromCode_eq_top_iff_empty f C_i]
exact Set.nonempty_iff_ne_empty'.mp h_C_i_nonempty
-- We can now work with the `Nat` value of `d_H`.
let d_H_nat := ENat.toNat d_H
have h_dH_eq : d_H = d_H_nat := (ENat.coe_toNat h_dH_ne_top).symm
-- The calculation is now done entirely in `Nat`.
have h_final_inequality : 2 * d_H_nat ≤ d_i - 1 := by
have h_bridge_nat : d_H_nat ≤ d_fw * 2 ^ steps := by
rw [←ENat.coe_le_coe]
exact le_of_eq_of_le (id (Eq.symm h_dH_eq)) h_dist_bridge
calc 2 * d_H_nat
_ ≤ 2 * (d_fw * 2 ^ steps) := by gcongr
_ = (2 * d_fw) * 2 ^ steps := by rw [mul_assoc]
_ ≤ (d_i_plus_steps - 1) * 2 ^ steps := by gcongr;
_ = d_i - 1 := h_algebraic_identity
simp only [d_H, d_H_nat] at h_dH_eq
-- This final line is equivalent to the goal statement.
rw [h_dH_eq]
-- ⊢ 2 * ↑Δ₀(f, C_i).toNat < ↑(BBF_CodeDistance ℓ 𝓡 ⟨↑i, ⋯⟩)
change ((2 : ℕ) : ℕ∞) * ↑Δ₀(f, C_i).toNat < ↑(BBF_CodeDistance ℓ 𝓡 ⟨↑i, by omega⟩)
rw [←ENat.coe_mul, ENat.coe_lt_coe]
apply Nat.lt_of_le_pred (n := 2 * Δ₀(f, C_i).toNat) (m := d_i) (h := h_d_i_gt_0)
(h_final_inequality) | 7 | 232 | false | Applied verif. |
2 | ConcreteBinaryTower.minPoly_of_powerBasisSucc_generator | @[simp]
theorem minPoly_of_powerBasisSucc_generator (k : ℕ) :
(minpoly (ConcreteBTField k) (powerBasisSucc k).gen) = X^2 + (Z k) • X + 1 | ArkLib | ArkLib/Data/FieldTheory/BinaryField/Tower/Impl.lean | [
"import ArkLib.Data.FieldTheory.BinaryField.Tower.Prelude",
"import ArkLib.Data.FieldTheory.BinaryField.Tower.Basic",
"import ArkLib.Data.Classes.DCast"
] | [
{
"name": "Eq",
"module": "Init.Prelude"
},
{
"name": "id",
"module": "Init.Prelude"
},
{
"name": "BitVec",
"module": "Init.Prelude"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "BitVec.cast",
"module": "Init.Data.BitVec.Basic"
},
{
"name": "BitVec.zero",
"module": "Init.Data.BitVec.Basic"
},
{
"name": "BitVec.append",
"module": "Init.Data.BitVec.Basic"
},
{
"name": "BitVec.extractLsb",
"module": "Init.Data.BitVec.Basic"
},
{
"name": "BitVec.xor",
"module": "Init.Data.BitVec.Basic"
},
{
"name": "AddCommGroup",
"module": "Mathlib.Algebra.Group.Defs"
},
{
"name": "Int",
"module": "Init.Data.Int.Basic"
},
{
"name": "Int.negSucc",
"module": "Init.Data.Int.Basic"
},
{
"name": "Ring",
"module": "Mathlib.Algebra.Ring.Defs"
},
{
"name": "DivisionRing",
"module": "Mathlib.Algebra.Field.Defs"
},
{
"name": "NNRat",
"module": "Mathlib.Data.Rat.Init"
},
{
"name": "NNRat.castRec",
"module": "Mathlib.Algebra.Field.Defs"
},
{
"name": "Rat",
"module": "Init.Data.Rat.Basic"
},
{
"name": "Rat.castRec",
"module": "Mathlib.Algebra.Field.Defs"
},
{
"name": "Field",
"module": "Mathlib.Algebra.Field.Defs"
},
{
"name": "Finset",
"module": "Mathlib.Data.Finset.Defs"
},
{
"name": "Finset.range",
"module": "Mathlib.Data.Finset.Range"
},
{
"name": "Polynomial.C",
"module": "Mathlib.Algebra.Polynomial.Basic"
},
{
"name": "Polynomial.X",
"module": "Mathlib.Algebra.Polynomial.Basic"
},
{
"name": "AdjoinRoot.instField",
"module": "Mathlib.RingTheory.AdjoinRoot"
},
{
"name": "Fintype",
"module": "Mathlib.Data.Fintype.Defs"
},
{
"name": "Fintype.card",
"module": "Mathlib.Data.Fintype.Card"
},
{
"name": "Irreducible",
"module": "Mathlib.Algebra.Group.Irreducible.Defs"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "List.Vector",
"module": "Mathlib.Data.Vector.Defs"
},
{
"name": "NeZero",
"module": "Init.Data.NeZero"
},
{
"name": "Polynomial",
"module": "Mathlib.Algebra.Polynomial.Basic"
},
{
"name": "AdjoinRoot",
"module": "Mathlib.RingTheory.AdjoinRoot"
},
{
"name": "AdjoinRoot.of",
"module": "Mathlib.RingTheory.AdjoinRoot"
},
{
"name": "AdjoinRoot.root",
"module": "Mathlib.RingTheory.AdjoinRoot"
},
{
"name": "Eq.mp",
"module": "Init.Core"
},
{
"name": "CharP",
"module": "Mathlib.Algebra.CharP.Defs"
},
{
"name": "DivisionSemiring",
"module": "Mathlib.Algebra.Field.Defs"
},
{
"name": "Finset.Icc",
"module": "Mathlib.Order.Interval.Finset.Defs"
},
{
"name": "GroupWithZero",
"module": "Mathlib.Algebra.GroupWithZero.Defs"
},
{
"name": "Ne",
"module": "Init.Core"
},
{
"name": "Equiv",
"module": "Mathlib.Logic.Equiv.Defs"
},
{
"name": "Equiv.ofBijective",
"module": "Mathlib.Logic.Equiv.Defs"
},
{
"name": "Fact",
"module": "Mathlib.Logic.Basic"
},
{
"name": "Fintype.ofEquiv",
"module": "Mathlib.Data.Fintype.OfMap"
},
{
"name": "Function.Bijective",
"module": "Mathlib.Logic.Function.Defs"
},
{
"name": "Function.Injective",
"module": "Init.Data.Function"
},
{
"name": "Function.Surjective",
"module": "Init.Data.Function"
},
{
"name": "Polynomial.Monic",
"module": "Mathlib.Algebra.Polynomial.Degree.Definitions"
},
{
"name": "Polynomial.eval₂",
"module": "Mathlib.Algebra.Polynomial.Eval.Defs"
},
{
"name": "Prod",
"module": "Init.Prelude"
},
{
"name": "Semiring",
"module": "Mathlib.Algebra.Ring.Defs"
},
{
"name": "Fintype.ofFinite",
"module": "Mathlib.Data.Fintype.EquivFin"
},
{
"name": "List.Vector.cons",
"module": "Mathlib.Data.Vector.Defs"
},
{
"name": "List.Vector.nil",
"module": "Mathlib.Data.Vector.Defs"
},
{
"name": "toFun",
"module": "ToMathlib.Control.Monad.Hom"
},
{
"name": "Algebra",
"module": "Mathlib.Algebra.Algebra.Defs"
},
{
"name": "RingHom",
"module": "Mathlib.Algebra.Ring.Hom.Defs"
},
{
"name": "RingHom.toAlgebra",
"module": "Mathlib.Algebra.Algebra.Defs"
},
{
"name": "invFun",
"module": "ToMathlib.Control.Monad.Equiv"
},
{
"name": "left_inv",
"module": "ToMathlib.Control.Monad.Equiv"
},
{
"name": "right_inv",
"module": "ToMathlib.Control.Monad.Equiv"
},
{
"name": "False.elim",
"module": "Init.Prelude"
},
{
"name": "Finite",
"module": "Mathlib.Data.Finite.Defs"
},
{
"name": "absurd",
"module": "Init.Prelude"
},
{
"name": "instAlgebra",
"module": "Mathlib.LinearAlgebra.TensorAlgebra.Basic"
},
{
"name": "instFintypeProd",
"module": "Mathlib.Data.Fintype.Prod"
},
{
"name": "reduceDIte",
"module": "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Core"
},
{
"name": "RingHom.id",
"module": "Mathlib.Algebra.Ring.Hom.Defs"
},
{
"name": "CommSemiring",
"module": "Mathlib.Algebra.Ring.Defs"
},
{
"name": "Preorder",
"module": "Mathlib.Order.Defs.PartialOrder"
},
{
"name": "algebraMap",
"module": "Mathlib.Algebra.Algebra.Defs"
},
{
"name": "CommMonoid",
"module": "Mathlib.Algebra.Group.Defs"
},
{
"name": "Fin",
"module": "Init.Prelude"
},
{
"name": "Module.Basis",
"module": "Mathlib.LinearAlgebra.Basis.Defs"
},
{
"name": "Algebra.algebraMap",
"module": "Mathlib.Algebra.Algebra.Defs"
},
{
"name": "Module.Basis.mk",
"module": "Mathlib.LinearAlgebra.Basis.Basic"
},
{
"name": "Set",
"module": "Mathlib.Data.Set.Defs"
},
{
"name": "Submodule",
"module": "Mathlib.Algebra.Module.Submodule.Defs"
},
{
"name": "PowerBasis",
"module": "Mathlib.RingTheory.PowerBasis"
},
{
"name": "gen",
"module": "VCVio.CryptoFoundations.FiatShamir"
},
{
"name": "minpoly",
"module": "Mathlib.FieldTheory.Minpoly.Basic"
},
{
"name": "IsUnit",
"module": "Mathlib.Algebra.Group.Units.Defs"
},
{
"name": "Polynomial.leadingCoeff",
"module": "Mathlib.Algebra.Polynomial.Degree.Definitions"
},
{
"name": "BitVec.ofNat",
"module": "Init.Prelude"
},
{
"name": "BitVec.extractLsb'",
"module": "Init.Data.BitVec.Basic"
},
{
"name": "BitVec.setWidth",
"module": "Init.Data.BitVec.Basic"
},
{
"name": "cast",
"module": "Init.Prelude"
},
{
"name": "And",
"module": "Init.Prelude"
},
{
"name": "OfNat",
"module": "Init.Prelude"
},
{
"name": "pos",
"module": "ToMathlib.Control.Comonad.Instances"
},
{
"name": "BitVec.toNat",
"module": "Init.Prelude"
},
{
"name": "Polynomial.aeval",
"module": "Mathlib.Algebra.Polynomial.AlgebraMap"
},
{
"name": "MonoidHom",
"module": "Mathlib.Algebra.Group.Hom.Defs"
},
{
"name": "OneHom",
"module": "Mathlib.Algebra.Group.Hom.Defs"
}
] | [
{
"name": "GaloisField",
"content": "notation : 10 \"GF(\" term : 10 \")\" => GaloisField term 1"
},
{
"name": "DCast",
"content": "class DCast (α : Sort*) (β : α → Sort*) where\n dcast : ∀ {a a' : α}, a = a' → β a → β a'\n dcast_id : ∀ {a : α}, dcast (Eq.refl a) = id"
},
{
"name": "sumZeroIffEq",
"content": "@[simp]\ndef sumZeroIffEq (k : ℕ) : ∀ (x y : BTField k),\n x + y = 0 ↔ x = y := (BinaryTowerAux k).2.sumZeroIffEq"
},
{
"name": "BTField",
"content": "@[simp]\ndef BTField (k : ℕ) := (BinaryTowerAux k).1"
},
{
"name": "BinaryTowerAux",
"content": "def BinaryTowerAux (k : ℕ) : (Σ' (F : Type 0), BinaryTowerResult F k) :=\n match k with\n | 0 => \n let curBTField := GF(2)\n let newList : List.Vector (GF(2)) 1 := List.Vector.cons (1 : GF(2)) List.Vector.nil\n let specialElement : GF(2) := newList.1.headI\n let firstElementOfVecIsSpecialElement : newList.1.headI = specialElement := rfl\n let specialElementIs1 : specialElement = 1 := by admit /- proof elided -/"
},
{
"name": "BinaryTowerInductiveStepResult",
"content": "structure BinaryTowerInductiveStepResult (k : ℕ) (prevBTField : Type _)\n (prevBTResult : BinaryTowerResult prevBTField k) [instPrevBTFieldIsField : Field prevBTField]\n (prevPoly : Polynomial prevBTField) (F : Type _) where\n binaryTowerResult : BinaryTowerResult F (k+1)\n eq_adjoin : F = AdjoinRoot prevPoly\n u_is_root : Eq.mp (eq_adjoin) binaryTowerResult.specialElement = AdjoinRoot.root prevPoly\n eval_defining_poly_at_root : Eq.mp (eq_adjoin) binaryTowerResult.specialElement^2 +\n Eq.mp (eq_adjoin) binaryTowerResult.specialElement * (of prevPoly) prevBTResult.specialElement\n + 1 = 0"
},
{
"name": "BinaryTowerResult",
"content": "structure BinaryTowerResult (F : Type _) (k : ℕ) where\n vec : (List.Vector F (k + 1))\n instField : (Field F)\n instFintype : Fintype F\n specialElement : F\n specialElementNeZero : NeZero specialElement\n firstElementOfVecIsSpecialElement [Inhabited F] : vec.1.headI = specialElement\n instIrreduciblePoly : (Irreducible (p := (definingPoly specialElement)))\n sumZeroIffEq : ∀ (x y : F), x + y = 0 ↔ x = y\n fieldFintypeCard : Fintype.card F = 2^(2^k)\n traceMapEvalAtRootsIs1 : TraceMapProperty F specialElement k"
},
{
"name": "Inhabited",
"content": "@[simp]\ninstance Inhabited (k : ℕ) : Inhabited (BTField k) where\n default := (0 : BTField k)"
},
{
"name": "TraceMapProperty",
"content": "structure TraceMapProperty (F : Type*) [Field F] (u : F) (k : ℕ) : Prop where\n element_trace : ∑ i ∈ Finset.range (2 ^ k), u ^ (2 ^ i) = 1\n inverse_trace : ∑ i ∈ Finset.range (2 ^ k), (u⁻¹) ^ (2 ^ i) = 1"
},
{
"name": "definingPoly",
"content": "noncomputable def definingPoly {F : Type*} [instField : Field F] (s : F)\n := X ^ 2 + C s * X + 1"
},
{
"name": "binary_tower_inductive_step",
"content": "def binary_tower_inductive_step\n (k : Nat)\n (prevBTField : Type _) [Field prevBTField]\n (prevBTResult : BinaryTowerResult prevBTField k)\n: Σ' (F : Type _), BinaryTowerInductiveStepResult (k:=k) (prevBTField:=prevBTField)\n (prevBTResult:=prevBTResult) (prevPoly:=definingPoly (F:=prevBTField)\n (instField:=prevBTResult.instField) (s:=prevBTResult.specialElement)) (F:=F)\n (instPrevBTFieldIsField:=prevBTResult.instField) :="
},
{
"name": "AlgebraTowerEquiv.symm",
"content": "def AlgebraTowerEquiv.symm (e : AlgebraTowerEquiv A B) : AlgebraTowerEquiv B A where\n toRingEquiv := fun i => (e.toRingEquiv i).symm\n commutesLeft' := fun i j h r => by admit /- proof elided -/"
},
{
"name": "AlgebraTowerEquiv",
"content": "structure AlgebraTowerEquiv (A : ι → Type*) [∀ i, CommSemiring (A i)] [a : AlgebraTower A]\n (B : ι → Type*) [∀ i, CommSemiring (B i)] [b : AlgebraTower B]\n where\n toRingEquiv : ∀ i, (A i ≃+* B i)\n commutesLeft' : ∀ (i j : ι) (h : i ≤ j) (r : A i),\n (b.algebraMap (i:=i) (j:=j) (h:=h)) ((toRingEquiv i) r) =\n (toRingEquiv j) (a.algebraMap (i:=i) (j:=j) (h:=h) r)"
},
{
"name": "SpecialElementRelation",
"content": "structure SpecialElementRelation {F_prev : Type*} [Field F_prev] (t1 : F_prev)\n {F_cur : Type*} [Field F_cur] (u : F_cur) [Algebra F_prev F_cur] : Prop where\n sum_inv_eq : u + u⁻¹ = algebraMap F_prev F_cur t1\n h_u_square : u^2 = u * (algebraMap F_prev F_cur t1) + 1"
},
{
"name": "irreducible_quadratic_defining_poly_of_traceMap_eq_1",
"content": "instance irreducible_quadratic_defining_poly_of_traceMap_eq_1\n {F : Type*} [Field F] [Fintype F] [CharP F 2] (s : F) [NeZero s] (k : ℕ)\n (trace_map_prop : TraceMapProperty F s k)\n (fintypeCard : Fintype.card F = 2 ^ (2 ^ k))\n : Irreducible (definingPoly s) :="
},
{
"name": "charP_eq_2_of_add_self_eq_zero",
"content": "instance charP_eq_2_of_add_self_eq_zero {F : Type*} [Field F]\n (sumZeroIffEq : ∀ (x y : F), x + y = 0 ↔ x = y) : CharP F 2 :=\n have h_two : (2 : (F)) = 0 := by admit /- proof elided -/"
},
{
"name": "coeff.{u}",
"content": "def coeff.{u} {F : Type u} [Semiring F] (f : F[X][Y]) (i j : ℕ) : F := (f.coeff j).coeff i"
},
{
"name": "GF_2_fintype",
"content": "instance GF_2_fintype : Fintype (GF(2)) := Fintype.ofFinite (GF(2))"
},
{
"name": "AlgebraTower.toIsScalarTower",
"content": "@[simp]\ninstance AlgebraTower.toIsScalarTower (a : AlgebraTower C) {i j k : ι}\n (h1 : i ≤ j) (h2 : j ≤ k) :\n letI : Algebra (C i) (C j) :="
},
{
"name": "AlgebraTower.toAlgebra",
"content": "@[simp]\ndef AlgebraTower.toAlgebra {i j : ι} (h : i ≤ j) : Algebra (A i) (A j) :=\n (AlgebraTower.algebraMap (i:=i) (j:=j) (h:=h)).toAlgebra"
}
] | [
{
"name": "Nat.sub_add_cancel",
"module": "Init.Data.Nat.Basic"
},
{
"name": "Nat.sub_zero",
"module": "Init.Data.Nat.Basic"
},
{
"name": "BitVec.ofNat_toNat",
"module": "Init.Data.BitVec.Bootstrap"
},
{
"name": "BitVec.setWidth_eq",
"module": "Init.Data.BitVec.Lemmas"
},
{
"name": "BitVec.toNat_setWidth",
"module": "Init.Data.BitVec.Bootstrap"
},
{
"name": "Nat.and_two_pow_sub_one_eq_mod",
"module": "Init.Data.Nat.Bitwise.Lemmas"
},
{
"name": "Nat.shiftRight_zero",
"module": "Init.Data.Nat.Bitwise.Basic"
},
{
"name": "Nat.add_sub_self_left",
"module": "Init.Data.Nat.Basic"
},
{
"name": "Nat.mul_two",
"module": "Init.Data.Nat.Basic"
},
{
"name": "Nat.pow_succ",
"module": "Init.Data.Nat.Basic"
},
{
"name": "Nat.succ_eq_add_one",
"module": "Init.Data.Nat.Basic"
},
{
"name": "Nat.mul_comm",
"module": "Init.Data.Nat.Basic"
},
{
"name": "Nat.two_pow_pred_mul_two",
"module": "Init.Data.Nat.Lemmas"
},
{
"name": "id_eq",
"module": "Init.Prelude"
},
{
"name": "Nat.add_sub_cancel",
"module": "Init.Data.Nat.Basic"
},
{
"name": "Nat.sub_add_comm",
"module": "Init.Data.Nat.Lemmas"
},
{
"name": "BitVec.extractLsb'_append_eq_of_le",
"module": "Init.Data.BitVec.Lemmas"
},
{
"name": "Nat.le_refl",
"module": "Init.Prelude"
},
{
"name": "congrArg",
"module": "Init.Prelude"
},
{
"name": "eq_mp_eq_cast",
"module": "Init.PropLemmas"
},
{
"name": "BitVec.append_eq",
"module": "Init.Data.BitVec.Basic"
},
{
"name": "BitVec.setWidth_append",
"module": "Init.Data.BitVec.Lemmas"
},
{
"name": "Nat.add_comm",
"module": "Init.Data.Nat.Basic"
},
{
"name": "Nat.div_eq_sub_mod_div",
"module": "Init.Data.Nat.Lemmas"
},
{
"name": "Nat.div_lt_of_lt_mul",
"module": "Init.Data.Nat.Mod"
},
{
"name": "Nat.div_mul_cancel",
"module": "Init.Data.Nat.Dvd"
},
{
"name": "Nat.dvd_sub_mod",
"module": "Init.Data.Nat.Lemmas"
},
{
"name": "Nat.mod_eq_of_lt",
"module": "Init.Data.Nat.Div.Basic"
},
{
"name": "Nat.pow_add",
"module": "Init.Data.Nat.Lemmas"
},
{
"name": "Nat.shiftLeft_eq",
"module": "Init.Data.Nat.Bitwise.Basic"
},
{
"name": "Nat.shiftRight_eq_div_pow",
"module": "Init.Data.Nat.Bitwise.Basic"
},
{
"name": "Nat.mod_le",
"module": "Init.Data.Nat.Div.Basic"
},
{
"name": "Nat.mod_lt",
"module": "Init.Prelude"
},
{
"name": "Nat.shiftLeft_add_eq_or_of_lt",
"module": "Init.Data.Nat.Bitwise.Lemmas"
},
{
"name": "BitVec.eq_of_toNat_eq",
"module": "Init.Data.BitVec.Bootstrap"
},
{
"name": "BitVec.isLt",
"module": "Init.Data.BitVec.BasicAux"
},
{
"name": "BitVec.toNat_append",
"module": "Init.Data.BitVec.Bootstrap"
},
{
"name": "BitVec.toNat_ofNat",
"module": "Init.Data.BitVec.Bootstrap"
},
{
"name": "Nat.ofNat_pos",
"module": "Mathlib.Data.Nat.Cast.Order.Ring"
},
{
"name": "OfNat.ofNat_ne_one",
"module": "Mathlib.Algebra.CharZero.Defs"
},
{
"name": "ne_eq",
"module": "Init.SimpLemmas"
},
{
"name": "not_false_eq_true",
"module": "Init.SimpLemmas"
},
{
"name": "pow_right_inj₀",
"module": "Mathlib.Algebra.Order.GroupWithZero.Unbundled.Basic"
},
{
"name": "Nat.two_pow_pos",
"module": "Init.Data.Nat.Basic"
},
{
"name": "Prod.ext_iff",
"module": "Init.Ext"
},
{
"name": "BitVec.extractLsb_ofNat",
"module": "Init.Data.BitVec.Lemmas"
},
{
"name": "BitVec.zero_eq",
"module": "Init.Data.BitVec.Basic"
},
{
"name": "Nat.zero_mod",
"module": "Init.Data.Nat.Div.Basic"
},
{
"name": "Nat.zero_shiftRight",
"module": "Init.Data.Nat.Lemmas"
},
{
"name": "Nat.ne_zero_of_lt",
"module": "Init.Data.Nat.Basic"
},
{
"name": "Nat.one_lt_two_pow_iff",
"module": "Init.Data.Nat.Lemmas"
},
{
"name": "Nat.shiftRight_eq_zero",
"module": "Init.Data.Nat.Bitwise.Basic"
},
{
"name": "Nat.one_mod_two_pow_eq_one",
"module": "Init.Data.Nat.Lemmas"
},
{
"name": "Nat.one_mod_two_pow",
"module": "Init.Data.Nat.Lemmas"
},
{
"name": "Nat.zero_lt_two",
"module": "Init.Data.Nat.Basic"
},
{
"name": "pow_pos",
"module": "Mathlib.Algebra.Order.GroupWithZero.Unbundled.Basic"
},
{
"name": "BitVec.zero_xor",
"module": "Init.Data.BitVec.Lemmas"
},
{
"name": "BitVec.xor_zero",
"module": "Init.Data.BitVec.Lemmas"
},
{
"name": "Nat.add_one_sub_one",
"module": "Init.Data.Nat.Basic"
},
{
"name": "pow_two",
"module": "Mathlib.Algebra.Group.Defs"
},
{
"name": "BitVec.ofNat_xor",
"module": "Init.Data.BitVec.Lemmas"
},
{
"name": "BitVec.xor_eq",
"module": "Init.Data.BitVec.Basic"
},
{
"name": "BitVec.toNat_xor",
"module": "Init.Data.BitVec.Lemmas"
},
{
"name": "Nat.and_xor_distrib_right",
"module": "Init.Data.Nat.Bitwise.Lemmas"
},
{
"name": "Nat.shiftRight_xor_distrib",
"module": "Init.Data.Nat.Bitwise.Lemmas"
},
{
"name": "mul_one",
"module": "Mathlib.Algebra.Group.Defs"
},
{
"name": "Ne.dite_eq_left_iff",
"module": "Mathlib.Logic.Basic"
},
{
"name": "Nat.left_eq_add",
"module": "Init.Data.Nat.Lemmas"
},
{
"name": "RingHom.comp_id",
"module": "Mathlib.Algebra.Ring.Hom.Defs"
},
{
"name": "cast_eq",
"module": "Init.Core"
},
{
"name": "one_ne_zero",
"module": "Mathlib.Algebra.NeZero"
},
{
"name": "BitVec.xor_assoc",
"module": "Init.Data.BitVec.Lemmas"
},
{
"name": "BitVec.xor_self",
"module": "Init.Data.BitVec.Lemmas"
},
{
"name": "Polynomial.C_mul'",
"module": "Mathlib.Algebra.Polynomial.Coeff"
},
{
"name": "Polynomial.aeval_def",
"module": "Mathlib.Algebra.Polynomial.AlgebraMap"
},
{
"name": "Polynomial.eval₂_X",
"module": "Mathlib.Algebra.Polynomial.Eval.Defs"
},
{
"name": "Polynomial.eval₂_X_pow",
"module": "Mathlib.Algebra.Polynomial.Eval.Defs"
},
{
"name": "Polynomial.eval₂_add",
"module": "Mathlib.Algebra.Polynomial.Eval.Defs"
},
{
"name": "Polynomial.eval₂_one",
"module": "Mathlib.Algebra.Polynomial.Eval.Defs"
},
{
"name": "Polynomial.eval₂_smul",
"module": "Mathlib.Algebra.Polynomial.Eval.SMul"
},
{
"name": "mul_comm",
"module": "Mathlib.Algebra.Group.Defs"
},
{
"name": "MonoidHom.coe_mk",
"module": "Mathlib.Algebra.Group.Hom.Defs"
},
{
"name": "Nat.sub_one_add_one",
"module": "Init.Data.Nat.Basic"
},
{
"name": "OneHom.coe_mk",
"module": "Mathlib.Algebra.Group.Hom.Defs"
},
{
"name": "RingHom.coe_mk",
"module": "Mathlib.Algebra.Ring.Hom.Defs"
},
{
"name": "cast_cast",
"module": "Init.PropLemmas"
},
{
"name": "eqRec_eq_cast",
"module": "Batteries.Logic"
},
{
"name": "Polynomial.aeval_C",
"module": "Mathlib.Algebra.Polynomial.AlgebraMap"
},
{
"name": "Polynomial.aeval_X",
"module": "Mathlib.Algebra.Polynomial.AlgebraMap"
},
{
"name": "Polynomial.degree_eq_iff_natDegree_eq",
"module": "Mathlib.Algebra.Polynomial.Degree.Definitions"
},
{
"name": "Polynomial.degree_ne_bot",
"module": "Mathlib.Algebra.Polynomial.Degree.Definitions"
},
{
"name": "Polynomial.eq_C_of_natDegree_eq_zero",
"module": "Mathlib.Algebra.Polynomial.Degree.Operations"
},
{
"name": "Polynomial.eq_X_add_C_of_degree_eq_one",
"module": "Mathlib.Algebra.Polynomial.Degree.SmallDegree"
},
{
"name": "Polynomial.leadingCoeff_eq_zero",
"module": "Mathlib.Algebra.Polynomial.Degree.Definitions"
},
{
"name": "Polynomial.natDegree_lt_iff_degree_lt",
"module": "Mathlib.Algebra.Polynomial.Degree.Definitions"
},
{
"name": "false_or",
"module": "Init.SimpLemmas"
},
{
"name": "map_add",
"module": "Mathlib.Algebra.Group.Hom.Defs"
},
{
"name": "map_eq_zero",
"module": "Mathlib.Algebra.GroupWithZero.Units.Lemmas"
},
{
"name": "map_smul",
"module": "Mathlib.GroupTheory.GroupAction.Hom"
},
{
"name": "map_zero",
"module": "Mathlib.Algebra.Group.Hom.Defs"
},
{
"name": "minpoly.unique'",
"module": "Mathlib.FieldTheory.Minpoly.Basic"
},
{
"name": "ne_zero_of_eq_one",
"module": "Mathlib.Algebra.NeZero"
},
{
"name": "not_true_eq_false",
"module": "Init.SimpLemmas"
},
{
"name": "or_false",
"module": "Init.SimpLemmas"
}
] | [
{
"name": "one_le_two_pow_n",
"content": "theorem one_le_two_pow_n (n : ℕ) : 1 ≤ 2 ^ n"
},
{
"name": "dcast_eq",
"content": "@[simp]\ntheorem dcast_eq : dcast (Eq.refl a) b = b"
},
{
"name": "one_le_sub_consecutive_two_pow",
"content": "theorem one_le_sub_consecutive_two_pow (n : ℕ): 1 ≤ 2^(n+1) - 2^n"
},
{
"name": "dcast_eq_root_cast",
"content": "theorem dcast_eq_root_cast (h : a = a') : dcast h b = _root_.cast (congrArg β h) b"
},
{
"name": "dcast_symm",
"content": "theorem dcast_symm (ha : a = a') (hb : dcast ha b = b') : dcast (ha.symm) b' = b"
},
{
"name": "dcast_eq_dcast_iff",
"content": "theorem dcast_eq_dcast_iff (h : a = a'') (h' : a' = a'') :\n dcast h b = dcast h' b' ↔ b = dcast (h'.trans h.symm) b'"
},
{
"name": "zero_lt_pow_n",
"content": "theorem zero_lt_pow_n (m : ℕ) (n : ℕ) (h_m : m > 0): 0 < m^n"
},
{
"name": "is_unit_iff_deg_0",
"content": "theorem is_unit_iff_deg_0 {R : Type*} [Field R] {p : R[X]} : p.degree = 0 ↔ IsUnit p"
},
{
"name": "definingPoly_is_monic",
"content": "lemma definingPoly_is_monic {F : Type*} [Field F] [Fintype F] (s : F) [NeZero s] :\n (definingPoly s).Monic"
},
{
"name": "degree_s_smul_X_add_1",
"content": "lemma degree_s_smul_X_add_1 {F : Type*} [Field F] [Fintype F] (s : F) [NeZero s] :\n (C s * (X : (F)[X]) + 1).degree = 1"
},
{
"name": "degree_s_smul_X",
"content": "lemma degree_s_smul_X {F : Type*} [Field F] [Fintype F] (s : F) [NeZero s] :\n (C s * (X : (F)[X])).degree = 1"
},
{
"name": "degree_definingPoly",
"content": "lemma degree_definingPoly {F : Type*} [Field F] [Fintype F] (s : F) [NeZero s] :\n (definingPoly s).degree = 2"
}
] | [
{
"name": "ConcreteBinaryTower.ConcreteBTField",
"content": "def ConcreteBTField : ℕ → Type := fun k => BitVec (2 ^ k)"
},
{
"name": "ConcreteBinaryTower.BitVec",
"content": "instance BitVec.instDCast : DCast Nat BitVec where\n dcast h := BitVec.cast h\n dcast_id := by admit /- proof elided -/"
},
{
"name": "ConcreteBinaryTower.fromNat",
"content": "def fromNat {k : ℕ} (n : Nat) : ConcreteBTField k :=\n BitVec.ofNat (2 ^ k) n"
},
{
"name": "ConcreteBinaryTower.ConcreteBTField",
"content": "instance ConcreteBTField.instDCast_local : DCast ℕ ConcreteBTField where\n dcast h_k_eq term_k1 := BitVec.cast (congrArg (fun n => 2 ^ n) h_k_eq) term_k1\n dcast_id := by admit /- proof elided -/"
},
{
"name": "ConcreteBinaryTower.zero",
"content": "def zero {k : ℕ} : ConcreteBTField k := BitVec.zero (2 ^ k)"
},
{
"name": "ConcreteBinaryTower.one",
"content": "def one {k : ℕ} : ConcreteBTField k := 1#(2 ^ k)"
},
{
"name": "ConcreteBinaryTower.add",
"content": "def add {k : ℕ} (x y : ConcreteBTField k) : ConcreteBTField k := BitVec.xor x y"
},
{
"name": "ConcreteBinaryTower.neg",
"content": "def neg {k : ℕ} (x : ConcreteBTField k) : ConcreteBTField k := x"
},
{
"name": "ConcreteBinaryTower.split",
"content": "def split {k : ℕ} (h : k > 0) (x : ConcreteBTField k) :\n ConcreteBTField (k - 1) × ConcreteBTField (k - 1) :=\n let lo_bits : BitVec (2 ^ (k - 1) - 1 - 0 + 1) :=\n BitVec.extractLsb (hi := 2 ^ (k - 1) - 1) (lo := 0) x\n let hi_bits : BitVec (2 ^ k - 1 - 2 ^ (k - 1) + 1) :=\n BitVec.extractLsb (hi := 2 ^ k - 1) (lo := 2 ^ (k - 1)) x\n have h_lo : 2 ^ (k - 1) - 1 - 0 + 1 = 2 ^ (k - 1) := by admit /- proof elided -/"
},
{
"name": "ConcreteBinaryTower.join",
"content": "def join {k : ℕ} (h_pos : k > 0) (hi lo : ConcreteBTField (k - 1)) : ConcreteBTField k :="
},
{
"name": "ConcreteBinaryTower.ConcreteBTFAddCommGroupProps",
"content": "structure ConcreteBTFAddCommGroupProps (k : ℕ) where\n add_assoc : ∀ a b c : ConcreteBTField k, (a + b) + c = a + (b + c) := add_assoc\n add_comm : ∀ a b : ConcreteBTField k, a + b = b + a := add_comm\n add_zero : ∀ a : ConcreteBTField k, a + zero = a := add_zero\n zero_add : ∀ a : ConcreteBTField k, zero + a = a := zero_add\n add_neg : ∀ a : ConcreteBTField k, a + (neg a) = zero := neg_add_cancel"
},
{
"name": "ConcreteBinaryTower.mkAddCommGroupInstance",
"content": "def mkAddCommGroupInstance {k : ℕ} : AddCommGroup (ConcreteBTField k) := {\n zero := zero\n neg := neg\n sub := fun x y => add x y\n add_assoc := add_assoc\n add_comm := add_comm\n zero_add := zero_add\n add_zero := add_zero\n nsmul := fun n x => if n % 2 = (0 : ℕ) then zero else x\n zsmul := fun (n : ℤ) x => if n % 2 = 0 then zero else x \n neg_add_cancel := neg_add_cancel\n nsmul_succ := nsmul_succ\n zsmul_succ' := fun n a => zsmul_succ n a\n add := add\n zsmul_neg' := zsmul_neg' (k := k)\n}"
},
{
"name": "ConcreteBinaryTower.Z",
"content": "def Z (k : ℕ) : ConcreteBTField k :=\n if h_k : k = 0 then one\n else\n 《 one (k:=k-1), zero (k:=k-1) 》"
},
{
"name": "ConcreteBinaryTower.equivProd",
"content": "def equivProd {k : ℕ} (h_k_pos : k > 0) :\n ConcreteBTField k ≃ ConcreteBTField (k - 1) × ConcreteBTField (k - 1) where\n toFun := split h_k_pos\n invFun := fun (hi, lo) => 《 hi, lo 》\n left_inv := fun x => Eq.symm (join_of_split h_k_pos x _ _ rfl)\n right_inv := fun ⟨hi, lo⟩ => Eq.symm (split_of_join h_k_pos _ hi lo rfl)"
},
{
"name": "ConcreteBinaryTower.concrete_mul",
"content": "def concrete_mul {k : ℕ} (a b : ConcreteBTField k) : ConcreteBTField k :=\n if h_k_zero : k = 0 then\n if a = zero then zero\n else if b = zero then zero\n else if a = one then b\n else if b = one then a\n else zero \n else\n have h_k_gt_0 : k > 0 := by admit /- proof elided -/"
},
{
"name": "ConcreteBinaryTower.concrete_inv",
"content": "def concrete_inv {k : ℕ} (a : ConcreteBTField k) : ConcreteBTField k :=\n if h_k_zero : k = 0 then\n if a = 0 then 0 else 1\n else\n if h_a_zero : a = 0 then 0\n else if h_a_one : a = 1 then 1\n else\n let h_k_gt_0 : k > 0 := Nat.zero_lt_of_ne_zero h_k_zero\n let (a_hi, a_lo) := split (k:=k) (h:=h_k_gt_0) a\n let prevZ := Z (k - 1)\n let a_lo_next := a_lo + concrete_mul a_hi prevZ\n let delta := concrete_mul a_lo a_lo_next + concrete_mul a_hi a_hi\n let delta_inverse := concrete_inv delta\n let out_hi := concrete_mul delta_inverse a_hi\n let out_lo := concrete_mul delta_inverse a_lo_next\n let res := 《 out_hi, out_lo 》\n res"
},
{
"name": "ConcreteBinaryTower.natCast",
"content": "def natCast {k : ℕ} (n : ℕ) : ConcreteBTField k := if n % 2 = 0 then zero else one"
},
{
"name": "ConcreteBinaryTower.natCast_zero",
"content": "def natCast_zero {k : ℕ} : natCast (k:=k) 0 = zero :="
},
{
"name": "ConcreteBinaryTower.natCast_succ",
"content": "def natCast_succ {k : ℕ} (n : ℕ) : natCast (k:=k) (n + 1) = natCast (k:=k) n + 1 :="
},
{
"name": "ConcreteBinaryTower.intCast",
"content": "def intCast {k : ℕ} (n : ℤ) : ConcreteBTField k := if n % 2 = 0 then zero else one"
},
{
"name": "ConcreteBinaryTower.intCast_ofNat",
"content": "def intCast_ofNat {k : ℕ} (n : ℕ) : intCast (k:=k) (n : ℤ) = natCast n :="
},
{
"name": "ConcreteBinaryTower.intCast_negSucc",
"content": "def intCast_negSucc {k : ℕ} (n : ℕ) : intCast (k:=k) (Int.negSucc n)\n = - (↑(n + 1) : ConcreteBTField k) :="
},
{
"name": "ConcreteBinaryTower.ConcreteBTFRingProps",
"content": "structure ConcreteBTFRingProps (k : ℕ) extends (ConcreteBTFAddCommGroupProps k) where\n \n mul_eq : ∀ (a b : ConcreteBTField k) (h_k : k > 0)\n {a₁ a₀ b₁ b₀ : ConcreteBTField (k - 1)}\n (_h_a : (a₁, a₀) = split h_k a) (_h_b : (b₁, b₀) = split h_k b),\n concrete_mul a b =\n 《 concrete_mul a₀ b₁ + concrete_mul b₀ a₁ + concrete_mul (concrete_mul a₁ b₁) (Z (k - 1)),\n concrete_mul a₀ b₀ + concrete_mul a₁ b₁ 》\n\n \n zero_mul : ∀ a : ConcreteBTField k, concrete_mul zero a = zero\n zero_mul' : ∀ a : ConcreteBTField k, concrete_mul 0 a = 0\n mul_zero : ∀ a : ConcreteBTField k, concrete_mul a zero = zero\n mul_zero' : ∀ a : ConcreteBTField k, concrete_mul a 0 = 0\n one_mul : ∀ a : ConcreteBTField k, concrete_mul one a = a\n mul_one : ∀ a : ConcreteBTField k, concrete_mul a one = a\n\n \n mul_assoc : ∀ a b c : ConcreteBTField k, concrete_mul (concrete_mul a b) c\n = concrete_mul a (concrete_mul b c)\n mul_left_distrib : ∀ a b c : ConcreteBTField k, concrete_mul a (b + c)\n = concrete_mul a b + concrete_mul a c\n mul_right_distrib : ∀ a b c : ConcreteBTField k, concrete_mul (a + b) c\n = concrete_mul a c + concrete_mul b c"
},
{
"name": "ConcreteBinaryTower.ConcreteBTFDivisionRingProps",
"content": "structure ConcreteBTFDivisionRingProps (k : ℕ) extends (ConcreteBTFRingProps k) where\n \n mul_inv_cancel : ∀ a : ConcreteBTField k, a ≠ zero → concrete_mul a (concrete_inv a) = one"
},
{
"name": "ConcreteBinaryTower.ConcreteBTFieldProps",
"content": "structure ConcreteBTFieldProps (k : ℕ) extends (ConcreteBTFDivisionRingProps k) where\n \n mul_comm : ∀ a b : ConcreteBTField k, concrete_mul a b = concrete_mul b a"
},
{
"name": "ConcreteBinaryTower.mkRingInstance",
"content": "def mkRingInstance {k : ℕ} (props : ConcreteBTFieldProps k) : Ring (ConcreteBTField k) where\n toAddCommGroup := mkAddCommGroupInstance\n toOne := inferInstance\n mul := concrete_mul\n mul_assoc := props.mul_assoc\n one_mul := props.one_mul\n mul_one := props.mul_one\n left_distrib := props.mul_left_distrib\n right_distrib := props.mul_right_distrib\n zero_mul := props.zero_mul\n mul_zero := props.mul_zero\n\n natCast n := natCast n\n natCast_zero := natCast_zero\n natCast_succ n := natCast_succ n\n intCast n := intCast n\n intCast_ofNat n := intCast_ofNat n\n intCast_negSucc n := intCast_negSucc n"
},
{
"name": "ConcreteBinaryTower.mkDivisionRingInstance",
"content": "def mkDivisionRingInstance {k : ℕ} (props : ConcreteBTFieldProps k)\n : DivisionRing (ConcreteBTField k) where\n toRing := mkRingInstance (k:=k) props\n inv := concrete_inv\n exists_pair_ne := concrete_exists_pair_ne (k := k)\n mul_inv_cancel := props.mul_inv_cancel\n inv_zero := concrete_inv_zero\n qsmul := (Rat.castRec · * ·)\n nnqsmul := (NNRat.castRec · * ·)"
},
{
"name": "ConcreteBinaryTower.mkFieldInstance",
"content": "def mkFieldInstance {k : ℕ} (props : ConcreteBTFieldProps k) : Field (ConcreteBTField k) where\n toDivisionRing := mkDivisionRingInstance (k:=k) props\n mul_comm := props.mul_comm"
},
{
"name": "ConcreteBinaryTower.ConcreteBTFStepResult",
"content": "structure ConcreteBTFStepResult (k : ℕ) extends (ConcreteBTFieldProps k) where\n instFintype : Fintype (ConcreteBTField k)\n fieldFintypeCard : Fintype.card (ConcreteBTField k) = 2^(2^k)\n \n sumZeroIffEq : ∀ (x y : ConcreteBTField k), x + y = 0 ↔ x = y\n traceMapEvalAtRootsIs1 :\n letI := mkFieldInstance (k:=k) (props:=toConcreteBTFieldProps)\n TraceMapProperty (ConcreteBTField k) (u:=Z k) k\n instIrreduciblePoly :\n letI := mkFieldInstance (k:=k) (props:=toConcreteBTFieldProps)\n (Irreducible (p := (definingPoly (s:=(Z k)))))"
},
{
"name": "ConcreteBinaryTower.liftBTFieldProps",
"content": "def liftBTFieldProps (k : ℕ) (prevBTFResult : ConcreteBTFStepResult (k := k)) :\n ConcreteBTFieldProps (k + 1) := {\n zero_mul := concrete_zero_mul (prevBTFResult.toConcreteBTFieldProps),\n zero_mul' := fun a => by admit /- proof elided -/"
},
{
"name": "ConcreteBinaryTower.liftConcreteBTField",
"content": "def liftConcreteBTField (k : ℕ) (prevBTFResult : ConcreteBTFStepResult (k := k)) :\n Field (ConcreteBTField (k + 1)) :="
},
{
"name": "ConcreteBinaryTower.concreteCanonicalEmbedding",
"content": "def concreteCanonicalEmbedding (k : ℕ)\n (prevBTFieldProps : ConcreteBTFieldProps (k := (k)))\n (curBTFieldProps : ConcreteBTFieldProps (k := (k + 1))) :\n letI := mkFieldInstance prevBTFieldProps\n letI := mkFieldInstance curBTFieldProps\n ConcreteBTField k →+* ConcreteBTField (k + 1) :="
},
{
"name": "ConcreteBinaryTower.instAlgebraLiftConcreteBTField",
"content": "instance instAlgebraLiftConcreteBTField (k : ℕ)\n (prevBTFResult : ConcreteBTFStepResult (k := k)) :\n letI := mkFieldInstance (prevBTFResult.toConcreteBTFieldProps)\n letI := liftConcreteBTField (k:=k) prevBTFResult\n Algebra (ConcreteBTField k) (ConcreteBTField (k + 1)) :=\n letI := mkFieldInstance (prevBTFResult.toConcreteBTFieldProps)\n letI := liftConcreteBTField (k:=k) prevBTFResult\n RingHom.toAlgebra (R:=ConcreteBTField k) (S:=ConcreteBTField (k + 1))\n (i:=(concreteCanonicalEmbedding (k:=k)\n (prevBTFieldProps:=prevBTFResult.toConcreteBTFieldProps)\n (curBTFieldProps:=liftBTFieldProps (k:=k) (prevBTFResult:=prevBTFResult))))"
},
{
"name": "ConcreteBinaryTower.getBTFResult",
"content": "def getBTFResult (k : ℕ) : ConcreteBTFStepResult k :=\n match k with\n | 0 =>\n let base : ConcreteBTFieldProps 0 := {\n mul_eq := fun a b h_k _ _ _ _ _ _ => by admit /- proof elided -/\n| c1_one\n · \n rw [c1_zero] at h_mul\n \n simp at h_mul\n · \n rcases c2_cases with c2_zero | c2_one\n · \n rw [c2_zero] at h_mul\n \n simp at h_mul\n · \n \n exact ⟨c1_one, c2_one⟩\n \n have specialElement_eq_zero : specialElement = 0 := by admit /- proof elided -/"
},
{
"name": "ConcreteBinaryTower.canonicalAlgMap",
"content": "def canonicalAlgMap (k : ℕ) := concreteCanonicalEmbedding (k:=k)\n (prevBTFieldProps:= ((getBTFResult k).toConcreteBTFieldProps))\n (curBTFieldProps:= ((getBTFResult (k + 1)).toConcreteBTFieldProps))"
},
{
"name": "ConcreteBinaryTower.concreteTowerAlgebraMap",
"content": "def concreteTowerAlgebraMap (l r : ℕ) (h_le : l ≤ r) :\n ConcreteBTField l →+* ConcreteBTField r :="
},
{
"name": "ConcreteBinaryTower.instAlgebraTowerConcreteBTF",
"content": "instance instAlgebraTowerConcreteBTF : AlgebraTower (ConcreteBTField) where\n algebraMap := concreteTowerAlgebraMap\n commutes' := by admit /- proof elided -/"
},
{
"name": "ConcreteBinaryTower.ConcreteBTFieldAlgebra",
"content": "def ConcreteBTFieldAlgebra {l r : ℕ} (h_le : l ≤ r) :\n Algebra (ConcreteBTField l) (ConcreteBTField r) := instAlgebraTowerConcreteBTF.toAlgebra h_le"
},
{
"name": "ConcreteBinaryTower.join_via_add_smul",
"content": "def join_via_add_smul (k : ℕ) (h_pos : k > 0) (hi_btf lo_btf : ConcreteBTField (k - 1)) :\n ConcreteBTField k :="
},
{
"name": "ConcreteBinaryTower.basisSucc",
"content": "def basisSucc (k : ℕ) : Basis (Fin 2) (ConcreteBTField k) (ConcreteBTField (k + 1)) :="
},
{
"name": "ConcreteBinaryTower.powerBasisSucc",
"content": "def powerBasisSucc (k : ℕ) :\n PowerBasis (ConcreteBTField k) (ConcreteBTField (k + 1)) :="
}
] | [
{
"name": "ConcreteBinaryTower.cast_ConcreteBTField_eq",
"content": "lemma cast_ConcreteBTField_eq (k m : ℕ) (h_eq : k = m) :\n ConcreteBTField k = ConcreteBTField m"
},
{
"name": "ConcreteBinaryTower.BitVec.dcast_id",
"content": "theorem BitVec.dcast_id {n : Nat} (bv : BitVec n) :\n DCast.dcast (Eq.refl n) bv = bv"
},
{
"name": "ConcreteBinaryTower.BitVec.dcast_bitvec_eq",
"content": "theorem BitVec.dcast_bitvec_eq {l r val : ℕ} (h_width_eq : l = r) :\n dcast h_width_eq (BitVec.ofNat l val) = BitVec.ofNat r val"
},
{
"name": "ConcreteBinaryTower.BitVec.dcast_bitvec_toNat_eq",
"content": "theorem BitVec.dcast_bitvec_toNat_eq {w w2 : ℕ} (x : BitVec w) (h_width_eq : w = w2) :\n BitVec.toNat x = BitVec.toNat (dcast (h_width_eq) x)"
},
{
"name": "ConcreteBinaryTower.BitVec.dcast_bitvec_eq_zero",
"content": "theorem BitVec.dcast_bitvec_eq_zero {l r : ℕ} (h_width_eq : l = r) :\n dcast (h_width_eq) 0#(l) = 0#(r)"
},
{
"name": "ConcreteBinaryTower.BitVec.dcast_bitvec_extractLsb_eq",
"content": "theorem BitVec.dcast_bitvec_extractLsb_eq {w hi1 lo1 hi2 lo2 : ℕ}\n (x : BitVec w) (h_lo_eq : lo1 = lo2)\n (h_width_eq : hi1 - lo1 + 1 = hi2 - lo2 + 1) :\n dcast h_width_eq (BitVec.extractLsb (hi:=hi1) (lo:=lo1) x)\n = BitVec.extractLsb (hi:=hi2) (lo:=lo2) (x)"
},
{
"name": "ConcreteBinaryTower.BitVec.eq_mp_eq_dcast",
"content": "theorem BitVec.eq_mp_eq_dcast {w w2 : ℕ} (x : BitVec w) (h_width_eq : w = w2)\n (h_bitvec_eq : BitVec w = BitVec w2 := by rw [h_width_eq]) :\n Eq.mp (h:=h_bitvec_eq) (a:=x) = dcast (h_width_eq) (x)"
},
{
"name": "ConcreteBinaryTower.BitVec.extractLsb_concat_hi",
"content": "theorem BitVec.extractLsb_concat_hi {hi_size lo_size : ℕ} (hi : BitVec hi_size)\n (lo : BitVec lo_size) (h_hi : hi_size > 0) :\n BitVec.extractLsb (hi:=hi_size + lo_size - 1) (lo:=lo_size)\n (BitVec.append (msbs:=hi) (lsbs:=lo)) = dcast (by\n rw [←Nat.sub_add_comm (by omega), Nat.sub_add_cancel (by omega), Nat.add_sub_cancel]\n ) hi"
},
{
"name": "ConcreteBinaryTower.BitVec.extractLsb_concat_lo",
"content": "theorem BitVec.extractLsb_concat_lo {hi_size lo_size : ℕ} (hi : BitVec hi_size)\n (lo : BitVec lo_size) (h_lo : lo_size > 0) : BitVec.extractLsb (hi:=lo_size - 1) (lo:=0)\n (BitVec.append (msbs:=hi) (lsbs:=lo)) = dcast (by\n rw [←Nat.sub_add_comm (h:=by omega), Nat.sub_add_cancel (h:=by omega), Nat.sub_zero]\n ) lo"
},
{
"name": "ConcreteBinaryTower.Nat.shiftRight_lo_mod_2_pow_hi_shiftLeft_lo",
"content": "theorem Nat.shiftRight_lo_mod_2_pow_hi_shiftLeft_lo (n hi_len lo_len : ℕ)\n (h_n : n < 2 ^ (hi_len + lo_len)) :\n (((n >>> lo_len) % (2 ^ hi_len)) <<< lo_len) = (n - n % 2 ^ lo_len)"
},
{
"name": "ConcreteBinaryTower.Nat.reconstruct_from_hi_and_lo_parts",
"content": "theorem Nat.reconstruct_from_hi_and_lo_parts (n hi_len lo_len : ℕ)\n (h_n : n < 2 ^ (hi_len + lo_len)) :\n n = (((n >>> lo_len) % (2 ^ hi_len)) <<< lo_len) + (n % (2 ^ lo_len))"
},
{
"name": "ConcreteBinaryTower.Nat.reconstruct_from_hi_and_lo_parts_or_ver",
"content": "theorem Nat.reconstruct_from_hi_and_lo_parts_or_ver (n hi_len lo_len : ℕ)\n (h_n : n < 2 ^ (hi_len + lo_len)) :\n n = (((n >>> lo_len) % (2 ^ hi_len)) <<< lo_len) ||| (n % (2 ^ lo_len))"
},
{
"name": "ConcreteBinaryTower.BitVec.eq_append_iff_extract",
"content": "theorem BitVec.eq_append_iff_extract {lo_size hi_size : ℕ} (lo : BitVec lo_size)\n (hi : BitVec hi_size) (h_hi_gt_0 : hi_size > 0) (h_lo_gt_0 : lo_size > 0)\n (x : BitVec (hi_size + lo_size)) : x = dcast (by rfl) (BitVec.append (msbs:=hi) (lsbs:=lo)) ↔\n hi = dcast (by omega) (BitVec.extractLsb (hi:=hi_size + lo_size - 1) (lo:=lo_size) x) ∧\n lo = dcast (by omega) (BitVec.extractLsb (hi:=lo_size - 1) (lo:=0) x)"
},
{
"name": "ConcreteBinaryTower.one_le_sub_middle_of_pow2",
"content": "lemma one_le_sub_middle_of_pow2 {k : ℕ} (h_k : 1 ≤ k) : 1 ≤ 2 ^ k - 2 ^ (k - 1)"
},
{
"name": "ConcreteBinaryTower.sub_middle_of_pow2_with_one_canceled",
"content": "lemma sub_middle_of_pow2_with_one_canceled {k : ℕ} (h_k : 1 ≤ k) : 2 ^ k - 1 - 2 ^ (k - 1) + 1\n = 2 ^ (k - 1)"
},
{
"name": "ConcreteBinaryTower.h_sub_middle",
"content": "lemma h_sub_middle {k : ℕ} (h_pos : k > 0) : 2 ^ k - 1 - 2 ^ (k - 1) + 1 = 2 ^ (k - 1)"
},
{
"name": "ConcreteBinaryTower.h_middle_sub",
"content": "lemma h_middle_sub {k : ℕ} : 2 ^ (k - 1) - 1 - 0 + 1 = 2 ^ (k - 1)"
},
{
"name": "ConcreteBinaryTower.h_sum_two_same_pow2",
"content": "lemma h_sum_two_same_pow2 {k : ℕ} (h_pos : k > 0) : 2 ^ (k - 1) + 2 ^ (k - 1) = 2 ^ k"
},
{
"name": "ConcreteBinaryTower.sum_fromNat_eq_from_xor_Nat",
"content": "theorem sum_fromNat_eq_from_xor_Nat {k : ℕ} (x y : Nat) :\n fromNat (k:=k) (x ^^^ y) = fromNat (k:=k) x + fromNat (k:=k) y"
},
{
"name": "ConcreteBinaryTower.add_self_cancel",
"content": "lemma add_self_cancel {k : ℕ} (a : ConcreteBTField k) : a + a = 0"
},
{
"name": "ConcreteBinaryTower.add_assoc",
"content": "lemma add_assoc {k : ℕ} : ∀ (a b c : ConcreteBTField k), a + b + c = a + (b + c)"
},
{
"name": "ConcreteBinaryTower.zero_add",
"content": "lemma zero_add {k : ℕ} (a : ConcreteBTField k) : 0 + a = a"
},
{
"name": "ConcreteBinaryTower.add_zero",
"content": "lemma add_zero {k : ℕ} (a : ConcreteBTField k) : a + 0 = a"
},
{
"name": "ConcreteBinaryTower.cast_join",
"content": "lemma cast_join {k n : ℕ} (h_pos : k > 0) (hi lo : ConcreteBTField (k - 1)) (heq : k = n) :\n join (k:=k) h_pos hi lo = cast (by rw [heq])\n (join (k:=n) (by omega) (cast (by subst heq; rfl) hi) (lo:=cast (by subst heq; rfl) lo))"
},
{
"name": "ConcreteBinaryTower.zero_is_0",
"content": "lemma zero_is_0 {k : ℕ} : (zero (k:=k)) = (0 : ConcreteBTField k)"
},
{
"name": "ConcreteBinaryTower.one_is_1",
"content": "lemma one_is_1 {k : ℕ} : (one (k:=k)) = 1"
},
{
"name": "ConcreteBinaryTower.BitVec.extractLsb_eq_shift_ofNat",
"content": "theorem BitVec.extractLsb_eq_shift_ofNat {n : Nat} (x : BitVec n) (l r : Nat) :\n BitVec.extractLsb r l x = BitVec.ofNat (r - l + 1) (x.toNat >>> l)"
},
{
"name": "ConcreteBinaryTower.setWidth_eq_ofNat_mod",
"content": "theorem setWidth_eq_ofNat_mod {n num_bits : Nat} (x : BitVec n) :\n BitVec.setWidth num_bits x = BitVec.ofNat num_bits (x.toNat % 2 ^ num_bits)"
},
{
"name": "ConcreteBinaryTower.BitVec.extractLsb_eq_and_pow_2_minus_1_ofNat",
"content": "theorem BitVec.extractLsb_eq_and_pow_2_minus_1_ofNat {n num_bits : Nat}\n (h_num_bits : num_bits > 0) (x : BitVec n) :\n BitVec.extractLsb (hi:= num_bits - 1) (lo := 0) x =\n BitVec.ofNat (num_bits - 1 - 0 + 1) (x.toNat &&& (2 ^ num_bits - 1))"
},
{
"name": "ConcreteBinaryTower.split_bitvec_eq_iff_fromNat",
"content": "theorem split_bitvec_eq_iff_fromNat {k : ℕ} (h_pos : k > 0) (x : ConcreteBTField k)\n (hi_btf lo_btf : ConcreteBTField (k - 1)) :\n split h_pos x = (hi_btf, lo_btf) ↔\n (hi_btf = fromNat (k:=k - 1) (x.toNat >>> 2 ^ (k - 1)) ∧\n lo_btf = fromNat (k:=k - 1) (x.toNat &&& (2 ^ (2 ^ (k - 1)) - 1)))"
},
{
"name": "ConcreteBinaryTower.join_eq_iff_dcast_extractLsb",
"content": "theorem join_eq_iff_dcast_extractLsb {k : ℕ} (h_pos : k > 0) (x : ConcreteBTField k)\n (hi_btf lo_btf : ConcreteBTField (k - 1)) :\n x = 《 hi_btf, lo_btf 》 ↔\n (hi_btf = dcast (h_sub_middle h_pos) (BitVec.extractLsb (hi := 2 ^ k - 1) (lo := 2 ^ (k - 1)) x) ∧\n lo_btf = dcast (h_middle_sub) (BitVec.extractLsb (hi := 2 ^ (k - 1) - 1) (lo := 0) x))"
},
{
"name": "ConcreteBinaryTower.join_eq_join_iff",
"content": "theorem join_eq_join_iff {k : ℕ} (h_pos : k > 0) (hi₀ lo₀ hi₁ lo₁ : ConcreteBTField (k - 1)) :\n 《 hi₀, lo₀ 》 = 《 hi₁, lo₁ 》 ↔ (hi₀ = hi₁ ∧ lo₀ = lo₁)"
},
{
"name": "ConcreteBinaryTower.join_eq_bitvec_iff_fromNat",
"content": "theorem join_eq_bitvec_iff_fromNat {k : ℕ} (h_pos : k > 0) (x : ConcreteBTField k)\n (hi_btf lo_btf : ConcreteBTField (k - 1)) :\n x = 《 hi_btf, lo_btf 》 ↔\n (hi_btf = fromNat (k:=k - 1) (x.toNat >>> 2 ^ (k - 1)) ∧\n lo_btf = fromNat (k:=k - 1) (x.toNat &&& (2 ^ (2 ^ (k - 1)) - 1)))"
},
{
"name": "ConcreteBinaryTower.join_of_split",
"content": "theorem join_of_split {k : ℕ} (h_pos : k > 0) (x : ConcreteBTField k)\n (hi_btf lo_btf : ConcreteBTField (k - 1))\n (h_split_eq : split h_pos x = (hi_btf, lo_btf)) :\n x = 《 hi_btf, lo_btf 》"
},
{
"name": "ConcreteBinaryTower.split_of_join",
"content": "theorem split_of_join {k : ℕ} (h_pos : k > 0) (x : ConcreteBTField k)\n (hi_btf lo_btf : ConcreteBTField (k - 1))\n (h_join : x = 《hi_btf, lo_btf》) :\n (hi_btf, lo_btf) = split h_pos x"
},
{
"name": "ConcreteBinaryTower.split_join_eq_split",
"content": "lemma split_join_eq_split {k : ℕ} (h_pos : k > 0)\n (hi_btf lo_btf : ConcreteBTField (k - 1)) :\n split h_pos (《 hi_btf, lo_btf 》) = (hi_btf, lo_btf)"
},
{
"name": "ConcreteBinaryTower.eq_iff_split_eq",
"content": "theorem eq_iff_split_eq {k : ℕ} (h_pos : k > 0) (x₀ x₁ : ConcreteBTField k) :\n x₀ = x₁ ↔ (split h_pos x₀ = split h_pos x₁)"
},
{
"name": "ConcreteBinaryTower.split_sum_eq_sum_split",
"content": "theorem split_sum_eq_sum_split {k : ℕ} (h_pos : k > 0) (x₀ x₁ : ConcreteBTField k)\n (hi₀ lo₀ hi₁ lo₁ : ConcreteBTField (k - 1))\n (h_split_x₀ : split h_pos x₀ = (hi₀, lo₀))\n (h_split_x₁ : split h_pos x₁ = (hi₁, lo₁)) :\n split h_pos (x₀ + x₁) = (hi₀ + hi₁, lo₀ + lo₁)"
},
{
"name": "ConcreteBinaryTower.join_add_join",
"content": "theorem join_add_join {k : ℕ} (h_pos : k > 0) (hi₀ lo₀ hi₁ lo₁ : ConcreteBTField (k - 1)) :\n 《 hi₀, lo₀ 》 + 《 hi₁, lo₁ 》 = 《 hi₀ + hi₁, lo₀ + lo₁ 》"
},
{
"name": "ConcreteBinaryTower.split_zero",
"content": "theorem split_zero {k : ℕ} (h_pos : k > 0) : split h_pos zero = (zero, zero)"
},
{
"name": "ConcreteBinaryTower.split_Z",
"content": "theorem split_Z {k : ℕ} (h_pos : k > 0) :\n split h_pos (Z k) = (one (k:=k - 1), zero (k:=k - 1))"
},
{
"name": "ConcreteBinaryTower.one_bitvec_toNat",
"content": "lemma one_bitvec_toNat {width : ℕ} (h_width : width > 0) : (1#width).toNat = 1"
},
{
"name": "ConcreteBinaryTower.one_bitvec_shiftRight",
"content": "lemma one_bitvec_shiftRight {d : ℕ} (h_d : d > 0) : 1 >>> d = 0"
},
{
"name": "ConcreteBinaryTower.split_one",
"content": "lemma split_one {k : ℕ} (h_k : k > 0) :\n split h_k (one (k:=k)) = (zero (k:=k - 1), one (k:=k - 1))"
},
{
"name": "ConcreteBinaryTower.join_zero_zero",
"content": "lemma join_zero_zero {k : ℕ} (h_k : k > 0) :\n 《 zero (k:=k - 1), zero (k:=k - 1) 》 = zero (k:=k)"
},
{
"name": "ConcreteBinaryTower.join_zero_one",
"content": "theorem join_zero_one {k : ℕ} (h_k : k > 0) :\n 《 zero (k:=k - 1), one (k:=k - 1) 》 = one (k:=k)"
},
{
"name": "ConcreteBinaryTower.Z_square_eq",
"content": "lemma Z_square_eq (k : ℕ) (prevBTFieldProps : ConcreteBTFieldProps (k := k))\n (curBTFieldProps : ConcreteBTFieldProps (k := (k + 1))) :\n letI : Field (ConcreteBTField (k + 1)) := mkFieldInstance curBTFieldProps\n (Z (k + 1)) ^ 2 = 《 Z (k), 1 》"
},
{
"name": "ConcreteBinaryTower.Z_square_mul_form",
"content": "lemma Z_square_mul_form\n (k : ℕ)\n (prev : ConcreteBTFStepResult (k := k)) :\n letI : Field (ConcreteBTField k) := mkFieldInstance (prev.toConcreteBTFieldProps)\n letI : Field (ConcreteBTField (k + 1)) := mkFieldInstance (k:=k+1)\n (props:=liftBTFieldProps (k:=k) (prevBTFResult:=prev))\n letI : Algebra (ConcreteBTField k) (ConcreteBTField (k + 1)) :=\n instAlgebraLiftConcreteBTField k prev\n Z (k + 1) ^ 2\n = Z (k + 1)\n * (algebraMap (ConcreteBTField k) (ConcreteBTField (k + 1))) (Z k)\n + 1"
},
{
"name": "ConcreteBinaryTower.ConcreteBTField.RingHom_eq_of_dest_eq",
"content": "@[simp]\ntheorem ConcreteBTField.RingHom_eq_of_dest_eq (k m n : ℕ) (h_eq : m = n) :\n (ConcreteBTField k →+* ConcreteBTField m)\n = (ConcreteBTField k →+* ConcreteBTField n)"
},
{
"name": "ConcreteBinaryTower.ConcreteBTField.RingHom_cast_dest_apply",
"content": "@[simp]\ntheorem ConcreteBTField.RingHom_cast_dest_apply (k m n : ℕ) (h_eq : m = n)\n (f : ConcreteBTField k →+* ConcreteBTField m) (x : ConcreteBTField k) :\n (cast (ConcreteBTField.RingHom_eq_of_dest_eq (k:=k) (m:=m) (n:=n) h_eq) f) x\n = cast (by apply cast_ConcreteBTField_eq (h_eq:=h_eq)) (f x)"
},
{
"name": "ConcreteBinaryTower.concreteTowerAlgebraMap_id",
"content": "lemma concreteTowerAlgebraMap_id (k : ℕ) :\n concreteTowerAlgebraMap (h_le:=by omega) = RingHom.id (ConcreteBTField k)"
},
{
"name": "ConcreteBinaryTower.concreteTowerAlgebraMap_succ_1",
"content": "lemma concreteTowerAlgebraMap_succ_1 (k : ℕ) :\n concreteTowerAlgebraMap (l:=k) (r:=k + 1) (h_le:=by omega) = canonicalAlgMap k"
},
{
"name": "ConcreteBinaryTower.split_algebraMap_eq_zero_x",
"content": "lemma split_algebraMap_eq_zero_x {k : ℕ} (h_pos : k > 0) (x : ConcreteBTField (k - 1)) :\n letI instAlgebra := ConcreteBTFieldAlgebra (l:=k-1) (r:=k) (h_le:=by omega)\n split h_pos (algebraMap (ConcreteBTField (k - 1)) (ConcreteBTField k) x) = (0, x)"
},
{
"name": "ConcreteBinaryTower.algebraMap_succ_eq_zero_x",
"content": "lemma algebraMap_succ_eq_zero_x {k : ℕ} (h_pos : k > 0) (x : ConcreteBTField (k - 1)) :\n letI instAlgebra := ConcreteBTFieldAlgebra (l:=k-1) (r:=k) (h_le:=by omega)\n algebraMap (ConcreteBTField (k - 1)) (ConcreteBTField k) x = 《 0, x 》"
},
{
"name": "ConcreteBinaryTower.split_smul_Z_eq_zero_x",
"content": "lemma split_smul_Z_eq_zero_x {k : ℕ} (h_pos : k > 0) (x : ConcreteBTField (k - 1)) :\n letI instAlgebra := ConcreteBTFieldAlgebra (l:=k-1) (r:=k) (h_le:=by omega)\n split h_pos (x • Z k) = (x, 0)"
},
{
"name": "ConcreteBinaryTower.smul_Z_eq_zero_x",
"content": "lemma smul_Z_eq_zero_x {k : ℕ} (h_pos : k > 0) (x : ConcreteBTField (k - 1)) :\n letI instAlgebra := ConcreteBTFieldAlgebra (l:=k-1) (r:=k) (h_le:=by omega)\n x • Z k = 《 x, 0 》"
},
{
"name": "ConcreteBinaryTower.aeval_definingPoly_at_Z_succ",
"content": "lemma aeval_definingPoly_at_Z_succ (k : ℕ) :\n (aeval (Z (k + 1))) (definingPoly (s:=Z (k))) = 0"
}
] | import ArkLib.Data.Classes.DCast
import ArkLib.Data.FieldTheory.BinaryField.Tower.Basic
namespace ConcreteBinaryTower
open Polynomial
def ConcreteBTField : ℕ → Type := fun k => BitVec (2 ^ k)
section BitVecDCast
instance BitVec.instDCast : DCast Nat BitVec where
dcast h := BitVec.cast h
dcast_id := by admit /- proof elided -/
end BitVecDCast
section ConversionUtils
def fromNat {k : ℕ} (n : Nat) : ConcreteBTField k :=
BitVec.ofNat (2 ^ k) n
instance ConcreteBTField.instDCast_local : DCast ℕ ConcreteBTField where
dcast h_k_eq term_k1 := BitVec.cast (congrArg (fun n => 2 ^ n) h_k_eq) term_k1
dcast_id := by admit /- proof elided -/
end ConversionUtils
section NumericLemmas
end NumericLemmas
section FieldOperationsAndInstances
def zero {k : ℕ} : ConcreteBTField k := BitVec.zero (2 ^ k)
def one {k : ℕ} : ConcreteBTField k := 1#(2 ^ k)
def add {k : ℕ} (x y : ConcreteBTField k) : ConcreteBTField k := BitVec.xor x y
def neg {k : ℕ} (x : ConcreteBTField k) : ConcreteBTField k := x
def split {k : ℕ} (h : k > 0) (x : ConcreteBTField k) :
ConcreteBTField (k - 1) × ConcreteBTField (k - 1) :=
let lo_bits : BitVec (2 ^ (k - 1) - 1 - 0 + 1) :=
BitVec.extractLsb (hi := 2 ^ (k - 1) - 1) (lo := 0) x
let hi_bits : BitVec (2 ^ k - 1 - 2 ^ (k - 1) + 1) :=
BitVec.extractLsb (hi := 2 ^ k - 1) (lo := 2 ^ (k - 1)) x
have h_lo : 2 ^ (k - 1) - 1 - 0 + 1 = 2 ^ (k - 1) := by admit /- proof elided -/
def join {k : ℕ} (h_pos : k > 0) (hi lo : ConcreteBTField (k - 1)) : ConcreteBTField k :=
structure ConcreteBTFAddCommGroupProps (k : ℕ) where
add_assoc : ∀ a b c : ConcreteBTField k, (a + b) + c = a + (b + c) := add_assoc
add_comm : ∀ a b : ConcreteBTField k, a + b = b + a := add_comm
add_zero : ∀ a : ConcreteBTField k, a + zero = a := add_zero
zero_add : ∀ a : ConcreteBTField k, zero + a = a := zero_add
add_neg : ∀ a : ConcreteBTField k, a + (neg a) = zero := neg_add_cancel
def mkAddCommGroupInstance {k : ℕ} : AddCommGroup (ConcreteBTField k) := {
zero := zero
neg := neg
sub := fun x y => add x y
add_assoc := add_assoc
add_comm := add_comm
zero_add := zero_add
add_zero := add_zero
nsmul := fun n x => if n % 2 = (0 : ℕ) then zero else x
zsmul := fun (n : ℤ) x => if n % 2 = 0 then zero else x
neg_add_cancel := neg_add_cancel
nsmul_succ := nsmul_succ
zsmul_succ' := fun n a => zsmul_succ n a
add := add
zsmul_neg' := zsmul_neg' (k := k)
}
def Z (k : ℕ) : ConcreteBTField k :=
if h_k : k = 0 then one
else
《 one (k:=k-1), zero (k:=k-1) 》
def equivProd {k : ℕ} (h_k_pos : k > 0) :
ConcreteBTField k ≃ ConcreteBTField (k - 1) × ConcreteBTField (k - 1) where
toFun := split h_k_pos
invFun := fun (hi, lo) => 《 hi, lo 》
left_inv := fun x => Eq.symm (join_of_split h_k_pos x _ _ rfl)
right_inv := fun ⟨hi, lo⟩ => Eq.symm (split_of_join h_k_pos _ hi lo rfl)
def concrete_mul {k : ℕ} (a b : ConcreteBTField k) : ConcreteBTField k :=
if h_k_zero : k = 0 then
if a = zero then zero
else if b = zero then zero
else if a = one then b
else if b = one then a
else zero
else
have h_k_gt_0 : k > 0 := by admit /- proof elided -/
def concrete_inv {k : ℕ} (a : ConcreteBTField k) : ConcreteBTField k :=
if h_k_zero : k = 0 then
if a = 0 then 0 else 1
else
if h_a_zero : a = 0 then 0
else if h_a_one : a = 1 then 1
else
let h_k_gt_0 : k > 0 := Nat.zero_lt_of_ne_zero h_k_zero
let (a_hi, a_lo) := split (k:=k) (h:=h_k_gt_0) a
let prevZ := Z (k - 1)
let a_lo_next := a_lo + concrete_mul a_hi prevZ
let delta := concrete_mul a_lo a_lo_next + concrete_mul a_hi a_hi
let delta_inverse := concrete_inv delta
let out_hi := concrete_mul delta_inverse a_hi
let out_lo := concrete_mul delta_inverse a_lo_next
let res := 《 out_hi, out_lo 》
res
section FieldLemmasOfLevel0
end FieldLemmasOfLevel0
section NumericCasting
def natCast {k : ℕ} (n : ℕ) : ConcreteBTField k := if n % 2 = 0 then zero else one
def natCast_zero {k : ℕ} : natCast (k:=k) 0 = zero :=
def natCast_succ {k : ℕ} (n : ℕ) : natCast (k:=k) (n + 1) = natCast (k:=k) n + 1 :=
def intCast {k : ℕ} (n : ℤ) : ConcreteBTField k := if n % 2 = 0 then zero else one
def intCast_ofNat {k : ℕ} (n : ℕ) : intCast (k:=k) (n : ℤ) = natCast n :=
def intCast_negSucc {k : ℕ} (n : ℕ) : intCast (k:=k) (Int.negSucc n)
= - (↑(n + 1) : ConcreteBTField k) :=
end NumericCasting
structure ConcreteBTFRingProps (k : ℕ) extends (ConcreteBTFAddCommGroupProps k) where
mul_eq : ∀ (a b : ConcreteBTField k) (h_k : k > 0)
{a₁ a₀ b₁ b₀ : ConcreteBTField (k - 1)}
(_h_a : (a₁, a₀) = split h_k a) (_h_b : (b₁, b₀) = split h_k b),
concrete_mul a b =
《 concrete_mul a₀ b₁ + concrete_mul b₀ a₁ + concrete_mul (concrete_mul a₁ b₁) (Z (k - 1)),
concrete_mul a₀ b₀ + concrete_mul a₁ b₁ 》
zero_mul : ∀ a : ConcreteBTField k, concrete_mul zero a = zero
zero_mul' : ∀ a : ConcreteBTField k, concrete_mul 0 a = 0
mul_zero : ∀ a : ConcreteBTField k, concrete_mul a zero = zero
mul_zero' : ∀ a : ConcreteBTField k, concrete_mul a 0 = 0
one_mul : ∀ a : ConcreteBTField k, concrete_mul one a = a
mul_one : ∀ a : ConcreteBTField k, concrete_mul a one = a
mul_assoc : ∀ a b c : ConcreteBTField k, concrete_mul (concrete_mul a b) c
= concrete_mul a (concrete_mul b c)
mul_left_distrib : ∀ a b c : ConcreteBTField k, concrete_mul a (b + c)
= concrete_mul a b + concrete_mul a c
mul_right_distrib : ∀ a b c : ConcreteBTField k, concrete_mul (a + b) c
= concrete_mul a c + concrete_mul b c
structure ConcreteBTFDivisionRingProps (k : ℕ) extends (ConcreteBTFRingProps k) where
mul_inv_cancel : ∀ a : ConcreteBTField k, a ≠ zero → concrete_mul a (concrete_inv a) = one
structure ConcreteBTFieldProps (k : ℕ) extends (ConcreteBTFDivisionRingProps k) where
mul_comm : ∀ a b : ConcreteBTField k, concrete_mul a b = concrete_mul b a
def mkRingInstance {k : ℕ} (props : ConcreteBTFieldProps k) : Ring (ConcreteBTField k) where
toAddCommGroup := mkAddCommGroupInstance
toOne := inferInstance
mul := concrete_mul
mul_assoc := props.mul_assoc
one_mul := props.one_mul
mul_one := props.mul_one
left_distrib := props.mul_left_distrib
right_distrib := props.mul_right_distrib
zero_mul := props.zero_mul
mul_zero := props.mul_zero
natCast n := natCast n
natCast_zero := natCast_zero
natCast_succ n := natCast_succ n
intCast n := intCast n
intCast_ofNat n := intCast_ofNat n
intCast_negSucc n := intCast_negSucc n
def mkDivisionRingInstance {k : ℕ} (props : ConcreteBTFieldProps k)
: DivisionRing (ConcreteBTField k) where
toRing := mkRingInstance (k:=k) props
inv := concrete_inv
exists_pair_ne := concrete_exists_pair_ne (k := k)
mul_inv_cancel := props.mul_inv_cancel
inv_zero := concrete_inv_zero
qsmul := (Rat.castRec · * ·)
nnqsmul := (NNRat.castRec · * ·)
def mkFieldInstance {k : ℕ} (props : ConcreteBTFieldProps k) : Field (ConcreteBTField k) where
toDivisionRing := mkDivisionRingInstance (k:=k) props
mul_comm := props.mul_comm
structure ConcreteBTFStepResult (k : ℕ) extends (ConcreteBTFieldProps k) where
instFintype : Fintype (ConcreteBTField k)
fieldFintypeCard : Fintype.card (ConcreteBTField k) = 2^(2^k)
sumZeroIffEq : ∀ (x y : ConcreteBTField k), x + y = 0 ↔ x = y
traceMapEvalAtRootsIs1 :
letI := mkFieldInstance (k:=k) (props:=toConcreteBTFieldProps)
TraceMapProperty (ConcreteBTField k) (u:=Z k) k
instIrreduciblePoly :
letI := mkFieldInstance (k:=k) (props:=toConcreteBTFieldProps)
(Irreducible (p := (definingPoly (s:=(Z k)))))
end FieldOperationsAndInstances
section BTFieldPropsOneLevelLiftingLemmas
variable {k : ℕ} {h_k : k > 0}
end BTFieldPropsOneLevelLiftingLemmas
section TowerFieldsConstruction
def liftBTFieldProps (k : ℕ) (prevBTFResult : ConcreteBTFStepResult (k := k)) :
ConcreteBTFieldProps (k + 1) := {
zero_mul := concrete_zero_mul (prevBTFResult.toConcreteBTFieldProps),
zero_mul' := fun a => by admit /- proof elided -/
def liftConcreteBTField (k : ℕ) (prevBTFResult : ConcreteBTFStepResult (k := k)) :
Field (ConcreteBTField (k + 1)) :=
def concreteCanonicalEmbedding (k : ℕ)
(prevBTFieldProps : ConcreteBTFieldProps (k := (k)))
(curBTFieldProps : ConcreteBTFieldProps (k := (k + 1))) :
letI := mkFieldInstance prevBTFieldProps
letI := mkFieldInstance curBTFieldProps
ConcreteBTField k →+* ConcreteBTField (k + 1) :=
instance instAlgebraLiftConcreteBTField (k : ℕ)
(prevBTFResult : ConcreteBTFStepResult (k := k)) :
letI := mkFieldInstance (prevBTFResult.toConcreteBTFieldProps)
letI := liftConcreteBTField (k:=k) prevBTFResult
Algebra (ConcreteBTField k) (ConcreteBTField (k + 1)) :=
letI := mkFieldInstance (prevBTFResult.toConcreteBTFieldProps)
letI := liftConcreteBTField (k:=k) prevBTFResult
RingHom.toAlgebra (R:=ConcreteBTField k) (S:=ConcreteBTField (k + 1))
(i:=(concreteCanonicalEmbedding (k:=k)
(prevBTFieldProps:=prevBTFResult.toConcreteBTFieldProps)
(curBTFieldProps:=liftBTFieldProps (k:=k) (prevBTFResult:=prevBTFResult))))
def getBTFResult (k : ℕ) : ConcreteBTFStepResult k :=
match k with
| 0 =>
let base : ConcreteBTFieldProps 0 := {
mul_eq := fun a b h_k _ _ _ _ _ _ => by admit /- proof elided -/
| c1_one
·
rw [c1_zero] at h_mul
simp at h_mul
·
rcases c2_cases with c2_zero | c2_one
·
rw [c2_zero] at h_mul
simp at h_mul
·
exact ⟨c1_one, c2_one⟩
have specialElement_eq_zero : specialElement = 0 := by admit /- proof elided -/
end TowerFieldsConstruction
section ConcreteBTFieldAlgebraConstruction
def canonicalAlgMap (k : ℕ) := concreteCanonicalEmbedding (k:=k)
(prevBTFieldProps:= ((getBTFResult k).toConcreteBTFieldProps))
(curBTFieldProps:= ((getBTFResult (k + 1)).toConcreteBTFieldProps))
def concreteTowerAlgebraMap (l r : ℕ) (h_le : l ≤ r) :
ConcreteBTField l →+* ConcreteBTField r :=
instance instAlgebraTowerConcreteBTF : AlgebraTower (ConcreteBTField) where
algebraMap := concreteTowerAlgebraMap
commutes' := by admit /- proof elided -/
def ConcreteBTFieldAlgebra {l r : ℕ} (h_le : l ≤ r) :
Algebra (ConcreteBTField l) (ConcreteBTField r) := instAlgebraTowerConcreteBTF.toAlgebra h_le
def join_via_add_smul (k : ℕ) (h_pos : k > 0) (hi_btf lo_btf : ConcreteBTField (k - 1)) :
ConcreteBTField k :=
end ConcreteBTFieldAlgebraConstruction
noncomputable section ConcreteMultilinearBasis
open Module
def basisSucc (k : ℕ) : Basis (Fin 2) (ConcreteBTField k) (ConcreteBTField (k + 1)) :=
def powerBasisSucc (k : ℕ) :
PowerBasis (ConcreteBTField k) (ConcreteBTField (k + 1)) := | @[simp]
theorem minPoly_of_powerBasisSucc_generator (k : ℕ) :
(minpoly (ConcreteBTField k) (powerBasisSucc k).gen) = X^2 + (Z k) • X + 1 := | := by
unfold powerBasisSucc
simp only
rw [←C_mul']
letI: Fintype (ConcreteBTField k) := (getBTFResult k).instFintype
refine Eq.symm (minpoly.unique' (ConcreteBTField k) (Z (k + 1)) ?_ ?_ ?_)
· exact (definingPoly_is_monic (s:=Z (k)))
· exact aeval_definingPoly_at_Z_succ k
· intro q h_degQ_lt_deg_minPoly
-- h_degQ_lt_deg_minPoly : q.degree < (X ^ 2 + Z k • X + 1).degree
-- ⊢ q = 0 ∨ (aeval (Z (k + 1))) q ≠ 0
have h_degree_definingPoly : (definingPoly (s:=Z (k))).degree = 2 := by
exact degree_definingPoly (s:=Z (k))
rw [←definingPoly, h_degree_definingPoly] at h_degQ_lt_deg_minPoly
if h_q_is_zero : q = 0 then
rw [h_q_is_zero]
simp only [map_zero, ne_eq, not_true_eq_false, or_false]
else
-- reason stuff related to IsUnit here
have h_q_is_not_zero : q ≠ 0 := by omega
simp only [h_q_is_zero, ne_eq, false_or]
-- ⊢ ¬(aeval (Z (k + 1))) q = 0
have h_deg_q_ne_bot : q.degree ≠ ⊥ := by
exact degree_ne_bot.mpr h_q_is_zero
have q_natDegree_lt_2 : q.natDegree < 2 := by
exact (natDegree_lt_iff_degree_lt h_q_is_zero).mpr h_degQ_lt_deg_minPoly
-- do case analysis on q.degree
interval_cases hqNatDeg : q.natDegree
· simp only [ne_eq]
have h_q_is_c : ∃ r : ConcreteBTField k, q = C r := by
use q.coeff 0
exact Polynomial.eq_C_of_natDegree_eq_zero hqNatDeg
let hx := h_q_is_c.choose_spec
set x := h_q_is_c.choose
simp only [hx, aeval_C, map_eq_zero, ne_eq]
-- ⊢ ¬x = 0
by_contra h_x_eq_0
simp only [h_x_eq_0, map_zero] at hx -- hx : q = 0, h_q_is_not_zero : q ≠ 0
contradiction
· have h_q_natDeg_ne_0 : q.natDegree ≠ 0 := by exact ne_zero_of_eq_one hqNatDeg
have h_q_deg_ne_0 : q.degree ≠ 0 := by
by_contra h_q_deg_is_0
have h_q_natDeg_is_0 : q.natDegree = 0 := by exact
(degree_eq_iff_natDegree_eq h_q_is_zero).mp h_q_deg_is_0
contradiction
have h_natDeg_q_is_1 : q.natDegree = 1 := by exact hqNatDeg
have h_deg_q_is_1 : q.degree = 1 := by
apply (degree_eq_iff_natDegree_eq h_q_is_zero).mpr
exact hqNatDeg
have h_q_is_not_unit : ¬IsUnit q := by
by_contra h_q_is_unit
rw [←is_unit_iff_deg_0] at h_q_is_unit
contradiction
let c := q.coeff 1
let r := q.coeff 0
have hc : c = q.leadingCoeff := by
rw [Polynomial.leadingCoeff]
exact congrArg q.toFinsupp.2 (id (Eq.symm hqNatDeg))
have hc_ne_zero : c ≠ 0 := by
rw [hc]
by_contra h_c_eq_zero
simp only [leadingCoeff_eq_zero] at h_c_eq_zero -- h_c_eq_zero : q = 0
contradiction
have hq_form : q = c • X + C r := by
rw [Polynomial.eq_X_add_C_of_degree_eq_one (p:=q) (h:=by exact h_deg_q_is_1)]
congr
rw [hc]
exact C_mul' q.leadingCoeff X
-- ⊢ ¬(aeval (Z (k + 1))) q = 0
simp only [hq_form, map_add, map_smul, aeval_X, aeval_C, ne_eq]
-- ⊢ ¬Z k • Z (k + 1) + (algebraMap (ConcreteBTField k) (ConcreteBTField (k + 1))) x = 0
have h_split_smul := split_smul_Z_eq_zero_x (k:=k+1) (h_pos:=by omega) (x:=c)
rw [smul_Z_eq_zero_x (k:=k+1) (h_pos:=by omega) (x:=c)]
have h_alg_map_x := algebraMap_succ_eq_zero_x (k:=k+1) (h_pos:=by omega) (x:=r)
simp only [Nat.add_one_sub_one] at h_alg_map_x
rw [h_alg_map_x, join_add_join]
simp only [Nat.add_one_sub_one, _root_.add_zero, _root_.zero_add,
ne_eq]
-- ⊢ ¬join ⋯ c x = 0
by_contra h_join_eq_zero
conv_rhs at h_join_eq_zero =>
rw [←zero_is_0];
rw! [←join_zero_zero (k:=k+1) (h_k:=by omega)]
rw [join_eq_join_iff] at h_join_eq_zero
have h_c_eq_zero := h_join_eq_zero.1
contradiction | 16 | 324 | false | Applied verif. |
3 | AdditiveNTT.evaluation_poly_split_identity | theorem evaluation_poly_split_identity (i : Fin (ℓ))
(coeffs : Fin (2 ^ (ℓ - i)) → L) :
let P_i: L[X] := intermediateEvaluationPoly 𝔽q β h_ℓ_add_R_rate ⟨i, by omega⟩ coeffs
let P_even_i_plus_1: L[X] := evenRefinement 𝔽q β h_ℓ_add_R_rate i coeffs
let P_odd_i_plus_1: L[X] := oddRefinement 𝔽q β h_ℓ_add_R_rate i coeffs
let q_i: L[X] := qMap 𝔽q β ⟨i, by omega⟩
P_i = (P_even_i_plus_1.comp q_i) + X * (P_odd_i_plus_1.comp q_i) | ArkLib | ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean | [
"import ArkLib.Data.FieldTheory.AdditiveNTT.NovelPolynomialBasis",
"import Mathlib.Data.Finsupp.Defs",
"import ArkLib.Data.Fin.BigOperators",
"import Mathlib.Tactic",
"import ArkLib.Data.Nat.Bitwise",
"import Mathlib.LinearAlgebra.LinearIndependent.Defs"
] | [
{
"name": "Fin",
"module": "Init.Prelude"
},
{
"name": "Subspace",
"module": "Mathlib.Algebra.Module.Submodule.Basic"
},
{
"name": "Set",
"module": "Mathlib.Data.Set.Defs"
},
{
"name": "Set.Ico",
"module": "Mathlib.Order.Interval.Set.Defs"
},
{
"name": "Submodule",
"module": "Mathlib.Algebra.Module.Submodule.Defs"
},
{
"name": "Submodule.span",
"module": "Mathlib.LinearAlgebra.Span.Defs"
},
{
"name": "Polynomial.C",
"module": "Mathlib.Algebra.Polynomial.Basic"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "Fintype",
"module": "Mathlib.Data.Fintype.Defs"
},
{
"name": "Fintype.card",
"module": "Mathlib.Data.Fintype.Card"
},
{
"name": "algebraMap",
"module": "Mathlib.Algebra.Algebra.Defs"
},
{
"name": "Fin.foldl",
"module": "Init.Data.Fin.Fold"
},
{
"name": "context",
"module": "Examples.FrankingProtocol"
},
{
"name": "Finset",
"module": "Mathlib.Data.Finset.Defs"
},
{
"name": "Finset.univ",
"module": "Mathlib.Data.Fintype.Defs"
},
{
"name": "Finset.range",
"module": "Mathlib.Data.Finset.Range"
},
{
"name": "reduceDIte",
"module": "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Core"
},
{
"name": "Eq",
"module": "Init.Prelude"
},
{
"name": "Polynomial",
"module": "Mathlib.Algebra.Polynomial.Basic"
},
{
"name": "DecidableEq",
"module": "Init.Prelude"
},
{
"name": "AddCommMonoid",
"module": "Mathlib.Algebra.Group.Defs"
}
] | [
{
"name": "W",
"content": "noncomputable def W (i : Fin r) : L[X] :=\n ∏ u : U 𝔽q β i, (X - C u.val)"
},
{
"name": "U",
"content": "def U (i : Fin r) : Subspace 𝔽q L := Submodule.span 𝔽q (β '' (Set.Ico 0 i))"
},
{
"name": "normalizedW",
"content": "noncomputable def normalizedW (i : Fin r) : L[X] :=\n C (1 / (W 𝔽q β i).eval (β i)) * W 𝔽q β i"
},
{
"name": "getBit",
"content": "def getBit (k n : Nat) : Nat := (n >>> k) &&& 1"
},
{
"name": "g",
"content": "def g (n : ℕ) (c : ℕ) (x : ℕ) := (x * x + c) % n"
}
] | [
{
"name": "Polynomial.comp_assoc",
"module": "Mathlib.Algebra.Polynomial.Eval.Defs"
},
{
"name": "implies_true",
"module": "Init.SimpLemmas"
},
{
"name": "Fin.coe_ofNat_eq_mod",
"module": "Mathlib.Data.Fin.Basic"
},
{
"name": "Fin.foldl_succ",
"module": "Init.Data.Fin.Fold"
},
{
"name": "Fin.val_succ",
"module": "Init.Data.Fin.Lemmas"
},
{
"name": "Nat.zero_mod",
"module": "Init.Data.Nat.Div.Basic"
},
{
"name": "Polynomial.X_comp",
"module": "Mathlib.Algebra.Polynomial.Eval.Defs"
},
{
"name": "Polynomial.comp_X",
"module": "Mathlib.Algebra.Polynomial.Eval.Defs"
},
{
"name": "add_zero",
"module": "Mathlib.Algebra.Group.Defs"
},
{
"name": "Nat.and_one_is_mod",
"module": "Init.Data.Nat.Bitwise.Lemmas"
},
{
"name": "Nat.mod_succ",
"module": "Init.Data.Nat.Lemmas"
},
{
"name": "Nat.mul_add_mod_self_right",
"module": "Init.Data.Nat.Div.Basic"
},
{
"name": "Nat.shiftRight_zero",
"module": "Init.Data.Nat.Bitwise.Basic"
},
{
"name": "Polynomial.pow_comp",
"module": "Mathlib.Algebra.Polynomial.Eval.Defs"
},
{
"name": "Polynomial.prod_comp",
"module": "Mathlib.Algebra.Polynomial.Eval.Defs"
},
{
"name": "pow_one",
"module": "Mathlib.Algebra.Group.Defs"
},
{
"name": "Finset.prod_congr",
"module": "Mathlib.Algebra.BigOperators.Group.Finset.Basic"
},
{
"name": "mul_comm",
"module": "Mathlib.Algebra.Group.Defs"
},
{
"name": "one_mul",
"module": "Mathlib.Algebra.Group.Defs"
},
{
"name": "pow_zero",
"module": "Mathlib.Algebra.Group.Defs"
},
{
"name": "Fin.eta",
"module": "Init.Data.Fin.Lemmas"
},
{
"name": "Fin.is_lt",
"module": "Init.Data.Fin.Lemmas"
},
{
"name": "Fin.sum_univ_eq_sum_range",
"module": "Mathlib.Data.Fintype.BigOperators"
},
{
"name": "Finset.mul_sum",
"module": "Mathlib.Algebra.BigOperators.Ring.Finset"
},
{
"name": "Finset.sum_congr",
"module": "Mathlib.Algebra.BigOperators.Group.Finset.Basic"
},
{
"name": "Nat.two_pow_pred_mul_two",
"module": "Init.Data.Nat.Lemmas"
},
{
"name": "Polynomial.C_comp",
"module": "Mathlib.Algebra.Polynomial.Eval.Defs"
},
{
"name": "Polynomial.mul_comp",
"module": "Mathlib.Algebra.Polynomial.Eval.Defs"
},
{
"name": "Polynomial.sum_comp",
"module": "Mathlib.Algebra.Polynomial.Eval.Defs"
},
{
"name": "map_eq_zero",
"module": "Mathlib.Algebra.GroupWithZero.Units.Lemmas"
},
{
"name": "mul_eq_mul_left_iff",
"module": "Mathlib.Algebra.GroupWithZero.Defs"
},
{
"name": "or_false",
"module": "Init.SimpLemmas"
},
{
"name": "or_true",
"module": "Init.SimpLemmas"
}
] | [
{
"name": "Xⱼ_zero_eq_one",
"content": "lemma Xⱼ_zero_eq_one (ℓ : ℕ) (h_ℓ : ℓ ≤ r) :\n Xⱼ 𝔽q β ℓ h_ℓ ⟨0, by exact Nat.two_pow_pos ℓ⟩ = 1"
},
{
"name": "getBit_eq_succ_getBit_of_mul_two_add_one",
"content": "lemma getBit_eq_succ_getBit_of_mul_two_add_one {n k : ℕ} : getBit (k+1) (2*n + 1) = getBit k n"
},
{
"name": "getBit_of_shiftRight",
"content": "lemma getBit_of_shiftRight {n p : ℕ}:\n ∀ k, getBit k (n >>> p) = getBit (k+p) n"
},
{
"name": "mul_two_add_bit_lt_two_pow",
"content": "theorem mul_two_add_bit_lt_two_pow (a b c : ℕ) (i : Fin 2)\n (h_a : a < 2 ^ b) (h_b : b < c) :\n a * 2 + i.val < 2^c"
},
{
"name": "lt_two_pow_of_lt_two_pow_exp_le",
"content": "lemma lt_two_pow_of_lt_two_pow_exp_le (x i j: ℕ)\n (h_x_lt_2_pow_i: x < 2^i) (h_i_le_j: i ≤ j): x < 2^j"
},
{
"name": "getBit_zero_of_two_mul",
"content": "lemma getBit_zero_of_two_mul {n : ℕ} : getBit 0 (2*n) = 0"
},
{
"name": "getBit_eq_succ_getBit_of_mul_two",
"content": "lemma getBit_eq_succ_getBit_of_mul_two {n k : ℕ} : getBit (k+1) (2*n) = getBit k n"
},
{
"name": "Fin.sum_univ_odd_even",
"content": "theorem Fin.sum_univ_odd_even {n : ℕ} {M : Type*} [AddCommMonoid M] (f : ℕ → M) :\n (∑ i : Fin (2 ^ n), f (2 * i)) + (∑ i : Fin (2 ^ n), f (2 * i + 1))\n = ∑ i: Fin (2 ^ (n+1)), f i"
}
] | [
{
"name": "AdditiveNTT.qMap",
"content": "noncomputable def qMap (i : Fin r) : L[X] :=\n let constMultiplier := ((W 𝔽q β i).eval (β i))^(Fintype.card 𝔽q)\n / ((W 𝔽q β (i + 1)).eval (β (i + 1)))\n C constMultiplier * ∏ c: 𝔽q, (X - C (algebraMap 𝔽q L c))"
},
{
"name": "AdditiveNTT.intermediateNormVpoly",
"content": "noncomputable def intermediateNormVpoly\n \n (i: Fin (ℓ+1)) (k : Fin (ℓ - i + 1)) : L[X] :=\n \n Fin.foldl (n:=k) (fun acc j =>\n (qMap 𝔽q β ⟨(i : ℕ) + (j : ℕ), by admit /- proof elided -/\n ⟩).comp acc) (X)"
},
{
"name": "AdditiveNTT.intermediateNovelBasisX",
"content": "noncomputable def intermediateNovelBasisX (i : Fin (ℓ + 1)) (j : Fin (2 ^ (ℓ - i))) : L[X] :=\n (Finset.univ: Finset (Fin (ℓ - i)) ).prod (fun k =>\n (intermediateNormVpoly 𝔽q β h_ℓ_add_R_rate i (k:=⟨k, by admit /- proof elided -/\n ⟩)) ^ (Nat.getBit k j))"
},
{
"name": "AdditiveNTT.intermediateEvaluationPoly",
"content": "noncomputable def intermediateEvaluationPoly (i : Fin (ℓ + 1))\n (coeffs : Fin (2 ^ (ℓ - i)) → L) : L[X] :=\n ∑ (⟨j, hj⟩: Fin (2^(ℓ-i))), C (coeffs ⟨j, by admit /- proof elided -/\n ⟩) *\n (intermediateNovelBasisX 𝔽q β h_ℓ_add_R_rate i ⟨j, by admit /- proof elided -/\n ⟩)"
},
{
"name": "AdditiveNTT.evenRefinement",
"content": "noncomputable def evenRefinement (i : Fin (ℓ))\n (coeffs : Fin (2 ^ (ℓ - i)) → L) : L[X] :=\n ∑ (⟨j, hj⟩: Fin (2^(ℓ-i-1))), C (coeffs ⟨j*2, by admit /- proof elided -/\n ⟩) * (intermediateNovelBasisX 𝔽q β h_ℓ_add_R_rate ⟨i+1, by admit /- proof elided -/\n ⟩ ⟨j, hj⟩)"
},
{
"name": "AdditiveNTT.oddRefinement",
"content": "noncomputable def oddRefinement (i : Fin (ℓ))\n (coeffs : Fin (2 ^ (ℓ - i)) → L) : L[X] :=\n ∑ (⟨j, hj⟩: Fin (2^(ℓ-i-1))), C (coeffs ⟨j*2+1, by admit /- proof elided -/\n ⟩) * (intermediateNovelBasisX 𝔽q β h_ℓ_add_R_rate ⟨i+1, by admit /- proof elided -/\n ⟩ ⟨j, hj⟩)"
}
] | [
{
"name": "AdditiveNTT.Polynomial.foldl_comp",
"content": "omit [Fintype L] [DecidableEq L] in\ntheorem Polynomial.foldl_comp (n : ℕ) (f : Fin n → L[X]) : ∀ initInner initOuter: L[X],\n Fin.foldl (n:=n) (fun acc j => (f j).comp acc) (initOuter.comp initInner)\n = (Fin.foldl (n:=n) (fun acc j => (f j).comp acc) (initOuter)).comp initInner"
},
{
"name": "AdditiveNTT.intermediateNormVpoly_comp_qmap",
"content": "theorem intermediateNormVpoly_comp_qmap (i : Fin (ℓ))\n (k : Fin (ℓ - i - 1)) : -- corresponds to intermediateNormVpoly_comp"
},
{
"name": "AdditiveNTT.intermediateNormVpoly_comp_qmap_helper",
"content": "theorem intermediateNormVpoly_comp_qmap_helper (i : Fin (ℓ))\n (k : Fin (ℓ - (↑i + 1))) :\n (intermediateNormVpoly 𝔽q β h_ℓ_add_R_rate\n ⟨↑i + 1, by omega⟩ (k:=⟨k, by simp only; omega⟩)).comp (qMap 𝔽q β ⟨↑i, by omega⟩) =\n intermediateNormVpoly 𝔽q β h_ℓ_add_R_rate\n ⟨↑i, by omega⟩ ⟨k + 1, by simp only; omega⟩"
},
{
"name": "AdditiveNTT.even_index_intermediate_novel_basis_decomposition",
"content": "lemma even_index_intermediate_novel_basis_decomposition (i : Fin ℓ) (j : Fin (2 ^ (ℓ - i - 1))) :\n intermediateNovelBasisX 𝔽q β h_ℓ_add_R_rate ⟨i, by omega⟩ ⟨j * 2, by\n apply mul_two_add_bit_lt_two_pow j (ℓ-i-1) (ℓ-i) ⟨0, by omega⟩ (by omega) (by omega)\n ⟩ = (intermediateNovelBasisX 𝔽q β h_ℓ_add_R_rate ⟨i+1, by omega⟩ ⟨j, by\n apply lt_two_pow_of_lt_two_pow_exp_le j (ℓ-i-1) (ℓ-(i+1)) (by omega) (by omega)\n ⟩).comp (qMap 𝔽q β ⟨i, by omega⟩)"
},
{
"name": "AdditiveNTT.odd_index_intermediate_novel_basis_decomposition",
"content": "lemma odd_index_intermediate_novel_basis_decomposition\n (i : Fin ℓ) (j : Fin (2 ^ (ℓ - i - 1))) :\n intermediateNovelBasisX 𝔽q β h_ℓ_add_R_rate ⟨i, by omega⟩ ⟨j * 2 + 1, by\n apply mul_two_add_bit_lt_two_pow j (ℓ-i-1) (ℓ-i) ⟨1, by omega⟩ (by omega) (by omega)\n ⟩ = X * (intermediateNovelBasisX 𝔽q β h_ℓ_add_R_rate ⟨i+1, by omega⟩ ⟨j, by\n apply lt_two_pow_of_lt_two_pow_exp_le j (ℓ-i-1) (ℓ-(i+1)) (by omega) (by omega)\n ⟩).comp (qMap 𝔽q β ⟨i, by omega⟩)"
}
] | import ArkLib.Data.FieldTheory.AdditiveNTT.NovelPolynomialBasis
import Mathlib.Tactic
import Mathlib.Data.Finsupp.Defs
import Mathlib.LinearAlgebra.LinearIndependent.Defs
open Polynomial AdditiveNTT Module
namespace AdditiveNTT
variable {r : ℕ} [NeZero r]
variable {L : Type u} [Field L] [Fintype L] [DecidableEq L]
variable (𝔽q : Type u) [Field 𝔽q] [Fintype 𝔽q] [DecidableEq 𝔽q]
[h_Fq_char_prime : Fact (Nat.Prime (ringChar 𝔽q))] [hF₂ : Fact (Fintype.card 𝔽q = 2)]
variable [Algebra 𝔽q L]
variable (β : Fin r → L) [hβ_lin_indep : Fact (LinearIndependent 𝔽q β)]
[h_β₀_eq_1 : Fact (β 0 = 1)]
variable {ℓ R_rate : ℕ} (h_ℓ_add_R_rate : ℓ + R_rate < r)-- ℓ ∈ {1, ..., r-1}
section IntermediateStructures
noncomputable def qMap (i : Fin r) : L[X] :=
let constMultiplier := ((W 𝔽q β i).eval (β i))^(Fintype.card 𝔽q)
/ ((W 𝔽q β (i + 1)).eval (β (i + 1)))
C constMultiplier * ∏ c: 𝔽q, (X - C (algebraMap 𝔽q L c))
noncomputable section DomainBijection
end DomainBijection
noncomputable def intermediateNormVpoly
(i: Fin (ℓ+1)) (k : Fin (ℓ - i + 1)) : L[X] :=
Fin.foldl (n:=k) (fun acc j =>
(qMap 𝔽q β ⟨(i : ℕ) + (j : ℕ), by admit /- proof elided -/
⟩).comp acc) (X)
noncomputable def intermediateNovelBasisX (i : Fin (ℓ + 1)) (j : Fin (2 ^ (ℓ - i))) : L[X] :=
(Finset.univ: Finset (Fin (ℓ - i)) ).prod (fun k =>
(intermediateNormVpoly 𝔽q β h_ℓ_add_R_rate i (k:=⟨k, by admit /- proof elided -/
⟩)) ^ (Nat.getBit k j))
noncomputable def intermediateEvaluationPoly (i : Fin (ℓ + 1))
(coeffs : Fin (2 ^ (ℓ - i)) → L) : L[X] :=
∑ (⟨j, hj⟩: Fin (2^(ℓ-i))), C (coeffs ⟨j, by admit /- proof elided -/
⟩) *
(intermediateNovelBasisX 𝔽q β h_ℓ_add_R_rate i ⟨j, by admit /- proof elided -/
⟩)
noncomputable def evenRefinement (i : Fin (ℓ))
(coeffs : Fin (2 ^ (ℓ - i)) → L) : L[X] :=
∑ (⟨j, hj⟩: Fin (2^(ℓ-i-1))), C (coeffs ⟨j*2, by admit /- proof elided -/
⟩) * (intermediateNovelBasisX 𝔽q β h_ℓ_add_R_rate ⟨i+1, by admit /- proof elided -/
⟩ ⟨j, hj⟩)
noncomputable def oddRefinement (i : Fin (ℓ))
(coeffs : Fin (2 ^ (ℓ - i)) → L) : L[X] :=
∑ (⟨j, hj⟩: Fin (2^(ℓ-i-1))), C (coeffs ⟨j*2+1, by admit /- proof elided -/
⟩) * (intermediateNovelBasisX 𝔽q β h_ℓ_add_R_rate ⟨i+1, by admit /- proof elided -/
⟩ ⟨j, hj⟩) | theorem evaluation_poly_split_identity (i : Fin (ℓ))
(coeffs : Fin (2 ^ (ℓ - i)) → L) :
let P_i: L[X] := | := intermediateEvaluationPoly 𝔽q β h_ℓ_add_R_rate ⟨i, by omega⟩ coeffs
let P_even_i_plus_1: L[X] := evenRefinement 𝔽q β h_ℓ_add_R_rate i coeffs
let P_odd_i_plus_1: L[X] := oddRefinement 𝔽q β h_ℓ_add_R_rate i coeffs
let q_i: L[X] := qMap 𝔽q β ⟨i, by omega⟩
P_i = (P_even_i_plus_1.comp q_i) + X * (P_odd_i_plus_1.comp q_i) := by
simp only [intermediateEvaluationPoly, Fin.eta]
simp only [evenRefinement, Fin.eta, sum_comp, mul_comp, C_comp, oddRefinement]
set leftEvenTerm := ∑ ⟨j, hj⟩ : Fin (2 ^ (ℓ - ↑i - 1)), C (coeffs ⟨j * 2, by
exact mul_two_add_bit_lt_two_pow j (ℓ-i-1) (ℓ-i) ⟨0, by omega⟩ (by omega) (by omega)
⟩) * intermediateNovelBasisX 𝔽q β h_ℓ_add_R_rate ⟨↑i, by omega⟩ ⟨j * 2, by
exact mul_two_add_bit_lt_two_pow j (ℓ-i-1) (ℓ-i) ⟨0, by omega⟩ (by omega) (by omega)
⟩
set leftOddTerm := ∑ ⟨j, hj⟩ : Fin (2 ^ (ℓ - ↑i - 1)), C (coeffs ⟨j * 2 + 1, by
apply mul_two_add_bit_lt_two_pow j (ℓ-i-1) (ℓ-i) ⟨1, by omega⟩ (by omega) (by omega)
⟩) * intermediateNovelBasisX 𝔽q β h_ℓ_add_R_rate ⟨↑i, by omega⟩ ⟨j * 2 + 1, by
exact mul_two_add_bit_lt_two_pow j (ℓ-i-1) (ℓ-i) ⟨1, by omega⟩ (by omega) (by omega)
⟩
have h_split_P_i: ∑ ⟨j, hj⟩ : Fin (2 ^ (ℓ - ↑i)), C (coeffs ⟨j, by
apply lt_two_pow_of_lt_two_pow_exp_le j (ℓ-i) (ℓ-i) (by omega) (by omega)
⟩) * intermediateNovelBasisX 𝔽q β h_ℓ_add_R_rate ⟨↑i, by omega⟩ ⟨j, by omega⟩ =
leftEvenTerm + leftOddTerm
:= by
unfold leftEvenTerm leftOddTerm
simp only [Fin.eta]
-- ⊢ ∑ k ∈ Fin (2 ^ (ℓ - ↑i)), C (coeffsₖ) * Xₖ⁽ⁱ⁾(X) = -- just pure even odd split
-- ∑ k ∈ Fin (2 ^ (ℓ - ↑i - 1)), C (coeffs₂ₖ) * X₂ₖ⁽ⁱ⁾(X) +
-- ∑ k ∈ Fin (2 ^ (ℓ - ↑i - 1)), C (coeffs₂ₖ+1) * X₂ₖ+1⁽ⁱ⁾(X)
set f1 := fun x: ℕ => -- => use a single function to represent the sum
if hx: x < 2 ^ (ℓ - ↑i) then
C (coeffs ⟨x, hx⟩) *
intermediateNovelBasisX 𝔽q β h_ℓ_add_R_rate ⟨↑i, by omega⟩ ⟨x, by omega⟩
else 0
have h_x: ∀ x: Fin (2 ^ (ℓ - ↑i)), f1 x.val =
C (coeffs ⟨x.val, by omega⟩) *
intermediateNovelBasisX 𝔽q β h_ℓ_add_R_rate ⟨↑i, by omega⟩
⟨x.val, by simp only; omega⟩ := by
intro x
unfold f1
simp only [Fin.is_lt, ↓reduceDIte, Fin.eta]
conv_lhs =>
enter [2, x]
rw [←h_x x]
have h_x_2: ∀ x: Fin (2 ^ (ℓ - ↑i - 1)), f1 (x*2) =
C (coeffs ⟨x.val * 2, by
calc _ < 2 ^ (ℓ - i - 1) * 2 := by omega
_ = 2 ^ (ℓ - i) := Nat.two_pow_pred_mul_two (w:=ℓ - i) (h:=by omega)
⟩) *
intermediateNovelBasisX 𝔽q β h_ℓ_add_R_rate ⟨↑i, by omega⟩ ⟨x.val * 2, by
exact mul_two_add_bit_lt_two_pow x.val (ℓ-i-1) (ℓ-i) ⟨0, by omega⟩ (by omega) (by omega)
⟩ := by
intro x
unfold f1
simp only
have h_x_lt_2_pow_i_minus_1 :=
mul_two_add_bit_lt_two_pow x.val (ℓ-i-1) (ℓ-i) ⟨0, by omega⟩ (by omega) (by omega)
simp at h_x_lt_2_pow_i_minus_1
simp only [h_x_lt_2_pow_i_minus_1, ↓reduceDIte]
conv_rhs =>
enter [1, 2, x]
rw [←h_x_2 x]
have h_x_3: ∀ x: Fin (2 ^ (ℓ - ↑i - 1)), f1 (x*2+1) =
C (coeffs ⟨x.val * 2 + 1, by
calc _ < 2 ^ (ℓ - i - 1) * 2 := by omega
_ = 2 ^ (ℓ - i) := Nat.two_pow_pred_mul_two (w:=ℓ - i) (h:=by omega)
⟩) *
intermediateNovelBasisX 𝔽q β h_ℓ_add_R_rate ⟨↑i, by omega⟩ ⟨x.val * 2 + 1, by
exact mul_two_add_bit_lt_two_pow x.val (ℓ-i-1) (ℓ-i) ⟨1, by omega⟩ (by omega) (by omega)
⟩ := by
intro x
unfold f1
simp only
have h_x_lt_2_pow_i_minus_1 := mul_two_add_bit_lt_two_pow x.val
(ℓ-i-1) (ℓ-i) ⟨1, by omega⟩ (by omega) (by omega)
simp only [h_x_lt_2_pow_i_minus_1, ↓reduceDIte]
conv_rhs =>
enter [2, 2, x]
rw [←h_x_3 x]
-- ⊢ ∑ x, f1 ↑x = ∑ x, f1 (↑x * 2) + ∑ x, f1 (↑x * 2 + 1)
have h_1: ∑ i ∈ Finset.range (2 ^ (ℓ - ↑i)), f1 i
= ∑ i ∈ Finset.range (2 ^ (ℓ - ↑i - 1 + 1)), f1 i := by
congr
omega
have res := Fin.sum_univ_odd_even (f:=f1) (n:=(ℓ - ↑i - 1))
conv_rhs at res =>
rw [Fin.sum_univ_eq_sum_range]
rw [←h_1]
rw [←Fin.sum_univ_eq_sum_range]
rw [←res]
congr
· funext i
rw [mul_comm]
· funext i
rw [mul_comm]
conv_lhs => rw [h_split_P_i]
set rightEvenTerm := ∑ ⟨j, hj⟩ : Fin (2 ^ (ℓ - ↑i - 1)),
C (coeffs ⟨j * 2, by
calc _ < 2 ^ (ℓ - i - 1) * 2 := by omega
_ = 2 ^ (ℓ - i) := Nat.two_pow_pred_mul_two (w:=ℓ - i) (h:=by omega)
⟩) *
(intermediateNovelBasisX 𝔽q β h_ℓ_add_R_rate ⟨i + 1, by omega⟩ ⟨j, by
apply lt_two_pow_of_lt_two_pow_exp_le (x:=j)
(i := ℓ-↑i-1) (j:=ℓ-↑i-1) (by omega) (by omega)
⟩).comp (qMap 𝔽q β ⟨i, by omega⟩)
set rightOddTerm :=
X *
∑ ⟨j, hj⟩ : Fin (2 ^ (ℓ - ↑i - 1)),
C (coeffs ⟨j * 2 + 1, by
calc _ < 2 ^ (ℓ - i - 1) * 2 := by omega
_ = 2 ^ (ℓ - i) := Nat.two_pow_pred_mul_two (w:=ℓ - i) (h:=by omega)
⟩) *
(intermediateNovelBasisX 𝔽q β h_ℓ_add_R_rate ⟨i + 1, by omega⟩ ⟨j, by
apply lt_two_pow_of_lt_two_pow_exp_le (x:=j)
(i := ℓ-↑i-1) (j:=ℓ-↑i-1) (by omega) (by omega)
⟩).comp (qMap 𝔽q β ⟨i, by omega⟩)
conv_rhs => change rightEvenTerm + rightOddTerm
have h_right_even_term: leftEvenTerm = rightEvenTerm := by
unfold rightEvenTerm leftEvenTerm
apply Finset.sum_congr rfl
intro j hj
simp only [Fin.eta, mul_eq_mul_left_iff, map_eq_zero]
-- X₂ⱼ⁽ⁱ⁾ = Xⱼ⁽ⁱ⁺¹⁾(q⁽ⁱ⁾(X)) ∨ a₂ⱼ = 0
by_cases h_a_j_eq_0: coeffs ⟨j * 2, by
calc _ < 2 ^ (ℓ - i - 1) * 2 := by omega
_ = 2 ^ (ℓ - i) := Nat.two_pow_pred_mul_two (w:=ℓ - i) (h:=by omega)
⟩ = 0
· simp only [h_a_j_eq_0, or_true]
· simp only [h_a_j_eq_0, or_false]
-- X₂ⱼ⁽ⁱ⁾ = Xⱼ⁽ⁱ⁺¹⁾(q⁽ⁱ⁾(X))
exact even_index_intermediate_novel_basis_decomposition
𝔽q β h_ℓ_add_R_rate (i := ⟨i, by omega⟩) j
have h_right_odd_term: rightOddTerm = leftOddTerm := by
unfold rightOddTerm leftOddTerm
simp only [Fin.eta]
conv_rhs =>
simp only [Fin.is_lt, odd_index_intermediate_novel_basis_decomposition, Fin.eta]
enter [2, x];
rw [mul_comm (a:=X)]
rw [Finset.mul_sum]
congr
funext x
ring_nf -- just associativity and commutativity of multiplication in L[X]
rw [h_right_even_term, h_right_odd_term] | 7 | 78 | false | Applied verif. |
4 | Nat.getBit_repr | theorem getBit_repr {ℓ : Nat} : ∀ j, j < 2^ℓ →
j = ∑ k ∈ Finset.Icc 0 (ℓ-1), (getBit k j) * 2^k | ArkLib | ArkLib/Data/Nat/Bitwise.lean | [
"import Mathlib.Algebra.Order.BigOperators.Group.Finset",
"import ArkLib.Data.Fin.BigOperators",
"import Mathlib.Algebra.BigOperators.Ring.Finset",
"import Mathlib.Data.Nat.Bitwise",
"import Mathlib.Data.Finsupp.Basic",
"import Mathlib.Algebra.Order.Ring.Star",
"import Mathlib.Data.Nat.Digits.Defs",
"import Mathlib.Algebra.BigOperators.Fin"
] | [
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "Finset",
"module": "Mathlib.Data.Finset.Defs"
},
{
"name": "Finset.Icc",
"module": "Mathlib.Order.Interval.Finset.Defs"
},
{
"name": "And",
"module": "Init.Prelude"
},
{
"name": "AddCommMonoid",
"module": "Mathlib.Algebra.Group.Defs"
}
] | [
{
"name": "...",
"content": "..."
}
] | [
{
"name": "Nat.shiftRight_add",
"module": "Init.Data.Nat.Bitwise.Basic"
},
{
"name": "add_comm",
"module": "Mathlib.Algebra.Group.Defs"
},
{
"name": "Finset.Icc_self",
"module": "Mathlib.Order.Interval.Finset.Basic"
},
{
"name": "Finset.mem_Icc",
"module": "Mathlib.Order.Interval.Finset.Defs"
},
{
"name": "Finset.sum_bij'",
"module": "Mathlib.Algebra.BigOperators.Group.Finset.Defs"
},
{
"name": "Finset.sum_congr",
"module": "Mathlib.Algebra.BigOperators.Group.Finset.Basic"
},
{
"name": "Finset.sum_mul",
"module": "Mathlib.Algebra.BigOperators.Ring.Finset"
},
{
"name": "Finset.sum_singleton",
"module": "Mathlib.Algebra.BigOperators.Group.Finset.Basic"
},
{
"name": "mul_assoc",
"module": "Mathlib.Algebra.Group.Defs"
},
{
"name": "mul_comm",
"module": "Mathlib.Algebra.Group.Defs"
},
{
"name": "mul_one",
"module": "Mathlib.Algebra.Group.Defs"
},
{
"name": "pow_one",
"module": "Mathlib.Algebra.Group.Defs"
},
{
"name": "pow_zero",
"module": "Mathlib.Algebra.Group.Defs"
},
{
"name": "tsub_self",
"module": "Mathlib.Algebra.Order.Sub.Basic"
},
{
"name": "zero_add",
"module": "Mathlib.Algebra.Group.Defs"
},
{
"name": "zero_tsub",
"module": "Mathlib.Algebra.Order.Sub.Basic"
}
] | [
{
"name": "sum_Icc_split",
"content": "theorem sum_Icc_split {α : Type*} [AddCommMonoid α] (f : ℕ → α) (a b c : ℕ)\n (h₁ : a ≤ b) (h₂ : b ≤ c):\n ∑ i ∈ Finset.Icc a c, f i = ∑ i ∈ Finset.Icc a b, f i + ∑ i ∈ Finset.Icc (b+1) c, f i"
}
] | [
{
"name": "Nat.getBit",
"content": "def getBit (k n : Nat) : Nat := (n >>> k) &&& 1"
}
] | [
{
"name": "Nat.getBit_of_shiftRight",
"content": "lemma getBit_of_shiftRight {n p : ℕ}:\n ∀ k, getBit k (n >>> p) = getBit (k+p) n"
}
] | import ArkLib.Data.Fin.BigOperators
import Mathlib.Algebra.BigOperators.Ring.Finset
import Mathlib.Algebra.Order.Ring.Star
import Mathlib.Data.Nat.Bitwise
import Mathlib.Data.Nat.Digits.Defs
import Mathlib.Data.Finsupp.Basic
import Mathlib.Algebra.Order.BigOperators.Group.Finset
import Mathlib.Algebra.BigOperators.Fin
namespace Nat
def getBit (k n : Nat) : Nat := (n >>> k) &&& 1 | theorem getBit_repr {ℓ : Nat} : ∀ j, j < 2^ℓ →
j = ∑ k ∈ Finset.Icc 0 (ℓ-1), (getBit k j) * 2^k := | := by
induction ℓ with
| zero =>
-- Base case : ℓ = 0
intro j h_j
have h_j_zero : j = 0 := by exact Nat.lt_one_iff.mp h_j
subst h_j_zero
simp only [zero_tsub, Finset.Icc_self, Finset.sum_singleton, pow_zero, mul_one]
unfold getBit
rw [Nat.shiftRight_zero, Nat.and_one_is_mod]
| succ ℓ₁ ih =>
by_cases h_ℓ₁ : ℓ₁ = 0
· simp only [h_ℓ₁, zero_add, pow_one, tsub_self, Finset.Icc_self, Finset.sum_singleton,
pow_zero, mul_one];
intro j hj
interval_cases j
· simp only [getBit, Nat.shiftRight_zero, Nat.and_one_is_mod, Nat.zero_mod]
· simp only [getBit, Nat.shiftRight_zero, Nat.and_one_is_mod]
· push_neg at h_ℓ₁
set ℓ := ℓ₁ + 1
have h_ℓ_eq : ℓ = ℓ₁ + 1 := by rfl
intro j h_j
-- Inductive step : assume theorem holds for ℓ₁ = ℓ - 1
-- => show j = ∑ k ∈ Finset.range (ℓ + 1), (getBit k j) * 2^k
-- Split j into lowBits (b) and higher getLowBits (m) &
-- reason inductively from the predicate of (m, ℓ₁)
set b := getBit 0 j -- Least significant getBit : j % 2
set m := j >>> 1 -- Higher getLowBits : j / 2
have h_b_eq : b = getBit 0 j := by rfl
have h_m_eq : m = j >>> 1 := by rfl
have h_getBit_shift : ∀ k, getBit (k+1) j = getBit k m := by
intro k
rw [h_m_eq]
exact (getBit_of_shiftRight (n := j) (p := 1) k).symm
have h_j_eq : j = b + 2 * m := by
calc
_ = 2 * m + b := by
have h_m_eq : m = j/2 := by rfl
have h_b_eq : b = j%2 := by
rw [h_b_eq]; unfold getBit; rw [Nat.shiftRight_zero]; rw [Nat.and_one_is_mod];
rw [h_m_eq, h_b_eq];
rw [Nat.div_add_mod (m := j) (n := 2)]; -- n * (m / n) + m % n = m := by
_ = b + 2 * m := by omega;
have h_m : m < 2^ℓ₁ := by
by_contra h_m_ge_2_pow_ℓ
push_neg at h_m_ge_2_pow_ℓ
have h_j_ge : j ≥ 2^ℓ := by
calc _ = 2 * m + b := by rw [h_j_eq]; omega
_ ≥ 2 * (2^ℓ₁) + b := by omega
_ = 2^ℓ + b := by rw [h_ℓ_eq]; omega;
_ ≥ 2^ℓ := by omega;
exact Nat.not_lt_of_ge h_j_ge h_j -- contradiction
have h_m_repr := ih (j := m) h_m
have getBit_shift : ∀ k, getBit (k + 1) j = getBit k m := by
intro k
rw [h_m_eq]
exact (getBit_of_shiftRight (n := j) (p := 1) k).symm
-- ⊢ j = ∑ k ∈ Finset.range ℓ, getBit k j * 2 ^ k
have h_sum : ∑ k ∈ Finset.Icc 0 (ℓ-1), getBit k j * 2 ^ k
= (∑ k ∈ Finset.Icc 0 0, getBit k j * 2 ^ k)
+ (∑ k ∈ Finset.Icc 1 (ℓ-1), getBit k j * 2 ^ k) := by
apply sum_Icc_split
omega
omega
rw [h_sum]
rw [h_j_eq]
rw [Finset.Icc_self, Finset.sum_singleton, pow_zero, mul_one]
have h_sum_2 : ∑ k ∈ Finset.Icc 1 (ℓ-1), getBit k (b + 2 * m) * 2 ^ k
= ∑ k ∈ Finset.Icc 0 (ℓ₁-1), getBit k (m) * 2 ^ (k+1) := by
apply Finset.sum_bij' (fun i _ => i - 1) (fun i _ => i + 1)
· -- left inverse
intro i hi
simp only [Finset.mem_Icc] at hi ⊢
exact Nat.sub_add_cancel hi.1
· -- right inverse
intro i hi
norm_num
· -- function value match
intro i hi
rw [←h_j_eq]
rw [getBit_of_shiftRight]
have ⟨left_bound, right_bound⟩ := Finset.mem_Icc.mp hi
rw [Nat.sub_add_cancel left_bound]
· -- left membership preservation
intro i hi -- hi : i ∈ Finset.Icc 1 (ℓ - 1)
rw [Finset.mem_Icc]
have ⟨left_bound, right_bound⟩ := Finset.mem_Icc.mp hi
-- ⊢ 0 ≤ i - 1 ∧ i - 1 ≤ ℓ₁ - 1
apply And.intro
· exact Nat.pred_le_pred left_bound
· exact Nat.pred_le_pred right_bound
· -- right membership preservation
intro j hj
rw [Finset.mem_Icc]
have ⟨left_bound, right_bound⟩ := Finset.mem_Icc.mp hj -- (0 ≤ j ∧ j ≤ ℓ₁ - 1)
-- ⊢ 1 ≤ j + 1 ∧ j + 1 ≤ ℓ - 1
apply And.intro
· exact Nat.le_add_of_sub_le left_bound
· rw [h_ℓ_eq]; rw [Nat.add_sub_cancel]; -- ⊢ j + 1 ≤ ℓ₁
have h_j_add_1_le_ℓ₁ : j + 1 ≤ ℓ₁ := by
calc j + 1 ≤ (ℓ₁ - 1) + 1 := by apply Nat.add_le_add_right; exact right_bound;
_ = ℓ₁ := by rw [Nat.sub_add_cancel]; omega;
exact h_j_add_1_le_ℓ₁
rw [h_sum_2]
have h_sum_3 : ∑ k ∈ Finset.Icc 0 (ℓ₁-1), getBit k (m) * 2 ^ (k+1)
= 2 * ∑ k ∈ Finset.Icc 0 (ℓ₁-1), getBit k (m) * 2 ^ k := by
calc
_ = ∑ k ∈ Finset.Icc 0 (ℓ₁-1), ((getBit k (m) * 2^k) * 2) := by
apply Finset.sum_congr rfl (fun k hk => by
rw [Finset.mem_Icc] at hk -- hk : 0 ≤ k ∧ k ≤ ℓ₁ - 1
have h_res : getBit k (m) * 2 ^ (k+1) = getBit k (m) * 2 ^ k * 2 := by
rw [Nat.pow_succ, ←mul_assoc]
exact h_res
)
_ = (∑ k ∈ Finset.Icc 0 (ℓ₁-1), getBit k (m) * 2 ^ k) * 2 := by rw [Finset.sum_mul]
_ = 2 * ∑ k ∈ Finset.Icc 0 (ℓ₁-1), getBit k (m) * 2 ^ k := by rw [mul_comm]
rw [h_sum_3]
rw [←h_m_repr]
conv =>
rhs
rw [←h_j_eq] | 2 | 24 | true | Applied verif. |
5 | Nat.getBit_of_binaryFinMapToNat | lemma getBit_of_binaryFinMapToNat {n : ℕ} (m : Fin n → ℕ) (h_binary: ∀ j: Fin n, m j ≤ 1) :
∀ k: ℕ, Nat.getBit k (binaryFinMapToNat m h_binary).val
= if h_k: k < n then m ⟨k, by omega⟩ else 0 | ArkLib | ArkLib/Data/Nat/Bitwise.lean | [
"import Mathlib.Algebra.Order.BigOperators.Group.Finset",
"import ArkLib.Data.Fin.BigOperators",
"import Mathlib.Algebra.BigOperators.Ring.Finset",
"import Mathlib.Data.Nat.Bitwise",
"import Mathlib.Data.Finsupp.Basic",
"import Mathlib.Algebra.Order.Ring.Star",
"import Mathlib.Data.Nat.Digits.Defs",
"import Mathlib.Algebra.BigOperators.Fin"
] | [
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "Fin",
"module": "Init.Prelude"
},
{
"name": "Finset",
"module": "Mathlib.Data.Finset.Defs"
},
{
"name": "Finset.univ",
"module": "Mathlib.Data.Fintype.Defs"
},
{
"name": "Ne",
"module": "Init.Core"
},
{
"name": "NeZero",
"module": "Init.Data.NeZero"
},
{
"name": "BEq",
"module": "Init.Prelude"
},
{
"name": "reduceDIte",
"module": "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Core"
},
{
"name": "Bool",
"module": "Init.Prelude"
},
{
"name": "Nat.testBit",
"module": "Init.Data.Nat.Bitwise.Basic"
},
{
"name": "Nat.binaryRec",
"module": "Mathlib.Data.Nat.BinaryRec"
},
{
"name": "Nat.bit",
"module": "Mathlib.Data.Nat.BinaryRec"
},
{
"name": "Nat.bodd",
"module": "Mathlib.Data.Nat.Bits"
},
{
"name": "Nat.boddDiv2",
"module": "Mathlib.Data.Nat.Bits"
},
{
"name": "Nat.div2",
"module": "Mathlib.Data.Nat.Bits"
}
] | [
{
"name": "...",
"content": "..."
}
] | [
{
"name": "Nat.and_one_is_mod",
"module": "Init.Data.Nat.Bitwise.Lemmas"
},
{
"name": "Nat.mod_lt",
"module": "Init.Prelude"
},
{
"name": "Nat.ofNat_pos",
"module": "Mathlib.Data.Nat.Cast.Order.Ring"
},
{
"name": "gt_iff_lt",
"module": "Init.Core"
},
{
"name": "Nat.mod_two_bne_zero",
"module": "Init.Data.Nat.Lemmas"
},
{
"name": "Nat.one_and_eq_mod_two",
"module": "Init.Data.Nat.Bitwise.Lemmas"
},
{
"name": "beq_iff_eq",
"module": "Init.Core"
},
{
"name": "Bool.not_eq_true",
"module": "Init.SimpLemmas"
},
{
"name": "Nat.pow_le_pow_right",
"module": "Init.Data.Nat.Basic"
},
{
"name": "Nat.testBit_eq_false_of_lt",
"module": "Mathlib.Data.Nat.Bitwise"
},
{
"name": "imp_false",
"module": "Init.Core"
},
{
"name": "ite_eq_right_iff",
"module": "Init.PropLemmas"
},
{
"name": "not_lt",
"module": "Mathlib.Order.Defs.LinearOrder"
},
{
"name": "one_ne_zero",
"module": "Mathlib.Algebra.NeZero"
},
{
"name": "Nat.eq_of_testBit_eq",
"module": "Init.Data.Nat.Bitwise.Lemmas"
},
{
"name": "beq_eq_beq",
"module": "Mathlib.Logic.Basic"
},
{
"name": "Nat.and_assoc",
"module": "Init.Data.Nat.Bitwise.Lemmas"
},
{
"name": "Nat.and_comm",
"module": "Init.Data.Nat.Bitwise.Lemmas"
},
{
"name": "Nat.and_self",
"module": "Init.Data.Nat.Bitwise.Lemmas"
},
{
"name": "Nat.shiftRight_and_distrib",
"module": "Init.Data.Nat.Bitwise.Lemmas"
},
{
"name": "Nat.zero_and",
"module": "Init.Data.Nat.Bitwise.Lemmas"
},
{
"name": "Nat.zero_shiftRight",
"module": "Init.Data.Nat.Lemmas"
},
{
"name": "Nat.div_eq_zero_iff_lt",
"module": "Init.Data.Nat.Div.Lemmas"
},
{
"name": "Nat.pow_lt_pow_right",
"module": "Init.Data.Nat.Lemmas"
},
{
"name": "Nat.shiftLeft_add",
"module": "Init.Data.Nat.Lemmas"
},
{
"name": "Nat.shiftLeft_eq",
"module": "Init.Data.Nat.Bitwise.Basic"
},
{
"name": "Nat.shiftLeft_shiftRight",
"module": "Init.Data.Nat.Lemmas"
},
{
"name": "Nat.shiftRight_add",
"module": "Init.Data.Nat.Bitwise.Basic"
},
{
"name": "Nat.shiftRight_eq_div_pow",
"module": "Init.Data.Nat.Bitwise.Basic"
},
{
"name": "Nat.sub_add_cancel",
"module": "Init.Data.Nat.Basic"
},
{
"name": "Nat.two_pow_mod_two_eq_zero",
"module": "Init.Data.Nat.Mod"
},
{
"name": "Nat.two_pow_pos",
"module": "Init.Data.Nat.Basic"
},
{
"name": "one_mul",
"module": "Mathlib.Algebra.Group.Defs"
},
{
"name": "Nat.and_zero",
"module": "Init.Data.Nat.Bitwise.Lemmas"
},
{
"name": "Nat.and_xor_distrib_right",
"module": "Init.Data.Nat.Bitwise.Lemmas"
},
{
"name": "Nat.shiftRight_xor_distrib",
"module": "Init.Data.Nat.Bitwise.Lemmas"
},
{
"name": "Nat.add_mul_div_left",
"module": "Init.Data.Nat.Div.Basic"
},
{
"name": "add_comm",
"module": "Mathlib.Algebra.Group.Defs"
},
{
"name": "mul_comm",
"module": "Mathlib.Algebra.Group.Defs"
},
{
"name": "Nat.and_div_two_pow",
"module": "Init.Data.Nat.Bitwise.Lemmas"
},
{
"name": "Nat.and_mod_two_pow",
"module": "Init.Data.Nat.Bitwise.Lemmas"
},
{
"name": "Nat.div_add_mod",
"module": "Init.Data.Nat.Div.Basic"
},
{
"name": "Nat.mul_add_mod_self_right",
"module": "Init.Data.Nat.Div.Basic"
},
{
"name": "pow_one",
"module": "Mathlib.Algebra.Group.Defs"
},
{
"name": "zero_add",
"module": "Mathlib.Algebra.Group.Defs"
},
{
"name": "Nat.or_div_two_pow",
"module": "Init.Data.Nat.Bitwise.Lemmas"
},
{
"name": "Nat.or_mod_two_pow",
"module": "Init.Data.Nat.Bitwise.Lemmas"
},
{
"name": "Nat.or_self",
"module": "Init.Data.Nat.Bitwise.Lemmas"
},
{
"name": "Nat.or_zero",
"module": "Init.Data.Nat.Bitwise.Lemmas"
},
{
"name": "Nat.zero_or",
"module": "Init.Data.Nat.Bitwise.Lemmas"
},
{
"name": "Nat.xor_div_two_pow",
"module": "Init.Data.Nat.Bitwise.Lemmas"
},
{
"name": "Nat.xor_mod_two_pow",
"module": "Init.Data.Nat.Bitwise.Lemmas"
},
{
"name": "Nat.xor_self",
"module": "Init.Data.Nat.Bitwise.Lemmas"
},
{
"name": "Nat.xor_zero",
"module": "Init.Data.Nat.Bitwise.Lemmas"
},
{
"name": "Nat.zero_xor",
"module": "Init.Data.Nat.Bitwise.Lemmas"
},
{
"name": "Bool.toNat_lt",
"module": "Init.Data.Bool"
},
{
"name": "Nat.bit_decomp",
"module": "Mathlib.Data.Nat.Bits"
},
{
"name": "Nat.bit_val",
"module": "Mathlib.Data.Nat.BinaryRec"
},
{
"name": "Nat.mul_zero",
"module": "Init.Data.Nat.Basic"
},
{
"name": "Nat.right_distrib",
"module": "Init.Data.Nat.Basic"
},
{
"name": "add_assoc",
"module": "Mathlib.Algebra.Group.Defs"
},
{
"name": "add_zero",
"module": "Mathlib.Algebra.Group.Defs"
},
{
"name": "Nat.pow_zero",
"module": "Init.Data.Nat.Basic"
},
{
"name": "NeZero.ne'",
"module": "Init.Data.NeZero"
},
{
"name": "lt_add_iff_pos_right",
"module": "Mathlib.Algebra.Order.Monoid.Unbundled.Basic"
},
{
"name": "lt_self_iff_false",
"module": "Mathlib.Order.Basic"
},
{
"name": "mul_one",
"module": "Mathlib.Algebra.Group.Defs"
},
{
"name": "ne_eq",
"module": "Init.SimpLemmas"
},
{
"name": "not_lt_zero'",
"module": "Mathlib.Algebra.Order.GroupWithZero.Canonical"
},
{
"name": "sub_one_lt",
"module": "Mathlib.Algebra.Order.Ring.Unbundled.Basic"
},
{
"name": "zero_lt_one",
"module": "Mathlib.Algebra.Order.ZeroLEOne"
}
] | [
{
"name": "List.getElem_append_left{α",
"content": "theorem List.getElem_append_left{α : Type u_1} {l₁ l₂ : List α} {i : Nat} (hn : i < l₁.length) :\\n(l₁ ++ l₂)[i] = l₁[i]"
}
] | [
{
"name": "Nat.getBit",
"content": "def getBit (k n : Nat) : Nat := (n >>> k) &&& 1"
},
{
"name": "Nat.binaryFinMapToNat",
"content": "def binaryFinMapToNat {n : ℕ} (m : Fin n → ℕ) (h_binary : ∀ j: Fin n, m j ≤ 1) : Fin (2^n) :="
}
] | [
{
"name": "Nat.getBit_lt_2",
"content": "lemma getBit_lt_2 {k n : Nat} : getBit k n < 2"
},
{
"name": "Nat.getBit_eq_testBit",
"content": "lemma getBit_eq_testBit (k n : Nat) : getBit k n = if n.testBit k then 1 else 0"
},
{
"name": "Nat.getBit_zero_eq_zero",
"content": "lemma getBit_zero_eq_zero {k : Nat} : getBit k 0 = 0"
},
{
"name": "Nat.eq_iff_eq_all_getBits",
"content": "lemma eq_iff_eq_all_getBits {n m : ℕ} : n = m ↔ ∀ k, getBit k n = getBit k m"
},
{
"name": "Nat.shiftRight_and_one_distrib",
"content": "lemma shiftRight_and_one_distrib {n m k : ℕ} :\n Nat.getBit k (n &&& m) = Nat.getBit k n &&& Nat.getBit k m"
},
{
"name": "Nat.and_eq_zero_iff_and_each_getBit_eq_zero",
"content": "lemma and_eq_zero_iff_and_each_getBit_eq_zero {n m : ℕ} :\n n &&& m = 0 ↔ ∀ k, Nat.getBit k n &&& Nat.getBit k m = 0"
},
{
"name": "Nat.getBit_two_pow",
"content": "lemma getBit_two_pow {i k : ℕ} : (getBit k (2^i) = if i == k then 1 else 0)"
},
{
"name": "Nat.and_two_pow_eq_zero_of_getBit_0",
"content": "lemma and_two_pow_eq_zero_of_getBit_0 {n i : ℕ} (h_getBit : getBit i n = 0)\n : n &&& (2 ^ i) = 0"
},
{
"name": "Nat.div_2_form",
"content": "lemma div_2_form {nD2 b : ℕ} (h_b : b < 2):\n (nD2 * 2 + b) / 2 = nD2"
},
{
"name": "Nat.and_by_split_lowBits",
"content": "lemma and_by_split_lowBits {n m n1 m1 bn bm : ℕ} (h_bn : bn < 2) (h_bm : bm < 2)\n (h_n : n = n1 * 2 + bn) (h_m : m = m1 * 2 + bm):\n n &&& m = (n1 &&& m1) * 2 + (bn &&& bm)"
},
{
"name": "Nat.xor_by_split_lowBits",
"content": "lemma xor_by_split_lowBits {n m n1 m1 bn bm : ℕ} (h_bn : bn < 2) (h_bm : bm < 2)\n (h_n : n = n1 * 2 + bn) (h_m : m = m1 * 2 + bm):\n n ^^^ m = (n1 ^^^ m1) * 2 + (bn ^^^ bm)"
},
{
"name": "Nat.or_by_split_lowBits",
"content": "lemma or_by_split_lowBits {n m n1 m1 bn bm : ℕ} (h_bn : bn < 2) (h_bm : bm < 2)\n (h_n : n = n1 * 2 + bn) (h_m : m = m1 * 2 + bm):\n n ||| m = (n1 ||| m1) * 2 + (bn ||| bm)"
},
{
"name": "Nat.sum_eq_xor_plus_twice_and",
"content": "lemma sum_eq_xor_plus_twice_and (n : Nat) : ∀ m : ℕ, n + m = (n ^^^ m) + 2 * (n &&& m)"
},
{
"name": "Nat.sum_of_and_eq_zero_is_xor",
"content": "lemma sum_of_and_eq_zero_is_xor {n m : ℕ} (h_n_AND_m : n &&& m = 0) : n + m = n ^^^ m"
},
{
"name": "Nat.getBit_of_xor",
"content": "lemma getBit_of_xor {n m k: ℕ} : getBit k (n ^^^ m) = getBit k n ^^^ getBit k m"
},
{
"name": "Nat.getBit_of_lt_two_pow",
"content": "lemma getBit_of_lt_two_pow {n: ℕ} (a: Fin (2^n)) (k: ℕ) :\n getBit k a = if k < n then getBit k a else 0"
}
] | import ArkLib.Data.Fin.BigOperators
import Mathlib.Algebra.BigOperators.Ring.Finset
import Mathlib.Algebra.Order.Ring.Star
import Mathlib.Data.Nat.Bitwise
import Mathlib.Data.Nat.Digits.Defs
import Mathlib.Data.Finsupp.Basic
import Mathlib.Algebra.Order.BigOperators.Group.Finset
import Mathlib.Algebra.BigOperators.Fin
namespace Nat
def getBit (k n : Nat) : Nat := (n >>> k) &&& 1
def binaryFinMapToNat {n : ℕ} (m : Fin n → ℕ) (h_binary : ∀ j: Fin n, m j ≤ 1) : Fin (2^n) := | lemma getBit_of_binaryFinMapToNat {n : ℕ} (m : Fin n → ℕ) (h_binary: ∀ j: Fin n, m j ≤ 1) :
∀ k: ℕ, Nat.getBit k (binaryFinMapToNat m h_binary).val
= if h_k: k < n then m ⟨k, by omega⟩ else 0 := | := by
-- We prove this by induction on `n`.
induction n with
| zero =>
intro k;
simp only [Nat.pow_zero, Fin.val_eq_zero, not_lt_zero', ↓reduceDIte]
exact getBit_zero_eq_zero
| succ n ih =>
-- Inductive step: Assume the property holds for `n`, prove it for `n+1`.
have h_lt: 2^n - 1 < 2^n := by
refine sub_one_lt ?_
exact Ne.symm (NeZero.ne' (2 ^ n))
intro k
dsimp [binaryFinMapToNat]
-- ⊢ (↑k).getBit (∑ j, 2 ^ ↑j * m j) = m k
rw [Fin.sum_univ_castSucc] -- split the msb
set prevSum := ∑ i: Fin n, (2 ^ i.castSucc.val) * (m i.castSucc)
let mPrev := fun i: Fin n => m i.castSucc
have h_getBit_prevSum := ih (m:=mPrev) (h_binary:=by exact fun j ↦ h_binary j.castSucc)
have h_prevSum_eq: prevSum = binaryFinMapToNat mPrev
(by exact fun j ↦ h_binary j.castSucc) := by rfl
set msbTerm := 2 ^ ((Fin.last n).val) * m (Fin.last n)
-- ⊢ (↑k).getBit (prevSum + msbTerm) = m k
have h_m_at_last: m ⟨n, by omega⟩ ≤ 1 := by exact h_binary (Fin.last n)
have h_sum_eq_xor: prevSum + msbTerm = prevSum ^^^ msbTerm := by
rw [sum_of_and_eq_zero_is_xor]
unfold msbTerm
interval_cases h_m_last_val: m ⟨n, by omega⟩
· simp only [Fin.last, h_m_last_val, mul_zero, Nat.and_zero]
· simp only [Fin.last, h_m_last_val, mul_one]
apply and_two_pow_eq_zero_of_getBit_0
have h_getBit_prevSum_at_n := getBit_of_lt_two_pow (k:=n) (n:=n) (a:=⟨prevSum, by omega⟩)
simp only [lt_self_iff_false, ↓reduceIte] at h_getBit_prevSum_at_n
rw [h_getBit_prevSum_at_n]
rw [h_sum_eq_xor, getBit_of_xor]
if h_k_eq: k = n then
rw [h_k_eq]
simp only [lt_add_iff_pos_right, zero_lt_one, ↓reduceDIte]
rw [h_prevSum_eq]
rw [getBit_of_lt_two_pow]
simp only [lt_self_iff_false, ↓reduceIte, zero_xor]
unfold msbTerm
-- ⊢ n.getBit (2 ^ ↑(Fin.last n) * m (Fin.last n)) = m ⟨n, ⋯⟩
interval_cases h_m_last_val: m ⟨n, by omega⟩
· -- ⊢ n.getBit (2 ^ ↑(Fin.last n) * m (Fin.last n)) = 0
rw [Fin.val_last, Fin.last]
rw [h_m_last_val, mul_zero]
exact getBit_zero_eq_zero
· -- ⊢ n.getBit (2 ^ ↑(Fin.last n) * m (Fin.last n)) = 1
simp only [Fin.last]
rw [h_m_last_val, mul_one]
rw [Nat.getBit_two_pow]
simp only [BEq.rfl, ↓reduceIte]
else
have hBitLhs := h_getBit_prevSum (k:=k)
simp only at hBitLhs
rw [h_prevSum_eq.symm] at hBitLhs
rw [hBitLhs]
if h_k_lt_n: k < n then
have h_k_lt_n_add_1: k < n + 1 := by omega
simp only [h_k_lt_n_add_1, ↓reduceDIte]
push_neg at h_k_eq
simp only [h_k_lt_n, ↓reduceDIte]
unfold msbTerm
interval_cases h_m_last_val: m ⟨n, by omega⟩
· simp only [Fin.last, h_m_last_val, mul_zero]
rw [Nat.getBit_zero_eq_zero, Nat.xor_zero]
rfl
· simp only [Fin.last, h_m_last_val, mul_one]
rw [Nat.getBit_two_pow]
simp only [beq_iff_eq]
simp only [h_k_eq.symm, ↓reduceIte, xor_zero]
rfl
else
have h_k_not_lt_n_add_1: ¬(k < n + 1) := by omega
have h_k_not_lt_n: ¬(k < n) := by omega
simp only [h_k_not_lt_n_add_1, h_k_not_lt_n, ↓reduceDIte, Nat.zero_xor]
unfold msbTerm
interval_cases h_m_last_val: m ⟨n, by omega⟩
· simp only [Fin.last, h_m_last_val, mul_zero]
exact getBit_zero_eq_zero
· simp only [Fin.last, h_m_last_val, mul_one]
rw [Nat.getBit_two_pow]
simp only [beq_iff_eq]
simp only [ite_eq_right_iff, one_ne_zero, imp_false, ne_eq]
omega | 4 | 104 | true | Applied verif. |
6 | ConcreteBinaryTower.towerEquiv_commutes_left_diff | "lemma towerEquiv_commutes_left_diff (i d : ℕ) : ∀ r : ConcreteBTField i,\n (AlgebraTower.algeb(...TRUNCATED) | ArkLib | ArkLib/Data/FieldTheory/BinaryField/Tower/Impl.lean | ["import ArkLib.Data.FieldTheory.BinaryField.Tower.Prelude","import ArkLib.Data.FieldTheory.BinaryFi(...TRUNCATED) | [{"name":"Eq","module":"Init.Prelude"},{"name":"id","module":"Init.Prelude"},{"name":"BitVec","modul(...TRUNCATED) | [{"name":"GaloisField","content":"notation : 10 \"GF(\" term : 10 \")\" => GaloisField term 1"},{"na(...TRUNCATED) | [{"name":"Ne.dite_eq_left_iff","module":"Mathlib.Logic.Basic"},{"name":"Nat.add_one_sub_one","module(...TRUNCATED) | [{"name":"one_le_two_pow_n","content":"theorem one_le_two_pow_n (n : ℕ) : 1 ≤ 2 ^ n"},{"name":"d(...TRUNCATED) | [{"name":"ConcreteBinaryTower.ConcreteBTField","content":"def ConcreteBTField : ℕ → Type := fun (...TRUNCATED) | [{"name":"ConcreteBinaryTower.cast_ConcreteBTField_eq","content":"lemma cast_ConcreteBTField_eq (k m(...TRUNCATED) | "import ArkLib.Data.Classes.DCast\n\nimport ArkLib.Data.FieldTheory.BinaryField.Tower.Basic\n\nnames(...TRUNCATED) | "lemma towerEquiv_commutes_left_diff (i d : ℕ) : ∀ r : ConcreteBTField i,\n (AlgebraTower.algeb(...TRUNCATED) | ":= by\n -- If d = 0, then this is trivial\n -- For d > 0 : let j = i+d\n -- lhs of goal : righ(...TRUNCATED) | 10 | 306 | false | Applied verif. |
7 | AdditiveNTT.intermediateNormVpoly_comp | "omit [DecidableEq L] [DecidableEq 𝔽q] h_Fq_char_prime hF₂ hβ_lin_indep h_β₀_eq_1 in\ntheor(...TRUNCATED) | ArkLib | ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean | ["import ArkLib.Data.FieldTheory.AdditiveNTT.NovelPolynomialBasis","import Mathlib.Data.Finsupp.Defs(...TRUNCATED) | [{"name":"Fin","module":"Init.Prelude"},{"name":"Subspace","module":"Mathlib.Algebra.Module.Submodul(...TRUNCATED) | [{"name":"W","content":"noncomputable def W (i : Fin r) : L[X] :=\n ∏ u : U 𝔽q β i, (X - C u.(...TRUNCATED) | [{"name":"Fin.cast_eq_self","module":"Mathlib.Data.Fin.Basic"},{"name":"Fin.coe_cast","module":"Init(...TRUNCATED) | [{"name":"Xⱼ_zero_eq_one","content":"lemma Xⱼ_zero_eq_one (ℓ : ℕ) (h_ℓ : ℓ ≤ r) :\n X(...TRUNCATED) | [{"name":"AdditiveNTT.qMap","content":"noncomputable def qMap (i : Fin r) : L[X] :=\n let constMult(...TRUNCATED) | [] | "import ArkLib.Data.FieldTheory.AdditiveNTT.NovelPolynomialBasis\n\nimport Mathlib.Tactic\n\nimport (...TRUNCATED) | "omit [DecidableEq L] [DecidableEq 𝔽q] h_Fq_char_prime hF₂ hβ_lin_indep h_β₀_eq_1 in\ntheor(...TRUNCATED) | ":= by\n induction l using Fin.succRecOnSameFinType with\n | zero =>\n simp only [Fin.coe_ofNat(...TRUNCATED) | 5 | 38 | false | Applied verif. |
8 | AdditiveNTT.inductive_rec_form_W_comp | "omit h_Fq_char_prime hF₂ in\nlemma inductive_rec_form_W_comp (i : Fin r) (h_i_add_1 : i + 1 < r)\(...TRUNCATED) | ArkLib | ArkLib/Data/FieldTheory/AdditiveNTT/NovelPolynomialBasis.lean | ["import Mathlib.Algebra.Polynomial.Degree.Definitions","import ArkLib.Data.Fin.BigOperators","impor(...TRUNCATED) | [{"name":"Fin","module":"Init.Prelude"},{"name":"Subspace","module":"Mathlib.Algebra.Module.Submodul(...TRUNCATED) | [
{
"name": "getBit",
"content": "def getBit (k n : Nat) : Nat := (n >>> k) &&& 1"
}
] | [{"name":"Fact.out","module":"Mathlib.Logic.Basic"},{"name":"Fin.le_zero_iff'","module":"Mathlib.Dat(...TRUNCATED) | [{"name":"Fin.lt_succ'","content":"lemma Fin.lt_succ' (a : Fin r) (h_a_add_1 : a + 1 < r) : a < a + (...TRUNCATED) | [{"name":"AdditiveNTT.U","content":"def U (i : Fin r) : Subspace 𝔽q L := Submodule.span 𝔽q (β(...TRUNCATED) | [{"name":"AdditiveNTT.βᵢ_not_in_Uᵢ","content":"lemma βᵢ_not_in_Uᵢ (i : Fin r) :\n β i (...TRUNCATED) | "import ArkLib.Data.Nat.Bitwise\n\nimport ArkLib.Data.Polynomial.Frobenius\n\nimport ArkLib.Data.Pol(...TRUNCATED) | "omit h_Fq_char_prime hF₂ in\nlemma inductive_rec_form_W_comp (i : Fin r) (h_i_add_1 : i + 1 < r)\(...TRUNCATED) | ":= by\n intro p\n set W_i := W 𝔽q β i\n set q := Fintype.card 𝔽q\n set v := W_i.eval (β(...TRUNCATED) | 6 | 229 | false | Applied verif. |
9 | AdditiveNTT.odd_index_intermediate_novel_basis_decomposition | "lemma odd_index_intermediate_novel_basis_decomposition\n (i : Fin ℓ) (j : Fin (2 ^ (ℓ - i - (...TRUNCATED) | ArkLib | ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean | ["import ArkLib.Data.FieldTheory.AdditiveNTT.NovelPolynomialBasis","import Mathlib.Data.Finsupp.Defs(...TRUNCATED) | [{"name":"Fin","module":"Init.Prelude"},{"name":"Subspace","module":"Mathlib.Algebra.Module.Submodul(...TRUNCATED) | [{"name":"W","content":"noncomputable def W (i : Fin r) : L[X] :=\n ∏ u : U 𝔽q β i, (X - C u.(...TRUNCATED) | [{"name":"Polynomial.comp_assoc","module":"Mathlib.Algebra.Polynomial.Eval.Defs"},{"name":"implies_t(...TRUNCATED) | [{"name":"Xⱼ_zero_eq_one","content":"lemma Xⱼ_zero_eq_one (ℓ : ℕ) (h_ℓ : ℓ ≤ r) :\n X(...TRUNCATED) | [{"name":"AdditiveNTT.qMap","content":"noncomputable def qMap (i : Fin r) : L[X] :=\n let constMult(...TRUNCATED) | [{"name":"AdditiveNTT.Polynomial.foldl_comp","content":"omit [Fintype L] [DecidableEq L] in\ntheorem(...TRUNCATED) | "import ArkLib.Data.FieldTheory.AdditiveNTT.NovelPolynomialBasis\n\nimport Mathlib.Tactic\n\nimport (...TRUNCATED) | "lemma odd_index_intermediate_novel_basis_decomposition\n (i : Fin ℓ) (j : Fin (2 ^ (ℓ - i - (...TRUNCATED) | ":= by\n unfold intermediateNovelBasisX\n rw [prod_comp]\n -- ∏ k ∈ Fin (ℓ - i), (Wₖ⁽(...TRUNCATED) | 5 | 50 | false | Applied verif. |
10 | AdditiveNTT.finToBinaryCoeffs_sDomainToFin | "omit h_β₀_eq_1 in\nlemma finToBinaryCoeffs_sDomainToFin (i : Fin r) (h_i : i < ℓ + R_rate)\n (...TRUNCATED) | ArkLib | ArkLib/Data/FieldTheory/AdditiveNTT/AdditiveNTT.lean | ["import ArkLib.Data.FieldTheory.AdditiveNTT.NovelPolynomialBasis","import Mathlib.Data.Finsupp.Defs(...TRUNCATED) | [{"name":"Nat","module":"Init.Prelude"},{"name":"Fin","module":"Init.Prelude"},{"name":"Subspace","m(...TRUNCATED) | [{"name":"getBit","content":"def getBit (k n : Nat) : Nat := (n >>> k) &&& 1"},{"name":"normalizedW"(...TRUNCATED) | [{"name":"Fintype.card_le_one_iff_subsingleton","module":"Mathlib.Data.Fintype.EquivFin"},{"name":"F(...TRUNCATED) | [{"name":"Xⱼ_zero_eq_one","content":"lemma Xⱼ_zero_eq_one (ℓ : ℕ) (h_ℓ : ℓ ≤ r) :\n X(...TRUNCATED) | [{"name":"AdditiveNTT.sDomain","content":"noncomputable def sDomain (i : Fin r) : Subspace 𝔽q L :(...TRUNCATED) | [{"name":"AdditiveNTT.𝔽q_element_eq_zero_or_eq_one","content":"omit h_Fq_char_prime in\nlemma (...TRUNCATED) | "import ArkLib.Data.FieldTheory.AdditiveNTT.NovelPolynomialBasis\n\nimport Mathlib.Tactic\n\nimport (...TRUNCATED) | "omit h_β₀_eq_1 in\nlemma finToBinaryCoeffs_sDomainToFin (i : Fin r) (h_i : i < ℓ + R_rate)\n (...TRUNCATED) | ":= (sDomainToFin 𝔽q β h_ℓ_add_R_rate i h_i) x\n finToBinaryCoeffs 𝔽q (i := i) (idx :=po(...TRUNCATED) | 5 | 84 | false | Applied verif. |
End of preview. Expand
in Data Studio
VeriSoftBench
VeriSoftBench is a benchmark for evaluating neural theorem provers on software verification tasks in Lean 4.
The dataset contains 500 theorem-proving tasks drawn from 23 real-world Lean 4 repositories spanning compiler verification, type system formalization, applied verification (zero-knowledge proofs, smart contracts), semantic frameworks, and more.
📄 Paper (arXiv): https://arxiv.org/html/2602.18307v1
💻 Full benchmark + pipeline + setup: https://github.com/utopia-group/VeriSoftBench
Dataset Contents
This Hugging Face release contains the dataset of the benchmark tasks only. For the full end-to-end evaluation pipeline, please refer to the Github repository:
👉 https://github.com/utopia-group/VeriSoftBench
Each task in verisoftbench.jsonl contains:
- Theorem name, statement, and source location
- Filtered dependencies (library defs, repo defs, local context, lemmas)
- Ground truth proof
- Metadata (category, difficulty metrics, Aristotle subset membership)
Citation
@misc{xin2026verisoftbenchrepositoryscaleformalverification,
title={VeriSoftBench: Repository-Scale Formal Verification Benchmarks for Lean},
author={Yutong Xin and Qiaochu Chen and Greg Durrett and Işil Dillig},
year={2026},
eprint={2602.18307},
archivePrefix={arXiv},
primaryClass={cs.SE},
url={https://arxiv.org/abs/2602.18307},
}
- Downloads last month
- 4
Size of downloaded dataset files:
9.22 MB
Size of the auto-converted Parquet files:
6.84 MB
Number of rows:
500