Download data/lean/OAI/LinearAlgebra/MatrixMultiplication/JointExtraction/ExtractionRates.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 19 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/LinearAlgebra/MatrixMultiplication/JointExtraction/ExtractionRates.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/LinearAlgebra/MatrixMultiplication/JointExtraction/ExtractionRates.lean
-
curl -L -o ExtractionRates.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/LinearAlgebra/MatrixMultiplication/JointExtraction/ExtractionRates.lean
19 kB
| import OAI.LinearAlgebra.MatrixMultiplication.Entropy.ComplexSeparationAsymptotics | |
| import OAI.LinearAlgebra.MatrixMultiplication.JointExtraction.APFree | |
| import Mathlib.Algebra.Order.Floor.Semiring | |
| import Mathlib.Analysis.SpecialFunctions.Exp | |
| namespace OAI | |
| /-! Joint tensor extraction, compatibility and entropy estimates. -/ | |
| noncomputable section | |
| 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 OAI | |