| import OAI.NumberTheory.GaussianMoat.AccurateScales |
|
|
| namespace OAI |
|
|
| universe uIota |
|
|
| namespace GaussianMoat |
|
|
| section |
| open scoped BigOperators Classical |
| open Filter |
|
|
| noncomputable def topParameter : ℝ := 1/1000000 |
| def topIterations : ℕ := 20 |
| noncomputable def topCoefficient (a : ℝ) : ℝ := (topParameter^2)^topIterations*a |
|
|
| lemma topParameter_pos : 0<topParameter := by norm_num [topParameter] |
| lemma topParameter_small : topParameter≤1/200 := by norm_num [topParameter] |
| lemma topCoefficient_pos {a : ℝ} (ha : 0<a) : 0<topCoefficient a := by |
| unfold topCoefficient; exact mul_pos (pow_pos (sq_pos_of_pos topParameter_pos) _) ha |
| lemma top_deficit : (1/2:ℝ)^topIterations+90*topParameter≤1/10000 := by |
| norm_num [topParameter,topIterations] |
|
|
| theorem eventually_top_band {D a δ : ℝ} (hD : 1≤D) (ha : 0<a) |
| (haδ : 2*a≤δ) : |
| ∀ᶠ x : ℝ in atTop, ∀ (s : SplitSieve) (pre post : List ℕ), |
| s.primes.Nonempty → |
| (∀ p∈s.primes, Real.exp x≤(p:ℝ) ∧ (p:ℝ)≤2*Real.exp x) → |
| δ*Real.exp x/Real.log (2*Real.exp x)≤ s.primes.card → |
| (∀ n∈post, (n:ℝ)≤Real.exp (topParameter*topCoefficient a*Real.exp x)) → |
| (post.length+2:ℝ)≤Real.exp (topParameter*topCoefficient a*Real.exp x) → |
| Nonempty (EntropyBand s D |
| (pre++List.ofFn (fun i : Fin topIterations => |
| bandLength topParameter (a*Real.exp x) i.val)++post) |
| 0 (bandSize s topParameter (a*Real.exp x) topIterations) (1/10000)) ∧ |
| topCoefficient a*Real.exp x/(4*x)≤ |
| (bandSize s topParameter (a*Real.exp x) topIterations:ℝ) := by |
| have hc := topCoefficient_pos ha |
| have hlarge := eventually_poly_le_exp (2*bandConstant D) |
| (a := topParameter^5*topCoefficient a) (mul_pos (pow_pos topParameter_pos _) hc) 1 |
| filter_upwards [hlarge,eventually_ge_atTop (2:ℝ)] with x hlarge hx |
| intro s pre post hne hp hdense hpost hlen |
| have hT2 : 2≤Real.exp x := by linarith only [Real.add_one_le_exp x,hx] |
| have hm := s.meanLog_bounds hne (Real.exp_pos x) hp |
| rw [Real.log_exp] at hm |
| have hmean : 1≤ s.meanLog := by linarith only [hm.1,hx] |
| have hmean0 : 0< s.meanLog := by linarith only [hmean] |
| have hlog2 : Real.log 2≤x := by |
| have hh := Real.log_le_sub_one_of_pos (by norm_num : (0:ℝ)<2) |
| linarith only [hh,hx] |
| have hmean' : s.meanLog≤2*x := by |
| rw [Real.log_mul (by norm_num) (Real.exp_ne_zero _),Real.log_exp] at hm |
| linarith only [hm.2,hlog2] |
| have hscale : bandScale topParameter (a*Real.exp x) topIterations=topCoefficient a*Real.exp x := by |
| unfold bandScale topCoefficient; ring |
| have hmargin : bandConstant D*s.meanLog≤topParameter^5* |
| bandScale topParameter (a*Real.exp x) topIterations := by |
| have hh := mul_le_mul_of_nonneg_left hmean' (bandConstant_pos D).le |
| rw [hscale] |
| simp only [pow_one] at hlarge |
| nlinarith only [hh,hlarge] |
| have hcap := dense_sieve_cap s hne hT2 hp hdense |
| (by nlinarith only [haδ,Real.exp_pos x] : 2*(a*Real.exp x)≤δ*Real.exp x) |
| have hband := entropyBand_from_margin s pre post 0 topIterations hD topParameter_pos |
| topParameter_small (mul_pos ha (Real.exp_pos _)) hmean hmargin hcap |
| (by simpa only [hscale,mul_assoc] using hpost) |
| (by simp only [Nat.cast_zero]; positivity) |
| (by simpa only [hscale,mul_assoc] using hlen) top_deficit |
| refine ⟨hband,?_⟩ |
| have hg5 : topParameter^5≤1 := pow_le_one₀ topParameter_pos.le (by norm_num [topParameter]) |
| have hVpos := bandScale_pos topParameter_pos (mul_pos ha (Real.exp_pos x)) topIterations |
| have hn := mul_le_mul_of_nonneg_right hg5 hVpos.le |
| have hC : 2≤bandConstant D := by |
| unfold bandConstant |
| linarith only [abs_nonneg (Real.log D),abs_nonneg (Real.log (max D ((latticeBall (4*D)).card:ℝ)))] |
| have hm2 := mul_le_mul_of_nonneg_right hC hmean0.le |
| have hV : 2*s.meanLog≤bandScale topParameter (a*Real.exp x) topIterations := by |
| nlinarith only [hmargin,hn,hm2] |
| have hh := bandSize_lower_of_scale hmean0 |
| (show 0<Real.log (Real.exp x) by rw [Real.log_exp]; linarith only [hx]) |
| (by simpa only [Real.log_exp] using hmean') hV (le_of_eq hscale.symm) |
| simpa only [Real.log_exp] using hh |
| |
| end |
| |
| open scoped BigOperators Classical |
| |
| noncomputable def topBlock (a : ℝ) (j : ℕ) : List ℕ := |
| List.ofFn (fun i : Fin topIterations => bandLength topParameter (a*(2:ℝ)^j) i.val) |
| |
| noncomputable def topBlocks (a : ℝ) (J : Finset ℕ) : List ℕ := |
| (J.sort (·≥·)).flatMap (topBlock a) |
| |
| noncomputable def accurateBlock (m : ℕ) (a : ℝ) : List ℕ := |
| List.ofFn (fun i : Fin (accurateIterations m) => |
| bandLength (accurateGrid m) (Real.exp (a*Real.exp m)) i.val) |
| |
| lemma topBlocks_length (a : ℝ) (J : Finset ℕ) : |
| (topBlocks a J).length=J.card*topIterations := by |
| unfold topBlocks |
| rw [List.length_flatMap] |
| simp only [topBlock,List.length_ofFn,List.map_const',List.sum_replicate,Finset.length_sort, |
| smul_eq_mul] |
|
|
| lemma topBlock_bound {a H : ℝ} (ha : 0≤a) (j : ℕ) |
| (h : topParameter*a*(2:ℝ)^j≤H) : |
| ∀ n∈topBlock a j, (n:ℝ)≤Real.exp H := by |
| intro n hn |
| obtain ⟨i,rfl⟩ := List.mem_ofFn.mp hn |
| exact (bandLength_le_exp_start topParameter_pos.le |
| (by norm_num [topParameter]) (mul_nonneg ha (by positivity)) i.val).trans |
| (Real.exp_le_exp.mpr (by simpa only [mul_assoc] using h)) |
|
|
| lemma accurateBlock_bound {a H : ℝ} {m : ℕ} (hg : accurateGrid m≤1) |
| (h : accurateGrid m*Real.exp (a*Real.exp m)≤H) : |
| ∀ n∈accurateBlock m a, (n:ℝ)≤Real.exp H := by |
| intro n hn |
| obtain ⟨i,rfl⟩ := List.mem_ofFn.mp hn |
| exact (bandLength_le_exp_start (accurateGrid_pos m).le hg (Real.exp_nonneg _) i.val).trans |
| (Real.exp_le_exp.mpr h) |
|
|
| lemma sorted_split {J : Finset ℕ} {j : ℕ} (hj : j∈J) : |
| ∃ pre post : List ℕ, J.sort (·≥·)=pre++j::post ∧ |
| (∀ i∈post, i∈J ∧ i < j) ∧ (∀ i∈pre, i∈J ∧ j < i) := by |
| have hm : j∈J.sort (·≥·) := (Finset.mem_sort (·≥·)).mpr hj |
| obtain ⟨pre,post,he⟩ := List.mem_iff_append.mp hm |
| have hp : (J.sort (·≥·)).Pairwise (·>·) := by |
| exact (Finset.sortedGT_sort J).pairwise |
| rw [he,List.pairwise_append,List.pairwise_cons] at hp |
| refine ⟨pre,post,he,?_,?_⟩ |
| · intro i hi |
| refine ⟨(Finset.mem_sort (·≥·)).mp ?_,hp.2.1.1 i hi⟩ |
| rw [he]; exact List.mem_append_right _ (List.mem_cons_of_mem _ hi) |
| · intro i hi |
| refine ⟨(Finset.mem_sort (·≥·)).mp ?_,hp.2.2 i hi j (List.mem_cons_self ..)⟩ |
| rw [he]; exact List.mem_append_left _ hi |
|
|
| lemma topBlocks_split {a : ℝ} {J : Finset ℕ} {j : ℕ} (hj : j∈J) : |
| ∃ pre post : List ℕ, topBlocks a J=pre++topBlock a j++post ∧ |
| post.length≤J.card*topIterations ∧ |
| (∀ n∈post, ∃ i∈J, i<j ∧ n∈topBlock a i) := by |
| obtain ⟨A,B,he,hB,_⟩ := sorted_split hj |
| refine ⟨A.flatMap (topBlock a),B.flatMap (topBlock a),?_,?_,?_⟩ |
| · simp only [topBlocks,he,List.flatMap_append,List.flatMap_cons,List.append_assoc] |
| · have hh : (B.flatMap (topBlock a)).length≤(topBlocks a J).length := by |
| simp only [topBlocks,he,List.flatMap_append,List.flatMap_cons,List.length_append] |
| omega |
| simpa only [topBlocks_length] using hh |
| · intro n hn |
| obtain ⟨i,hi,hn⟩ := List.mem_flatMap.mp hn |
| exact ⟨i,(hB i hi).1,(hB i hi).2,hn⟩ |
|
|
| noncomputable def windowBlocks (a : ℝ) (m : ℕ) (J : ℕ → Finset ℕ) (W : ℕ) : List ℕ := |
| ((List.range W).reverse).flatMap (fun w => |
| topBlocks a (J w)++accurateBlock m ((100:ℝ)^w/4)) |
|
|
| lemma windowBlocks_succ (a : ℝ) (m : ℕ) (J : ℕ → Finset ℕ) (W : ℕ) : |
| windowBlocks a m J (W+1)=topBlocks a (J W)++accurateBlock m ((100:ℝ)^W/4)++ |
| windowBlocks a m J W := by |
| simp only [windowBlocks,List.range_succ,List.reverse_append,List.reverse_singleton, |
| List.flatMap_append,List.flatMap_cons,List.flatMap_nil,List.append_nil,List.append_assoc] |
|
|
| lemma windowBlocks_split (a : ℝ) (m : ℕ) (J : ℕ → Finset ℕ) {W w : ℕ} (hw : w<W) : |
| ∃ pre, windowBlocks a m J W=pre++topBlocks a (J w)++ |
| accurateBlock m ((100:ℝ)^w/4)++windowBlocks a m J w := by |
| induction W with |
| | zero => omega |
| | succ W ih => |
| rw [windowBlocks_succ] |
| by_cases he : w=W |
| · subst w; exact ⟨[],by simp only [List.nil_append]⟩ |
| · obtain ⟨pre,hp⟩ := ih (by omega) |
| rw [hp] |
| exact ⟨topBlocks a (J W)++accurateBlock m ((100:ℝ)^W/4)++pre,by simp only [List.append_assoc]⟩ |
|
|
| lemma windowBlocks_mem (a : ℝ) (m : ℕ) (J : ℕ → Finset ℕ) {W n : ℕ} |
| (hn : n∈windowBlocks a m J W) : |
| ∃ w<W, n∈topBlocks a (J w) ∨ n∈accurateBlock m ((100:ℝ)^w/4) := by |
| obtain ⟨w,hw,hn⟩ := List.mem_flatMap.mp hn |
| exact ⟨w,List.mem_range.mp (List.mem_reverse.mp hw),List.mem_append.mp hn⟩ |
|
|
| theorem separated_power_sum (J : Finset ℕ) {K j : ℕ} (hK : 0<K) |
| (hsep : ∀ a∈J, ∀ b∈J, a<b → a+K≤b) |
| (hcap : ∀ a∈J, a+K≤j) : |
| (∑ a∈J, (2:ℝ)^a)≤(2:ℝ)^j/((2:ℝ)^K-1) := by |
| have hden : 0<(2:ℝ)^K-1 := by |
| have hh := one_lt_pow₀ (by norm_num : (1:ℝ)<2) (by omega : K≠0) |
| linarith only [hh] |
| induction J using Finset.induction_on_max generalizing j with |
| | empty => simp only [Finset.sum_empty]; positivity |
| | @insert a J hmax ih => |
| have ha : a∉J := fun h => (lt_irrefl a) (hmax a h) |
| have hci : ∀ b∈J, b+K≤a := by |
| intro b hb |
| exact hsep b (Finset.mem_insert_of_mem hb) a (Finset.mem_insert_self ..) |
| (hmax b hb) |
| have hi := ih (fun b hb c hc hbc => hsep b (Finset.mem_insert_of_mem hb) |
| c (Finset.mem_insert_of_mem hc) hbc) hci |
| rw [Finset.sum_insert ha] |
| have hp := pow_le_pow_right₀ (by norm_num : (1:ℝ)≤2) (hcap a (Finset.mem_insert_self ..)) |
| have hd := (div_le_div_iff_of_pos_right hden).mpr hp |
| rw [pow_add] at hd |
| have he : (2:ℝ)^a+(2:ℝ)^a/((2:ℝ)^K-1)=(2:ℝ)^a*2^K/(2^K-1) := by |
| field_simp; ring |
| exact (add_le_add (le_refl ((2:ℝ)^a)) hi).trans (he ▸ hd) |
|
|
| lemma residueWeight_union_le (F G : Finset GaussianInt) : |
| residueWeight (F∪G)≤residueWeight F+residueWeight G := by |
| classical |
| have hh := Finset.sum_union_inter (s₁ := F) (s₂ := G) (f := fun f : GaussianInt => Real.log f.norm.natAbs) |
| change residueWeight (F∪G)+residueWeight (F∩G)=residueWeight F+residueWeight G at hh |
| linarith only [hh,residueWeight_nonneg (F∩G)] |
|
|
| lemma residueWeight_biUnion_le {ι : Type uIota} (J : Finset ι) (F : ι → Finset GaussianInt) : |
| residueWeight (J.biUnion F)≤∑ j∈J, residueWeight (F j) := by |
| induction J using Finset.induction_on with |
| | empty => simp [residueWeight] |
| | @insert j J hj ih => |
| rw [Finset.biUnion_insert,Finset.sum_insert hj] |
| exact (residueWeight_union_le _ _).trans (add_le_add (le_refl _) ih) |
|
|
| lemma separated_factor_cost (J : Finset ℕ) {K j : ℕ} (hK : 0<K) |
| (hsep : ∀ a∈J, ∀ b∈J, a<b → a+K≤b) |
| (hcap : ∀ a∈J, a+K≤j) : |
| residueWeight (J.biUnion (fun a => (dyadicSieve a).availableFactors))≤ |
| (4*Real.log 4/((2:ℝ)^K-1))*(2:ℝ)^j := by |
| have hsum := Finset.sum_le_sum (fun a (_ : a∈J) => dyadicSieve_available_weight a) |
| rw [←Finset.mul_sum] at hsum |
| have hh := mul_le_mul_of_nonneg_left (separated_power_sum J hK hsep hcap) |
| (show 0≤4*Real.log 4 by positivity) |
| have ht := (residueWeight_biUnion_le J (fun a => (dyadicSieve a).availableFactors)).trans (hsum.trans hh) |
| calc |
| _ ≤ 4*Real.log 4*((2:ℝ)^j/(2^K-1)) := ht |
| _ = _ := by ring |
|
|
| open scoped BigOperators Classical |
| open Filter |
|
|
| lemma log_two_lower : (1/2:ℝ)≤Real.log 2 := by |
| have hh := Real.one_sub_inv_le_log_of_pos (by norm_num : (0:ℝ)<2) |
| norm_num at hh |
| exact hh |
|
|
| lemma narrow_bins_card {X : ℝ} (hX : 2≤X) (J : Finset ℕ) |
| (hJ : ∀ j∈J, (j:ℝ)*Real.log 2≤21/20*X) : |
| (J.card:ℝ)≤3*X := by |
| have hj : ∀ j∈J, (j:ℝ)≤21/10*X := by |
| intro j hj |
| have hh := mul_le_mul_of_nonneg_left log_two_lower (Nat.cast_nonneg j) |
| linarith only [hh,hJ j hj] |
| have hs : J⊆Finset.range (⌊21/10*X⌋₊+1) := by |
| intro j hj' |
| apply Finset.mem_range.mpr |
| exact Nat.lt_succ_of_le ((Nat.le_floor_iff (by positivity)).mpr (hj j hj')) |
| have hc : (J.card:ℝ)≤(⌊21/10*X⌋₊:ℝ)+1 := by |
| exact_mod_cast (Finset.card_le_card hs).trans_eq (Finset.card_range _) |
| have hf := Nat.floor_le (show 0≤21/10*X by linarith only [hX]) |
| linarith only [hc,hf,hX] |
|
|
| lemma topBlock_separated {a : ℝ} (ha : 0<a) {i j K : ℕ} |
| (hgap : a≤(2:ℝ)^K*topCoefficient a) (hij : i+K≤j) : |
| ∀ n∈topBlock a i, (n:ℝ)≤Real.exp (topParameter*topCoefficient a*(2:ℝ)^j) := by |
| apply topBlock_bound ha.le |
| have hh := mul_le_mul_of_nonneg_left hgap (show 0≤(2:ℝ)^i by positivity) |
| rw [←mul_assoc,←pow_add] at hh |
| have hp : (2:ℝ)^(i+K)≤(2:ℝ)^j := pow_le_pow_right₀ (by norm_num) hij |
| have hp' := mul_le_mul_of_nonneg_right hp (topCoefficient_pos ha).le |
| have hg := mul_le_mul_of_nonneg_left (hh.trans hp') topParameter_pos.le |
| nlinarith only [hg] |
|
|
| theorem eventually_window_top {D a δ : ℝ} {K : ℕ} |
| (hD : 1≤D) (ha : 0<a) (haδ : 2*a≤δ) |
| (hgap : a≤(2:ℝ)^K*topCoefficient a) : |
| ∀ᶠ X : ℝ in atTop, ∀ (J : Finset ℕ) (initial : List ℕ), |
| (∀ i∈J, ∀ j∈J, i<j → i+K≤j) → |
| (∀ j∈J, X≤j*Real.log 2 ∧ j*Real.log 2≤21/20*X ∧ |
| δ*(2:ℝ)^j/Real.log ((2:ℝ)^(j+1))≤(PrimeLogMass.dyadicBatch j).card) → |
| ∀ j∈J, Nonempty (EntropyBand (dyadicSieve j) D (initial++topBlocks a J) |
| 0 (bandSize (dyadicSieve j) topParameter (a*(2:ℝ)^j) topIterations) (1/10000)) ∧ |
| topCoefficient a*(2:ℝ)^j/(4*Real.log ((2:ℝ)^j))≤ |
| (bandSize (dyadicSieve j) topParameter (a*(2:ℝ)^j) topIterations:ℝ) := by |
| have hδ : 0<δ := by linarith only [ha,haδ] |
| have htop := eventually_top_band hD ha haδ |
| have hlen := eventually_poly_le_exp (100:ℝ) |
| (a := topParameter*topCoefficient a) (mul_pos topParameter_pos (topCoefficient_pos ha)) 1 |
| obtain ⟨x0,h0⟩ := eventually_atTop.mp (htop.and hlen) |
| filter_upwards [eventually_ge_atTop (max x0 2)] with X hX |
| intro J initial hsep hJ j hj |
| have hX2 : 2≤X := (le_max_right _ _).trans hX |
| have hX0 : x0≤X := (le_max_left _ _).trans hX |
| have hlog := (hJ j hj).1 |
| have hlog' := (hJ j hj).2.1 |
| obtain ⟨hband,hlen⟩ := h0 (j*Real.log 2) (hX0.trans hlog) |
| have hn : (dyadicSieve j).primes.Nonempty := by |
| apply Finset.card_pos.mp |
| have hlogp : 0<Real.log ((2:ℝ)^(j+1)) := by |
| rw [Real.log_pow] |
| positivity |
| have hh := (hJ j hj).2.2 |
| have hp : 0<δ*(2:ℝ)^j/Real.log ((2:ℝ)^(j+1)) := div_pos (by positivity) hlogp |
| have hc : (0:ℝ)<(PrimeLogMass.dyadicBatch j).card := hp.trans_le hh |
| exact_mod_cast hc |
| obtain ⟨pre,post,he,hpl,hpm⟩ := topBlocks_split (a := a) hj |
| have hT : Real.exp (j*Real.log 2)=(2:ℝ)^j := by rw [Real.exp_nat_mul,Real.exp_log (by norm_num : (0:ℝ)<2)] |
| have hcard := narrow_bins_card hX2 J (fun i hi => (hJ i hi).2.1) |
| have hlen' : (post.length+2:ℝ)≤Real.exp (topParameter*topCoefficient a*(2:ℝ)^j) := by |
| have hp : (post.length:ℝ)≤(J.card:ℝ)*topIterations := by exact_mod_cast hpl |
| simp only [pow_one,hT] at hlen |
| have he := Real.add_one_le_exp (topParameter*topCoefficient a*(2:ℝ)^j) |
| norm_num only [topIterations,Nat.cast_ofNat] at hp |
| nlinarith only [hp,hcard,hlen,he,hlog,hX2] |
| have hprime : ∀ p∈(dyadicSieve j).primes, Real.exp (j*Real.log 2)≤(p:ℝ) ∧ |
| (p:ℝ)≤2*Real.exp (j*Real.log 2) := by |
| intro p hp |
| rw [hT] |
| have hh := (PrimeLogMass.mem_dyadicBatch j p).mp hp |
| constructor |
| · exact_mod_cast hh.1 |
| · have hh' : p≤2^(j+1) := hh.2.1.le |
| rw [pow_succ] at hh' |
| exact_mod_cast (by simpa only [mul_comm] using hh' : p≤2*2^j) |
| have hdense : δ*Real.exp (j*Real.log 2)/Real.log (2*Real.exp (j*Real.log 2))≤ |
| (dyadicSieve j).primes.card := by |
| change δ*Real.exp (j*Real.log 2)/Real.log (2*Real.exp (j*Real.log 2))≤ |
| (PrimeLogMass.dyadicBatch j).card |
| simpa only [hT,pow_succ,mul_comm] using (hJ j hj).2.2 |
| have hpst : ∀ n∈post, (n:ℝ)≤Real.exp (topParameter*topCoefficient a*Real.exp (j*Real.log 2)) := by |
| intro n hnp |
| obtain ⟨i,hi,hij,hni⟩ := hpm n hnp |
| rw [hT] |
| exact topBlock_separated ha hgap (hsep i hi j hj hij) n hni |
| obtain ⟨hb,hbsize⟩ := hband (dyadicSieve j) (initial++pre) post hn hprime hdense hpst |
| (by simpa only [hT] using hlen') |
| refine ⟨?_,?_⟩ |
| · simpa only [hT,he,topBlock,List.append_assoc] using hb |
| · simpa only [hT,Real.log_pow] using hbsize |
|
|
| end GaussianMoat |
|
|
| end OAI |
|
|
