| import Mathlib.Algebra.Field.ZMod |
| import Mathlib.Analysis.Real.Sqrt |
| import OAI.NumberTheory.Catalan.Arithmetic.OddPrimeLoss |
| import OAI.NumberTheory.Catalan.Estimates.TwoAdicQuadratic |
| import OAI.NumberTheory.Catalan.PrimeLimits.ContinuousWeightedPNT |
| import OAI.NumberTheory.Catalan.PrimeLimits.ImportedPNTCoreBridge |
|
|
| namespace OAI |
|
|
| section |
|
|
| open Filter |
| open scoped Topology BigOperators |
| open Zeta5.Workers.W14 |
| open Zeta5.W12.ImportedPNTCoreBridge |
|
|
| namespace InternalCatalan |
|
|
| theorem oddPrimeLoss_weighted_0_25 (R : ℝ) (hR : 0 < R) : |
| weightedPrimeIntervalSum oddPrimeLoss 0 25 R = |
| 96 * (Chebyshev.theta (25 * R) / R) := by |
| have hconstant : weightedPrimeIntervalSum oddPrimeLoss 0 25 R = |
| weightedPrimeIntervalSum (fun _ => 96) 0 25 R := by |
| unfold weightedPrimeIntervalSum |
| congr 1 |
| apply Finset.sum_congr rfl |
| intro p hp |
| have hupper : p ≤ ⌊(25 : ℝ) * R⌋₊ := |
| (Finset.mem_Ioc.mp (Finset.mem_filter.mp hp).1).2 |
| have hreal : (p : ℝ) ≤ 25 * R := |
| (Nat.le_floor_iff (by positivity : 0 ≤ (25 : ℝ) * R)).mp hupper |
| rw [oddPrimeLoss_of_le_25 _ ((div_le_iff₀ hR).mpr hreal)] |
| rw [hconstant, weightedPrimeIntervalSum_const] |
| simp only [primeIntervalSum, Chebyshev.theta, zero_mul, Nat.floor_zero] |
|
|
| theorem oddPrimeLoss_weighted_tendsto_real : |
| Tendsto (weightedPrimeIntervalSum oddPrimeLoss 0 65) |
| atTop (𝓝 (8609 / 2 : ℝ)) := by |
| have hfirst := (theta_scaled_tendsto theta_ratio_tendsto_one |
| (by norm_num : (0 : ℝ) < 25)).const_mul (96 : ℝ) |
| have hlast := continuous_weightedPrime_tendsto |
| (by norm_num : (0 : ℝ) < 25) (by norm_num : (25 : ℝ) < 65) |
| (continuous_oddPrimeLoss.continuousOn : ContinuousOn oddPrimeLoss (Set.Icc 25 65)) |
| theta_ratio_tendsto_one |
| rw [integral_oddPrimeLoss_25_65] at hlast |
| have hcombined := hfirst.add hlast |
| norm_num at hcombined |
| apply hcombined.congr' |
| filter_upwards [eventually_gt_atTop (0 : ℝ)] with R hR |
| simpa only [oddPrimeLoss_weighted_0_25 R hR] using |
| (weightedPrimeIntervalSum_add_adjacent oddPrimeLoss |
| (by norm_num : (0 : ℝ) ≤ 25) (by norm_num : (25 : ℝ) ≤ 65) hR.le) |
| |
| theorem oddPrimeLoss_prime_sum_tendsto : |
| Tendsto (fun N : ℕ => |
| (∑ p ∈ Finset.Ioc 0 (65 * N) with p.Prime, |
| oddPrimeLoss ((p : ℝ) / N) * Real.log (p : ℝ)) / N) |
| atTop (𝓝 (8609 / 2 : ℝ)) := by |
| have h := oddPrimeLoss_weighted_tendsto_real.comp tendsto_natCast_atTop_atTop |
| have hfloor (N : ℕ) : ⌊(65 : ℝ) * N⌋₊ = 65 * N := by |
| rw [show (65 : ℝ) * N = ((65 * N : ℕ) : ℝ) by norm_num [Nat.cast_mul]] |
| exact Nat.floor_natCast _ |
| simpa only [Function.comp_def, weightedPrimeIntervalSum, zero_mul, |
| Nat.floor_zero, hfloor] using h |
| |
| end InternalCatalan |
| |
| end |
| |
| section |
| |
| open Filter |
| open scoped Topology BigOperators |
| open Zeta5.Workers.W14 |
| |
| namespace InternalCatalan |
| |
| noncomputable def removedPrimeLoss (N : ℕ) : ℝ := |
| (∑ p ∈ (Finset.Ioc 0 (H N)).filter |
| (fun p : ℕ => p.Prime ∧ (p : ℝ) ≤ 2 * Real.sqrt (H N)), |
| oddPrimeLoss ((p : ℝ) / N) * Real.log (p : ℝ)) / N |
| |
| theorem removedPrimeLoss_nonneg (N : ℕ) : 0 ≤ removedPrimeLoss N := by |
| unfold removedPrimeLoss |
| apply div_nonneg _ (Nat.cast_nonneg N) |
| apply Finset.sum_nonneg |
| intro p hp |
| exact mul_nonneg (oddPrimeLoss_mem_Icc _).1 |
| (log_prime_nonneg (Finset.mem_filter.mp hp).2.1) |
| |
| theorem removedPrimeLoss_le (N : ℕ) : |
| removedPrimeLoss N ≤ |
| (96 * Real.log 4 * 2) * (Real.sqrt (H N) / N) := by |
| let y : ℝ := 2 * Real.sqrt (H N) |
| let s := (Finset.Ioc 0 (H N)).filter |
| (fun p : ℕ => p.Prime ∧ (p : ℝ) ≤ y) |
| let t := (Finset.Ioc 0 ⌊y⌋₊).filter Nat.Prime |
| have hy : 0 ≤ y := by dsimp [y]; positivity |
| have hsub : s ⊆ t := by |
| intro p hp |
| rcases Finset.mem_filter.mp hp with ⟨hpI, hprime, hcut⟩ |
| exact Finset.mem_filter.mpr |
| ⟨Finset.mem_Ioc.mpr ⟨(Finset.mem_Ioc.mp hpI).1, |
| (Nat.le_floor_iff hy).mpr hcut⟩, hprime⟩ |
| have hsum : (∑ p ∈ s, oddPrimeLoss ((p : ℝ) / N) * Real.log (p : ℝ)) ≤ |
| 96 * Chebyshev.theta y := by |
| calc |
| _ ≤ ∑ p ∈ s, (96 : ℝ) * Real.log (p : ℝ) := by |
| apply Finset.sum_le_sum |
| intro p hp |
| exact mul_le_mul_of_nonneg_right (oddPrimeLoss_mem_Icc _).2 |
| (log_prime_nonneg (Finset.mem_filter.mp hp).2.1) |
| _ ≤ ∑ p ∈ t, (96 : ℝ) * Real.log (p : ℝ) := by |
| apply Finset.sum_le_sum_of_subset_of_nonneg hsub |
| intro p hp _ |
| exact mul_nonneg (by norm_num) |
| (log_prime_nonneg (Finset.mem_filter.mp hp).2) |
| _ = 96 * Chebyshev.theta y := by |
| simp only [t, Chebyshev.theta, Finset.mul_sum] |
| calc |
| removedPrimeLoss N ≤ (96 * Chebyshev.theta y) / N := |
| div_le_div_of_nonneg_right hsum (Nat.cast_nonneg N) |
| _ ≤ (96 * (Real.log 4 * y)) / N := |
| div_le_div_of_nonneg_right |
| (mul_le_mul_of_nonneg_left (Chebyshev.theta_le_log4_mul_x hy) (by norm_num)) |
| (Nat.cast_nonneg N) |
| _ = (96 * Real.log 4 * 2) * (Real.sqrt (H N) / N) := by |
| dsimp [y] |
| ring |
| |
| theorem sqrt_H_div_tendsto_zero : |
| Tendsto (fun N : ℕ => Real.sqrt (H N) / N) atTop (𝓝 0) := by |
| have hcast : Tendsto (fun N : ℕ => (N : ℝ)) atTop atTop := |
| tendsto_natCast_atTop_atTop |
| have h := (tendsto_inv_atTop_zero.comp |
| (Real.tendsto_sqrt_atTop.comp hcast)).const_mul (Real.sqrt 65) |
| simpa only [H, Nat.cast_mul, Nat.cast_ofNat, Function.comp_def, |
| Real.sqrt_mul (by norm_num : (0 : ℝ) ≤ 65), |
| mul_div_assoc, Real.sqrt_div_self, mul_zero] using h |
| |
| theorem removedPrimeLoss_tendsto_zero : |
| Tendsto removedPrimeLoss atTop (𝓝 0) := by |
| have h := sqrt_H_div_tendsto_zero.const_mul (96 * Real.log 4 * 2) |
| simp only [mul_zero] at h |
| exact squeeze_zero removedPrimeLoss_nonneg removedPrimeLoss_le h |
| |
| theorem oddPrimeLoss_large_prime_sum_tendsto : |
| Tendsto (fun N : ℕ => |
| (∑ p ∈ (Finset.Ioc 0 (H N)).filter |
| (fun p : ℕ => p.Prime ∧ 2 * Real.sqrt (H N) < (p : ℝ)), |
| oddPrimeLoss ((p : ℝ) / N) * Real.log (p : ℝ)) / N) |
| atTop (𝓝 (8609 / 2 : ℝ)) := by |
| have h := oddPrimeLoss_prime_sum_tendsto.sub removedPrimeLoss_tendsto_zero |
| simp only [sub_zero] at h |
| apply h.congr |
| intro N |
| apply (sub_eq_iff_eq_add).mpr |
| unfold removedPrimeLoss |
| rw [← add_div] |
| congr 1 |
| change (∑ p ∈ Finset.Ioc 0 (H N) with p.Prime, |
| oddPrimeLoss ((p : ℝ) / N) * Real.log (p : ℝ)) = _ |
| simp only [Finset.sum_filter] |
| rw [← Finset.sum_add_distrib] |
| apply Finset.sum_congr rfl |
| intro p _ |
| by_cases hprime : p.Prime |
| · by_cases hcut : (p : ℝ) ≤ 2 * Real.sqrt (H N) |
| · simp [hprime, hcut, not_lt.mpr hcut] |
| · simp [hprime, hcut, lt_of_not_ge hcut] |
| · simp [hprime] |
| |
| theorem large_prime_cutoff_ne_two {N p : ℕ} (hN : 0 < N) |
| (hp : 2 * Real.sqrt (H N) < (p : ℝ)) : p ≠ 2 := by |
| have hH : (1 : ℝ) ≤ (H N : ℝ) := by |
| exact_mod_cast (show 1 ≤ H N by unfold H; omega) |
| have hs := Real.one_le_sqrt.mpr hH |
| intro heq |
| subst p |
| norm_num only [Nat.cast_ofNat] at hp |
| linarith |
| |
| end InternalCatalan |
| |
| end |
| |
| |
| namespace InternalCatalan |
| |
| open Filter |
| |
| theorem large_prime_cutoff_square {N p : ℕ} |
| (hp : 2 * Real.sqrt (H N) < (p : ℝ)) : 4 * H N < p ^ 2 := by |
| have hsq := Real.sq_sqrt (Nat.cast_nonneg (H N)) |
| have hs := Real.sqrt_nonneg (H N) |
| have hr : (4 : ℝ) * (H N : ℝ) < (p : ℝ) ^ 2 := by |
| nlinarith [show (0 : ℝ) ≤ (p : ℝ) by positivity] |
| exact_mod_cast hr |
| |
| theorem large_prime_cutoff_gt_fixed {B N p : ℕ} (hB : B ^ 2 ≤ N) |
| (hp : 2 * Real.sqrt (H N) < (p : ℝ)) : B < p := by |
| have hBH : B ^ 2 ≤ H N := by unfold H; omega |
| have hs : (B : ℝ) ≤ Real.sqrt (H N) := |
| (Real.le_sqrt (Nat.cast_nonneg B) (Nat.cast_nonneg (H N))).mpr |
| (by exact_mod_cast hBH) |
| have hreal : (B : ℝ) < (p : ℝ) := by |
| linarith [Real.sqrt_nonneg (H N)] |
| exact_mod_cast hreal |
| |
| theorem large_prime_witness_den_eventually (z : ℚ) : |
| ∀ᶠ N : ℕ in atTop, ∀ p : ℕ, |
| 2 * Real.sqrt (H N) < (p : ℝ) → (z.den : ZMod p) ≠ 0 := by |
| filter_upwards [eventually_ge_atTop (z.den ^ 2)] with N hN |
| intro p hp hz |
| have hden := large_prime_cutoff_gt_fixed hN hp |
| exact (Nat.not_dvd_of_pos_of_lt z.pos hden) |
| ((ZMod.natCast_eq_zero_iff z.den p).mp hz) |
| |
| end InternalCatalan |
| |
| |
| |
| noncomputable section |
| |
| namespace InternalCatalan |
| |
| open Filter |
| open scoped Topology BigOperators |
| |
| theorem oddPrimeLoss_large_prime_normalized_tendsto : |
| Tendsto (fun N : ℕ => |
| (N : ℝ) * |
| (∑ p ∈ (Finset.Ioc 0 (H N)).filter |
| (fun p : ℕ => p.Prime ∧ 2 * Real.sqrt (H N) < (p : ℝ)), |
| oddPrimeLoss ((p : ℝ) / N) * Real.log (p : ℝ)) / (n N : ℝ) ^ 2) |
| atTop (𝓝 (8609 / 4608 : ℝ)) := by |
| have hs := oddPrimeLoss_large_prime_sum_tendsto.div_const (2304 : ℝ) |
| norm_num only [div_div, show (2 : ℝ) * 2304 = 4608 by norm_num] at hs |
| apply hs.congr' |
| filter_upwards [eventually_gt_atTop (0 : ℕ)] with N hN |
| have hNr : (N : ℝ) ≠ 0 := by exact_mod_cast (Nat.ne_of_gt hN) |
| simp only [n, Nat.cast_mul, Nat.cast_ofNat] |
| field_simp [hNr] |
| ring |
|
|
| theorem oddPrimeLoss_large_prime_normalized_eventually_upper {ε : ℝ} (hε : 0 < ε) : |
| ∀ᶠ N : ℕ in atTop, |
| (N : ℝ) * |
| (∑ p ∈ (Finset.Ioc 0 (H N)).filter |
| (fun p : ℕ => p.Prime ∧ 2 * Real.sqrt (H N) < (p : ℝ)), |
| oddPrimeLoss ((p : ℝ) / N) * Real.log (p : ℝ)) / (n N : ℝ) ^ 2 < |
| (8609 / 4608 : ℝ) + ε := |
| (tendsto_order.mp oddPrimeLoss_large_prime_normalized_tendsto).2 _ (by linarith) |
|
|
| end InternalCatalan |
|
|
| end |
|
|
| end OAI |
|
|
