| import Mathlib |
|
|
| namespace OAI |
|
|
| /-! |
| # Finite pools of distinct primes from central binomial estimates |
| -/ |
|
|
| namespace EditPrimes |
| open scoped BigOperators |
| open Nat Finset |
|
|
| def pool (n : ℕ) : Finset ℕ := (Finset.Ioc n (2*n)).filter Nat.Prime |
|
|
| lemma centralBinom_le_with_primes (n : ℕ) (hn : 2 < n) : |
| n.centralBinom ≤ (2*n)^(Nat.sqrt (2*n)) * 4^(2*n/3) * (2*n)^(pool n).card := by |
| have hpos : 0 < n := by omega |
| have h2pos : 1 ≤ 2*n := by omega |
| let f (p : ℕ) := p ^ n.centralBinom.factorization p |
| let S := (Finset.range (2*n+1)).filter Nat.Prime |
| let T := (Finset.range (2*n/3+1)).filter Nat.Prime |
| have heq : n.centralBinom = ∏ p ∈ S, f p := by |
| rw [← n.prod_pow_factorization_centralBinom] |
| dsimp [S,f] |
| symm |
| apply Finset.prod_filter_of_ne |
| intro p _ h |
| contrapose h |
| rw [Nat.factorization_eq_zero_of_not_prime _ h,pow_zero] |
| have hlow : ∏ p ∈ S.filter (· ≤ n), f p = ∏ p ∈ T, f p := by |
| symm |
| apply Finset.prod_subset |
| · intro p hp |
| obtain ⟨hp,hprime⟩ := Finset.mem_filter.mp hp |
| have hb := Finset.mem_range.mp hp |
| have hm : 2*n/3 ≤ n := by omega |
| exact Finset.mem_filter.mpr ⟨Finset.mem_filter.mpr ⟨Finset.mem_range.mpr (by omega),hprime⟩,by omega⟩ |
| · intro p hp hpT |
| obtain ⟨hp,hpn⟩ := Finset.mem_filter.mp hp |
| obtain ⟨_,hprime⟩ := Finset.mem_filter.mp hp |
| have hb : 2*n/3 < p := by |
| by_contra h |
| apply hpT |
| exact Finset.mem_filter.mpr ⟨Finset.mem_range.mpr (by omega),hprime⟩ |
| have hb' : 2*n < 3*p := by omega |
| dsimp [f] |
| rw [Nat.factorization_centralBinom_of_two_mul_self_lt_three_mul hn hpn hb',pow_zero] |
| have hhigh : S.filter (fun p => ¬p ≤ n) = pool n := by |
| ext p |
| simp only [S,pool,Finset.mem_filter,Finset.mem_range,Finset.mem_Ioc,Nat.lt_succ_iff,not_le] |
| tauto |
| have hT : ∏ p ∈ T, f p ≤ (2*n)^Nat.sqrt (2*n) * 4^(2*n/3) := by |
| rw [←Finset.prod_filter_mul_prod_filter_not T (· ≤ Nat.sqrt (2*n))] |
| apply mul_le_mul' |
| · refine (Finset.prod_le_prod (fun p _ => (show f p ≤ 2*n from |
| Nat.pow_factorization_choose_le (by omega)))).trans ?_ |
| rw [Finset.prod_const] |
| apply Nat.pow_le_pow_right h2pos |
| have hc : (Finset.Icc 1 (Nat.sqrt (2*n))).card = Nat.sqrt (2*n) := by |
| rw [Nat.card_Icc,Nat.add_sub_cancel] |
| apply (Finset.card_le_card ?_).trans hc.le |
| intro p hp |
| obtain ⟨hp,hs⟩ := Finset.mem_filter.mp hp |
| exact Finset.mem_Icc.mpr ⟨(Finset.mem_filter.mp hp).2.one_lt.le,hs⟩ |
| · refine le_trans ?_ (primorial_le_four_pow (2*n/3)) |
| refine (Finset.prod_le_prod (fun p hp => (show f p ≤ p from ?_))).trans ?_ |
| · obtain ⟨hp,hs⟩ := Finset.mem_filter.mp hp |
| dsimp [f] |
| refine (Nat.pow_le_pow_right (Finset.mem_filter.mp hp).2.one_lt.le ?_).trans (pow_one p).le |
| exact Nat.factorization_choose_le_one (Nat.sqrt_lt'.mp (not_le.mp hs)) |
| · apply Finset.prod_le_prod_of_subset_of_one_le (Finset.filter_subset _ _) |
| intro p hp _ |
| exact (Finset.mem_filter.mp hp).2.one_lt.le |
| rw [heq,←Finset.prod_filter_mul_prod_filter_not S (· ≤ n),hlow,hhigh] |
| apply Nat.mul_le_mul hT |
| calc |
| ∏ p ∈ pool n, f p ≤ ∏ _p ∈ pool n, (2*n) := |
| Finset.prod_le_prod (fun _ _ => Nat.pow_factorization_choose_le (by omega)) |
| _ = (2*n)^(pool n).card := Finset.prod_const _ |
|
|
| end EditPrimes |
|
|
| namespace EditPrimes |
| open scoped BigOperators |
| open Nat Finset Filter |
|
|
| lemma binomial_log_bound {n : ℕ} (hn : 4 ≤ n) : |
| (n : ℝ) * Real.log 4 < Real.log (n : ℝ) + |
| ((Nat.sqrt (2*n) : ℝ) + (pool n).card) * Real.log (2*(n : ℝ)) + |
| (2*(n : ℝ)/3) * Real.log 4 := by |
| have hb := Nat.four_pow_lt_mul_centralBinom n (by omega) |
| have hu := centralBinom_le_with_primes n (by omega) |
| have hr : (4 : ℝ)^n < (n : ℝ) * |
| ((2*(n : ℝ))^(Nat.sqrt (2*n)) * 4^(2*n/3) * (2*(n : ℝ))^(pool n).card) := by |
| exact_mod_cast hb.trans_le (Nat.mul_le_mul_left n hu) |
| have hnR : 0 < (n : ℝ) := by exact_mod_cast (show 0<n by omega) |
| have h2n : 0 < 2*(n : ℝ) := by positivity |
| have hl := Real.log_lt_log (by positivity : 0 < (4 : ℝ)^n) hr |
| rw [Real.log_mul hnR.ne' (by positivity), |
| Real.log_mul (by positivity) (by positivity), |
| Real.log_mul (by positivity) (by positivity)] at hl |
| simp only [Real.log_pow] at hl |
| have hf : ((2*n/3 : ℕ) : ℝ) ≤ 2*(n : ℝ)/3 := by |
| have h := (Nat.cast_div_le (m := 2*n) (n := 3) : ((2*n/3 : ℕ) : ℝ) ≤ ((2*n : ℕ) : ℝ)/(3 : ℝ)) |
| simpa only [Nat.cast_mul,Nat.cast_ofNat] using h |
| have hlog : 0 ≤ Real.log (4 : ℝ) := Real.log_nonneg (by norm_num) |
| nlinarith [mul_le_mul_of_nonneg_right hf hlog] |
|
|
| lemma pool_square_large {b : ℕ} (hb : 2 ≤ b) |
| (hlog : Real.log (b : ℝ) ≤ (Real.log 4 / 60) * (b : ℝ)) : b ≤ (pool (b^2)).card := by |
| by_contra hcard |
| have hcard : (pool (b^2)).card ≤ b := by omega |
| have h := binomial_log_bound (show 4 ≤ b^2 by nlinarith) |
| have bpos : (0 : ℝ) < b := by exact_mod_cast (show 0 < b by omega) |
| have hbR : (2 : ℝ) ≤ b := by exact_mod_cast hb |
| have hs : Nat.sqrt (2*(b^2)) ≤ 2*b := by |
| have hsq := Nat.sqrt_le (2*b^2) |
| nlinarith |
| have hsR : (Nat.sqrt (2*b^2) : ℝ) ≤ 2*(b : ℝ) := by exact_mod_cast hs |
| have hcR : ((pool (b^2)).card : ℝ) ≤ b := by exact_mod_cast hcard |
| have hlogb : 0 ≤ Real.log (b : ℝ) := Real.log_nonneg (by linarith) |
| have hlog2 : Real.log (2 : ℝ) ≤ Real.log (b : ℝ) := Real.log_le_log (by norm_num) hbR |
| have hlog4 : 0 < Real.log (4 : ℝ) := Real.log_pos (by norm_num) |
| have hlogn : Real.log ((b^2 : ℕ) : ℝ) = 2 * Real.log (b : ℝ) := by |
| simp only [Nat.cast_pow,Real.log_pow,Nat.cast_ofNat] |
| have hlog2n : Real.log (2 * ((b^2 : ℕ) : ℝ)) ≤ 3 * Real.log (b : ℝ) := by |
| rw [Real.log_mul (by norm_num) (by positivity),hlogn] |
| linarith |
| have hlog2np : 0 ≤ Real.log (2*((b^2 : ℕ) : ℝ)) := Real.log_nonneg (by push_cast; nlinarith) |
| have hterm : ((Nat.sqrt (2*b^2) : ℝ) + (pool (b^2)).card) * Real.log (2*((b^2 : ℕ) : ℝ)) ≤ |
| 9 * (b : ℝ) * Real.log (b : ℝ) := by |
| calc |
| _ ≤ (3 * (b : ℝ)) * (3*Real.log (b : ℝ)) := by gcongr; linarith |
| _ = _ := by ring |
| rw [hlogn] at h |
| push_cast at h hterm |
| have hsmall : 2*Real.log (b : ℝ) + 9*(b : ℝ)*Real.log (b : ℝ) ≤ 10*(b : ℝ)*Real.log (b : ℝ) := by |
| nlinarith |
| have hbound := mul_le_mul_of_nonneg_left hlog (show 0 ≤ 10*(b : ℝ) by positivity) |
| nlinarith [sq_pos_of_pos bpos] |
|
|
| theorem eventually_pool_square : ∀ᶠ b : ℕ in Filter.atTop, b ≤ (pool (b^2)).card := by |
| have hε : 0 < Real.log (4 : ℝ) / 60 := by positivity |
| have hh := Real.isLittleO_log_id_atTop.def hε |
| have hn : Filter.Tendsto (fun b : ℕ => (b : ℝ)) Filter.atTop Filter.atTop := |
| tendsto_natCast_atTop_atTop |
| filter_upwards [hn.eventually hh,Filter.eventually_ge_atTop (2 : ℕ)] with b hlog hb |
| apply pool_square_large hb |
| have hbn : (1 : ℝ) ≤ b := by exact_mod_cast (show 1 ≤ b by omega) |
| have hlogb : 0 ≤ Real.log (b : ℝ) := Real.log_nonneg hbn |
| simpa only [Function.id_def,Real.norm_eq_abs,abs_of_nonneg hlogb, |
| abs_of_nonneg (Nat.cast_nonneg b : (0 : ℝ) ≤ b)] using hlog |
|
|
| theorem primes_of_pool {b : ℕ} (hb : b ≤ (pool (b^2)).card) : |
| ∃ p : Fin b → ℕ, Function.Injective p ∧ |
| (∀ j, (p j).Prime) ∧ (∀ j, b^2 ≤ p j) ∧ (∀ j, p j ≤ 2*b^2) := by |
| classical |
| let e : Fin b ↪ (pool (b^2)) := Classical.choice |
| (Function.Embedding.nonempty_of_card_le (by simpa only [Fintype.card_fin,Fintype.card_coe] using hb)) |
| refine ⟨fun j => (e j).val, ?_, ?_, ?_, ?_⟩ |
| · intro i j hij |
| exact e.injective (Subtype.ext hij) |
| · intro j |
| exact (Finset.mem_filter.mp (e j).property).2 |
| · intro j |
| exact (Finset.mem_Ioc.mp (Finset.mem_filter.mp (e j).property).1).1.le |
| · intro j |
| exact (Finset.mem_Ioc.mp (Finset.mem_filter.mp (e j).property).1).2 |
|
|
| end EditPrimes |
|
|
| end OAI |
|
|
