| import OAI.NumberTheory.TwoPoint.Bounds.AffineTransfer |
| import OAI.NumberTheory.TwoPoint.Statements |
| import Mathlib.Analysis.SpecialFunctions.Pow.Asymptotics |
|
|
| namespace OAI |
|
|
| /-! Quantitative passage from all progression classes to the main |
| affine Liouville statement. The logarithmic exponent is preserved. -/ |
|
|
| namespace TwoPointCorrelations |
|
|
| open Finset Filter |
| open scoped Classical Topology |
|
|
| lemma progressionSum_eq_residuePrefix (f g : ℕ → ℂ) (h l b N : ℕ) : |
| progressionSum f g h l b N = |
| residuePrefix (fun n => f n * g (n + h)) l b N := by |
| have hs : Icc 1 N = Ioc 0 N := by |
| ext n |
| simp only [mem_Icc, mem_Ioc] |
| omega |
| simp only [progressionSum, residuePrefix, sum_filter, hs] |
|
|
| lemma liouville_affine_norm_le (a₁ a₂ b₁ b₂ N : ℕ) |
| (ha₁ : 0 < a₁) (ha₂ : 0 < a₂) : |
| ‖affineSum liouville liouville a₁ a₂ b₁ b₂ N‖ ≤ N := by |
| unfold affineSum |
| calc |
| _ ≤ ∑ n ∈ Icc 1 N, ‖liouville (a₁ * n + b₁) * liouville (a₂ * n + b₂)‖ := |
| norm_sum_le _ _ |
| _ ≤ ∑ _n ∈ Icc 1 N, (1 : ℝ) := by |
| apply sum_le_sum |
| intro n hn |
| have hnpos := (mem_Icc.mp hn).1 |
| rw [norm_mul] |
| exact (mul_le_of_le_one_left (norm_nonneg _) |
| (liouville_oneBounded _ (by nlinarith))).trans |
| (liouville_oneBounded _ (by nlinarith)) |
| _ = _ := by simp |
|
|
| lemma eventually_log_power_le_self (c : ℝ) : |
| ∀ᶠ X : ℝ in atTop, (Real.log X) ^ c ≤ X := by |
| have hb := (isLittleO_log_rpow_rpow_atTop c (show (0 : ℝ) < 1 by norm_num)).bound |
| (show (0 : ℝ) < 1 by norm_num) |
| filter_upwards [hb, eventually_ge_atTop (1 : ℝ)] with X hb hX |
| simpa only [Real.rpow_one, Real.norm_eq_abs, |
| abs_of_nonneg (Real.rpow_nonneg (Real.log_nonneg hX) _), |
| abs_of_nonneg (zero_le_one.trans hX), one_mul] using hb |
|
|
| lemma affine_cutoff_log_bound (c X : ℝ) (l b : ℕ) |
| (hc : 0 ≤ c) (hX : 4 ≤ X) (hl : 0 < l) : |
| ((l * ⌊X⌋₊ + b : ℕ) : ℝ) / |
| (Real.log ((l * ⌊X⌋₊ + b : ℕ) : ℝ)) ^ c ≤ |
| ((l + b : ℕ) : ℝ) * (2 : ℝ) ^ c * X / (Real.log X) ^ c := by |
| let Y : ℝ := (l * ⌊X⌋₊ + b : ℕ) |
| have hXp : 0 < X := by linarith |
| have hYlower : X / 2 ≤ Y := by |
| have hf := Nat.lt_floor_add_one X |
| have hl' : (1 : ℝ) ≤ l := by exact_mod_cast hl |
| have hn : (0 : ℝ) ≤ ⌊X⌋₊ := Nat.cast_nonneg _ |
| have hh : (⌊X⌋₊ : ℝ) ≤ Y := by |
| dsimp only [Y] |
| push_cast |
| nlinarith [show (0 : ℝ) ≤ b from Nat.cast_nonneg b] |
| linarith |
| have hYupper : Y ≤ ((l + b : ℕ) : ℝ) * X := by |
| have hf := Nat.floor_le hXp.le |
| have hXone : 1 ≤ X := by linarith |
| dsimp only [Y] |
| push_cast |
| nlinarith [show (0 : ℝ) ≤ l from Nat.cast_nonneg l, |
| show (0 : ℝ) ≤ b from Nat.cast_nonneg b] |
| have hlogX : 0 < Real.log X := Real.log_pos (by linarith) |
| have hlog4 : 2 * Real.log 2 ≤ Real.log X := by |
| have he : Real.log (4 : ℝ) = 2 * Real.log 2 := by |
| rw [show (4 : ℝ) = 2 * 2 by norm_num, Real.log_mul (by norm_num) (by norm_num)] |
| ring |
| rw [← he] |
| exact Real.log_le_log (by norm_num) hX |
| have hlogY : Real.log X / 2 ≤ Real.log Y := by |
| have hh := Real.log_le_log (by positivity : 0 < X / 2) hYlower |
| rw [Real.log_div hXp.ne' (by norm_num)] at hh |
| linarith |
| have hden : (Real.log X / 2) ^ c ≤ (Real.log Y) ^ c := |
| Real.rpow_le_rpow (by positivity) hlogY hc |
| change Y / (Real.log Y) ^ c ≤ _ |
| calc |
| _ ≤ (((l + b : ℕ) : ℝ) * X) / (Real.log X / 2) ^ c := |
| div_le_div₀ (by positivity) hYupper (Real.rpow_pos_of_pos (by positivity) _) hden |
| _ = _ := by |
| rw [Real.div_rpow hlogX.le (by norm_num)] |
| rw [div_div_eq_mul_div] |
| ring |
|
|
| lemma real_log_saving_extend (F : ℝ → ℂ) (c : ℝ) (hc : 0 < c) |
| (htrivial : ∀ X : ℝ, 3 ≤ X → ‖F X‖ ≤ X) |
| (hlarge : ∃ C : ℝ, 0 < C ∧ ∀ᶠ X : ℝ in atTop, |
| ‖F X‖ ≤ C * X / (Real.log X) ^ c) : |
| ∃ C : ℝ, 0 < C ∧ ∀ X : ℝ, 3 ≤ X → |
| ‖F X‖ ≤ C * X / (Real.log X) ^ c := by |
| obtain ⟨C, hC, hb⟩ := hlarge |
| obtain ⟨B, hB⟩ := eventually_atTop.1 hb |
| let Z : ℝ := max B 3 |
| let K : ℝ := C + (Real.log Z) ^ c + 1 |
| have hZ : 3 ≤ Z := le_max_right _ _ |
| have hlogZ : 0 < Real.log Z := Real.log_pos (by linarith) |
| have hK : 0 < K := by dsimp only [K]; positivity |
| refine ⟨K, hK, ?_⟩ |
| intro X hX |
| have hXp : 0 < X := by linarith |
| have hlogX : 0 < (Real.log X) ^ c := Real.rpow_pos_of_pos (Real.log_pos (by linarith)) _ |
| by_cases hx : Z ≤ X |
| · apply (hB X ((le_max_left _ _).trans hx)).trans |
| apply div_le_div_of_nonneg_right _ hlogX.le |
| have hCK : C ≤ K := by |
| dsimp only [K] |
| have hp := Real.rpow_nonneg hlogZ.le c |
| linarith |
| exact mul_le_mul_of_nonneg_right hCK hXp.le |
| · have hxl : (Real.log X) ^ c ≤ (Real.log Z) ^ c := |
| Real.rpow_le_rpow (Real.log_pos (by linarith)).le |
| (Real.log_le_log hXp (le_of_not_ge hx)) hc.le |
| apply (htrivial X hX).trans |
| apply (le_div_iff₀ hlogX).mpr |
| have hk : (Real.log X) ^ c ≤ K := by |
| dsimp only [K] |
| linarith |
| nlinarith |
|
|
| theorem liouvilleLogSaving_of_progression |
| (hprog : ∃ c : ℝ, 0 < c ∧ ∀ h l b : ℕ, 0 < h → 0 < l → |
| ∃ C : ℝ, 0 < C ∧ ∀ᶠ X : ℝ in atTop, |
| ‖progressionSum liouville liouville h l b ⌊X⌋₊‖ ≤ |
| C * X / (Real.log X) ^ c) : LiouvilleLogSaving := by |
| obtain ⟨c, hc, hprog⟩ := hprog |
| refine ⟨c, hc, ?_⟩ |
| intro a₁ a₂ b₁ b₂ ha₁ ha₂ hneq |
| let l := a₁ * a₂ |
| let b := min (a₂ * b₁) (a₁ * b₂) |
| let h := Nat.dist (a₁ * b₂) (a₂ * b₁) |
| have hl : 0 < l := Nat.mul_pos ha₁ ha₂ |
| have hh : 0 < h := Nat.dist_pos_of_ne hneq |
| obtain ⟨C, hC, hp⟩ := hprog h l b hh hl |
| let u : ℕ → ℂ := fun m => liouville m * liouville (m + h) |
| let d : ℝ := ‖residuePrefix u l b b‖ |
| have hd : 0 ≤ d := norm_nonneg _ |
| have hsample : Tendsto (fun X : ℝ => ((l * ⌊X⌋₊ + b : ℕ) : ℝ)) atTop atTop := by |
| apply tendsto_atTop.mpr |
| intro B |
| filter_upwards [(tendsto_nat_floor_atTop (α := ℝ)).eventually |
| (eventually_ge_atTop ⌈max B 0⌉₊)] with X hX |
| have hn : ⌊X⌋₊ ≤ l * ⌊X⌋₊ + b := by nlinarith |
| have hb : B ≤ (⌈max B 0⌉₊ : ℝ) := |
| (le_max_left _ _).trans (Nat.le_ceil _) |
| exact hb.trans (by exact_mod_cast hX.trans hn) |
| apply real_log_saving_extend _ c hc |
| (fun X hX => (liouville_affine_norm_le a₁ a₂ b₁ b₂ ⌊X⌋₊ ha₁ ha₂).trans |
| (Nat.floor_le (by linarith))) |
| refine ⟨C * ((l + b : ℕ) : ℝ) * (2 : ℝ) ^ c + d, by |
| have hlb : (0 : ℝ) < (l + b : ℕ) := by exact_mod_cast (by omega : 0 < l + b) |
| positivity, ?_⟩ |
| filter_upwards [hsample.eventually hp, eventually_log_power_le_self c, |
| eventually_ge_atTop (4 : ℝ)] with X hp hlog hX |
| have hY := affine_cutoff_log_bound c X l b hc.le hX hl |
| have hXp : 0 < X := by linarith |
| have hden : 0 < (Real.log X) ^ c := Real.rpow_pos_of_pos (Real.log_pos (by linarith)) _ |
| have hboundary : d ≤ d * (X / (Real.log X) ^ c) := by |
| have hr : 1 ≤ X / (Real.log X) ^ c := (one_le_div hden).mpr hlog |
| simpa only [mul_one] using mul_le_mul_of_nonneg_left hr hd |
| have hprefix : ‖residuePrefix u l b (l * ⌊X⌋₊ + b)‖ ≤ |
| C * ((l * ⌊X⌋₊ + b : ℕ) : ℝ) / |
| (Real.log ((l * ⌊X⌋₊ + b : ℕ) : ℝ)) ^ c := by |
| simpa only [Nat.floor_natCast, progressionSum_eq_residuePrefix, u] using hp |
| rw [liouville_affine_sum_endpoints_all a₁ a₂ b₁ b₂ ⌊X⌋₊ ha₁ ha₂] |
| change ‖liouville l * (residuePrefix u l b (l * ⌊X⌋₊ + b) - |
| residuePrefix u l b b)‖ ≤ _ |
| calc |
| _ ≤ ‖residuePrefix u l b (l * ⌊X⌋₊ + b) - residuePrefix u l b b‖ := |
| (norm_mul_le _ _).trans (by |
| exact mul_le_of_le_one_left (norm_nonneg _) (liouville_oneBounded l hl)) |
| _ ≤ ‖residuePrefix u l b (l * ⌊X⌋₊ + b)‖ + d := norm_sub_le _ _ |
| _ ≤ C * (((l + b : ℕ) : ℝ) * (2 : ℝ) ^ c * X / (Real.log X) ^ c) + |
| d * (X / (Real.log X) ^ c) := |
| add_le_add (hprefix.trans (by |
| rw [mul_div_assoc] |
| exact mul_le_mul_of_nonneg_left hY hC.le)) hboundary |
| _ = _ := by ring |
|
|
| end TwoPointCorrelations |
|
|
| end OAI |
|
|
