math / data /lean /OAI /NumberTheory /PowerFree /PrimeBlocks.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
13.4 kB
import OAI.NumberTheory.PowerFree.AdaptiveRanks
namespace OAI
open scoped BigOperators
open Matrix
open scoped BigOperators
open scoped BigOperators
namespace QuarticPowerFree
theorem product_distinct_prime_divisors_le (a : β„€) (ha : a β‰  0)
(P : Finset β„•) (hp : βˆ€ p ∈ P, p.Prime)
(hd : βˆ€ p ∈ P, (p : β„€) ∣ a) :
(∏ p ∈ P, (p : ℝ)) ≀ |(a : ℝ)| := by
have hn : a.natAbs β‰  0 := (Int.natAbs_pos.mpr ha).ne'
have hs : P βŠ† a.natAbs.primeFactors := by
intro p h
exact Nat.mem_primeFactors.mpr ⟨hp p h,
by simpa using Int.natAbs_dvd_natAbs.mpr (hd p h), hn⟩
have hh := Nat.le_of_dvd (Int.natAbs_pos.mpr ha)
((Finset.prod_dvd_prod_of_subset P a.natAbs.primeFactors id hs).trans
(Nat.prod_primeFactors_dvd a.natAbs))
have he : (a.natAbs : ℝ) = |(a : ℝ)| := by
rw [← Int.cast_natCast, Int.natCast_natAbs, Int.cast_abs]
rw [← he, ← Nat.cast_prod]
exact_mod_cast hh
theorem card_large_prime_divisors_le (a : β„€) (ha : a β‰  0)
(P : Finset β„•) (hp : βˆ€ p ∈ P, p.Prime) (hd : βˆ€ p ∈ P, (p : β„€) ∣ a)
(X ΞΆ B : ℝ) (hX : 1 < X) (hΞΆ : 0 < ΞΆ)
(hsmall : βˆ€ p ∈ P, X ^ ΞΆ ≀ (p : ℝ)) (hlarge : |(a : ℝ)| ≀ X ^ B) :
(P.card : ℝ) ≀ B / ΞΆ := by
have hx : 0 ≀ X := (zero_lt_one.trans hX).le
have h : X ^ (ΞΆ * (P.card : ℝ)) ≀ X ^ B := by
rw [Real.rpow_mul hx, Real.rpow_natCast]
calc
(X ^ ΢) ^ P.card = ∏ _p ∈ P, X ^ ΢ := (Finset.prod_const _).symm
_ ≀ ∏ p ∈ P, (p : ℝ) := Finset.prod_le_prodβ‚€
(fun _ _ => (Real.rpow_pos_of_pos (zero_lt_one.trans hX) ΞΆ).le) hsmall
_ ≀ |(a : ℝ)| := product_distinct_prime_divisors_le a ha P hp hd
_ ≀ X ^ B := hlarge
rw [le_div_iffβ‚€ hΞΆ]
simpa [mul_comm] using (Real.rpow_le_rpow_left_iff hX).mp h
theorem card_large_prime_divisors_le_floor (a : β„€) (ha : a β‰  0)
(P : Finset β„•) (hp : βˆ€ p ∈ P, p.Prime) (hd : βˆ€ p ∈ P, (p : β„€) ∣ a)
(X ΞΆ B : ℝ) (hX : 1 < X) (hΞΆ : 0 < ΞΆ)
(hsmall : βˆ€ p ∈ P, X ^ ΞΆ ≀ (p : ℝ)) (hlarge : |(a : ℝ)| ≀ X ^ B) :
P.card ≀ ⌊B / ΞΆβŒ‹β‚Š :=
Nat.le_floor (card_large_prime_divisors_le a ha P hp hd X ΞΆ B hX hΞΆ hsmall hlarge)
open scoped BigOperators
def cellKernel {K V ΞΉ : Type*} [Field K] [AddCommGroup V] [Module K V]
(ev : ΞΉ β†’ V β†’β‚—[K] K) (S : Set ΞΉ) : Submodule K V :=
β¨… i ∈ S, LinearMap.ker (ev i)
theorem cellKernel_mono {K V ΞΉ : Type*} [Field K] [AddCommGroup V] [Module K V]
(ev : ΞΉ β†’ V β†’β‚—[K] K) {S T : Set ΞΉ} (h : S βŠ† T) :
cellKernel ev T ≀ cellKernel ev S := by
intro v hv
simp only [cellKernel, Submodule.mem_iInf, LinearMap.mem_ker] at hv ⊒
exact fun i hi => hv i (h hi)
theorem adaptiveStates_length {K V Οƒ Ξ± : Type*} [Field K] [AddCommGroup V] [Module K V]
(W : β„• β†’ Οƒ β†’ Ξ± β†’ Submodule K V) (next : β„• β†’ Οƒ β†’ Submodule K V β†’ Οƒ)
(n i : β„•) (s : Οƒ) (a : Ξ±) : (adaptiveStates W next n i s a).length = n+1 := by
induction n generalizing i s with
| zero => rfl
| succ n ih => simp only [adaptiveStates, List.length_cons, ih]
theorem list_minor_product_bound {Οƒ : Type*} (l : List Οƒ) (minor : Οƒ β†’ β„€)
(X B : ℝ) (hX : 0 < X)
(hminor : βˆ€ s ∈ l, minor s β‰  0 ∧ |(minor s : ℝ)| ≀ X^B) :
(l.map minor).prod β‰  0 ∧ |(((l.map minor).prod : β„€) : ℝ)| ≀ X^(B*(l.length : ℝ)) := by
induction l with
| nil => simp
| cons x l ih =>
have hx := hminor x (by simp)
have ht := ih (fun s hs => hminor s (by simp [hs]))
constructor
Β· simpa only [List.map_cons, List.prod_cons] using mul_ne_zero hx.1 ht.1
Β· simp only [List.map_cons, List.prod_cons, Int.cast_mul, abs_mul,
List.length_cons, Nat.cast_add, Nat.cast_one, mul_add, mul_one,
Real.rpow_add hX]
exact (mul_le_mul hx.2 ht.2 (abs_nonneg _) (Real.rpow_nonneg hX.le _)).trans_eq (mul_comm _ _)
theorem adaptive_deletion_bound {K V Οƒ : Type*} [Field K] [AddCommGroup V]
[Module K V] [Module.Finite K V]
(W : β„• β†’ Οƒ β†’ Finset β„• β†’ Submodule K V)
(next : β„• β†’ Οƒ β†’ Submodule K V β†’ Οƒ)
(hW : βˆ€ i s A B, A βŠ† B β†’ W i s A ≀ W i s B)
(minor : Οƒ β†’ β„€) (n : β„•) (s : Οƒ)
(P : Finset β„•) (hp : βˆ€ p ∈ P, p.Prime)
(X ΞΆ B : ℝ) (hX : 1 < X) (hΞΆ : 0 < ΞΆ)
(hsmall : βˆ€ p ∈ P, X^ΞΆ ≀ (p : ℝ))
(hminor : βˆ€ A βŠ† P, βˆ€ t ∈ adaptiveStates W next n 0 s A,
minor t β‰  0 ∧ |(minor t : ℝ)| ≀ X^B)
(ell T : β„•) (hT : 0 < T) (hsize : ell+T < P.card) :
let bad := fun A => P.filter fun p : β„• =>
(p : β„€) ∣ ((adaptiveStates W next n 0 s A).map minor).prod
(βˆ‘ j ∈ Finset.range T, badFraction P (ell+j+1) bad) / (T : ℝ) ≀
(((Module.finrank K V+1)^n : β„•) : ℝ) / T +
(⌊(B*(n+1:β„•))/ΞΆβŒ‹β‚Š : ℝ) / ((P.card : ℝ) - (ell+T)) := by
classical
intro bad
let R := fun A => adaptiveCode W next n 0 s A
apply deletion_average_bound P ell T hT hsize R bad
((Module.finrank K V+1)^n) ⌊(B*(n+1:β„•))/ΞΆβŒ‹β‚Š
Β· intro A _
exact (adaptiveCode_lt W next n 0 s A).le
Β· intro A _ q _
exact (adaptiveCode_mono_stable W next (A.erase q) A
(fun i s => hW i s _ _ (Finset.erase_subset _ _)) n 0 s).1
Β· intro A _ q _ he
have hs := (adaptiveCode_mono_stable W next (A.erase q) A
(fun i s => hW i s _ _ (Finset.erase_subset _ _)) n 0 s).2 he
dsimp [bad]
rw [hs]
Β· intro A hAP
let l := adaptiveStates W next n 0 s A
have hb := list_minor_product_bound l minor X B (zero_lt_one.trans hX) (hminor A hAP)
have hl : l.length = n+1 := adaptiveStates_length W next n 0 s A
have hin : P ∩ bad A = bad A := Finset.inter_eq_right.mpr (Finset.filter_subset _ _)
rw [hin]
apply card_large_prime_divisors_le_floor _ hb.1 _
(fun p h => hp p (Finset.mem_filter.mp h).1)
(fun _ h => (Finset.mem_filter.mp h).2) X ΞΆ (B*(n+1:β„•)) hX hΞΆ
(fun p h => hsmall p (Finset.mem_filter.mp h).1)
simpa only [hl] using hb.2
open scoped BigOperators
def BlockSample (P : Finset β„•) (ell T : β„•) :=
Ξ£ j : Fin T, (P.powersetCard (ell+j.val+1))
noncomputable instance (P : Finset β„•) (ell T : β„•) : Fintype (BlockSample P ell T) :=
inferInstanceAs (Fintype (Ξ£ j : Fin T, (P.powersetCard (ell+j.val+1))))
noncomputable def blockWeight (P : Finset β„•) (ell T : β„•)
(a : BlockSample P ell T) : ℝ :=
((T : ℝ) * ((P.powersetCard (ell+a.1.val+1)).card : ℝ))⁻¹
def blockSet {P : Finset β„•} {ell T : β„•} (a : BlockSample P ell T) : Finset β„• :=
a.2.val
theorem blockSet_spec {P : Finset β„•} {ell T : β„•} (a : BlockSample P ell T) :
blockSet a βŠ† P ∧ (blockSet a).card = ell+a.1.val+1 :=
Finset.mem_powersetCard.mp a.2.property
theorem blockWeight_nonneg (P : Finset β„•) (ell T : β„•)
(a : BlockSample P ell T) : 0 ≀ blockWeight P ell T a := by
unfold blockWeight
positivity
theorem blockWeight_sum (P : Finset β„•) (ell T : β„•)
(hT : 0 < T) (hsize : ell+T ≀ P.card) :
βˆ‘ a : BlockSample P ell T, blockWeight P ell T a = 1 := by
classical
change (βˆ‘ a : Ξ£ j : Fin T, (P.powersetCard (ell+j.val+1)),
((T : ℝ) * ((P.powersetCard (ell+a.1.val+1)).card : ℝ))⁻¹) = 1
rw [Fintype.sum_sigma]
have he (j : Fin T) :
(βˆ‘ _a : (P.powersetCard (ell+j.val+1)),
((T : ℝ) * ((P.powersetCard (ell+j.val+1)).card : ℝ))⁻¹) = (T : ℝ)⁻¹ := by
have hc : 0 < (P.powersetCard (ell+j.val+1)).card :=
Finset.card_pos.mpr (Finset.powersetCard_nonempty.mpr (by omega))
simp only [Finset.sum_const, Finset.card_univ, Fintype.card_coe, nsmul_eq_mul]
field_simp
simp only [he,Finset.sum_const,Finset.card_univ,Fintype.card_fin,nsmul_eq_mul]
exact mul_inv_cancelβ‚€ (Nat.cast_ne_zero.mpr hT.ne')
theorem blockWeight_bad_average (P : Finset β„•) (ell T : β„•)
(bad : Finset β„• β†’ Finset β„•) :
(βˆ‘ a : BlockSample P ell T, blockWeight P ell T a *
((βˆ‘ q ∈ blockSet a, if q ∈ bad (blockSet a) then (1 : ℝ) else 0) /
(blockSet a).card)) =
(βˆ‘ j ∈ Finset.range T, badFraction P (ell+j+1) bad) / T := by
classical
change (βˆ‘ a : Ξ£ j : Fin T, (P.powersetCard (ell+j.val+1)),
((T : ℝ) * ((P.powersetCard (ell+a.1.val+1)).card : ℝ))⁻¹ *
((βˆ‘ q ∈ a.2.val, if q ∈ bad a.2.val then (1 : ℝ) else 0) / a.2.val.card)) = _
rw [Fintype.sum_sigma, ← Fin.sum_univ_eq_sum_range, Finset.sum_div]
apply Finset.sum_congr rfl
intro j _
simp only [badFraction]
rw [Finset.sum_coe_sort (P.powersetCard (ell+j.val+1))
(fun S : Finset β„• => ((T : ℝ) * ((P.powersetCard (ell+j.val+1)).card : ℝ))⁻¹ *
((βˆ‘ q ∈ S, if q ∈ bad S then (1 : ℝ) else 0) / S.card)),
Finset.sum_div, Finset.sum_div]
apply Finset.sum_congr rfl
intro a ha
rw [(Finset.mem_powersetCard.mp ha).2]
simp only [div_eq_mul_inv, _root_.mul_inv_rev]
ring
theorem independent_average_le {ΞΉ : Type*} [Fintype ΞΉ] [DecidableEq ΞΉ]
{Ξ© : ΞΉ β†’ Type*} [βˆ€ i, Fintype (Ξ© i)]
(w : βˆ€ i, Ξ© i β†’ ℝ) (hw : βˆ€ i a, 0 ≀ w i a)
(hsum : βˆ€ i, βˆ‘ a, w i a = 1) (i : ΞΉ)
(F : (βˆ€ j, Ξ© j) β†’ ℝ) (C : ℝ)
(hF : βˆ€ x, (βˆ‘ a, w i a * F (Function.update x i a)) ≀ C) :
(βˆ‘ x, (∏ j, w j (x j)) * F x) ≀ C := by
classical
let E := Equiv.piSplitAt i Ξ©
let W : (βˆ€ j : {j // j β‰  i}, Ξ© j) β†’ ℝ := fun x => ∏ j : {j // j β‰  i}, w j.val (x j)
have hs : βˆ‘ x, W x = 1 := by
rw [show (βˆ‘ x, W x) = βˆ‘ x : (βˆ€ j : {j // j β‰  i}, Ξ© j), ∏ j : {j // j β‰  i}, w j.val (x j) from rfl, ← Fintype.prod_sum]
simp only [hsum, Finset.prod_const_one]
have hwE (x : βˆ€ j, Ξ© j) : (∏ j, w j (x j)) = w i (x i) * W (E x).2 := by
rw [← Finset.mul_prod_erase Finset.univ (fun j => w j (x j)) (Finset.mem_univ i)]
congr 1
exact Finset.prod_subtype (p := fun j => j β‰  i) (Finset.univ.erase i) (by simp) (fun j => w j (x j))
have hE (x : (βˆ€ j : {j // j β‰  i}, Ξ© j)) (a b : Ξ© i) :
Function.update (E.symm (a,x)) i b = E.symm (b,x) := by
funext j
by_cases h : j = i
Β· subst j; simp [E, Equiv.piSplitAt]
Β· simp [E, Equiv.piSplitAt, h]
have hEq : (βˆ‘ x, (∏ j, w j (x j)) * F x) =
βˆ‘ x, W x * (βˆ‘ a, w i a * F (E.symm (a,x))) := by
rw [Fintype.sum_equiv E _ (fun z => w i z.1 * W z.2 * F (E.symm z))]
Β· rw [Fintype.sum_prod_type, Finset.sum_comm]
apply Finset.sum_congr rfl
intro x _
rw [Finset.mul_sum]
apply Finset.sum_congr rfl
intro a _
ring
Β· intro x
rw [hwE, E.symm_apply_apply]
rfl
rw [hEq]
have hFin (x : βˆ€ j : {j // j β‰  i}, Ξ© j) :
(βˆ‘ a, w i a * F (E.symm (a,x))) ≀ C := by
by_cases h : Nonempty (Ξ© i)
· obtain ⟨a⟩ := h
simpa only [hE] using hF (E.symm (a,x))
Β· have := not_nonempty_iff.mp h
have hz := hsum i
simp at hz
calc
_ ≀ βˆ‘ x, W x * C := Finset.sum_le_sum fun x _ =>
mul_le_mul_of_nonneg_left (hFin x) (Finset.prod_nonneg fun j _ => hw j.val (x j))
_ = C := by rw [← Finset.sum_mul, hs, one_mul]
theorem exists_many_regular {Ξ© ΞΉ : Type*} [Fintype Ξ©] [Fintype ΞΉ]
(w : Ξ© β†’ ℝ) (hw : βˆ€ a, 0 ≀ w a) (hsum : βˆ‘ a, w a = 1)
(bad : Ξ© β†’ ΞΉ β†’ Prop) [DecidableRel bad]
(Ξ· : ℝ) (hbad : βˆ€ z, (βˆ‘ a, w a * if bad a z then (1 : ℝ) else 0) ≀ Ξ·) :
βˆƒ a : Ξ©, ((Finset.univ.filter fun z => Β¬ bad a z).card : ℝ) β‰₯
(1-Ξ·) * Fintype.card ΞΉ := by
classical
have havg : (βˆ‘ a, w a * ((Finset.univ.filter fun z => bad a z).card : ℝ)) ≀
Ξ· * Fintype.card ΞΉ := by
simp_rw [← Finset.sum_boole, Finset.mul_sum]
rw [Finset.sum_comm]
exact (Finset.sum_le_sum fun z _ => hbad z).trans_eq (by simp; ring)
have hex : βˆƒ a : Ξ©, ((Finset.univ.filter fun z => bad a z).card : ℝ) ≀ Ξ· * Fintype.card ΞΉ := by
by_contra h
push Not at h
have hp : βˆƒ a, 0 < w a := by
by_contra h0
push Not at h0
have hz : βˆ€ a, w a = 0 := fun a => le_antisymm (h0 a) (hw a)
simp [hz] at hsum
obtain ⟨a,ha⟩ := hp
have hlt : (βˆ‘ b, w b * (Ξ· * Fintype.card ΞΉ)) <
βˆ‘ b, w b * ((Finset.univ.filter fun z => bad b z).card : ℝ) := by
apply Finset.sum_lt_sum
Β· intro b _
exact mul_le_mul_of_nonneg_left (h b).le (hw b)
· exact ⟨a,Finset.mem_univ _,mul_lt_mul_of_pos_left (h a) ha⟩
rw [← Finset.sum_mul,hsum,one_mul] at hlt
linarith
obtain ⟨a,ha⟩ := hex
refine ⟨a,?_⟩
have hc : (Finset.univ.filter fun z => bad a z).card +
(Finset.univ.filter fun z => Β¬ bad a z).card = Fintype.card ΞΉ := by
simpa using Finset.card_filter_add_card_filter_not (s := Finset.univ) (fun z => bad a z)
have hcr : ((Finset.univ.filter fun z => bad a z).card : ℝ) +
((Finset.univ.filter fun z => Β¬ bad a z).card : ℝ) = Fintype.card ΞΉ := by exact_mod_cast hc
linarith
theorem bad_blocks_indicator_le {r : β„•} (b : Fin r β†’ ℝ) (hb : βˆ€ i, 0 ≀ b i)
(ΞΎ : ℝ) (hΞΎ : 0 < ΞΎ) :
(if βˆƒ i, ΞΎ < b i then (1 : ℝ) else 0) ≀ (βˆ‘ i, b i) / ΞΎ := by
classical
split_ifs with h
· obtain ⟨i,hi⟩ := h
rw [le_div_iffβ‚€ hΞΎ, one_mul]
exact hi.le.trans (Finset.single_le_sum (fun j _ => hb j) (Finset.mem_univ i))
Β· exact div_nonneg (Finset.sum_nonneg fun i _ => hb i) hΞΎ.le
end QuarticPowerFree
end OAI