File size: 8,268 Bytes
180bc03 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 | 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
|