| import Mathlib |
| import OAI.NumberTheory.Jacobsthal.Estimates.HeightBlockCount |
| import OAI.NumberTheory.Jacobsthal.Estimates.HypotheticalPairRows |
|
|
| namespace OAI |
|
|
| namespace Erdos970 |
| open scoped _root_.Erdos970 |
|
|
|
|
| namespace ErdosCommonParameterInterval |
|
|
| noncomputable def commonLower (a R T : ℝ) : ℝ := max (a/R) (a/T) |
| noncomputable def commonUpper (b R T : ℝ) : ℝ := min (b/R) (b/T) |
|
|
| theorem div_between_endpoints (a : ℝ) {R p T : ℝ} (hR : 0 < R) |
| (hRp : R ≤ p) (hpT : p ≤ T) : |
| min (a/R) (a/T) ≤ a/p ∧ a/p ≤ max (a/R) (a/T) := by |
| have hp : 0 < p := hR.trans_le hRp |
| have hT : 0 < T := hp.trans_le hpT |
| by_cases ha : 0 ≤ a |
| · exact ⟨(min_le_right _ _).trans (div_le_div_of_nonneg_left ha hp hpT), |
| (div_le_div_of_nonneg_left ha hR hRp).trans (le_max_left _ _)⟩ |
| · have han : 0 ≤ -a := by linarith |
| have h1 := div_le_div_of_nonneg_left han hp hpT |
| have h2 := div_le_div_of_nonneg_left han hR hRp |
| simp only [neg_div] at h1 h2 |
| exact ⟨(min_le_left _ _).trans (by linarith), |
| (show a/p ≤ a/T by linarith).trans (le_max_right _ _)⟩ |
|
|
| theorem common_interval_subset (a b : ℝ) {R p T : ℝ} (hR : 0 < R) |
| (hRp : R ≤ p) (hpT : p ≤ T) : |
| Set.Ioc (commonLower a R T) (commonUpper b R T) ⊆ Set.Ioc (a/p) (b/p) := by |
| intro m hm |
| exact ⟨(div_between_endpoints a hR hRp hpT).2.trans_lt hm.1, |
| hm.2.trans (div_between_endpoints b hR hRp hpT).1⟩ |
|
|
| theorem commonLower_error (a : ℝ) {R T : ℝ} (hR : 0 < R) (hRT : R ≤ T) : |
| commonLower a R T ≤ a/T+|a| *(1/R-1/T) := by |
| have hT : 0 < T := hR.trans_le hRT |
| have hd : 0 ≤ 1/R-1/T := sub_nonneg.mpr (one_div_le_one_div_of_le hR hRT) |
| have he : a/R=a/T+a*(1/R-1/T) := by ring |
| apply max_le |
| · rw [he] |
| exact add_le_add le_rfl (mul_le_mul_of_nonneg_right (le_abs_self a) hd) |
| · exact le_add_of_nonneg_right (mul_nonneg (abs_nonneg a) hd) |
|
|
| theorem commonUpper_error (b : ℝ) {R T : ℝ} (hR : 0 < R) (hRT : R ≤ T) : |
| b/T-|b| *(1/R-1/T) ≤ commonUpper b R T := by |
| have hT : 0 < T := hR.trans_le hRT |
| have hd : 0 ≤ 1/R-1/T := sub_nonneg.mpr (one_div_le_one_div_of_le hR hRT) |
| have he : b/R=b/T+b*(1/R-1/T) := by ring |
| apply le_min |
| · rw [he] |
| have h := mul_le_mul_of_nonneg_right (neg_abs_le b) hd |
| nlinarith |
| · exact sub_le_self _ (mul_nonneg (abs_nonneg b) hd) |
|
|
| theorem common_length_lower (a b : ℝ) {R T : ℝ} (hR : 0 < R) (hRT : R ≤ T) : |
| (b-a)/T-(|a|+|b|)*(1/R-1/T) ≤ commonUpper b R T-commonLower a R T := by |
| have hl := commonLower_error a hR hRT |
| have hu := commonUpper_error b hR hRT |
| have he : (b-a)/T-(|a|+|b|)*(1/R-1/T) = |
| (b/T-|b| *(1/R-1/T))-(a/T+|a| *(1/R-1/T)) := by ring |
| rw [he] |
| exact sub_le_sub hu hl |
|
|
| theorem common_height_bound (a b m : ℝ) {R T : ℝ} (hR : 0 < R) |
| (hm : m ∈ Set.Ioc (commonLower a R T) (commonUpper b R T)) : |
| |m| ≤ max |a| |b|/R := by |
| apply abs_le.mpr |
| constructor |
| · have h1 : -(max |a| |b|) ≤ a := |
| (neg_le_neg (le_max_left _ _)).trans (neg_abs_le a) |
| have h2 := div_le_div_of_nonneg_right h1 hR.le |
| have h3 : a/R ≤ commonLower a R T := le_max_left _ _ |
| rw [neg_div] at h2 |
| exact h2.trans (h3.trans hm.1.le) |
| · have h1 : b ≤ max |a| |b| := (le_abs_self b).trans (le_max_right _ _) |
| have h2 := div_le_div_of_nonneg_right h1 hR.le |
| exact hm.2.trans ((min_le_left _ _).trans h2) |
|
|
|
|
|
|
|
|
|
|
| theorem reciprocal_width_bound {R T epsilon : ℝ} (hR : 0 < R) (hRT : R ≤ T) |
| (hwidth : T ≤ (1+epsilon)*R) : 1/R-1/T ≤ epsilon/T := by |
| have hT : 0 < T := hR.trans_le hRT |
| have hdiv : T/R ≤ 1+epsilon := (div_le_iff₀ hR).mpr hwidth |
| have he : (1/R-1/T)*T=T/R-1 := by field_simp |
| apply (le_div_iff₀ hT).mpr |
| rw [he] |
| linarith |
|
|
| theorem common_length_lower_relative (a b : ℝ) {R T epsilon : ℝ} |
| (hR : 0 < R) (hRT : R ≤ T) (hwidth : T ≤ (1+epsilon)*R) : |
| ((b-a)-epsilon*(|a|+|b|))/T ≤ commonUpper b R T-commonLower a R T := by |
| have hd := reciprocal_width_bound hR hRT hwidth |
| have hmul := mul_le_mul_of_nonneg_left hd (add_nonneg (abs_nonneg a) (abs_nonneg b)) |
| calc |
| _ = (b-a)/T-(|a|+|b|)*(epsilon/T) := by ring |
| _ ≤ (b-a)/T-(|a|+|b|)*(1/R-1/T) := sub_le_sub_left hmul _ |
| _ ≤ _ := common_length_lower a b hR hRT |
|
|
| theorem affine_common_interval (A D Y q m : ℝ) {R p T : ℝ} |
| (hq : 0 < q) (hR : 0 < R) (hRp : R ≤ p) (hpT : p ≤ T) |
| (hm : m ∈ Set.Ioc (commonLower (-A/q) R T) (commonUpper ((D*Y-A)/q) R T)) : |
| 0 < A+p*q*m ∧ A+p*q*m ≤ D*Y := by |
| have hp : 0 < p := hR.trans_le hRp |
| have hc := common_interval_subset (-A/q) ((D*Y-A)/q) hR hRp hpT hm |
| simp only [div_div] at hc |
| have hl := (div_lt_iff₀ (mul_pos hq hp)).mp hc.1 |
| have hu := (le_div_iff₀ (mul_pos hq hp)).mp hc.2 |
| constructor <;> nlinarith |
|
|
| end ErdosCommonParameterInterval |
|
|
|
|
|
|
| namespace ErdosCommonMInterval |
| open ErdosCommonParameterInterval |
|
|
| noncomputable def lower (A q R T : ℝ) : ℝ := commonLower (-A/q) R T + 1 |
| noncomputable def upper (A D Y q R T : ℝ) : ℝ := commonUpper ((D*Y-A)/q) R T |
| noncomputable def interval (A D Y q R T : ℝ) : Set ℝ := |
| Set.Icc (lower A q R T) (upper A D Y q R T) |
| noncomputable def referenceLength (Y R q : ℝ) : ℝ := Y/(R*q) |
| noncomputable def lengthExponent (P Y R q : ℝ) : ℝ := Real.log (referenceLength Y R q)/Real.log P |
|
|
| theorem closed_subset (A D Y q R T : ℝ) : |
| interval A D Y q R T ⊆ |
| Set.Ioc (commonLower (-A/q) R T) (commonUpper ((D*Y-A)/q) R T) := by |
| intro m hm |
| exact ⟨by have := hm.1; dsimp [interval,lower] at this; linarith, hm.2⟩ |
|
|
| theorem closed_affine {A D Y q R T m p : ℝ} |
| (hq : 0 < q) (hR : 0 < R) (hRp : R ≤ p) (hpT : p ≤ T) |
| (hm : m ∈ interval A D Y q R T) : |
| 0 < A+p*q*m ∧ A+p*q*m ≤ D*Y := |
| affine_common_interval A D Y q m hq hR hRp hpT (closed_subset A D Y q R T hm) |
|
|
| theorem integer_decode {A m : ℤ} {D Y q p : ℕ} {R T : ℝ} |
| (hD : 0 < D) (hq : 0 < q) (hR : 0 < R) |
| (hRp : R ≤ (p : ℝ)) (hpT : (p : ℝ) ≤ T) |
| (hm : (m : ℝ) ∈ interval A D Y q R T) |
| (hdvd : (D : ℤ) ∣ A+(p : ℤ)*q*m) : |
| ∃ n : ℕ, 1 ≤ n ∧ n ≤ Y ∧ (D : ℤ)*n=A+(p : ℤ)*q*m := by |
| have hb := closed_affine (by exact_mod_cast hq) hR hRp hpT hm |
| obtain ⟨k,hk⟩ := hdvd |
| have he : (A : ℝ)+(p : ℝ)*q*m=(D : ℝ)*(k : ℝ) := by exact_mod_cast hk |
| have hDp : (0 : ℝ) < D := by exact_mod_cast hD |
| have hkpos : (0 : ℝ) < k := by nlinarith [hb.1] |
| have hkY : (k : ℝ) ≤ Y := by nlinarith [hb.2] |
| have hkint : 0 ≤ k := le_of_lt (by exact_mod_cast hkpos : (0 : ℤ) < k) |
| refine ⟨k.toNat, ?_, ?_, ?_⟩ |
| · have : (1 : ℤ) ≤ k := by exact_mod_cast (by exact_mod_cast hkpos : (0 : ℤ) < k) |
| exact_mod_cast (show (1 : ℤ) ≤ (k.toNat : ℤ) by simpa [Int.toNat_of_nonneg hkint] using this) |
| · have : k ≤ (Y : ℤ) := by exact_mod_cast hkY |
| exact_mod_cast (show (k.toNat : ℤ) ≤ (Y : ℤ) by simpa [Int.toNat_of_nonneg hkint] using this) |
| · simpa [Int.toNat_of_nonneg hkint] using hk.symm |
|
|
| def decode (A m : ℤ) (D q p : ℕ) : ℕ := |
| ((A+(p : ℤ)*q*m)/(D : ℤ)).toNat |
|
|
| theorem decode_spec {A m : ℤ} {D Y q p : ℕ} {R T : ℝ} |
| (hD : 0 < D) (hq : 0 < q) (hR : 0 < R) |
| (hRp : R ≤ (p : ℝ)) (hpT : (p : ℝ) ≤ T) |
| (hm : (m : ℝ) ∈ interval A D Y q R T) |
| (hdvd : (D : ℤ) ∣ A+(p : ℤ)*q*m) : |
| 1 ≤ decode A m D q p ∧ decode A m D q p ≤ Y ∧ |
| (D : ℤ)*decode A m D q p=A+(p : ℤ)*q*m := by |
| obtain ⟨n,hn1,hnY,hn⟩ := integer_decode hD hq hR hRp hpT hm hdvd |
| have hDn : (D : ℤ) ≠ 0 := by exact_mod_cast hD.ne' |
| have hid : decode A m D q p=n := by |
| unfold decode |
| rw [← hn,Int.mul_ediv_cancel_left _ hDn] |
| simp |
| simpa only [hid] using And.intro hn1 (And.intro hnY hn) |
|
|
| theorem reference_rpow {P Y R q : ℝ} (hP : 1 < P) |
| (hY : 0 < Y) (hR : 0 < R) (hq : 0 < q) : |
| P ^ lengthExponent P Y R q = referenceLength Y R q := by |
| have hJ : 0 < referenceLength Y R q := div_pos hY (mul_pos hR hq) |
| rw [lengthExponent,Real.rpow_def_of_pos (by linarith : 0 < P)] |
| rw [mul_div_cancel₀ _ (Real.log_pos hP).ne'] |
| exact Real.exp_log hJ |
|
|
| end ErdosCommonMInterval |
|
|
|
|
|
|
| namespace ErdosCommonMInterval |
| open ErdosCommonParameterInterval |
|
|
| theorem endpoint_magnitude {A D Y q : ℝ} (hD : 0 ≤ D) (hY : 0 ≤ Y) (hq : 0 < q) : |
| |-A/q|+|(D*Y-A)/q| ≤ (D*Y+2*|A|)/q := by |
| rw [abs_div,abs_div,abs_of_pos hq,abs_neg,← add_div] |
| apply div_le_div_of_nonneg_right _ hq.le |
| have h : |D*Y-A| ≤ |D*Y|+|A| := by |
| simpa only [sub_zero, zero_sub, abs_neg] using abs_sub_le (D*Y) 0 A |
| rw [abs_of_nonneg (mul_nonneg hD hY)] at h |
| linarith |
|
|
| theorem closed_length_lower {A D Y q R T H e : ℝ} |
| (hD : 1 ≤ D) (hY : 0 < Y) (hq : 0 < q) (hR : 0 < R) (hRT : R ≤ T) |
| (hH : 0 ≤ H) (he : 0 ≤ e) (hwidth : T ≤ (1+e)*R) (hA : |A| ≤ Y*H) : |
| (1-2*e*(1+H))*D*referenceLength Y R q-1 ≤ |
| upper A D Y q R T-lower A q R T := by |
| have hT : 0 < T := hR.trans_le hRT |
| have hD0 : 0 < D := by linarith |
| have hd0 : 0 ≤ 1/R-1/T := sub_nonneg.mpr (one_div_le_one_div_of_le hR hRT) |
| have hd := (reciprocal_width_bound hR hRT hwidth).trans |
| (div_le_div_of_nonneg_left he hR hRT) |
| have hmag := endpoint_magnitude (A := A) hD0.le hY.le hq |
| have hbase : (D*Y-A)/q-(-A/q) = D*Y/q := by ring |
| have hnorm : D*Y/q+|-A/q|+|(D*Y-A)/q| ≤ 2*D*Y*(1+H)/q := by |
| have hDH : Y*H ≤ D*Y*H := by nlinarith [mul_nonneg hY.le hH] |
| have : (D*Y+2*|A|)/q ≤ (D*Y+2*D*Y*H)/q := |
| div_le_div_of_nonneg_right (by linarith) hq.le |
| calc |
| _ ≤ D*Y/q+(D*Y+2*D*Y*H)/q := by linarith |
| _ = _ := by ring |
| have hnorm0 : 0 ≤ D*Y/q+|-A/q|+|(D*Y-A)/q| := by positivity |
| have hprod := mul_le_mul hnorm hd hd0 (by positivity : 0 ≤ 2*D*Y*(1+H)/q) |
| have hf := common_length_lower (-A/q) ((D*Y-A)/q) hR hRT |
| rw [hbase] at hf |
| have heq : (D*Y/q)/T-(|-A/q|+|(D*Y-A)/q|)*(1/R-1/T) = |
| D*Y/(R*q)-(D*Y/q+|-A/q|+|(D*Y-A)/q|)*(1/R-1/T) := by ring |
| rw [heq] at hf |
| dsimp [upper,lower,referenceLength] |
| have heq2 : D*Y/(R*q)-(2*D*Y*(1+H)/q)*(e/R) = |
| (1-2*e*(1+H))*D*(Y/(R*q)) := by ring |
| linarith |
|
|
| theorem closed_length_upper (A D Y q R T : ℝ) : |
| upper A D Y q R T-lower A q R T ≤ D*referenceLength Y R q-1 := by |
| have hU : upper A D Y q R T ≤ ((D*Y-A)/q)/R := min_le_left _ _ |
| have hL : (-A/q)/R+1 ≤ lower A q R T := by |
| have h : (-A/q)/R ≤ ErdosCommonParameterInterval.commonLower (-A/q) R T := le_max_left _ _ |
| dsimp [lower];linarith |
| have heq : ((D*Y-A)/q)/R-((-A/q)/R+1)=D*referenceLength Y R q-1 := by |
| dsimp [referenceLength];ring |
| linarith |
|
|
| theorem closed_height {A D Y q R T H m : ℝ} |
| (hD : 0 ≤ D) (hY : 0 < Y) (hq : 0 < q) (hR : 0 < R) |
| (hA : |A| ≤ Y*H) (hm : m ∈ interval A D Y q R T) : |
| |m| ≤ (D+H)*referenceLength Y R q := by |
| have hb := common_height_bound (-A/q) ((D*Y-A)/q) m hR |
| (closed_subset A D Y q R T hm) |
| have ha : |-A/q| ≤ (D*Y+Y*H)/q := by |
| rw [abs_div,abs_neg,abs_of_pos hq] |
| exact div_le_div_of_nonneg_right (by nlinarith) hq.le |
| have hc : |(D*Y-A)/q| ≤ (D*Y+Y*H)/q := by |
| rw [abs_div,abs_of_pos hq] |
| apply div_le_div_of_nonneg_right _ hq.le |
| have h : |D*Y-A| ≤ |D*Y|+|A| := by |
| simpa only [sub_zero, zero_sub, abs_neg] using abs_sub_le (D*Y) 0 A |
| rw [abs_of_nonneg (mul_nonneg hD hY.le)] at h |
| linarith |
| calc |
| _ ≤ max |-A/q| |(D*Y-A)/q|/R := hb |
| _ ≤ ((D*Y+Y*H)/q)/R := div_le_div_of_nonneg_right (max_le ha hc) hR.le |
| _ = _ := by dsimp [referenceLength];ring |
|
|
| end ErdosCommonMInterval |
|
|
|
|
| section |
|
|
| open _root_.Filter |
| open scoped Topology |
| namespace ErdosCommonMInterval |
|
|
| theorem eventual_polynomial_cutoff (B K : ℝ) (hB : 0 ≤ B) (hK : 0 < K) : |
| ∀ᶠ w : ℝ in atTop, 2 ≤ w ∧ w^B ≤ Real.exp (K*(Real.log w)^3) := by |
| filter_upwards [eventually_ge_atTop (2 : ℝ), |
| Real.tendsto_log_atTop.eventually_ge_atTop (max 1 (B/K))] with w hw hL |
| have hw0 : 0 < w := by linarith |
| have hL1 : 1 ≤ Real.log w := (le_max_left _ _).trans hL |
| have hBL : B ≤ K*Real.log w := by |
| have := (div_le_iff₀ hK).mp (show B/K ≤ Real.log w from (le_max_right _ _).trans hL) |
| nlinarith |
| refine ⟨hw, ?_⟩ |
| rw [Real.rpow_def_of_pos hw0] |
| apply Real.exp_le_exp.mpr |
| have hsq : Real.log w ≤ (Real.log w)^2 := by nlinarith |
| have hpow : (Real.log w)^2 ≤ (Real.log w)^3 := by nlinarith |
| nlinarith [mul_le_mul_of_nonneg_right hBL (by linarith : 0 ≤ Real.log w)] |
|
|
| theorem subbin_loss {w C : ℝ} (hw : 1 ≤ w) (hC : 0 ≤ C) : |
| 2*w^(-2*C-10)*(1+w^(C+2)) ≤ 4*w^(-8 : ℝ) := by |
| have hw0 : 0 < w := by linarith |
| have hH : 1 ≤ w^(C+2) := Real.one_le_rpow hw (by linarith) |
| have hmul : w^(-2*C-10)*w^(C+2) = w^(-C-8) := by |
| rw [← Real.rpow_add hw0];congr 1;ring |
| have hcmp : w^(-C-8) ≤ w^(-8 : ℝ) := Real.rpow_le_rpow_of_exponent_le hw (by linarith) |
| have hnon : 0 ≤ w^(-2*C-10) := Real.rpow_nonneg hw0.le _ |
| have hle : w^(-2*C-10) ≤ w^(-2*C-10)*w^(C+2) := by nlinarith |
| nlinarith |
|
|
| theorem height_absorption {w P C : ℝ} (hw : 2 ≤ w) |
| (hP : w^(50*(C+3)) ≤ P) : 2*w^(C+2) ≤ P^((2 : ℝ)/100) := by |
| have hw0 : 0 < w := by linarith |
| have h1 : 2*w^(C+2) ≤ w^(C+3) := by |
| have he : w^(C+3)=w*w^(C+2) := by |
| calc w^(C+3) = w^((1 : ℝ)+(C+2)) := by congr 1;ring |
| _ = w*w^(C+2) := by rw [Real.rpow_add hw0,Real.rpow_one] |
| rw [he] |
| exact mul_le_mul_of_nonneg_right hw (Real.rpow_nonneg hw0.le _) |
| have h2 := Real.rpow_le_rpow (Real.rpow_nonneg hw0.le (50*(C+3))) hP |
| (by norm_num : (0 : ℝ) ≤ 2/100) |
| have he : (w^(50*(C+3)))^((2 : ℝ)/100)=w^(C+3) := by |
| rw [← Real.rpow_mul hw0.le];congr 1;ring |
| exact h1.trans (by rwa [he] at h2) |
|
|
| noncomputable def relativeError (w : ℝ) : ℝ := 4*w^(-8 : ℝ)+w^(-2 : ℝ) |
|
|
| theorem relativeError_tends_zero : Tendsto relativeError atTop (𝓝 0) := by |
| have h8 := tendsto_rpow_neg_atTop (by norm_num : (0 : ℝ) < 8) |
| have h2 := tendsto_rpow_neg_atTop (by norm_num : (0 : ℝ) < 2) |
| change Tendsto (fun w : ℝ => 4*w^(-8 : ℝ)+w^(-2 : ℝ)) atTop (𝓝 0) |
| simpa only [mul_zero,add_zero] using (h8.const_mul 4).add h2 |
|
|
| theorem uniform_common_interval (C K delta : ℝ) (hC : 0 ≤ C) (hK : 0 < K) |
| (hd0 : 0 < delta) (hd1 : delta < 1) : |
| ∃ W : ℝ, ∀ w : ℝ, W ≤ w → ∀ P A D Y q R T : ℝ, |
| Real.exp (K*(Real.log w)^3) ≤ P → |
| 1 ≤ D → D ≤ w^C → 0 < Y → 0 < q → 0 < R → R ≤ T → |
| T ≤ (1+w^(-2*C-10))*R → |A| ≤ Y*w^(C+2) → |
| 2 ≤ lengthExponent P Y R q → |
| (1-delta)*D*referenceLength Y R q ≤ upper A D Y q R T-lower A q R T ∧ |
| upper A D Y q R T-lower A q R T ≤ D*referenceLength Y R q ∧ |
| (interval A D Y q R T).Nonempty ∧ |
| ∀ m ∈ interval A D Y q R T, |m| ≤ P^(lengthExponent P Y R q+(2 : ℝ)/100) := by |
| have hE := relativeError_tends_zero.eventually (gt_mem_nhds hd0) |
| have hpoly := eventual_polynomial_cutoff (50*(C+3)) K (by positivity) hK |
| obtain ⟨W,hW⟩ := eventually_atTop.mp (hE.and hpoly) |
| refine ⟨W, ?_⟩ |
| intro w hw P A D Y q R T hP hD hDu hY hq hR hRT hwidth hA hs |
| obtain ⟨hErr,hw2,hpow⟩ := hW w hw |
| have hw0 : 0 < w := by linarith |
| have hw1 : 1 ≤ w := by linarith |
| have hwpow : w ≤ w^(50*(C+3)) := by |
| calc w = w^(1 : ℝ) := (Real.rpow_one _).symm |
| _ ≤ _ := Real.rpow_le_rpow_of_exponent_le hw1 (by nlinarith) |
| have hwP : w ≤ P := hwpow.trans (hpow.trans hP) |
| have hP1 : 1 < P := by linarith |
| have hD0 : 0 < D := by linarith |
| have hJ : 0 < referenceLength Y R q := div_pos hY (mul_pos hR hq) |
| have hJid := reference_rpow hP1 hY hR hq |
| have hJlow : P^2 ≤ referenceLength Y R q := by |
| rw [← hJid] |
| simpa only [Real.rpow_ofNat] using Real.rpow_le_rpow_of_exponent_le hP1.le hs |
| have hJw : w^2 ≤ referenceLength Y R q := by nlinarith |
| have hpay : 1 ≤ w^(-2 : ℝ)*D*referenceLength Y R q := by |
| have hid : w^(-2 : ℝ)*w^2=1 := by |
| rw [← Real.rpow_ofNat,← Real.rpow_add hw0];norm_num |
| have hn : 0 ≤ w^(-2 : ℝ) := Real.rpow_nonneg hw0.le _ |
| have hm : w^2 ≤ D*referenceLength Y R q := by nlinarith |
| have := mul_le_mul_of_nonneg_left hm hn |
| nlinarith |
| have hraw := closed_length_lower hD hY hq hR hRT |
| (Real.rpow_nonneg hw0.le (C+2)) (Real.rpow_nonneg hw0.le (-2*C-10)) hwidth hA |
| have hcost := subbin_loss hw1 hC |
| have hlen : (1-delta)*D*referenceLength Y R q ≤ |
| upper A D Y q R T-lower A q R T := by |
| have hmul := mul_le_mul_of_nonneg_right hcost (mul_pos hD0 hJ).le |
| have herrmul := mul_le_mul_of_nonneg_right hErr.le (mul_pos hD0 hJ).le |
| dsimp [relativeError] at herrmul |
| nlinarith |
| refine ⟨hlen, (closed_length_upper A D Y q R T).trans (by linarith), ?_, ?_⟩ |
| · apply Set.nonempty_Icc.mpr |
| have := mul_pos (mul_pos (by linarith : 0 < 1-delta) hD0) hJ |
| linarith |
| · intro m hm |
| have hheight := closed_height hD0.le hY hq hR hA hm |
| have hDC : D ≤ w^(C+2) := hDu.trans |
| (Real.rpow_le_rpow_of_exponent_le hw1 (by linarith)) |
| have habs := height_absorption hw2 (hpow.trans hP) |
| have hp02 : D+w^(C+2) ≤ P^((2 : ℝ)/100) := by linarith |
| calc |
| |m| ≤ (D+w^(C+2))*referenceLength Y R q := hheight |
| _ ≤ P^((2 : ℝ)/100)*referenceLength Y R q := mul_le_mul_of_nonneg_right hp02 hJ.le |
| _ = P^(lengthExponent P Y R q+(2 : ℝ)/100) := by |
| rw [← hJid,← Real.rpow_add (by linarith : 0 < P)];congr 1;ring |
|
|
| theorem uniform_integer_common_interval (C K delta : ℝ) (hC : 0 ≤ C) (hK : 0 < K) |
| (hd0 : 0 < delta) (hd1 : delta < 1) : |
| ∃ W : ℝ, ∀ w : ℝ, W ≤ w → ∀ P R T : ℝ, ∀ A : ℤ, ∀ D Y q : ℕ, |
| Real.exp (K*(Real.log w)^3) ≤ P → |
| 0 < D → (D : ℝ) ≤ w^C → 0 < Y → 0 < q → 0 < R → R ≤ T → |
| T ≤ (1+w^(-2*C-10))*R → |(A : ℝ)| ≤ (Y : ℝ)*w^(C+2) → |
| 2 ≤ lengthExponent P Y R q → |
| (1-delta)*(D : ℝ)*referenceLength Y R q ≤ upper A D Y q R T-lower A q R T ∧ |
| upper A D Y q R T-lower A q R T ≤ (D : ℝ)*referenceLength Y R q ∧ |
| (interval A D Y q R T).Nonempty ∧ |
| (∀ m ∈ interval A D Y q R T, |m| ≤ P^(lengthExponent P Y R q+(2 : ℝ)/100)) ∧ |
| ∀ p : ℕ, ∀ m : ℤ, R ≤ (p : ℝ) → (p : ℝ) ≤ T → |
| (m : ℝ) ∈ interval A D Y q R T → (D : ℤ) ∣ A+(p : ℤ)*q*m → |
| 1 ≤ decode A m D q p ∧ decode A m D q p ≤ Y ∧ |
| (D : ℤ)*decode A m D q p=A+(p : ℤ)*q*m := by |
| obtain ⟨W,hW⟩ := uniform_common_interval C K delta hC hK hd0 hd1 |
| refine ⟨W, ?_⟩ |
| intro w hw P R T A D Y q hP hD hDu hY hq hR hRT hwidth hA hs |
| have hb := hW w hw P A D Y q R T hP |
| (by exact_mod_cast (show 1 ≤ D from hD)) hDu |
| (by exact_mod_cast hY) (by exact_mod_cast hq) hR hRT hwidth hA hs |
| refine ⟨hb.1,hb.2.1,hb.2.2.1,hb.2.2.2,?_⟩ |
| intro p m hRp hpT hm hdvd |
| exact decode_spec hD hq hR hRp hpT hm hdvd |
|
|
| end ErdosCommonMInterval |
|
|
| end |
|
|
|
|
| namespace ErdosLargeHeightBlocks |
|
|
| noncomputable def blockLeft (C0 : ℤ) (R xi : ℝ) (H i : ℕ) : ℝ := |
| ErdosTagSubbins.left R xi (blockCount C0 R xi H) i |
| noncomputable def blockRight (C0 : ℤ) (R xi : ℝ) (H i : ℕ) : ℝ := |
| ErdosTagSubbins.right R xi (blockCount C0 R xi H) i |
|
|
| theorem block_reciprocal_variation (C0 : ℤ) (R xi : ℝ) (H i : ℕ) |
| (hR : 0 < R) (hxi : 0 < xi) (hH : 0 < H) : |
| |(C0 : ℝ)/blockLeft C0 R xi H i-(C0 : ℝ)/blockRight C0 R xi H i| ≤ (H : ℝ) := by |
| let N := blockCount C0 R xi H |
| let a := blockLeft C0 R xi H i |
| let b := blockRight C0 R xi H i |
| have hN : 0 < N := blockCount_pos C0 R xi H |
| have hNr : (0 : ℝ) < N := by exact_mod_cast hN |
| have hHr : (0 : ℝ) < H := by exact_mod_cast hH |
| have hs := ErdosTagSubbins.step_pos hR hxi hN |
| have ha : R ≤ a := ErdosTagSubbins.left_lower hs.le |
| have hab : a < b := ErdosTagSubbins.left_lt_right hR hxi hN |
| have hb : R ≤ b := ha.trans hab.le |
| have ha0 : 0 < a := hR.trans_le ha |
| have hb0 : 0 < b := hR.trans_le hb |
| have hd : b-a = ErdosTagSubbins.step R xi N := ErdosTagSubbins.right_sub_left R xi N i |
| have hden : R^2 ≤ a*b := by |
| simpa only [pow_two] using mul_le_mul ha hb hR.le ha0.le |
| have he : (C0 : ℝ)/a-(C0 : ℝ)/b=(C0 : ℝ)*(b-a)/(a*b) := by |
| field_simp |
| have hcount := (div_le_iff₀ (mul_pos hR hHr)).mp (blockCount_lower C0 R xi H) |
| change |(C0 : ℝ)/a-(C0 : ℝ)/b| ≤ (H : ℝ) |
| rw [he,abs_div,abs_mul,abs_of_nonneg (sub_nonneg.mpr hab.le),abs_of_pos (mul_pos ha0 hb0)] |
| calc |
| _ ≤ |(C0 : ℝ)| * (b-a)/R^2 := |
| div_le_div_of_nonneg_left (mul_nonneg (abs_nonneg _) (sub_nonneg.mpr hab.le)) (sq_pos_of_pos hR) hden |
| _ = xi*|(C0 : ℝ)|/(R*(N : ℝ)) := by |
| rw [hd] |
| dsimp [ErdosTagSubbins.step] |
| field_simp |
| _ ≤ _ := by |
| apply (div_le_iff₀ (mul_pos hR hNr)).mpr |
| change xi*|(C0 : ℝ)| ≤ (N : ℝ)*(R*(H : ℝ)) at hcount |
| nlinarith |
|
|
| noncomputable def coordinateLower (C0 : ℤ) (R xi : ℝ) (H i : ℕ) : ℝ := |
| min ((C0 : ℝ)/blockLeft C0 R xi H i) ((C0 : ℝ)/blockRight C0 R xi H i) |
| noncomputable def coordinateUpper (C0 : ℤ) (R xi : ℝ) (H i : ℕ) : ℝ := |
| max ((C0 : ℝ)/blockLeft C0 R xi H i) ((C0 : ℝ)/blockRight C0 R xi H i)+(H : ℝ) |
|
|
| theorem block_coordinate_containment (C0 : ℤ) (R xi : ℝ) (H i : ℕ) |
| (hR : 0 < R) (hxi : 0 < xi) (p m : ℝ) |
| (hpL : blockLeft C0 R xi H i ≤ p) (hpU : p ≤ blockRight C0 R xi H i) |
| (hmL : (C0 : ℝ)/p ≤ m) (hmU : m < (C0 : ℝ)/p+(H : ℝ)) : |
| m ∈ Set.Ico (coordinateLower C0 R xi H i) (coordinateUpper C0 R xi H i) := by |
| have hL : 0 < blockLeft C0 R xi H i := |
| ErdosTagSubbins.left_pos hR hxi (blockCount_pos C0 R xi H) |
| have hb := ErdosCommonParameterInterval.div_between_endpoints (C0 : ℝ) hL hpL hpU |
| refine ⟨hb.1.trans hmL,?_⟩ |
| dsimp only [coordinateUpper] |
| linarith [hb.2] |
|
|
| theorem block_coordinate_width (C0 : ℤ) (R xi : ℝ) (H i : ℕ) |
| (hR : 0 < R) (hxi : 0 < xi) (hH : 0 < H) : |
| coordinateUpper C0 R xi H i-coordinateLower C0 R xi H i ≤ 2*(H : ℝ) := by |
| have hv := block_reciprocal_variation C0 R xi H i hR hxi hH |
| have he (x y : ℝ) : max x y-min x y=|x-y| := by |
| rw [max_sub_min_eq_abs,abs_sub_comm] |
| dsimp [coordinateUpper,coordinateLower] |
| rw [show max ((C0 : ℝ)/blockLeft C0 R xi H i) ((C0 : ℝ)/blockRight C0 R xi H i)+(H : ℝ)- |
| min ((C0 : ℝ)/blockLeft C0 R xi H i) ((C0 : ℝ)/blockRight C0 R xi H i) = |
| (max ((C0 : ℝ)/blockLeft C0 R xi H i) ((C0 : ℝ)/blockRight C0 R xi H i)- |
| min ((C0 : ℝ)/blockLeft C0 R xi H i) ((C0 : ℝ)/blockRight C0 R xi H i))+(H : ℝ) by ring, |
| he] |
| linarith |
|
|
| end ErdosLargeHeightBlocks |
|
|
|
|
|
|
| namespace ErdosStoppedArithmetic |
| open ErdosCommonMInterval ErdosAlignedProgression |
|
|
| theorem common_slice_mem_parameter (Y q p : ℕ) (r : ℚ) (R T : ℝ) (m : ℤ) |
| (hq : 0 < q) (hR : 0 < R) (hRp : R ≤ (p : ℝ)) (hpT : (p : ℝ) ≤ T) |
| (hm : (m : ℝ) ∈ interval r.num r.den Y q R T) |
| (hdiv : (r.den : ℤ) ∣ r.num+((p*q : ℕ) : ℤ)*m) : |
| m ∈ parameterInterval Y r (p*q) := by |
| have hp : 0 < p := by exact_mod_cast hR.trans_le hRp |
| have hdiv' : (r.den : ℤ) ∣ r.num+(p : ℤ)*q*m := by |
| simpa only [Nat.cast_mul] using hdiv |
| obtain ⟨n,hn,hY,he⟩ := integer_decode r.den_pos hq hR hRp hpT hm hdiv' |
| apply (mem_parameterInterval Y r (p*q) (Nat.mul_pos hp hq) m).mpr |
| have hD : (0 : ℤ) ≤ r.den := Int.natCast_nonneg _ |
| have hn' : (1 : ℤ) ≤ n := by exact_mod_cast hn |
| have hY' : (n : ℤ) ≤ Y := by exact_mod_cast hY |
| have hlo := mul_le_mul_of_nonneg_left hn' hD |
| have hhi := mul_le_mul_of_nonneg_left hY' hD |
| simp only [mul_one,he] at hlo hhi |
| simpa only [Nat.cast_mul] using And.intro hlo hhi |
|
|
| theorem common_slice_endpoint_height (w Cs P R T : ℝ) (A : ℤ) (D Y q : ℕ) |
| (hw : 1 ≤ w) (hP : 1 < P) (hDw : (D : ℝ) ≤ w^Cs) |
| (hY : 0 < Y) (hq : 0 < q) (hR : 0 < R) |
| (hA : |(A : ℝ)| ≤ (Y : ℝ)*w^(Cs+2)) |
| (hne : (interval A D Y q R T).Nonempty) : |
| max |lower A q R T| |upper A D Y q R T| ≤ |
| 2*w^(Cs+2)*P^(lengthExponent P Y R q) := by |
| have hY' : (0 : ℝ) < Y := by exact_mod_cast hY |
| have hq' : (0 : ℝ) < q := by exact_mod_cast hq |
| have hD' : (0 : ℝ) ≤ D := Nat.cast_nonneg _ |
| have hEnds : lower A q R T ≤ upper A D Y q R T := Set.nonempty_Icc.mp hne |
| have hLo := closed_height hD' hY' hq' hR hA |
| (show lower A q R T ∈ interval A D Y q R T from ⟨le_rfl,hEnds⟩) |
| have hHi := closed_height hD' hY' hq' hR hA |
| (show upper A D Y q R T ∈ interval A D Y q R T from ⟨hEnds,le_rfl⟩) |
| have hDC : (D : ℝ) ≤ w^(Cs+2) := hDw.trans |
| (Real.rpow_le_rpow_of_exponent_le hw (by linarith)) |
| have hJ : 0 ≤ referenceLength Y R q := (div_pos hY' (mul_pos hR hq')).le |
| have hBound := mul_le_mul_of_nonneg_right |
| (show (D : ℝ)+w^(Cs+2) ≤ 2*w^(Cs+2) by linarith) hJ |
| rw [reference_rpow hP hY' hR hq'] |
| exact (max_le hLo hHi).trans (by simpa only [mul_assoc] using hBound) |
|
|
| end ErdosStoppedArithmetic |
|
|
|
|
| end Erdos970 |
|
|
| end OAI |
|
|
