math / data /lean /OAI /LinearAlgebra /MatrixFields /Entropy /JointExtractionRates.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
33.6 kB
import Mathlib
import OAI.LinearAlgebra.MatrixFields.Construction.JointAPFree
import OAI.LinearAlgebra.MatrixFields.Extraction.ComplexFiniteSeparation
namespace OAI
namespace MatrixAllFields
open scoped BigOperators Topology Polynomial
section
noncomputable section
namespace MatrixMultiplication.Foundation.Separation
open Filter
private theorem scale_exists (K : β„•) : βˆƒ n : β„•, K ≀ 2 ^ (n ^ 2) := by
refine ⟨K + 1, ?_⟩
have hK : K < 2 ^ K := Nat.lt_pow_self (by decide : 1 < 2)
exact hK.le.trans (Nat.pow_le_pow_right (by decide) (by nlinarith))
noncomputable def gridScale (K : β„•) : β„• := Nat.find (scale_exists K)
theorem population_le_scale (K : β„•) : K ≀ 2 ^ ((gridScale K) ^ 2) :=
Nat.find_spec (scale_exists K)
theorem previous_scale_lt_population {K : β„•} (hn : 0 < gridScale K) :
2 ^ ((gridScale K - 1) ^ 2) < K := by
exact lt_of_not_ge (Nat.find_min (scale_exists K) (Nat.sub_lt hn (by decide)))
theorem scale_pos {K : β„•} (hK : 1 < K) : 0 < gridScale K := by
have h := population_le_scale K
by_contra hn
have hz : gridScale K = 0 := Nat.eq_zero_of_not_pos hn
simp only [hz, zero_pow (by decide : 2 β‰  0), pow_zero] at h
exact (not_le_of_gt hK) h
theorem scale_gt_of_population_gt {K n : β„•} (hK : 2 ^ (n ^ 2) < K) :
n < gridScale K := by
by_contra hn
have hscale : gridScale K ≀ n := Nat.le_of_not_gt hn
have hp : 2 ^ ((gridScale K) ^ 2) ≀ 2 ^ (n ^ 2) :=
Nat.pow_le_pow_right (by decide) (Nat.pow_le_pow_left hscale 2)
exact (not_le_of_gt hK) ((population_le_scale K).trans hp)
theorem gridScale_monotone : Monotone gridScale := by
intro K L hKL
exact Nat.find_min' (scale_exists K) (hKL.trans (population_le_scale L))
def gridDimension (K : β„•) : β„• := gridScale K + 4
def gridWidth (K : β„•) : β„• := 2 ^ (gridScale K + 2)
def gridGroupOrder (K : β„•) : β„• := (4 * gridWidth K) ^ gridDimension K
theorem gridDimension_pos (K : β„•) : 0 < gridDimension K := by
simp [gridDimension]
theorem gridWidth_ge_two (K : β„•) : 2 ≀ gridWidth K := by
simpa only [gridWidth, pow_one] using
(Nat.pow_le_pow_right (by decide : 0 < 2) (by omega : 1 ≀ gridScale K + 2))
private theorem dimension_le_power (n : β„•) : n + 4 ≀ 2 ^ (n + 2) := by
induction n with
| zero => norm_num
| succ n ih =>
have hp : 2 ^ (n + 2 + 1) = 2 ^ (n + 2) * 2 := pow_succ _ _
have he : n + 1 + 2 = n + 2 + 1 := by omega
rw [he, hp]
omega
theorem grid_population_bound (K : β„•) :
(gridDimension K * gridWidth K ^ 2 + 1) * K ≀
gridWidth K ^ gridDimension K := by
let n := gridScale K
have hd : n + 4 ≀ 2 ^ (n + 2) := dimension_le_power n
have hq : 0 < 2 ^ (n + 2) := by positivity
have hcolorpos : 0 < (n + 4) * (2 ^ (n + 2)) ^ 2 := by positivity
have hcolor : (n + 4) * (2 ^ (n + 2)) ^ 2 + 1 ≀ 2 ^ (3 * n + 7) := by
calc
(n + 4) * (2 ^ (n + 2)) ^ 2 + 1 ≀
2 * ((n + 4) * (2 ^ (n + 2)) ^ 2) := by nlinarith
_ ≀ 2 * (2 ^ (n + 2) * (2 ^ (n + 2)) ^ 2) := by gcongr
_ = 2 ^ (3 * n + 7) := by
rw [← pow_mul, ← pow_add, ← pow_succ']
congr 1
omega
calc
(gridDimension K * gridWidth K ^ 2 + 1) * K ≀
2 ^ (3 * n + 7) * 2 ^ (n ^ 2) :=
Nat.mul_le_mul hcolor (population_le_scale K)
_ = 2 ^ (3 * n + 7 + n ^ 2) := (pow_add _ _ _).symm
_ ≀ 2 ^ ((n + 2) * (n + 4)) :=
Nat.pow_le_pow_right (by decide) (by nlinarith)
_ = gridWidth K ^ gridDimension K := by
simp only [gridWidth, gridDimension, n, pow_mul]
theorem gridGroupOrder_eq (K : β„•) :
gridGroupOrder K = 2 ^ ((gridScale K + 4) ^ 2) := by
unfold gridGroupOrder gridWidth gridDimension
have hb : 4 * 2 ^ (gridScale K + 2) = 2 ^ (gridScale K + 4) := by
calc
4 * 2 ^ (gridScale K + 2) = 2 ^ 2 * 2 ^ (gridScale K + 2) := by norm_num
_ = 2 ^ (2 + (gridScale K + 2)) := (pow_add _ _ _).symm
_ = 2 ^ (gridScale K + 4) := by congr 1; omega
rw [hb, ← pow_mul, pow_two]
theorem gridGroupOrder_pos (K : β„•) : 0 < gridGroupOrder K := by
rw [gridGroupOrder_eq]
positivity
theorem population_le_gridGroupOrder (K : β„•) : K ≀ gridGroupOrder K := by
rw [gridGroupOrder_eq]
exact (population_le_scale K).trans
(Nat.pow_le_pow_right (by decide)
(Nat.pow_le_pow_left (Nat.le_add_right (gridScale K) 4) 2))
theorem gridGroupOrder_monotone : Monotone gridGroupOrder := by
intro K L hKL
rw [gridGroupOrder_eq, gridGroupOrder_eq]
exact Nat.pow_le_pow_right (by decide)
(Nat.pow_le_pow_left (Nat.add_le_add_right (gridScale_monotone hKL) 4) 2)
theorem asymptotic_grid_tags_slices (K : β„•) :
βˆƒ tags : Finset (Grid (gridDimension K) (gridWidth K)), tags.card = K ∧
(βˆƒ radius : Fin (gridDimension K * gridWidth K ^ 2 + 1),
βˆ€ t ∈ tags, normColor t = radius) ∧
βˆ€ t ∈ tags, βˆƒ slice : Finset (Grid (gridDimension K) (gridWidth K)),
slice.card = K ∧ βˆƒ level : Fin (gridDimension K * gridWidth K ^ 2 + 1),
βˆ€ u ∈ slice, dotColor t u = level :=
grid_tags_slices (grid_population_bound K) (grid_population_bound K)
theorem log_gridGroupOrder (K : β„•) :
Real.log (gridGroupOrder K : ℝ) = ((gridScale K : ℝ) + 4) ^ 2 * Real.log 2 := by
rw [gridGroupOrder_eq, Nat.cast_pow, Real.log_pow]
norm_cast
theorem log_population_le_log_gridGroupOrder {K : β„•} (hK : 0 < K) :
Real.log (K : ℝ) ≀ Real.log (gridGroupOrder K : ℝ) := by
exact Real.log_le_log (by exact_mod_cast hK)
(by exact_mod_cast population_le_gridGroupOrder K)
theorem previous_scale_log_lt {K : β„•} (hK : 1 < K) :
((gridScale K : ℝ) - 1) ^ 2 * Real.log 2 < Real.log (K : ℝ) := by
have hn : 1 ≀ gridScale K := scale_pos hK
have hp : (0 : ℝ) < (2 : ℝ) ^ ((gridScale K - 1) ^ 2) := by positivity
have hc : (2 : ℝ) ^ ((gridScale K - 1) ^ 2) < (K : ℝ) := by
exact_mod_cast previous_scale_lt_population (scale_pos hK)
have h := Real.log_lt_log hp hc
simpa only [Real.log_pow, Nat.cast_pow, Nat.cast_sub hn, Nat.cast_one] using h
theorem log_gridGroupOrder_le_of_scale {K : β„•} {Ξ΅ : ℝ}
(hK : 1 < K) (hΞ΅ : 0 ≀ Ξ΅)
(hscale : 10 * (gridScale K : ℝ) + 15 ≀
Ξ΅ * ((gridScale K : ℝ) - 1) ^ 2) :
Real.log (gridGroupOrder K : ℝ) ≀ (1 + Ξ΅) * Real.log (K : ℝ) := by
have hlog2 : 0 < Real.log 2 := Real.log_pos (by norm_num)
have hpoly : ((gridScale K : ℝ) + 4) ^ 2 ≀
(1 + Ξ΅) * ((gridScale K : ℝ) - 1) ^ 2 := by nlinarith
calc
Real.log (gridGroupOrder K : ℝ) =
((gridScale K : ℝ) + 4) ^ 2 * Real.log 2 := log_gridGroupOrder K
_ ≀ ((1 + Ξ΅) * ((gridScale K : ℝ) - 1) ^ 2) * Real.log 2 :=
mul_le_mul_of_nonneg_right hpoly hlog2.le
_ = (1 + Ξ΅) * (((gridScale K : ℝ) - 1) ^ 2 * Real.log 2) := by ring
_ ≀ (1 + Ξ΅) * Real.log (K : ℝ) :=
mul_le_mul_of_nonneg_left (previous_scale_log_lt hK).le (by positivity)
private theorem scale_error_bound {n Ξ΅ : ℝ} (hn : 2 ≀ n) (hΞ΅ : 0 ≀ Ξ΅)
(hlarge : 72 ≀ Ξ΅ * n) : 10 * n + 15 ≀ Ξ΅ * (n - 1) ^ 2 := by
have hsq : n ^ 2 ≀ 4 * (n - 1) ^ 2 := by nlinarith
have hmul := mul_le_mul_of_nonneg_left hsq hΞ΅
have hlarge' := mul_le_mul_of_nonneg_right hlarge (by linarith : 0 ≀ n)
nlinarith
theorem eventually_log_gridGroupOrder_le {Ξ΅ : ℝ} (hΞ΅ : 0 < Ξ΅) :
βˆ€αΆ  K : β„• in atTop,
Real.log (gridGroupOrder K : ℝ) ≀ (1 + Ξ΅) * Real.log (K : ℝ) := by
obtain ⟨m : β„•, hm⟩ := exists_nat_gt (max 2 (72 / Ξ΅))
refine eventually_atTop.2 ⟨2 ^ (m ^ 2) + 1, ?_⟩
intro K hK
have hKm : 2 ^ (m ^ 2) < K := by omega
have hn := scale_gt_of_population_gt hKm
have hnR : (m : ℝ) < (gridScale K : ℝ) := by exact_mod_cast hn
have hm2 : 2 < (m : ℝ) := (le_max_left _ _).trans_lt hm
have hmΞ΅ : 72 / Ξ΅ < (m : ℝ) := (le_max_right _ _).trans_lt hm
have hnΞ΅ : 72 ≀ Ξ΅ * (gridScale K : ℝ) := by
have hdiv : 72 / Ξ΅ < (gridScale K : ℝ) := hmΞ΅.trans hnR
have hmul := (div_lt_iffβ‚€ hΞ΅).1 hdiv
nlinarith
have hKone : 1 < K := by
have hp : 1 ≀ 2 ^ (m ^ 2) := Nat.one_le_pow _ _ (by decide)
omega
exact log_gridGroupOrder_le_of_scale hKone hΞ΅.le
(scale_error_bound (by linarith) hΞ΅.le hnΞ΅)
theorem uniform_log_gridGroupOrder_le {Ξ΅ : ℝ} (hΞ΅ : 0 < Ξ΅) :
βˆƒ C : ℝ, 0 ≀ C ∧ βˆ€ K : β„•,
Real.log (gridGroupOrder K : ℝ) ≀ (1 + Ξ΅) * Real.log (K : ℝ) + C := by
obtain ⟨Kβ‚€, hKβ‚€βŸ© := eventually_atTop.1 (eventually_log_gridGroupOrder_le hΞ΅)
refine ⟨Real.log (gridGroupOrder Kβ‚€ : ℝ), Real.log_natCast_nonneg _, ?_⟩
intro K
by_cases hK : Kβ‚€ ≀ K
Β· exact (hKβ‚€ K hK).trans (le_add_of_nonneg_right (Real.log_natCast_nonneg _))
Β· have horder : gridGroupOrder K ≀ gridGroupOrder Kβ‚€ :=
gridGroupOrder_monotone (Nat.le_of_lt (Nat.lt_of_not_ge hK))
have hpos : (0 : ℝ) < (gridGroupOrder K : ℝ) := by
rw [gridGroupOrder_eq, Nat.cast_pow]
positivity
have hcast : (gridGroupOrder K : ℝ) ≀ (gridGroupOrder Kβ‚€ : ℝ) := by
exact_mod_cast horder
have hlog := Real.log_le_log hpos hcast
have hnonneg : 0 ≀ (1 + Ξ΅) * Real.log (K : ℝ) :=
mul_nonneg (by linarith) (Real.log_natCast_nonneg K)
linarith
theorem tendsto_log_gridGroupOrder_div_log_population :
Tendsto (fun K : β„• => Real.log (gridGroupOrder K : ℝ) / Real.log (K : ℝ))
atTop (nhds 1) := by
refine tendsto_order.2 ⟨?_, ?_⟩
Β· intro a ha
refine eventually_atTop.2 ⟨2, ?_⟩
intro K hK
have hKone : 1 < K := by omega
have hlog : 0 < Real.log (K : ℝ) :=
Real.log_pos (by exact_mod_cast hKone)
have hle := log_population_le_log_gridGroupOrder (by omega : 0 < K)
exact ha.trans_le ((le_div_iffβ‚€ hlog).2 (by simpa using hle))
Β· intro b hb
have he : 0 < (b - 1) / 2 := by linarith
filter_upwards [eventually_log_gridGroupOrder_le he,
(eventually_atTop.2 ⟨2, fun K (hK : 2 ≀ K) => hK⟩)] with K hcost hK
have hlog : 0 < Real.log (K : ℝ) :=
Real.log_pos (by exact_mod_cast (show 1 < K by omega))
have hratio : Real.log (gridGroupOrder K : ℝ) / Real.log (K : ℝ) ≀
1 + (b - 1) / 2 := (div_le_iffβ‚€ hlog).2 hcost
linarith
theorem tendsto_log_gridGroupOrder_div_nat {K : β„• β†’ β„•} {H : ℝ}
(hK : βˆ€ N, 0 < K N) (hH : 0 ≀ H)
(hpop : Tendsto (fun N => Real.log (K N : ℝ) / (N : ℝ)) atTop (nhds H)) :
Tendsto (fun N => Real.log (gridGroupOrder (K N) : ℝ) / (N : ℝ))
atTop (nhds H) := by
refine tendsto_order.2 ⟨?_, ?_⟩
Β· intro a ha
filter_upwards [(tendsto_order.1 hpop).1 a ha,
(eventually_atTop.2 ⟨1, fun N (hN : 1 ≀ N) => hN⟩)] with N haN hN
have hNpos : (0 : ℝ) < (N : ℝ) := by exact_mod_cast hN
exact haN.trans_le (div_le_div_of_nonneg_right
(log_population_le_log_gridGroupOrder (hK N)) hNpos.le)
Β· intro b hb
let Ξ΅ := (b - H) / (2 * (H + 1))
have hdenom : 0 < 2 * (H + 1) := by linarith
have hΞ΅ : 0 < Ξ΅ := div_pos (by linarith) hdenom
obtain ⟨C, hC, hbound⟩ := uniform_log_gridGroupOrder_le hΡ
have hΞ΅eq : Ξ΅ * (2 * (H + 1)) = b - H := div_mul_cancelβ‚€ _ hdenom.ne'
have hlimitlt : (1 + Ξ΅) * H < b := by nlinarith
have hconstant : Tendsto (fun N : β„• => C / (N : ℝ)) atTop (nhds 0) :=
tendsto_const_nhds.div_atTop tendsto_natCast_atTop_atTop
have hupper : Tendsto
(fun N : β„• => (1 + Ξ΅) * (Real.log (K N : ℝ) / (N : ℝ)) + C / (N : ℝ))
atTop (nhds ((1 + Ξ΅) * H)) := by
simpa using (hpop.const_mul (1 + Ξ΅)).add hconstant
filter_upwards [(tendsto_order.1 hupper).2 b hlimitlt,
(eventually_atTop.2 ⟨1, fun N (hN : 1 ≀ N) => hN⟩)] with N hbN hN
have hNpos : (0 : ℝ) < (N : ℝ) := by exact_mod_cast hN
have hle := div_le_div_of_nonneg_right (hbound (K N)) hNpos.le
have heq : ((1 + Ξ΅) * Real.log (K N : ℝ) + C) / (N : ℝ) =
(1 + Ξ΅) * (Real.log (K N : ℝ) / (N : ℝ)) + C / (N : ℝ) := by ring
rw [heq] at hle
exact hle.trans_lt hbN
theorem log_nat_prod {I : Type*} (s : Finset I) (a : I β†’ β„•)
(ha : βˆ€ i ∈ s, 0 < a i) :
Real.log ((∏ i ∈ s, a i : β„•) : ℝ) = βˆ‘ i ∈ s, Real.log (a i : ℝ) := by
rw [Nat.cast_prod]
exact Real.log_prod fun i hi =>
Nat.cast_ne_zero.mpr (Nat.ne_of_gt (ha i hi))
theorem tendsto_log_nat_prod_div_nat {I : Type*} (s : Finset I)
{K : I β†’ β„• β†’ β„•} {H : I β†’ ℝ}
(hK : βˆ€ i ∈ s, βˆ€ N, 0 < K i N)
(hpop : βˆ€ i ∈ s,
Tendsto (fun N => Real.log (K i N : ℝ) / (N : ℝ)) atTop (nhds (H i))) :
Tendsto (fun N => Real.log ((∏ i ∈ s, K i N : β„•) : ℝ) / (N : ℝ))
atTop (nhds (βˆ‘ i ∈ s, H i)) := by
have hsum := tendsto_finsetSum s hpop
apply hsum.congr
intro N
rw [log_nat_prod s (fun i => K i N) (fun i hi => hK i hi N)]
simp only [div_eq_mul_inv, Finset.sum_mul]
theorem tendsto_log_gridGroupOrder_prod_div_nat {I : Type*} (s : Finset I)
{K : I β†’ β„• β†’ β„•} {H : I β†’ ℝ}
(hK : βˆ€ i ∈ s, βˆ€ N, 0 < K i N) (hH : βˆ€ i ∈ s, 0 ≀ H i)
(hpop : βˆ€ i ∈ s,
Tendsto (fun N => Real.log (K i N : ℝ) / (N : ℝ)) atTop (nhds (H i))) :
Tendsto (fun N => Real.log ((∏ i ∈ s, gridGroupOrder (K i N) : β„•) : ℝ) / (N : ℝ))
atTop (nhds (βˆ‘ i ∈ s, H i)) := by
exact tendsto_log_nat_prod_div_nat s (fun i hi N => gridGroupOrder_pos (K i N))
(fun i hi => tendsto_log_gridGroupOrder_div_nat (hK i hi) (hH i hi) (hpop i hi))
theorem tendsto_log_nat_weighted_prod_div_nat {I : Type*} (s : Finset I) (w : I β†’ β„•)
{K : I β†’ β„• β†’ β„•} {H : I β†’ ℝ}
(hK : βˆ€ i ∈ s, βˆ€ N, 0 < K i N)
(hpop : βˆ€ i ∈ s,
Tendsto (fun N => Real.log (K i N : ℝ) / (N : ℝ)) atTop (nhds (H i))) :
Tendsto (fun N => Real.log ((∏ i ∈ s, (K i N) ^ w i : β„•) : ℝ) / (N : ℝ))
atTop (nhds (βˆ‘ i ∈ s, (w i : ℝ) * H i)) := by
apply tendsto_log_nat_prod_div_nat s
Β· intro i hi N
exact pow_pos (hK i hi N) _
Β· intro i hi
simpa only [Nat.cast_pow, Real.log_pow, mul_div_assoc] using
(hpop i hi).const_mul (w i : ℝ)
theorem tendsto_log_gridGroupOrder_weighted_prod_div_nat {I : Type*}
(s : Finset I) (w : I β†’ β„•) {K : I β†’ β„• β†’ β„•} {H : I β†’ ℝ}
(hK : βˆ€ i ∈ s, βˆ€ N, 0 < K i N) (hH : βˆ€ i ∈ s, 0 ≀ H i)
(hpop : βˆ€ i ∈ s,
Tendsto (fun N => Real.log (K i N : ℝ) / (N : ℝ)) atTop (nhds (H i))) :
Tendsto
(fun N => Real.log ((∏ i ∈ s, gridGroupOrder (K i N) ^ w i : β„•) : ℝ) / (N : ℝ))
atTop (nhds (βˆ‘ i ∈ s, (w i : ℝ) * H i)) := by
exact tendsto_log_nat_weighted_prod_div_nat s w
(fun i hi N => gridGroupOrder_pos (K i N))
(fun i hi => tendsto_log_gridGroupOrder_div_nat (hK i hi) (hH i hi) (hpop i hi))
end MatrixMultiplication.Foundation.Separation
namespace MatrixMultiplication.JointExtractionRates
open Filter
open scoped BigOperators Topology
def goodCount {Ξ© E : Type*} [Fintype E] (good : Ξ© β†’ E β†’ Prop) (Ο‰ : Ξ©) : β„• := by
classical
exact (Finset.univ.filter (good Ο‰)).card
def goodIncidence {Ξ© E : Type*} [Fintype Ξ©] (good : Ξ© β†’ E β†’ Prop) (e : E) : β„• := by
classical
exact (Finset.univ.filter (fun Ο‰ => good Ο‰ e)).card
theorem sum_goodCount_eq_sum_goodIncidence {Ξ© E : Type*} [Fintype Ξ©] [Fintype E]
(good : Ξ© β†’ E β†’ Prop) :
(βˆ‘ Ο‰, goodCount good Ο‰) = βˆ‘ e, goodIncidence good e := by
classical
simp only [goodCount, goodIncidence, Finset.card_filter]
exact Finset.sum_comm
theorem exists_goodCount_ge {Ξ© E : Type*} [Fintype Ξ©] [Nonempty Ξ©] [Fintype E]
(good : Ξ© β†’ E β†’ Prop) (q : ℝ)
(hinc : βˆ€ e, q * (Fintype.card Ξ© : ℝ) ≀ (goodIncidence good e : ℝ)) :
βˆƒ Ο‰, (Fintype.card E : ℝ) * q ≀ (goodCount good Ο‰ : ℝ) := by
have hsum := Finset.sum_le_sum (fun e (_ : e ∈ Finset.univ) => hinc e)
have hdouble : (βˆ‘ Ο‰, (goodCount good Ο‰ : ℝ)) =
βˆ‘ e, (goodIncidence good e : ℝ) := by
exact_mod_cast sum_goodCount_eq_sum_goodIncidence good
have havg : (βˆ‘ _Ο‰ : Ξ©, (Fintype.card E : ℝ) * q) ≀
βˆ‘ Ο‰, (goodCount good Ο‰ : ℝ) := by
rw [hdouble]
simpa only [Finset.sum_const, Finset.card_univ, nsmul_eq_mul, mul_assoc,
mul_comm, mul_left_comm] using hsum
obtain βŸ¨Ο‰, _, hΟ‰βŸ© := Finset.exists_le_of_sum_le Finset.univ_nonempty havg
exact βŸ¨Ο‰, hΟ‰βŸ©
theorem exists_good_subfamily {Ξ© E : Type*} [Fintype E]
(good : Ξ© β†’ E β†’ Prop) (Ο‰ : Ξ©) (K : β„•) (hK : K ≀ goodCount good Ο‰) :
βˆƒ G : Finset E, G.card = K ∧ βˆ€ e ∈ G, good Ο‰ e := by
classical
obtain ⟨G, hG, hcard⟩ := Finset.exists_subset_card_eq
(s := Finset.univ.filter (good Ο‰)) (by simpa only [goodCount] using hK)
exact ⟨G, hcard, fun e he => (Finset.mem_filter.mp (hG he)).2⟩
theorem eventually_exists_good_subfamily {Ξ© E : β„• β†’ Type*}
[βˆ€ N, Fintype (E N)]
(good : βˆ€ N, Ξ© N β†’ E N β†’ Prop) (K : β„• β†’ β„•)
(hK : βˆ€αΆ  N in atTop, βˆƒ Ο‰ : Ξ© N, K N ≀ goodCount (good N) Ο‰) :
βˆ€αΆ  N in atTop, βˆƒ (Ο‰ : Ξ© N) (G : Finset (E N)),
G.card = K N ∧ βˆ€ e ∈ G, good N Ο‰ e := by
filter_upwards [hK] with N hN
obtain βŸ¨Ο‰, hΟ‰βŸ© := hN
obtain ⟨G, hcard, hgood⟩ := exists_good_subfamily (good N) Ο‰ (K N) hΟ‰
exact βŸ¨Ο‰, G, hcard, hgood⟩
theorem incidence_lower_of_survival_and_loss {Ξ© E : Type*} [Fintype Ξ©]
(survives bad : Ξ© β†’ E β†’ Prop) (e : E) (s Ξ΅ : ℝ)
(hs : s * (Fintype.card Ξ© : ℝ) ≀ (goodIncidence survives e : ℝ))
(hb : (goodIncidence (fun Ο‰ e => survives Ο‰ e ∧ bad Ο‰ e) e : ℝ) ≀
s * Ξ΅ * (Fintype.card Ξ© : ℝ)) :
s * (1 - Ξ΅) * (Fintype.card Ξ© : ℝ) ≀
(goodIncidence (fun Ο‰ e => survives Ο‰ e ∧ Β¬ bad Ο‰ e) e : ℝ) := by
classical
have hsplit : goodIncidence (fun Ο‰ e => survives Ο‰ e ∧ bad Ο‰ e) e +
goodIncidence (fun Ο‰ e => survives Ο‰ e ∧ Β¬ bad Ο‰ e) e =
goodIncidence survives e := by
simp only [goodIncidence, Finset.card_filter, ← Finset.sum_add_distrib]
apply Finset.sum_congr rfl
intro Ο‰ _
by_cases hs : survives Ο‰ e <;> by_cases hb : bad Ο‰ e <;> simp [hs, hb]
have hsplitR :
(goodIncidence (fun Ο‰ e => survives Ο‰ e ∧ bad Ο‰ e) e : ℝ) +
(goodIncidence (fun Ο‰ e => survives Ο‰ e ∧ Β¬ bad Ο‰ e) e : ℝ) =
(goodIncidence survives e : ℝ) := by
exact_mod_cast hsplit
nlinarith
theorem exists_goodCount_ge_half_survival {Ξ© E : Type*}
[Fintype Ξ©] [Nonempty Ξ©] [Fintype E]
(survives bad : Ξ© β†’ E β†’ Prop) (s Ξ΅ : ℝ) (hsβ‚€ : 0 ≀ s) (hΞ΅ : Ξ΅ ≀ 1 / 2)
(hs : βˆ€ e, s * (Fintype.card Ξ© : ℝ) ≀ (goodIncidence survives e : ℝ))
(hb : βˆ€ e, (goodIncidence (fun Ο‰ e => survives Ο‰ e ∧ bad Ο‰ e) e : ℝ) ≀
s * Ξ΅ * (Fintype.card Ξ© : ℝ)) :
βˆƒ Ο‰, (Fintype.card E : ℝ) * (s / 2) ≀
(goodCount (fun Ο‰ e => survives Ο‰ e ∧ Β¬ bad Ο‰ e) Ο‰ : ℝ) := by
apply exists_goodCount_ge
intro e
have h := incidence_lower_of_survival_and_loss survives bad e s Ξ΅ (hs e) (hb e)
have hc : (0 : ℝ) ≀ Fintype.card Ξ© := Nat.cast_nonneg _
have hm := mul_le_mul_of_nonneg_right (mul_le_mul_of_nonneg_left hΞ΅ hsβ‚€) hc
nlinarith
theorem tendsto_polynomial_mul_exp_neg (d : β„•) {c : ℝ} (hc : 0 < c) :
Tendsto (fun N : β„• => ((N : ℝ) + 1) ^ d * Real.exp (-c * (N : ℝ)))
atTop (𝓝 0) := by
have hbase := (Real.summable_pow_mul_exp_neg_nat_mul d hc).tendsto_atTop_zero
have hshift := (hbase.comp (tendsto_add_atTop_nat 1)).mul_const (Real.exp c)
simp only [zero_mul, Function.comp_apply, Nat.cast_add, Nat.cast_one] at hshift
convert hshift using 1
ext N
rw [mul_assoc, ← Real.exp_add]
congr 2
ring
theorem eventually_error_le_half {error : β„• β†’ ℝ} (B : ℝ) (d : β„•)
{c : ℝ} (hc : 0 < c)
(hbound : βˆ€αΆ  N in atTop,
error N ≀ B * (((N : ℝ) + 1) ^ d * Real.exp (-c * (N : ℝ)))) :
βˆ€αΆ  N in atTop, error N ≀ 1 / 2 := by
have hlim := (tendsto_polynomial_mul_exp_neg d hc).const_mul B
have hsmall : βˆ€αΆ  N : β„• in atTop,
B * (((N : ℝ) + 1) ^ d * Real.exp (-c * (N : ℝ))) < 1 / 2 := by
simpa only [mul_zero] using (tendsto_order.1 hlim).2 (1 / 2) (by simp)
filter_upwards [hbound, hsmall] with N hb hs
exact hb.trans hs.le
theorem tendsto_log_one_sub_error_div_nat {error : β„• β†’ ℝ}
(herror : Tendsto error atTop (𝓝 0)) :
Tendsto (fun N => Real.log (1 - error N) / (N : ℝ)) atTop (𝓝 0) := by
have hone : Tendsto (fun N => 1 - error N) atTop (𝓝 (1 : ℝ)) := by
simpa using (tendsto_const_nhds :
Tendsto (fun _ : β„• => (1 : ℝ)) atTop (𝓝 1)).sub herror
exact (hone.log one_ne_zero).div_atTop tendsto_natCast_atTop_atTop
def hashModulus (H : ℝ) (N : β„•) : β„• :=
37 ^ (⌊(N : ℝ) * H / Real.log 37βŒ‹β‚Š + 1)
theorem hashModulus_ge (H : ℝ) (N : β„•) : 37 ≀ hashModulus H N := by
simpa only [hashModulus, pow_one] using
(Nat.pow_le_pow_right (by norm_num : 0 < 37)
(show 1 ≀ ⌊(N : ℝ) * H / Real.log 37βŒ‹β‚Š + 1 by omega))
theorem hashModulus_log_bounds {H : ℝ} (hH : 0 ≀ H) (N : β„•) :
(N : ℝ) * H ≀ Real.log (hashModulus H N : ℝ) ∧
Real.log (hashModulus H N : ℝ) ≀ (N : ℝ) * H + Real.log 37 := by
have hl : 0 < Real.log (37 : ℝ) := Real.log_pos (by norm_num)
have harg : 0 ≀ (N : ℝ) * H / Real.log 37 :=
div_nonneg (mul_nonneg (Nat.cast_nonneg N) hH) hl.le
have hfloor := mul_le_mul_of_nonneg_right (Nat.floor_le harg) hl.le
have hceil := mul_lt_mul_of_pos_right
(Nat.lt_floor_add_one ((N : ℝ) * H / Real.log 37)) hl
have hcancel : (N : ℝ) * H / Real.log 37 * Real.log 37 = (N : ℝ) * H :=
div_mul_cancelβ‚€ _ hl.ne'
simp only [hashModulus, Nat.cast_pow, Real.log_pow, Nat.cast_add, Nat.cast_one]
constructor <;> nlinarith
theorem tendsto_log_hashModulus_div_nat {H : ℝ} (hH : 0 ≀ H) :
Tendsto (fun N => Real.log (hashModulus H N : ℝ) / (N : ℝ))
atTop (𝓝 H) := by
have hc : Tendsto (fun N : β„• => Real.log 37 / (N : ℝ)) atTop (𝓝 0) :=
tendsto_const_nhds.div_atTop tendsto_natCast_atTop_atTop
have hu : Tendsto (fun N : β„• => H + Real.log 37 / (N : ℝ)) atTop (𝓝 H) := by
simpa only [add_zero] using hc.const_add H
apply tendsto_of_tendsto_of_tendsto_of_le_of_le' tendsto_const_nhds hu
Β· filter_upwards [eventually_ge_atTop (1 : β„•)] with N hN
have hNr : (0 : ℝ) < N := by exact_mod_cast hN
apply (le_div_iffβ‚€ hNr).2
nlinarith [(hashModulus_log_bounds hH N).1]
Β· filter_upwards [eventually_ge_atTop (1 : β„•)] with N hN
have hNr : (0 : ℝ) < N := by exact_mod_cast hN
have hb := div_le_div_of_nonneg_right (hashModulus_log_bounds hH N).2 hNr.le
simpa only [add_div, mul_div_cancel_leftβ‚€ H hNr.ne'] using hb
theorem eventual_log_upper_of_error {degree : β„• β†’ β„•} {error : β„• β†’ ℝ} {D : ℝ}
(herror : Tendsto (fun N => error N / (N : ℝ)) atTop (𝓝 0))
(hbound : βˆ€αΆ  N in atTop,
Real.log (degree N : ℝ) ≀ (N : ℝ) * D + error N)
{Ξ· : ℝ} (hΞ· : 0 < Ξ·) :
βˆ€αΆ  N in atTop, Real.log (degree N : ℝ) / (N : ℝ) ≀ D + Ξ· := by
filter_upwards [hbound, (tendsto_order.1 herror).2 Ξ· hΞ·,
eventually_ge_atTop (1 : β„•)] with N hb he hN
have hNr : (0 : ℝ) < N := by exact_mod_cast hN
have hd := div_le_div_of_nonneg_right hb hNr.le
rw [add_div, mul_div_cancel_leftβ‚€ D hNr.ne'] at hd
linarith
theorem eventually_ratio_le_exp_neg_of_log_bounds {degree M : β„• β†’ β„•} {D H c : ℝ}
(hdegree : βˆ€ Ξ· : ℝ, 0 < Ξ· β†’
βˆ€αΆ  N in atTop, Real.log (degree N : ℝ) / (N : ℝ) ≀ D + Ξ·)
(hpos : βˆ€αΆ  N in atTop, 0 < M N)
(hM : Tendsto (fun N => Real.log (M N : ℝ) / (N : ℝ)) atTop (𝓝 H))
(hc : c < H - D) :
βˆ€αΆ  N in atTop, (degree N : ℝ) / (M N : ℝ) ≀ Real.exp (-c * (N : ℝ)) := by
let Ξ· : ℝ := (H - D - c) / 3
have hΞ· : 0 < Ξ· := by dsimp [Ξ·]; linarith
filter_upwards [hdegree Ξ· hΞ·, hpos,
(tendsto_order.1 hM).1 (H - Ξ·) (by linarith),
eventually_ge_atTop (1 : β„•)] with N hd hp hm hN
by_cases hz : degree N = 0
Β· simp only [hz, Nat.cast_zero, zero_div]
exact (Real.exp_pos _).le
have hdpos : (0 : ℝ) < degree N := by
exact_mod_cast Nat.pos_of_ne_zero hz
have hmpos : (0 : ℝ) < M N := by exact_mod_cast hp
have hNr : (0 : ℝ) < N := by exact_mod_cast hN
have hdu := (div_le_iffβ‚€ hNr).mp hd
have hml := (lt_div_iffβ‚€ hNr).mp hm
have hcoefficient : D - H + 2 * Ξ· ≀ -c := by dsimp [Ξ·]; linarith
have hscaled := mul_le_mul_of_nonneg_right hcoefficient hNr.le
have hdiff : Real.log (degree N : ℝ) - Real.log (M N : ℝ) ≀
-c * (N : ℝ) := by nlinarith
calc
_ = Real.exp (Real.log (degree N : ℝ) - Real.log (M N : ℝ)) := by
rw [Real.exp_sub, Real.exp_log hdpos, Real.exp_log hmpos]
_ ≀ _ := Real.exp_le_exp.mpr hdiff
theorem eventually_degree_div_hashModulus_le_exp {degree : β„• β†’ β„•} {D H c : ℝ}
(hH : 0 ≀ H)
(hdegree : βˆ€ Ξ· : ℝ, 0 < Ξ· β†’
βˆ€αΆ  N in atTop, Real.log (degree N : ℝ) / (N : ℝ) ≀ D + Ξ·)
(hc : c < H - D) :
βˆ€αΆ  N in atTop, (degree N : ℝ) / (hashModulus H N : ℝ) ≀
Real.exp (-c * (N : ℝ)) := by
apply eventually_ratio_le_exp_neg_of_log_bounds hdegree _
(tendsto_log_hashModulus_div_nat hH) hc
exact Eventually.of_forall fun N =>
lt_of_lt_of_le (by decide : 0 < 37) (hashModulus_ge H N)
theorem tendsto_sqrt_div_nat_of_div_nat {a : β„• β†’ ℝ} {A : ℝ}
(ha : βˆ€ N, 0 ≀ a N)
(h : Tendsto (fun N => a N / (N : ℝ)) atTop (𝓝 A)) :
Tendsto (fun N => Real.sqrt (a N) / (N : ℝ)) atTop (𝓝 0) := by
have hinv : Tendsto (fun N : β„• => 1 / (N : ℝ)) atTop (𝓝 0) :=
tendsto_const_nhds.div_atTop tendsto_natCast_atTop_atTop
have hp := h.sqrt.mul hinv.sqrt
simp only [Real.sqrt_zero, mul_zero] at hp
convert hp using 1
ext N
symm
rw [Real.sqrt_div (ha N), Real.sqrt_div (by norm_num : (0 : ℝ) ≀ 1),
Real.sqrt_one, div_mul_div_comm, mul_one, Real.mul_self_sqrt (Nat.cast_nonneg N)]
theorem tendsto_log_modularSet_card_div_nat {M : β„• β†’ β„•} {H : ℝ}
(hM : βˆ€αΆ  N in atTop, 2 ≀ M N)
(hlog : Tendsto (fun N => Real.log (M N : ℝ) / (N : ℝ)) atTop (𝓝 H)) :
Tendsto (fun N => Real.log ((JointAPFree.modularSet (M N)).card : ℝ) / (N : ℝ))
atTop (𝓝 H) := by
have hsqrt := tendsto_sqrt_div_nat_of_div_nat
(fun N => Real.log_natCast_nonneg (M N)) hlog
have hconst : Tendsto (fun N : β„• => Real.log 3 / (N : ℝ)) atTop (𝓝 0) :=
tendsto_const_nhds.div_atTop tendsto_natCast_atTop_atTop
have hlower : Tendsto (fun N =>
(Real.log (M N : ℝ) - Real.log 3 -
4 * Real.sqrt (Real.log (M N : ℝ))) / (N : ℝ))
atTop (𝓝 H) := by
have h := (hlog.sub hconst).sub (hsqrt.const_mul 4)
simp only [mul_zero, sub_zero] at h
apply h.congr
intro N
ring
apply tendsto_of_tendsto_of_tendsto_of_le_of_le' hlower hlog
Β· filter_upwards [hM] with N hN
exact div_le_div_of_nonneg_right
(JointAPFree.modularSet_log_card_lower_modulus hN) (Nat.cast_nonneg N)
Β· filter_upwards [hM] with N hN
exact div_le_div_of_nonneg_right
(JointAPFree.modularSet_log_card_le_modulus hN) (Nat.cast_nonneg N)
theorem tendsto_log_yield_lower {T U M : β„• β†’ β„•} {A B C : ℝ}
(hT : Tendsto (fun N => Real.log (T N : ℝ) / (N : ℝ)) atTop (𝓝 A))
(hU : Tendsto (fun N => Real.log (U N : ℝ) / (N : ℝ)) atTop (𝓝 B))
(hM : Tendsto (fun N => Real.log (M N : ℝ) / (N : ℝ)) atTop (𝓝 C)) :
Tendsto (fun N =>
(Real.log (T N : ℝ) + Real.log (U N : ℝ) -
2 * Real.log (M N : ℝ) - Real.log 2) / (N : ℝ))
atTop (𝓝 (A + B - 2 * C)) := by
have hconst : Tendsto (fun N : β„• => Real.log 2 / (N : ℝ)) atTop (𝓝 0) :=
tendsto_const_nhds.div_atTop tendsto_natCast_atTop_atTop
have h := ((hT.add hU).sub (hM.const_mul 2)).sub hconst
simp only [sub_zero] at h
apply h.congr
intro N
ring
theorem exp_log_yield_lower {T U M : β„•} (hT : 0 < T) (hU : 0 < U) (hM : 0 < M) :
Real.exp (Real.log (T : ℝ) + Real.log (U : ℝ) -
2 * Real.log (M : ℝ) - Real.log 2) =
(T : ℝ) * ((U : ℝ) / (M : ℝ) ^ 2 / 2) := by
have hTr : (0 : ℝ) < T := by exact_mod_cast hT
have hUr : (0 : ℝ) < U := by exact_mod_cast hU
have hMr : (0 : ℝ) < M := by exact_mod_cast hM
rw [Real.exp_sub, Real.exp_sub, Real.exp_add, Real.exp_log hTr,
Real.exp_log hUr, Real.exp_log (by norm_num : (0 : ℝ) < 2)]
rw [show 2 * Real.log (M : ℝ) = Real.log ((M : ℝ) ^ 2) by
rw [Real.log_pow]; norm_num, Real.exp_log (pow_pos hMr 2)]
ring
theorem eventually_floor_exp_le_of_log_lower {Y : β„• β†’ β„•} {L : β„• β†’ ℝ} {R : ℝ}
(hL : Tendsto (fun N => L N / (N : ℝ)) atTop (𝓝 R))
(hY : βˆ€αΆ  N in atTop, Real.exp (L N) ≀ (Y N : ℝ))
{Ξ΅ : ℝ} (hΞ΅ : 0 < Ξ΅) :
βˆ€αΆ  N : β„• in atTop, ⌊Real.exp ((N : ℝ) * (R - Ξ΅))βŒ‹β‚Š ≀ Y N := by
filter_upwards [(tendsto_order.1 hL).1 (R - Ξ΅) (by linarith), hY,
(eventually_atTop.2 ⟨1, fun N (hN : 1 ≀ N) => hN⟩)] with N hrate hy hN
have hNr : (0 : ℝ) < N := by exact_mod_cast hN
have hexp : Real.exp ((N : ℝ) * (R - Ξ΅)) ≀ (Y N : ℝ) := by
apply le_trans (Real.exp_le_exp.mpr ?_) hy
have hm := (lt_div_iffβ‚€ hNr).mp hrate
nlinarith
simpa only [Nat.floor_natCast] using Nat.floor_le_floor hexp
theorem eventually_exists_many_good
{Ξ© E : β„• β†’ Type*} [βˆ€ N, Fintype (Ξ© N)] [βˆ€ N, Nonempty (Ξ© N)]
[βˆ€ N, Fintype (E N)]
(good : βˆ€ N, Ξ© N β†’ E N β†’ Prop) (U M : β„• β†’ β„•) {A H : ℝ}
(hpos : βˆ€αΆ  N in atTop, 0 < Fintype.card (E N) ∧ 0 < U N ∧ 0 < M N)
(hinc : βˆ€αΆ  N in atTop, βˆ€ e,
((U N : ℝ) / (M N : ℝ) ^ 2 / 2) * (Fintype.card (Ξ© N) : ℝ) ≀
(goodIncidence (good N) e : ℝ))
(hE : Tendsto (fun N => Real.log (Fintype.card (E N) : ℝ) / (N : ℝ))
atTop (𝓝 A))
(hU : Tendsto (fun N => Real.log (U N : ℝ) / (N : ℝ)) atTop (𝓝 H))
(hM : Tendsto (fun N => Real.log (M N : ℝ) / (N : ℝ)) atTop (𝓝 H))
{Ξ΅ : ℝ} (hΞ΅ : 0 < Ξ΅) :
βˆ€αΆ  N in atTop, βˆƒ Ο‰ : Ξ© N,
⌊Real.exp ((N : ℝ) * (A - H - Ξ΅))βŒ‹β‚Š ≀ goodCount (good N) Ο‰ := by
let L : β„• β†’ ℝ := fun N => Real.log (Fintype.card (E N) : ℝ) +
Real.log (U N : ℝ) - 2 * Real.log (M N : ℝ) - Real.log 2
have hL : Tendsto (fun N => L N / (N : ℝ)) atTop (𝓝 (A - H)) := by
simpa only [L, show A + H - 2 * H = A - H by ring] using
tendsto_log_yield_lower hE hU hM
filter_upwards [hpos, hinc, (tendsto_order.1 hL).1 (A - H - Ξ΅) (by linarith),
(eventually_atTop.2 ⟨1, fun N (hN : 1 ≀ N) => hN⟩)] with N hp hi hr hN
obtain βŸ¨Ο‰, hΟ‰βŸ© := exists_goodCount_ge (good N) _ hi
refine βŸ¨Ο‰, ?_⟩
have heq := exp_log_yield_lower hp.1 hp.2.1 hp.2.2
have hNr : (0 : ℝ) < N := by exact_mod_cast hN
have he : Real.exp ((N : ℝ) * (A - H - Ξ΅)) ≀
(goodCount (good N) Ο‰ : ℝ) := by
calc
_ ≀ Real.exp (L N) := Real.exp_le_exp.mpr (by
have hm := (lt_div_iffβ‚€ hNr).mp hr
nlinarith)
_ = _ := heq
_ ≀ _ := hΟ‰
simpa only [Nat.floor_natCast] using Nat.floor_le_floor he
theorem eventually_exists_many_good_explicit
{Ξ© E : β„• β†’ Type*} [βˆ€ N, Fintype (Ξ© N)] [βˆ€ N, Nonempty (Ξ© N)]
[βˆ€ N, Fintype (E N)]
(good : βˆ€ N, Ξ© N β†’ E N β†’ Prop) {A H : ℝ} (hH : 0 ≀ H)
(hpos : βˆ€αΆ  N in atTop, 0 < Fintype.card (E N))
(hinc : βˆ€αΆ  N in atTop, βˆ€ e,
(((JointAPFree.modularSet (hashModulus H N)).card : ℝ) /
(hashModulus H N : ℝ) ^ 2 / 2) * (Fintype.card (Ξ© N) : ℝ) ≀
(goodIncidence (good N) e : ℝ))
(hE : Tendsto (fun N => Real.log (Fintype.card (E N) : ℝ) / (N : ℝ))
atTop (𝓝 A))
{Ξ΅ : ℝ} (hΞ΅ : 0 < Ξ΅) :
βˆ€αΆ  N in atTop, βˆƒ Ο‰ : Ξ© N,
⌊Real.exp ((N : ℝ) * (A - H - Ξ΅))βŒ‹β‚Š ≀ goodCount (good N) Ο‰ := by
have hM : βˆ€ N, 2 ≀ hashModulus H N := fun N =>
(by norm_num : 2 ≀ 37).trans (hashModulus_ge H N)
have hr := tendsto_log_hashModulus_div_nat hH
apply eventually_exists_many_good good
(fun N => (JointAPFree.modularSet (hashModulus H N)).card) (hashModulus H)
_ hinc hE (tendsto_log_modularSet_card_div_nat (Eventually.of_forall hM) hr) hr hΞ΅
filter_upwards [hpos] with N hN
exact ⟨hN, JointAPFree.modularSet_card_pos (hM N),
lt_of_lt_of_le (by decide : 0 < 2) (hM N)⟩
theorem fixed_product_subexponential {I : Type*} (s : Finset I) (R : I β†’ β„• β†’ β„•)
(hpos : βˆ€ i ∈ s, βˆ€ N, 0 < R i N)
(hR : βˆ€ i ∈ s,
Tendsto (fun N => Real.log (R i N : ℝ) / (N : ℝ)) atTop (𝓝 0)) :
Tendsto (fun N => Real.log ((∏ i ∈ s, R i N : β„•) : ℝ) / (N : ℝ))
atTop (𝓝 0) := by
simpa only [Finset.sum_const_zero] using
MatrixMultiplication.Foundation.Separation.tendsto_log_nat_prod_div_nat s hpos hR
theorem presence_replications_subexponential (L : β„• β†’ β„•)
(hL : Tendsto (fun N => (L N : ℝ) / (N : ℝ)) atTop (𝓝 0)) :
Tendsto (fun N => Real.log ((2 ^ (3 * L N) : β„•) : ℝ) / (N : ℝ))
atTop (𝓝 0) := by
have h := hL.const_mul (3 * Real.log 2)
simp only [mul_zero] at h
apply h.congr
intro N
rw [Nat.cast_pow, Real.log_pow]
push_cast
ring
end MatrixMultiplication.JointExtractionRates
end
end
end MatrixAllFields
end OAI