| import OAI.Geometry.LatticeCovering.Sections |
|
|
| namespace OAI |
|
|
| section |
| section |
| noncomputable section |
| open Real Filter Topology Asymptotics |
|
|
| namespace SingleLatticeCovering.FinalRates |
|
|
| def firstSize (n : ℕ) : ℕ := ⌈(Real.log (Real.log (n : ℝ)))^2⌉₊ |
|
|
| lemma loglog_nat_atTop : Tendsto (fun n : ℕ => Real.log (Real.log (n : ℝ))) atTop atTop := |
| Real.tendsto_log_atTop.comp (Real.tendsto_log_atTop.comp tendsto_natCast_atTop_atTop) |
|
|
| lemma log_nat_atTop : Tendsto (fun n : ℕ => Real.log (n : ℝ)) atTop atTop := |
| Real.tendsto_log_atTop.comp tendsto_natCast_atTop_atTop |
|
|
| lemma loglog_sq_littleO : |
| (fun n : ℕ => (Real.log (Real.log (n : ℝ)))^2) =o[atTop] |
| (fun n : ℕ => Real.log (n : ℝ)) := by |
| simpa only [Function.comp_def,Real.rpow_two,Real.rpow_one] using |
| (isLittleO_log_rpow_rpow_atTop (2 : ℝ) (by norm_num : (0 : ℝ) < 1)).comp_tendsto log_nat_atTop |
|
|
| lemma firstSize_tendsto : Tendsto firstSize atTop atTop := by |
| apply tendsto_nat_ceil_atTop.comp |
| simpa only [Function.comp_def,Real.rpow_two] using (tendsto_rpow_atTop (by norm_num : (0 : ℝ) < 2)).comp loglog_nat_atTop |
|
|
| lemma eventually_firstSize_le_log {c : ℝ} (hc : 0 < c) : |
| ∀ᶠ n : ℕ in atTop, (firstSize n : ℝ)+1 ≤ c*Real.log (n : ℝ) := by |
| filter_upwards [loglog_sq_littleO.bound (half_pos hc), |
| log_nat_atTop.eventually (eventually_ge_atTop (4/c))] with n hs hl |
| rw [Real.norm_eq_abs,Real.norm_eq_abs,abs_of_nonneg (sq_nonneg _), |
| abs_of_nonneg (Real.log_natCast_nonneg n)] at hs |
| have hceil := Nat.ceil_lt_add_one (sq_nonneg (Real.log (Real.log (n : ℝ)))) |
| have he : 4 ≤ c*Real.log (n : ℝ) := by simpa only [mul_comm] using (div_le_iff₀ hc).mp hl |
| change (firstSize n : ℝ) < (Real.log (Real.log (n : ℝ)))^2+1 at hceil |
| linarith |
|
|
|
|
|
|
| lemma eventually_dimension_power {C a r : ℝ} (hC : 0 < C) (ha : 1 < a) (hr : 0 < r) : |
| ∀ᶠ n : ℕ in atTop, ∀ D : ℕ, (D : ℝ) ≤ C*((firstSize n : ℝ)+1) → |
| a^D ≤ (n : ℝ)^r := by |
| have hal : 0 < Real.log a := Real.log_pos ha |
| have ha0 : 0 < a := lt_trans zero_lt_one ha |
| filter_upwards [eventually_firstSize_le_log (div_pos hr (mul_pos hC hal)), |
| eventually_ge_atTop (1 : ℕ)] with n hn hn1 D hD |
| have hn0 : (0 : ℝ) < n := by exact_mod_cast hn1 |
| apply (Real.log_le_log_iff (pow_pos ha0 _) (Real.rpow_pos_of_pos hn0 r)).mp |
| rw [Real.log_pow,Real.log_rpow hn0] |
| calc |
| (D : ℝ)*Real.log a ≤ C*((firstSize n : ℝ)+1)*Real.log a := |
| mul_le_mul_of_nonneg_right hD hal.le |
| _ = (C*Real.log a)*((firstSize n : ℝ)+1) := by ring |
| _ ≤ (C*Real.log a)*(r/(C*Real.log a)*Real.log (n : ℝ)) := |
| mul_le_mul_of_nonneg_left hn (mul_pos hC hal).le |
| _ = r*Real.log (n : ℝ) := by field_simp |
|
|
| lemma eventually_superlinear_power {k : ℝ} (hk : 0 < k) : |
| ∀ᶠ s : ℝ in atTop, 2*s ≤ k*s^(7/5 : ℝ) := by |
| filter_upwards [eventually_ge_atTop (1 : ℝ), |
| (tendsto_rpow_atTop (by norm_num : (0 : ℝ) < 2/5)).eventually |
| (eventually_ge_atTop (2/k))] with s hs hpow |
| have hs0 : 0 < s := lt_of_lt_of_le zero_lt_one hs |
| have hmul : 2 ≤ k*s^(2/5 : ℝ) := by simpa only [mul_comm] using (div_le_iff₀ hk).mp hpow |
| have he : s^(7/5 : ℝ)=s*s^(2/5 : ℝ) := by |
| rw [show (7/5 : ℝ)=1+2/5 by norm_num,Real.rpow_add hs0,Real.rpow_one] |
| rw [he] |
| nlinarith [mul_nonneg hs0.le (sub_nonneg.mpr hmul)] |
|
|
|
|
|
|
| lemma cap_log_tendsto {k : ℝ} (hk : 0 < k) : |
| Tendsto (fun n : ℕ => Real.log (n : ℝ)* |
| Real.exp (-k*(firstSize n : ℝ)^(70/100 : ℝ))) atTop (𝓝 0) := by |
| have hexp : Tendsto (fun n : ℕ => Real.exp (-Real.log (Real.log (n : ℝ)))) atTop (𝓝 0) := |
| Real.tendsto_exp_atBot.comp (tendsto_neg_atTop_atBot.comp loglog_nat_atTop) |
| apply squeeze_zero' (Eventually.of_forall (fun n => |
| mul_nonneg (Real.log_natCast_nonneg n) (Real.exp_pos _).le)) ?_ hexp |
| filter_upwards [loglog_nat_atTop.eventually (eventually_superlinear_power hk), |
| loglog_nat_atTop.eventually (eventually_ge_atTop (1 : ℝ)), |
| eventually_ge_atTop (2 : ℕ)] with n hpow hs hn |
| have hnlog : 0 < Real.log (n : ℝ) := Real.log_pos (by exact_mod_cast hn) |
| have hs0 : 0 ≤ Real.log (Real.log (n : ℝ)) := le_trans zero_le_one hs |
| have hceil := Nat.le_ceil ((Real.log (Real.log (n : ℝ)))^2) |
| have hcappow : (Real.log (Real.log (n : ℝ)))^(7/5 : ℝ) ≤ |
| (firstSize n : ℝ)^(70/100 : ℝ) := by |
| have hh := Real.rpow_le_rpow (sq_nonneg (Real.log (Real.log (n : ℝ)))) hceil |
| (by norm_num : (0 : ℝ) ≤ 70/100) |
| rw [←Real.rpow_natCast _ 2,←Real.rpow_mul hs0] at hh |
| norm_num at hh |
| simpa only [firstSize,show (70/100 : ℝ)=(7/10 : ℝ) by norm_num] using hh |
| conv_lhs => rw [←Real.exp_log hnlog,←Real.exp_add] |
| apply Real.exp_le_exp.mpr |
| nlinarith [mul_le_mul_of_nonneg_left hcappow hk.le] |
| |
| |
| |
| end SingleLatticeCovering.FinalRates |
| noncomputable section |
| |
| namespace SingleLatticeCovering.FinalRates |
| open Real Filter Topology Asymptotics |
| |
| lemma eventually_log_power_bound (k : ℕ) {r ε : ℝ} (hr : 0 < r) (hε : 0 < ε) : |
| ∀ᶠ n : ℕ in atTop, (Real.log (n : ℝ))^k ≤ ε*(n : ℝ)^r := by |
| have h : (fun n : ℕ => (Real.log (n : ℝ))^k) =o[atTop] |
| (fun n : ℕ => (n : ℝ)^r) := by |
| simpa only [Function.comp_def,Real.rpow_natCast] using |
| (isLittleO_log_rpow_rpow_atTop (k : ℝ) hr).comp_tendsto tendsto_natCast_atTop_atTop |
| filter_upwards [h.bound hε] with n hn |
| simpa only [Real.norm_eq_abs,abs_of_nonneg (pow_nonneg (Real.log_natCast_nonneg n) _), |
| abs_of_nonneg (Real.rpow_nonneg (Nat.cast_nonneg n) _)] using hn |
| |
| lemma eventually_dimension_small {C : ℝ} (hC : 0 < C) : |
| ∀ᶠ n : ℕ in atTop, ∀ D : ℕ, (D : ℝ) ≤ C*((firstSize n : ℝ)+1) → |
| (D : ℝ) ≤ Real.log (n : ℝ) ∧ (D : ℝ) ≤ (n : ℝ)/2 := by |
| filter_upwards [eventually_firstSize_le_log (inv_pos.mpr hC), |
| eventually_log_power_bound 1 (by norm_num : (0 : ℝ) < 1) |
| (by norm_num : (0 : ℝ) < 1/2)] with n hn hlog D hD |
| have hDl : (D : ℝ) ≤ Real.log (n : ℝ) := by |
| calc |
| _ ≤ C*((firstSize n : ℝ)+1) := hD |
| _ ≤ C*(C⁻¹*Real.log (n : ℝ)) := mul_le_mul_of_nonneg_left hn hC.le |
| _ = Real.log (n : ℝ) := by field_simp |
| refine ⟨hDl,hDl.trans ?_⟩ |
| simpa only [pow_one,Real.rpow_one,one_div,mul_comm,div_eq_mul_inv,one_mul] using hlog |
| |
| def eta (m : ℕ) : ℝ := (m : ℝ)/4*Real.log (27/16 : ℝ)-3*Real.log (m : ℝ) |
| |
| lemma eta_linear_lower : |
| ∀ᶠ m : ℕ in atTop, (Real.log (27/16 : ℝ)/8)*(m : ℝ) ≤ eta m := by |
| have hlog : 0 < Real.log (27/16 : ℝ) := Real.log_pos (by norm_num) |
| filter_upwards [eventually_log_power_bound 1 (by norm_num : (0 : ℝ) < 1) |
| (div_pos hlog (by norm_num : (0 : ℝ) < 24))] with m hm |
| simp only [pow_one,Real.rpow_one] at hm |
| dsimp [eta] |
| linarith |
| |
| lemma eventually_cap_linear {k H ε : ℝ} (hk : 0 < k) (hH : 0 ≤ H) (hε : 0 < ε) : |
| ∀ᶠ n : ℕ in atTop, ∀ m : ℕ, (n : ℝ)/2 ≤ m → |
| H*(n : ℝ)*Real.log (n : ℝ)*Real.exp (-k*(firstSize n : ℝ)^(70/100 : ℝ)) ≤ ε*m := by |
| have _ := hH |
| have ht : Tendsto (fun n : ℕ => H*(Real.log (n : ℝ)* |
| Real.exp (-k*(firstSize n : ℝ)^(70/100 : ℝ)))) atTop (𝓝 0) := |
| by simpa only [mul_zero] using (cap_log_tendsto hk).const_mul H |
| filter_upwards [ht.eventually (gt_mem_nhds (half_pos hε))] with n hn m hm |
| calc |
| _ = (n : ℝ)*(H*(Real.log (n : ℝ)*Real.exp (-k*(firstSize n : ℝ)^(70/100 : ℝ)))) := by ring |
| _ ≤ (n : ℝ)*(ε/2) := mul_le_mul_of_nonneg_left hn.le (Nat.cast_nonneg n) |
| _ ≤ ε*m := by nlinarith |
| |
| |
| |
| lemma eventually_cap_eta {C k H : ℝ} (hC : 0 < C) (hk : 0 < k) (hH : 0 ≤ H) : |
| ∀ᶠ n : ℕ in atTop, ∀ D : ℕ, (D : ℝ) ≤ C*((firstSize n : ℝ)+1) → |
| D ≤ n ∧ H*(n : ℝ)*Real.log (n : ℝ)* |
| Real.exp (-k*(firstSize n : ℝ)^(70/100 : ℝ)) ≤ eta (n-D) := by |
| obtain ⟨M,hM⟩ := eventually_atTop.mp eta_linear_lower |
| have hlog : 0 < Real.log (27/16 : ℝ) := Real.log_pos (by norm_num) |
| filter_upwards [eventually_dimension_small hC, |
| eventually_cap_linear hk hH (div_pos hlog (by norm_num : (0 : ℝ) < 8)), |
| eventually_ge_atTop (2*M)] with n hD hn hnM D hdim |
| have hhalf := (hD D hdim).2 |
| have hDn : D ≤ n := by exact_mod_cast (show (D : ℝ) ≤ n by linarith) |
| have hm : (n : ℝ)/2 ≤ (n-D : ℕ) := by rw [Nat.cast_sub hDn]; linarith |
| have hMm : M ≤ n-D := by |
| have hnMr : (2 : ℝ)*M ≤ n := by exact_mod_cast hnM |
| exact_mod_cast (show (M : ℝ) ≤ (n-D : ℕ) from by linarith) |
| exact ⟨hDn,(hn (n-D) hm).trans (hM _ hMm)⟩ |
| |
| lemma eventually_rpow_bound {a b ε : ℝ} (hab : a < b) (hε : 0 < ε) : |
| ∀ᶠ n : ℕ in atTop, (n : ℝ)^a ≤ ε*(n : ℝ)^b := by |
| filter_upwards [((tendsto_rpow_atTop (sub_pos.mpr hab)).comp |
| tendsto_natCast_atTop_atTop).eventually (eventually_ge_atTop (1/ε)), |
| eventually_ge_atTop (1 : ℕ)] with n hn hn1 |
| have hn0 : (0 : ℝ) < n := by exact_mod_cast hn1 |
| have hm : 1 ≤ ε*(n : ℝ)^(b-a) := by |
| simpa only [Function.comp_def,mul_comm] using (div_le_iff₀ hε).mp hn |
| have he : (n : ℝ)^b=(n : ℝ)^a*(n : ℝ)^(b-a) := by |
| rw [←Real.rpow_add hn0]; congr 1; ring |
| rw [he] |
| nlinarith [mul_le_mul_of_nonneg_left hm (Real.rpow_pos_of_pos hn0 a).le] |
| |
| lemma sqrt_nat_atTop : Tendsto (fun n : ℕ => Real.sqrt (n : ℝ)) atTop atTop := by |
| simpa only [Function.comp_def,Real.sqrt_eq_rpow] using |
| (tendsto_rpow_atTop (by norm_num : (0 : ℝ) < 1/2)).comp tendsto_natCast_atTop_atTop |
| |
| lemma sqrt_half_bound {n m : ℕ} (hm : (n : ℝ)/2 ≤ m) : |
| Real.sqrt (n : ℝ) ≤ 2*Real.sqrt (m : ℝ) := by |
| have hn0 := Real.sqrt_nonneg (n : ℝ) |
| have hm0 := Real.sqrt_nonneg (m : ℝ) |
| have hn2 := Real.sq_sqrt (Nat.cast_nonneg n : (0 : ℝ) ≤ n) |
| have hm2 := Real.sq_sqrt (Nat.cast_nonneg m : (0 : ℝ) ≤ m) |
| nlinarith |
| |
| |
| lemma eventually_discard_bound {C ε : ℝ} (hC : 0 < C) (hε : 0 < ε) : |
| ∀ᶠ n : ℕ in atTop, ∀ D m : ℕ, (D : ℝ) ≤ C*((firstSize n : ℝ)+1) → m ≤ n → |
| (2 : ℝ)^D*Real.sqrt (m : ℝ) ≤ ε*(n : ℝ)*Real.log (n : ℝ) := by |
| filter_upwards [eventually_dimension_power hC (by norm_num : (1 : ℝ) < 2) |
| (by norm_num : (0 : ℝ) < 1/4), |
| eventually_rpow_bound (by norm_num : (3/4 : ℝ) < 1) hε, |
| log_nat_atTop.eventually (eventually_ge_atTop (1 : ℝ)), |
| eventually_ge_atTop (1 : ℕ)] with n hp hr hlog hn1 D m hD hmn |
| have hn0 : (0 : ℝ) < n := by exact_mod_cast hn1 |
| calc |
| _ ≤ (n : ℝ)^(1/4 : ℝ)*Real.sqrt (n : ℝ) := |
| mul_le_mul (hp D hD) (Real.sqrt_le_sqrt (by exact_mod_cast hmn)) |
| (Real.sqrt_nonneg _) (Real.rpow_pos_of_pos hn0 _).le |
| _ = (n : ℝ)^(3/4 : ℝ) := by |
| rw [Real.sqrt_eq_rpow,←Real.rpow_add hn0]; norm_num |
| _ ≤ ε*(n : ℝ) := by simpa only [Real.rpow_one] using hr |
| _ ≤ ε*(n : ℝ)*Real.log (n : ℝ) := le_mul_of_one_le_right (by positivity) hlog |
| |
| |
| |
| lemma eventually_label_criterion {C Cs CR : ℝ} (hC : 0 < C) (hCs : 1 ≤ Cs) (hCR : 0 ≤ CR) : |
| ∀ᶠ n : ℕ in atTop, ∀ D m : ℕ, (D : ℝ) ≤ C*((firstSize n : ℝ)+1) → |
| (n : ℝ)/2 ≤ m → m ≤ n → |
| (1+CR)*(Cs*(m : ℝ)^2)^D*Real.exp (-Real.sqrt (m : ℝ)/2) < 1 := by |
| have hCR1 : 0 < 1+CR := by linarith |
| have hCs0 : 0 < Cs := lt_of_lt_of_le zero_lt_one hCs |
| filter_upwards [eventually_dimension_small hC, |
| eventually_log_power_bound 2 (by norm_num : (0 : ℝ) < 1/2) |
| (by norm_num : (0 : ℝ) < 1/48), |
| sqrt_nat_atTop.eventually (eventually_ge_atTop (16*(Real.log (1+CR)+1))), |
| tendsto_natCast_atTop_atTop.eventually (eventually_ge_atTop Cs), |
| eventually_ge_atTop (2 : ℕ)] with n hdim hpoly hsqrt hCsn hn2 D m hD hm hmn |
| have hn1 : (1 : ℝ) ≤ n := by exact_mod_cast (show 1 ≤ n by omega) |
| have hm1 : (1 : ℝ) ≤ m := by |
| have hn2r : (2 : ℝ) ≤ n := by exact_mod_cast hn2 |
| linarith |
| have hm0 : (0 : ℝ) < m := lt_of_lt_of_le zero_lt_one hm1 |
| have hn0 : (0 : ℝ) < n := lt_of_lt_of_le zero_lt_one hn1 |
| have hDl := (hdim D hD).1 |
| have hlogm : Real.log (m : ℝ) ≤ Real.log (n : ℝ) := Real.log_le_log hm0 (by exact_mod_cast hmn) |
| have hlogC : Real.log Cs ≤ Real.log (n : ℝ) := Real.log_le_log hCs0 hCsn |
| have hlogm0 : 0 ≤ Real.log (m : ℝ) := Real.log_nonneg hm1 |
| have hlogC0 : 0 ≤ Real.log Cs := Real.log_nonneg hCs |
| have hlogs : (D : ℝ)*(Real.log Cs+2*Real.log (m : ℝ)) ≤ 3*(Real.log (n : ℝ))^2 := by |
| calc |
| _ ≤ Real.log (n : ℝ)*(Real.log Cs+2*Real.log (m : ℝ)) := |
| mul_le_mul_of_nonneg_right hDl (by linarith) |
| _ ≤ Real.log (n : ℝ)*(3*Real.log (n : ℝ)) := |
| mul_le_mul_of_nonneg_left (by linarith) (Real.log_natCast_nonneg n) |
| _ = _ := by ring |
| rw [←Real.sqrt_eq_rpow] at hpoly |
| have hs := sqrt_half_bound hm |
| have hneg : Real.log (1+CR)+(D : ℝ)*(Real.log Cs+2*Real.log (m : ℝ))- |
| Real.sqrt (m : ℝ)/2 < 0 := by linarith [Real.sqrt_nonneg (m : ℝ)] |
| have he : (1+CR)*(Cs*(m : ℝ)^2)^D*Real.exp (-Real.sqrt (m : ℝ)/2) = |
| Real.exp (Real.log (1+CR)+(D : ℝ)*(Real.log Cs+2*Real.log (m : ℝ))- |
| Real.sqrt (m : ℝ)/2) := by |
| have hp : (Cs*(m : ℝ)^2)^D = |
| Real.exp ((D : ℝ)*(Real.log Cs+2*Real.log (m : ℝ))) := by |
| rw [Real.exp_nat_mul,Real.exp_add,Real.exp_log hCs0] |
| rw [show (2 : ℝ)*Real.log (m : ℝ)=Real.log ((m : ℝ)^2) by rw [Real.log_pow]; norm_num, |
| Real.exp_log (pow_pos hm0 2)] |
| calc |
| _ = Real.exp (Real.log (1+CR))* |
| Real.exp ((D : ℝ)*(Real.log Cs+2*Real.log (m : ℝ)))* |
| Real.exp (-Real.sqrt (m : ℝ)/2) := by rw [Real.exp_log hCR1,hp] |
| _ = _ := by rw [←Real.exp_add,←Real.exp_add]; congr 1; ring |
| rw [he] |
| exact Real.exp_lt_one_iff.mpr hneg |
| |
| |
| |
| |
| end SingleLatticeCovering.FinalRates |
| |
| end |
| end |
| end |
| |
| section |
| |
| noncomputable section |
| namespace SingleLatticeCovering.Shear |
| open Real Filter Topology |
| open scoped BigOperators |
| |
| |
| |
| def pointBudget {α : Type*} (A : ℕ → Finset ℝ) (s : Finset α) (D : ℕ) : ℕ := |
| (s.card+1)*∏ j ∈ Finset.range D, ((A j).card+1) |
| |
| lemma pointBudget_pos {α : Type*} (A : ℕ → Finset ℝ) (s : Finset α) (D : ℕ) : |
| 0 < pointBudget A s D := by |
| dsimp [pointBudget] |
| exact Nat.mul_pos (by omega) (Finset.prod_pos (fun j hj => by omega)) |
| |
| lemma alphabetPoints_card_le_budget {α : Type*} (A : ℕ → Finset ℝ) (s : Finset α) |
| {q D : ℕ} (hq : q ≤ D) : (alphabetPoints A s q).card ≤ pointBudget A s D := by |
| classical |
| have hp : ∏ j ∈ Finset.range q, (A j).card ≤ |
| ∏ j ∈ Finset.range D, ((A j).card+1) := by |
| calc |
| _ ≤ ∏ j ∈ Finset.range q, ((A j).card+1) := Finset.prod_le_prod₀ (fun j hj => Nat.zero_le _) (fun j hj => Nat.le_succ _) |
| _ ≤ _ := Finset.prod_le_prod_of_subset_of_one_le₀ (Finset.range_mono hq) (fun j hj => Nat.zero_le _) (fun j hj _ => Nat.succ_pos _) |
| dsimp [alphabetPoints,pointBudget] |
| rw [Finset.card_product,Fintype.card_piFinset] |
| have he : (∏ i : Fin q, (A i.val).card) = ∏ j ∈ Finset.range q, (A j).card := |
| Fin.prod_univ_eq_prod_range (fun j => (A j).card) q |
| rw [he] |
| exact le_trans (Nat.mul_le_mul_right s.card hp) (by simp [mul_comm]) |
| |
| def patternTotal {α : Type*} (A : ℕ → Finset ℝ) (s : Finset α) (D : ℕ) : ℕ := |
| ∑ q ∈ Finset.range (D+1), (allPatterns A s q).card |
| |
| lemma patternTotal_bound {α : Type*} (A : ℕ → Finset ℝ) (s : Finset α) (D : ℕ) : |
| patternTotal A s D ≤ (D+1)*(pointBudget A s D+1)^(2^D) := |
| allPatterns_total_bound A s D (pointBudget A s D) (fun _ hq => alphabetPoints_card_le_budget A s hq) |
| |
| lemma log_pointBudget {α : Type*} (A : ℕ → Finset ℝ) (s : Finset α) (D : ℕ) : |
| Real.log (pointBudget A s D : ℝ) = Real.log (s.card+1 : ℝ)+ |
| ∑ j ∈ Finset.range D, Real.log ((A j).card+1 : ℝ) := by |
| simp only [pointBudget,Nat.cast_mul,Nat.cast_add,Nat.cast_one,Nat.cast_prod] |
| rw [Real.log_mul (by positivity) (by positivity),Real.log_prod] |
| intro j hj; positivity |
| |
| lemma scalar_pattern_cost (D N Q : ℕ) (hN : 0 < N) |
| (hQ : Q ≤ (D+1)*(N+1)^(2^D)) : |
| (2 : ℝ)^D*Real.log (2*((Q : ℝ)+1)) ≤ |
| (4 : ℝ)^D*(Real.log 8+Real.log ((D : ℝ)+1)+Real.log (N : ℝ)) := by |
| have hNr : (1 : ℝ) ≤ N := by exact_mod_cast hN |
| have hNp : (0 : ℝ) < N := lt_of_lt_of_le zero_lt_one hNr |
| have hD : (0 : ℝ) < (D : ℝ)+1 := by positivity |
| have hbase : (1 : ℝ) ≤ ((D : ℝ)+1)*((N : ℝ)+1)^(2^D) := |
| one_le_mul_of_one_le_of_one_le (by linarith [(Nat.cast_nonneg D : (0 : ℝ) ≤ D)]) (one_le_pow₀ (by linarith)) |
| have hQr : (Q : ℝ) ≤ ((D : ℝ)+1)*((N : ℝ)+1)^(2^D) := by exact_mod_cast hQ |
| have hl : Real.log (2*((Q : ℝ)+1)) ≤ Real.log 4+Real.log ((D : ℝ)+1)+ |
| (2^D : ℕ)*Real.log ((N : ℝ)+1) := by |
| calc |
| _ ≤ Real.log (4*(((D : ℝ)+1)*((N : ℝ)+1)^(2^D))) := |
| Real.log_le_log (by positivity) (by linarith) |
| _ = _ := by rw [Real.log_mul (by norm_num) (by positivity), |
| Real.log_mul hD.ne' (by positivity),Real.log_pow]; ring |
| have hNl : Real.log ((N : ℝ)+1) ≤ Real.log 2+Real.log (N : ℝ) := by |
| rw [←Real.log_mul (by norm_num) hNp.ne'] |
| exact Real.log_le_log (by positivity) (by linarith) |
| have h2 : (1 : ℝ) ≤ (2 : ℝ)^D := one_le_pow₀ (by norm_num) |
| have hDl : 0 ≤ Real.log ((D : ℝ)+1) := Real.log_nonneg (by linarith [(Nat.cast_nonneg D : (0 : ℝ) ≤ D)]) |
| have hNlog : 0 ≤ Real.log (N : ℝ) := Real.log_nonneg hNr |
| have h4log : 0 ≤ Real.log 4 := Real.log_nonneg (by norm_num) |
| have h2log : 0 ≤ Real.log 2 := Real.log_nonneg (by norm_num) |
| have hcast : ((2^D : ℕ) : ℝ)=(2 : ℝ)^D := by norm_cast |
| rw [hcast] at hl |
| have h24 : (2 : ℝ)^D*(2 : ℝ)^D=(4 : ℝ)^D := by rw [←mul_pow]; norm_num |
| have h8 : Real.log 8=Real.log 4+Real.log 2 := by |
| rw [←Real.log_mul (by norm_num) (by norm_num)]; norm_num |
| calc |
| _ ≤ (2 : ℝ)^D*(Real.log 4+Real.log ((D : ℝ)+1)+(2 : ℝ)^D*Real.log ((N : ℝ)+1)) := |
| mul_le_mul_of_nonneg_left hl (by positivity) |
| _ ≤ (2 : ℝ)^D*((2 : ℝ)^D*(Real.log 4+Real.log ((D : ℝ)+1))+ |
| (2 : ℝ)^D*(Real.log 2+Real.log (N : ℝ))) := by gcongr; nlinarith |
| _ = _ := by rw [h8,←h24]; ring |
| |
| lemma all_pattern_cost {α : Type*} (A : ℕ → Finset ℝ) (s : Finset α) (D : ℕ) : |
| (2 : ℝ)^D*Real.log (2*((patternTotal A s D : ℝ)+1)) ≤ |
| (4 : ℝ)^D*(Real.log 8+Real.log ((D : ℝ)+1)+Real.log (s.card+1 : ℝ)+ |
| ∑ j ∈ Finset.range D, Real.log ((A j).card+1 : ℝ)) := by |
| have h := scalar_pattern_cost D (pointBudget A s D) (patternTotal A s D) |
| (pointBudget_pos A s D) (patternTotal_bound A s D) |
| rw [log_pointBudget] at h |
| convert h using 1 ; ring |
| |
| |
| end SingleLatticeCovering.Shear |
| |
| noncomputable section |
| namespace SingleLatticeCovering.Shear |
| open Real Filter Topology |
| open scoped BigOperators |
| |
| lemma polynomial_pattern_cost {α : Type*} (A : ℕ → Finset ℝ) (s : Finset α) |
| (D : ℕ) {L CL CA : ℝ} (hL : 1 ≤ L) (hCL : 0 ≤ CL) (hCA : 0 ≤ CA) |
| (hD : (D : ℝ) ≤ L) |
| (hlabel : Real.log (s.card+1 : ℝ) ≤ CL*L^2) |
| (halphabet : ∀ j < D, Real.log ((A j).card+1 : ℝ) ≤ CA*L^2) : |
| (2 : ℝ)^D*Real.log (2*((patternTotal A s D : ℝ)+1)) ≤ |
| (4 : ℝ)^D*(Real.log 8+1+CL+CA)*L^3 := by |
| have hs : ∑ j ∈ Finset.range D, Real.log ((A j).card+1 : ℝ) ≤ (D : ℝ)*(CA*L^2) := by |
| calc |
| _ ≤ ∑ j ∈ Finset.range D, CA*L^2 := Finset.sum_le_sum (fun j hj => halphabet j (Finset.mem_range.mp hj)) |
| _ = _ := by simp [nsmul_eq_mul] |
| have hlogD : Real.log ((D : ℝ)+1) ≤ L := by |
| have hh := Real.log_le_sub_one_of_pos (show (0 : ℝ) < D+1 by positivity) |
| linarith |
| have h12 : L ≤ L^2 := by nlinarith |
| have h23 : L^2 ≤ L^3 := by nlinarith [sq_nonneg (L-1)] |
| have h01 : 0 ≤ Real.log 8 := Real.log_nonneg (by norm_num) |
| have hterm : Real.log 8+Real.log ((D : ℝ)+1)+Real.log (s.card+1 : ℝ)+ |
| ∑ j ∈ Finset.range D, Real.log ((A j).card+1 : ℝ) ≤ (Real.log 8+1+CL+CA)*L^3 := by |
| have hsd := mul_le_mul_of_nonneg_right hD (show 0 ≤ CA*L^2 by positivity) |
| have hlab := mul_le_mul_of_nonneg_left h23 hCL |
| have hc := mul_le_mul_of_nonneg_left (show 1 ≤ L^3 by nlinarith) h01 |
| nlinarith |
| calc |
| _ ≤ (4 : ℝ)^D*(Real.log 8+Real.log ((D : ℝ)+1)+Real.log (s.card+1 : ℝ)+ |
| ∑ j ∈ Finset.range D, Real.log ((A j).card+1 : ℝ)) := all_pattern_cost A s D |
| _ ≤ _ := by nlinarith [mul_le_mul_of_nonneg_left hterm (show 0 ≤ (4 : ℝ)^D by positivity)] |
| |
| lemma log_label_count {α : Type*} (s : Finset α) {D n : ℕ} {Cs : ℝ} |
| (hn : 1 ≤ Real.log (n : ℝ)) (hCs : 1 ≤ Cs) (hD : (D : ℝ) ≤ Real.log (n : ℝ)) |
| (hs : (s.card : ℝ) ≤ (Cs*(n : ℝ)^2)^D) : |
| Real.log (s.card+1 : ℝ) ≤ (Real.log 2+Real.log Cs+2)*(Real.log (n : ℝ))^2 := by |
| have hn0 : (0 : ℝ) < n := by |
| by_contra h; have h0 : n=0 := by exact_mod_cast le_antisymm (le_of_not_gt h) (Nat.cast_nonneg n) |
| subst n; norm_num at hn |
| have hn1 : (1 : ℝ) ≤ n := by exact_mod_cast (show 1 ≤ n by exact_mod_cast (Nat.succ_le_iff.mpr (by exact_mod_cast hn0))) |
| have hp : 0 < Cs*(n : ℝ)^2 := by positivity |
| have hp1 : 1 ≤ (Cs*(n : ℝ)^2)^D := one_le_pow₀ (by nlinarith [sq_nonneg ((n : ℝ)-1)]) |
| have hl : Real.log (s.card+1 : ℝ) ≤ Real.log 2+(D : ℝ)*(Real.log Cs+2*Real.log (n : ℝ)) := by |
| calc |
| _ ≤ Real.log (2*(Cs*(n : ℝ)^2)^D) := Real.log_le_log (by positivity) (by linarith) |
| _ = _ := by rw [Real.log_mul (by norm_num) (pow_pos hp _).ne',Real.log_pow, |
| Real.log_mul (by positivity) (by positivity),Real.log_pow]; ring |
| have hc : 0 ≤ Real.log Cs := Real.log_nonneg hCs |
| have hl2 : Real.log (n : ℝ) ≤ (Real.log (n : ℝ))^2 := by nlinarith |
| have h2 : 0 ≤ Real.log 2 := Real.log_nonneg (by norm_num) |
| have hh := mul_le_mul_of_nonneg_right hD (show 0 ≤ Real.log Cs+2*Real.log (n : ℝ) by linarith) |
| nlinarith [mul_le_mul_of_nonneg_left hl2 hc, |
| mul_le_mul_of_nonneg_left (show 1 ≤ (Real.log (n : ℝ))^2 by nlinarith) h2] |
|
|
| lemma log_alphabet_bound {b D : ℕ} {L : ℝ} (hL : 1 ≤ L) |
| (hD : (D : ℝ) ≤ L) (hb : (b : ℝ) ≤ L) : |
| Real.log 8+(D : ℝ)*Real.log ((D : ℝ)+2)+(b : ℝ)^2 ≤ |
| (Real.log 8+3)*L^2 := by |
| have hlog : Real.log ((D : ℝ)+2) ≤ 2*L := by |
| have hh := Real.log_le_sub_one_of_pos (show (0 : ℝ) < D+2 by positivity) |
| linarith |
| have hp := mul_le_mul_of_nonneg_left hlog (Nat.cast_nonneg D) |
| have hD' := mul_le_mul_of_nonneg_right hD (show 0 ≤ 2*L by linarith) |
| have hb2 := pow_le_pow_left₀ (Nat.cast_nonneg b) hb 2 |
| have hc := mul_le_mul_of_nonneg_left (show 1 ≤ L^2 by nlinarith) |
| (Real.log_nonneg (by norm_num : (1 : ℝ) ≤ 8)) |
| nlinarith |
| |
| |
| |
| lemma eventually_pattern_cost {C Cs ε : ℝ} (hC : 0 < C) (hCs : 1 ≤ Cs) (hε : 0 < ε) : |
| ∀ᶠ n : ℕ in atTop, ∀ D : ℕ, (D : ℝ) ≤ C*((FinalRates.firstSize n : ℝ)+1) → |
| ∀ {α : Type*} (s : Finset α) (A : ℕ → Finset ℝ), |
| (s.card : ℝ) ≤ (Cs*(n : ℝ)^2)^D → |
| (∀ j < D, Real.log ((A j).card+1 : ℝ) ≤ |
| Real.log 8+(D : ℝ)*Real.log ((D : ℝ)+2)+(FinalRates.firstSize n : ℝ)^2) → |
| (2 : ℝ)^D*Real.log (2*((patternTotal A s D : ℝ)+1)) ≤ ε*(n : ℝ)*Real.log (n : ℝ) := by |
| let H := Real.log 8+1+(Real.log 2+Real.log Cs+2)+(Real.log 8+3) |
| have hH : 0 < H := by |
| dsimp [H] |
| linarith [Real.log_nonneg hCs,Real.log_nonneg (by norm_num : (1 : ℝ) ≤ 8), |
| Real.log_nonneg (by norm_num : (1 : ℝ) ≤ 2)] |
| filter_upwards [FinalRates.eventually_dimension_small hC, |
| FinalRates.eventually_dimension_power (C := C) (a := 4) (r := 1/2) hC (by norm_num) (by norm_num), |
| FinalRates.eventually_firstSize_le_log (c := 1) (by norm_num), |
| FinalRates.eventually_log_power_bound 3 (r := 1/2) (by norm_num) (div_pos hε hH), |
| FinalRates.log_nat_atTop.eventually (eventually_ge_atTop (1 : ℝ)),eventually_ge_atTop (1 : ℕ)] |
| with n hdim hpow hb hlog hn hn1 |
| intro D hD α s A hs hA |
| have hDL := (hdim D hD).1 |
| have hbL : (FinalRates.firstSize n : ℝ) ≤ Real.log (n : ℝ) := by linarith |
| have hc := polynomial_pattern_cost A s D hn |
| (show 0 ≤ Real.log 2+Real.log Cs+2 by linarith [Real.log_nonneg hCs,Real.log_nonneg (by norm_num : (1 : ℝ) ≤ 2)]) |
| (show 0 ≤ Real.log 8+3 by linarith [Real.log_nonneg (by norm_num : (1 : ℝ) ≤ 8)]) hDL |
| (log_label_count s hn hCs hDL hs) |
| (fun j hj => (hA j hj).trans (log_alphabet_bound hn hDL hbL)) |
| have hn0 : (0 : ℝ) ≤ n := Nat.cast_nonneg n |
| have he : (n : ℝ)^(1/2 : ℝ)*(n : ℝ)^(1/2 : ℝ)=(n : ℝ) := by |
| rw [←Real.rpow_add (show (0 : ℝ) < n by exact_mod_cast hn1)] |
| norm_num |
| calc |
| _ ≤ (4 : ℝ)^D*H*(Real.log (n : ℝ))^3 := hc |
| _ ≤ (n : ℝ)^(1/2 : ℝ)*H*((ε/H)*(n : ℝ)^(1/2 : ℝ)) := by gcongr; exact hpow D hD |
| _ = ε*(n : ℝ) := by calc |
| _ = ε*((n : ℝ)^(1/2 : ℝ)*(n : ℝ)^(1/2 : ℝ)) := by field_simp |
| _ = _ := by rw [he] |
| _ ≤ _ := le_mul_of_one_le_right (mul_nonneg hε.le hn0) hn |
| |
| |
| end SingleLatticeCovering.Shear |
| |
| end |
| end |
| end |
| |
| section |
| |
| |
| |
| noncomputable section |
| namespace SingleLatticeCovering.FinalRates |
| open Real Filter Topology Shear |
| open scoped BigOperators |
| |
| |
| |
| lemma exp_error {n : ℕ} (hn : 2 ≤ n) {cost : ℝ} |
| (hcost : cost ≤ (n : ℝ)*Real.log (n : ℝ)) : |
| Real.exp (cost-(8*(n : ℝ)*Real.log (n : ℝ))/2) ≤ |
| 1/(n : ℝ)^(2*n) := by |
| have hn0 : (0 : ℝ) < n := by exact_mod_cast (show 0 < n by omega) |
| have hlog : 0 ≤ Real.log (n : ℝ) := Real.log_nonneg (by exact_mod_cast (show 1 ≤ n by omega)) |
| have hemp : cost-(8*(n : ℝ)*Real.log (n : ℝ))/2 ≤ -((2*n : ℕ) : ℝ)*Real.log (n : ℝ) := by |
| push_cast; nlinarith [mul_nonneg (Nat.cast_nonneg n) hlog] |
| apply (Real.exp_le_exp.mpr hemp).trans_eq |
| rw [neg_mul,Real.exp_neg,Real.exp_nat_mul,Real.exp_log hn0,one_div] |
| |
| |
| |
| |
| theorem final_conditions {C k csec Csec κ Cs CR : ℝ} |
| (hC : 0 < C) (hk : 0 < k) (hcsec : 0 < csec) (hCsec : 0 ≤ Csec) |
| (hκ : 0 < κ) (hCs : 1 ≤ Cs) (hCR : 0 ≤ CR) : |
| ∃ Cstar : ℝ, 0 < Cstar ∧ ∀ᶠ n : ℕ in atTop, |
| 2 ≤ n ∧ ∀ D : ℕ, (D : ℝ) ≤ C*((firstSize n : ℝ)+1) → |
| D ≤ n ∧ 2 ≤ n-D ∧ |
| Csec*(Cstar*(n : ℝ)*Real.log (n : ℝ))*Real.exp (-k*(firstSize n : ℝ)^(70/100 : ℝ)) ≤ eta (n-D) ∧ |
| 8*(n : ℝ)*Real.log (n : ℝ)+(2 : ℝ)^D*Real.sqrt ((n-D : ℕ) : ℝ) ≤ |
| csec*κ*(Cstar*(n : ℝ)*Real.log (n : ℝ)) ∧ |
| (1+CR)*(Cs*((n-D : ℕ) : ℝ)^2)^D*Real.exp (-Real.sqrt ((n-D : ℕ) : ℝ)/2)<1 ∧ |
| ∀ {α : Type*} (s : Finset α) (A : ℕ → Finset ℝ), |
| (s.card : ℝ) ≤ (Cs*(n : ℝ)^2)^D → |
| (∀ j < D, Real.log ((A j).card+1 : ℝ) ≤ |
| Real.log 8+(D : ℝ)*Real.log ((D : ℝ)+2)+(firstSize n : ℝ)^2) → |
| let Lstar := 2*((patternTotal A s D : ℝ)+1) |
| 1 ≤ Lstar ∧ (patternTotal A s D : ℝ)<Lstar ∧ |
| Real.exp ((2 : ℝ)^D*Real.log Lstar-(8*(n : ℝ)*Real.log (n : ℝ))/2) ≤ |
| 1/(n : ℝ)^(2*n) := by |
| let Cstar : ℝ := 16/(csec*κ) |
| have hstar : 0 < Cstar := div_pos (by norm_num) (mul_pos hcsec hκ) |
| have hprod : csec*κ*Cstar=16 := by dsimp [Cstar]; field_simp |
| refine ⟨Cstar,hstar,?_⟩ |
| filter_upwards [eventually_cap_eta (C := C) (H := Csec*Cstar) hC hk (mul_nonneg hCsec hstar.le), |
| eventually_discard_bound (C := C) (ε := 8) hC (by norm_num), |
| eventually_label_criterion hC hCs hCR, |
| eventually_pattern_cost (C := C) (Cs := Cs) (ε := 1) hC hCs (by norm_num), |
| eventually_dimension_small hC,eventually_ge_atTop (4 : ℕ)] with n hcap hdiscard hlabel hpat hdim hn |
| refine ⟨by omega,?_⟩ |
| intro D hD |
| have hDn := (hcap D hD).1 |
| have hm : (n : ℝ)/2 ≤ ((n-D : ℕ) : ℝ) := by rw [Nat.cast_sub hDn]; linarith [(hdim D hD).2] |
| have hmn : n-D ≤ n := Nat.sub_le _ _ |
| have hmh : (2 : ℝ) ≤ ((n-D : ℕ) : ℝ) := by |
| have hn4 : (4 : ℝ) ≤ n := by exact_mod_cast hn |
| linarith |
| refine ⟨hDn,by exact_mod_cast hmh,?_,?_,?_,?_⟩ |
| · convert (hcap D hD).2 using 1 ; ring |
| · have hh := hdiscard D (n-D) hD hmn |
| have he : csec*κ*(Cstar*(n : ℝ)*Real.log (n : ℝ))=16*(n : ℝ)*Real.log (n : ℝ) := by |
| calc |
| _ = (csec*κ*Cstar)*(n : ℝ)*Real.log (n : ℝ) := by ring |
| _ = _ := by rw [hprod] |
| rw [he]; linarith |
| · exact hlabel D (n-D) hD hm hmn |
| · intro α s A hs hA |
| have hQ : 0 ≤ (patternTotal A s D : ℝ) := Nat.cast_nonneg _ |
| refine ⟨by linarith,by linarith,?_⟩ |
| exact exp_error (by omega) (by simpa using hpat D hD s A hs hA) |
| |
| |
| end SingleLatticeCovering.FinalRates |
| |
| end |
| end |
| |
| section |
| |
| |
| |
| |
| namespace SingleLatticeCovering.Horizontal |
| open MeasureTheory Filter |
| open scoped BigOperators ENNReal |
| |
| |
| lemma finite_threshold_selection {X I : Type*} [MeasurableSpace X] |
| (μ : Measure X) [IsProbabilityMeasure μ] |
| (s : Finset I) (f : I → X → ℝ≥0∞) (t b : I → ℝ≥0∞) |
| (hf : ∀ i ∈ s, Measurable (f i)) |
| (ht0 : ∀ i ∈ s, t i ≠ 0) (htt : ∀ i ∈ s, t i ≠ ∞) |
| (hint : ∀ i ∈ s, ∫⁻ x, f i x ∂μ ≤ t i*b i) |
| (hsum : ∑ i ∈ s, b i < 1) : |
| ∃ x, ∀ i ∈ s, f i x ≤ t i := by |
| classical |
| let F : X → ℝ≥0∞ := fun x => ∑ i ∈ s, (t i)⁻¹*f i x |
| have hF : ∫⁻ x, F x ∂μ < 1 := by |
| dsimp [F] |
| rw [lintegral_finsetSum s (fun i hi => (hf i hi).const_mul _)] |
| apply lt_of_le_of_lt _ hsum |
| apply Finset.sum_le_sum |
| intro i hi |
| rw [lintegral_const_mul _ (hf i hi)] |
| calc |
| _ ≤ (t i)⁻¹*(t i*b i) := mul_le_mul' le_rfl (hint i hi) |
| _ = b i := by rw [←mul_assoc,ENNReal.inv_mul_cancel (ht0 i hi) (htt i hi),one_mul] |
| have hsome : ∃ x, F x < 1 := by |
| by_contra h |
| push Not at h |
| have hh : (1 : ℝ≥0∞) ≤ ∫⁻ x, F x ∂μ := by |
| simpa using lintegral_mono (μ := μ) (fun x => h x) |
| exact (not_le_of_gt hF) hh |
| obtain ⟨x,hx⟩ := hsome |
| refine ⟨x,fun i hi => ?_⟩ |
| have hix : (t i)⁻¹*f i x ≤ F x := by |
| exact Finset.single_le_sum (f := fun i => (t i)⁻¹*f i x) (fun j _ => bot_le) hi |
| have hmul : (t i)⁻¹*f i x ≤ 1 := hix.trans hx.le |
| have hm := mul_le_mul' (le_refl (t i)) hmul |
| simpa only [←mul_assoc,ENNReal.mul_inv_cancel (ht0 i hi) (htt i hi),one_mul,mul_one] using hm |
| |
| |
| |
| |
| lemma common_hole_sample {X I : Type*} [MeasurableSpace X] |
| (μ : Measure X) [IsProbabilityMeasure μ] (s : Finset I) |
| (hole : I → X → ℝ≥0∞) (u : I → ℝ) (C η : ℝ) (hC : 0 ≤ C) |
| (hhole : ∀ i ∈ s, Measurable (hole i)) |
| (hu : ∀ i ∈ s, u i ≤ η) |
| (hmean : ∀ i ∈ s, ∫⁻ x, hole i x ∂μ ≤ |
| ENNReal.ofReal (Real.exp (-u i)+C*Real.exp (-η))) |
| (hsum : (1+C)*(∑ i ∈ s, Real.exp (-u i/2)) < 1) : |
| ∃ x, ∀ i ∈ s, hole i x ≤ ENNReal.ofReal (Real.exp (-u i/2)) := by |
| apply finite_threshold_selection μ s hole |
| (fun i => ENNReal.ofReal (Real.exp (-u i/2))) |
| (fun i => ENNReal.ofReal ((1+C)*Real.exp (-u i/2))) hhole |
| (fun _ _ => (ENNReal.ofReal_pos.mpr (Real.exp_pos _)).ne') |
| (fun _ _ => ENNReal.ofReal_ne_top) |
| · intro i hi |
| apply (hmean i hi).trans |
| rw [←ENNReal.ofReal_mul (Real.exp_pos _).le] |
| apply ENNReal.ofReal_le_ofReal |
| have he : Real.exp (-η) ≤ Real.exp (-u i) := Real.exp_le_exp.mpr (neg_le_neg (hu i hi)) |
| have hsq : Real.exp (-u i/2)*Real.exp (-u i/2)=Real.exp (-u i) := by |
| rw [←Real.exp_add]; congr 1; ring |
| nlinarith [mul_le_mul_of_nonneg_left he hC] |
| · rw [←ENNReal.ofReal_sum_of_nonneg (fun i hi => mul_nonneg (by linarith) (Real.exp_pos _).le)] |
| rw [←Finset.mul_sum] |
| exact ENNReal.ofReal_lt_one.mpr hsum |
|
|
|
|
| end SingleLatticeCovering.Horizontal |
|
|
| end |
|
|
| section |
|
|
| noncomputable section |
|
|
| end |
| end |
| end |
|
|
| end OAI |
|
|
