LiCircleBound.lean
3929 lines · 65 declarations · 0 sorries · updated 08-24-2026
Declarations
| Kind | Name | Line |
|---|---|---|
| lemma | isNontrivialZero_conj | 38 |
| def | A0count | 50 |
| lemma | A0count_ge_one | 52 |
| lemma | A0count_pos | 55 |
| lemma | Ncount_window_le | 58 |
| lemma | Ncount_add_of_le | 64 |
| lemma | Ncount_chain_le | 89 |
| lemma | Ncount_le_of_interval | 152 |
| def | dirichletC2 | 203 |
| lemma | norm_logDeriv_zeta_le_dirichlet | 208 |
| lemma | dirichletC2_nonneg | 241 |
| lemma | tsum_split_finset | 249 |
| lemma | Ncount_le_of_interval_gen | 273 |
| def | lowZeros | 328 |
| def | lowZeroConst | 335 |
| lemma | lowZeroConst_nonneg | 338 |
| lemma | tsum_dyadic_log | 346 |
| lemma | log_two_le_one | 369 |
| lemma | dyadic_tail_constant | 376 |
| def | dyadClass | 401 |
| lemma | dyadClass_lower | 404 |
| lemma | dyadClass_upper | 422 |
| def | tailTerm | 438 |
| lemma | tailTerm_nonneg | 441 |
| lemma | tailTerm_summable | 449 |
| lemma | dyadicLog_summable | 491 |
| lemma | dyadClass_fiber_finite | 506 |
| lemma | fiber_mult_count | 524 |
| lemma | fiber_tail_le | 659 |
| theorem | zero_tail_inv_sq_le | 745 |
| theorem | gapCircle_threshold | 878 |
| lemma | abs_im_ge_norm_sub_one | 1010 |
| theorem | not_isNontrivialZero_on_gapCircle | 1023 |
| lemma | seriesTerm_norm_eq_div | 1132 |
| def | circleZeros | 1152 |
| lemma | mem_circleZeros | 1155 |
| lemma | sum_zeroMult_le_of_im_band | 1162 |
| lemma | nine_le_log_of_16002_le | 1305 |
| lemma | series_tail_le | 1324 |
| lemma | seriesFun_norm_le_split | 1435 |
| lemma | half_le_log_two | 1461 |
| lemma | Nat.log_floor_two_le | 1474 |
| lemma | log_three_le_two_log | 1499 |
| lemma | dyadic_family_le | 1515 |
| lemma | shell_low | 1574 |
| lemma | two_pow_log_floor_le | 1658 |
| lemma | shell_inlo | 1674 |
| lemma | shell_inhi | 1909 |
| lemma | shell_up | 2195 |
| lemma | norm_circle_sub_abs_im_le | 2503 |
| lemma | shell_crit | 2529 |
| theorem | seriesFun_norm_le_gapCircle | 2738 |
| theorem | differentiableAt_Gammaℝ_of_not_neg_nat | 2894 |
| theorem | logDeriv_Gammaℝ_eq_of_not_neg_nat | 2910 |
| theorem | gapCircle_sep | 2964 |
| lemma | nearZeros_count_le | 3058 |
| theorem | gapCircle_sep_of_mem_nearZeros | 3087 |
| lemma | digamma_right_le | 3126 |
| lemma | digamma_circle_le | 3170 |
| lemma | norm_one_div_le_of_norm_eq | 3307 |
| lemma | norm_one_div_sub_one_le_of_norm_eq | 3313 |
| lemma | log_pi_le_two | 3323 |
| lemma | norm_logPi_div_two_le | 3339 |
| theorem | logDeriv_circle_le | 3368 |
| theorem | Fexpr_circle_le | 3806 |
Source
/-
NguyenRH1/LiCircleBound.lean — tier ii′ sub-stage ii′-5e-v (D-068 §5):
the circle bound for the partial-fraction difference and the squeeze to
the capstone identity.
§0: conjugate symmetry of the nontrivial zeros (for the lower-half
circle arcs).
§1: the mult-weighted ordinate-window count bridges from Zeta23's RvM
local count (`zeta_local_zero_count`: Ncount(t, t+1] ≤ A₀·log(|t|+3)
with multiplicity, ALL t — no perimeter): `A0count` + the dyadic
interval count `Ncount_le_of_interval`.
§2: the Dirichlet bound `norm_logDeriv_zeta_le_dirichlet` (‖ζ′/ζ s‖ ≤
dirichletC2 for re s ≥ 2; −ζ′/ζ = LSeries Λ, termwise ≤ the s = 2
majorant) — the right near-axis arc input.
§3+: (this file, subsequent sub-stages) the series bound, the logDeriv
assembly, the Fexpr circle bound, the Schwarz squeeze, and the
capstone `partialFraction_identity`.
Archive references: D-068 §5, journal-029.
-/
import Mathlib
import Zeta23.RvM.LocalCount
import NguyenRH1.LiFEntire
import NguyenRH1.LiGapCircles
import NguyenRH1.LiDisc
import NguyenRH1.LiReflect
import NguyenRH1.LiDigammaLeft
open Zeta23 Complex Filter Topology
noncomputable section
namespace NguyenRH1
/-! ## 0. Conjugate symmetry -/
/-- The conjugate of a nontrivial zero is a nontrivial zero. -/
lemma isNontrivialZero_conj {ρ : ℂ} (hρ : IsNontrivialZero ρ) :
IsNontrivialZero ((starRingEnd ℂ) ρ) := by
refine ⟨?_, ?_, ?_⟩
· rw [_root_.riemannZeta_conj, hρ.1, map_zero]
· rw [Complex.conj_re]; exact hρ.2.1
· rw [Complex.conj_re]; exact hρ.2.2
/-! ## 1. The mult-weighted window count bridges -/
/-- The local-count constant: from Zeta23's RvM local count
(`zeta_local_zero_count`, [Tit86 Thm 9.2] — mult-weighted, two-sided,
all t, PROVED unconditionally in Zeta23). -/
def A0count : ℝ := Classical.choose Zeta23.RvM.zeta_local_zero_count
lemma A0count_ge_one : (1 : ℝ) ≤ A0count :=
(Classical.choose_spec Zeta23.RvM.zeta_local_zero_count).1
lemma A0count_pos : (0 : ℝ) < A0count := lt_of_lt_of_le one_pos A0count_ge_one
/-- The unit-window bound: Ncount(t, t+1] ≤ A₀·log(|t|+3). -/
lemma Ncount_window_le (t : ℝ) :
(Zeta23.Ncount t (t + 1) : ℝ) ≤ A0count * Real.log (|t| + 3) :=
(Classical.choose_spec Zeta23.RvM.zeta_local_zero_count).2 t
/-- Window additivity: Ncount(a, c] = Ncount(a, b] + Ncount(b, c] for
a ≤ b ≤ c (the disjoint union of the ordinate windows). -/
lemma Ncount_add_of_le {a b c : ℝ} (hab : a ≤ b) (hbc : b ≤ c) :
Zeta23.Ncount a c = Zeta23.Ncount a b + Zeta23.Ncount b c := by
have hunion : Zeta23.zerosIn a c = Zeta23.zerosIn a b ∪ Zeta23.zerosIn b c := by
ext ρ
constructor
· intro hρc
obtain ⟨hρ, ha, hc⟩ := hρc
rcases le_or_gt ρ.im b with h | h
· exact Set.mem_union_left _ ⟨hρ, ha, h⟩
· exact Set.mem_union_right _ ⟨hρ, h, hc⟩
· intro h
rcases h with hρb | hρc
· obtain ⟨hρ, ha, hb⟩ := hρb
exact ⟨hρ, ha, hb.trans hbc⟩
· obtain ⟨hρ, hb, hc⟩ := hρc
exact ⟨hρ, hab.trans_lt hb, hc⟩
have hdisj : Disjoint (Zeta23.zerosIn a b) (Zeta23.zerosIn b c) := by
rw [Set.disjoint_iff]
intro ρ ⟨h1, h2⟩
exact absurd (h1.2.2.trans_lt h2.2.1) (lt_irrefl ρ.im)
rw [Zeta23.Ncount, Zeta23.Ncount, Zeta23.Ncount, hunion]
exact_mod_cast finsum_mem_union hdisj (Zeta23.zerosIn_finite a b)
(Zeta23.zerosIn_finite b c)
/-- The N-step unit-window chain: Ncount(a, a+N] ≤ A₀·N·log(|a|+N+3). -/
lemma Ncount_chain_le (a : ℝ) (N : ℕ) :
(Zeta23.Ncount a (a + (N : ℝ)) : ℝ)
≤ A0count * (N : ℝ) * Real.log (|a| + (N : ℝ) + 3) := by
induction N with
| zero =>
simp only [Nat.cast_zero, add_zero]
have h0 : Zeta23.zerosIn a a = ∅ := by
ext ρ
constructor
· intro h
obtain ⟨-, h1, h2⟩ := h
exact absurd (h2.trans_lt h1) (lt_irrefl _)
· intro h
simp at h
have hz : Zeta23.Ncount a a = 0 := by
simp only [Zeta23.Ncount, h0, finsum_mem_empty]
rw [hz, Nat.cast_zero]
simp
| succ N ih =>
have hN0 : (0 : ℝ) ≤ (N : ℝ) := Nat.cast_nonneg N
have hsplit : Zeta23.Ncount a (a + (N : ℝ) + 1)
= Zeta23.Ncount a (a + (N : ℝ)) + Zeta23.Ncount (a + (N : ℝ)) (a + (N : ℝ) + 1) :=
Ncount_add_of_le (a := a) (b := a + (N : ℝ)) (c := a + (N : ℝ) + 1)
(by linarith) (by linarith)
have hcast : a + ((N + 1 : ℕ) : ℝ) = a + (N : ℝ) + 1 := by push_cast; ring
rw [hcast, hsplit]
have hwin := Ncount_window_le (a + (N : ℝ))
have hlog : Real.log (|a + (N : ℝ)| + 3) ≤ Real.log (|a| + (N : ℝ) + 3) := by
apply Real.log_le_log (by positivity)
have h1 : |a + (N : ℝ)| ≤ |a| + (N : ℝ) :=
(abs_add_le _ _).trans (by rw [abs_of_nonneg (show (0 : ℝ) ≤ (N : ℝ) from Nat.cast_nonneg N)])
linarith
have hlogpos : (0 : ℝ) ≤ Real.log (|a| + (N : ℝ) + 3) := by
apply Real.log_nonneg
have h1 : (1 : ℝ) ≤ |a| + 3 := by linarith [abs_nonneg a]
linarith [hN0]
have hlogpos' : (0 : ℝ) ≤ Real.log (|a| + ((N : ℝ) + 1) + 3) := by
apply Real.log_nonneg
have h1 : (1 : ℝ) ≤ |a| + 3 := by linarith [abs_nonneg a]
linarith [hN0]
push_cast
-- goal: ↑(Ncount a (a+↑N)) + ↑(Ncount (a+↑N) (a+↑N+1)) ≤ A₀(↑N+1)·log(|a|+(↑N+1)+3)
have hlogC : Real.log (|a| + (N : ℝ) + 3)
≤ Real.log (|a| + ((N : ℝ) + 1) + 3) :=
Real.log_le_log (by positivity) (by linarith)
have hle1 : A0count * (N : ℝ) * Real.log (|a| + (N : ℝ) + 3)
≤ A0count * (N : ℝ) * Real.log (|a| + ((N : ℝ) + 1) + 3) :=
mul_le_mul_of_nonneg_left hlogC (mul_nonneg A0count_pos.le hN0)
have hle2 : A0count * Real.log (|a + (N : ℝ)| + 3)
≤ A0count * Real.log (|a| + ((N : ℝ) + 1) + 3) := by
apply mul_le_mul_of_nonneg_left _ A0count_pos.le
apply Real.log_le_log (by positivity)
have h1 : |a + (N : ℝ)| ≤ |a| + (N : ℝ) :=
(abs_add_le _ _).trans (by rw [abs_of_nonneg (show (0 : ℝ) ≤ (N : ℝ) from Nat.cast_nonneg N)])
linarith
have hsum : ↑(Zeta23.Ncount a (a + (N : ℝ))) + ↑(Zeta23.Ncount (a + (N : ℝ)) (a + (N : ℝ) + 1))
≤ A0count * (N : ℝ) * Real.log (|a| + (N : ℝ) + 3)
+ A0count * Real.log (|a + (N : ℝ)| + 3) :=
add_le_add ih hwin
linarith [hsum, hle1, hle2]
/-- The dyadic-interval count: Ncount(a, b] ≤ A₀·(b−a+1)·log(b+4) for
0 ≤ a ≤ b (the unit-window chain + the ceil cover). -/
lemma Ncount_le_of_interval {a b : ℝ} (ha : 0 ≤ a) (hab : a ≤ b) :
(Zeta23.Ncount a b : ℝ) ≤ A0count * (b - a + 1) * Real.log (b + 4) := by
set N : ℕ := ⌈b - a⌉₊ with hN
have hNb : b ≤ a + (N : ℝ) := by
have h := Nat.le_ceil (b - a)
rw [← hN] at h
have h2 : (b - a : ℝ) ≤ (N : ℝ) := h
linarith
have hsub : Zeta23.zerosIn a b ⊆ Zeta23.zerosIn a (a + (N : ℝ)) := by
intro ρ hρ
refine ⟨hρ.1, hρ.2.1, ?_⟩
exact hρ.2.2.trans hNb
have hle : Zeta23.Ncount a b ≤ Zeta23.Ncount a (a + (N : ℝ)) := by
rw [Zeta23.Ncount, Zeta23.Ncount]
rw [finsum_mem_eq_finite_toFinset_sum _ (Zeta23.zerosIn_finite a b),
finsum_mem_eq_finite_toFinset_sum _ (Zeta23.zerosIn_finite a (a + (N : ℝ)))]
apply Finset.sum_le_sum_of_subset_of_nonneg
· intro ρ hρ
rw [Set.Finite.mem_toFinset] at hρ ⊢
exact hsub hρ
· intro ρ _ _
exact Nat.cast_nonneg _
have hchain := Ncount_chain_le a N
have hNle : (N : ℝ) ≤ b - a + 1 := by
have h := Nat.ceil_lt_add_one (sub_nonneg.mpr hab)
rw [← hN] at h
have h2 : ((N : ℝ)) < b - a + 1 := by exact_mod_cast h
linarith
have hlogle : Real.log (|a| + (N : ℝ) + 3) ≤ Real.log (b + 4) := by
apply Real.log_le_log (by positivity)
rw [abs_of_nonneg ha]
linarith
calc (Zeta23.Ncount a b : ℝ)
≤ (Zeta23.Ncount a (a + (N : ℝ)) : ℝ) := by exact_mod_cast hle
_ ≤ A0count * (N : ℝ) * Real.log (|a| + (N : ℝ) + 3) := hchain
_ ≤ A0count * (b - a + 1) * Real.log (b + 4) := by
have hlogpos : (0 : ℝ) ≤ Real.log (b + 4) := by
apply Real.log_nonneg; linarith
have h1 : A0count * (N : ℝ) * Real.log (|a| + (N : ℝ) + 3)
≤ A0count * (N : ℝ) * Real.log (b + 4) :=
mul_le_mul_of_nonneg_left hlogle (mul_nonneg A0count_pos.le (Nat.cast_nonneg N))
have h2 : A0count * (N : ℝ) * Real.log (b + 4)
≤ A0count * (b - a + 1) * Real.log (b + 4) := by
apply mul_le_mul_of_nonneg_right _ hlogpos
nlinarith [A0count_pos, hNle, sub_nonneg.mpr hab]
exact h1.trans h2
/-! ## 2. The Dirichlet bound -/
/-- The Dirichlet majorant constant: the absolute sum of the von
Mangoldt L-series terms at s = 2 (summable since 2 > 1). -/
def dirichletC2 : ℝ :=
∑' n : ℕ, ‖LSeries.term (fun n => (ArithmeticFunction.vonMangoldt n : ℂ)) (2 : ℂ) n‖
/-- ‖ζ′/ζ s‖ ≤ C₂ for re s ≥ 2 (the Dirichlet-series majorant:
−ζ′/ζ = LSeries Λ for re > 1, termwise ≤ the s = 2 sum). -/
lemma norm_logDeriv_zeta_le_dirichlet {s : ℂ} (hs : 2 ≤ s.re) :
‖logDeriv riemannZeta s‖ ≤ dirichletC2 := by
have hs1 : (1 : ℝ) < s.re := by linarith
have h1 : -logDeriv riemannZeta s
= LSeries (fun n => (ArithmeticFunction.vonMangoldt n : ℂ)) s := by
have h2 := ArithmeticFunction.LSeries_vonMangoldt_eq_deriv_riemannZeta_div hs1
rw [logDeriv, Pi.div_apply, h2]
ring
have hsum2 : Summable (fun n : ℕ =>
‖LSeries.term (fun n => (ArithmeticFunction.vonMangoldt n : ℂ)) (2 : ℂ) n‖) := by
rw [summable_norm_iff]
exact ArithmeticFunction.LSeriesSummable_vonMangoldt (by norm_num)
have hsumS : Summable (fun n : ℕ =>
‖LSeries.term (fun n => (ArithmeticFunction.vonMangoldt n : ℂ)) s n‖) := by
rw [summable_norm_iff]
exact ArithmeticFunction.LSeriesSummable_vonMangoldt hs1
have hle : ‖LSeries (fun n => (ArithmeticFunction.vonMangoldt n : ℂ)) s‖
≤ dirichletC2 := by
show ‖∑' n : ℕ, LSeries.term (fun n => (ArithmeticFunction.vonMangoldt n : ℂ)) s n‖ ≤ _
calc ‖∑' n : ℕ, LSeries.term (fun n => (ArithmeticFunction.vonMangoldt n : ℂ)) s n‖
≤ ∑' n : ℕ, ‖LSeries.term (fun n => (ArithmeticFunction.vonMangoldt n : ℂ)) s n‖ :=
norm_tsum_le_tsum_norm hsumS
_ ≤ ∑' n : ℕ, ‖LSeries.term (fun n => (ArithmeticFunction.vonMangoldt n : ℂ)) (2 : ℂ) n‖ :=
Summable.tsum_le_tsum (fun n => LSeries.norm_term_le_of_re_le_re _ (by
simp
exact hs) n) hsumS hsum2
_ = dirichletC2 := rfl
calc ‖logDeriv riemannZeta s‖
= ‖LSeries (fun n => (ArithmeticFunction.vonMangoldt n : ℂ)) s‖ := by
rw [← h1, norm_neg]
_ ≤ dirichletC2 := hle
/-- The Dirichlet majorant is nonnegative (a tsum of norms). -/
lemma dirichletC2_nonneg : (0 : ℝ) ≤ dirichletC2 :=
tsum_nonneg (fun _ => norm_nonneg _)
/-! ## 3. The tsum split + the generalized interval count + the low-zero
constant -/
/-- Splitting a summable real tsum over a finset:
∑' f = ∑_{i ∈ s} f i + ∑' (if i ∈ s then 0 else f i). -/
lemma tsum_split_finset {ι : Type*} [DecidableEq ι] {f : ι → ℝ} (hf : Summable f)
(s : Finset ι) :
∑' i, f i = ∑ i ∈ s, f i + ∑' i, (if i ∈ s then 0 else f i) := by
classical
have h1 : Summable (fun i => if i ∈ s then f i else 0) := by
apply Summable.of_norm_bounded hf.norm
intro i
by_cases hi : i ∈ s <;> simp [hi]
have h2 : Summable (fun i => if i ∈ s then 0 else f i) := by
apply Summable.of_norm_bounded hf.norm
intro i
by_cases hi : i ∈ s <;> simp [hi]
have h3 : ∑' i, f i
= ∑' i, ((if i ∈ s then f i else 0) + (if i ∈ s then 0 else f i)) := by
apply tsum_congr
intro i
by_cases hi : i ∈ s <;> simp [hi]
rw [h3, Summable.tsum_add h1 h2]
congr 1
rw [tsum_eq_sum (s := s) (fun b hb => if_neg hb)]
exact Finset.sum_congr rfl (fun b hb => if_pos hb)
/-- The generalized dyadic-interval count (both signs):
Ncount(a, b] ≤ A₀·(b−a+1)·log(3·max|a||b| + 5). -/
lemma Ncount_le_of_interval_gen {a b : ℝ} (hab : a ≤ b) :
(Zeta23.Ncount a b : ℝ)
≤ A0count * (b - a + 1) * Real.log (3 * max |a| |b| + 5) := by
set N : ℕ := ⌈b - a⌉₊ with hN
have hNb : b ≤ a + (N : ℝ) := by
have h := Nat.le_ceil (b - a)
rw [← hN] at h
linarith
have hsub : Zeta23.zerosIn a b ⊆ Zeta23.zerosIn a (a + (N : ℝ)) := by
intro ρ hρ
exact ⟨hρ.1, hρ.2.1, hρ.2.2.trans hNb⟩
have hle : Zeta23.Ncount a b ≤ Zeta23.Ncount a (a + (N : ℝ)) := by
rw [Zeta23.Ncount, Zeta23.Ncount]
rw [finsum_mem_eq_finite_toFinset_sum _ (Zeta23.zerosIn_finite a b),
finsum_mem_eq_finite_toFinset_sum _ (Zeta23.zerosIn_finite a (a + (N : ℝ)))]
apply Finset.sum_le_sum_of_subset_of_nonneg
· intro ρ hρ
rw [Set.Finite.mem_toFinset] at hρ ⊢
exact hsub hρ
· intro ρ _ _
exact Nat.cast_nonneg _
have hchain := Ncount_chain_le a N
have hNle : (N : ℝ) ≤ b - a + 1 := by
have h := Nat.ceil_lt_add_one (sub_nonneg.mpr hab)
rw [← hN] at h
have h2 : ((N : ℝ)) < b - a + 1 := by exact_mod_cast h
linarith
have hlogle : Real.log (|a| + (N : ℝ) + 3)
≤ Real.log (3 * max |a| |b| + 5) := by
apply Real.log_le_log (by positivity)
have hM1 : |a| ≤ max |a| |b| := le_max_left _ _
have hM2 : |b| ≤ max |a| |b| := le_max_right _ _
have hba : b - a ≤ |b| + |a| := by
have h1 := le_abs_self b
have h2 : -a ≤ |a| := by rw [← abs_neg a]; exact le_abs_self (-a)
linarith
nlinarith [hNle, hM1, hM2, hba, abs_nonneg a, abs_nonneg b]
have hlogpos : (0 : ℝ) ≤ Real.log (3 * max |a| |b| + 5) := by
apply Real.log_nonneg
have h1 : (0 : ℝ) ≤ max |a| |b| := le_trans (abs_nonneg a) (le_max_left _ _)
linarith
calc (Zeta23.Ncount a b : ℝ)
≤ (Zeta23.Ncount a (a + (N : ℝ)) : ℝ) := by exact_mod_cast hle
_ ≤ A0count * (N : ℝ) * Real.log (|a| + (N : ℝ) + 3) := hchain
_ ≤ A0count * (b - a + 1) * Real.log (3 * max |a| |b| + 5) := by
have h1 : A0count * (N : ℝ) * Real.log (|a| + (N : ℝ) + 3)
≤ A0count * (N : ℝ) * Real.log (3 * max |a| |b| + 5) :=
mul_le_mul_of_nonneg_left hlogle (mul_nonneg A0count_pos.le (Nat.cast_nonneg N))
have h2 : A0count * (N : ℝ) * Real.log (3 * max |a| |b| + 5)
≤ A0count * (b - a + 1) * Real.log (3 * max |a| |b| + 5) := by
apply mul_le_mul_of_nonneg_right _ hlogpos
nlinarith [A0count_pos, hNle, sub_nonneg.mpr hab]
exact h1.trans h2
/-- The low-zero finset: nontrivial zeros with ‖ρ‖ ≤ 3. -/
def lowZeros : Finset {ρ : ℂ // IsNontrivialZero ρ} :=
(show {ρ : {ρ // IsNontrivialZero ρ} | ‖(ρ : ℂ)‖ ≤ 3}.Finite from
(finite_subtype_norm_lt 4).subset
(fun ρ hρ => lt_of_le_of_lt (show ‖(ρ : ℂ)‖ ≤ 3 from hρ) (by norm_num))).toFinset
/-- The low-zero symbolic constant (a fixed finite sum of fixed positive
reals; ‖ρ‖ > 0 for nontrivial ρ since re ρ > 0). -/
def lowZeroConst : ℝ :=
∑ ρ ∈ lowZeros, (zeroMult (ρ : ℂ) : ℝ) * (1 + 1 / ‖(ρ : ℂ)‖)
lemma lowZeroConst_nonneg : 0 ≤ lowZeroConst :=
Finset.sum_nonneg fun _ρ _ => mul_nonneg (Nat.cast_nonneg _)
(add_nonneg one_pos.le (div_nonneg one_pos.le (norm_nonneg _)))
/-! ## 4. The far-tail bound -/
/-- The dyadic log series closed form:
∑' j, ((j+4)·log 2 + log X)/2^j = 10·log 2 + 2·log X. -/
lemma tsum_dyadic_log (X : ℝ) :
∑' j : ℕ, ((j + 4) * Real.log 2 + Real.log X) / (2 : ℝ) ^ j
= 10 * Real.log 2 + 2 * Real.log X := by
have hgeom2H : Summable (fun j : ℕ => ((1 : ℝ) / 2) ^ j) := summable_geometric_two
have hgeom2 : ∑' j : ℕ, ((1 : ℝ) / 2) ^ j = 2 := tsum_geometric_two
have hlinH := hasSum_coe_mul_geometric_of_norm_lt_one (r := (1 : ℝ) / 2) (by norm_num)
have hlin : ∑' j : ℕ, (j : ℝ) * ((1 : ℝ) / 2) ^ j = 2 := by
have h := hlinH.tsum_eq
norm_num at h
exact h
have hsplit : (fun j : ℕ => ((j + 4) * Real.log 2 + Real.log X) / (2 : ℝ) ^ j)
= fun j : ℕ => Real.log 2 * ((j : ℝ) * ((1 : ℝ) / 2) ^ j)
+ (4 * Real.log 2 + Real.log X) * ((1 : ℝ) / 2) ^ j := by
funext j
have hj : (2 : ℝ) ^ j ≠ 0 := pow_ne_zero _ two_ne_zero
rw [one_div_pow]
field_simp
ring
rw [hsplit, Summable.tsum_add (hlinH.summable.mul_left _) (hgeom2H.mul_left _)]
rw [tsum_mul_left, tsum_mul_left, hlin, hgeom2]
ring
/-- log 2 ≤ 1 (since 2 ≤ e). -/
lemma log_two_le_one : Real.log 2 ≤ 1 := by
rw [show (1 : ℝ) = Real.log (Real.exp 1) by rw [Real.log_exp]]
apply Real.log_le_log (by norm_num)
have h := Real.exp_one_gt_d9
linarith
/-- For X ≥ 200: (4A₀/X)·(10·log 2 + 2·log X) ≤ 16·A₀·log X / X. -/
lemma dyadic_tail_constant {X : ℝ} (hX : 200 ≤ X) :
(4 * A0count / X) * (10 * Real.log 2 + 2 * Real.log X)
≤ 16 * A0count * Real.log X / X := by
have hX0 : (0 : ℝ) < X := by linarith
have hlogX : 5 ≤ Real.log X := by
rw [show (5 : ℝ) = Real.log (Real.exp 5) by rw [Real.log_exp]]
apply Real.log_le_log (Real.exp_pos _)
have h1 : Real.exp 5 = (Real.exp 1) ^ 5 := by
rw [← Real.exp_nat_mul]
norm_num
have h2 := Real.exp_one_lt_d9.le
have h3 : (Real.exp 1) ^ 5 ≤ (2.7182818286 : ℝ) ^ 5 :=
pow_le_pow_left₀ (Real.exp_pos 1).le h2 5
have h4 : (2.7182818286 : ℝ) ^ 5 ≤ 200 := by norm_num
linarith [h1, h3, h4]
have hlog2 := log_two_le_one
have hA0 : (0 : ℝ) ≤ 4 * A0count / X :=
div_nonneg (mul_nonneg (by norm_num) A0count_pos.le) hX0.le
have h1 : 10 * Real.log 2 + 2 * Real.log X ≤ 4 * Real.log X := by linarith
calc (4 * A0count / X) * (10 * Real.log 2 + 2 * Real.log X)
≤ (4 * A0count / X) * (4 * Real.log X) := mul_le_mul_of_nonneg_left h1 hA0
_ = 16 * A0count * Real.log X / X := by ring
/-- The dyadic class of a zero relative to scale X:
Nat.log 2 ⌊|im ρ|/X⌋₊, so 2^j·X ≤ |im ρ| < 2^{j+1}·X when |im ρ| ≥ X. -/
def dyadClass (X : ℝ) (ρ : {ρ : ℂ // IsNontrivialZero ρ}) : ℕ :=
Nat.log 2 ⌊|(ρ : ℂ).im| / X⌋₊
lemma dyadClass_lower {X : ℝ} (hX : 0 < X) {ρ : {ρ : ℂ // IsNontrivialZero ρ}}
(hρ : X ≤ |(ρ : ℂ).im|) :
(2 : ℝ) ^ dyadClass X ρ * X ≤ |(ρ : ℂ).im| := by
have hfl : ⌊|(ρ : ℂ).im| / X⌋₊ ≠ 0 := by
rw [Ne, Nat.floor_eq_zero]
push Not
have h1 : (1 : ℝ) ≤ |(ρ : ℂ).im| / X := (le_div_iff₀ hX).mpr (by linarith)
linarith
have h2 := Nat.pow_log_le_self 2 hfl
have h3 : ((2 ^ dyadClass X ρ : ℕ) : ℝ) ≤ ⌊|(ρ : ℂ).im| / X⌋₊ := by exact_mod_cast h2
have h4 : (⌊|(ρ : ℂ).im| / X⌋₊ : ℝ) ≤ |(ρ : ℂ).im| / X := Nat.floor_le (by positivity)
have h5 : ((2 ^ dyadClass X ρ : ℕ) : ℝ) = (2 : ℝ) ^ dyadClass X ρ := by push_cast; ring
rw [h5] at h3
rw [le_div_iff₀ hX] at h4
have h6 : (2 : ℝ) ^ dyadClass X ρ * X ≤ ⌊|(ρ : ℂ).im| / X⌋₊ * X :=
mul_le_mul_of_nonneg_right h3 hX.le
linarith
lemma dyadClass_upper {X : ℝ} (hX : 0 < X) (ρ : {ρ : ℂ // IsNontrivialZero ρ}) :
|(ρ : ℂ).im| < (2 : ℝ) ^ (dyadClass X ρ + 1) * X := by
have h2 : ⌊|(ρ : ℂ).im| / X⌋₊ < 2 ^ (dyadClass X ρ + 1) :=
Nat.lt_pow_succ_log_self (by norm_num) _
have h3 : (⌊|(ρ : ℂ).im| / X⌋₊ : ℝ) + 1 ≤ (2 : ℝ) ^ (dyadClass X ρ + 1) := by
have h4 : ⌊|(ρ : ℂ).im| / X⌋₊ + 1 ≤ 2 ^ (dyadClass X ρ + 1) := h2
have h5 : ((⌊|(ρ : ℂ).im| / X⌋₊ + 1 : ℕ) : ℝ) ≤ ((2 ^ (dyadClass X ρ + 1) : ℕ) : ℝ) := by
exact_mod_cast h4
push_cast at h5
linarith
have h6 : |(ρ : ℂ).im| / X < (2 : ℝ) ^ (dyadClass X ρ + 1) :=
(Nat.lt_floor_add_one _).trans_le h3
rw [div_lt_iff₀ hX] at h6
linarith
/-- The tail summand (if-form on the zero subtype). -/
def tailTerm (X : ℝ) (ρ : {ρ : ℂ // IsNontrivialZero ρ}) : ℝ :=
if X < |(ρ : ℂ).im| then (zeroMult ρ : ℝ) / (1 + ((ρ : ℂ).im) ^ 2) else 0
lemma tailTerm_nonneg {X : ℝ} (ρ : {ρ : ℂ // IsNontrivialZero ρ}) :
0 ≤ tailTerm X ρ := by
by_cases h : X < |(ρ : ℂ).im| <;>
simp [tailTerm, h, div_nonneg (Nat.cast_nonneg _)
(by positivity : (0 : ℝ) ≤ 1 + ((ρ : ℂ).im) ^ 2)]
/-- The tail summand is summable (dominated by 2·m/(1+‖γ‖²) via
1 + ‖γ‖² ≤ 2(1 + im²)). -/
lemma tailTerm_summable (X : ℝ) :
Summable (tailTerm X) := by
have hbase : Summable (fun ρ : {ρ : ℂ // IsNontrivialZero ρ} =>
2 * ((zeroMult ρ : ℝ) / (1 + Complex.normSq (gammaOf (ρ : ℂ))))) :=
(WeilEF.zero_sum_inv_sq zetaSeam).mul_left 2
apply Summable.of_norm_bounded hbase
intro ρ
rw [tailTerm]
by_cases h : X < |(ρ : ℂ).im|
· rw [if_pos h]
have hgam : Complex.normSq (gammaOf (ρ : ℂ))
= (ρ : ℂ).im ^ 2 + (1 / 2 - (ρ : ℂ).re) ^ 2 := by
rw [Complex.normSq_apply, WeilEF.gammaOf_re, WeilEF.gammaOf_im]
ring
have hcmp : 1 + Complex.normSq (gammaOf (ρ : ℂ)) ≤ 2 * (1 + (ρ : ℂ).im ^ 2) := by
rw [hgam]
have hre : ((ρ : ℂ).re - 1 / 2) ^ 2 ≤ 1 / 4 := by
have h0 := ρ.2.2.1
have h1 := ρ.2.2.2
nlinarith [sq_nonneg ((ρ : ℂ).re - 1 / 2)]
nlinarith [sq_nonneg (ρ : ℂ).im]
have hpos1 : (0 : ℝ) < 1 + Complex.normSq (gammaOf (ρ : ℂ)) := by
have h := Complex.normSq_nonneg (gammaOf (ρ : ℂ)); linarith
have hpos2 : (0 : ℝ) < 1 + (ρ : ℂ).im ^ 2 := by positivity
have hfrac : 1 / (1 + (ρ : ℂ).im ^ 2) ≤ 2 / (1 + Complex.normSq (gammaOf (ρ : ℂ))) := by
rw [div_le_div_iff₀ hpos2 hpos1]
nlinarith [hcmp]
have hm : (0 : ℝ) ≤ (zeroMult ρ : ℝ) := Nat.cast_nonneg _
calc ‖(zeroMult ρ : ℝ) / (1 + (ρ : ℂ).im ^ 2)‖
= (zeroMult ρ : ℝ) / (1 + (ρ : ℂ).im ^ 2) := by
rw [Real.norm_eq_abs, abs_of_nonneg (div_nonneg (Nat.cast_nonneg _) hpos2.le)]
_ ≤ 2 * ((zeroMult ρ : ℝ) / (1 + Complex.normSq (gammaOf (ρ : ℂ)))) := by
rw [show (zeroMult ρ : ℝ) / (1 + (ρ : ℂ).im ^ 2)
= (zeroMult ρ : ℝ) * (1 / (1 + (ρ : ℂ).im ^ 2)) from by ring]
rw [show 2 * ((zeroMult ρ : ℝ) / (1 + Complex.normSq (gammaOf (ρ : ℂ))))
= (zeroMult ρ : ℝ) * (2 / (1 + Complex.normSq (gammaOf (ρ : ℂ)))) from by ring]
exact mul_le_mul_of_nonneg_left hfrac hm
· rw [if_neg h, norm_zero]
have hnn := Complex.normSq_nonneg (gammaOf (ρ : ℂ))
exact mul_nonneg (by norm_num) (div_nonneg (Nat.cast_nonneg _) (by linarith))
/-- The dyadic log series is summable. -/
lemma dyadicLog_summable (X : ℝ) :
Summable (fun j : ℕ => ((j + 4) * Real.log 2 + Real.log X) / (2 : ℝ) ^ j) := by
have hlinH := hasSum_coe_mul_geometric_of_norm_lt_one (r := (1 : ℝ) / 2) (by norm_num)
have hsplit : (fun j : ℕ => ((j + 4) * Real.log 2 + Real.log X) / (2 : ℝ) ^ j)
= fun j : ℕ => Real.log 2 * ((j : ℝ) * ((1 : ℝ) / 2) ^ j)
+ (4 * Real.log 2 + Real.log X) * ((1 : ℝ) / 2) ^ j := by
funext j
have hj : (2 : ℝ) ^ j ≠ 0 := pow_ne_zero _ two_ne_zero
rw [one_div_pow]
field_simp
ring
rw [hsplit]
exact (hlinH.summable.mul_left _).add (summable_geometric_two.mul_left _)
/-- The dyadic fiber {dyadClass X ρ = j} is finite. -/
lemma dyadClass_fiber_finite {X : ℝ} (hX : 0 < X) (j : ℕ) :
{ρ : {ρ // IsNontrivialZero ρ} | dyadClass X ρ = j}.Finite := by
apply (finite_subtype_norm_lt (1 + (2 : ℝ) ^ (j + 1) * X + 1)).subset
intro ρ hρ
have hρj : dyadClass X ρ = j := hρ
have hup := dyadClass_upper hX ρ
rw [hρj] at hup
have hnorm : ‖(ρ : ℂ)‖ ≤ |(ρ : ℂ).re| + |(ρ : ℂ).im| :=
Complex.norm_le_abs_re_add_abs_im _
have hre : |(ρ : ℂ).re| ≤ 1 := by
rw [abs_le]
exact ⟨by linarith [ρ.2.2.1], by linarith [ρ.2.2.2]⟩
have h2pow : (0 : ℝ) ≤ (2 : ℝ) ^ (j + 1) * X := by positivity
show ‖(ρ : ℂ)‖ < 1 + (2 : ℝ) ^ (j + 1) * X + 1
linarith
/-- The fiber count: the zeros in the dyadic fiber with X < |γ| have
multiplicity-sum ≤ A₀·(2^{j+1}X+3)·log(3·2^{j+1}X+5). -/
lemma fiber_mult_count {X : ℝ} (hX : 200 ≤ X) (j : ℕ) :
∑ ρ ∈ (Set.Finite.subset (dyadClass_fiber_finite (by linarith : (0 : ℝ) < X) j)
(t := {ρ : {ρ // IsNontrivialZero ρ} | dyadClass X ρ = j ∧ X < |(ρ : ℂ).im|})
(fun ρ hρ => hρ.1)).toFinset,
(zeroMult (ρ : ℂ) : ℝ)
≤ A0count * ((2 : ℝ) ^ (j + 1) * X + 3) * Real.log (3 * (2 : ℝ) ^ (j + 1) * X + 5) := by
classical
have hX0 : (0 : ℝ) < X := by linarith
have h2jX : (0 : ℝ) < (2 : ℝ) ^ j * X := by positivity
have h2j1X : (0 : ℝ) < (2 : ℝ) ^ (j + 1) * X := by positivity
set FS := (Set.Finite.subset (dyadClass_fiber_finite (by linarith : (0 : ℝ) < X) j)
(t := {ρ : {ρ // IsNontrivialZero ρ} | dyadClass X ρ = j ∧ X < |(ρ : ℂ).im|})
(fun ρ hρ => hρ.1)).toFinset with hFS
have hmemFS : ∀ ρ : {ρ : ℂ // IsNontrivialZero ρ},
ρ ∈ FS ↔ dyadClass X ρ = j ∧ X < |(ρ : ℂ).im| := by
intro ρ
rw [hFS, Set.Finite.mem_toFinset]
exact Iff.rfl
have hW1 : (Zeta23.zerosIn ((2 : ℝ) ^ j * X - 1) ((2 : ℝ) ^ (j + 1) * X)).Finite :=
Zeta23.zerosIn_finite _ _
have hW2 : (Zeta23.zerosIn (-((2 : ℝ) ^ (j + 1) * X)) (-((2 : ℝ) ^ j * X))).Finite :=
Zeta23.zerosIn_finite _ _
have himg : FS.image (Subtype.val) ⊆ hW1.toFinset ∪ hW2.toFinset := by
intro z hz
obtain ⟨ρ, hρ, rfl⟩ := Finset.mem_image.mp hz
rw [hmemFS] at hρ
obtain ⟨hρj, hgt⟩ := hρ
have hup : |(ρ : ℂ).im| < (2 : ℝ) ^ (j + 1) * X := by
have h := dyadClass_upper hX0 ρ
rw [hρj] at h
exact h
have hlo : (2 : ℝ) ^ j * X ≤ |(ρ : ℂ).im| := by
have h := dyadClass_lower hX0 (show X ≤ |(ρ : ℂ).im| from hgt.le)
rw [hρj] at h
exact h
rcases le_or_gt 0 (ρ : ℂ).im with him | him
· apply Finset.mem_union_left
rw [Set.Finite.mem_toFinset]
refine ⟨ρ.2, ?_, ?_⟩
· rw [abs_of_nonneg him] at hlo
linarith
· rw [abs_of_nonneg him] at hup
linarith
· apply Finset.mem_union_right
rw [Set.Finite.mem_toFinset]
refine ⟨ρ.2, ?_, ?_⟩
· rw [abs_of_neg him] at hup
linarith
· rw [abs_of_neg him] at hlo
linarith
have hsum_img : ∑ ρ ∈ FS, (zeroMult (ρ : ℂ) : ℝ)
= ∑ z ∈ FS.image (Subtype.val), (zeroMult z : ℝ) := by
rw [Finset.sum_image (fun x _ y _ h => Subtype.val_injective h)]
have hdisj : Disjoint hW1.toFinset hW2.toFinset := by
rw [Finset.disjoint_left]
intro z hz1 hz2
rw [Set.Finite.mem_toFinset] at hz1 hz2
have h1 : (2 : ℝ) ^ j * X - 1 < z.im := hz1.2.1
have h2 : z.im ≤ -((2 : ℝ) ^ j * X) := hz2.2.2
have hge : (1 : ℝ) ≤ (2 : ℝ) ^ j * X := by
have h1le : (1 : ℝ) ≤ (2 : ℝ) ^ j := by exact_mod_cast Nat.one_le_two_pow
nlinarith [h1le, hX]
linarith
calc ∑ ρ ∈ FS, (zeroMult (ρ : ℂ) : ℝ)
= ∑ z ∈ FS.image (Subtype.val), (zeroMult z : ℝ) := hsum_img
_ ≤ ∑ z ∈ hW1.toFinset ∪ hW2.toFinset, (zeroMult z : ℝ) :=
Finset.sum_le_sum_of_subset_of_nonneg himg (fun z _ _ => Nat.cast_nonneg _)
_ = ∑ z ∈ hW1.toFinset, (zeroMult z : ℝ) + ∑ z ∈ hW2.toFinset, (zeroMult z : ℝ) :=
Finset.sum_union hdisj
_ = (Zeta23.Ncount ((2 : ℝ) ^ j * X - 1) ((2 : ℝ) ^ (j + 1) * X) : ℝ)
+ (Zeta23.Ncount (-((2 : ℝ) ^ (j + 1) * X)) (-((2 : ℝ) ^ j * X)) : ℝ) := by
rw [Zeta23.Ncount, Zeta23.Ncount, finsum_mem_eq_finite_toFinset_sum _ hW1,
finsum_mem_eq_finite_toFinset_sum _ hW2, Nat.cast_sum, Nat.cast_sum]
_ ≤ A0count * ((2 : ℝ) ^ (j + 1) * X + 3) * Real.log (3 * (2 : ℝ) ^ (j + 1) * X + 5) := by
have h2jX1 : (1 : ℝ) ≤ (2 : ℝ) ^ j * X := by
have h1 : (1 : ℝ) ≤ (2 : ℝ) ^ j := by exact_mod_cast Nat.one_le_two_pow
nlinarith [h1, hX]
have hpowX : (2 : ℝ) ^ (j + 1) * X = 2 * ((2 : ℝ) ^ j * X) := by
rw [pow_succ']; ring
have hlogpos : (0 : ℝ) ≤ Real.log (3 * (2 : ℝ) ^ (j + 1) * X + 5) := by
apply Real.log_nonneg
linarith [h2j1X]
have h1 := Ncount_le_of_interval_gen (a := (2 : ℝ) ^ j * X - 1)
(b := (2 : ℝ) ^ (j + 1) * X) (by linarith [hpowX, h2jX1])
have h2 := Ncount_le_of_interval_gen (a := -((2 : ℝ) ^ (j + 1) * X))
(b := -((2 : ℝ) ^ j * X)) (by linarith [hpowX, h2jX1])
-- the log arguments match L = log(3·2^{j+1}X + 5)
have hlog1 : Real.log (3 * max |(2 : ℝ) ^ j * X - 1| |(2 : ℝ) ^ (j + 1) * X| + 5)
≤ Real.log (3 * (2 : ℝ) ^ (j + 1) * X + 5) := by
apply Real.log_le_log (by positivity)
have hmax : max |(2 : ℝ) ^ j * X - 1| |(2 : ℝ) ^ (j + 1) * X|
≤ (2 : ℝ) ^ (j + 1) * X := by
apply max_le
· rw [abs_of_nonneg (by linarith [h2jX1])]
nlinarith [h2jX, h2j1X]
· rw [abs_of_nonneg h2j1X.le]
linarith [hmax]
have hlog2 : Real.log (3 * max |-((2 : ℝ) ^ (j + 1) * X)| |-((2 : ℝ) ^ j * X)| + 5)
≤ Real.log (3 * (2 : ℝ) ^ (j + 1) * X + 5) := by
apply Real.log_le_log (by positivity)
have hmax : max |-((2 : ℝ) ^ (j + 1) * X)| |-((2 : ℝ) ^ j * X)|
≤ (2 : ℝ) ^ (j + 1) * X := by
apply max_le
· rw [abs_neg, abs_of_nonneg h2j1X.le]
· rw [abs_neg, abs_of_nonneg h2jX.le]
nlinarith [h2jX, h2j1X]
linarith [hmax]
-- the lengths: b−a+1 = 2^jX + 2 and 2^jX + 1
have hlen1 : (2 : ℝ) ^ (j + 1) * X - ((2 : ℝ) ^ j * X - 1) + 1
= (2 : ℝ) ^ j * X + 2 := by
have hpow : (2 : ℝ) ^ (j + 1) = 2 * (2 : ℝ) ^ j := by rw [pow_succ']
rw [hpow]
ring
have hlen2 : -((2 : ℝ) ^ j * X) - (-((2 : ℝ) ^ (j + 1) * X)) + 1
= (2 : ℝ) ^ j * X + 1 := by
have hpow : (2 : ℝ) ^ (j + 1) = 2 * (2 : ℝ) ^ j := by rw [pow_succ']
rw [hpow]
ring
rw [hlen1] at h1
rw [hlen2] at h2
-- assemble: A₀(2^jX+2)L + A₀(2^jX+1)L = A₀(2^{j+1}X+3)L
have hA0 := A0count_pos.le
have h1' : (Zeta23.Ncount ((2 : ℝ) ^ j * X - 1) ((2 : ℝ) ^ (j + 1) * X) : ℝ)
≤ A0count * ((2 : ℝ) ^ j * X + 2) * Real.log (3 * (2 : ℝ) ^ (j + 1) * X + 5) :=
h1.trans (mul_le_mul_of_nonneg_left hlog1 (by positivity))
have h2' : (Zeta23.Ncount (-((2 : ℝ) ^ (j + 1) * X)) (-((2 : ℝ) ^ j * X)) : ℝ)
≤ A0count * ((2 : ℝ) ^ j * X + 1) * Real.log (3 * (2 : ℝ) ^ (j + 1) * X + 5) :=
h2.trans (mul_le_mul_of_nonneg_left hlog2 (by positivity))
have hpow : (2 : ℝ) ^ (j + 1) * X = 2 * ((2 : ℝ) ^ j * X) := by rw [pow_succ']; ring
rw [hpow] at h1' h2' ⊢
linarith [h1', h2', hA0, hlogpos]
/-- The per-fiber tail bound (in ℝ≥0∞): the sum of ofReal(tailTerm X)
over the dyadic fiber (dyadClass X)⁻¹'{j} is at most ofReal of
(1/(2^j X)²)·A₀·(2^{j+1}X+3)·log(3·2^{j+1}X+5). -/
lemma fiber_tail_le {X : ℝ} (hX : 200 ≤ X) (j : ℕ) :
∑' b : (dyadClass X) ⁻¹' {j}, ENNReal.ofReal (tailTerm X b.1)
≤ ENNReal.ofReal ((1 / ((2 : ℝ) ^ j * X) ^ 2) *
(A0count * ((2 : ℝ) ^ (j + 1) * X + 3)
* Real.log (3 * (2 : ℝ) ^ (j + 1) * X + 5))) := by
classical
have hX0 : (0 : ℝ) < X := by linarith
have hfin : ((dyadClass X) ⁻¹' {j} : Set {ρ : ℂ // IsNontrivialZero ρ}).Finite := by
have h := dyadClass_fiber_finite hX0 j
have h2 : ((dyadClass X) ⁻¹' {j} : Set {ρ : ℂ // IsNontrivialZero ρ})
= {ρ : {ρ // IsNontrivialZero ρ} | dyadClass X ρ = j} := by
ext ρ
exact Iff.rfl
rw [h2]
exact h
have htsum : ∑' b : (dyadClass X) ⁻¹' {j}, ENNReal.ofReal (tailTerm X b.1)
= ∑' ρ : {ρ : ℂ // IsNontrivialZero ρ},
((dyadClass X) ⁻¹' {j}).indicator (fun ρ => ENNReal.ofReal (tailTerm X ρ)) ρ :=
tsum_subtype ((dyadClass X) ⁻¹' {j})
(fun ρ : {ρ : ℂ // IsNontrivialZero ρ} => ENNReal.ofReal (tailTerm X ρ))
rw [htsum]
rw [tsum_eq_sum (s := hfin.toFinset) (fun ρ hρ => by
apply Set.indicator_of_notMem
rwa [Set.Finite.mem_toFinset] at hρ)]
rw [Finset.sum_congr rfl (fun ρ hρ =>
Set.indicator_of_mem (by rwa [Set.Finite.mem_toFinset] at hρ) _)]
rw [← ENNReal.ofReal_sum_of_nonneg (fun ρ _ => tailTerm_nonneg ρ)]
apply ENNReal.ofReal_le_ofReal
rw [← Finset.sum_filter_add_sum_filter_not hfin.toFinset
(fun ρ : {ρ : ℂ // IsNontrivialZero ρ} => X < |(ρ : ℂ).im|) (tailTerm X)]
have hzero : ∑ ρ ∈ hfin.toFinset.filter (fun ρ : {ρ : ℂ // IsNontrivialZero ρ} => ¬ X < |(ρ : ℂ).im|), tailTerm X ρ = 0 := by
apply Finset.sum_eq_zero
intro ρ hρ
rw [Finset.mem_filter] at hρ
rw [tailTerm, if_neg hρ.2]
rw [hzero, add_zero]
have hfilter_eq : hfin.toFinset.filter (fun ρ : {ρ : ℂ // IsNontrivialZero ρ} => X < |(ρ : ℂ).im|)
= (Set.Finite.subset (dyadClass_fiber_finite hX0 j)
(t := {ρ : {ρ // IsNontrivialZero ρ} | dyadClass X ρ = j ∧ X < |(ρ : ℂ).im|})
(fun ρ hρ => hρ.1)).toFinset := by
ext ρ
simp only [Finset.mem_filter, Set.Finite.mem_toFinset]
exact Iff.rfl
rw [hfilter_eq]
calc ∑ ρ ∈ (Set.Finite.subset (dyadClass_fiber_finite hX0 j)
(t := {ρ : {ρ // IsNontrivialZero ρ} | dyadClass X ρ = j ∧ X < |(ρ : ℂ).im|})
(fun ρ hρ => hρ.1)).toFinset, tailTerm X ρ
≤ ∑ ρ ∈ (Set.Finite.subset (dyadClass_fiber_finite hX0 j)
(t := {ρ : {ρ // IsNontrivialZero ρ} | dyadClass X ρ = j ∧ X < |(ρ : ℂ).im|})
(fun ρ hρ => hρ.1)).toFinset,
(1 / ((2 : ℝ) ^ j * X) ^ 2) * (zeroMult (ρ : ℂ) : ℝ) := by
apply Finset.sum_le_sum
intro ρ hρ
rw [Set.Finite.mem_toFinset] at hρ
obtain ⟨hρj, hgt⟩ := hρ
have hlo : (2 : ℝ) ^ j * X ≤ |(ρ : ℂ).im| := by
have h := dyadClass_lower hX0 (show X ≤ |(ρ : ℂ).im| from hgt.le)
rw [hρj] at h
exact h
have hlo2 : ((2 : ℝ) ^ j * X) ^ 2 ≤ ((ρ : ℂ).im) ^ 2 := by
have h := pow_le_pow_left₀ (by positivity : (0 : ℝ) ≤ (2 : ℝ) ^ j * X) hlo 2
rwa [sq_abs] at h
have hsq : ((2 : ℝ) ^ j * X) ^ 2 ≤ 1 + ((ρ : ℂ).im) ^ 2 := by
linarith [hlo2, sq_nonneg (ρ : ℂ).im]
have hpos1 : (0 : ℝ) < 1 + ((ρ : ℂ).im) ^ 2 := by positivity
have hpos2 : (0 : ℝ) < ((2 : ℝ) ^ j * X) ^ 2 := by positivity
rw [tailTerm, if_pos hgt]
rw [show (zeroMult (ρ : ℂ) : ℝ) / (1 + ((ρ : ℂ).im) ^ 2)
= (zeroMult (ρ : ℂ) : ℝ) * (1 / (1 + ((ρ : ℂ).im) ^ 2)) from by ring]
rw [show (1 / ((2 : ℝ) ^ j * X) ^ 2) * (zeroMult (ρ : ℂ) : ℝ)
= (zeroMult (ρ : ℂ) : ℝ) * (1 / ((2 : ℝ) ^ j * X) ^ 2) from by ring]
apply mul_le_mul_of_nonneg_left _ (Nat.cast_nonneg _)
rw [div_le_div_iff₀ hpos1 hpos2]
nlinarith [hsq]
_ = (1 / ((2 : ℝ) ^ j * X) ^ 2) *
∑ ρ ∈ (Set.Finite.subset (dyadClass_fiber_finite hX0 j)
(t := {ρ : {ρ // IsNontrivialZero ρ} | dyadClass X ρ = j ∧ X < |(ρ : ℂ).im|})
(fun ρ hρ => hρ.1)).toFinset, (zeroMult (ρ : ℂ) : ℝ) := by
rw [Finset.mul_sum]
_ ≤ (1 / ((2 : ℝ) ^ j * X) ^ 2) *
(A0count * ((2 : ℝ) ^ (j + 1) * X + 3)
* Real.log (3 * (2 : ℝ) ^ (j + 1) * X + 5)) :=
mul_le_mul_of_nonneg_left (fiber_mult_count hX j) (by positivity)
/-- **The far-tail bound**: for X ≥ 200, the zeros with |γ| > X
contribute Σ m/(1+γ²) ≤ 16·A₀·log X / X. -/
theorem zero_tail_inv_sq_le {X : ℝ} (hX : 200 ≤ X) :
∑' ρ : {ρ : ℂ // IsNontrivialZero ρ}, tailTerm X ρ
≤ 16 * A0count * Real.log X / X := by
have hX0 : (0 : ℝ) < X := by linarith
have hlogXnn : (0 : ℝ) ≤ Real.log X := Real.log_nonneg (by linarith)
have hC0 : (0 : ℝ) ≤ 16 * A0count * Real.log X / X :=
div_nonneg (mul_nonneg (mul_nonneg (by norm_num) A0count_pos.le) hlogXnn) hX0.le
rw [← ENNReal.ofReal_le_ofReal_iff hC0]
rw [ENNReal.ofReal_tsum_of_nonneg (fun ρ => tailTerm_nonneg ρ) (tailTerm_summable X)]
rw [← ENNReal.tsum_fiberwise (fun ρ => ENNReal.ofReal (tailTerm X ρ)) (dyadClass X)]
-- the real dyadic majorant
set F : ℕ → ℝ := fun j => (1 / ((2 : ℝ) ^ j * X) ^ 2) *
(A0count * ((2 : ℝ) ^ (j + 1) * X + 3) * Real.log (3 * (2 : ℝ) ^ (j + 1) * X + 5)) with hFdef
set G : ℕ → ℝ := fun j => (((j : ℝ) + 4) * Real.log 2 + Real.log X) / (2 : ℝ) ^ j with hGdef
have hFnn : ∀ j : ℕ, 0 ≤ F j := by
intro j
rw [hFdef]
have hL : (0 : ℝ) ≤ Real.log (3 * (2 : ℝ) ^ (j + 1) * X + 5) := by
apply Real.log_nonneg
have h2j1X : (0 : ℝ) < (2 : ℝ) ^ (j + 1) * X := by positivity
linarith
have h2j1X : (0 : ℝ) ≤ (2 : ℝ) ^ (j + 1) * X := by positivity
exact mul_nonneg (div_nonneg (by norm_num) (by positivity))
(mul_nonneg (mul_nonneg A0count_pos.le (by linarith)) hL)
have hGnn : ∀ j : ℕ, 0 ≤ (4 * A0count / X) * G j := by
intro j
rw [hGdef]
have hlog2nn : (0 : ℝ) ≤ Real.log 2 := Real.log_nonneg (by norm_num)
have hjn : (0 : ℝ) ≤ (j : ℝ) := Nat.cast_nonneg j
have hGj : (0 : ℝ) ≤ (((j : ℝ) + 4) * Real.log 2 + Real.log X) :=
add_nonneg (mul_nonneg (by linarith) hlog2nn) hlogXnn
exact mul_nonneg (div_nonneg (mul_nonneg (by norm_num) A0count_pos.le) hX0.le)
(div_nonneg hGj (by positivity))
have hFle : ∀ j : ℕ, F j ≤ (4 * A0count / X) * G j := by
intro j
rw [hFdef, hGdef]
show (1 / ((2 : ℝ) ^ j * X) ^ 2)
* (A0count * ((2 : ℝ) ^ (j + 1) * X + 3) * Real.log (3 * (2 : ℝ) ^ (j + 1) * X + 5))
≤ (4 * A0count / X)
* ((((j : ℝ) + 4) * Real.log 2 + Real.log X) / (2 : ℝ) ^ j)
have h2jX1 : (1 : ℝ) ≤ (2 : ℝ) ^ j * X := by
have h1 : (1 : ℝ) ≤ (2 : ℝ) ^ j := by exact_mod_cast Nat.one_le_two_pow
nlinarith [h1, hX]
have h2jX : (0 : ℝ) < (2 : ℝ) ^ j * X := by positivity
have h2j1X : (0 : ℝ) < (2 : ℝ) ^ (j + 1) * X := by positivity
have h2j : (0 : ℝ) < (2 : ℝ) ^ j := by positivity
have hLnn : (0 : ℝ) ≤ Real.log (3 * (2 : ℝ) ^ (j + 1) * X + 5) := by
apply Real.log_nonneg
linarith
-- log(3·2^{j+1}X+5) ≤ (j+4)·log 2 + log X
have hlogle : Real.log (3 * (2 : ℝ) ^ (j + 1) * X + 5)
≤ ((j : ℝ) + 4) * Real.log 2 + Real.log X := by
have harg : 3 * (2 : ℝ) ^ (j + 1) * X + 5 ≤ (2 : ℝ) ^ (j + 4) * X := by
have hpow : (2 : ℝ) ^ (j + 4) = 16 * (2 : ℝ) ^ j := by
rw [show (2 : ℝ) ^ (j + 4) = (2 : ℝ) ^ j * (2 : ℝ) ^ 4 from by rw [← pow_add]]
ring_nf
rw [hpow]
have hpow2 : (2 : ℝ) ^ (j + 1) = 2 * (2 : ℝ) ^ j := by rw [pow_succ']
rw [hpow2]
nlinarith [h2jX1, h2jX]
have hlogeq : Real.log ((2 : ℝ) ^ (j + 4) * X)
= ((j : ℝ) + 4) * Real.log 2 + Real.log X := by
rw [Real.log_mul (by positivity : (2 : ℝ) ^ (j + 4) ≠ 0) (by linarith : X ≠ 0)]
rw [Real.log_pow]
push_cast
ring
rw [← hlogeq]
exact Real.log_le_log (by positivity) harg
-- the two factor bounds
have hfac1 : A0count * ((2 : ℝ) ^ (j + 1) * X + 3) / ((2 : ℝ) ^ j * X) ^ 2
≤ (4 * A0count) / (X * (2 : ℝ) ^ j) := by
rw [div_le_div_iff₀ (by positivity) (by positivity)]
have hpow : (2 : ℝ) ^ (j + 1) * X = 2 * ((2 : ℝ) ^ j * X) := by rw [pow_succ']; ring
have h2jX200 : (200 : ℝ) ≤ (2 : ℝ) ^ j * X := by
have h1p : (1 : ℝ) ≤ (2 : ℝ) ^ j := by exact_mod_cast Nat.one_le_two_pow
nlinarith [h1p, hX]
have hkey : A0count * ((2 : ℝ) ^ j * X) * 3
≤ A0count * ((2 : ℝ) ^ j * X) * (2 * ((2 : ℝ) ^ j * X)) := by
apply mul_le_mul_of_nonneg_left _ (mul_nonneg A0count_pos.le (by positivity))
linarith [h2jX200]
rw [hpow]
have hA0 := A0count_pos.le
nlinarith [hkey, h2jX, hA0]
have h1 : (1 / ((2 : ℝ) ^ j * X) ^ 2) *
(A0count * ((2 : ℝ) ^ (j + 1) * X + 3) * Real.log (3 * (2 : ℝ) ^ (j + 1) * X + 5))
= (A0count * ((2 : ℝ) ^ (j + 1) * X + 3) / ((2 : ℝ) ^ j * X) ^ 2)
* Real.log (3 * (2 : ℝ) ^ (j + 1) * X + 5) := by ring
rw [h1]
have h2 : (4 * A0count / X) * ((((j : ℝ) + 4) * Real.log 2 + Real.log X) / (2 : ℝ) ^ j)
= ((4 * A0count) / (X * (2 : ℝ) ^ j))
* (((j : ℝ) + 4) * Real.log 2 + Real.log X) := by
field_simp
rw [h2]
apply mul_le_mul hfac1 hlogle hLnn
apply div_nonneg _ (mul_nonneg hX0.le (by positivity))
exact mul_nonneg (by norm_num) A0count_pos.le
have hGsum : Summable (fun j : ℕ => (4 * A0count / X) * G j) :=
(dyadicLog_summable X).mul_left _
have hFsum : Summable F := by
apply Summable.of_norm_bounded hGsum
intro j
rw [Real.norm_eq_abs, abs_of_nonneg (hFnn j)]
exact hFle j
have hGtotal : ∑' j : ℕ, G j = 10 * Real.log 2 + 2 * Real.log X := tsum_dyadic_log X
have htotal : ∑' j : ℕ, F j ≤ 16 * A0count * Real.log X / X := by
calc ∑' j : ℕ, F j ≤ ∑' j : ℕ, (4 * A0count / X) * G j :=
Summable.tsum_le_tsum hFle hFsum hGsum
_ = (4 * A0count / X) * (10 * Real.log 2 + 2 * Real.log X) := by
rw [tsum_mul_left, hGtotal]
_ ≤ 16 * A0count * Real.log X / X := dyadic_tail_constant hX
calc ∑' j : ℕ, ∑' b : (dyadClass X) ⁻¹' {j}, ENNReal.ofReal (tailTerm X b.1)
≤ ∑' j : ℕ, ENNReal.ofReal (F j) := by
apply ENNReal.tsum_le_tsum
intro j
exact fiber_tail_le hX j
_ = ENNReal.ofReal (∑' j : ℕ, F j) := (ENNReal.ofReal_tsum_of_nonneg hFnn hFsum).symm
_ ≤ ENNReal.ofReal (16 * A0count * Real.log X / X) := ENNReal.ofReal_le_ofReal htotal
/-! ## 5. The threshold lemma and the zero-free circle (5e-v-b chunk 3a)
The γ-gap circle radius R ∈ [4k+5/2, 4k+3] with k ≥ 4000 satisfies
416·Ĉ₀(4k+9/2) ≤ 4k+5/2 ≤ R (`gapCircle_threshold`) — explicit
linear/rational arithmetic from the two exp facts 2.7¹⁰ ≥ 16006.5 and
2.72⁹ ≤ 16006.5 plus log x ≤ x−1. Consequences: 16·Ĉ₀ < R (the circle
carries NO nontrivial zero, `not_isNontrivialZero_on_gapCircle`) and
13/R ≤ 1/(32·Ĉ₀) (the critical-arc clearance, used in the shell bounds
of the next chunk). -/
/-- **The threshold lemma**: for k ≥ 4000, 416·Ĉ₀(4k+9/2) ≤ 4k+5/2.
Base bound Ĉ₀(16004.5) ≤ 9.3564 (log 16006.5 ≤ 10 via 2.7¹⁰ ≥ 16006.5;
log log ≤ log 10 ≤ 2.4 via e^{2.4} ≥ 10.2); increment
Ĉ₀(x) − Ĉ₀(16004.5) ≤ 0.532·(x−16004.5)/16006.5 via log(a/b) ≤ a/b − 1
(twice; log 16006.5 ≥ 9 via 2.72⁹ ≤ 16006.5). -/
theorem gapCircle_threshold {k : ℕ} (hk : 4000 ≤ k) :
416 * C0hat (4 * (k : ℝ) + 9 / 2) ≤ 4 * (k : ℝ) + 5 / 2 := by
have hk4 : (16000 : ℝ) ≤ 4 * (k : ℝ) := by
have hkR : (4000 : ℝ) ≤ (k : ℝ) := by exact_mod_cast hk
linarith
-- the exp facts
have he10 : (16006.5 : ℝ) ≤ Real.exp 10 := by
have h1 : Real.exp 10 = (Real.exp 1) ^ 10 := by
rw [← Real.exp_nat_mul]; norm_num
have h2 : (2.7 : ℝ) ≤ Real.exp 1 := by
have h := Real.exp_one_gt_d9; linarith
have h3 : (2.7 : ℝ) ^ 10 ≤ (Real.exp 1) ^ 10 :=
pow_le_pow_left₀ (by norm_num) h2 10
have h4 : (16006.5 : ℝ) ≤ (2.7 : ℝ) ^ 10 := by norm_num
linarith [h1, h3, h4]
have hL0up : Real.log (16006.5) ≤ 10 := by
rw [show (10 : ℝ) = Real.log (Real.exp 10) by rw [Real.log_exp]]
exact Real.log_le_log (by norm_num) he10
have he9 : Real.exp 9 ≤ (16006.5 : ℝ) := by
have h1 : Real.exp 9 = (Real.exp 1) ^ 9 := by
rw [← Real.exp_nat_mul]; norm_num
have h2 : Real.exp 1 ≤ (2.72 : ℝ) := by
have h := Real.exp_one_lt_d9.le; linarith
have h3 : (Real.exp 1) ^ 9 ≤ (2.72 : ℝ) ^ 9 :=
pow_le_pow_left₀ (Real.exp_pos 1).le h2 9
have h4 : (2.72 : ℝ) ^ 9 ≤ 16006.5 := by norm_num
linarith [h1, h3, h4]
have hL0lo : (9 : ℝ) ≤ Real.log (16006.5) := by
rw [show (9 : ℝ) = Real.log (Real.exp 9) by rw [Real.log_exp]]
exact Real.log_le_log (Real.exp_pos _) he9
have he2 : (2.7 : ℝ) ^ 2 ≤ Real.exp 2 := by
have h1 : Real.exp 2 = (Real.exp 1) ^ 2 := by
rw [← Real.exp_nat_mul]; norm_num
have h2 : (2.7 : ℝ) ≤ Real.exp 1 := by
have h := Real.exp_one_gt_d9; linarith
have h3 : (2.7 : ℝ) ^ 2 ≤ (Real.exp 1) ^ 2 :=
pow_le_pow_left₀ (by norm_num) h2 2
linarith [h1, h3]
have he04 : (1.4 : ℝ) ≤ Real.exp 0.4 := by
have h := Real.add_one_le_exp (0.4 : ℝ)
linarith
have he24 : (10 : ℝ) ≤ Real.exp 2.4 := by
have h1 : Real.exp 2.4 = Real.exp 2 * Real.exp 0.4 := by
rw [← Real.exp_add]; norm_num
have h2 : (10 : ℝ) ≤ (2.7 : ℝ) ^ 2 * 1.4 := by norm_num
have h3 : (2.7 : ℝ) ^ 2 * 1.4 ≤ Real.exp 2 * Real.exp 0.4 :=
mul_le_mul he2 he04 (by norm_num) (Real.exp_pos 2).le
linarith [h1, h3]
have hlog10 : Real.log 10 ≤ (2.4 : ℝ) := by
rw [show (2.4 : ℝ) = Real.log (Real.exp 2.4) by rw [Real.log_exp]]
exact Real.log_le_log (by norm_num) he24
have hLL0 : Real.log (Real.log (16006.5)) ≤ 2.4 :=
(Real.log_le_log (by linarith [hL0lo]) hL0up).trans hlog10
-- the increments, with x = 4k+9/2, x+2 = 4k+13/2 ≥ 16006.5
set y : ℝ := 4 * (k : ℝ) with hy
have hx2 : (16006.5 : ℝ) ≤ y + 13 / 2 := by linarith
have hΔdef : (y + 13 / 2) / 16006.5 - 1 = (y - 16000) / 16006.5 := by
field_simp
ring
have hinc0 : Real.log (y + 13 / 2) - Real.log (16006.5)
≤ (y - 16000) / 16006.5 := by
have hpos : (0 : ℝ) < (y + 13 / 2) / 16006.5 := by positivity
have h1 := Real.log_le_sub_one_of_pos hpos
have h2 : Real.log (y + 13 / 2)
= Real.log (16006.5) + Real.log ((y + 13 / 2) / 16006.5) := by
rw [← Real.log_mul (by norm_num : (16006.5 : ℝ) ≠ 0)
(by positivity : (y + 13 / 2) / 16006.5 ≠ 0)]
congr 1
field_simp
rw [hΔdef] at h1
linarith [h2, h1]
have hinc1 : Real.log (y + 13 / 2) ≤ 10 + (y - 16000) / 16006.5 := by
linarith [hinc0, hL0up]
have hLge : Real.log (16006.5) ≤ Real.log (y + 13 / 2) :=
Real.log_le_log (by norm_num) hx2
have hinc2 : Real.log (Real.log (y + 13 / 2))
≤ 2.4 + (Real.log (y + 13 / 2) - Real.log (16006.5)) / 9 := by
have hpos : (0 : ℝ) < Real.log (y + 13 / 2) / Real.log (16006.5) :=
div_pos (by linarith [hL0lo, hLge]) (by linarith [hL0lo])
have h1 := Real.log_le_sub_one_of_pos hpos
have h2 : Real.log (Real.log (y + 13 / 2))
= Real.log (Real.log (16006.5))
+ Real.log (Real.log (y + 13 / 2) / Real.log (16006.5)) := by
rw [← Real.log_mul (by linarith [hL0lo] : Real.log (16006.5) ≠ 0)
(by positivity : Real.log (y + 13 / 2) / Real.log (16006.5) ≠ 0)]
congr 1
field_simp
have h3 : Real.log (y + 13 / 2) / Real.log (16006.5) - 1
≤ (Real.log (y + 13 / 2) - Real.log (16006.5)) / 9 := by
have h4 : Real.log (y + 13 / 2) / Real.log (16006.5) - 1
= (Real.log (y + 13 / 2) - Real.log (16006.5))
/ Real.log (16006.5) := by
field_simp
rw [h4]
exact div_le_div_of_nonneg_left (by linarith [hLge]) (by norm_num)
hL0lo
linarith [h1, h2, h3, hLL0]
-- assemble: Ĉ₀(4k+9/2) ≤ 9.3564 + 0.532·(y−16000)/16006.5
unfold C0hat
have hΔnn : (0 : ℝ) ≤ (y - 16000) / 16006.5 := by positivity
have hΔle : (y - 16000) / 16006.5 ≤ (y - 16000) / 16000 :=
div_le_div_of_nonneg_left (by linarith) (by norm_num) (by norm_num)
have hC : 0.433 * Real.log (y + 9 / 2 + 2)
+ 0.886 * Real.log (Real.log (y + 9 / 2 + 2)) + 2.9
≤ 9.3564 + 0.532 * ((y - 16000) / 16006.5) := by
have harg : y + 9 / 2 + 2 = y + 13 / 2 := by ring
rw [harg]
linarith [hinc1, hinc2, hinc0, hΔnn]
have hC2 : 416 * (0.433 * Real.log (y + 9 / 2 + 2)
+ 0.886 * Real.log (Real.log (y + 9 / 2 + 2)) + 2.9)
≤ 416 * (9.3564 + 0.532 * ((y - 16000) / 16006.5)) :=
mul_le_mul_of_nonneg_left hC (by norm_num)
have hfin : 416 * (9.3564 + 0.532 * ((y - 16000) / 16006.5))
≤ y + 5 / 2 := by
have h1 : 416 * (9.3564 + 0.532 * ((y - 16000) / 16006.5))
≤ 416 * (9.3564 + 0.532 * ((y - 16000) / 16000)) := by
exact mul_le_mul_of_nonneg_left
(add_le_add (le_refl _)
(mul_le_mul_of_nonneg_left hΔle (by norm_num : (0 : ℝ) ≤ 0.532)))
(by norm_num : (0 : ℝ) ≤ 416)
have h2 : 416 * (9.3564 + 0.532 * ((y - 16000) / 16000))
= 3670.9504 + 0.013832 * y := by
field_simp
ring
rw [h2] at h1
linarith [hk4]
calc 416 * (0.433 * Real.log (y + 9 / 2 + 2)
+ 0.886 * Real.log (Real.log (y + 9 / 2 + 2)) + 2.9)
≤ 416 * (9.3564 + 0.532 * ((y - 16000) / 16006.5)) := hC2
_ ≤ y + 5 / 2 := hfin
/-- |im ρ| ≥ ‖ρ‖ − 1 for a nontrivial zero (‖ρ‖ ≤ |re| + |im| ≤ 1 + |im|). -/
lemma abs_im_ge_norm_sub_one (ρ : {ρ : ℂ // IsNontrivialZero ρ}) :
‖(ρ : ℂ)‖ - 1 ≤ |(ρ : ℂ).im| := by
have hnorm : ‖(ρ : ℂ)‖ ≤ |(ρ : ℂ).re| + |(ρ : ℂ).im| :=
Complex.norm_le_abs_re_add_abs_im _
have hre : |(ρ : ℂ).re| ≤ 1 := by
rw [abs_le]
exact ⟨by linarith [ρ.2.2.1], by linarith [ρ.2.2.2]⟩
linarith
/-- **The gap circle is zero-free**: for k ≥ 4000 and R with the
gap-circle properties, no point s with ‖s‖ = R is a nontrivial zero.
(A zero on the circle would have ordinate ±√(R²−re²) within 1/R of R,
below the γ-gap clearance 1/(16·Ĉ₀) since 16·Ĉ₀ < R by the threshold.) -/
theorem not_isNontrivialZero_on_gapCircle {k : ℕ} (hk : 4000 ≤ k)
{R : ℝ} (hRlo : 4 * (k : ℝ) + 5 / 2 ≤ R)
(hgap : ∀ ρ : ℂ, IsNontrivialZero ρ →
(1 / (16 * C0hat (4 * (k : ℝ) + 9 / 2))) ≤ |ρ.im - R| ∨
1 ≤ |ρ.im - R|)
{s : ℂ} (hs : ‖s‖ = R) : ¬ IsNontrivialZero s := by
intro hz
have hth := gapCircle_threshold hk
have hĈ2 : (2 : ℝ) ≤ C0hat (4 * (k : ℝ) + 9 / 2) := two_le_C0hat (by
have hkR : (1 : ℝ) ≤ (k : ℝ) := by exact_mod_cast (by omega : 1 ≤ k)
linarith)
have hR1 : (1 : ℝ) < R := by
have hkR : (1 : ℝ) ≤ (k : ℝ) := by exact_mod_cast (by omega : 1 ≤ k)
linarith [hRlo]
-- 16·Ĉ₀ < R
have h16 : 16 * C0hat (4 * (k : ℝ) + 9 / 2) < R := by
have h1 : 16 * C0hat (4 * (k : ℝ) + 9 / 2)
< 416 * C0hat (4 * (k : ℝ) + 9 / 2) := by
have hpos : (0 : ℝ) < C0hat (4 * (k : ℝ) + 9 / 2) := by linarith [hĈ2]
nlinarith [hpos]
linarith [hth, hRlo, h1]
-- the ordinate t = |im s| and its distance to R
have hnormSq : ‖s‖ ^ 2 = s.re ^ 2 + s.im ^ 2 := by
rw [← Complex.normSq_eq_norm_sq, Complex.normSq_apply]
ring
have hre2 : s.re ^ 2 ≤ 1 := by
have h0 := hz.2.1
have h1 := hz.2.2
nlinarith [sq_nonneg s.re]
have ht_le : |s.im| ≤ R := by
have h := abs_im_le_norm s
rw [hs] at h
exact h
have ht2 : |s.im| ^ 2 = R ^ 2 - s.re ^ 2 := by
have h1 : s.im ^ 2 = R ^ 2 - s.re ^ 2 := by
have h2 : s.re ^ 2 + s.im ^ 2 = R ^ 2 := by
rw [← hnormSq, hs]
linarith
rw [sq_abs]
linarith [h1]
-- R − |im s| = re²/(R+|im s|) ≤ 1/R
have hRt : R - |s.im| = s.re ^ 2 / (R + |s.im|) := by
have hne : R + |s.im| ≠ 0 := by positivity
field_simp
have h1 : (R - |s.im|) * (R + |s.im|) = R ^ 2 - |s.im| ^ 2 := by ring
rw [h1, ht2]
ring
have hRt_le : R - |s.im| ≤ 1 / R := by
rw [hRt]
have h1 : s.re ^ 2 / (R + |s.im|) ≤ s.re ^ 2 / R := by
apply div_le_div_of_nonneg_left (sq_nonneg _) (by linarith [hR1])
have h2 : (0 : ℝ) ≤ |s.im| := abs_nonneg _
linarith
have h3 : s.re ^ 2 / R ≤ 1 / R := by
apply div_le_div_of_nonneg_right _ (by linarith [hR1])
linarith [hre2]
exact h1.trans h3
-- the witness zero with positive ordinate
have hkR0 : (0 : ℝ) < R := by linarith [hR1]
set ρ' : ℂ := if 0 ≤ s.im then s else (starRingEnd ℂ) s with hρ'
have hρ'z : IsNontrivialZero ρ' := by
rw [hρ']
by_cases him : 0 ≤ s.im
· rw [if_pos him]; exact hz
· rw [if_neg him]; exact isNontrivialZero_conj hz
have hρ'im : ρ'.im = |s.im| := by
rw [hρ']
by_cases him : 0 ≤ s.im
· rw [if_pos him]; exact (abs_of_nonneg him).symm
· rw [if_neg him, Complex.conj_im]
exact (abs_of_neg (lt_of_not_ge him)).symm
-- |im ρ' − R| = R − |im s| ≤ 1/R < min 1 (1/(16Ĉ₀)): contradiction
have hgap' := hgap ρ' hρ'z
rw [hρ'im] at hgap'
have hle : (|s.im| : ℝ) - R ≤ 0 := by linarith [ht_le]
have hdist : |(|s.im| : ℝ) - R| = R - |s.im| := by
rw [abs_of_nonpos hle]
ring
rw [hdist] at hgap'
have hsmall : R - |s.im| < 1 / (16 * C0hat (4 * (k : ℝ) + 9 / 2)) := by
have hpos : (0 : ℝ) < 16 * C0hat (4 * (k : ℝ) + 9 / 2) := by
linarith [hĈ2]
have h1 : 1 / R < 1 / (16 * C0hat (4 * (k : ℝ) + 9 / 2)) :=
one_div_lt_one_div_of_lt hpos h16
linarith [hRt_le, h1]
have hsmall1 : R - |s.im| < 1 := by
have h1 : 1 / R < 1 := (div_lt_one (by linarith [hR1] : (0 : ℝ) < R)).mpr hR1
linarith [hRt_le, h1]
rcases hgap' with h | h
· linarith [h, hsmall]
· linarith [h, hsmall1]
/-! ## 6. The per-term norm identity, the count brick, and the tail
application (5e-v-b chunk 3b)
`seriesTerm_norm_eq_div`: on the zero-free circle (‖s‖ = R),
‖seriesTerm s ρ‖ = m·R/(‖ρ‖·‖s−ρ‖) (the key algebra
1/(s−ρ)+1/ρ = s/(ρ(s−ρ))). `circleZeros R`: the finite part
{‖ρ‖ < 2R+1}. `sum_zeroMult_le_of_im_band`: the reusable window-count
brick — a zero finset whose ordinates lie in the band [a, b] (with the
sign-separation c, max a c ≥ 1) has multiplicity-sum ≤
3·A₀·(b−a+2)·log(3·max|a||b|+5) (the two-window cover
(M−1, b] ∪ (−b−1, −M], M := max a c; the −1 paddings absorb the
non-strict band bounds; the negative window's log loses +1 via
3b+8 ≤ 2(3b+5)). `series_tail_le`: the far tail (‖ρ‖ ≥ 2R+1) ≤
91·A₀·log R via `seriesTerm_norm_le` + `zero_tail_inv_sq_le`.
`seriesFun_norm_le_split`: the ONE tsum split. -/
/-- The per-term norm identity on a zero-free circle. -/
lemma seriesTerm_norm_eq_div {s : ℂ} {R : ℝ} (hs : ‖s‖ = R)
(hsz : ¬ IsNontrivialZero s) (ρ : {ρ : ℂ // IsNontrivialZero ρ}) :
‖seriesTerm s ρ‖ =
(zeroMult (ρ : ℂ) : ℝ) * (R / (‖(ρ : ℂ)‖ * ‖s - (ρ : ℂ)‖)) := by
have h0 : (ρ : ℂ) ≠ 0 := by
intro h
have hre := ρ.2.2.1
rw [h] at hre
simp at hre
have h1 : s - (ρ : ℂ) ≠ 0 := by
intro h
apply hsz
have hs_eq : s = (ρ : ℂ) := by rw [← sub_eq_zero]; exact h
rw [hs_eq]
exact ρ.2
have halg := one_div_sub_add_one_div h0 h1
simp only [seriesTerm]
rw [halg, norm_mul, RCLike.norm_natCast, norm_div, norm_mul, hs]
/-- The finite-part finset for the circle split: {‖ρ‖ < 2R+1}. -/
def circleZeros (R : ℝ) : Finset {ρ : ℂ // IsNontrivialZero ρ} :=
(finite_subtype_norm_lt (2 * R + 1)).toFinset
lemma mem_circleZeros {R : ℝ} {ρ : {ρ : ℂ // IsNontrivialZero ρ}} :
ρ ∈ circleZeros R ↔ ‖(ρ : ℂ)‖ < 2 * R + 1 :=
Set.Finite.mem_toFinset _
/-- **The count brick**: a zero finset with ordinates in the band
[a, b] (sign-separated by c, 1 ≤ max a c ≤ b) has multiplicity-sum
≤ 3·A₀·(b−a+2)·log(3·max|a||b|+5). -/
lemma sum_zeroMult_le_of_im_band (FS : Finset {ρ : ℂ // IsNontrivialZero ρ})
{a b c : ℝ} (hM1 : (1 : ℝ) ≤ max a c) (hMb : max a c ≤ b)
(hsub : ∀ ρ ∈ FS, a ≤ |(ρ : ℂ).im| ∧ |(ρ : ℂ).im| ≤ b ∧ c ≤ |(ρ : ℂ).im|) :
∑ ρ ∈ FS, (zeroMult (ρ : ℂ) : ℝ)
≤ 3 * A0count * (b - a + 2) * Real.log (3 * max |a| |b| + 5) := by
classical
set M := max a c with hM
have hM1' : (1 : ℝ) ≤ M := hM1
have hMb' : M ≤ b := hMb
have hb1 : (1 : ℝ) ≤ b := le_trans hM1' hMb'
have hW1 : (Zeta23.zerosIn (M - 1) b).Finite := Zeta23.zerosIn_finite _ _
have hW2 : (Zeta23.zerosIn (-b - 1) (-M)).Finite := Zeta23.zerosIn_finite _ _
have himg : FS.image (Subtype.val) ⊆ hW1.toFinset ∪ hW2.toFinset := by
intro z hz
obtain ⟨ρ, hρ, rfl⟩ := Finset.mem_image.mp hz
have hbnd1 := (hsub ρ hρ).1
have hbnd2 := (hsub ρ hρ).2.1
have hbnd3 := (hsub ρ hρ).2.2
have hMle : M ≤ |(ρ : ℂ).im| := max_le_iff.mpr ⟨hbnd1, hbnd3⟩
rcases le_or_gt 0 (ρ : ℂ).im with him | him
· apply Finset.mem_union_left
rw [Set.Finite.mem_toFinset]
refine ⟨ρ.2, ?_, ?_⟩
· rw [abs_of_nonneg him] at hMle
linarith
· rw [abs_of_nonneg him] at hbnd2
exact hbnd2
· apply Finset.mem_union_right
rw [Set.Finite.mem_toFinset]
refine ⟨ρ.2, ?_, ?_⟩
· rw [abs_of_neg him] at hbnd2
linarith
· rw [abs_of_neg him] at hMle
linarith
have hdisj : Disjoint hW1.toFinset hW2.toFinset := by
rw [Finset.disjoint_left]
intro z hz1 hz2
rw [Set.Finite.mem_toFinset] at hz1 hz2
have h1 : M - 1 < z.im := hz1.2.1
have h2 : z.im ≤ -M := hz2.2.2
linarith [hM1']
have hbridge : ∑ ρ ∈ FS, (zeroMult (ρ : ℂ) : ℝ)
≤ (Zeta23.Ncount (M - 1) b : ℝ) + (Zeta23.Ncount (-b - 1) (-M) : ℝ) := by
have hsum_img : ∑ ρ ∈ FS, (zeroMult (ρ : ℂ) : ℝ)
= ∑ z ∈ FS.image (Subtype.val), (zeroMult z : ℝ) :=
(Finset.sum_image (f := fun z : ℂ => (zeroMult z : ℝ))
(fun x _ y _ h => Subtype.val_injective h)).symm
rw [hsum_img]
calc ∑ z ∈ FS.image (Subtype.val), (zeroMult z : ℝ)
≤ ∑ z ∈ hW1.toFinset ∪ hW2.toFinset, (zeroMult z : ℝ) :=
Finset.sum_le_sum_of_subset_of_nonneg himg (fun z _ _ => Nat.cast_nonneg _)
_ = ∑ z ∈ hW1.toFinset, (zeroMult z : ℝ)
+ ∑ z ∈ hW2.toFinset, (zeroMult z : ℝ) :=
Finset.sum_union hdisj
_ = (Zeta23.Ncount (M - 1) b : ℝ) + (Zeta23.Ncount (-b - 1) (-M) : ℝ) := by
rw [Zeta23.Ncount, Zeta23.Ncount, finsum_mem_eq_finite_toFinset_sum _ hW1,
finsum_mem_eq_finite_toFinset_sum _ hW2, Nat.cast_sum, Nat.cast_sum]
-- the log comparisons
have hLpos : (0 : ℝ) < 3 * max |a| |b| + 5 := by
have h1 : (0 : ℝ) ≤ max |a| |b| := le_trans (abs_nonneg a) (le_max_left _ _)
linarith
have hLnn : (0 : ℝ) ≤ Real.log (3 * max |a| |b| + 5) := by
apply Real.log_nonneg
have h1 : (0 : ℝ) ≤ max |a| |b| := le_trans (abs_nonneg a) (le_max_left _ _)
linarith
have hL1 : (1 : ℝ) ≤ Real.log (3 * max |a| |b| + 5) := by
have h1 : (5 : ℝ) ≤ 3 * max |a| |b| + 5 := by
have h2 : (0 : ℝ) ≤ max |a| |b| := le_trans (abs_nonneg a) (le_max_left _ _)
linarith
rw [Real.le_log_iff_exp_le hLpos]
have h2 : Real.exp 1 ≤ (5 : ℝ) := by
have h := Real.exp_one_lt_d9.le
linarith
linarith [h1, h2]
have hLog1 : Real.log (3 * max |M - 1| |b| + 5)
≤ Real.log (3 * max |a| |b| + 5) := by
apply Real.log_le_log (by positivity)
have h1 : |M - 1| ≤ max |a| |b| := by
have h2 : |M - 1| = M - 1 := abs_of_nonneg (by linarith [hM1'])
rw [h2]
have h3 : M - 1 ≤ |b| := by
have h4 : |b| = b := abs_of_nonneg (by linarith [hb1])
rw [h4]
linarith [hMb']
have h4 : |b| ≤ max |a| |b| := le_max_right _ _
linarith [h3, h4]
have h2 : |b| ≤ max |a| |b| := le_max_right _ _
have h3 := max_le h1 h2
linarith [h3]
have hLog2 : Real.log (3 * max |-b - 1| |-M| + 5)
≤ Real.log (3 * max |a| |b| + 5) + 1 := by
have h1 : |-b - 1| = b + 1 := by
rw [show -b - 1 = -(b + 1) by ring, abs_neg, abs_of_nonneg (by linarith [hb1])]
have h2 : |-M| = M := by
rw [abs_neg]
exact abs_of_nonneg (by linarith [hM1'] : (0 : ℝ) ≤ M)
have h3 : max |-b - 1| |-M| = b + 1 := by
rw [h1, h2]
exact max_eq_left (by linarith [hMb'])
rw [h3]
have h4 : 3 * (b + 1) + 5 ≤ 2 * (3 * max |a| |b| + 5) := by
have h6 : (b : ℝ) ≤ max |a| |b| :=
le_trans (le_abs_self b) (le_max_right _ _)
linarith [h6]
have h5 : Real.log (3 * (b + 1) + 5)
≤ Real.log (2 * (3 * max |a| |b| + 5)) :=
Real.log_le_log (by positivity) h4
have h6 : Real.log (2 * (3 * max |a| |b| + 5))
= Real.log 2 + Real.log (3 * max |a| |b| + 5) :=
Real.log_mul (by norm_num : (2 : ℝ) ≠ 0) (by linarith [hLpos])
have h7 := log_two_le_one
linarith [h5, h6, h7]
-- the two window counts
have hw1 : (Zeta23.Ncount (M - 1) b : ℝ)
≤ A0count * (b - M + 2) * Real.log (3 * max |a| |b| + 5) := by
have h1 := Ncount_le_of_interval_gen (a := M - 1) (b := b) (by linarith [hMb'])
have h2 : b - (M - 1) + 1 = b - M + 2 := by ring
rw [h2] at h1
exact h1.trans (mul_le_mul_of_nonneg_left hLog1
(mul_nonneg A0count_pos.le (by linarith [hMb'])))
have hw2 : (Zeta23.Ncount (-b - 1) (-M) : ℝ)
≤ A0count * (b - M + 2) * (Real.log (3 * max |a| |b| + 5) + 1) := by
have h1 := Ncount_le_of_interval_gen (a := -b - 1) (b := -M) (by linarith [hMb'])
have h2 : -M - (-b - 1) + 1 = b - M + 2 := by ring
rw [h2] at h1
exact h1.trans (mul_le_mul_of_nonneg_left hLog2
(mul_nonneg A0count_pos.le (by linarith [hMb'])))
have hMa : a ≤ M := le_max_left _ _
calc ∑ ρ ∈ FS, (zeroMult (ρ : ℂ) : ℝ)
≤ (Zeta23.Ncount (M - 1) b : ℝ) + (Zeta23.Ncount (-b - 1) (-M) : ℝ) := hbridge
_ ≤ A0count * (b - M + 2) * Real.log (3 * max |a| |b| + 5)
+ A0count * (b - M + 2) * (Real.log (3 * max |a| |b| + 5) + 1) :=
add_le_add hw1 hw2
_ = A0count * (b - M + 2) * (2 * Real.log (3 * max |a| |b| + 5) + 1) := by ring
_ ≤ A0count * (b - a + 2) * (3 * Real.log (3 * max |a| |b| + 5)) := by
apply mul_le_mul
· exact mul_le_mul_of_nonneg_left (by linarith [hMa]) A0count_pos.le
· linarith [hL1, hLnn]
· linarith [hL1, hLnn]
· exact mul_nonneg A0count_pos.le (by linarith [hMa, hMb'])
_ = 3 * A0count * (b - a + 2) * Real.log (3 * max |a| |b| + 5) := by ring
/-- 9 ≤ log R for R ≥ 16002 (e⁹ ≤ 2.72⁹ ≤ 16002). -/
lemma nine_le_log_of_16002_le {R : ℝ} (hR : (16002 : ℝ) ≤ R) :
(9 : ℝ) ≤ Real.log R := by
have he9 : Real.exp 9 ≤ (16002 : ℝ) := by
have h1 : Real.exp 9 = (Real.exp 1) ^ 9 := by
rw [← Real.exp_nat_mul]; norm_num
have h2 : Real.exp 1 ≤ (2.72 : ℝ) := by
have h := Real.exp_one_lt_d9.le
linarith
have h3 : (Real.exp 1) ^ 9 ≤ (2.72 : ℝ) ^ 9 :=
pow_le_pow_left₀ (Real.exp_pos 1).le h2 9
have h4 : (2.72 : ℝ) ^ 9 ≤ 16002 := by norm_num
linarith [h1, h3, h4]
rw [show (9 : ℝ) = Real.log (Real.exp 9) by rw [Real.log_exp]]
exact Real.log_le_log (Real.exp_pos _) (he9.trans hR)
/-- **The tail application**: for ‖s‖ = R ≥ 16002, the if-zeroed tail
over {‖ρ‖ ≥ 2R+1} is ≤ 91·A₀·log R (per-term (17R/6)·m/(1+γ²) via
`seriesTerm_norm_le` + 1/(1+‖γ‖²) ≤ 1/(1+im²), then
`zero_tail_inv_sq_le` at X = 2R−1 ≥ 200). -/
lemma series_tail_le {s : ℂ} {R : ℝ} (hs : ‖s‖ = R) (hR : (16002 : ℝ) ≤ R) :
∑' ρ : {ρ : ℂ // IsNontrivialZero ρ},
(if ρ ∈ circleZeros R then (0 : ℝ) else ‖seriesTerm s ρ‖)
≤ 91 * A0count * Real.log R := by
have hRpos : (0 : ℝ) < R := by linarith [hR]
have hX : (200 : ℝ) ≤ 2 * R - 1 := by linarith [hR]
have hlogR : (9 : ℝ) ≤ Real.log R := nine_le_log_of_16002_le hR
have hpoint : ∀ ρ : {ρ : ℂ // IsNontrivialZero ρ},
(if ρ ∈ circleZeros R then (0 : ℝ) else ‖seriesTerm s ρ‖)
≤ (17 * R / 6) * tailTerm (2 * R - 1) ρ := by
intro ρ
by_cases hmem : ρ ∈ circleZeros R
· rw [if_pos hmem]
exact mul_nonneg (by positivity) (tailTerm_nonneg ρ)
· rw [if_neg hmem]
have hnorm : (2 * R + 1 : ℝ) ≤ ‖(ρ : ℂ)‖ := by
have h := not_lt.mp (mt mem_circleZeros.mpr hmem)
linarith
have hρ2 : (2 : ℝ) ≤ ‖(ρ : ℂ)‖ := by linarith [hR, hnorm]
have hsρ : 2 * ‖s‖ ≤ ‖(ρ : ℂ)‖ := by rw [hs]; linarith [hnorm]
have h1 := seriesTerm_norm_le ρ hρ2 hsρ
rw [hs] at h1
-- m/(1+‖γ‖²) ≤ m/(1+im²) = tailTerm (|im| ≥ ‖ρ‖−1 ≥ 2R > 2R−1)
have hgam : Complex.normSq (gammaOf (ρ : ℂ))
= (ρ : ℂ).im ^ 2 + (1 / 2 - (ρ : ℂ).re) ^ 2 := by
rw [Complex.normSq_apply, WeilEF.gammaOf_re, WeilEF.gammaOf_im]
ring
have hcmp : (1 : ℝ) + (ρ : ℂ).im ^ 2
≤ 1 + Complex.normSq (gammaOf (ρ : ℂ)) := by
rw [hgam]
have h2 : (0 : ℝ) ≤ (1 / 2 - (ρ : ℂ).re) ^ 2 := sq_nonneg _
linarith
have hpos1 : (0 : ℝ) < 1 + Complex.normSq (gammaOf (ρ : ℂ)) := by
have h := Complex.normSq_nonneg (gammaOf (ρ : ℂ))
linarith
have hpos2 : (0 : ℝ) < 1 + (ρ : ℂ).im ^ 2 := by positivity
have hfrac : 1 / (1 + Complex.normSq (gammaOf (ρ : ℂ)))
≤ 1 / (1 + (ρ : ℂ).im ^ 2) :=
one_div_le_one_div_of_le hpos2 hcmp
have hm : (0 : ℝ) ≤ (zeroMult ρ : ℝ) := Nat.cast_nonneg _
have h2 : (zeroMult ρ : ℝ) / (1 + Complex.normSq (gammaOf (ρ : ℂ)))
≤ (zeroMult ρ : ℝ) / (1 + (ρ : ℂ).im ^ 2) := by
rw [show (zeroMult ρ : ℝ) / (1 + Complex.normSq (gammaOf (ρ : ℂ)))
= (zeroMult ρ : ℝ) * (1 / (1 + Complex.normSq (gammaOf (ρ : ℂ)))) from by ring]
rw [show (zeroMult ρ : ℝ) / (1 + (ρ : ℂ).im ^ 2)
= (zeroMult ρ : ℝ) * (1 / (1 + (ρ : ℂ).im ^ 2)) from by ring]
exact mul_le_mul_of_nonneg_left hfrac hm
have him : (2 : ℝ) * R - 1 < |(ρ : ℂ).im| := by
have h3 := abs_im_ge_norm_sub_one ρ
linarith [hnorm, hR]
rw [tailTerm, if_pos him]
calc ‖seriesTerm s ρ‖
≤ 17 / 6 * R * ((zeroMult ρ : ℝ) / (1 + Complex.normSq (gammaOf (ρ : ℂ)))) := h1
_ ≤ 17 / 6 * R * ((zeroMult ρ : ℝ) / (1 + (ρ : ℂ).im ^ 2)) :=
mul_le_mul_of_nonneg_left h2 (by positivity)
_ = 17 * R / 6 * ((zeroMult ρ : ℝ) / (1 + (ρ : ℂ).im ^ 2)) := by ring
have hsumL : Summable (fun ρ : {ρ : ℂ // IsNontrivialZero ρ} =>
if ρ ∈ circleZeros R then (0 : ℝ) else ‖seriesTerm s ρ‖) := by
apply Summable.of_norm_bounded (seriesSummable s).norm
intro ρ
by_cases h : ρ ∈ circleZeros R <;> simp [h]
have hsumR : Summable (fun ρ : {ρ : ℂ // IsNontrivialZero ρ} =>
(17 * R / 6) * tailTerm (2 * R - 1) ρ) :=
(tailTerm_summable (2 * R - 1)).mul_left _
have htsum := Summable.tsum_le_tsum hpoint hsumL hsumR
rw [tsum_mul_left] at htsum
have htail := zero_tail_inv_sq_le hX
have hlog2R : Real.log (2 * R - 1) ≤ 2 * Real.log R := by
have h1 : Real.log (2 * R - 1) ≤ Real.log (2 * R) := by
apply Real.log_le_log (by linarith [hRpos])
linarith
have h2 : Real.log (2 * R) = Real.log 2 + Real.log R :=
Real.log_mul (by norm_num : (2 : ℝ) ≠ 0) (by linarith [hRpos] : R ≠ 0)
have h3 := log_two_le_one
linarith [h1, h2, h3, hlogR]
have hR21 : R / (2 * R - 1) ≤ 1 := by
rw [div_le_one (by linarith [hRpos] : (0 : ℝ) < 2 * R - 1)]
linarith [hRpos]
have hA0 := A0count_pos.le
have hlogRnn : (0 : ℝ) ≤ Real.log R := by linarith [hlogR]
have hbound : 17 * R / 6 * (16 * A0count * Real.log (2 * R - 1) / (2 * R - 1))
≤ 91 * A0count * Real.log R := by
have h1 : 17 * R / 6 * (16 * A0count * Real.log (2 * R - 1) / (2 * R - 1))
= (17 / 6) * 16 * A0count * (R / (2 * R - 1)) * Real.log (2 * R - 1) := by
ring
rw [h1]
have hlog21nn : (0 : ℝ) ≤ Real.log (2 * R - 1) :=
Real.log_nonneg (by linarith [hRpos])
have h2 : (17 / 6 : ℝ) * 16 * A0count * (R / (2 * R - 1)) * Real.log (2 * R - 1)
≤ (17 / 6) * 16 * A0count * 1 * (2 * Real.log R) :=
mul_le_mul
(mul_le_mul_of_nonneg_left hR21
(mul_nonneg (by norm_num : (0 : ℝ) ≤ 17 / 6 * 16) hA0))
hlog2R hlog21nn
(mul_nonneg (mul_nonneg (by norm_num : (0 : ℝ) ≤ 17 / 6 * 16) hA0) one_pos.le)
calc (17 / 6 : ℝ) * 16 * A0count * (R / (2 * R - 1)) * Real.log (2 * R - 1)
≤ (17 / 6) * 16 * A0count * 1 * (2 * Real.log R) := h2
_ = (272 / 3) * A0count * Real.log R := by ring
_ ≤ 91 * A0count * Real.log R := by
apply mul_le_mul_of_nonneg_right _ hlogRnn
apply mul_le_mul_of_nonneg_right _ hA0
norm_num
calc ∑' ρ : {ρ : ℂ // IsNontrivialZero ρ},
(if ρ ∈ circleZeros R then (0 : ℝ) else ‖seriesTerm s ρ‖)
≤ 17 * R / 6 * ∑' ρ : {ρ : ℂ // IsNontrivialZero ρ}, tailTerm (2 * R - 1) ρ := htsum
_ ≤ 17 * R / 6 * (16 * A0count * Real.log (2 * R - 1) / (2 * R - 1)) :=
mul_le_mul_of_nonneg_left htail (by positivity)
_ ≤ 91 * A0count * Real.log R := hbound
/-- **The one tsum split**: ‖seriesFun s‖ ≤ the finite part over
{‖ρ‖ < 2R+1} + the if-zeroed tail. -/
lemma seriesFun_norm_le_split {s : ℂ} {R : ℝ} :
‖seriesFun s‖
≤ ∑ ρ ∈ circleZeros R, ‖seriesTerm s ρ‖
+ ∑' ρ : {ρ : ℂ // IsNontrivialZero ρ},
(if ρ ∈ circleZeros R then (0 : ℝ) else ‖seriesTerm s ρ‖) := by
have h1 : ‖seriesFun s‖
≤ ∑' ρ : {ρ : ℂ // IsNontrivialZero ρ}, ‖seriesTerm s ρ‖ :=
norm_tsum_le_tsum_norm (seriesSummable s).norm
have h2 := tsum_split_finset (seriesSummable s).norm (circleZeros R)
calc ‖seriesFun s‖
≤ ∑' ρ : {ρ : ℂ // IsNontrivialZero ρ}, ‖seriesTerm s ρ‖ := h1
_ = ∑ ρ ∈ circleZeros R, ‖seriesTerm s ρ‖
+ ∑' ρ : {ρ : ℂ // IsNontrivialZero ρ},
(if ρ ∈ circleZeros R then (0 : ℝ) else ‖seriesTerm s ρ‖) := h2
/-! ## 7. The dyadic-family machine and the low shell (5e-v-b chunk 3c)
`half_le_log_two`, `Nat.log_floor_two_le` (J := Nat.log 2 ⌊R⌋₊ ≤
2·log R), `log_three_le_two_log` (log(3x+5) ≤ 2·log R for 0 ≤ x ≤ 3R).
`dyadic_family_le`: the generic dyadic-shell bound — with
j(ρ) := Nat.log 2 ⌊d ρ⌋₊ valued in Ico 1 (J+1) on FS, per-fiber count
≤ cnt j, and per-element term bound g ρ ≤ C₁·m/2^{j(ρ)}, the FS-sum of
g is ≤ Σ_{j ∈ Ico 1 (J+1)} (C₁/2^j)·cnt j. `shell_low`: the low shell
(‖ρ‖ ≤ 3) ≤ 2·lowZeroConst. -/
/-- 1/2 ≤ log 2 (log 4 = 2 log 2 and 4 ≥ e). -/
lemma half_le_log_two : (1 : ℝ) / 2 ≤ Real.log 2 := by
have h1 : Real.log 4 = 2 * Real.log 2 := by
rw [show (4 : ℝ) = 2 ^ 2 by norm_num, Real.log_pow]
push_cast
ring
have h2 : (1 : ℝ) ≤ Real.log 4 := by
rw [Real.le_log_iff_exp_le (by norm_num : (0 : ℝ) < 4)]
have h := Real.exp_one_lt_d9.le
linarith
linarith [h1, h2]
/-- J := Nat.log 2 ⌊R⌋₊ satisfies J ≤ 2·log R for R ≥ 16002
(2^J ≤ ⌊R⌋₊ ≤ R ⟹ J·log 2 ≤ log R; log 2 ≥ 1/2). -/
lemma Nat.log_floor_two_le {R : ℝ} (hR : (16002 : ℝ) ≤ R) :
(Nat.log 2 ⌊R⌋₊ : ℝ) ≤ 2 * Real.log R := by
have hfl : ⌊R⌋₊ ≠ 0 := by
rw [Ne, Nat.floor_eq_zero]
push Not
linarith
have h1 : (2 : ℝ) ^ Nat.log 2 ⌊R⌋₊ ≤ R := by
have h2 := Nat.pow_log_le_self 2 hfl
have h3 : ((2 ^ Nat.log 2 ⌊R⌋₊ : ℕ) : ℝ) ≤ (⌊R⌋₊ : ℝ) := by exact_mod_cast h2
have h4 : (⌊R⌋₊ : ℝ) ≤ R := Nat.floor_le (by linarith [hR])
have h5 : ((2 ^ Nat.log 2 ⌊R⌋₊ : ℕ) : ℝ) = (2 : ℝ) ^ Nat.log 2 ⌊R⌋₊ := by
push_cast
ring
rw [h5] at h3
linarith [h3, h4]
have h2 : (Nat.log 2 ⌊R⌋₊ : ℝ) * Real.log 2 ≤ Real.log R := by
have h3 : Real.log ((2 : ℝ) ^ Nat.log 2 ⌊R⌋₊) ≤ Real.log R :=
Real.log_le_log (by positivity) h1
rw [Real.log_pow] at h3
exact h3
have h3 := half_le_log_two
have h4 : (0 : ℝ) ≤ (Nat.log 2 ⌊R⌋₊ : ℝ) := Nat.cast_nonneg _
nlinarith [h2, h3, h4]
/-- For 0 ≤ x ≤ 3R with R ≥ 16002: log(3x+5) ≤ 2·log R. -/
lemma log_three_le_two_log {R x : ℝ} (hR : (16002 : ℝ) ≤ R)
(hx0 : (0 : ℝ) ≤ x) (hx : x ≤ 3 * R) :
Real.log (3 * x + 5) ≤ 2 * Real.log R := by
have hlogR : (9 : ℝ) ≤ Real.log R := nine_le_log_of_16002_le hR
have h1 : Real.log (3 * x + 5) ≤ Real.log (10 * R) := by
apply Real.log_le_log (by linarith [hx0, hR])
linarith [hx, hR]
have h2 : Real.log (10 * R) = Real.log 10 + Real.log R :=
Real.log_mul (by norm_num : (10 : ℝ) ≠ 0) (by linarith [hR] : R ≠ 0)
have h3 : Real.log 10 ≤ Real.log R := Real.log_le_log (by norm_num) (by linarith [hR])
linarith [h1, h2, h3]
/-- **The generic dyadic-family bound.** With j(ρ) := Nat.log 2 ⌊d ρ⌋₊
valued in Ico 1 (J+1) on FS, per-fiber multiplicity count ≤ cnt j, and
per-element term bound g ρ ≤ C₁·m/2^{j(ρ)}, the FS-sum of g is at most
Σ_{j ∈ Ico 1 (J+1)} (C₁/2^j)·cnt j. -/
lemma dyadic_family_le (FS : Finset {ρ : ℂ // IsNontrivialZero ρ})
(d : {ρ : ℂ // IsNontrivialZero ρ} → ℝ) (J : ℕ)
(g : {ρ : ℂ // IsNontrivialZero ρ} → ℝ) (C₁ : ℝ) (cnt : ℕ → ℝ)
(hC1 : (0 : ℝ) ≤ C₁)
(hdj : ∀ ρ ∈ FS, 1 ≤ Nat.log 2 ⌊d ρ⌋₊ ∧ Nat.log 2 ⌊d ρ⌋₊ ≤ J)
(hterm : ∀ ρ ∈ FS, g ρ
≤ C₁ * (zeroMult (ρ : ℂ) : ℝ) / (2 : ℝ) ^ (Nat.log 2 ⌊d ρ⌋₊))
(hcount : ∀ j : ℕ,
∑ ρ ∈ FS.filter (fun ρ => Nat.log 2 ⌊d ρ⌋₊ = j), (zeroMult (ρ : ℂ) : ℝ) ≤ cnt j) :
∑ ρ ∈ FS, g ρ ≤ ∑ j ∈ Finset.Ico 1 (J + 1), (C₁ / (2 : ℝ) ^ j) * cnt j := by
classical
have h1 : ∑ ρ ∈ FS, g ρ
≤ ∑ ρ ∈ FS, C₁ * (zeroMult (ρ : ℂ) : ℝ) / (2 : ℝ) ^ (Nat.log 2 ⌊d ρ⌋₊) :=
Finset.sum_le_sum (fun ρ hρ => hterm ρ hρ)
have hmaps : ∀ ρ ∈ FS, Nat.log 2 ⌊d ρ⌋₊ ∈ Finset.Ico 1 (J + 1) := by
intro ρ hρ
rw [Finset.mem_Ico]
have h1' := (hdj ρ hρ).1
have h2' := (hdj ρ hρ).2
exact ⟨h1', by omega⟩
have h2 : ∑ ρ ∈ FS, C₁ * (zeroMult (ρ : ℂ) : ℝ) / (2 : ℝ) ^ (Nat.log 2 ⌊d ρ⌋₊)
= ∑ j ∈ Finset.Ico 1 (J + 1),
∑ ρ ∈ FS.filter (fun ρ => Nat.log 2 ⌊d ρ⌋₊ = j),
C₁ * (zeroMult (ρ : ℂ) : ℝ) / (2 : ℝ) ^ (Nat.log 2 ⌊d ρ⌋₊) :=
(Finset.sum_fiberwise_of_maps_to hmaps
(fun ρ => C₁ * (zeroMult (ρ : ℂ) : ℝ) / (2 : ℝ) ^ (Nat.log 2 ⌊d ρ⌋₊))).symm
have h3 : ∀ j ∈ Finset.Ico 1 (J + 1),
∑ ρ ∈ FS.filter (fun ρ => Nat.log 2 ⌊d ρ⌋₊ = j),
C₁ * (zeroMult (ρ : ℂ) : ℝ) / (2 : ℝ) ^ (Nat.log 2 ⌊d ρ⌋₊)
= (C₁ / (2 : ℝ) ^ j) *
∑ ρ ∈ FS.filter (fun ρ => Nat.log 2 ⌊d ρ⌋₊ = j), (zeroMult (ρ : ℂ) : ℝ) := by
intro j hj
have hterm' : ∀ ρ ∈ FS.filter (fun ρ => Nat.log 2 ⌊d ρ⌋₊ = j),
C₁ * (zeroMult (ρ : ℂ) : ℝ) / (2 : ℝ) ^ (Nat.log 2 ⌊d ρ⌋₊)
= (C₁ / (2 : ℝ) ^ j) * (zeroMult (ρ : ℂ) : ℝ) := by
intro ρ hρ
rw [Finset.mem_filter] at hρ
rw [hρ.2]
ring
rw [Finset.sum_congr rfl hterm', Finset.mul_sum]
have h4 : ∀ j ∈ Finset.Ico 1 (J + 1),
(C₁ / (2 : ℝ) ^ j) *
∑ ρ ∈ FS.filter (fun ρ => Nat.log 2 ⌊d ρ⌋₊ = j), (zeroMult (ρ : ℂ) : ℝ)
≤ (C₁ / (2 : ℝ) ^ j) * cnt j :=
fun j _ => mul_le_mul_of_nonneg_left (hcount j)
(div_nonneg hC1 (by positivity))
calc ∑ ρ ∈ FS, g ρ
≤ ∑ ρ ∈ FS, C₁ * (zeroMult (ρ : ℂ) : ℝ) / (2 : ℝ) ^ (Nat.log 2 ⌊d ρ⌋₊) := h1
_ = ∑ j ∈ Finset.Ico 1 (J + 1),
∑ ρ ∈ FS.filter (fun ρ => Nat.log 2 ⌊d ρ⌋₊ = j),
C₁ * (zeroMult (ρ : ℂ) : ℝ) / (2 : ℝ) ^ (Nat.log 2 ⌊d ρ⌋₊) := h2
_ = ∑ j ∈ Finset.Ico 1 (J + 1),
(C₁ / (2 : ℝ) ^ j) *
∑ ρ ∈ FS.filter (fun ρ => Nat.log 2 ⌊d ρ⌋₊ = j), (zeroMult (ρ : ℂ) : ℝ) :=
Finset.sum_congr rfl h3
_ ≤ ∑ j ∈ Finset.Ico 1 (J + 1), (C₁ / (2 : ℝ) ^ j) * cnt j :=
Finset.sum_le_sum h4
/-- **The low shell** (‖ρ‖ ≤ 3): at most 2·lowZeroConst. -/
lemma shell_low {s : ℂ} {R : ℝ} (hs : ‖s‖ = R) (hsz : ¬ IsNontrivialZero s)
(hR : (16002 : ℝ) ≤ R) :
∑ ρ ∈ (circleZeros R).filter (fun ρ : {ρ : ℂ // IsNontrivialZero ρ} => ‖(ρ : ℂ)‖ ≤ 3), ‖seriesTerm s ρ‖
≤ 2 * lowZeroConst := by
have hRpos : (0 : ℝ) < R := by linarith [hR]
have hterm : ∀ ρ ∈ (circleZeros R).filter (fun ρ : {ρ : ℂ // IsNontrivialZero ρ} => ‖(ρ : ℂ)‖ ≤ 3),
‖seriesTerm s ρ‖
≤ 2 * ((zeroMult (ρ : ℂ) : ℝ) * (1 + 1 / ‖(ρ : ℂ)‖)) := by
intro ρ hρ
rw [Finset.mem_filter] at hρ
have hρ3 : ‖(ρ : ℂ)‖ ≤ 3 := hρ.2
have h0 : (ρ : ℂ) ≠ 0 := by
intro h
have hre := ρ.2.2.1
rw [h] at hre
simp at hre
have hρpos : (0 : ℝ) < ‖(ρ : ℂ)‖ := norm_pos_iff.mpr h0
have hsr : R - ‖(ρ : ℂ)‖ ≤ ‖s - (ρ : ℂ)‖ := by
have h := abs_norm_sub_norm_le s (ρ : ℂ)
rw [hs, abs_of_nonneg (by linarith [hR, hρ3] : (0 : ℝ) ≤ R - ‖(ρ : ℂ)‖)] at h
exact h
have hsr3 : (R - 3 : ℝ) ≤ ‖s - (ρ : ℂ)‖ := by linarith [hsr, hρ3]
have hsrpos : (0 : ℝ) < ‖s - (ρ : ℂ)‖ := by linarith [hsr3, hR]
have hid := seriesTerm_norm_eq_div hs hsz ρ
rw [hid]
have h1 : R / (‖(ρ : ℂ)‖ * ‖s - (ρ : ℂ)‖) ≤ R / (‖(ρ : ℂ)‖ * (R - 3)) := by
apply div_le_div_of_nonneg_left hRpos.le (mul_pos hρpos (by linarith [hR]))
exact mul_le_mul_of_nonneg_left hsr3 hρpos.le
have h2 : R / (‖(ρ : ℂ)‖ * (R - 3)) = (R / (R - 3)) * (1 / ‖(ρ : ℂ)‖) := by
field_simp
have h3 : R / (R - 3) ≤ 2 := by
rw [div_le_iff₀ (by linarith [hR] : (0 : ℝ) < R - 3)]
linarith [hR]
have hm : (0 : ℝ) ≤ (zeroMult (ρ : ℂ) : ℝ) := Nat.cast_nonneg _
calc (zeroMult (ρ : ℂ) : ℝ) * (R / (‖(ρ : ℂ)‖ * ‖s - (ρ : ℂ)‖))
≤ (zeroMult (ρ : ℂ) : ℝ) * (R / (‖(ρ : ℂ)‖ * (R - 3))) :=
mul_le_mul_of_nonneg_left h1 hm
_ = (zeroMult (ρ : ℂ) : ℝ) * ((R / (R - 3)) * (1 / ‖(ρ : ℂ)‖)) := by rw [h2]
_ ≤ (zeroMult (ρ : ℂ) : ℝ) * (2 * (1 / ‖(ρ : ℂ)‖)) := by
apply mul_le_mul_of_nonneg_left _ hm
apply mul_le_mul_of_nonneg_right h3
exact div_nonneg one_pos.le hρpos.le
_ = 2 * ((zeroMult (ρ : ℂ) : ℝ) / ‖(ρ : ℂ)‖) := by ring
_ ≤ 2 * ((zeroMult (ρ : ℂ) : ℝ) * (1 + 1 / ‖(ρ : ℂ)‖)) := by
apply mul_le_mul_of_nonneg_left _ (by norm_num : (0 : ℝ) ≤ 2)
have h4 : (zeroMult (ρ : ℂ) : ℝ) / ‖(ρ : ℂ)‖
≤ (zeroMult (ρ : ℂ) : ℝ) * (1 + 1 / ‖(ρ : ℂ)‖) := by
rw [mul_add, mul_one, mul_one_div]
have h5 : (zeroMult (ρ : ℂ) : ℝ) / ‖(ρ : ℂ)‖
≤ (zeroMult (ρ : ℂ) : ℝ) + (zeroMult (ρ : ℂ) : ℝ) / ‖(ρ : ℂ)‖ := by
linarith [hm]
exact h5
exact h4
calc ∑ ρ ∈ (circleZeros R).filter (fun ρ : {ρ : ℂ // IsNontrivialZero ρ} => ‖(ρ : ℂ)‖ ≤ 3), ‖seriesTerm s ρ‖
≤ ∑ ρ ∈ (circleZeros R).filter (fun ρ : {ρ : ℂ // IsNontrivialZero ρ} => ‖(ρ : ℂ)‖ ≤ 3),
2 * ((zeroMult (ρ : ℂ) : ℝ) * (1 + 1 / ‖(ρ : ℂ)‖)) :=
Finset.sum_le_sum hterm
_ = 2 * ∑ ρ ∈ (circleZeros R).filter (fun ρ : {ρ : ℂ // IsNontrivialZero ρ} => ‖(ρ : ℂ)‖ ≤ 3),
(zeroMult (ρ : ℂ) : ℝ) * (1 + 1 / ‖(ρ : ℂ)‖) := by
rw [Finset.mul_sum]
_ ≤ 2 * lowZeroConst := by
apply mul_le_mul_of_nonneg_left _ (by norm_num : (0 : ℝ) ≤ 2)
rw [lowZeroConst]
apply Finset.sum_le_sum_of_subset_of_nonneg
· intro ρ hρ
rw [Finset.mem_filter] at hρ
have hρ3 : ‖(ρ : ℂ)‖ ≤ 3 := hρ.2
have hmem : ρ ∈ lowZeros := by
rw [lowZeros, Set.Finite.mem_toFinset]
exact hρ3
exact hmem
· intro ρ _ _
exact mul_nonneg (Nat.cast_nonneg _)
(add_nonneg one_pos.le (div_nonneg one_pos.le (norm_nonneg _)))
/-! ## 8. The three dyadic shells (5e-v-b chunk 3c-ii)
`two_pow_log_floor_le`: (2:ℝ)^J ≤ R. `shell_inlo` (3 < ‖ρ‖ ≤ R/2),
`shell_inhi` (R/2 < ‖ρ‖ ≤ R−2), `shell_up` (R+2 ≤ ‖ρ‖ within the
finite part): dyadic in ‖ρ‖ / R−‖ρ‖ / ‖ρ‖−R respectively, per-fiber
count via the brick, uniform log bound ≤ 2·log R. Each ≤
60/60/30·A₀·(log R)². -/
/-- (2:ℝ)^J ≤ R for J = Nat.log 2 ⌊R⌋₊, R ≥ 16002. -/
lemma two_pow_log_floor_le {R : ℝ} (hR : (16002 : ℝ) ≤ R) :
(2 : ℝ) ^ (Nat.log 2 ⌊R⌋₊) ≤ R := by
have hfl : ⌊R⌋₊ ≠ 0 := by
rw [Ne, Nat.floor_eq_zero]
push Not
linarith
have h2 := Nat.pow_log_le_self 2 hfl
have h3 : ((2 ^ Nat.log 2 ⌊R⌋₊ : ℕ) : ℝ) ≤ (⌊R⌋₊ : ℝ) := by exact_mod_cast h2
have h4 : (⌊R⌋₊ : ℝ) ≤ R := Nat.floor_le (by linarith [hR])
have h5 : ((2 ^ Nat.log 2 ⌊R⌋₊ : ℕ) : ℝ) = (2 : ℝ) ^ Nat.log 2 ⌊R⌋₊ := by
push_cast
ring
rw [h5] at h3
linarith [h3, h4]
/-- **The inner-low shell** (3 < ‖ρ‖ ≤ R/2): ≤ 60·A₀·(log R)². -/
lemma shell_inlo {s : ℂ} {R : ℝ} (hs : ‖s‖ = R) (hsz : ¬ IsNontrivialZero s)
(hR : (16002 : ℝ) ≤ R) :
∑ ρ ∈ (circleZeros R).filter (fun ρ : {ρ : ℂ // IsNontrivialZero ρ} =>
¬ ‖(ρ : ℂ)‖ ≤ 3 ∧ ‖(ρ : ℂ)‖ ≤ R / 2), ‖seriesTerm s ρ‖
≤ 60 * A0count * (Real.log R) ^ 2 := by
classical
have hRpos : (0 : ℝ) < R := by linarith [hR]
have hlogR : (9 : ℝ) ≤ Real.log R := nine_le_log_of_16002_le hR
have hlogRnn : (0 : ℝ) ≤ Real.log R := by linarith [hlogR]
set J := Nat.log 2 ⌊R⌋₊ with hJ
have hJle : (J : ℝ) ≤ 2 * Real.log R := Nat.log_floor_two_le hR
have h2JR : (2 : ℝ) ^ J ≤ R := two_pow_log_floor_le hR
set FS := (circleZeros R).filter (fun ρ : {ρ : ℂ // IsNontrivialZero ρ} =>
¬ ‖(ρ : ℂ)‖ ≤ 3 ∧ ‖(ρ : ℂ)‖ ≤ R / 2) with hFS
have hdj : ∀ ρ ∈ FS, 1 ≤ Nat.log 2 ⌊‖(ρ : ℂ)‖⌋₊ ∧ Nat.log 2 ⌊‖(ρ : ℂ)‖⌋₊ ≤ J := by
intro ρ hρ
rw [hFS, Finset.mem_filter] at hρ
obtain ⟨-, hρ3, hρR2⟩ := hρ
have hρ3' : (3 : ℝ) < ‖(ρ : ℂ)‖ := lt_of_not_ge hρ3
have hfl3 : (3 : ℕ) ≤ ⌊‖(ρ : ℂ)‖⌋₊ := by
rw [Nat.le_floor_iff (norm_nonneg _)]
exact_mod_cast hρ3'.le
have h1 : (1 : ℕ) ≤ Nat.log 2 ⌊‖(ρ : ℂ)‖⌋₊ := by
have h2 := Nat.log_mono_right (b := 2) hfl3
have h3 : Nat.log 2 3 = 1 := by decide
rw [h3] at h2
exact h2
have h2 : Nat.log 2 ⌊‖(ρ : ℂ)‖⌋₊ ≤ J := by
apply Nat.log_mono_right (b := 2)
apply Nat.floor_mono
linarith [hρR2, hR]
exact ⟨h1, h2⟩
have hterm : ∀ ρ ∈ FS, ‖seriesTerm s ρ‖
≤ 2 * (zeroMult (ρ : ℂ) : ℝ) / (2 : ℝ) ^ (Nat.log 2 ⌊‖(ρ : ℂ)‖⌋₊) := by
intro ρ hρ
rw [hFS, Finset.mem_filter] at hρ
obtain ⟨-, hρ3, hρR2⟩ := hρ
have hρ3' : (3 : ℝ) < ‖(ρ : ℂ)‖ := lt_of_not_ge hρ3
have hpowle : (2 : ℝ) ^ (Nat.log 2 ⌊‖(ρ : ℂ)‖⌋₊) ≤ ‖(ρ : ℂ)‖ := by
have hfl : ⌊‖(ρ : ℂ)‖⌋₊ ≠ 0 := by
rw [Ne, Nat.floor_eq_zero]
push Not
linarith [hρ3']
have h1 := Nat.pow_log_le_self 2 hfl
have h2 : ((2 ^ Nat.log 2 ⌊‖(ρ : ℂ)‖⌋₊ : ℕ) : ℝ) ≤ (⌊‖(ρ : ℂ)‖⌋₊ : ℝ) := by
exact_mod_cast h1
have h3 : ((2 ^ Nat.log 2 ⌊‖(ρ : ℂ)‖⌋₊ : ℕ) : ℝ)
= (2 : ℝ) ^ (Nat.log 2 ⌊‖(ρ : ℂ)‖⌋₊) := by
push_cast
ring
rw [h3] at h2
have h4 : (⌊‖(ρ : ℂ)‖⌋₊ : ℝ) ≤ ‖(ρ : ℂ)‖ := Nat.floor_le (norm_nonneg _)
linarith [h2, h4]
have hsr : R / 2 ≤ ‖s - (ρ : ℂ)‖ := by
have h := abs_norm_sub_norm_le s (ρ : ℂ)
rw [hs, abs_of_nonneg (by linarith [hR, hρR2] : (0 : ℝ) ≤ R - ‖(ρ : ℂ)‖)] at h
linarith [h, hρR2]
have hρpos : (0 : ℝ) < ‖(ρ : ℂ)‖ := by linarith [hρ3']
have hsrpos : (0 : ℝ) < ‖s - (ρ : ℂ)‖ := by linarith [hsr, hR]
have hid := seriesTerm_norm_eq_div hs hsz ρ
rw [hid]
have hm : (0 : ℝ) ≤ (zeroMult (ρ : ℂ) : ℝ) := Nat.cast_nonneg _
have h1 : R / (‖(ρ : ℂ)‖ * ‖s - (ρ : ℂ)‖) ≤ R / (‖(ρ : ℂ)‖ * (R / 2)) := by
apply div_le_div_of_nonneg_left hRpos.le (mul_pos hρpos (by linarith [hR]))
exact mul_le_mul_of_nonneg_left hsr hρpos.le
have h2 : R / (‖(ρ : ℂ)‖ * (R / 2)) = 2 / ‖(ρ : ℂ)‖ := by
field_simp
have h3 : (2 : ℝ) / ‖(ρ : ℂ)‖ ≤ 2 / (2 : ℝ) ^ (Nat.log 2 ⌊‖(ρ : ℂ)‖⌋₊) := by
apply div_le_div_of_nonneg_left (by norm_num : (0 : ℝ) ≤ 2) (by positivity)
exact hpowle
calc (zeroMult (ρ : ℂ) : ℝ) * (R / (‖(ρ : ℂ)‖ * ‖s - (ρ : ℂ)‖))
≤ (zeroMult (ρ : ℂ) : ℝ) * (R / (‖(ρ : ℂ)‖ * (R / 2))) :=
mul_le_mul_of_nonneg_left h1 hm
_ = (zeroMult (ρ : ℂ) : ℝ) * (2 / ‖(ρ : ℂ)‖) := by rw [h2]
_ ≤ (zeroMult (ρ : ℂ) : ℝ) * (2 / (2 : ℝ) ^ (Nat.log 2 ⌊‖(ρ : ℂ)‖⌋₊)) :=
mul_le_mul_of_nonneg_left h3 hm
_ = 2 * (zeroMult (ρ : ℂ) : ℝ) / (2 : ℝ) ^ (Nat.log 2 ⌊‖(ρ : ℂ)‖⌋₊) := by ring
have hcount : ∀ j : ℕ,
∑ ρ ∈ FS.filter (fun ρ : {ρ : ℂ // IsNontrivialZero ρ} =>
Nat.log 2 ⌊‖(ρ : ℂ)‖⌋₊ = j), (zeroMult (ρ : ℂ) : ℝ)
≤ 3 * A0count * ((2 : ℝ) ^ j + 3) * Real.log (3 * (2 : ℝ) ^ (j + 1) + 5) := by
intro j
by_cases hj : j ∈ Finset.Ico 1 (J + 1)
· rw [Finset.mem_Ico] at hj
have hj2 : (2 : ℝ) ≤ (2 : ℝ) ^ j := by
have h1 : (2 : ℝ) ^ 1 ≤ (2 : ℝ) ^ j :=
pow_le_pow_right₀ (by norm_num) (by omega : 1 ≤ j)
linarith [h1]
have hM1 : (1 : ℝ) ≤ max ((2 : ℝ) ^ j - 1) ((2 : ℝ) ^ j - 1) := by
rw [max_self]
linarith [hj2]
have hMb : max ((2 : ℝ) ^ j - 1) ((2 : ℝ) ^ j - 1) ≤ (2 : ℝ) ^ (j + 1) := by
rw [max_self]
have h1 : (2 : ℝ) ^ (j + 1) = 2 * (2 : ℝ) ^ j := by rw [pow_succ']
linarith [hj2]
have hsub : ∀ ρ ∈ FS.filter (fun ρ : {ρ : ℂ // IsNontrivialZero ρ} =>
Nat.log 2 ⌊‖(ρ : ℂ)‖⌋₊ = j),
(2 : ℝ) ^ j - 1 ≤ |(ρ : ℂ).im| ∧ |(ρ : ℂ).im| ≤ (2 : ℝ) ^ (j + 1) ∧
(2 : ℝ) ^ j - 1 ≤ |(ρ : ℂ).im| := by
intro ρ hρ
rw [Finset.mem_filter] at hρ
obtain ⟨hρF, hρj⟩ := hρ
have hpowle : (2 : ℝ) ^ j ≤ ‖(ρ : ℂ)‖ := by
have hfl : ⌊‖(ρ : ℂ)‖⌋₊ ≠ 0 := by
rw [Ne, Nat.floor_eq_zero]
push Not
rw [hFS, Finset.mem_filter] at hρF
have hρ3' : (3 : ℝ) < ‖(ρ : ℂ)‖ := lt_of_not_ge hρF.2.1
linarith [hρ3']
have h1 := Nat.pow_log_le_self 2 hfl
rw [hρj] at h1
have h2 : ((2 ^ j : ℕ) : ℝ) ≤ (⌊‖(ρ : ℂ)‖⌋₊ : ℝ) := by exact_mod_cast h1
have h3 : ((2 ^ j : ℕ) : ℝ) = (2 : ℝ) ^ j := by push_cast; ring
rw [h3] at h2
have h4 : (⌊‖(ρ : ℂ)‖⌋₊ : ℝ) ≤ ‖(ρ : ℂ)‖ := Nat.floor_le (norm_nonneg _)
linarith [h2, h4]
have hpowup : ‖(ρ : ℂ)‖ < (2 : ℝ) ^ (j + 1) := by
have h1 : ⌊‖(ρ : ℂ)‖⌋₊ < 2 ^ (Nat.log 2 ⌊‖(ρ : ℂ)‖⌋₊ + 1) :=
Nat.lt_pow_succ_log_self (by norm_num) _
rw [hρj] at h1
have h2 : ⌊‖(ρ : ℂ)‖⌋₊ + 1 ≤ 2 ^ (j + 1) := h1
have h3 : ‖(ρ : ℂ)‖ < (⌊‖(ρ : ℂ)‖⌋₊ : ℝ) + 1 := Nat.lt_floor_add_one _
have h4 : ((⌊‖(ρ : ℂ)‖⌋₊ + 1 : ℕ) : ℝ) ≤ ((2 ^ (j + 1) : ℕ) : ℝ) := by
exact_mod_cast h2
have h5 : ((2 ^ (j + 1) : ℕ) : ℝ) = (2 : ℝ) ^ (j + 1) := by push_cast; ring
rw [h5] at h4
push_cast at h4
linarith [h3, h4]
have him1 := abs_im_ge_norm_sub_one ρ
have him2 : |(ρ : ℂ).im| ≤ ‖(ρ : ℂ)‖ := abs_im_le_norm _
exact ⟨by linarith [him1, hpowle], by linarith [him2, hpowup],
by linarith [him1, hpowle]⟩
have hbrick := sum_zeroMult_le_of_im_band
(FS.filter (fun ρ : {ρ : ℂ // IsNontrivialZero ρ} => Nat.log 2 ⌊‖(ρ : ℂ)‖⌋₊ = j))
hM1 hMb hsub
have hab : (2 : ℝ) ^ (j + 1) - ((2 : ℝ) ^ j - 1) + 2 = (2 : ℝ) ^ j + 3 := by
have h1 : (2 : ℝ) ^ (j + 1) = 2 * (2 : ℝ) ^ j := by rw [pow_succ']
linarith [h1]
have hmax : max |(2 : ℝ) ^ j - 1| |(2 : ℝ) ^ (j + 1)| = (2 : ℝ) ^ (j + 1) := by
have h1 : |(2 : ℝ) ^ (j + 1)| = (2 : ℝ) ^ (j + 1) := abs_of_nonneg (by positivity)
have h2 : |(2 : ℝ) ^ j - 1| = (2 : ℝ) ^ j - 1 := abs_of_nonneg (by linarith [hj2])
rw [h1, h2]
have h3 : (2 : ℝ) ^ (j + 1) = 2 * (2 : ℝ) ^ j := by rw [pow_succ']
have h4 : (0 : ℝ) < (2 : ℝ) ^ j := by positivity
exact max_eq_right (by linarith [h3, h4])
rw [hab, hmax] at hbrick
exact hbrick
· have hempty : FS.filter (fun ρ : {ρ : ℂ // IsNontrivialZero ρ} =>
Nat.log 2 ⌊‖(ρ : ℂ)‖⌋₊ = j) = ∅ := by
apply Finset.eq_empty_iff_forall_notMem.mpr
intro ρ hρ
rw [Finset.mem_filter] at hρ
obtain ⟨hρF, hρj⟩ := hρ
have hdjρ := hdj ρ hρF
rw [hρj] at hdjρ
rw [Finset.mem_Ico] at hj
omega
rw [hempty, Finset.sum_empty]
have h1 : (0 : ℝ) ≤ Real.log (3 * (2 : ℝ) ^ (j + 1) + 5) := by
apply Real.log_nonneg
have h2 : (0 : ℝ) < (2 : ℝ) ^ (j + 1) := by positivity
linarith [h2]
exact mul_nonneg (mul_nonneg (mul_nonneg (by norm_num : (0 : ℝ) ≤ 3) A0count_pos.le) (by positivity)) h1
-- the closed-form per-shell bound
have hper : ∀ j ∈ Finset.Ico 1 (J + 1),
(2 / (2 : ℝ) ^ j) * (3 * A0count * ((2 : ℝ) ^ j + 3) *
Real.log (3 * (2 : ℝ) ^ (j + 1) + 5))
≤ 30 * A0count * Real.log R := by
intro j hj
rw [Finset.mem_Ico] at hj
have h2j0 : (0 : ℝ) < (2 : ℝ) ^ j := by positivity
have hj2 : (2 : ℝ) ≤ (2 : ℝ) ^ j := by
have h1 : (2 : ℝ) ^ 1 ≤ (2 : ℝ) ^ j :=
pow_le_pow_right₀ (by norm_num) (by omega : 1 ≤ j)
linarith [h1]
have hlogle : Real.log (3 * (2 : ℝ) ^ (j + 1) + 5) ≤ 2 * Real.log R := by
apply log_three_le_two_log hR (by positivity)
have h1 : (2 : ℝ) ^ (j + 1) = 2 * (2 : ℝ) ^ j := by rw [pow_succ']
have h2 : (2 : ℝ) ^ j ≤ (2 : ℝ) ^ J := pow_le_pow_right₀ (by norm_num) (by omega : j ≤ J)
nlinarith [h1, h2, h2JR, hR]
have hA0 := A0count_pos.le
have h1 : (2 / (2 : ℝ) ^ j) * (3 * A0count * ((2 : ℝ) ^ j + 3) *
Real.log (3 * (2 : ℝ) ^ (j + 1) + 5))
= 6 * A0count * Real.log (3 * (2 : ℝ) ^ (j + 1) + 5) * (1 + 3 / (2 : ℝ) ^ j) := by
field_simp
ring
rw [h1]
have h2 : 3 / (2 : ℝ) ^ j ≤ 3 / 2 := by
apply div_le_div_of_nonneg_left (by norm_num : (0 : ℝ) ≤ 3) (by norm_num) hj2
have hlognn : (0 : ℝ) ≤ Real.log (3 * (2 : ℝ) ^ (j + 1) + 5) := by
apply Real.log_nonneg
have h3 : (0 : ℝ) < (2 : ℝ) ^ (j + 1) := by positivity
linarith [h3]
have h3 : (6 : ℝ) * A0count * Real.log (3 * (2 : ℝ) ^ (j + 1) + 5)
≤ 6 * A0count * (2 * Real.log R) :=
mul_le_mul_of_nonneg_left hlogle (mul_nonneg (by norm_num) hA0)
have h4 : (0 : ℝ) ≤ 1 + 3 / (2 : ℝ) ^ j := by
have h5 : (0 : ℝ) ≤ 3 / (2 : ℝ) ^ j := div_nonneg (by norm_num) h2j0.le
linarith [h5]
have h5 : (1 : ℝ) + 3 / (2 : ℝ) ^ j ≤ 5 / 2 := by linarith [h2]
have h6 : (6 : ℝ) * A0count * Real.log (3 * (2 : ℝ) ^ (j + 1) + 5) * (1 + 3 / (2 : ℝ) ^ j)
≤ (6 * A0count * (2 * Real.log R)) * (5 / 2) :=
mul_le_mul h3 h5 h4
(mul_nonneg (mul_nonneg (by norm_num : (0 : ℝ) ≤ 6) hA0)
(mul_nonneg (by norm_num : (0 : ℝ) ≤ 2) hlogRnn))
have h7 : (6 : ℝ) * A0count * (2 * Real.log R) * (5 / 2) = 30 * A0count * Real.log R := by
ring
rw [h7] at h6
exact h6
-- assembly via dyadic_family_le
have hmain := dyadic_family_le FS (fun ρ => ‖(ρ : ℂ)‖) J
(fun ρ => ‖seriesTerm s ρ‖) 2
(fun j => 3 * A0count * ((2 : ℝ) ^ j + 3) * Real.log (3 * (2 : ℝ) ^ (j + 1) + 5))
(by norm_num) hdj hterm hcount
calc ∑ ρ ∈ FS, ‖seriesTerm s ρ‖
≤ ∑ j ∈ Finset.Ico 1 (J + 1), (2 / (2 : ℝ) ^ j) *
(3 * A0count * ((2 : ℝ) ^ j + 3) * Real.log (3 * (2 : ℝ) ^ (j + 1) + 5)) := hmain
_ ≤ ∑ j ∈ Finset.Ico 1 (J + 1), 30 * A0count * Real.log R := Finset.sum_le_sum hper
_ = (J : ℝ) * (30 * A0count * Real.log R) := by
rw [Finset.sum_const, Nat.card_Ico, Nat.add_sub_cancel, nsmul_eq_mul]
_ ≤ 60 * A0count * (Real.log R) ^ 2 := by
have hA0 := A0count_pos.le
have h1 : (J : ℝ) * (30 * A0count * Real.log R)
≤ (2 * Real.log R) * (30 * A0count * Real.log R) :=
mul_le_mul_of_nonneg_right hJle
(mul_nonneg (mul_nonneg (by norm_num : (0 : ℝ) ≤ 30) hA0) hlogRnn)
have h2 : (2 * Real.log R) * (30 * A0count * Real.log R)
= 60 * A0count * (Real.log R) ^ 2 := by ring
rw [h2] at h1
exact h1
/-! ## 8b. The inner-high and upper shells -/
/-- **The inner-high shell** (R/2 < ‖ρ‖ ≤ R−2): ≤ 60·A₀·(log R)².
Dyadic in d := R−‖ρ‖ ∈ [2, R/2). -/
lemma shell_inhi {s : ℂ} {R : ℝ} (hs : ‖s‖ = R) (hsz : ¬ IsNontrivialZero s)
(hR : (16002 : ℝ) ≤ R) :
∑ ρ ∈ (circleZeros R).filter (fun ρ : {ρ : ℂ // IsNontrivialZero ρ} =>
¬ ‖(ρ : ℂ)‖ ≤ R / 2 ∧ ‖(ρ : ℂ)‖ ≤ R - 2), ‖seriesTerm s ρ‖
≤ 60 * A0count * (Real.log R) ^ 2 := by
classical
have hRpos : (0 : ℝ) < R := by linarith [hR]
have hlogR : (9 : ℝ) ≤ Real.log R := nine_le_log_of_16002_le hR
have hlogRnn : (0 : ℝ) ≤ Real.log R := by linarith [hlogR]
set J := Nat.log 2 ⌊R⌋₊ with hJ
have hJle : (J : ℝ) ≤ 2 * Real.log R := Nat.log_floor_two_le hR
have h2JR : (2 : ℝ) ^ J ≤ R := two_pow_log_floor_le hR
set FS := (circleZeros R).filter (fun ρ : {ρ : ℂ // IsNontrivialZero ρ} =>
¬ ‖(ρ : ℂ)‖ ≤ R / 2 ∧ ‖(ρ : ℂ)‖ ≤ R - 2) with hFS
have hdj : ∀ ρ ∈ FS,
1 ≤ Nat.log 2 ⌊R - ‖(ρ : ℂ)‖⌋₊ ∧ Nat.log 2 ⌊R - ‖(ρ : ℂ)‖⌋₊ ≤ J := by
intro ρ hρ
rw [hFS, Finset.mem_filter] at hρ
obtain ⟨-, hρR2, hρRm2⟩ := hρ
have hd2 : (2 : ℝ) ≤ R - ‖(ρ : ℂ)‖ := by linarith [hρRm2]
have hfl2 : (2 : ℕ) ≤ ⌊R - ‖(ρ : ℂ)‖⌋₊ := by
rw [Nat.le_floor_iff (by linarith [hd2] : (0 : ℝ) ≤ R - ‖(ρ : ℂ)‖)]
exact_mod_cast hd2
have h1 : (1 : ℕ) ≤ Nat.log 2 ⌊R - ‖(ρ : ℂ)‖⌋₊ := by
have h2 := Nat.log_mono_right (b := 2) hfl2
have h3 : Nat.log 2 2 = 1 := by decide
rw [h3] at h2
exact h2
have h2 : Nat.log 2 ⌊R - ‖(ρ : ℂ)‖⌋₊ ≤ J := by
apply Nat.log_mono_right (b := 2)
apply Nat.floor_mono
have hnn : (0 : ℝ) ≤ ‖(ρ : ℂ)‖ := norm_nonneg _
linarith [hnn]
exact ⟨h1, h2⟩
have hterm : ∀ ρ ∈ FS, ‖seriesTerm s ρ‖
≤ 2 * (zeroMult (ρ : ℂ) : ℝ) / (2 : ℝ) ^ (Nat.log 2 ⌊R - ‖(ρ : ℂ)‖⌋₊) := by
intro ρ hρ
rw [hFS, Finset.mem_filter] at hρ
obtain ⟨-, hρR2, hρRm2⟩ := hρ
have hρR2' : (R / 2 : ℝ) < ‖(ρ : ℂ)‖ := lt_of_not_ge hρR2
have hd2 : (2 : ℝ) ≤ R - ‖(ρ : ℂ)‖ := by linarith [hρRm2]
have hpowle : (2 : ℝ) ^ (Nat.log 2 ⌊R - ‖(ρ : ℂ)‖⌋₊) ≤ R - ‖(ρ : ℂ)‖ := by
have hfl : ⌊R - ‖(ρ : ℂ)‖⌋₊ ≠ 0 := by
rw [Ne, Nat.floor_eq_zero]
push Not
linarith [hd2]
have h1 := Nat.pow_log_le_self 2 hfl
have h2 : ((2 ^ Nat.log 2 ⌊R - ‖(ρ : ℂ)‖⌋₊ : ℕ) : ℝ) ≤ (⌊R - ‖(ρ : ℂ)‖⌋₊ : ℝ) := by
exact_mod_cast h1
have h3 : ((2 ^ Nat.log 2 ⌊R - ‖(ρ : ℂ)‖⌋₊ : ℕ) : ℝ)
= (2 : ℝ) ^ (Nat.log 2 ⌊R - ‖(ρ : ℂ)‖⌋₊) := by
push_cast
ring
rw [h3] at h2
have h4 : (⌊R - ‖(ρ : ℂ)‖⌋₊ : ℝ) ≤ R - ‖(ρ : ℂ)‖ :=
Nat.floor_le (by linarith [hd2])
linarith [h2, h4]
have hsr : R - ‖(ρ : ℂ)‖ ≤ ‖s - (ρ : ℂ)‖ := by
have h := abs_norm_sub_norm_le s (ρ : ℂ)
rw [hs, abs_of_nonneg (by linarith [hd2] : (0 : ℝ) ≤ R - ‖(ρ : ℂ)‖)] at h
exact h
have hρpos : (0 : ℝ) < ‖(ρ : ℂ)‖ := by linarith [hρR2', hR]
have hsrpos : (0 : ℝ) < ‖s - (ρ : ℂ)‖ := by linarith [hsr, hd2]
have hid := seriesTerm_norm_eq_div hs hsz ρ
rw [hid]
have hm : (0 : ℝ) ≤ (zeroMult (ρ : ℂ) : ℝ) := Nat.cast_nonneg _
have h1 : R / (‖(ρ : ℂ)‖ * ‖s - (ρ : ℂ)‖)
≤ R / (‖(ρ : ℂ)‖ * (R - ‖(ρ : ℂ)‖)) := by
apply div_le_div_of_nonneg_left hRpos.le (mul_pos hρpos (by linarith [hd2]))
exact mul_le_mul_of_nonneg_left hsr hρpos.le
have h2 : R / (‖(ρ : ℂ)‖ * (R - ‖(ρ : ℂ)‖)) ≤ 2 / (R - ‖(ρ : ℂ)‖) := by
have h5 : R ≤ 2 * ‖(ρ : ℂ)‖ := by linarith [hρR2']
have h2a : R / ‖(ρ : ℂ)‖ ≤ 2 := by
rw [div_le_iff₀ hρpos]
linarith [h5]
rw [show R / (‖(ρ : ℂ)‖ * (R - ‖(ρ : ℂ)‖))
= (R / ‖(ρ : ℂ)‖) / (R - ‖(ρ : ℂ)‖) from by rw [div_div]]
exact div_le_div_of_nonneg_right h2a (by linarith [hd2] : (0 : ℝ) ≤ R - ‖(ρ : ℂ)‖)
have h3 : (2 : ℝ) / (R - ‖(ρ : ℂ)‖) ≤ 2 / (2 : ℝ) ^ (Nat.log 2 ⌊R - ‖(ρ : ℂ)‖⌋₊) := by
apply div_le_div_of_nonneg_left (by norm_num : (0 : ℝ) ≤ 2) (by positivity)
exact hpowle
calc (zeroMult (ρ : ℂ) : ℝ) * (R / (‖(ρ : ℂ)‖ * ‖s - (ρ : ℂ)‖))
≤ (zeroMult (ρ : ℂ) : ℝ) * (R / (‖(ρ : ℂ)‖ * (R - ‖(ρ : ℂ)‖))) :=
mul_le_mul_of_nonneg_left h1 hm
_ ≤ (zeroMult (ρ : ℂ) : ℝ) * (2 / (R - ‖(ρ : ℂ)‖)) :=
mul_le_mul_of_nonneg_left h2 hm
_ ≤ (zeroMult (ρ : ℂ) : ℝ) * (2 / (2 : ℝ) ^ (Nat.log 2 ⌊R - ‖(ρ : ℂ)‖⌋₊)) :=
mul_le_mul_of_nonneg_left h3 hm
_ = 2 * (zeroMult (ρ : ℂ) : ℝ) / (2 : ℝ) ^ (Nat.log 2 ⌊R - ‖(ρ : ℂ)‖⌋₊) := by ring
have hcount : ∀ j : ℕ,
∑ ρ ∈ FS.filter (fun ρ : {ρ : ℂ // IsNontrivialZero ρ} =>
Nat.log 2 ⌊R - ‖(ρ : ℂ)‖⌋₊ = j), (zeroMult (ρ : ℂ) : ℝ)
≤ 3 * A0count * ((2 : ℝ) ^ j + 3) * (2 * Real.log R) := by
intro j
have hRHSnn : (0 : ℝ) ≤ 3 * A0count * ((2 : ℝ) ^ j + 3) * (2 * Real.log R) :=
mul_nonneg (mul_nonneg (mul_nonneg (by norm_num : (0 : ℝ) ≤ 3) A0count_pos.le)
(by positivity)) (mul_nonneg (by norm_num : (0 : ℝ) ≤ 2) hlogRnn)
by_cases hj : j ∈ Finset.Ico 1 (J + 1)
· rw [Finset.mem_Ico] at hj
by_cases hbig : R / 2 ≤ (2 : ℝ) ^ j
· -- the fiber is empty: d ≥ 2^j ≥ R/2 contradicts d < R/2
have hempty : FS.filter (fun ρ : {ρ : ℂ // IsNontrivialZero ρ} =>
Nat.log 2 ⌊R - ‖(ρ : ℂ)‖⌋₊ = j) = ∅ := by
apply Finset.eq_empty_iff_forall_notMem.mpr
intro ρ hρ
rw [Finset.mem_filter] at hρ
obtain ⟨hρF, hρj⟩ := hρ
rw [hFS, Finset.mem_filter] at hρF
obtain ⟨-, hρR2, hρRm2⟩ := hρF
have hρR2' : (R / 2 : ℝ) < ‖(ρ : ℂ)‖ := lt_of_not_ge hρR2
have hd2 : (2 : ℝ) ≤ R - ‖(ρ : ℂ)‖ := by linarith [hρRm2]
have hpowle : (2 : ℝ) ^ j ≤ R - ‖(ρ : ℂ)‖ := by
have hfl : ⌊R - ‖(ρ : ℂ)‖⌋₊ ≠ 0 := by
rw [Ne, Nat.floor_eq_zero]
push Not
linarith [hd2]
have h1 := Nat.pow_log_le_self 2 hfl
rw [hρj] at h1
have h2 : ((2 ^ j : ℕ) : ℝ) ≤ (⌊R - ‖(ρ : ℂ)‖⌋₊ : ℝ) := by exact_mod_cast h1
have h3 : ((2 ^ j : ℕ) : ℝ) = (2 : ℝ) ^ j := by push_cast; ring
rw [h3] at h2
have h4 : (⌊R - ‖(ρ : ℂ)‖⌋₊ : ℝ) ≤ R - ‖(ρ : ℂ)‖ :=
Nat.floor_le (by linarith [hd2])
linarith [h2, h4]
linarith [hpowle, hbig, hρR2']
rw [hempty, Finset.sum_empty]
exact hRHSnn
· push Not at hbig
have hj2 : (2 : ℝ) ≤ (2 : ℝ) ^ j := by
have h1 : (2 : ℝ) ^ 1 ≤ (2 : ℝ) ^ j :=
pow_le_pow_right₀ (by norm_num) (by omega : 1 ≤ j)
linarith [h1]
have hM1 : (1 : ℝ) ≤ max (R - (2 : ℝ) ^ (j + 1) - 1) (R / 2 - 1) := by
have h1 : (1 : ℝ) ≤ R / 2 - 1 := by linarith [hR]
exact le_trans h1 (le_max_right _ _)
have hMb : max (R - (2 : ℝ) ^ (j + 1) - 1) (R / 2 - 1) ≤ R - (2 : ℝ) ^ j := by
apply max_le_iff.mpr
constructor
· have h1 : (2 : ℝ) ^ (j + 1) = 2 * (2 : ℝ) ^ j := by rw [pow_succ']
have h2 : (0 : ℝ) < (2 : ℝ) ^ j := by positivity
linarith [h1, h2]
· linarith [hbig]
have hsub : ∀ ρ ∈ FS.filter (fun ρ : {ρ : ℂ // IsNontrivialZero ρ} =>
Nat.log 2 ⌊R - ‖(ρ : ℂ)‖⌋₊ = j),
R - (2 : ℝ) ^ (j + 1) - 1 ≤ |(ρ : ℂ).im| ∧ |(ρ : ℂ).im| ≤ R - (2 : ℝ) ^ j ∧
R / 2 - 1 ≤ |(ρ : ℂ).im| := by
intro ρ hρ
rw [Finset.mem_filter] at hρ
obtain ⟨hρF, hρj⟩ := hρ
rw [hFS, Finset.mem_filter] at hρF
obtain ⟨-, hρR2, hρRm2⟩ := hρF
have hρR2' : (R / 2 : ℝ) < ‖(ρ : ℂ)‖ := lt_of_not_ge hρR2
have hd2 : (2 : ℝ) ≤ R - ‖(ρ : ℂ)‖ := by linarith [hρRm2]
have hpowle : (2 : ℝ) ^ j ≤ R - ‖(ρ : ℂ)‖ := by
have hfl : ⌊R - ‖(ρ : ℂ)‖⌋₊ ≠ 0 := by
rw [Ne, Nat.floor_eq_zero]
push Not
linarith [hd2]
have h1 := Nat.pow_log_le_self 2 hfl
rw [hρj] at h1
have h2 : ((2 ^ j : ℕ) : ℝ) ≤ (⌊R - ‖(ρ : ℂ)‖⌋₊ : ℝ) := by exact_mod_cast h1
have h3 : ((2 ^ j : ℕ) : ℝ) = (2 : ℝ) ^ j := by push_cast; ring
rw [h3] at h2
have h4 : (⌊R - ‖(ρ : ℂ)‖⌋₊ : ℝ) ≤ R - ‖(ρ : ℂ)‖ :=
Nat.floor_le (by linarith [hd2])
linarith [h2, h4]
have hpowup : R - ‖(ρ : ℂ)‖ < (2 : ℝ) ^ (j + 1) := by
have h1 : ⌊R - ‖(ρ : ℂ)‖⌋₊ < 2 ^ (Nat.log 2 ⌊R - ‖(ρ : ℂ)‖⌋₊ + 1) :=
Nat.lt_pow_succ_log_self (by norm_num) _
rw [hρj] at h1
have h2 : ⌊R - ‖(ρ : ℂ)‖⌋₊ + 1 ≤ 2 ^ (j + 1) := h1
have h3 : R - ‖(ρ : ℂ)‖ < (⌊R - ‖(ρ : ℂ)‖⌋₊ : ℝ) + 1 := Nat.lt_floor_add_one _
have h4 : ((⌊R - ‖(ρ : ℂ)‖⌋₊ + 1 : ℕ) : ℝ) ≤ ((2 ^ (j + 1) : ℕ) : ℝ) := by
exact_mod_cast h2
have h5 : ((2 ^ (j + 1) : ℕ) : ℝ) = (2 : ℝ) ^ (j + 1) := by push_cast; ring
rw [h5] at h4
push_cast at h4
linarith [h3, h4]
have him1 := abs_im_ge_norm_sub_one ρ
have him2 : |(ρ : ℂ).im| ≤ ‖(ρ : ℂ)‖ := abs_im_le_norm _
exact ⟨by linarith [him1, hpowup], by linarith [him2, hpowle],
by linarith [him1, hρR2']⟩
have hbrick := sum_zeroMult_le_of_im_band
(FS.filter (fun ρ : {ρ : ℂ // IsNontrivialZero ρ} =>
Nat.log 2 ⌊R - ‖(ρ : ℂ)‖⌋₊ = j)) hM1 hMb hsub
have hab : R - (2 : ℝ) ^ j - (R - (2 : ℝ) ^ (j + 1) - 1) + 2 = (2 : ℝ) ^ j + 3 := by
have h1 : (2 : ℝ) ^ (j + 1) = 2 * (2 : ℝ) ^ j := by rw [pow_succ']
linarith [h1]
rw [hab] at hbrick
-- the log bound: max|a||b| ≤ 3R
have hmaxle : max |R - (2 : ℝ) ^ (j + 1) - 1| |R - (2 : ℝ) ^ j| ≤ 3 * R := by
have h1 : |R - (2 : ℝ) ^ j| = R - (2 : ℝ) ^ j := by
apply abs_of_nonneg
have h2 : (2 : ℝ) ^ j ≤ (2 : ℝ) ^ J :=
pow_le_pow_right₀ (by norm_num) (by omega : j ≤ J)
linarith [h2, h2JR, hbig]
have h2 : |R - (2 : ℝ) ^ (j + 1) - 1| ≤ 3 * R := by
have h3 : (2 : ℝ) ^ (j + 1) = 2 * (2 : ℝ) ^ j := by rw [pow_succ']
have h4 : (2 : ℝ) ^ j ≤ (2 : ℝ) ^ J :=
pow_le_pow_right₀ (by norm_num) (by omega : j ≤ J)
have h5 : R - (2 : ℝ) ^ (j + 1) - 1 ≤ R := by
have h6 : (0 : ℝ) < (2 : ℝ) ^ (j + 1) := by positivity
linarith [h6]
have h6 : (2 : ℝ) ^ (j + 1) - 1 ≤ 2 * R + 1 := by
nlinarith [h3, h4, h2JR, hR]
rw [abs_le]
constructor <;> linarith [h5, h6, hR]
have h3 : |R - (2 : ℝ) ^ j| ≤ 3 * R := by
rw [h1]
have h4 : (0 : ℝ) < (2 : ℝ) ^ j := by positivity
linarith [h4, hR]
exact max_le h2 h3
have hlogle : Real.log (3 * max |R - (2 : ℝ) ^ (j + 1) - 1| |R - (2 : ℝ) ^ j| + 5)
≤ 2 * Real.log R :=
log_three_le_two_log hR (le_trans (abs_nonneg _) (le_max_left _ _)) hmaxle
exact hbrick.trans (mul_le_mul_of_nonneg_left hlogle
(mul_nonneg (mul_nonneg (by norm_num : (0 : ℝ) ≤ 3) A0count_pos.le)
(by positivity)))
· have hempty : FS.filter (fun ρ : {ρ : ℂ // IsNontrivialZero ρ} =>
Nat.log 2 ⌊R - ‖(ρ : ℂ)‖⌋₊ = j) = ∅ := by
apply Finset.eq_empty_iff_forall_notMem.mpr
intro ρ hρ
rw [Finset.mem_filter] at hρ
obtain ⟨hρF, hρj⟩ := hρ
have hdjρ := hdj ρ hρF
rw [hρj] at hdjρ
rw [Finset.mem_Ico] at hj
omega
rw [hempty, Finset.sum_empty]
exact hRHSnn
-- the closed-form per-shell bound
have hper : ∀ j ∈ Finset.Ico 1 (J + 1),
(2 / (2 : ℝ) ^ j) * (3 * A0count * ((2 : ℝ) ^ j + 3) * (2 * Real.log R))
≤ 30 * A0count * Real.log R := by
intro j hj
rw [Finset.mem_Ico] at hj
have h2j0 : (0 : ℝ) < (2 : ℝ) ^ j := by positivity
have hj2 : (2 : ℝ) ≤ (2 : ℝ) ^ j := by
have h1 : (2 : ℝ) ^ 1 ≤ (2 : ℝ) ^ j :=
pow_le_pow_right₀ (by norm_num) (by omega : 1 ≤ j)
linarith [h1]
have hA0 := A0count_pos.le
have h1 : (2 / (2 : ℝ) ^ j) * (3 * A0count * ((2 : ℝ) ^ j + 3) * (2 * Real.log R))
= 12 * A0count * Real.log R * (1 + 3 / (2 : ℝ) ^ j) := by
field_simp
ring
rw [h1]
have h2 : 3 / (2 : ℝ) ^ j ≤ 3 / 2 := by
apply div_le_div_of_nonneg_left (by norm_num : (0 : ℝ) ≤ 3) (by norm_num) hj2
have h3 : (0 : ℝ) ≤ 1 + 3 / (2 : ℝ) ^ j := by
have h4 : (0 : ℝ) ≤ 3 / (2 : ℝ) ^ j := div_nonneg (by norm_num) h2j0.le
linarith [h4]
have h4 : (1 : ℝ) + 3 / (2 : ℝ) ^ j ≤ 5 / 2 := by linarith [h2]
have h5 : (12 : ℝ) * A0count * Real.log R * (1 + 3 / (2 : ℝ) ^ j)
≤ (12 * A0count * Real.log R) * (5 / 2) :=
mul_le_mul_of_nonneg_left h4
(mul_nonneg (mul_nonneg (by norm_num : (0 : ℝ) ≤ 12) hA0) hlogRnn)
have h6 : (12 : ℝ) * A0count * Real.log R * (5 / 2) = 30 * A0count * Real.log R := by
ring
rw [h6] at h5
exact h5
-- assembly via dyadic_family_le
have hmain := dyadic_family_le FS (fun ρ => R - ‖(ρ : ℂ)‖) J
(fun ρ => ‖seriesTerm s ρ‖) 2
(fun j => 3 * A0count * ((2 : ℝ) ^ j + 3) * (2 * Real.log R))
(by norm_num) hdj hterm hcount
calc ∑ ρ ∈ FS, ‖seriesTerm s ρ‖
≤ ∑ j ∈ Finset.Ico 1 (J + 1), (2 / (2 : ℝ) ^ j) *
(3 * A0count * ((2 : ℝ) ^ j + 3) * (2 * Real.log R)) := hmain
_ ≤ ∑ j ∈ Finset.Ico 1 (J + 1), 30 * A0count * Real.log R := Finset.sum_le_sum hper
_ = (J : ℝ) * (30 * A0count * Real.log R) := by
rw [Finset.sum_const, Nat.card_Ico, Nat.add_sub_cancel, nsmul_eq_mul]
_ ≤ 60 * A0count * (Real.log R) ^ 2 := by
have hA0 := A0count_pos.le
have h1 : (J : ℝ) * (30 * A0count * Real.log R)
≤ (2 * Real.log R) * (30 * A0count * Real.log R) :=
mul_le_mul_of_nonneg_right hJle
(mul_nonneg (mul_nonneg (by norm_num : (0 : ℝ) ≤ 30) hA0) hlogRnn)
have h2 : (2 * Real.log R) * (30 * A0count * Real.log R)
= 60 * A0count * (Real.log R) ^ 2 := by ring
rw [h2] at h1
exact h1
/-- **The upper shell** (R+2 ≤ ‖ρ‖, within the finite part): ≤
45·A₀·(log R)². Dyadic in u := ‖ρ‖−R ∈ [2, R+1); the dyadic class can
reach J+1 (⌊u⌋₊ can be ⌊R⌋₊+1), so the shell count is J+1 ≤ 3·log R. -/
lemma shell_up {s : ℂ} {R : ℝ} (hs : ‖s‖ = R) (hsz : ¬ IsNontrivialZero s)
(hR : (16002 : ℝ) ≤ R) :
∑ ρ ∈ (circleZeros R).filter (fun ρ : {ρ : ℂ // IsNontrivialZero ρ} =>
¬ ‖(ρ : ℂ)‖ < R + 2), ‖seriesTerm s ρ‖
≤ 45 * A0count * (Real.log R) ^ 2 := by
classical
have hRpos : (0 : ℝ) < R := by linarith [hR]
have hlogR : (9 : ℝ) ≤ Real.log R := nine_le_log_of_16002_le hR
have hlogRnn : (0 : ℝ) ≤ Real.log R := by linarith [hlogR]
set J := Nat.log 2 ⌊R⌋₊ with hJ
have hJle : (J : ℝ) ≤ 2 * Real.log R := Nat.log_floor_two_le hR
have h2JR : (2 : ℝ) ^ J ≤ R := two_pow_log_floor_le hR
set FS := (circleZeros R).filter (fun ρ : {ρ : ℂ // IsNontrivialZero ρ} =>
¬ ‖(ρ : ℂ)‖ < R + 2) with hFS
have hdj : ∀ ρ ∈ FS,
1 ≤ Nat.log 2 ⌊‖(ρ : ℂ)‖ - R⌋₊ ∧ Nat.log 2 ⌊‖(ρ : ℂ)‖ - R⌋₊ ≤ J + 1 := by
intro ρ hρ
rw [hFS, Finset.mem_filter] at hρ
obtain ⟨hρcirc, hρR2⟩ := hρ
have hρR2' : (R + 2 : ℝ) ≤ ‖(ρ : ℂ)‖ := le_of_not_gt hρR2
have hu2 : (2 : ℝ) ≤ ‖(ρ : ℂ)‖ - R := by linarith [hρR2']
have hρup : ‖(ρ : ℂ)‖ < 2 * R + 1 := by
rw [mem_circleZeros] at hρcirc
exact hρcirc
have hfl2 : (2 : ℕ) ≤ ⌊‖(ρ : ℂ)‖ - R⌋₊ := by
rw [Nat.le_floor_iff (by linarith [hu2] : (0 : ℝ) ≤ ‖(ρ : ℂ)‖ - R)]
exact_mod_cast hu2
have h1 : (1 : ℕ) ≤ Nat.log 2 ⌊‖(ρ : ℂ)‖ - R⌋₊ := by
have h2 := Nat.log_mono_right (b := 2) hfl2
have h3 : Nat.log 2 2 = 1 := by decide
rw [h3] at h2
exact h2
have h2 : Nat.log 2 ⌊‖(ρ : ℂ)‖ - R⌋₊ ≤ J + 1 := by
have hpowle : (2 : ℝ) ^ (Nat.log 2 ⌊‖(ρ : ℂ)‖ - R⌋₊) ≤ ‖(ρ : ℂ)‖ - R := by
have hfl : ⌊‖(ρ : ℂ)‖ - R⌋₊ ≠ 0 := by
rw [Ne, Nat.floor_eq_zero]
push Not
linarith [hu2]
have h1 := Nat.pow_log_le_self 2 hfl
have h2 : ((2 ^ Nat.log 2 ⌊‖(ρ : ℂ)‖ - R⌋₊ : ℕ) : ℝ) ≤ (⌊‖(ρ : ℂ)‖ - R⌋₊ : ℝ) := by
exact_mod_cast h1
have h3 : ((2 ^ Nat.log 2 ⌊‖(ρ : ℂ)‖ - R⌋₊ : ℕ) : ℝ)
= (2 : ℝ) ^ (Nat.log 2 ⌊‖(ρ : ℂ)‖ - R⌋₊) := by
push_cast
ring
rw [h3] at h2
have h4 : (⌊‖(ρ : ℂ)‖ - R⌋₊ : ℝ) ≤ ‖(ρ : ℂ)‖ - R :=
Nat.floor_le (by linarith [hu2])
linarith [h2, h4]
have h2J1 : R < (2 : ℝ) ^ (J + 1) := by
have h1 : ⌊R⌋₊ < 2 ^ (J + 1) := Nat.lt_pow_succ_log_self (by norm_num) _
have h2 : R < (⌊R⌋₊ : ℝ) + 1 := Nat.lt_floor_add_one _
have h5 : (⌊R⌋₊ : ℝ) + 1 ≤ (2 : ℝ) ^ (J + 1) := by
have h6 : ((⌊R⌋₊ + 1 : ℕ) : ℝ) ≤ ((2 ^ (J + 1) : ℕ) : ℝ) := by exact_mod_cast h1
have h7 : ((2 ^ (J + 1) : ℕ) : ℝ) = (2 : ℝ) ^ (J + 1) := by push_cast; ring
rw [h7] at h6
push_cast at h6
linarith [h6]
linarith [h2, h5]
by_contra hcon
push Not at hcon
have h55 : J + 2 ≤ Nat.log 2 ⌊‖(ρ : ℂ)‖ - R⌋₊ := by omega
have h66 : (2 : ℝ) ^ (J + 2) ≤ (2 : ℝ) ^ (Nat.log 2 ⌊‖(ρ : ℂ)‖ - R⌋₊) :=
pow_le_pow_right₀ (by norm_num) h55
have h77 : (2 : ℝ) ^ (J + 2) = 2 * (2 : ℝ) ^ (J + 1) := by rw [pow_succ']
linarith [hpowle, hρup, h2J1, h66, h77, hR]
exact ⟨h1, h2⟩
have hterm : ∀ ρ ∈ FS, ‖seriesTerm s ρ‖
≤ 1 * (zeroMult (ρ : ℂ) : ℝ) / (2 : ℝ) ^ (Nat.log 2 ⌊‖(ρ : ℂ)‖ - R⌋₊) := by
intro ρ hρ
rw [hFS, Finset.mem_filter] at hρ
obtain ⟨hρcirc, hρR2⟩ := hρ
have hρR2' : (R + 2 : ℝ) ≤ ‖(ρ : ℂ)‖ := le_of_not_gt hρR2
have hu2 : (2 : ℝ) ≤ ‖(ρ : ℂ)‖ - R := by linarith [hρR2']
have hpowle : (2 : ℝ) ^ (Nat.log 2 ⌊‖(ρ : ℂ)‖ - R⌋₊) ≤ ‖(ρ : ℂ)‖ - R := by
have hfl : ⌊‖(ρ : ℂ)‖ - R⌋₊ ≠ 0 := by
rw [Ne, Nat.floor_eq_zero]
push Not
linarith [hu2]
have h1 := Nat.pow_log_le_self 2 hfl
have h2 : ((2 ^ Nat.log 2 ⌊‖(ρ : ℂ)‖ - R⌋₊ : ℕ) : ℝ) ≤ (⌊‖(ρ : ℂ)‖ - R⌋₊ : ℝ) := by
exact_mod_cast h1
have h3 : ((2 ^ Nat.log 2 ⌊‖(ρ : ℂ)‖ - R⌋₊ : ℕ) : ℝ)
= (2 : ℝ) ^ (Nat.log 2 ⌊‖(ρ : ℂ)‖ - R⌋₊) := by
push_cast
ring
rw [h3] at h2
have h4 : (⌊‖(ρ : ℂ)‖ - R⌋₊ : ℝ) ≤ ‖(ρ : ℂ)‖ - R :=
Nat.floor_le (by linarith [hu2])
linarith [h2, h4]
have hsr : ‖(ρ : ℂ)‖ - R ≤ ‖s - (ρ : ℂ)‖ := by
have h := abs_norm_sub_norm_le s (ρ : ℂ)
rw [hs, abs_of_nonpos (by linarith [hρR2', hR] : R - ‖(ρ : ℂ)‖ ≤ 0)] at h
have h1 : -(R - ‖(ρ : ℂ)‖) = ‖(ρ : ℂ)‖ - R := by ring
rw [h1] at h
exact h
have hρpos : (0 : ℝ) < ‖(ρ : ℂ)‖ := by linarith [hρR2', hR]
have hsrpos : (0 : ℝ) < ‖s - (ρ : ℂ)‖ := by linarith [hsr, hu2]
have hid := seriesTerm_norm_eq_div hs hsz ρ
rw [hid]
have hm : (0 : ℝ) ≤ (zeroMult (ρ : ℂ) : ℝ) := Nat.cast_nonneg _
have h1 : R / (‖(ρ : ℂ)‖ * ‖s - (ρ : ℂ)‖)
≤ R / (‖(ρ : ℂ)‖ * (‖(ρ : ℂ)‖ - R)) := by
apply div_le_div_of_nonneg_left hRpos.le (mul_pos hρpos (by linarith [hu2]))
exact mul_le_mul_of_nonneg_left hsr hρpos.le
have h2a : R / ‖(ρ : ℂ)‖ ≤ 1 := by
rw [div_le_iff₀ hρpos]
linarith [hρR2', hR]
have h2 : R / (‖(ρ : ℂ)‖ * (‖(ρ : ℂ)‖ - R)) ≤ 1 / (‖(ρ : ℂ)‖ - R) := by
rw [show R / (‖(ρ : ℂ)‖ * (‖(ρ : ℂ)‖ - R))
= (R / ‖(ρ : ℂ)‖) / (‖(ρ : ℂ)‖ - R) from by rw [div_div]]
exact div_le_div_of_nonneg_right h2a (by linarith [hu2] : (0 : ℝ) ≤ ‖(ρ : ℂ)‖ - R)
have h3 : (1 : ℝ) / (‖(ρ : ℂ)‖ - R) ≤ 1 / (2 : ℝ) ^ (Nat.log 2 ⌊‖(ρ : ℂ)‖ - R⌋₊) := by
apply div_le_div_of_nonneg_left (by norm_num : (0 : ℝ) ≤ 1) (by positivity)
exact hpowle
calc (zeroMult (ρ : ℂ) : ℝ) * (R / (‖(ρ : ℂ)‖ * ‖s - (ρ : ℂ)‖))
≤ (zeroMult (ρ : ℂ) : ℝ) * (R / (‖(ρ : ℂ)‖ * (‖(ρ : ℂ)‖ - R))) :=
mul_le_mul_of_nonneg_left h1 hm
_ ≤ (zeroMult (ρ : ℂ) : ℝ) * (1 / (‖(ρ : ℂ)‖ - R)) :=
mul_le_mul_of_nonneg_left h2 hm
_ ≤ (zeroMult (ρ : ℂ) : ℝ) * (1 / (2 : ℝ) ^ (Nat.log 2 ⌊‖(ρ : ℂ)‖ - R⌋₊)) :=
mul_le_mul_of_nonneg_left h3 hm
_ = 1 * (zeroMult (ρ : ℂ) : ℝ) / (2 : ℝ) ^ (Nat.log 2 ⌊‖(ρ : ℂ)‖ - R⌋₊) := by ring
have hcount : ∀ j : ℕ,
∑ ρ ∈ FS.filter (fun ρ : {ρ : ℂ // IsNontrivialZero ρ} =>
Nat.log 2 ⌊‖(ρ : ℂ)‖ - R⌋₊ = j), (zeroMult (ρ : ℂ) : ℝ)
≤ 3 * A0count * ((2 : ℝ) ^ j + 3) * (2 * Real.log R) := by
intro j
have hRHSnn : (0 : ℝ) ≤ 3 * A0count * ((2 : ℝ) ^ j + 3) * (2 * Real.log R) :=
mul_nonneg (mul_nonneg (mul_nonneg (by norm_num : (0 : ℝ) ≤ 3) A0count_pos.le)
(by positivity)) (mul_nonneg (by norm_num : (0 : ℝ) ≤ 2) hlogRnn)
by_cases hj : j ∈ Finset.Ico 1 (J + 1 + 1)
· rw [Finset.mem_Ico] at hj
have hM1 : (1 : ℝ) ≤ max (R + (2 : ℝ) ^ j - 1) (R + 1) := by
have h1 : (1 : ℝ) ≤ R + 1 := by linarith [hR]
exact le_trans h1 (le_max_right _ _)
have hMb : max (R + (2 : ℝ) ^ j - 1) (R + 1) ≤ R + (2 : ℝ) ^ (j + 1) := by
apply max_le_iff.mpr
constructor
· have h1 : (2 : ℝ) ^ (j + 1) = 2 * (2 : ℝ) ^ j := by rw [pow_succ']
have h2 : (0 : ℝ) < (2 : ℝ) ^ j := by positivity
linarith [h1, h2]
· have h1 : (2 : ℝ) ^ (j + 1) = 2 * (2 : ℝ) ^ j := by rw [pow_succ']
have h2 : (1 : ℝ) ≤ (2 : ℝ) ^ j := by exact_mod_cast Nat.one_le_two_pow
linarith [h1, h2]
have hsub : ∀ ρ ∈ FS.filter (fun ρ : {ρ : ℂ // IsNontrivialZero ρ} =>
Nat.log 2 ⌊‖(ρ : ℂ)‖ - R⌋₊ = j),
R + (2 : ℝ) ^ j - 1 ≤ |(ρ : ℂ).im| ∧ |(ρ : ℂ).im| ≤ R + (2 : ℝ) ^ (j + 1) ∧
R + 1 ≤ |(ρ : ℂ).im| := by
intro ρ hρ
rw [Finset.mem_filter] at hρ
obtain ⟨hρF, hρj⟩ := hρ
rw [hFS, Finset.mem_filter] at hρF
obtain ⟨hρcirc, hρR2⟩ := hρF
have hρR2' : (R + 2 : ℝ) ≤ ‖(ρ : ℂ)‖ := le_of_not_gt hρR2
have hu2 : (2 : ℝ) ≤ ‖(ρ : ℂ)‖ - R := by linarith [hρR2']
have hpowle : (2 : ℝ) ^ j ≤ ‖(ρ : ℂ)‖ - R := by
have hfl : ⌊‖(ρ : ℂ)‖ - R⌋₊ ≠ 0 := by
rw [Ne, Nat.floor_eq_zero]
push Not
linarith [hu2]
have h1 := Nat.pow_log_le_self 2 hfl
rw [hρj] at h1
have h2 : ((2 ^ j : ℕ) : ℝ) ≤ (⌊‖(ρ : ℂ)‖ - R⌋₊ : ℝ) := by exact_mod_cast h1
have h3 : ((2 ^ j : ℕ) : ℝ) = (2 : ℝ) ^ j := by push_cast; ring
rw [h3] at h2
have h4 : (⌊‖(ρ : ℂ)‖ - R⌋₊ : ℝ) ≤ ‖(ρ : ℂ)‖ - R :=
Nat.floor_le (by linarith [hu2])
linarith [h2, h4]
have hpowup : ‖(ρ : ℂ)‖ - R < (2 : ℝ) ^ (j + 1) := by
have h1 : ⌊‖(ρ : ℂ)‖ - R⌋₊ < 2 ^ (Nat.log 2 ⌊‖(ρ : ℂ)‖ - R⌋₊ + 1) :=
Nat.lt_pow_succ_log_self (by norm_num) _
rw [hρj] at h1
have h2 : ⌊‖(ρ : ℂ)‖ - R⌋₊ + 1 ≤ 2 ^ (j + 1) := h1
have h3 : ‖(ρ : ℂ)‖ - R < (⌊‖(ρ : ℂ)‖ - R⌋₊ : ℝ) + 1 := Nat.lt_floor_add_one _
have h4 : ((⌊‖(ρ : ℂ)‖ - R⌋₊ + 1 : ℕ) : ℝ) ≤ ((2 ^ (j + 1) : ℕ) : ℝ) := by
exact_mod_cast h2
have h5 : ((2 ^ (j + 1) : ℕ) : ℝ) = (2 : ℝ) ^ (j + 1) := by push_cast; ring
rw [h5] at h4
push_cast at h4
linarith [h3, h4]
have him1 := abs_im_ge_norm_sub_one ρ
have him2 : |(ρ : ℂ).im| ≤ ‖(ρ : ℂ)‖ := abs_im_le_norm _
exact ⟨by linarith [him1, hpowle], by linarith [him2, hpowup],
by linarith [him1, hρR2', hR]⟩
have hbrick := sum_zeroMult_le_of_im_band
(FS.filter (fun ρ : {ρ : ℂ // IsNontrivialZero ρ} =>
Nat.log 2 ⌊‖(ρ : ℂ)‖ - R⌋₊ = j)) hM1 hMb hsub
have hab : R + (2 : ℝ) ^ (j + 1) - (R + (2 : ℝ) ^ j - 1) + 2 = (2 : ℝ) ^ j + 3 := by
have h1 : (2 : ℝ) ^ (j + 1) = 2 * (2 : ℝ) ^ j := by rw [pow_succ']
linarith [h1]
rw [hab] at hbrick
-- the log bound: max|a||b| = b ≤ 5R ⟹ log(3b+5) ≤ log(16R) ≤ 2L
have h2j4R : (2 : ℝ) ^ (j + 1) ≤ 4 * R := by
have h1 : (2 : ℝ) ^ (j + 1) = 2 * (2 : ℝ) ^ j := by rw [pow_succ']
have h2 : (2 : ℝ) ^ j ≤ (2 : ℝ) ^ (J + 1) :=
pow_le_pow_right₀ (by norm_num) (by omega : j ≤ J + 1)
have h3 : (2 : ℝ) ^ (J + 1) = 2 * (2 : ℝ) ^ J := by rw [pow_succ']
nlinarith [h1, h2, h3, h2JR, hR]
have hb5 : R + (2 : ℝ) ^ (j + 1) ≤ 5 * R := by linarith [h2j4R, hR]
have hmaxb : max |R + (2 : ℝ) ^ j - 1| |R + (2 : ℝ) ^ (j + 1)| = R + (2 : ℝ) ^ (j + 1) := by
have h1 : |R + (2 : ℝ) ^ (j + 1)| = R + (2 : ℝ) ^ (j + 1) :=
abs_of_nonneg (by positivity)
have h2 : |R + (2 : ℝ) ^ j - 1| = R + (2 : ℝ) ^ j - 1 := by
apply abs_of_nonneg
have h3 : (1 : ℝ) ≤ (2 : ℝ) ^ j := by exact_mod_cast Nat.one_le_two_pow
linarith [h3, hR]
rw [h1, h2]
have h3 : (2 : ℝ) ^ (j + 1) = 2 * (2 : ℝ) ^ j := by rw [pow_succ']
have h4 : (0 : ℝ) < (2 : ℝ) ^ j := by positivity
exact max_eq_right (by linarith [h3, h4, hR])
have hlogle : Real.log (3 * max |R + (2 : ℝ) ^ j - 1| |R + (2 : ℝ) ^ (j + 1)| + 5)
≤ 2 * Real.log R := by
rw [hmaxb]
have h1 : Real.log (3 * (R + (2 : ℝ) ^ (j + 1)) + 5) ≤ Real.log (16 * R) := by
apply Real.log_le_log (by positivity)
linarith [hb5, hR]
have h2 : Real.log (16 * R) = Real.log 16 + Real.log R :=
Real.log_mul (by norm_num : (16 : ℝ) ≠ 0) (by linarith [hR] : R ≠ 0)
have h3 : Real.log 16 = 4 * Real.log 2 := by
rw [show (16 : ℝ) = 2 ^ 4 by norm_num, Real.log_pow]
push_cast
ring
have h4 := log_two_le_one
linarith [h1, h2, h3, h4, hlogR]
exact hbrick.trans (mul_le_mul_of_nonneg_left hlogle
(mul_nonneg (mul_nonneg (by norm_num : (0 : ℝ) ≤ 3) A0count_pos.le)
(by positivity)))
· have hempty : FS.filter (fun ρ : {ρ : ℂ // IsNontrivialZero ρ} =>
Nat.log 2 ⌊‖(ρ : ℂ)‖ - R⌋₊ = j) = ∅ := by
apply Finset.eq_empty_iff_forall_notMem.mpr
intro ρ hρ
rw [Finset.mem_filter] at hρ
obtain ⟨hρF, hρj⟩ := hρ
have hdjρ := hdj ρ hρF
rw [hρj] at hdjρ
rw [Finset.mem_Ico] at hj
omega
rw [hempty, Finset.sum_empty]
exact hRHSnn
-- the closed-form per-shell bound
have hper : ∀ j ∈ Finset.Ico 1 (J + 1 + 1),
(1 / (2 : ℝ) ^ j) * (3 * A0count * ((2 : ℝ) ^ j + 3) * (2 * Real.log R))
≤ 15 * A0count * Real.log R := by
intro j hj
rw [Finset.mem_Ico] at hj
have h2j0 : (0 : ℝ) < (2 : ℝ) ^ j := by positivity
have hj2 : (2 : ℝ) ≤ (2 : ℝ) ^ j := by
have h1 : (2 : ℝ) ^ 1 ≤ (2 : ℝ) ^ j :=
pow_le_pow_right₀ (by norm_num) (by omega : 1 ≤ j)
linarith [h1]
have hA0 := A0count_pos.le
have h1 : (1 / (2 : ℝ) ^ j) * (3 * A0count * ((2 : ℝ) ^ j + 3) * (2 * Real.log R))
= 6 * A0count * Real.log R * (1 + 3 / (2 : ℝ) ^ j) := by
field_simp
ring
rw [h1]
have h2 : 3 / (2 : ℝ) ^ j ≤ 3 / 2 := by
apply div_le_div_of_nonneg_left (by norm_num : (0 : ℝ) ≤ 3) (by norm_num) hj2
have h3 : (0 : ℝ) ≤ 1 + 3 / (2 : ℝ) ^ j := by
have h4 : (0 : ℝ) ≤ 3 / (2 : ℝ) ^ j := div_nonneg (by norm_num) h2j0.le
linarith [h4]
have h4 : (1 : ℝ) + 3 / (2 : ℝ) ^ j ≤ 5 / 2 := by linarith [h2]
have h5 : (6 : ℝ) * A0count * Real.log R * (1 + 3 / (2 : ℝ) ^ j)
≤ (6 * A0count * Real.log R) * (5 / 2) :=
mul_le_mul_of_nonneg_left h4
(mul_nonneg (mul_nonneg (by norm_num : (0 : ℝ) ≤ 6) hA0) hlogRnn)
have h6 : (6 : ℝ) * A0count * Real.log R * (5 / 2) = 15 * A0count * Real.log R := by
ring
rw [h6] at h5
exact h5
-- assembly via dyadic_family_le (J' := J+1)
have hmain := dyadic_family_le FS (fun ρ => ‖(ρ : ℂ)‖ - R) (J + 1)
(fun ρ => ‖seriesTerm s ρ‖) 1
(fun j => 3 * A0count * ((2 : ℝ) ^ j + 3) * (2 * Real.log R))
(by norm_num) hdj hterm hcount
calc ∑ ρ ∈ FS, ‖seriesTerm s ρ‖
≤ ∑ j ∈ Finset.Ico 1 (J + 1 + 1), (1 / (2 : ℝ) ^ j) *
(3 * A0count * ((2 : ℝ) ^ j + 3) * (2 * Real.log R)) := hmain
_ ≤ ∑ j ∈ Finset.Ico 1 (J + 1 + 1), 15 * A0count * Real.log R := Finset.sum_le_sum hper
_ = ((J + 1 : ℕ) : ℝ) * (15 * A0count * Real.log R) := by
rw [Finset.sum_const, Nat.card_Ico, Nat.add_sub_cancel, nsmul_eq_mul]
_ ≤ 45 * A0count * (Real.log R) ^ 2 := by
have hA0 := A0count_pos.le
have hJ1 : ((J + 1 : ℕ) : ℝ) ≤ 3 * Real.log R := by
have h1 : ((J + 1 : ℕ) : ℝ) = (J : ℝ) + 1 := by push_cast; ring
linarith [hJle, hlogR]
have h1 : ((J + 1 : ℕ) : ℝ) * (15 * A0count * Real.log R)
≤ (3 * Real.log R) * (15 * A0count * Real.log R) :=
mul_le_mul_of_nonneg_right hJ1
(mul_nonneg (mul_nonneg (by norm_num : (0 : ℝ) ≤ 15) hA0) hlogRnn)
have h2 : (3 * Real.log R) * (15 * A0count * Real.log R)
= 45 * A0count * (Real.log R) ^ 2 := by ring
rw [h2] at h1
exact h1
/-! ## 9. The critical shell and the assembly (5e-v-b chunk 3c-iii)
`norm_circle_sub_abs_im_le`: on ‖s‖ = R, R−|im s| = re²/(R+|im|) ≤ B/R
when re² ≤ B. `shell_crit`: the critical annulus (R−2 < ‖ρ‖ < R+2) —
the γ-gap arc analysis: |re s| ≤ √13 ⟹ |t| within 13/R of R ⟹
|t−γ| ≥ 1/(32·Ĉ₀) (the γ-gap + threshold); |re s| > √13 ⟹
‖s−ρ‖ ≥ √13−1 ≥ 2. Uniform separation ‖s−ρ‖ ≥ 1/(32·Ĉ₀), term ≤
64·Ĉ₀·m, single-window count 42·A₀·log R ⟹ ≤ 2688·Ĉ₀·A₀·log R.
`seriesFun_norm_le_gapCircle`: the assembly. -/
/-- On the circle ‖s‖ = R: R − |im s| = re²/(R+|im s|) ≤ B/R when
re² ≤ B. -/
lemma norm_circle_sub_abs_im_le {s : ℂ} {R B : ℝ} (hs : ‖s‖ = R) (hR0 : (0 : ℝ) < R)
(hre : s.re ^ 2 ≤ B) : R - |s.im| ≤ B / R := by
have hnormSq : ‖s‖ ^ 2 = s.re ^ 2 + s.im ^ 2 := by
rw [← Complex.normSq_eq_norm_sq, Complex.normSq_apply]
ring
have ht2 : |s.im| ^ 2 = R ^ 2 - s.re ^ 2 := by
have h1 : s.im ^ 2 = R ^ 2 - s.re ^ 2 := by
have h2 : s.re ^ 2 + s.im ^ 2 = R ^ 2 := by rw [← hnormSq, hs]
linarith
rw [sq_abs]
linarith [h1]
have hRt : R - |s.im| = s.re ^ 2 / (R + |s.im|) := by
have hne : R + |s.im| ≠ 0 := by positivity
field_simp
have h1 : (R - |s.im|) * (R + |s.im|) = R ^ 2 - |s.im| ^ 2 := by ring
rw [h1, ht2]
ring
rw [hRt]
have h1 : s.re ^ 2 / (R + |s.im|) ≤ s.re ^ 2 / R := by
apply div_le_div_of_nonneg_left (sq_nonneg _) hR0
have h2 : (0 : ℝ) ≤ |s.im| := abs_nonneg _
linarith
have h3 : s.re ^ 2 / R ≤ B / R := div_le_div_of_nonneg_right hre hR0.le
exact h1.trans h3
/-- **The critical shell** (R−2 < ‖ρ‖ < R+2): ≤ 2688·Ĉ₀·A₀·log R. -/
lemma shell_crit {k : ℕ} (hk : 4000 ≤ k) {R : ℝ} (hRlo : 4 * (k : ℝ) + 5 / 2 ≤ R)
(hgap : ∀ ρ : ℂ, IsNontrivialZero ρ →
1 / (16 * C0hat (4 * (k : ℝ) + 9 / 2)) ≤ |ρ.im - R| ∨ 1 ≤ |ρ.im - R|)
{s : ℂ} (hs : ‖s‖ = R) (hsz : ¬ IsNontrivialZero s) :
∑ ρ ∈ (circleZeros R).filter (fun ρ : {ρ : ℂ // IsNontrivialZero ρ} =>
¬ ‖(ρ : ℂ)‖ ≤ R - 2 ∧ ‖(ρ : ℂ)‖ < R + 2), ‖seriesTerm s ρ‖
≤ 2688 * C0hat (4 * (k : ℝ) + 9 / 2) * A0count * Real.log R := by
classical
have hth := gapCircle_threshold hk
have hĈ2 : (2 : ℝ) ≤ C0hat (4 * (k : ℝ) + 9 / 2) := two_le_C0hat (by
have hkR : (1 : ℝ) ≤ (k : ℝ) := by exact_mod_cast (by omega : 1 ≤ k)
linarith)
have hR : (16002 : ℝ) ≤ R := by
have hkR : (16000 : ℝ) ≤ 4 * (k : ℝ) := by
have h1 : (4000 : ℝ) ≤ (k : ℝ) := by exact_mod_cast hk
linarith
linarith [hRlo]
have hRpos : (0 : ℝ) < R := by linarith [hR]
have hlogR : (9 : ℝ) ≤ Real.log R := nine_le_log_of_16002_le hR
have hlogRnn : (0 : ℝ) ≤ Real.log R := by linarith [hlogR]
have hĈpos : (0 : ℝ) < C0hat (4 * (k : ℝ) + 9 / 2) := by linarith [hĈ2]
set FS := (circleZeros R).filter (fun ρ : {ρ : ℂ // IsNontrivialZero ρ} =>
¬ ‖(ρ : ℂ)‖ ≤ R - 2 ∧ ‖(ρ : ℂ)‖ < R + 2) with hFS
-- the uniform separation 1/(32Ĉ₀) ≤ ‖s−ρ‖ on the critical shell
have hsep : ∀ ρ ∈ FS, 1 / (32 * C0hat (4 * (k : ℝ) + 9 / 2)) ≤ ‖s - (ρ : ℂ)‖ := by
intro ρ hρ
rw [hFS, Finset.mem_filter] at hρ
obtain ⟨-, hρRm2, hρRp2⟩ := hρ
have hρRm2' : (R - 2 : ℝ) < ‖(ρ : ℂ)‖ := lt_of_not_ge hρRm2
-- |γ| ≥ ‖ρ‖−1 ≥ R−3; the γ-gap for |γ| near R (conj if γ < 0)
have hγR : 1 / (16 * C0hat (4 * (k : ℝ) + 9 / 2)) ≤ |(|(ρ : ℂ).im|) - R| := by
rcases le_or_gt 0 (ρ : ℂ).im with hγ | hγ
· have hgap' := hgap (ρ : ℂ) ρ.2
rw [← abs_of_nonneg hγ] at hgap'
rcases hgap' with h | h
· exact h
· have h1 : 1 / (16 * C0hat (4 * (k : ℝ) + 9 / 2)) ≤ 1 := by
rw [div_le_one (by positivity : (0 : ℝ) < 16 * C0hat (4 * (k : ℝ) + 9 / 2))]
linarith [hĈ2]
exact h1.trans h
· have hconj := hgap ((starRingEnd ℂ) (ρ : ℂ)) (isNontrivialZero_conj ρ.2)
rw [Complex.conj_im, ← abs_of_neg hγ] at hconj
rcases hconj with h | h
· exact h
· have h1 : 1 / (16 * C0hat (4 * (k : ℝ) + 9 / 2)) ≤ 1 := by
rw [div_le_one (by positivity : (0 : ℝ) < 16 * C0hat (4 * (k : ℝ) + 9 / 2))]
linarith [hĈ2]
exact h1.trans h
by_cases hre13 : s.re ^ 2 ≤ 13
· -- the strip arcs: |t| within 13/R of R, |t−γ| ≥ 1/(32Ĉ₀)
have hRt : R - |s.im| ≤ 13 / R :=
norm_circle_sub_abs_im_le hs hRpos hre13
have ht_le : |s.im| ≤ R := by
have h := abs_im_le_norm s
rw [hs] at h
exact h
have h1 : |(|s.im| - |(ρ : ℂ).im|)| ≤ |s.im - (ρ : ℂ).im| :=
abs_abs_sub_abs_le_abs_sub _ _
have h2 : |(|(ρ : ℂ).im| - R)| ≤ |(|(ρ : ℂ).im| - |s.im|)| + |(|s.im| - R)| :=
abs_sub_le _ _ _
have h3 : |(|(ρ : ℂ).im| - |s.im|)| = |(|s.im| - |(ρ : ℂ).im|)| := abs_sub_comm _ _
have h4 : |(|s.im| - R)| = R - |s.im| := by
rw [abs_of_nonpos (by linarith [ht_le] : |s.im| - R ≤ 0)]
ring
-- the threshold: 13/R ≤ 1/(32Ĉ₀)
have hthr : 13 / R ≤ 1 / (32 * C0hat (4 * (k : ℝ) + 9 / 2)) := by
rw [div_le_div_iff₀ hRpos (by positivity : (0 : ℝ) < 32 * C0hat (4 * (k : ℝ) + 9 / 2))]
have h1 : 13 * (32 * C0hat (4 * (k : ℝ) + 9 / 2))
= 416 * C0hat (4 * (k : ℝ) + 9 / 2) := by ring
rw [h1]
linarith [hth, hRlo]
have hP2Q : 1 / (16 * C0hat (4 * (k : ℝ) + 9 / 2))
= 2 * (1 / (32 * C0hat (4 * (k : ℝ) + 9 / 2))) := by
have hne : C0hat (4 * (k : ℝ) + 9 / 2) ≠ 0 := hĈpos.ne'
field_simp [hne]
ring
have hb1 : |(|(ρ : ℂ).im| - R)| - (R - |s.im|) ≤ |s.im - (ρ : ℂ).im| := by
linarith [h1, h2, h3, h4]
have h5 : 1 / (32 * C0hat (4 * (k : ℝ) + 9 / 2)) ≤ |s.im - (ρ : ℂ).im| := by
linarith [hγR, hRt, hthr, hb1, hP2Q]
have h6 : (s - (ρ : ℂ)).im = s.im - (ρ : ℂ).im := Complex.sub_im _ _
have h7 : |(s - (ρ : ℂ)).im| ≤ ‖s - (ρ : ℂ)‖ := abs_im_le_norm _
rw [h6] at h7
linarith [h5, h7]
· -- the near-axis arcs: |re s| > √13 ⟹ ‖s−ρ‖ ≥ √13−1 ≥ 2
push Not at hre13
have hsqrt : Real.sqrt 13 < |s.re| := by
rw [Real.sqrt_lt (by norm_num : (0 : ℝ) ≤ 13) (abs_nonneg _)]
rw [sq_abs]
exact hre13
have h3le : (3 : ℝ) ≤ Real.sqrt 13 := by
rw [show (3 : ℝ) = Real.sqrt (3 ^ 2) from (Real.sqrt_sq (by norm_num)).symm]
exact Real.sqrt_le_sqrt (by norm_num : (3 : ℝ) ^ 2 ≤ 13)
have h1 : |s.re| - |(ρ : ℂ).re| ≤ |s.re - (ρ : ℂ).re| := abs_sub_abs_le_abs_sub _ _
have hreρ : |(ρ : ℂ).re| ≤ 1 := by
rw [abs_le]
exact ⟨by linarith [ρ.2.2.1], by linarith [ρ.2.2.2]⟩
have h2 : (2 : ℝ) < |s.re - (ρ : ℂ).re| := by linarith [hsqrt, h3le, h1, hreρ]
have h3 : (s - (ρ : ℂ)).re = s.re - (ρ : ℂ).re := Complex.sub_re _ _
have h4 : |(s - (ρ : ℂ)).re| ≤ ‖s - (ρ : ℂ)‖ := abs_re_le_norm _
rw [h3] at h4
have h5 : 1 / (32 * C0hat (4 * (k : ℝ) + 9 / 2)) ≤ 2 := by
rw [div_le_iff₀ (by positivity : (0 : ℝ) < 32 * C0hat (4 * (k : ℝ) + 9 / 2))]
linarith [hĈ2]
linarith [h2, h4, h5]
-- the per-element term bound g ρ ≤ 64·Ĉ₀·m
have hterm : ∀ ρ ∈ FS, ‖seriesTerm s ρ‖
≤ 64 * C0hat (4 * (k : ℝ) + 9 / 2) * (zeroMult (ρ : ℂ) : ℝ) := by
intro ρ hρ
have hsepρ := hsep ρ hρ
rw [hFS, Finset.mem_filter] at hρ
obtain ⟨-, hρRm2, hρRp2⟩ := hρ
have hρRm2' : (R - 2 : ℝ) < ‖(ρ : ℂ)‖ := lt_of_not_ge hρRm2
have hρpos : (0 : ℝ) < ‖(ρ : ℂ)‖ := by linarith [hR]
have hsepρpos : (0 : ℝ) < ‖s - (ρ : ℂ)‖ := by
have h1 : (0 : ℝ) < 1 / (32 * C0hat (4 * (k : ℝ) + 9 / 2)) := by positivity
linarith [hsepρ, h1]
have hid := seriesTerm_norm_eq_div hs hsz ρ
rw [hid]
have hm : (0 : ℝ) ≤ (zeroMult (ρ : ℂ) : ℝ) := Nat.cast_nonneg _
have hden : (R - 2) * (1 / (32 * C0hat (4 * (k : ℝ) + 9 / 2)))
≤ ‖(ρ : ℂ)‖ * ‖s - (ρ : ℂ)‖ :=
mul_le_mul hρRm2'.le hsepρ
(div_nonneg one_pos.le (mul_nonneg (by norm_num : (0 : ℝ) ≤ 32) hĈpos.le))
(by linarith [hR])
have h1 : R / (‖(ρ : ℂ)‖ * ‖s - (ρ : ℂ)‖)
≤ R / ((R - 2) * (1 / (32 * C0hat (4 * (k : ℝ) + 9 / 2)))) := by
apply div_le_div_of_nonneg_left hRpos.le
(mul_pos (by linarith [hR] : (0 : ℝ) < R - 2)
(div_pos one_pos (mul_pos (by norm_num : (0 : ℝ) < 32) hĈpos)))
exact hden
have h2 : R / ((R - 2) * (1 / (32 * C0hat (4 * (k : ℝ) + 9 / 2))))
= 32 * C0hat (4 * (k : ℝ) + 9 / 2) * (R / (R - 2)) := by
field_simp
have h3 : R / (R - 2) ≤ 2 := by
rw [div_le_iff₀ (by linarith [hR] : (0 : ℝ) < R - 2)]
linarith [hR]
calc (zeroMult (ρ : ℂ) : ℝ) * (R / (‖(ρ : ℂ)‖ * ‖s - (ρ : ℂ)‖))
≤ (zeroMult (ρ : ℂ) : ℝ) *
(R / ((R - 2) * (1 / (32 * C0hat (4 * (k : ℝ) + 9 / 2))))) :=
mul_le_mul_of_nonneg_left h1 hm
_ = (zeroMult (ρ : ℂ) : ℝ) * (32 * C0hat (4 * (k : ℝ) + 9 / 2) * (R / (R - 2))) := by
rw [h2]
_ ≤ (zeroMult (ρ : ℂ) : ℝ) * (32 * C0hat (4 * (k : ℝ) + 9 / 2) * 2) := by
apply mul_le_mul_of_nonneg_left _ hm
exact mul_le_mul_of_nonneg_left h3
(mul_nonneg (by norm_num : (0 : ℝ) ≤ 32) hĈpos.le)
_ = 64 * C0hat (4 * (k : ℝ) + 9 / 2) * (zeroMult (ρ : ℂ) : ℝ) := by ring
-- the single-window count
have hcount : ∑ ρ ∈ FS, (zeroMult (ρ : ℂ) : ℝ)
≤ 3 * A0count * 7 * (2 * Real.log R) := by
have hM1 : (1 : ℝ) ≤ max (R - 3) (R - 3) := by rw [max_self]; linarith [hR]
have hMb : max (R - 3) (R - 3) ≤ R + 2 := by rw [max_self]; linarith [hR]
have hsub : ∀ ρ ∈ FS,
R - 3 ≤ |(ρ : ℂ).im| ∧ |(ρ : ℂ).im| ≤ R + 2 ∧ R - 3 ≤ |(ρ : ℂ).im| := by
intro ρ hρ
rw [hFS, Finset.mem_filter] at hρ
obtain ⟨-, hρRm2, hρRp2⟩ := hρ
have hρRm2' : (R - 2 : ℝ) < ‖(ρ : ℂ)‖ := lt_of_not_ge hρRm2
have him1 := abs_im_ge_norm_sub_one ρ
have him2 : |(ρ : ℂ).im| ≤ ‖(ρ : ℂ)‖ := abs_im_le_norm _
exact ⟨by linarith [him1, hρRm2'], by linarith [him2, hρRp2],
by linarith [him1, hρRm2']⟩
have hbrick := sum_zeroMult_le_of_im_band FS hM1 hMb hsub
have hab : R + 2 - (R - 3) + 2 = 7 := by ring
have hmax : max |R - 3| |R + 2| = R + 2 := by
rw [abs_of_nonneg (by linarith [hR] : (0 : ℝ) ≤ R - 3),
abs_of_nonneg (by linarith [hR] : (0 : ℝ) ≤ R + 2)]
exact max_eq_right (by linarith [hR])
rw [hab, hmax] at hbrick
have hlogle : Real.log (3 * (R + 2) + 5) ≤ 2 * Real.log R := by
have h1 : Real.log (3 * (R + 2) + 5) ≤ Real.log (4 * R) := by
apply Real.log_le_log (by linarith [hRpos])
linarith [hR]
have h2 : Real.log (4 * R) = Real.log 4 + Real.log R :=
Real.log_mul (by norm_num : (4 : ℝ) ≠ 0) (by linarith [hR] : R ≠ 0)
have h3 : Real.log 4 = 2 * Real.log 2 := by
rw [show (4 : ℝ) = 2 ^ 2 by norm_num, Real.log_pow]
push_cast
ring
have h4 := log_two_le_one
linarith [h1, h2, h3, h4, hlogR]
exact hbrick.trans (mul_le_mul_of_nonneg_left hlogle
(mul_nonneg (mul_nonneg (by norm_num : (0 : ℝ) ≤ 3) A0count_pos.le)
(by norm_num : (0 : ℝ) ≤ 7)))
-- assemble
have hsum : ∑ ρ ∈ FS, ‖seriesTerm s ρ‖
≤ ∑ ρ ∈ FS, 64 * C0hat (4 * (k : ℝ) + 9 / 2) * (zeroMult (ρ : ℂ) : ℝ) :=
Finset.sum_le_sum hterm
have hfact : ∑ ρ ∈ FS, 64 * C0hat (4 * (k : ℝ) + 9 / 2) * (zeroMult (ρ : ℂ) : ℝ)
= (64 * C0hat (4 * (k : ℝ) + 9 / 2)) * ∑ ρ ∈ FS, (zeroMult (ρ : ℂ) : ℝ) := by
rw [Finset.mul_sum]
have hfin : (64 : ℝ) * C0hat (4 * (k : ℝ) + 9 / 2) * (3 * A0count * 7 * (2 * Real.log R))
= 2688 * C0hat (4 * (k : ℝ) + 9 / 2) * A0count * Real.log R := by ring
calc ∑ ρ ∈ FS, ‖seriesTerm s ρ‖
≤ ∑ ρ ∈ FS, 64 * C0hat (4 * (k : ℝ) + 9 / 2) * (zeroMult (ρ : ℂ) : ℝ) := hsum
_ = (64 * C0hat (4 * (k : ℝ) + 9 / 2)) * ∑ ρ ∈ FS, (zeroMult (ρ : ℂ) : ℝ) := hfact
_ ≤ (64 * C0hat (4 * (k : ℝ) + 9 / 2)) * (3 * A0count * 7 * (2 * Real.log R)) :=
mul_le_mul_of_nonneg_left hcount
(mul_nonneg (by norm_num : (0 : ℝ) ≤ 64) hĈpos.le)
_ = 2688 * C0hat (4 * (k : ℝ) + 9 / 2) * A0count * Real.log R := hfin
/-- **The series circle bound** (ii′-5e-v-b chunk 3 capstone): on the
γ-gap circle |s| = R (k ≥ 4000), ‖seriesFun s‖ ≤ 2·lowZeroConst +
2900·A₀·Ĉ₀(4k+9/2)·(log R)². The ONE tsum split at {‖ρ‖ < 2R+1}, the
five-way shell partition of the finite part (iterated filter splits;
the redundant ¬q1/¬q2 conjuncts dropped via the range implications),
the shell bounds (low 2·lowZeroConst; inlo/inhi 60·A₀L²; crit
2688·Ĉ₀A₀L; up 45·A₀L²), and the far tail ≤ 91·A₀L. -/
theorem seriesFun_norm_le_gapCircle {k : ℕ} (hk : 4000 ≤ k)
{R : ℝ} (hRlo : 4 * (k : ℝ) + 5 / 2 ≤ R)
(hgap : ∀ ρ : ℂ, IsNontrivialZero ρ →
1 / (16 * C0hat (4 * (k : ℝ) + 9 / 2)) ≤ |ρ.im - R| ∨ 1 ≤ |ρ.im - R|)
{s : ℂ} (hs : ‖s‖ = R) :
‖seriesFun s‖ ≤ 2 * lowZeroConst +
2900 * A0count * C0hat (4 * (k : ℝ) + 9 / 2) * (Real.log R) ^ 2 := by
classical
have hsz : ¬ IsNontrivialZero s :=
not_isNontrivialZero_on_gapCircle hk hRlo hgap hs
have hR : (16002 : ℝ) ≤ R := by
have h1 : (4000 : ℝ) ≤ (k : ℝ) := by exact_mod_cast hk
linarith [hRlo]
have hlogR : (9 : ℝ) ≤ Real.log R := nine_le_log_of_16002_le hR
have hlogRnn : (0 : ℝ) ≤ Real.log R := by linarith [hlogR]
have hĈ2 : (2 : ℝ) ≤ C0hat (4 * (k : ℝ) + 9 / 2) := two_le_C0hat (by
have hkR : (1 : ℝ) ≤ (k : ℝ) := by exact_mod_cast (by omega : 1 ≤ k)
linarith)
have hA0 := A0count_pos.le
-- the shell bounds and the tail
have hsh1 := shell_low hs hsz hR
have hsh2 := shell_inlo hs hsz hR
have hsh3 := shell_inhi hs hsz hR
have hsh4 := shell_crit hk hRlo hgap hs hsz
have hsh5 := shell_up hs hsz hR
have htail := series_tail_le hs hR
have hsplit0 := seriesFun_norm_le_split (s := s) (R := R)
-- the partition identity (iterated filter splits)
have hsplit1 := Finset.sum_filter_add_sum_filter_not (circleZeros R)
(fun ρ : {ρ : ℂ // IsNontrivialZero ρ} => ‖(ρ : ℂ)‖ ≤ 3) (fun ρ => ‖seriesTerm s ρ‖)
have hsplit2 := Finset.sum_filter_add_sum_filter_not
((circleZeros R).filter (fun ρ : {ρ : ℂ // IsNontrivialZero ρ} => ¬ ‖(ρ : ℂ)‖ ≤ 3))
(fun ρ : {ρ : ℂ // IsNontrivialZero ρ} => ‖(ρ : ℂ)‖ ≤ R / 2) (fun ρ => ‖seriesTerm s ρ‖)
have hff2 : ((circleZeros R).filter (fun ρ : {ρ : ℂ // IsNontrivialZero ρ} =>
¬ ‖(ρ : ℂ)‖ ≤ 3)).filter (fun ρ : {ρ : ℂ // IsNontrivialZero ρ} => ‖(ρ : ℂ)‖ ≤ R / 2)
= (circleZeros R).filter (fun ρ : {ρ : ℂ // IsNontrivialZero ρ} =>
¬ ‖(ρ : ℂ)‖ ≤ 3 ∧ ‖(ρ : ℂ)‖ ≤ R / 2) := Finset.filter_filter _ _ _
rw [hff2] at hsplit2
have hff2' : ((circleZeros R).filter (fun ρ : {ρ : ℂ // IsNontrivialZero ρ} =>
¬ ‖(ρ : ℂ)‖ ≤ 3)).filter (fun ρ : {ρ : ℂ // IsNontrivialZero ρ} => ¬ ‖(ρ : ℂ)‖ ≤ R / 2)
= (circleZeros R).filter (fun ρ : {ρ : ℂ // IsNontrivialZero ρ} =>
¬ ‖(ρ : ℂ)‖ ≤ 3 ∧ ¬ ‖(ρ : ℂ)‖ ≤ R / 2) := Finset.filter_filter _ _ _
rw [hff2'] at hsplit2
have hsplit3 := Finset.sum_filter_add_sum_filter_not
((circleZeros R).filter (fun ρ : {ρ : ℂ // IsNontrivialZero ρ} =>
¬ ‖(ρ : ℂ)‖ ≤ 3 ∧ ¬ ‖(ρ : ℂ)‖ ≤ R / 2))
(fun ρ : {ρ : ℂ // IsNontrivialZero ρ} => ‖(ρ : ℂ)‖ ≤ R - 2) (fun ρ => ‖seriesTerm s ρ‖)
have hff3 : ((circleZeros R).filter (fun ρ : {ρ : ℂ // IsNontrivialZero ρ} =>
¬ ‖(ρ : ℂ)‖ ≤ 3 ∧ ¬ ‖(ρ : ℂ)‖ ≤ R / 2)).filter
(fun ρ : {ρ : ℂ // IsNontrivialZero ρ} => ‖(ρ : ℂ)‖ ≤ R - 2)
= (circleZeros R).filter (fun ρ : {ρ : ℂ // IsNontrivialZero ρ} =>
(¬ ‖(ρ : ℂ)‖ ≤ 3 ∧ ¬ ‖(ρ : ℂ)‖ ≤ R / 2) ∧ ‖(ρ : ℂ)‖ ≤ R - 2) :=
Finset.filter_filter _ _ _
rw [hff3] at hsplit3
have hff3' : ((circleZeros R).filter (fun ρ : {ρ : ℂ // IsNontrivialZero ρ} =>
¬ ‖(ρ : ℂ)‖ ≤ 3 ∧ ¬ ‖(ρ : ℂ)‖ ≤ R / 2)).filter
(fun ρ : {ρ : ℂ // IsNontrivialZero ρ} => ¬ ‖(ρ : ℂ)‖ ≤ R - 2)
= (circleZeros R).filter (fun ρ : {ρ : ℂ // IsNontrivialZero ρ} =>
(¬ ‖(ρ : ℂ)‖ ≤ 3 ∧ ¬ ‖(ρ : ℂ)‖ ≤ R / 2) ∧ ¬ ‖(ρ : ℂ)‖ ≤ R - 2) :=
Finset.filter_filter _ _ _
rw [hff3'] at hsplit3
have hsplit4 := Finset.sum_filter_add_sum_filter_not
((circleZeros R).filter (fun ρ : {ρ : ℂ // IsNontrivialZero ρ} =>
(¬ ‖(ρ : ℂ)‖ ≤ 3 ∧ ¬ ‖(ρ : ℂ)‖ ≤ R / 2) ∧ ¬ ‖(ρ : ℂ)‖ ≤ R - 2))
(fun ρ : {ρ : ℂ // IsNontrivialZero ρ} => ‖(ρ : ℂ)‖ < R + 2) (fun ρ => ‖seriesTerm s ρ‖)
have hff4 : ((circleZeros R).filter (fun ρ : {ρ : ℂ // IsNontrivialZero ρ} =>
(¬ ‖(ρ : ℂ)‖ ≤ 3 ∧ ¬ ‖(ρ : ℂ)‖ ≤ R / 2) ∧ ¬ ‖(ρ : ℂ)‖ ≤ R - 2)).filter
(fun ρ : {ρ : ℂ // IsNontrivialZero ρ} => ‖(ρ : ℂ)‖ < R + 2)
= (circleZeros R).filter (fun ρ : {ρ : ℂ // IsNontrivialZero ρ} =>
((¬ ‖(ρ : ℂ)‖ ≤ 3 ∧ ¬ ‖(ρ : ℂ)‖ ≤ R / 2) ∧ ¬ ‖(ρ : ℂ)‖ ≤ R - 2) ∧ ‖(ρ : ℂ)‖ < R + 2) :=
Finset.filter_filter _ _ _
rw [hff4] at hsplit4
have hff4' : ((circleZeros R).filter (fun ρ : {ρ : ℂ // IsNontrivialZero ρ} =>
(¬ ‖(ρ : ℂ)‖ ≤ 3 ∧ ¬ ‖(ρ : ℂ)‖ ≤ R / 2) ∧ ¬ ‖(ρ : ℂ)‖ ≤ R - 2)).filter
(fun ρ : {ρ : ℂ // IsNontrivialZero ρ} => ¬ ‖(ρ : ℂ)‖ < R + 2)
= (circleZeros R).filter (fun ρ : {ρ : ℂ // IsNontrivialZero ρ} =>
((¬ ‖(ρ : ℂ)‖ ≤ 3 ∧ ¬ ‖(ρ : ℂ)‖ ≤ R / 2) ∧ ¬ ‖(ρ : ℂ)‖ ≤ R - 2) ∧ ¬ ‖(ρ : ℂ)‖ < R + 2) :=
Finset.filter_filter _ _ _
rw [hff4'] at hsplit4
-- the three congruences dropping the redundant conjuncts
have hc3 : (circleZeros R).filter (fun ρ : {ρ : ℂ // IsNontrivialZero ρ} =>
(¬ ‖(ρ : ℂ)‖ ≤ 3 ∧ ¬ ‖(ρ : ℂ)‖ ≤ R / 2) ∧ ‖(ρ : ℂ)‖ ≤ R - 2)
= (circleZeros R).filter (fun ρ : {ρ : ℂ // IsNontrivialZero ρ} =>
¬ ‖(ρ : ℂ)‖ ≤ R / 2 ∧ ‖(ρ : ℂ)‖ ≤ R - 2) := by
ext ρ
simp only [Finset.mem_filter]
constructor
· rintro ⟨hF, ⟨-, h2⟩, h3⟩
exact ⟨hF, h2, h3⟩
· rintro ⟨hF, h2, h3⟩
refine ⟨hF, ⟨⟨?_, h2⟩, h3⟩⟩
exact not_le_of_gt (by linarith [lt_of_not_ge h2, hR] : (3 : ℝ) < ‖(ρ : ℂ)‖)
rw [hc3] at hsplit3
have hc4 : (circleZeros R).filter (fun ρ : {ρ : ℂ // IsNontrivialZero ρ} =>
((¬ ‖(ρ : ℂ)‖ ≤ 3 ∧ ¬ ‖(ρ : ℂ)‖ ≤ R / 2) ∧ ¬ ‖(ρ : ℂ)‖ ≤ R - 2) ∧ ‖(ρ : ℂ)‖ < R + 2)
= (circleZeros R).filter (fun ρ : {ρ : ℂ // IsNontrivialZero ρ} =>
¬ ‖(ρ : ℂ)‖ ≤ R - 2 ∧ ‖(ρ : ℂ)‖ < R + 2) := by
ext ρ
simp only [Finset.mem_filter]
constructor
· rintro ⟨hF, ⟨-, h3⟩, h4⟩
exact ⟨hF, h3, h4⟩
· rintro ⟨hF, h3, h4⟩
refine ⟨hF, ⟨⟨?_, ?_⟩, h3⟩, h4⟩
· exact not_le_of_gt (by linarith [lt_of_not_ge h3, hR] : (3 : ℝ) < ‖(ρ : ℂ)‖)
· exact not_le_of_gt (by linarith [lt_of_not_ge h3, hR] : (R / 2 : ℝ) < ‖(ρ : ℂ)‖)
rw [hc4] at hsplit4
have hc5 : (circleZeros R).filter (fun ρ : {ρ : ℂ // IsNontrivialZero ρ} =>
((¬ ‖(ρ : ℂ)‖ ≤ 3 ∧ ¬ ‖(ρ : ℂ)‖ ≤ R / 2) ∧ ¬ ‖(ρ : ℂ)‖ ≤ R - 2) ∧ ¬ ‖(ρ : ℂ)‖ < R + 2)
= (circleZeros R).filter (fun ρ : {ρ : ℂ // IsNontrivialZero ρ} =>
¬ ‖(ρ : ℂ)‖ < R + 2) := by
ext ρ
simp only [Finset.mem_filter]
constructor
· rintro ⟨hF, -, h4⟩
exact ⟨hF, h4⟩
· rintro ⟨hF, h4⟩
refine ⟨hF, ⟨⟨?_, ?_⟩, ?_⟩, h4⟩
· exact not_le_of_gt (by linarith [le_of_not_gt h4, hR] : (3 : ℝ) < ‖(ρ : ℂ)‖)
· exact not_le_of_gt (by linarith [le_of_not_gt h4, hR] : (R / 2 : ℝ) < ‖(ρ : ℂ)‖)
· exact not_le_of_gt (by linarith [le_of_not_gt h4, hR] : (R - 2 : ℝ) < ‖(ρ : ℂ)‖)
rw [hc5] at hsplit4
-- the final absorption: 165A₀L² + 2688ĈA₀L + 91A₀L ≤ 2900A₀ĈL²
have hL2 : Real.log R ≤ (Real.log R) ^ 2 := by nlinarith [hlogR]
have hnn1 : (0 : ℝ) ≤ A0count * (Real.log R) ^ 2 := mul_nonneg hA0 (pow_two_nonneg _)
have hnn2 : (0 : ℝ) ≤ C0hat (4 * (k : ℝ) + 9 / 2) * A0count :=
mul_nonneg (by linarith [hĈ2]) hA0
have hfin : 2 * lowZeroConst + ((60 * A0count * (Real.log R) ^ 2 +
(60 * A0count * (Real.log R) ^ 2 + (2688 * C0hat (4 * (k : ℝ) + 9 / 2) * A0count *
Real.log R + 45 * A0count * (Real.log R) ^ 2))) + 91 * A0count * Real.log R)
≤ 2 * lowZeroConst + 2900 * A0count * C0hat (4 * (k : ℝ) + 9 / 2) * (Real.log R) ^ 2 := by
nlinarith [hĈ2, hlogR, hA0, hL2, hnn1, hnn2, lowZeroConst_nonneg]
linarith [hsplit0, hsplit1, hsplit2, hsplit3, hsplit4, hsh1, hsh2, hsh3, hsh4, hsh5,
htail, hfin]
/-! ## 10. The (G) formula at real non-pole points + the standalone
separation (5e-v-c-i)
`differentiableAt_Gammaℝ_of_not_neg_nat` / `logDeriv_Gammaℝ_eq_of_not_neg_nat`:
the ΓR logDeriv formula logDeriv ΓR s₀ = −(log π)/2 + ½ψ(s₀/2) at ANY
s₀ with s₀/2 off the Γ poles — the im ≠ 0 hypothesis of 5e-ii's
`logDeriv_Gammaℝ_eq` was only used for pole-avoidance, and the direct
`logDeriv_mul` computation (digamma := logDeriv Γ by definition) works
everywhere. This discharges the real point s = −R of the left
near-axis arc (no continuity argument needed).
`gapCircle_sep`: the shell_crit arc analysis as a standalone statement
for ALL nontrivial zeros (the shell range was only used for the term
bound, not the separation). `nearZeros_count_le`: the near-window
mult-count ≤ 3·A₀·log(3·max|t−1||t+1|+5) for |t| ≥ 10 (single
zerosIn(t−1, t+1] window — |t| ≥ 10 makes all ordinates same-sign).
`gapCircle_sep_of_mem_nearZeros`: the separation for nearZeros
(‖ρ‖ > R−2: gapCircle_sep; else ‖s−ρ‖ ≥ 2). -/
/-- ΓR differentiable at any s with s/2 off the Γ poles (the
pole-avoidance form of `differentiableAt_Gammaℝ_of_im_ne_zero'`). -/
theorem differentiableAt_Gammaℝ_of_not_neg_nat {s : ℂ}
(hs : ∀ m : ℕ, s / 2 ≠ -(m : ℂ)) :
DifferentiableAt ℂ Complex.Gammaℝ s := by
have h1 : DifferentiableAt ℂ (fun z : ℂ => (Real.pi : ℂ) ^ (-z / 2)) s := by
refine DifferentiableAt.const_cpow ?_ (Or.inl (by exact_mod_cast Real.pi_ne_zero))
exact (differentiableAt_id.neg).div_const 2
have h2 : DifferentiableAt ℂ (fun z : ℂ => Complex.Gamma (z / 2)) s :=
(Complex.differentiableAt_Gamma _ hs).comp s (differentiableAt_id.div_const 2)
have hdef : Complex.Gammaℝ = fun z : ℂ => (Real.pi : ℂ) ^ (-z / 2) * Complex.Gamma (z / 2) :=
funext Complex.Gammaℝ_def
rw [hdef]; exact h1.mul h2
/-- **The (G) formula at any non-pole point** (incl. real points):
logDeriv ΓR s₀ = −(log π)/2 + ½ψ(s₀/2). Via `logDeriv_mul` on
Gammaℝ_def: the π^(−s/2) factor contributes −(log π)/2 and the Γ(s/2)
factor ½ψ(s₀/2) (digamma := logDeriv Γ by definition). -/
theorem logDeriv_Gammaℝ_eq_of_not_neg_nat {s₀ : ℂ}
(hs : ∀ m : ℕ, s₀ / 2 ≠ -(m : ℂ)) :
logDeriv Complex.Gammaℝ s₀
= -(Real.log Real.pi : ℂ) / 2 + (1 / 2 : ℂ) * Complex.digamma (s₀ / 2) := by
have hdef : Complex.Gammaℝ = fun z : ℂ => (Real.pi : ℂ) ^ (-z / 2) * Complex.Gamma (z / 2) :=
funext Complex.Gammaℝ_def
rw [hdef]
have h1 : DifferentiableAt ℂ (fun z : ℂ => (Real.pi : ℂ) ^ (-z / 2)) s₀ := by
refine DifferentiableAt.const_cpow ?_ (Or.inl (by exact_mod_cast Real.pi_ne_zero))
exact (differentiableAt_id.neg).div_const 2
have h2 : DifferentiableAt ℂ (fun z : ℂ => Complex.Gamma (z / 2)) s₀ :=
(Complex.differentiableAt_Gamma _ hs).comp s₀ (differentiableAt_id.div_const 2)
have hne1 : (Real.pi : ℂ) ^ (-s₀ / 2) ≠ 0 :=
Complex.cpow_ne_zero_iff.mpr (Or.inl (by exact_mod_cast Real.pi_ne_zero))
have hne2 : Complex.Gamma (s₀ / 2) ≠ 0 := Complex.Gamma_ne_zero hs
rw [logDeriv_mul (f := fun z : ℂ => (Real.pi : ℂ) ^ (-z / 2))
(g := fun z : ℂ => Complex.Gamma (z / 2)) _ hne1 hne2 h1 h2]
have hf1 : logDeriv (fun z : ℂ => (Real.pi : ℂ) ^ (-z / 2)) s₀
= -(Real.log Real.pi : ℂ) / 2 := by
rw [logDeriv_apply]
have hbase : HasDerivAt (fun z : ℂ => -z / 2) (-(1 : ℂ) / 2) s₀ :=
(hasDerivAt_id' s₀).neg.div_const 2
have hder := hbase.const_cpow (Or.inl (by exact_mod_cast Real.pi_ne_zero :
(Real.pi : ℂ) ≠ 0))
rw [hder.deriv]
field_simp [hne1]
rw [← Complex.ofReal_log Real.pi_nonneg]
have hf2 : logDeriv (fun z : ℂ => Complex.Gamma (z / 2)) s₀
= (1 / 2 : ℂ) * Complex.digamma (s₀ / 2) := by
rw [logDeriv_apply]
have hder : deriv (fun z : ℂ => Complex.Gamma (z / 2)) s₀
= deriv Complex.Gamma (s₀ / 2) * (1 / 2) := by
have h1 : deriv (Complex.Gamma ∘ fun z : ℂ => z / 2) s₀
= deriv Complex.Gamma (s₀ / 2) * deriv (fun z : ℂ => z / 2) s₀ :=
deriv_comp _ (Complex.differentiableAt_Gamma _ hs) (differentiableAt_id.div_const 2)
have h2 : deriv (fun z : ℂ => z / 2) s₀ = 1 / 2 :=
((hasDerivAt_id' s₀).div_const 2).deriv
have h3 : deriv (fun z : ℂ => Complex.Gamma (z / 2)) s₀
= deriv (Complex.Gamma ∘ fun z : ℂ => z / 2) s₀ := rfl
rw [h3, h1, h2]
rw [hder]
have hdig : deriv Complex.Gamma (s₀ / 2)
= Complex.digamma (s₀ / 2) * Complex.Gamma (s₀ / 2) := by
rw [Complex.digamma_def, logDeriv_apply]
field_simp [hne2]
rw [hdig]
field_simp [hne2]
rw [hf1, hf2]
/-- **The γ-gap separation, standalone**: for k ≥ 4000, R with the
gap-circle properties, ‖s‖ = R, every nontrivial zero ρ satisfies
‖s−ρ‖ ≥ 1/(32·Ĉ₀). (The shell_crit arc analysis: strip arcs |t−γ| ≥
1/(32Ĉ₀) via the γ-gap — applied to conj ρ for γ < 0 — + the
threshold; near-axis arcs ‖s−ρ‖ ≥ √13−1.) -/
theorem gapCircle_sep {k : ℕ} (hk : 4000 ≤ k) {R : ℝ} (hRlo : 4 * (k : ℝ) + 5 / 2 ≤ R)
(hgap : ∀ ρ : ℂ, IsNontrivialZero ρ →
1 / (16 * C0hat (4 * (k : ℝ) + 9 / 2)) ≤ |ρ.im - R| ∨ 1 ≤ |ρ.im - R|)
{s : ℂ} (hs : ‖s‖ = R) {ρ : ℂ} (hρ : IsNontrivialZero ρ) :
1 / (32 * C0hat (4 * (k : ℝ) + 9 / 2)) ≤ ‖s - ρ‖ := by
have hth := gapCircle_threshold hk
have hĈ2 : (2 : ℝ) ≤ C0hat (4 * (k : ℝ) + 9 / 2) := two_le_C0hat (by
have hkR : (1 : ℝ) ≤ (k : ℝ) := by exact_mod_cast (by omega : 1 ≤ k)
linarith)
have hR : (16002 : ℝ) ≤ R := by
have hkR : (16000 : ℝ) ≤ 4 * (k : ℝ) := by
have h1 : (4000 : ℝ) ≤ (k : ℝ) := by exact_mod_cast hk
linarith
linarith [hRlo]
have hRpos : (0 : ℝ) < R := by linarith [hR]
have hĈpos : (0 : ℝ) < C0hat (4 * (k : ℝ) + 9 / 2) := by linarith [hĈ2]
have hγR : 1 / (16 * C0hat (4 * (k : ℝ) + 9 / 2)) ≤ |(|ρ.im|) - R| := by
rcases le_or_gt 0 ρ.im with hγ | hγ
· have hgap' := hgap ρ hρ
rw [← abs_of_nonneg hγ] at hgap'
rcases hgap' with h | h
· exact h
· have h1 : 1 / (16 * C0hat (4 * (k : ℝ) + 9 / 2)) ≤ 1 := by
rw [div_le_one (by positivity : (0 : ℝ) < 16 * C0hat (4 * (k : ℝ) + 9 / 2))]
linarith [hĈ2]
exact h1.trans h
· have hconj := hgap ((starRingEnd ℂ) ρ) (isNontrivialZero_conj hρ)
rw [Complex.conj_im, ← abs_of_neg hγ] at hconj
rcases hconj with h | h
· exact h
· have h1 : 1 / (16 * C0hat (4 * (k : ℝ) + 9 / 2)) ≤ 1 := by
rw [div_le_one (by positivity : (0 : ℝ) < 16 * C0hat (4 * (k : ℝ) + 9 / 2))]
linarith [hĈ2]
exact h1.trans h
by_cases hre13 : s.re ^ 2 ≤ 13
· -- strip arcs
have hRt : R - |s.im| ≤ 13 / R :=
norm_circle_sub_abs_im_le hs hRpos hre13
have ht_le : |s.im| ≤ R := by
have h := abs_im_le_norm s
rw [hs] at h
exact h
have h1 : |(|s.im| - |ρ.im|)| ≤ |s.im - ρ.im| :=
abs_abs_sub_abs_le_abs_sub _ _
have h2 : |(|ρ.im| - R)| ≤ |(|ρ.im| - |s.im|)| + |(|s.im| - R)| :=
abs_sub_le _ _ _
have h3 : |(|ρ.im| - |s.im|)| = |(|s.im| - |ρ.im|)| := abs_sub_comm _ _
have h4 : |(|s.im| - R)| = R - |s.im| := by
rw [abs_of_nonpos (by linarith [ht_le] : |s.im| - R ≤ 0)]
ring
have hthr : 13 / R ≤ 1 / (32 * C0hat (4 * (k : ℝ) + 9 / 2)) := by
rw [div_le_div_iff₀ hRpos (by positivity : (0 : ℝ) < 32 * C0hat (4 * (k : ℝ) + 9 / 2))]
have h1 : 13 * (32 * C0hat (4 * (k : ℝ) + 9 / 2))
= 416 * C0hat (4 * (k : ℝ) + 9 / 2) := by ring
rw [h1]
linarith [hth, hRlo]
have hP2Q : 1 / (16 * C0hat (4 * (k : ℝ) + 9 / 2))
= 2 * (1 / (32 * C0hat (4 * (k : ℝ) + 9 / 2))) := by
have hne : C0hat (4 * (k : ℝ) + 9 / 2) ≠ 0 := hĈpos.ne'
field_simp [hne]
ring
have hb1 : |(|ρ.im| - R)| - (R - |s.im|) ≤ |s.im - ρ.im| := by
linarith [h1, h2, h3, h4]
have h5 : 1 / (32 * C0hat (4 * (k : ℝ) + 9 / 2)) ≤ |s.im - ρ.im| := by
linarith [hγR, hRt, hthr, hb1, hP2Q]
have h6 : (s - ρ).im = s.im - ρ.im := Complex.sub_im _ _
have h7 : |(s - ρ).im| ≤ ‖s - ρ‖ := abs_im_le_norm _
rw [h6] at h7
linarith [h5, h7]
· -- near-axis arcs
push Not at hre13
have hsqrt : Real.sqrt 13 < |s.re| := by
rw [Real.sqrt_lt (by norm_num : (0 : ℝ) ≤ 13) (abs_nonneg _)]
rw [sq_abs]
exact hre13
have h3le : (3 : ℝ) ≤ Real.sqrt 13 := by
rw [show (3 : ℝ) = Real.sqrt (3 ^ 2) from (Real.sqrt_sq (by norm_num)).symm]
exact Real.sqrt_le_sqrt (by norm_num : (3 : ℝ) ^ 2 ≤ 13)
have h1 : |s.re| - |ρ.re| ≤ |s.re - ρ.re| := abs_sub_abs_le_abs_sub _ _
have hreρ : |ρ.re| ≤ 1 := by
rw [abs_le]
exact ⟨by linarith [hρ.2.1], by linarith [hρ.2.2]⟩
have h2 : (2 : ℝ) < |s.re - ρ.re| := by linarith [hsqrt, h3le, h1, hreρ]
have h3 : (s - ρ).re = s.re - ρ.re := Complex.sub_re _ _
have h4 : |(s - ρ).re| ≤ ‖s - ρ‖ := abs_re_le_norm _
rw [h3] at h4
have h5 : 1 / (32 * C0hat (4 * (k : ℝ) + 9 / 2)) ≤ 2 := by
rw [div_le_iff₀ (by positivity : (0 : ℝ) < 32 * C0hat (4 * (k : ℝ) + 9 / 2))]
linarith [hĈ2]
linarith [h2, h4, h5]
/-- **The near-window count**: the multiplicity sum over nearZeros t is
≤ 3·A₀·log(3·max|t−1||t+1|+5) (the single zerosIn(t−1, t+1] window —
zerosIn counts by ordinate, sign irrelevant). -/
lemma nearZeros_count_le {t : ℝ} :
∑ ρ ∈ nearZeros t, (zeroMult ρ : ℝ)
≤ 3 * A0count * Real.log (3 * max |t - 1| |t + 1| + 5) := by
have hsub : nearZeros t ⊆ (Zeta23.zerosIn_finite (t - 1) (t + 1)).toFinset := by
intro ρ hρ
rw [mem_nearZeros] at hρ
obtain ⟨hρd, hρt⟩ := hρ
rw [Set.Finite.mem_toFinset]
refine ⟨zeroDisc_isNontrivial hρd, ?_, ?_⟩
· have h1 : -1 < ρ.im - t := (abs_lt.mp hρt).1
linarith
· have h2 : ρ.im - t < 1 := (abs_lt.mp hρt).2
linarith
calc ∑ ρ ∈ nearZeros t, (zeroMult ρ : ℝ)
≤ ∑ ρ ∈ (Zeta23.zerosIn_finite (t - 1) (t + 1)).toFinset, (zeroMult ρ : ℝ) :=
Finset.sum_le_sum_of_subset_of_nonneg hsub (fun z _ _ => Nat.cast_nonneg _)
_ = (Zeta23.Ncount (t - 1) (t + 1) : ℝ) := by
rw [Zeta23.Ncount,
finsum_mem_eq_finite_toFinset_sum _ (Zeta23.zerosIn_finite _ _), Nat.cast_sum]
_ ≤ A0count * 3 * Real.log (3 * max |t - 1| |t + 1| + 5) := by
have h1 := Ncount_le_of_interval_gen (a := t - 1) (b := t + 1) (by linarith)
have h2 : t + 1 - (t - 1) + 1 = 3 := by ring
rw [h2] at h1
exact h1
_ = 3 * A0count * Real.log (3 * max |t - 1| |t + 1| + 5) := by ring
/-- **The separation for nearZeros**: for ρ ∈ nearZeros (s.im) on the
gap circle, ‖s−ρ‖ ≥ 1/(32·Ĉ₀) (‖ρ‖ > R−2: gapCircle_sep; else
‖s−ρ‖ ≥ R−‖ρ‖ ≥ 2). -/
theorem gapCircle_sep_of_mem_nearZeros {k : ℕ} (hk : 4000 ≤ k)
{R : ℝ} (hRlo : 4 * (k : ℝ) + 5 / 2 ≤ R)
(hgap : ∀ ρ : ℂ, IsNontrivialZero ρ →
1 / (16 * C0hat (4 * (k : ℝ) + 9 / 2)) ≤ |ρ.im - R| ∨ 1 ≤ |ρ.im - R|)
{s : ℂ} (hs : ‖s‖ = R) {ρ : ℂ} (hρ : ρ ∈ nearZeros (s.im)) :
1 / (32 * C0hat (4 * (k : ℝ) + 9 / 2)) ≤ ‖s - ρ‖ := by
have hρnt : IsNontrivialZero ρ := zeroDisc_isNontrivial (mem_nearZeros.mp hρ).1
have hĈ2 : (2 : ℝ) ≤ C0hat (4 * (k : ℝ) + 9 / 2) := two_le_C0hat (by
have hkR : (1 : ℝ) ≤ (k : ℝ) := by exact_mod_cast (by omega : 1 ≤ k)
linarith)
by_cases hn : R - 2 < ‖ρ‖
· exact gapCircle_sep hk hRlo hgap hs hρnt
· push Not at hn
have hR : (16002 : ℝ) ≤ R := by
have hkR : (16000 : ℝ) ≤ 4 * (k : ℝ) := by
have h1 : (4000 : ℝ) ≤ (k : ℝ) := by exact_mod_cast hk
linarith
linarith [hRlo]
have h1 : (2 : ℝ) ≤ ‖s - ρ‖ := by
have h2 := abs_norm_sub_norm_le s ρ
rw [hs, abs_of_nonneg (by linarith [hn, hR] : (0 : ℝ) ≤ R - ‖ρ‖)] at h2
linarith [h2, hn]
have h3 : 1 / (32 * C0hat (4 * (k : ℝ) + 9 / 2)) ≤ 2 := by
rw [div_le_iff₀ (by positivity : (0 : ℝ) < 32 * C0hat (4 * (k : ℝ) + 9 / 2))]
linarith [hĈ2]
exact h3.trans h1
/-! ## 11. The digamma bounds and the elementary terms (5e-v-c-ii)
`digamma_right_le`: re w ≥ 1.75 ⟹ ‖ψ(w)‖ ≤ 48 + 23·log(2+‖w‖)
(sub-log for |im| ≥ 5; 5e-ii (B) for re ≥ 2; 5e-ii (A) with c = 1
else). `digamma_circle_le`: on the gap circle, ‖ψ(s/2)‖ ≤
62 + 23·log(2+R/2) UNIFORMLY (strip arcs: sub-log; re(s/2) ≥ 1.75:
right_le; the left near-axis: 5e-ii (A) with c = 1/8 from the
ℤ-clearance dist(R/2,ℤ) ≥ 1/4 — the R+re s = im²/(R−re s) identity
avoids square roots). Small elems: ‖1/s‖, ‖1/(s−1)‖, ‖(log π)/2‖. -/
/-- The right-halfplane digamma bound: re w ≥ 1.75 ⟹
‖ψ(w)‖ ≤ 48 + 23·log(2+‖w‖). -/
lemma digamma_right_le {w : ℂ} (hwre : (1.75 : ℝ) ≤ w.re) :
‖Complex.digamma w‖ ≤ 48 + 23 * Real.log (2 + ‖w‖) := by
have hlog2w_nn : (0 : ℝ) ≤ Real.log (2 + ‖w‖) :=
Real.log_nonneg (by linarith [norm_nonneg w] : (1 : ℝ) ≤ 2 + ‖w‖)
rcases le_or_gt (5 : ℝ) |w.im| with him | him
· -- the Stirling-flavoured sub-log bound
have h1 := norm_digamma_sub_log_le_of_two_le_abs_im (by linarith [him] : (2 : ℝ) ≤ |w.im|)
have hwnorm : (1 : ℝ) ≤ ‖w‖ := by
have h2 := Complex.abs_re_le_norm w
rw [abs_of_nonneg (by linarith [hwre])] at h2
linarith [hwre, h2]
have h2 := norm_log_le_of_one_le hwnorm
have hlogle : Real.log ‖w‖ ≤ Real.log (2 + ‖w‖) :=
Real.log_le_log (by linarith [hwnorm] : (0 : ℝ) < ‖w‖)
(by linarith [norm_nonneg w])
have hpi : Real.pi ≤ 45 := by have h := Real.pi_lt_d2; linarith
calc ‖Complex.digamma w‖
= ‖(Complex.digamma w - Complex.log w) + Complex.log w‖ := by rw [sub_add_cancel]
_ ≤ ‖Complex.digamma w - Complex.log w‖ + ‖Complex.log w‖ := norm_add_le _ _
_ ≤ 3 + (Real.log ‖w‖ + Real.pi) := add_le_add h1 h2
_ ≤ 48 + 23 * Real.log (2 + ‖w‖) := by linarith [hlogle, hpi, hlog2w_nn]
· by_cases hwre2 : (2 : ℝ) ≤ w.re
· -- 5e-ii (B)
have h1 := norm_digamma_le_of_two_le_re hwre2 (by linarith [him])
linarith [h1, hlog2w_nn]
· -- 5e-ii (A) with c = 1
push Not at hwre2
have hdist : ∀ m : ℕ, (1 : ℝ) ≤ ‖w + (m : ℂ)‖ := by
intro m
have h1 : ‖w + (m : ℂ)‖ ≥ |(w + (m : ℂ)).re| := Complex.abs_re_le_norm _
have h2 : (w + (m : ℂ)).re = w.re + (m : ℝ) := by
rw [Complex.add_re, Complex.natCast_re]
rw [h2] at h1
have h3 : (0 : ℝ) ≤ (m : ℝ) := Nat.cast_nonneg _
have h4 : |w.re + (m : ℝ)| = w.re + (m : ℝ) := abs_of_nonneg (by linarith [hwre, h3])
linarith [hwre, h1, h3, h4]
have h1 := norm_digamma_le_of_dist_nat (show (0 : ℝ) < 1 by norm_num)
(by linarith [hwre2] : w.re ≤ 2) hdist
have h2 : (46 : ℝ) + 2 / 1 = 48 := by norm_num
rw [h2] at h1
exact h1
/-- **The uniform digamma bound on the gap circle**: ‖ψ(s/2)‖ ≤
62 + 23·log(2+R/2). -/
lemma digamma_circle_le {s : ℂ} {R : ℝ} (hs : ‖s‖ = R)
(hgapInt : ∀ m : ℤ, 1 / 4 ≤ |R / 2 - (m : ℝ)|) (hR : (16002 : ℝ) ≤ R) :
‖Complex.digamma (s / 2)‖ ≤ 62 + 23 * Real.log (2 + R / 2) := by
have hRpos : (0 : ℝ) < R := by linarith [hR]
have hsnorm : ‖s / 2‖ = R / 2 := by
rw [norm_div, hs]
have h1 : ‖(2 : ℂ)‖ = 2 := by
rw [show (2 : ℂ) = ((2 : ℝ) : ℂ) by push_cast; ring, Complex.norm_real]
norm_num
rw [h1]
have hre : (s / 2).re = s.re / 2 := by simp
have hlog_nn : (0 : ℝ) ≤ Real.log (2 + R / 2) :=
Real.log_nonneg (by linarith [hRpos] : (1 : ℝ) ≤ 2 + R / 2)
have him2 : (s / 2).im = s.im / 2 := by simp
rcases le_or_gt (5 : ℝ) |(s / 2).im| with him | him
· -- strip arcs: the sub-log bound
have h1 := norm_digamma_sub_log_le_of_two_le_abs_im (by linarith [him] :
(2 : ℝ) ≤ |(s / 2).im|)
have hwnorm : (1 : ℝ) ≤ ‖s / 2‖ := by rw [hsnorm]; linarith [hR]
have h2 := norm_log_le_of_one_le hwnorm
have hlogle : Real.log (R / 2) ≤ Real.log (2 + R / 2) :=
Real.log_le_log (by linarith [hRpos] : (0 : ℝ) < R / 2) (by linarith [hRpos])
have hpi : Real.pi ≤ 45 := by have h := Real.pi_lt_d2; linarith
rw [hsnorm] at h2
calc ‖Complex.digamma (s / 2)‖
= ‖(Complex.digamma (s / 2) - Complex.log (s / 2)) + Complex.log (s / 2)‖ := by
rw [sub_add_cancel]
_ ≤ ‖Complex.digamma (s / 2) - Complex.log (s / 2)‖ + ‖Complex.log (s / 2)‖ :=
norm_add_le _ _
_ ≤ 3 + (Real.log (R / 2) + Real.pi) := add_le_add h1 h2
_ ≤ 62 + 23 * Real.log (2 + R / 2) := by linarith [hlogle, hpi, hlog_nn]
· by_cases hre2 : (1.75 : ℝ) ≤ (s / 2).re
· -- the right bound (48 ≤ 62)
have h1 := digamma_right_le hre2
rw [hsnorm] at h1
linarith [h1, hlog_nn]
· -- the left near-axis: 5e-ii (A) with c = 1/8
push Not at hre2
have him10 : |s.im| < 10 := by
rw [him2] at him
have h1 : |s.im / 2| = |s.im| / 2 := by
rw [abs_div, abs_of_nonneg (by norm_num : (0 : ℝ) ≤ 2)]
linarith [him, h1]
-- (re s)² = R² − (im s)² > R²−100 ⟹ |re s| > R−100/R
have hnormSq : ‖s‖ ^ 2 = s.re ^ 2 + s.im ^ 2 := by
rw [← Complex.normSq_eq_norm_sq, Complex.normSq_apply]
ring
have himsq : s.im ^ 2 < 100 := by
have h1 : s.im ^ 2 = |s.im| ^ 2 := (sq_abs s.im).symm
rw [h1]
nlinarith [him10, abs_nonneg s.im]
have hre2sq : s.re ^ 2 = R ^ 2 - s.im ^ 2 := by
have h1 : s.re ^ 2 + s.im ^ 2 = R ^ 2 := by rw [← hnormSq, hs]
linarith
have hRmin : R - |s.re| < 100 / R := by
have h9 : |s.re| ≤ R := by
have h10 := abs_re_le_norm s
rw [hs] at h10
exact h10
have h1 : (R - |s.re|) * (R + |s.re|) = s.im ^ 2 := by
have h2 : (R - |s.re|) * (R + |s.re|) = R ^ 2 - |s.re| ^ 2 := by ring
rw [h2, sq_abs]
linarith [hre2sq]
have h3 : (R - |s.re|) * (R + |s.re|) < 100 := by linarith [h1, himsq]
have h5 : (R - |s.re|) * R ≤ (R - |s.re|) * (R + |s.re|) :=
mul_le_mul_of_nonneg_left (by linarith [abs_nonneg s.re] : R ≤ R + |s.re|)
(by linarith [h9] : (0 : ℝ) ≤ R - |s.re|)
have h6 : (R - |s.re|) * R < 100 := by linarith [h3, h5]
exact (lt_div_iff₀ hRpos).mpr (show (R - |s.re|) * R < 100 from h6)
-- re(s/2) + R/2 ∈ [0, 50/R)
have hre_neg : (s / 2).re < 0 := by
have h14 : (100 : ℝ) / R < 1 := by
rw [div_lt_one hRpos]
linarith [hR]
have h15 : s.re < 0 := by
by_contra hcon
push Not at hcon
have h17 : |s.re| = s.re := abs_of_nonneg hcon
have h18 : R - s.re < 100 / R := by rw [← h17]; exact hRmin
rw [hre] at hre2
linarith [h18, hR, h14, hre2]
rw [hre]
linarith [h15]
-- the distance bound
have hdist : ∀ m : ℕ, (1 / 8 : ℝ) ≤ ‖(s / 2) + (m : ℂ)‖ := by
intro m
have h1 : ‖(s / 2) + (m : ℂ)‖ ≥ |((s / 2) + (m : ℂ)).re| := Complex.abs_re_le_norm _
have h2 : ((s / 2) + (m : ℂ)).re = s.re / 2 + (m : ℝ) := by
rw [Complex.add_re, hre, Complex.natCast_re]
rw [h2] at h1
-- (re s)/2 + R/2 ∈ [0, 50/R)
have hge : (0 : ℝ) ≤ s.re / 2 + R / 2 := by
have h9 : |s.re| ≤ R := by
have h10 := abs_re_le_norm s
rw [hs] at h10
exact h10
have h11 : -R ≤ s.re := by
have h12 := abs_le.mp (show |s.re| ≤ R from h9)
linarith [h12.1]
linarith [h11]
have hlt : s.re / 2 + R / 2 < 50 / R := by
have h15 : s.re < 0 := by
have h16 := hre_neg
rw [hre] at h16
linarith [h16]
have h19 : R + s.re < 100 / R := by
have h20 : |s.re| = -s.re := abs_of_neg h15
have h21 : R - (-s.re) < 100 / R := by rw [← h20]; exact hRmin
linarith [h21]
have h22 : s.re / 2 + R / 2 = (R + s.re) / 2 := by ring
have h23 : (50 : ℝ) / R = 100 / R / 2 := by field_simp; ring
rw [h22, h23]
linarith [h19]
-- |x + m| ≥ |m − R/2| − (x + R/2) ≥ 1/4 − 50/R ≥ 1/8
have hgap' := hgapInt (m : ℤ)
have hcast : ((m : ℤ) : ℝ) = (m : ℝ) := by push_cast; ring
rw [hcast] at hgap'
have h4 : |(m : ℝ) - R / 2| - (s.re / 2 + R / 2) ≤ |s.re / 2 + (m : ℝ)| := by
have h7 := abs_sub_abs_le_abs_sub ((m : ℝ) - R / 2) (-(s.re / 2 + R / 2))
rw [abs_neg, sub_neg_eq_add] at h7
have h5 : (m : ℝ) - R / 2 + (s.re / 2 + R / 2) = s.re / 2 + (m : ℝ) := by ring
rw [h5] at h7
have h8 : |s.re / 2 + R / 2| = s.re / 2 + R / 2 := abs_of_nonneg hge
linarith [h7, h8]
have h50 : (50 : ℝ) / R ≤ 1 / 8 := by
rw [div_le_iff₀ hRpos]
linarith [hR]
have h9 : |R / 2 - (m : ℝ)| = |(m : ℝ) - R / 2| := abs_sub_comm _ _
linarith [h1, h4, hgap', h9, hlt, h50]
have hwre2 : (s / 2).re ≤ 2 := by linarith [hre_neg]
have h1 := norm_digamma_le_of_dist_nat (show (0 : ℝ) < 1 / 8 by norm_num)
hwre2 hdist
have h2 : (46 : ℝ) + 2 / (1 / 8) = 62 := by norm_num
rw [h2, hsnorm] at h1
exact h1
/-- ‖1/s‖ ≤ 1 on ‖s‖ = R ≥ 1. -/
lemma norm_one_div_le_of_norm_eq {s : ℂ} {R : ℝ} (hs : ‖s‖ = R) (hR : (1 : ℝ) ≤ R) :
‖(1 : ℂ) / s‖ ≤ 1 := by
rw [norm_div, norm_one, hs]
exact div_le_one_of_le₀ hR (by linarith [hR] : (0 : ℝ) ≤ R)
/-- ‖1/(s−1)‖ ≤ 1 on ‖s‖ = R ≥ 2 (‖s−1‖ ≥ R−1 ≥ 1). -/
lemma norm_one_div_sub_one_le_of_norm_eq {s : ℂ} {R : ℝ} (hs : ‖s‖ = R)
(hR : (2 : ℝ) ≤ R) : ‖(1 : ℂ) / (s - 1)‖ ≤ 1 := by
have hnorm : (1 : ℝ) ≤ ‖s - 1‖ := by
have h := abs_norm_sub_norm_le s (1 : ℂ)
rw [hs, norm_one, abs_of_nonneg (by linarith [hR] : (0 : ℝ) ≤ R - 1)] at h
linarith [h, hR]
rw [norm_div, norm_one]
exact div_le_one_of_le₀ hnorm (norm_nonneg _)
/-- log π ≤ 2 (π < 3.15 ≤ e²). -/
lemma log_pi_le_two : Real.log Real.pi ≤ 2 := by
rw [show (2 : ℝ) = Real.log (Real.exp 2) by rw [Real.log_exp]]
apply Real.log_le_log Real.pi_pos
have h1 : Real.exp 2 = (Real.exp 1) ^ 2 := by
rw [← Real.exp_nat_mul]; norm_num
have h2 : (2.7 : ℝ) ≤ Real.exp 1 := by
have h := Real.exp_one_gt_d9; linarith
have h3 : (2.7 : ℝ) ^ 2 ≤ (Real.exp 1) ^ 2 :=
pow_le_pow_left₀ (by norm_num) h2 2
have h4 := Real.pi_lt_d2
have h5 : Real.pi ≤ (2.7 : ℝ) ^ 2 := by
have h6 : (2.7 : ℝ) ^ 2 = 7.29 := by norm_num
linarith [h4, h6]
linarith [h1, h3, h5]
/-- ‖(log π : ℂ)/2‖ ≤ 1. -/
lemma norm_logPi_div_two_le : ‖(Real.log Real.pi : ℂ) / 2‖ ≤ 1 := by
have hpos : (0 : ℝ) < Real.log Real.pi :=
Real.log_pos (by linarith [Real.pi_gt_three] : (1 : ℝ) < Real.pi)
have hle := log_pi_le_two
rw [norm_div]
have h1 : ‖(Real.log Real.pi : ℂ)‖ = Real.log Real.pi := by
rw [show ((Real.log Real.pi : ℂ)) = ((Real.log Real.pi : ℝ) : ℂ) from rfl,
Complex.norm_real, Real.norm_eq_abs, abs_of_pos hpos]
rw [h1]
have h2 : ‖(2 : ℂ)‖ = 2 := by
rw [show (2 : ℂ) = ((2 : ℝ) : ℂ) by push_cast; ring, Complex.norm_real]
norm_num
rw [h2]
linarith [hle]
/-! ## 12. The logDeriv circle bound and the Fexpr assembly (5e-v-c-iii)
`logDeriv_circle_le`: three regions — (i) re s ≥ 2: the Dirichlet
bound; (ii) re s ∈ [−5/2, 2] (automatically |im s| ≥ 10): the 5c/5d
capstones + the near sum ≤ 32·Ĉ₀·(near count); (iii) re s < −5/2: the
FE identity `logDeriv_zeta_fe` + Dirichlet at 1−s + the ΓR bracket
via `logDeriv_Gammaℝ_eq_of_not_neg_nat` (which also discharges the
real point s = −R). Uniform:
‖logDeriv ζ s‖ ≤ dirichletC2 + 200000·(log R)² + 300·A₀·Ĉ₀·(log R)².
`Fexpr_circle_le`: ‖Fexpr s‖ ≤ 2·lowZeroConst + dirichletC2 +
400000·A₀·Ĉ₀(R+2)·(log R)². -/
/-- **The logDeriv bound on the gap circle.** -/
theorem logDeriv_circle_le {k : ℕ} (hk : 4000 ≤ k) {R : ℝ}
(hRlo : 4 * (k : ℝ) + 5 / 2 ≤ R)
(hgap : ∀ ρ : ℂ, IsNontrivialZero ρ →
1 / (16 * C0hat (4 * (k : ℝ) + 9 / 2)) ≤ |ρ.im - R| ∨ 1 ≤ |ρ.im - R|)
(hgapInt : ∀ m : ℤ, 1 / 4 ≤ |R / 2 - (m : ℝ)|)
{s : ℂ} (hs : ‖s‖ = R) (hsz : ¬ IsNontrivialZero s) :
‖logDeriv riemannZeta s‖ ≤ dirichletC2 +
200000 * (Real.log R) ^ 2 +
300 * A0count * C0hat (4 * (k : ℝ) + 9 / 2) * (Real.log R) ^ 2 := by
classical
have hĈ2 : (2 : ℝ) ≤ C0hat (4 * (k : ℝ) + 9 / 2) := two_le_C0hat (by
have hkR : (1 : ℝ) ≤ (k : ℝ) := by exact_mod_cast (by omega : 1 ≤ k)
linarith)
have hR : (16002 : ℝ) ≤ R := by
have hkR : (16000 : ℝ) ≤ 4 * (k : ℝ) := by
have h1 : (4000 : ℝ) ≤ (k : ℝ) := by exact_mod_cast hk
linarith
linarith [hRlo]
have hRpos : (0 : ℝ) < R := by linarith [hR]
have hlogR : (9 : ℝ) ≤ Real.log R := nine_le_log_of_16002_le hR
have hlogRnn : (0 : ℝ) ≤ Real.log R := by linarith [hlogR]
have hA0 := A0count_pos.le
have hĈpos : (0 : ℝ) < C0hat (4 * (k : ℝ) + 9 / 2) := by linarith [hĈ2]
have hnnR : (0 : ℝ) ≤ 200000 * (Real.log R) ^ 2 +
300 * A0count * C0hat (4 * (k : ℝ) + 9 / 2) * (Real.log R) ^ 2 := by
apply add_nonneg (mul_nonneg (by norm_num) (pow_two_nonneg _))
exact mul_nonneg (mul_nonneg (mul_nonneg (by norm_num) hA0) hĈpos.le)
(pow_two_nonneg _)
-- ζ s ≠ 0 on the whole circle
have hζs : riemannZeta s ≠ 0 := by
intro h
rcases zeta_zero_classification h with hn | h0 | ⟨n, hn, h2n⟩
· exact hsz hn
· rw [h0, norm_zero] at hs
linarith [hs, hR]
· -- s = −2n: R = ‖s‖ = 2n; n ≥ 2: R/2 = n ∈ ℤ contradicts the
-- ℤ-clearance; n = 1: R = 2 contradicts R ≥ 16002
have hnorm : ‖s‖ = 2 * (n : ℝ) := by
rw [h2n, norm_mul]
have h1 : ‖(-2 : ℂ)‖ = 2 := by
rw [show (-2 : ℂ) = ((-2 : ℝ) : ℂ) by push_cast; ring, Complex.norm_real]
norm_num
rw [h1, Complex.norm_natCast]
rw [hs] at hnorm
have hnn : (1 : ℝ) ≤ (n : ℝ) := by exact_mod_cast hn
by_cases hn2 : n = 1
· rw [hn2] at hnorm
push_cast at hnorm
linarith [hnorm, hR]
· have hn3 : 2 ≤ n := by omega
have hR2n : R / 2 = (n : ℝ) := by
have h4 : (2 : ℝ) ≤ (n : ℝ) := by exact_mod_cast hn3
linarith [hnorm]
have hgap' := hgapInt (n : ℤ)
have hcast : ((n : ℤ) : ℝ) = (n : ℝ) := by push_cast; ring
rw [hcast, ← hR2n] at hgap'
rw [show R / 2 - R / 2 = (0 : ℝ) by ring, abs_zero] at hgap'
norm_num at hgap'
-- the three regions
by_cases hreg1 : 2 ≤ s.re
· -- (i) the Dirichlet bound
have h1 := norm_logDeriv_zeta_le_dirichlet hreg1
linarith [h1, hnnR, dirichletC2_nonneg]
· push Not at hreg1
by_cases hreg2 : -5 / 2 ≤ s.re
· -- (ii) the capstones + the near sum
have ht10 : (10 : ℝ) ≤ |s.im| := by
have hre25 : s.re ^ 2 ≤ 25 / 4 := by
have h1 : -5 / 2 ≤ s.re ∧ s.re ≤ 2 := ⟨hreg2, hreg1.le⟩
nlinarith [sq_nonneg s.re]
have hRt : R - |s.im| ≤ (25 / 4) / R :=
norm_circle_sub_abs_im_le hs hRpos hre25
have h1 : (25 / 4 : ℝ) / R ≤ 1 := by
rw [div_le_one hRpos]
linarith [hR]
have ht_le : |s.im| ≤ R := by
have h := abs_im_le_norm s
rw [hs] at h
exact h
linarith [hRt, h1, ht_le, hR]
-- the near sum
have hnear : ‖∑ ρ ∈ nearZeros s.im, (zeroMult ρ : ℂ) / (s - ρ)‖
≤ 32 * C0hat (4 * (k : ℝ) + 9 / 2) * (3 * A0count) *
Real.log (3 * max |s.im - 1| |s.im + 1| + 5) := by
calc ‖∑ ρ ∈ nearZeros s.im, (zeroMult ρ : ℂ) / (s - ρ)‖
≤ ∑ ρ ∈ nearZeros s.im, ‖(zeroMult ρ : ℂ) / (s - ρ)‖ := norm_sum_le _ _
_ = ∑ ρ ∈ nearZeros s.im, (zeroMult ρ : ℝ) / ‖s - ρ‖ := by
apply Finset.sum_congr rfl
intro ρ hρ
rw [norm_div, RCLike.norm_natCast]
_ ≤ ∑ ρ ∈ nearZeros s.im, (zeroMult ρ : ℝ) * (32 * C0hat (4 * (k : ℝ) + 9 / 2)) := by
apply Finset.sum_le_sum
intro ρ hρ
have hsep := gapCircle_sep_of_mem_nearZeros hk hRlo hgap hs hρ
rw [show (zeroMult ρ : ℝ) / ‖s - ρ‖ = (zeroMult ρ : ℝ) * (1 / ‖s - ρ‖) from by ring]
apply mul_le_mul_of_nonneg_left _ (Nat.cast_nonneg _)
have h1 : (0 : ℝ) < 1 / (32 * C0hat (4 * (k : ℝ) + 9 / 2)) := by positivity
exact (one_div_le_one_div_of_le h1 hsep).trans_eq (one_div_one_div _)
_ = (32 * C0hat (4 * (k : ℝ) + 9 / 2)) * ∑ ρ ∈ nearZeros s.im, (zeroMult ρ : ℝ) := by
rw [← Finset.sum_congr rfl (g := fun ρ => (zeroMult ρ : ℝ) *
(32 * C0hat (4 * (k : ℝ) + 9 / 2))) (fun ρ hρ => mul_comm _ _), Finset.mul_sum]
_ ≤ (32 * C0hat (4 * (k : ℝ) + 9 / 2)) *
(3 * A0count * Real.log (3 * max |s.im - 1| |s.im + 1| + 5)) :=
mul_le_mul_of_nonneg_left nearZeros_count_le (by positivity)
_ = 32 * C0hat (4 * (k : ℝ) + 9 / 2) * (3 * A0count) *
Real.log (3 * max |s.im - 1| |s.im + 1| + 5) := by ring
have hlogmax : Real.log (3 * max |s.im - 1| |s.im + 1| + 5) ≤ 2 * Real.log R := by
have hmax : max |s.im - 1| |s.im + 1| ≤ |s.im| + 1 := by
apply max_le_iff.mpr
constructor
· have h4 : s.im - 1 = s.im + (-1 : ℝ) := by ring
rw [h4]
have h := abs_add_le s.im (-1 : ℝ)
rwa [abs_neg, abs_one] at h
· have h := abs_add_le s.im (1 : ℝ)
rwa [abs_one] at h
have ht_le : |s.im| ≤ R := by
have h := abs_im_le_norm s
rw [hs] at h
exact h
have h1 : Real.log (3 * max |s.im - 1| |s.im + 1| + 5) ≤ Real.log (3 * (|s.im| + 1) + 5) := by
apply Real.log_le_log (by positivity)
have h4 : 3 * max |s.im - 1| |s.im + 1| ≤ 3 * (|s.im| + 1) :=
mul_le_mul_of_nonneg_left hmax (by norm_num : (0 : ℝ) ≤ 3)
linarith [h4]
have h2 : Real.log (3 * (|s.im| + 1) + 5) ≤ Real.log (4 * R) := by
apply Real.log_le_log (by linarith [abs_nonneg s.im, hRpos])
linarith [ht_le, hR]
have h3 : Real.log (4 * R) = Real.log 4 + Real.log R :=
Real.log_mul (by norm_num : (4 : ℝ) ≠ 0) (by linarith [hRpos] : R ≠ 0)
have h4 : Real.log 4 ≤ Real.log R :=
Real.log_le_log (by norm_num) (by linarith [hR])
linarith [h1, h2, h3, h4]
-- the capstone difference
have hcap : ‖logDeriv riemannZeta s - ∑ ρ ∈ nearZeros s.im, (zeroMult ρ : ℂ) / (s - ρ)‖
≤ 200000 * (Real.log |s.im|) ^ 2 := by
by_cases hhalf : (1 : ℝ) / 2 ≤ s.re
· exact (logDeriv_riemannZeta_sub_nearZeros_le (t := s.im) ht10 rfl hhalf
(by linarith [hreg1] : s.re ≤ 7 / 2) hζs).trans
(mul_le_mul_of_nonneg_right (by norm_num : (100000 : ℝ) ≤ 200000)
(pow_two_nonneg _))
· push Not at hhalf
exact logDeriv_riemannZeta_sub_nearZeros_le_left (t := s.im) ht10 rfl hreg2
(by linarith [hhalf] : s.re ≤ 1 / 2) hζs
have hlogt : (Real.log |s.im|) ^ 2 ≤ (Real.log R) ^ 2 := by
have ht_le : |s.im| ≤ R := by
have h := abs_im_le_norm s
rw [hs] at h
exact h
have h1 : Real.log |s.im| ≤ Real.log R :=
Real.log_le_log (by linarith [ht10] : (0 : ℝ) < |s.im|) ht_le
have h2 : (0 : ℝ) ≤ Real.log |s.im| :=
Real.log_nonneg (by linarith [ht10] : (1 : ℝ) ≤ |s.im|)
exact pow_le_pow_left₀ h2 h1 2
calc ‖logDeriv riemannZeta s‖
= ‖(logDeriv riemannZeta s - ∑ ρ ∈ nearZeros s.im, (zeroMult ρ : ℂ) / (s - ρ))
+ ∑ ρ ∈ nearZeros s.im, (zeroMult ρ : ℂ) / (s - ρ)‖ := by
rw [sub_add_cancel]
_ ≤ ‖logDeriv riemannZeta s - ∑ ρ ∈ nearZeros s.im, (zeroMult ρ : ℂ) / (s - ρ)‖
+ ‖∑ ρ ∈ nearZeros s.im, (zeroMult ρ : ℂ) / (s - ρ)‖ :=
norm_add_le _ _
_ ≤ 200000 * (Real.log |s.im|) ^ 2 +
32 * C0hat (4 * (k : ℝ) + 9 / 2) * (3 * A0count) *
Real.log (3 * max |s.im - 1| |s.im + 1| + 5) :=
add_le_add hcap hnear
_ ≤ dirichletC2 + 200000 * (Real.log R) ^ 2 +
300 * A0count * C0hat (4 * (k : ℝ) + 9 / 2) * (Real.log R) ^ 2 := by
have h1 : 32 * C0hat (4 * (k : ℝ) + 9 / 2) * (3 * A0count) *
Real.log (3 * max |s.im - 1| |s.im + 1| + 5)
≤ 192 * A0count * C0hat (4 * (k : ℝ) + 9 / 2) * (Real.log R) ^ 2 := by
have h2 := mul_le_mul_of_nonneg_left hlogmax
(mul_nonneg (mul_nonneg (by norm_num : (0 : ℝ) ≤ 32) hĈpos.le)
(mul_nonneg (by norm_num : (0 : ℝ) ≤ 3) hA0))
have h3 : 32 * C0hat (4 * (k : ℝ) + 9 / 2) * (3 * A0count) * (2 * Real.log R)
= 192 * A0count * C0hat (4 * (k : ℝ) + 9 / 2) * Real.log R := by ring
have h4 : 192 * A0count * C0hat (4 * (k : ℝ) + 9 / 2) * Real.log R
≤ 192 * A0count * C0hat (4 * (k : ℝ) + 9 / 2) * (Real.log R) ^ 2 := by
apply mul_le_mul_of_nonneg_left _ (mul_nonneg (mul_nonneg (by norm_num) hA0) hĈpos.le)
nlinarith [hlogR, hlogRnn]
rw [h3] at h2
exact h2.trans h4
have h5 : 192 * A0count * C0hat (4 * (k : ℝ) + 9 / 2) * (Real.log R) ^ 2
≤ 300 * A0count * C0hat (4 * (k : ℝ) + 9 / 2) * (Real.log R) ^ 2 := by
apply mul_le_mul_of_nonneg_right _ (pow_two_nonneg _)
apply mul_le_mul_of_nonneg_right _ hĈpos.le
apply mul_le_mul_of_nonneg_right _ hA0
norm_num
nlinarith [hlogt, h1, h5, hlogRnn, dirichletC2_nonneg, pow_two_nonneg (Real.log R)]
· -- (iii) the FE route
push Not at hreg2
-- pole-avoidance for s/2
have hpoles : ∀ m : ℕ, s / 2 ≠ -(m : ℂ) := by
intro m hm
by_cases him : s.im = 0
· -- s real: s = −R, then R/2 = m contradicts the ℤ-clearance
have hsR : s = (-R : ℝ) := by
have hnormSq : ‖s‖ ^ 2 = s.re ^ 2 + s.im ^ 2 := by
rw [← Complex.normSq_eq_norm_sq, Complex.normSq_apply]
ring
have h1 : s.re ^ 2 + s.im ^ 2 = R ^ 2 := by rw [← hnormSq, hs]
rw [him] at h1
have h2 : s.re ^ 2 = R ^ 2 := by linarith [h1, sq_nonneg s.re]
have h4 : s.re = -R := by
have h5 : (s.re - R) * (s.re + R) = 0 := by
have h7 : s.re ^ 2 - R ^ 2 = (s.re - R) * (s.re + R) := by ring
rw [← h7]
linarith [h2]
rcases mul_eq_zero.mp h5 with h8 | h8
· have h9 : s.re = R := by linarith [h8]
linarith [h9, hreg2]
· linarith [h8]
apply Complex.ext_iff.mpr
rw [h4, him]
simp
rw [hsR] at hm
have hm2 : (m : ℝ) = R / 2 := by
have h1 := congrArg Complex.re hm
have h2 : (↑(-R) / 2 : ℂ).re = -R / 2 := by simp
have h3 : (-(m : ℂ)).re = -(m : ℝ) := by
rw [Complex.neg_re, Complex.natCast_re]
rw [h2, h3] at h1
linarith [h1]
have hgap' := hgapInt (m : ℤ)
have hcast : ((m : ℤ) : ℝ) = (m : ℝ) := by push_cast; ring
rw [hcast, hm2] at hgap'
rw [show R / 2 - R / 2 = (0 : ℝ) by ring, abs_zero] at hgap'
norm_num at hgap'
· have h1 : (s / 2).im ≠ 0 := by
have h2 : (s / 2).im = s.im / 2 := by simp
rw [h2]
exact div_ne_zero him (two_ne_zero : (2 : ℝ) ≠ 0)
have h3 : (-(m : ℂ)).im = 0 := by simp
have h4 : (s / 2).im = (-(m : ℂ)).im := congrArg Complex.im hm
rw [h3] at h4
exact h1 h4
-- the FE identity
have hG : Complex.Gammaℝ s ≠ 0 := by
rw [ne_eq, Complex.Gammaℝ_eq_zero_iff]
rintro ⟨m, hm⟩
have h1 : s / 2 = -(m : ℂ) := by
rw [hm]
ring
exact hpoles m h1
have hG1 : Complex.Gammaℝ (1 - s) ≠ 0 := by
rw [ne_eq, Complex.Gammaℝ_eq_zero_iff]
rintro ⟨m, hm⟩
have h2 : (1 - s) / 2 = -(m : ℂ) := by
rw [hm]
ring
have hre : ((1 - s) / 2).re = -(m : ℝ) := by
have h4 : ((1 - s) / 2).re = (1 - s.re) / 2 := by simp
rw [h4]
have h3 := congrArg Complex.re h2
rw [Complex.neg_re, Complex.natCast_re] at h3
rw [h4] at h3
exact h3
have hpos : (0 : ℝ) < ((1 - s) / 2).re := by
have h1 : ((1 - s) / 2).re = (1 - s.re) / 2 := by simp
rw [h1]
linarith [hreg2]
rw [hre] at hpos
have hmn : (0 : ℝ) ≤ (m : ℝ) := Nat.cast_nonneg _
linarith [hpos, hmn]
have hζ1 : riemannZeta (1 - s) ≠ 0 := by
apply riemannZeta_ne_zero_of_one_le_re
have h1 : (1 - s).re = 1 - s.re := by simp
rw [h1]
linarith [hreg2]
have hs0' : s ≠ 0 := fun h => by rw [h, norm_zero] at hs; linarith [hs, hR]
have hs1' : s ≠ 1 := fun h => by
have h1 : s.re = 1 := by rw [h]; simp
linarith [h1, hreg2]
have h1s0' : (1 : ℂ) - s ≠ 0 := fun h => by
have h2 : s = 1 := by linear_combination -h
exact absurd h2 hs1'
have h1s1' : (1 : ℂ) - s ≠ 1 := fun h => by
have h2 : s = 0 := by linear_combination -h
exact absurd h2 hs0'
have hd1' : DifferentiableAt ℂ Complex.Gammaℝ (1 - s) :=
differentiableAt_Gammaℝ_of_not_neg_nat (fun m hm => by
have hre : ((1 - s) / 2).re = (1 - s.re) / 2 := by simp
have h1 : (0 : ℝ) < ((1 - s) / 2).re := by rw [hre]; linarith [hreg2]
have h2 : (-(m : ℂ)).re = -(m : ℝ) := by
rw [Complex.neg_re, Complex.natCast_re]
have h3 := congrArg Complex.re hm
rw [hre, h2] at h3
have hmn : (0 : ℝ) ≤ (m : ℝ) := Nat.cast_nonneg _
linarith [h1, h3, hmn])
have hfe := logDeriv_zeta_fe hs0' hs1' hG hζs
(differentiableAt_Gammaℝ_of_not_neg_nat hpoles)
h1s0' h1s1' hG1 hζ1 hd1'
-- the bracket bound
have hbr1 : logDeriv Complex.Gammaℝ s
= -(Real.log Real.pi : ℂ) / 2 + (1 / 2 : ℂ) * Complex.digamma (s / 2) :=
logDeriv_Gammaℝ_eq_of_not_neg_nat hpoles
have hbr2 : logDeriv Complex.Gammaℝ (1 - s)
= -(Real.log Real.pi : ℂ) / 2 + (1 / 2 : ℂ) * Complex.digamma ((1 - s) / 2) :=
logDeriv_Gammaℝ_eq_of_not_neg_nat (fun m hm => by
have hre : ((1 - s) / 2).re = (1 - s.re) / 2 := by simp
have h1 : (0 : ℝ) < ((1 - s) / 2).re := by rw [hre]; linarith [hreg2]
have h2 : (-(m : ℂ)).re = -(m : ℝ) := by
rw [Complex.neg_re, Complex.natCast_re]
have h3 := congrArg Complex.re hm
rw [hre, h2] at h3
have hmn : (0 : ℝ) ≤ (m : ℝ) := Nat.cast_nonneg _
linarith [h1, h3, hmn])
have hψ1 : ‖Complex.digamma (s / 2)‖ ≤ 62 + 23 * Real.log (2 + R / 2) :=
digamma_circle_le hs hgapInt hR
have hψ2 : ‖Complex.digamma ((1 - s) / 2)‖ ≤ 48 + 23 * Real.log R := by
have hre : ((1 - s) / 2).re = (1 - s.re) / 2 := by simp
have h1 : (1.75 : ℝ) ≤ ((1 - s) / 2).re := by rw [hre]; linarith [hreg2]
have h2 := digamma_right_le h1
have hnorm : ‖(1 - s) / 2‖ = ‖1 - s‖ / 2 := by
rw [norm_div]
have h3 : ‖(2 : ℂ)‖ = 2 := by
rw [show (2 : ℂ) = ((2 : ℝ) : ℂ) by push_cast; ring, Complex.norm_real]
norm_num
rw [h3]
have hnorm1s : ‖1 - s‖ ≤ 1 + R := by
calc ‖1 - s‖ ≤ ‖(1 : ℂ)‖ + ‖s‖ := norm_sub_le _ _
_ = 1 + R := by rw [norm_one, hs]
have hlogle : Real.log (2 + ‖(1 - s) / 2‖) ≤ Real.log R := by
apply Real.log_le_log (by positivity)
rw [hnorm]
linarith [hnorm1s, hR]
have hlog2w_nn : (0 : ℝ) ≤ Real.log (2 + ‖(1 - s) / 2‖) := by
apply Real.log_nonneg
have h3 : (0 : ℝ) ≤ ‖(1 - s) / 2‖ := norm_nonneg _
linarith [h3]
linarith [h2, hlogle, hlog2w_nn, hlogRnn]
-- assemble case (iii)
have hld1 : ‖logDeriv riemannZeta (1 - s)‖ ≤ dirichletC2 := by
apply norm_logDeriv_zeta_le_dirichlet
have h1 : (1 - s).re = 1 - s.re := by simp
rw [h1]
linarith [hreg2]
rw [hfe]
have hstep1 : ‖-logDeriv riemannZeta (1 - s)
- (logDeriv Complex.Gammaℝ s + logDeriv Complex.Gammaℝ (1 - s))‖
≤ ‖logDeriv riemannZeta (1 - s)‖ +
‖logDeriv Complex.Gammaℝ s + logDeriv Complex.Gammaℝ (1 - s)‖ := by
calc ‖-logDeriv riemannZeta (1 - s)
- (logDeriv Complex.Gammaℝ s + logDeriv Complex.Gammaℝ (1 - s))‖
≤ ‖-logDeriv riemannZeta (1 - s)‖ +
‖logDeriv Complex.Gammaℝ s + logDeriv Complex.Gammaℝ (1 - s)‖ :=
norm_sub_le _ _
_ = ‖logDeriv riemannZeta (1 - s)‖ +
‖logDeriv Complex.Gammaℝ s + logDeriv Complex.Gammaℝ (1 - s)‖ := by
rw [norm_neg]
have hbracket : ‖logDeriv Complex.Gammaℝ s + logDeriv Complex.Gammaℝ (1 - s)‖
≤ 2 + (62 + 23 * Real.log (2 + R / 2)) / 2 + (48 + 23 * Real.log R) / 2 := by
rw [hbr1, hbr2]
have h1 : -(Real.log Real.pi : ℂ) / 2 + (1 / 2 : ℂ) * Complex.digamma (s / 2) +
(-(Real.log Real.pi : ℂ) / 2 + (1 / 2 : ℂ) * Complex.digamma ((1 - s) / 2))
= -(Real.log Real.pi : ℂ) +
((1 / 2 : ℂ) * Complex.digamma (s / 2) +
(1 / 2 : ℂ) * Complex.digamma ((1 - s) / 2)) := by ring
rw [h1]
calc ‖-(Real.log Real.pi : ℂ) +
((1 / 2 : ℂ) * Complex.digamma (s / 2) +
(1 / 2 : ℂ) * Complex.digamma ((1 - s) / 2))‖
≤ ‖(Real.log Real.pi : ℂ)‖ +
‖(1 / 2 : ℂ) * Complex.digamma (s / 2) +
(1 / 2 : ℂ) * Complex.digamma ((1 - s) / 2)‖ := by
have h2 := norm_add_le (-(Real.log Real.pi : ℂ))
((1 / 2 : ℂ) * Complex.digamma (s / 2) +
(1 / 2 : ℂ) * Complex.digamma ((1 - s) / 2))
rw [norm_neg] at h2
exact h2
_ ≤ 2 + ((62 + 23 * Real.log (2 + R / 2)) / 2 + (48 + 23 * Real.log R) / 2) := by
have hlogpi : ‖(Real.log Real.pi : ℂ)‖ ≤ 2 := by
have h1 := log_pi_le_two
have hpos : (0 : ℝ) < Real.log Real.pi :=
Real.log_pos (by linarith [Real.pi_gt_three] : (1 : ℝ) < Real.pi)
rw [show ((Real.log Real.pi : ℂ)) = ((Real.log Real.pi : ℝ) : ℂ) from rfl,
Complex.norm_real, Real.norm_eq_abs, abs_of_pos hpos]
exact h1
have hψ : ‖(1 / 2 : ℂ) * Complex.digamma (s / 2) +
(1 / 2 : ℂ) * Complex.digamma ((1 - s) / 2)‖
≤ (62 + 23 * Real.log (2 + R / 2)) / 2 + (48 + 23 * Real.log R) / 2 := by
calc ‖(1 / 2 : ℂ) * Complex.digamma (s / 2) +
(1 / 2 : ℂ) * Complex.digamma ((1 - s) / 2)‖
≤ ‖(1 / 2 : ℂ) * Complex.digamma (s / 2)‖ +
‖(1 / 2 : ℂ) * Complex.digamma ((1 - s) / 2)‖ := norm_add_le _ _
_ = ‖Complex.digamma (s / 2)‖ / 2 + ‖Complex.digamma ((1 - s) / 2)‖ / 2 := by
have h1 : ‖(1 / 2 : ℂ)‖ = 1 / 2 := by
rw [show (1 / 2 : ℂ) = ((1 / 2 : ℝ) : ℂ) by push_cast; ring,
Complex.norm_real]
norm_num
rw [norm_mul, h1, norm_mul, h1]
ring
_ ≤ (62 + 23 * Real.log (2 + R / 2)) / 2 + (48 + 23 * Real.log R) / 2 := by
have h1 := div_le_div_of_nonneg_right hψ1 (by norm_num : (0 : ℝ) ≤ 2)
have h2 := div_le_div_of_nonneg_right hψ2 (by norm_num : (0 : ℝ) ≤ 2)
have h3 : ‖Complex.digamma (s / 2)‖ / 2
≤ (62 + 23 * Real.log (2 + R / 2)) / 2 := h1
have h4 : ‖Complex.digamma ((1 - s) / 2)‖ / 2
≤ (48 + 23 * Real.log R) / 2 := h2
linarith [h3, h4]
linarith [hlogpi, hψ]
_ = 2 + (62 + 23 * Real.log (2 + R / 2)) / 2 + (48 + 23 * Real.log R) / 2 := by ring
have hlog2R : Real.log (2 + R / 2) ≤ Real.log R := by
apply Real.log_le_log (by linarith [hRpos] : (0 : ℝ) < 2 + R / 2)
linarith [hR]
calc ‖-logDeriv riemannZeta (1 - s)
- (logDeriv Complex.Gammaℝ s + logDeriv Complex.Gammaℝ (1 - s))‖
≤ ‖logDeriv riemannZeta (1 - s)‖ +
‖logDeriv Complex.Gammaℝ s + logDeriv Complex.Gammaℝ (1 - s)‖ := hstep1
_ ≤ dirichletC2 + (2 + (62 + 23 * Real.log (2 + R / 2)) / 2 +
(48 + 23 * Real.log R) / 2) := add_le_add hld1 hbracket
_ ≤ dirichletC2 + 200000 * (Real.log R) ^ 2 +
300 * A0count * C0hat (4 * (k : ℝ) + 9 / 2) * (Real.log R) ^ 2 := by
have h1 : 2 + (62 + 23 * Real.log (2 + R / 2)) / 2 + (48 + 23 * Real.log R) / 2
≤ 100 * A0count * C0hat (4 * (k : ℝ) + 9 / 2) * (Real.log R) ^ 2 := by
have h2 : 2 + (62 + 23 * Real.log (2 + R / 2)) / 2 + (48 + 23 * Real.log R) / 2
≤ 57 + 23 * Real.log R := by
have h3 := div_le_div_of_nonneg_right hlog2R (by norm_num : (0 : ℝ) ≤ 2)
have h4 : (0 : ℝ) ≤ Real.log (2 + R / 2) :=
Real.log_nonneg (by linarith [hRpos] : (1 : ℝ) ≤ 2 + R / 2)
linarith [h3, h4, hlogRnn]
have h4 : (57 : ℝ) + 23 * Real.log R
≤ 100 * A0count * C0hat (4 * (k : ℝ) + 9 / 2) * (Real.log R) ^ 2 := by
have h5 : (2 : ℝ) ≤ A0count * C0hat (4 * (k : ℝ) + 9 / 2) := by
have h1c : (1 : ℝ) ≤ C0hat (4 * (k : ℝ) + 9 / 2) := by linarith [hĈ2]
have h2c : C0hat (4 * (k : ℝ) + 9 / 2)
≤ A0count * C0hat (4 * (k : ℝ) + 9 / 2) :=
calc C0hat (4 * (k : ℝ) + 9 / 2)
= 1 * C0hat (4 * (k : ℝ) + 9 / 2) := by ring
_ ≤ A0count * C0hat (4 * (k : ℝ) + 9 / 2) :=
mul_le_mul_of_nonneg_right A0count_ge_one hĈpos.le
linarith [hĈ2, h2c]
have h6 : (81 : ℝ) ≤ (Real.log R) ^ 2 := by nlinarith [hlogR, hlogRnn]
nlinarith [h5, h6, hA0, hĈpos, hlogRnn]
linarith [h2, h4]
nlinarith [h1, hnnR, dirichletC2_nonneg]
/-- **The Fexpr circle bound**: ‖Fexpr s‖ ≤ 2·lowZeroConst +
dirichletC2 + 400000·A₀·Ĉ₀(R+2)·(log R)². -/
theorem Fexpr_circle_le {k : ℕ} (hk : 4000 ≤ k) {R : ℝ}
(hRlo : 4 * (k : ℝ) + 5 / 2 ≤ R) (_hRhi : R ≤ 4 * (k : ℝ) + 3)
(hgap : ∀ ρ : ℂ, IsNontrivialZero ρ →
1 / (16 * C0hat (4 * (k : ℝ) + 9 / 2)) ≤ |ρ.im - R| ∨ 1 ≤ |ρ.im - R|)
(hgapInt : ∀ m : ℤ, 1 / 4 ≤ |R / 2 - (m : ℝ)|)
{s : ℂ} (hs : ‖s‖ = R) :
‖Fexpr s‖ ≤ 2 * lowZeroConst + dirichletC2 +
400000 * A0count * C0hat (R + 2) * (Real.log R) ^ 2 := by
classical
have hsz : ¬ IsNontrivialZero s :=
not_isNontrivialZero_on_gapCircle hk hRlo hgap hs
have hĈ2 : (2 : ℝ) ≤ C0hat (4 * (k : ℝ) + 9 / 2) := two_le_C0hat (by
have hkR : (1 : ℝ) ≤ (k : ℝ) := by exact_mod_cast (by omega : 1 ≤ k)
linarith)
have hR : (16002 : ℝ) ≤ R := by
have hkR : (16000 : ℝ) ≤ 4 * (k : ℝ) := by
have h1 : (4000 : ℝ) ≤ (k : ℝ) := by exact_mod_cast hk
linarith
linarith [hRlo]
have hRpos : (0 : ℝ) < R := by linarith [hR]
have hlogR : (9 : ℝ) ≤ Real.log R := nine_le_log_of_16002_le hR
have hlogRnn : (0 : ℝ) ≤ Real.log R := by linarith [hlogR]
have hA0 := A0count_pos.le
have hĈR2 : C0hat (4 * (k : ℝ) + 9 / 2) ≤ C0hat (R + 2) :=
C0hat_mono (by linarith [hRlo] : (1 : ℝ) ≤ 4 * (k : ℝ) + 9 / 2)
(by linarith [hRlo] : 4 * (k : ℝ) + 9 / 2 ≤ R + 2)
have hĈR2pos : (0 : ℝ) < C0hat (R + 2) := by linarith [hĈ2, hĈR2]
-- the pieces
have hser := seriesFun_norm_le_gapCircle hk hRlo hgap hs
have hld := logDeriv_circle_le hk hRlo hgap hgapInt hs hsz
have hψ := digamma_circle_le hs hgapInt hR
have h1s := norm_one_div_le_of_norm_eq hs (by linarith [hR] : (1 : ℝ) ≤ R)
have h1s1 := norm_one_div_sub_one_le_of_norm_eq hs (by linarith [hR] : (2 : ℝ) ≤ R)
have hlogpi := norm_logPi_div_two_le
-- the norm chain: Fexpr = logDeriv ζ − seriesFun + 1/s + 1/(s−1) − (log π)/2 + ψ(s/2)/2
have hchain : ‖Fexpr s‖ ≤ ‖logDeriv riemannZeta s‖ + ‖seriesFun s‖ +
‖(1 : ℂ) / s‖ + ‖(1 : ℂ) / (s - 1)‖ + ‖(Real.log Real.pi : ℂ) / 2‖ +
‖Complex.digamma (s / 2) / 2‖ := by
have hc1 : ‖Fexpr s‖ ≤ ‖logDeriv riemannZeta s - seriesFun s + 1 / s + 1 / (s - 1)
- (Real.log Real.pi : ℂ) / 2‖ + ‖Complex.digamma (s / 2) / 2‖ := by
rw [Fexpr]
exact norm_add_le _ _
have hc2 : ‖logDeriv riemannZeta s - seriesFun s + 1 / s + 1 / (s - 1)
- (Real.log Real.pi : ℂ) / 2‖
≤ ‖logDeriv riemannZeta s - seriesFun s + 1 / s + 1 / (s - 1)‖
+ ‖(Real.log Real.pi : ℂ) / 2‖ :=
norm_sub_le _ _
have hc3 : ‖logDeriv riemannZeta s - seriesFun s + 1 / s + 1 / (s - 1)‖
≤ ‖logDeriv riemannZeta s - seriesFun s + 1 / s‖ + ‖(1 : ℂ) / (s - 1)‖ :=
norm_add_le _ _
have hc4 : ‖logDeriv riemannZeta s - seriesFun s + 1 / s‖
≤ ‖logDeriv riemannZeta s - seriesFun s‖ + ‖(1 : ℂ) / s‖ :=
norm_add_le _ _
have hc5 : ‖logDeriv riemannZeta s - seriesFun s‖
≤ ‖logDeriv riemannZeta s‖ + ‖seriesFun s‖ :=
norm_sub_le _ _
linarith [hc1, hc2, hc3, hc4, hc5]
-- the ψ term: ‖ψ(s/2)/2‖ = ‖ψ(s/2)‖/2
have hψnorm : ‖Complex.digamma (s / 2) / 2‖ = ‖Complex.digamma (s / 2)‖ / 2 := by
rw [norm_div]
have h1 : ‖(2 : ℂ)‖ = 2 := by
rw [show (2 : ℂ) = ((2 : ℝ) : ℂ) by push_cast; ring, Complex.norm_real]
norm_num
rw [h1]
-- assemble
have hbig : ‖logDeriv riemannZeta s‖ + ‖seriesFun s‖ + ‖(1 : ℂ) / s‖ +
‖(1 : ℂ) / (s - 1)‖ + ‖(Real.log Real.pi : ℂ) / 2‖ + ‖Complex.digamma (s / 2) / 2‖
≤ 2 * lowZeroConst + dirichletC2 +
400000 * A0count * C0hat (R + 2) * (Real.log R) ^ 2 := by
have hser2 : ‖seriesFun s‖ ≤ 2 * lowZeroConst +
2900 * A0count * C0hat (R + 2) * (Real.log R) ^ 2 := by
have h1 : 2900 * A0count * C0hat (4 * (k : ℝ) + 9 / 2) * (Real.log R) ^ 2
≤ 2900 * A0count * C0hat (R + 2) * (Real.log R) ^ 2 :=
mul_le_mul_of_nonneg_right
(mul_le_mul_of_nonneg_left hĈR2
(mul_nonneg (by norm_num : (0 : ℝ) ≤ 2900) hA0)) (pow_two_nonneg _)
linarith [hser, h1]
have hld2 : ‖logDeriv riemannZeta s‖ ≤ dirichletC2 + 200000 * (Real.log R) ^ 2 +
300 * A0count * C0hat (R + 2) * (Real.log R) ^ 2 := by
have h1 : 300 * A0count * C0hat (4 * (k : ℝ) + 9 / 2) * (Real.log R) ^ 2
≤ 300 * A0count * C0hat (R + 2) * (Real.log R) ^ 2 :=
mul_le_mul_of_nonneg_right
(mul_le_mul_of_nonneg_left hĈR2
(mul_nonneg (by norm_num : (0 : ℝ) ≤ 300) hA0)) (pow_two_nonneg _)
linarith [hld, h1]
have hψ2 : ‖Complex.digamma (s / 2) / 2‖ ≤ 31 + 12 * Real.log R := by
rw [hψnorm]
have hlog2R : Real.log (2 + R / 2) ≤ Real.log R := by
apply Real.log_le_log (by linarith [hRpos] : (0 : ℝ) < 2 + R / 2)
linarith [hR]
have h1 : (62 + 23 * Real.log (2 + R / 2)) / 2
≤ (62 + 23 * Real.log R) / 2 :=
div_le_div_of_nonneg_right (add_le_add (le_refl _)
(mul_le_mul_of_nonneg_left hlog2R (by norm_num : (0 : ℝ) ≤ 23))) (by norm_num)
have h2 := div_le_div_of_nonneg_right hψ (by norm_num : (0 : ℝ) ≤ 2)
linarith [h1, h2, hlogRnn]
have h1 : 2900 * A0count * C0hat (R + 2) * (Real.log R) ^ 2 +
(200000 * (Real.log R) ^ 2 + 300 * A0count * C0hat (R + 2) * (Real.log R) ^ 2) +
((31 + 12 * Real.log R) + 3)
≤ 400000 * A0count * C0hat (R + 2) * (Real.log R) ^ 2 := by
have h2 : (2 : ℝ) ≤ A0count * C0hat (R + 2) := by
have h1c : (1 : ℝ) ≤ C0hat (R + 2) := by linarith [hĈ2, hĈR2]
have h2c : C0hat (R + 2) ≤ A0count * C0hat (R + 2) :=
calc C0hat (R + 2) = 1 * C0hat (R + 2) := by ring
_ ≤ A0count * C0hat (R + 2) :=
mul_le_mul_of_nonneg_right A0count_ge_one hĈR2pos.le
linarith [hĈ2, hĈR2, h2c]
have h3 : (81 : ℝ) ≤ (Real.log R) ^ 2 := by nlinarith [hlogR, hlogRnn]
have h4 : (1 : ℝ) ≤ A0count * C0hat (R + 2) * (Real.log R) ^ 2 := by
nlinarith [h2, h3, hA0, hĈR2pos]
have h5 : 200000 * (Real.log R) ^ 2
≤ 100000 * A0count * C0hat (R + 2) * (Real.log R) ^ 2 := by
have h6 : (2 : ℝ) ≤ A0count * C0hat (R + 2) := h2
nlinarith [h6, pow_two_nonneg (Real.log R)]
have hLL : Real.log R ≤ (Real.log R) ^ 2 := by nlinarith [hlogR]
nlinarith [h5, h4, h2, h3, hLL, hlogRnn, hA0, hĈR2pos]
linarith [hser2, hld2, hψ2, h1s, h1s1, hlogpi, h1, lowZeroConst_nonneg,
dirichletC2_nonneg]
exact hchain.trans hbig
end NguyenRH1
end