| import OAI.NumberTheory.PrimeGaps.LevelMoments | |
| namespace OAI | |
| namespace LargePrimeGaps | |
| open Filter | |
| open Set Filter MeasureTheory | |
| open scoped Topology ContDiff | |
| theorem integral_eq_orthant_integral {j : ℕ} {f : (Fin j → ℝ) → ℝ} | |
| (hf : Function.support f ⊆ {t | ∀ i, 0 < t i}) : | |
| (∫ t, f t) = ∫ t in {t : Fin j → ℝ | ∀ i, 0 ≤ t i}, f t := by | |
| have hm : MeasurableSet {t : Fin j → ℝ | ∀ i, 0 ≤ t i} := by | |
| have heq : {t : Fin j → ℝ | ∀ i, 0 ≤ t i} = | |
| ⋂ i : Fin j, {t : Fin j → ℝ | 0 ≤ t i} := by ext t; simp | |
| rw [heq] | |
| exact MeasurableSet.iInter (fun i : Fin j => | |
| (isClosed_le continuous_const (continuous_apply i)).measurableSet) | |
| rw [← integral_indicator hm] | |
| apply integral_congr_ae | |
| filter_upwards [] with t | |
| by_cases ht : t ∈ {t : Fin j → ℝ | ∀ i, 0 ≤ t i} | |
| · rw [Set.indicator_of_mem ht] | |
| · rw [Set.indicator_of_notMem ht] | |
| by_contra hn | |
| exact ht (fun i => (hf hn i).le) | |
| theorem l2Mass_eq_orthant_integral {j : ℕ} {f : (Fin j → ℝ) → ℝ} | |
| (hf : Function.support f ⊆ {t | ∀ i, 0 < t i}) : | |
| l2Mass f = ∫ t in {t : Fin j → ℝ | ∀ i, 0 ≤ t i}, f t^2 := by | |
| apply integral_eq_orthant_integral | |
| intro t ht | |
| apply hf | |
| exact fun h => ht (by simp only [h, zero_pow (by decide : 2 ≠ 0)]) | |
| theorem deleteCoordinate_eq_orthant_integral {j : ℕ} {f : (Fin (j+1) → ℝ) → ℝ} | |
| (hf : Function.support f ⊆ {t | ∀ i, 0 < t i}) (t : Fin j → ℝ) : | |
| deleteCoordinate f t = ∫ u in Ici (0:ℝ), f (Fin.snoc t u) := by | |
| unfold deleteCoordinate | |
| rw [← integral_indicator measurableSet_Ici] | |
| apply integral_congr_ae | |
| filter_upwards [] with u | |
| by_cases hu : u ∈ Ici (0:ℝ) | |
| · rw [Set.indicator_of_mem hu] | |
| · rw [Set.indicator_of_notMem hu] | |
| by_contra hn | |
| apply hu | |
| change 0 ≤ u | |
| simpa only [Fin.snoc_last] using (hf hn (Fin.last j)).le | |
| def squareDimension (m : ℕ) : ℕ := (m+1)^2 | |
| theorem squareDimension_pos (m : ℕ) : 0 < squareDimension m := by | |
| unfold squareDimension | |
| positivity | |
| theorem active_length_le_squareDimension (m : ℕ) : m+1 ≤ squareDimension m := by | |
| unfold squareDimension | |
| nlinarith [Nat.zero_le m] | |
| theorem squareDimension_strictMono : StrictMono squareDimension := by | |
| intro m n hmn | |
| unfold squareDimension | |
| nlinarith | |
| theorem tendsto_squareDimension : Tendsto squareDimension atTop atTop := | |
| squareDimension_strictMono.tendsto_atTop | |
| theorem tendsto_inverse_squareDimension : | |
| Tendsto (fun m : ℕ => ((squareDimension m:ℕ):ℝ)⁻¹) atTop (nhds 0) := | |
| (tendsto_natCast_atTop_atTop.comp tendsto_squareDimension).inv_tendsto_atTop | |
| theorem tendsto_inverse_active_length : | |
| Tendsto (fun m : ℕ => (((m+1):ℕ):ℝ)⁻¹) atTop (nhds 0) := | |
| (tendsto_natCast_atTop_atTop.comp (tendsto_add_atTop_nat 1)).inv_tendsto_atTop | |
| theorem rectangle_error_tendsto_zero (v d : ℝ) : | |
| Tendsto (fun m : ℕ => v/((squareDimension m:ℝ)*d^2)) atTop (nhds 0) := by | |
| have h := tendsto_inverse_squareDimension.const_mul (v/(d^2)) | |
| simpa only [mul_zero, div_eq_mul_inv, mul_inv_rev, mul_assoc, mul_comm (d^2)⁻¹] using h | |
| theorem square_ratio_eq_inverse (m : ℕ) : | |
| ((m+1:ℕ):ℝ)/(squareDimension m:ℝ) = ((m+1:ℕ):ℝ)⁻¹ := by | |
| have hm : ((m+1:ℕ):ℝ) ≠ 0 := by positivity | |
| unfold squareDimension | |
| rw [Nat.cast_pow] | |
| field_simp | |
| theorem cancellation_bound_tendsto_zero (lambda v d : ℝ) : | |
| Tendsto (fun m : ℕ => lambda * (2/((m+1:ℕ):ℝ) + | |
| (((m+1:ℕ):ℝ)/(squareDimension m:ℝ))^2 + | |
| 4*v/((squareDimension m:ℝ)*d^2))) atTop (nhds 0) := by | |
| have h1 := tendsto_inverse_active_length.const_mul 2 | |
| have h2 := tendsto_inverse_active_length.pow 2 | |
| have h3 := rectangle_error_tendsto_zero (4*v) d | |
| have h := ((h1.add h2).add h3).const_mul lambda | |
| simp only [square_ratio_eq_inverse] | |
| simpa only [mul_zero, zero_pow (by decide : 2 ≠ 0), zero_add, div_eq_mul_inv] using h | |
| theorem cancellationFamily_W_tendsto {g chi : ℝ → ℝ} {lambda beta : ℝ} | |
| (hlambda : 0 < lambda) (hg : Continuous g) (hgc : HasCompactSupport g) | |
| (hgs : Function.support g ⊆ Ioi 0) (hg2 : (∫ u, g u^2) = 1) | |
| (hchi : Continuous chi) (hchi0 : ∀ s, 0 ≤ chi s) (hchi1 : ∀ s, chi s ≤ 1) | |
| (hflat : ∀ s ≤ beta, chi s = 1) (hmu : (∫ u, u*g u^2) < beta) : | |
| Tendsto (fun m => familyW lambda (squareDimension m) | |
| (cancellationFamily g chi lambda (squareDimension m) (m+1))) atTop (nhds 1) := by | |
| let d := beta - ∫ u, u*g u^2 | |
| let v := ∫ u, (u-∫ v, v*g v^2)^2 * g u^2 | |
| have hlo := (rectangle_error_tendsto_zero v d).const_sub 1 | |
| simp only [sub_zero] at hlo | |
| apply tendsto_of_tendsto_of_tendsto_of_le_of_le hlo tendsto_const_nhds | |
| · intro m | |
| exact (cancellationFamily_W_bounds hlambda (Nat.succ_pos m) | |
| (active_length_le_squareDimension m) hg hgc hgs hg2 hchi hchi0 hchi1 hflat hmu).1 | |
| · intro m | |
| exact (cancellationFamily_W_bounds hlambda (Nat.succ_pos m) | |
| (active_length_le_squareDimension m) hg hgc hgs hg2 hchi hchi0 hchi1 hflat hmu).2 | |
| theorem cancellationFamily_V_tendsto {g chi : ℝ → ℝ} {lambda beta B : ℝ} | |
| (hlambda : 0 < lambda) (hg : Continuous g) (hgc : HasCompactSupport g) | |
| (hgs : Function.support g ⊆ Ioi 0) (hgn : ∀ u, 0 ≤ g u) | |
| (hg2 : (∫ u, g u^2) = 1) (hg1 : (∫ u, g u) = Real.sqrt lambda) | |
| (hB : ∀ u ∈ Function.support g, u ≤ B) (hB0 : 0 ≤ B) | |
| (hchi : Continuous chi) (hchi0 : ∀ s, 0 ≤ chi s) (hchi1 : ∀ s, chi s ≤ 1) | |
| (hflat : ∀ s ≤ beta, chi s = 1) (hmu : (∫ u, u*g u^2) < beta) : | |
| Tendsto (fun m => familyV lambda (squareDimension m) | |
| (cancellationFamily g chi lambda (squareDimension m) (m+1))) atTop (nhds 0) := by | |
| let d := beta - ∫ u, u*g u^2 | |
| let v := ∫ u, (u-∫ v, v*g v^2)^2 * g u^2 | |
| have hBdiv : Tendsto (fun m => B/(squareDimension m:ℝ)) atTop (nhds 0) := by | |
| simpa only [div_eq_mul_inv, mul_zero] using tendsto_inverse_squareDimension.const_mul B | |
| have hBk : ∀ᶠ m in atTop, B/(squareDimension m:ℝ) ≤ d/2 := by | |
| exact ((tendsto_order.mp hBdiv).2 (d/2) (by dsimp only [d]; linarith)).mono (fun _ h => h.le) | |
| apply squeeze_zero' (Eventually.of_forall fun m => familyV_nonneg hlambda _ _) | |
| _ (cancellation_bound_tendsto_zero lambda v d) | |
| filter_upwards [hBk] with m hm | |
| exact cancellationFamily_V_bound hlambda (Nat.succ_pos m) | |
| (active_length_le_squareDimension m) hg hgc hgs hgn hg2 hg1 hB hB0 hchi hchi0 hchi1 hflat hmu hm | |
| def AdmissibleFamily (tau : ℝ) (k : ℕ) (f : (j : ℕ) → (Fin j → ℝ) → ℝ) : Prop := | |
| 0 < k ∧ | |
| (∀ j, j ≤ k → ContDiff ℝ ∞ (f j) ∧ HasCompactSupport (f j) ∧ | |
| tsupport (f j) ⊆ positiveSimplex j tau ∧ SymmetricFunction (f j)) ∧ | |
| (∀ j, k < j → f j = 0) | |
| theorem exists_canceling_families {lambda tau : ℝ} (hlambda : 0 < lambda) (htau : 0 < tau) : | |
| ∃ f : (m j : ℕ) → (Fin j → ℝ) → ℝ, | |
| (∀ m, AdmissibleFamily tau (squareDimension m) (f m) ∧ f m 0 = 0) ∧ | |
| Tendsto (fun m => familyW lambda (squareDimension m) (f m)) atTop (nhds 1) ∧ | |
| Tendsto (fun m => familyV lambda (squareDimension m) (f m)) atTop (nhds 0) := by | |
| let beta := tau/3 | |
| let gamma := 2*tau/3 | |
| have hb : 0 < beta := by dsimp only [beta]; positivity | |
| have hbg : beta < gamma := by dsimp only [beta, gamma]; linarith | |
| have hgt : gamma < tau := by dsimp only [gamma]; linarith | |
| obtain ⟨g, hgsmooth, hgc, hgs, hgn, hg2, hg1, hmu⟩ := exists_small_first_moment_profile hlambda hb | |
| let chi := simplexCutoff beta gamma | |
| have hchi : ContDiff ℝ ∞ chi := simplexCutoff_smooth beta gamma | |
| have hc0 : ∀ s, 0 ≤ chi s := simplexCutoff_nonneg beta gamma | |
| have hc1 : ∀ s, chi s ≤ 1 := simplexCutoff_le_one beta gamma | |
| have hcflat : ∀ s ≤ beta, chi s = 1 := fun _ hs => simplexCutoff_eq_one hbg hs | |
| have hcz : ∀ s, gamma ≤ s → chi s = 0 := fun _ hs => simplexCutoff_eq_zero hbg hs | |
| obtain ⟨b, hbnd⟩ := hgc.bddAbove | |
| let B := max b 0 | |
| have hB : ∀ u ∈ Function.support g, u ≤ B := fun u hu => | |
| (hbnd (subset_closure hu)).trans (le_max_left b 0) | |
| have hB0 : 0 ≤ B := le_max_right b 0 | |
| have hsupport : Function.support g ⊆ Ioi 0 := fun _ hu => hgs (subset_closure hu) | |
| refine ⟨fun m => cancellationFamily g chi lambda (squareDimension m) (m+1), ?_, ?_, ?_⟩ | |
| · intro m | |
| refine ⟨⟨squareDimension_pos m, ?_, ?_⟩, cancellationFamily_zero _ _ _ _ _⟩ | |
| · intro j _ | |
| exact cancellationFamily_properties (squareDimension_pos m) hgsmooth hgc hgs hchi hgt hcz j | |
| · intro j hj | |
| exact cancellationFamily_above _ _ _ _ _ hj | |
| · exact cancellationFamily_W_tendsto hlambda hgsmooth.continuous hgc hsupport hg2 | |
| hchi.continuous hc0 hc1 hcflat hmu | |
| · exact cancellationFamily_V_tendsto hlambda hgsmooth.continuous hgc hsupport hgn hg2 hg1 | |
| hB hB0 hchi.continuous hc0 hc1 hcflat hmu | |
| theorem exists_family_small_marked_ratio {lambda tau epsilon : ℝ} | |
| (hlambda : 0 < lambda) (htau : 0 < tau) (hepsilon : 0 < epsilon) : | |
| ∃ k : ℕ, ∃ f : (j : ℕ) → (Fin j → ℝ) → ℝ, | |
| AdmissibleFamily tau k f ∧ f 0 = 0 ∧ | |
| 0 < familyW lambda k f ∧ familyV lambda k f / familyW lambda k f ≤ epsilon := by | |
| obtain ⟨f, hf, hW, hV⟩ := exists_canceling_families hlambda htau | |
| have hWpos : ∀ᶠ m in atTop, 0 < familyW lambda (squareDimension m) (f m) := | |
| (tendsto_order.mp hW).1 0 (by norm_num) | |
| have hratio : Tendsto (fun m => familyV lambda (squareDimension m) (f m) / | |
| familyW lambda (squareDimension m) (f m)) atTop (nhds 0) := by | |
| have hdiv := hV.div hW (by norm_num : (1:ℝ) ≠ 0) | |
| rw [zero_div] at hdiv | |
| exact hdiv | |
| have hsmall := (tendsto_order.mp hratio).2 epsilon hepsilon | |
| obtain ⟨m, hmW, hmV⟩ := (hWpos.and hsmall).exists | |
| exact ⟨squareDimension m, f m, (hf m).1, (hf m).2, hmW, hmV.le⟩ | |
| def divisorMultiplicity (k n : ℕ) : ℕ := (ArithmeticFunction.zeta ^ k) n | |
| theorem divisorMultiplicity_one (k : ℕ) : divisorMultiplicity k 1 = 1 := by | |
| exact (ArithmeticFunction.isMultiplicative_zeta.pow).1 | |
| theorem divisorMultiplicity_succ (k n : ℕ) : | |
| divisorMultiplicity (k+1) n = ∑ d ∈ n.divisors, divisorMultiplicity k d := by | |
| simp only [divisorMultiplicity, pow_succ, ArithmeticFunction.mul_zeta_apply] | |
| theorem divisorMultiplicity_prime (k : ℕ) {p : ℕ} (hp : Nat.Prime p) : | |
| divisorMultiplicity k p = k := by | |
| induction k with | |
| | zero => simp [divisorMultiplicity, hp.ne_one] | |
| | succ k ih => | |
| rw [divisorMultiplicity_succ, hp.divisors] | |
| simp [hp.ne_one.symm, divisorMultiplicity_one, ih, Nat.add_comm] | |
| theorem divisorMultiplicity_squarefree (k : ℕ) {q : ℕ} (hq : Squarefree q) : | |
| divisorMultiplicity k q = k ^ q.primeFactors.card := by | |
| rw [divisorMultiplicity, ← ArithmeticFunction.IsMultiplicative.prod_primeFactors | |
| (ArithmeticFunction.isMultiplicative_zeta.pow) hq] | |
| calc | |
| _ = ∏ p ∈ q.primeFactors, k := Finset.prod_congr rfl fun p hp => | |
| divisorMultiplicity_prime k (Nat.prime_of_mem_primeFactors hp) | |
| _ = _ := by simp | |
| theorem reciprocal_divisor_sum_le (f : ℕ → ℝ) (hf : ∀ n, 0 ≤ f n) (Q : ℕ) : | |
| (∑ q ∈ Finset.Icc 1 Q, (∑ d ∈ q.divisors, f d) / (q : ℝ)) ≤ | |
| (∑ d ∈ Finset.Icc 1 Q, f d / (d : ℝ)) * (harmonic Q : ℝ) := by | |
| classical | |
| let s := (Finset.Icc 1 Q).sigma fun q => q.divisors | |
| let t := (Finset.Icc 1 Q) ×ˢ (Finset.Icc 1 Q) | |
| let e : (a : ℕ) × ℕ → ℕ × ℕ := fun x => (x.2, x.1/x.2) | |
| have he_mem : ∀ x ∈ s, e x ∈ t := by | |
| rintro ⟨q,d⟩ hx | |
| obtain ⟨hq, hd⟩ := Finset.mem_sigma.mp hx | |
| obtain ⟨hq1,hqQ⟩ := Finset.mem_Icc.mp hq | |
| obtain ⟨hdq,hq0⟩ := Nat.mem_divisors.mp hd | |
| have hd0 : 0 < d := Nat.pos_of_dvd_of_pos hdq hq1 | |
| have hdle : d ≤ q := Nat.le_of_dvd hq1 hdq | |
| have hdivpos : 0 < q/d := Nat.div_pos hdle hd0 | |
| exact Finset.mem_product.mpr ⟨Finset.mem_Icc.mpr ⟨hd0, hdle.trans hqQ⟩, | |
| Finset.mem_Icc.mpr ⟨hdivpos, (Nat.div_le_self q d).trans hqQ⟩⟩ | |
| have he_inj : Set.InjOn e s := by | |
| rintro ⟨q,d⟩ hx ⟨q',d'⟩ hy he | |
| obtain ⟨hq,hd⟩ := Finset.mem_sigma.mp hx | |
| obtain ⟨hq',hd'⟩ := Finset.mem_sigma.mp hy | |
| have hed : d = d' := congrArg Prod.fst he | |
| have heq : q/d = q'/d' := congrArg Prod.snd he | |
| have hdq : d ∣ q := (Nat.mem_divisors.mp hd).1 | |
| have hdq' : d' ∣ q' := (Nat.mem_divisors.mp hd').1 | |
| have hqq : q = q' := by | |
| rw [← Nat.div_mul_cancel hdq, ← Nat.div_mul_cancel hdq', heq, hed] | |
| subst d' | |
| subst q' | |
| rfl | |
| have hsum : (∑ q ∈ Finset.Icc 1 Q, (∑ d ∈ q.divisors, f d) / (q : ℝ)) = | |
| ∑ x ∈ s, f (e x).1 / (e x).1 / (e x).2 := by | |
| dsimp only [s] | |
| rw [Finset.sum_sigma] | |
| apply Finset.sum_congr rfl | |
| intro q hq | |
| rw [Finset.sum_div] | |
| apply Finset.sum_congr rfl | |
| intro d hd | |
| have hdq := (Nat.mem_divisors.mp hd).1 | |
| dsimp only [e] | |
| rw [div_div, ← Nat.cast_mul, Nat.mul_div_cancel' hdq] | |
| rw [hsum] | |
| calc | |
| _ = ∑ x ∈ s.image e, f x.1 / (x.1 : ℝ) / (x.2 : ℝ) := by | |
| rw [Finset.sum_image he_inj] | |
| _ ≤ ∑ x ∈ t, f x.1 / (x.1 : ℝ) / (x.2 : ℝ) := | |
| Finset.sum_le_sum_of_subset_of_nonneg (Finset.image_subset_iff.mpr he_mem) | |
| (fun x _ _ => div_nonneg (div_nonneg (hf _) (Nat.cast_nonneg _)) (Nat.cast_nonneg _)) | |
| _ = _ := by | |
| simp only [t, Finset.sum_product, div_eq_mul_inv, Finset.sum_mul, Finset.mul_sum, | |
| harmonic_eq_sum_Icc, Rat.cast_sum, Rat.cast_inv, Rat.cast_natCast] | |
| rw [Finset.sum_comm] | |
| theorem sum_divisorMultiplicity_reciprocal_le (k Q : ℕ) : | |
| (∑ q ∈ Finset.Icc 1 Q, (divisorMultiplicity k q : ℝ) / (q : ℝ)) ≤ | |
| (harmonic Q : ℝ) ^ k := by | |
| induction k with | |
| | zero => | |
| by_cases hQ : Q = 0 | |
| · subst Q; simp | |
| · have hQ1 : 1 ≤ Q := Nat.one_le_iff_ne_zero.mpr hQ | |
| simp [divisorMultiplicity, ArithmeticFunction.one_apply, ite_div, hQ1] | |
| | succ k ih => | |
| have h := reciprocal_divisor_sum_le (fun n => (divisorMultiplicity k n : ℝ)) | |
| (fun n => Nat.cast_nonneg _) Q | |
| simp only [divisorMultiplicity_succ, Nat.cast_sum] at ⊢ | |
| apply h.trans | |
| rw [pow_succ] | |
| exact mul_le_mul_of_nonneg_right ih (by | |
| simp only [harmonic_eq_sum_Icc, Rat.cast_sum, Rat.cast_inv, Rat.cast_natCast] | |
| exact Finset.sum_nonneg fun _ _ => inv_nonneg.mpr (Nat.cast_nonneg _)) | |
| theorem squarefree_reciprocal_weight_bound (T Q : ℕ) : | |
| (∑ q ∈ Finset.Icc 1 Q, if Squarefree q then (T : ℝ)^q.primeFactors.card / q else 0) ≤ | |
| (harmonic Q : ℝ)^T := by | |
| classical | |
| apply (Finset.sum_le_sum (g := fun q => (divisorMultiplicity T q : ℝ)/(q:ℝ)) ?_).trans | |
| (sum_divisorMultiplicity_reciprocal_le T Q) | |
| intro q _ | |
| split_ifs with hq | |
| · rw [divisorMultiplicity_squarefree T hq, Nat.cast_pow] | |
| · positivity | |
| theorem squarefree_totient_lower {q : ℕ} (hq : Squarefree q) : | |
| q ≤ 2 ^ q.primeFactors.card * q.totient := by | |
| rw [Nat.totient_eq_div_primeFactors_mul, Nat.prod_primeFactors_of_squarefree hq, | |
| Nat.div_self (Nat.pos_of_ne_zero hq.ne_zero), one_mul] | |
| calc | |
| q = ∏ p ∈ q.primeFactors, p := (Nat.prod_primeFactors_of_squarefree hq).symm | |
| _ ≤ ∏ p ∈ q.primeFactors, 2 * (p-1) := by | |
| apply Finset.prod_le_prod | |
| intro p hp | |
| have := (Nat.prime_of_mem_primeFactors hp).two_le | |
| omega | |
| _ = _ := by rw [Finset.prod_mul_distrib, Finset.prod_const] | |
| theorem weighted_error_square_bound (K Q : ℕ) (E : ℕ → ℝ) (hE : ∀ q, 0 ≤ E q) | |
| {X L : ℝ} (hX : 0 ≤ X) (hL : 0 ≤ L) | |
| (hb : ∀ q ∈ Finset.Icc 1 Q, Squarefree q → | |
| E q ≤ X/(q:ℝ) * (L + 2^q.primeFactors.card)) : | |
| (∑ q ∈ Finset.Icc 1 Q, if Squarefree q then (K:ℝ)^q.primeFactors.card * E q else 0)^2 ≤ | |
| (∑ q ∈ Finset.Icc 1 Q, E q) * X * | |
| (L * (harmonic Q : ℝ)^(K^2) + (harmonic Q : ℝ)^(2*K^2)) := by | |
| classical | |
| let s := Finset.Icc 1 Q | |
| let w : ℕ → ℝ := fun q => if Squarefree q then (K:ℝ)^q.primeFactors.card else 0 | |
| have hcs := Finset.sum_mul_sq_le_sq_mul_sq s (fun q => Real.sqrt (E q)) | |
| (fun q => w q * Real.sqrt (E q)) | |
| have heq1 : ∀ q, Real.sqrt (E q) * (w q * Real.sqrt (E q)) = w q * E q := by | |
| intro q | |
| calc | |
| _ = w q * (Real.sqrt (E q))^2 := by ring | |
| _ = _ := by rw [Real.sq_sqrt (hE q)] | |
| simp only [heq1, mul_pow, Real.sq_sqrt (hE _)] at hcs | |
| have hsecond : (∑ q ∈ s, w q ^ 2 * E q) ≤ | |
| X * (L * (harmonic Q : ℝ)^(K^2) + (harmonic Q : ℝ)^(2*K^2)) := by | |
| have hterm : ∀ q ∈ s, w q^2 * E q ≤ | |
| X * (L * (if Squarefree q then ((K^2:ℕ):ℝ)^q.primeFactors.card / q else 0) + | |
| (if Squarefree q then ((2*K^2:ℕ):ℝ)^q.primeFactors.card / q else 0)) := by | |
| intro q hq | |
| have hqR : (0 : ℝ) < q := by exact_mod_cast (Finset.mem_Icc.mp hq).1 | |
| by_cases hsq : Squarefree q | |
| · simp only [w, ite_eq_left hsq] | |
| calc | |
| _ ≤ ((K:ℝ)^q.primeFactors.card)^2 * (X/(q:ℝ) * (L+2^q.primeFactors.card)) := | |
| mul_le_mul_of_nonneg_left (hb q hq hsq) (sq_nonneg _) | |
| _ = _ := by | |
| rw [Nat.cast_mul, Nat.cast_ofNat, Nat.cast_pow, mul_pow, ← pow_mul, Nat.mul_comm, | |
| pow_mul] | |
| ring | |
| · simp [w, hsq] | |
| calc | |
| _ ≤ ∑ q ∈ s, X * (L * | |
| (if Squarefree q then ((K^2:ℕ):ℝ)^q.primeFactors.card / q else 0) + | |
| (if Squarefree q then ((2*K^2:ℕ):ℝ)^q.primeFactors.card / q else 0)) := | |
| Finset.sum_le_sum hterm | |
| _ = X * (L * (∑ q ∈ s, if Squarefree q then ((K^2:ℕ):ℝ)^q.primeFactors.card/q else 0) + | |
| ∑ q ∈ s, if Squarefree q then ((2*K^2:ℕ):ℝ)^q.primeFactors.card/q else 0) := by | |
| simp only [Finset.mul_sum, Finset.sum_add_distrib, mul_add] | |
| _ ≤ _ := mul_le_mul_of_nonneg_left | |
| (add_le_add (mul_le_mul_of_nonneg_left (squarefree_reciprocal_weight_bound (K^2) Q) hL) | |
| (squarefree_reciprocal_weight_bound (2*K^2) Q)) hX | |
| have hsumE : 0 ≤ ∑ q ∈ s, E q := Finset.sum_nonneg fun q _ => hE q | |
| have h := hcs.trans (mul_le_mul_of_nonneg_left hsecond hsumE) | |
| simp only [w, ite_mul, zero_mul] at h | |
| simpa only [mul_assoc] using h | |
| theorem markedClassError_trivial {X H q a c : ℕ} (hX : 1 ≤ X) (hq : 0 < q) | |
| (hqX : q ≤ X) (ha : a ≤ H) (hc : c < q) (hsq : Squarefree q) : | |
| |(∑ m ∈ residueStarts X q c, theta (m+a)) - (X:ℝ)/q.totient| ≤ | |
| (X:ℝ)/(q:ℝ) * (3 * Real.log (2*X+H) + 2^q.primeFactors.card) := by | |
| have hqR : (0:ℝ) < q := by exact_mod_cast hq | |
| have hphi : (0:ℝ) < q.totient := by exact_mod_cast Nat.totient_pos.mpr hq | |
| have hXq : (1:ℝ) ≤ (X:ℝ)/q := (le_div_iff₀ hqR).mpr (by simpa using (show (q:ℝ) ≤ X by exact_mod_cast hqX)) | |
| have hboundpos : (1:ℝ) ≤ 2*X+H := by exact_mod_cast (show 1 ≤ 2*X+H by omega) | |
| have hlog : 0 ≤ Real.log (2*X+H) := Real.log_nonneg hboundpos | |
| have htheta : ∀ m ∈ residueStarts X q c, theta (m+a) ≤ Real.log (2*X+H) := by | |
| intro m hm | |
| have hmhi := (Finset.mem_Ioc.mp (Finset.mem_filter.mp hm).1).2 | |
| by_cases hp : Nat.Prime (m+a) | |
| · rw [theta, ite_eq_left hp] | |
| exact Real.log_le_log (by exact_mod_cast hp.pos) (by exact_mod_cast (show m+a ≤ 2*X+H by omega)) | |
| · simpa [theta, hp] | |
| have hsum : (∑ m ∈ residueStarts X q c, theta (m+a)) ≤ | |
| 3 * ((X:ℝ)/q) * Real.log (2*X+H) := by | |
| calc | |
| _ ≤ ∑ m ∈ residueStarts X q c, Real.log (2*X+H) := Finset.sum_le_sum htheta | |
| _ = ((residueStarts X q c).card:ℝ) * Real.log (2*X+H) := by simp | |
| _ ≤ ((X:ℝ)/q+2) * Real.log (2*X+H) := by | |
| apply mul_le_mul_of_nonneg_right _ hlog | |
| have hh := (abs_le.mp (residueStarts_card_error X hq hc)).2 | |
| linarith | |
| _ ≤ _ := mul_le_mul_of_nonneg_right (by linarith) hlog | |
| have htot : (X:ℝ)/q.totient ≤ (X:ℝ)/q * (2:ℝ)^q.primeFactors.card := by | |
| have ht : (q:ℝ) ≤ (2:ℝ)^q.primeFactors.card * q.totient := by | |
| exact_mod_cast squarefree_totient_lower hsq | |
| apply (div_le_iff₀ hphi).mpr | |
| have hx := mul_le_mul_of_nonneg_left ht (show 0 ≤ (X:ℝ)/q by positivity) | |
| field_simp at hx ⊢ | |
| nlinarith | |
| calc | |
| _ ≤ (∑ m ∈ residueStarts X q c, theta (m+a)) + (X:ℝ)/q.totient := by | |
| have hs0 : 0 ≤ ∑ m ∈ residueStarts X q c, theta (m+a) := | |
| Finset.sum_nonneg fun m _ => theta_nonneg (m+a) | |
| have ht0 : 0 ≤ (X:ℝ)/q.totient := by positivity | |
| exact abs_sub_le_iff.mpr ⟨by linarith, by linarith⟩ | |
| _ ≤ 3 * ((X:ℝ)/q) * Real.log (2*X+H) + (X:ℝ)/q * 2^q.primeFactors.card := | |
| add_le_add hsum htot | |
| _ = _ := by ring | |
| theorem markedError_trivial {X H q : ℕ} (hX : 1 ≤ X) (hq : 0 < q) | |
| (hqX : q ≤ X) (hsq : Squarefree q) : | |
| (markedError X H q : ℝ) ≤ | |
| (X:ℝ)/(q:ℝ) * (3 * Real.log (2*X+H) + 2^q.primeFactors.card) := by | |
| have hnonneg : 0 ≤ (X:ℝ)/(q:ℝ) * | |
| (3 * Real.log (2*X+H) + 2^q.primeFactors.card) := by | |
| have : 0 ≤ Real.log (2*X+H) := Real.log_nonneg (by | |
| exact_mod_cast (show 1 ≤ 2*X+H by omega)) | |
| positivity | |
| change markedError X H q ≤ NNReal.mk _ hnonneg | |
| apply Finset.sup_le | |
| rintro ⟨a,c⟩ hac | |
| have ha : a ≤ H := by simpa using (Finset.mem_product.mp hac).1 | |
| have hc : c < q := Finset.mem_range.mp (Finset.mem_product.mp hac).2 | |
| dsimp only | |
| split_ifs | |
| · exact markedClassError_trivial hX hq hqX ha hc hsq | |
| · exact zero_le | |
| noncomputable def residueSlice (f : ℕ → ℝ) (L U q c : ℕ) : ℝ := | |
| ∑ n ∈ (Finset.Ioc L U).filter (fun n => n % q = c), f n | |
| noncomputable def residuePrefix (f : ℕ → ℝ) (Y q c : ℕ) : ℝ := | |
| residueSlice f 0 Y q c | |
| theorem residuePrefix_sub (f : ℕ → ℝ) {L U : ℕ} (hLU : L ≤ U) (q c : ℕ) : | |
| residuePrefix f U q c - residuePrefix f L q c = residueSlice f L U q c := by | |
| classical | |
| have hunion : Finset.Ioc 0 U = Finset.Ioc 0 L ∪ Finset.Ioc L U := by | |
| ext n | |
| simp only [Finset.mem_Ioc, Finset.mem_union] | |
| omega | |
| have hd : Disjoint ((Finset.Ioc 0 L).filter fun n => n % q = c) | |
| ((Finset.Ioc L U).filter fun n => n % q = c) := by | |
| apply Finset.disjoint_left.mpr | |
| intro n hn hm | |
| have hl := (Finset.mem_Ioc.mp (Finset.mem_filter.mp hn).1).2 | |
| have hu := (Finset.mem_Ioc.mp (Finset.mem_filter.mp hm).1).1 | |
| omega | |
| simp only [residuePrefix, residueSlice, hunion, Finset.filter_union, Finset.sum_union hd] | |
| ring | |
| theorem shifted_sum_eq_residueSlice (f : ℕ → ℝ) (X q a : ℕ) {c : ℕ} (hc : c < q) : | |
| (∑ m ∈ residueStarts X q c, f (m+a)) = | |
| residueSlice f (X+a) (2*X+a) q ((c+a)%q) := by | |
| classical | |
| apply Finset.sum_bij (fun m _ => m+a) | |
| · intro m hm | |
| obtain ⟨hm,hmc⟩ := Finset.mem_filter.mp hm | |
| obtain ⟨hmlo,hmhi⟩ := Finset.mem_Ioc.mp hm | |
| apply Finset.mem_filter.mpr | |
| refine ⟨Finset.mem_Ioc.mpr ⟨by omega, by omega⟩, ?_⟩ | |
| have hh : Nat.ModEq q m c := by | |
| change m % q = c % q | |
| rw [hmc, Nat.mod_eq_of_lt hc] | |
| exact hh.add_right a | |
| · intro m _ n _ heq | |
| omega | |
| · intro n hn | |
| obtain ⟨hn,hnc⟩ := Finset.mem_filter.mp hn | |
| obtain ⟨hnlo,hnhi⟩ := Finset.mem_Ioc.mp hn | |
| have ha : a ≤ n := by omega | |
| refine ⟨n-a, Finset.mem_filter.mpr ⟨Finset.mem_Ioc.mpr ⟨by omega, by omega⟩, ?_⟩, | |
| Nat.sub_add_cancel ha⟩ | |
| have hh : Nat.ModEq q ((n-a)+a) (c+a) := by | |
| change ((n-a)+a) % q = (c+a) % q | |
| simpa only [Nat.sub_add_cancel ha] using hnc | |
| have hhc := Nat.ModEq.add_right_cancel' a hh | |
| simpa only [Nat.ModEq, Nat.mod_eq_of_lt hc] using hhc | |
| · intro m _ | |
| rfl | |
| end LargePrimeGaps | |
| end OAI | |