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.S... | [
{
"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"... | [
{
"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) => `(LinearCo... | [
{
"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_ze... | [
{
"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": "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) ... | [
{
"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_fib... | 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"... | [
{
"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": "su... | [
{
"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": "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 : ℕ):... | [
{
"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.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.dca... | 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"... | [
{
"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 (... | [
{
"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.Fol... | [
{
"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) = get... | [
{
"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.intermedia... | [
{
"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).... | 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",
"... | [
{
"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":... | [
{
"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.... | [
{
"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",
"... | [
{
"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": "...",
"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": "Na... | [
{
"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... | 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
- 11
Size of downloaded dataset files:
9.22 MB
Size of the auto-converted Parquet files:
6.84 MB
Number of rows:
500