| import OAI.NumberTheory.GaussianMoat.Information |
|
|
| namespace OAI |
|
|
| universe uOmega uAlpha |
|
|
| namespace GaussianMoat |
| open scoped BigOperators Classical |
|
|
| structure EnrichmentMargins (s : SplitSieve) (D g : ℝ) (n b q : ℕ) : Prop where |
| length_pos : 1 ≤ n |
| output_pos : 0 < b |
| decreases : b < q |
| input_cap : q ≤ s.primes.card |
| ratio : (b:ℝ) ≤ g*q |
| log_pos : 0 < Real.log n-Real.log 18 |
| rounding : s.meanLog ≤ g*(Real.log n-Real.log 18) |
| large : 5120*s.meanLog ≤ g^4*(Real.log n-Real.log 18) |
| output_cost : (b:ℝ)*s.meanLog ≤ g*(Real.log n-Real.log 18) |
| lattice_cost : Real.log 16+Real.log (max D ((latticeBall (4*D)).card:ℝ)) ≤ |
| g*(Real.log n-Real.log 18) |
| geometry_cap : 2*(2*Real.log n+Real.log 16+2*Real.log D) ≤ s.primes.card*s.meanLog |
| displacement_cost : 2*(Real.log 36+2*Real.log (D*n)) ≤ 8*g*q*s.meanLog |
|
|
| theorem TimeLaw.geometric_step_deficit (P : TimeLaw) (s : SplitSieve) |
| (hne : s.primes.Nonempty) (z : ℕ → GaussianInt) (hinj : Function.Injective z) |
| {D T g e : ℝ} (hD : 1 ≤ D) (hT : 5 ≤ T) |
| (hstep : ∀ t, dist (z t:ℂ) (z (t+1):ℂ) ≤ D) |
| (hpT : ∀ p ∈ s.primes, T ≤ (p:ℝ) ∧ (p:ℝ) ≤ 2*T) |
| (hg : 0 < g) (hg1 : g ≤ 1/100) (hL : 1 ≤ s.meanLog) {n b q : ℕ} |
| (hm : EnrichmentMargins s D g n b q) |
| (hE : (1-e)*(q:ℝ)*s.meanLog ≤ s.pointEntropy P.law (fun a => z a.val) q) : |
| (1-e/2-20*g)*(b:ℝ)*s.meanLog ≤ |
| s.pointEntropy (P.step z n).law (fun a => z a.val) b := by |
| apply P.step_deficit s z hD hstep hm.length_pos hm.output_pos hm.decreases |
| hm.input_cap hg.le hg1 (by linarith only [hL]) hm.ratio ?_ hE hm.displacement_cost |
| intro a |
| obtain ⟨hb,hh⟩ := s.walk_fresh_lower hne (fun t => z (a.val+t)) hm.length_pos |
| (shifted_walk_injective z hinj a.val) hD hT |
| (fun t _ => by simpa only [Nat.add_assoc] using hstep (a.val+t)) hpT hg hg1 hL |
| hm.log_pos hm.rounding hm.large hm.output_cost hm.lattice_cost hm.geometry_cap |
| exact hh |
|
|
| lemma SplitSieve.pointEntropy_nonneg {Ω : Type uOmega} [Fintype Ω] |
| (s : SplitSieve) (p : FinLaw Ω) (Z : Ω → GaussianInt) (b : ℕ) : |
| 0 ≤ s.pointEntropy p Z b := by |
| unfold pointEntropy FinLaw.signedEntropy |
| exact Finset.expect_nonneg (fun _ _ => p.orderedEntropy_nonneg _ _) |
|
|
| noncomputable def TimeLaw.run (P : TimeLaw) (z : ℕ → GaussianInt) (n : ℕ → ℕ) : ℕ → TimeLaw |
| | 0 => P |
| | j+1 => (P.run z n j).step z (n j) |
|
|
| @[simp] lemma TimeLaw.run_zero (P : TimeLaw) (z : ℕ → GaussianInt) (n : ℕ → ℕ) : |
| P.run z n 0=P := rfl |
| @[simp] lemma TimeLaw.run_succ (P : TimeLaw) (z : ℕ → GaussianInt) (n : ℕ → ℕ) (j : ℕ) : |
| P.run z n (j+1)=(P.run z n j).step z (n j) := rfl |
|
|
| theorem TimeLaw.run_entropy (P : TimeLaw) (s : SplitSieve) (hne : s.primes.Nonempty) |
| (z : ℕ → GaussianInt) (hinj : Function.Injective z) {D T g : ℝ} |
| (hD : 1 ≤ D) (hT : 5 ≤ T) (hstep : ∀ t, dist (z t:ℂ) (z (t+1):ℂ) ≤ D) |
| (hpT : ∀ p ∈ s.primes, T ≤ (p:ℝ) ∧ (p:ℝ) ≤ 2*T) |
| (hg : 0 < g) (hg1 : g ≤ 1/100) (hL : 1 ≤ s.meanLog) |
| (n q : ℕ → ℕ) (l : ℕ) (hm : ∀ j<l, EnrichmentMargins s D g (n j) (q (j+1)) (q j)) : |
| (1-(1/2:ℝ)^l-40*g)*(q l:ℝ)*s.meanLog ≤ |
| s.pointEntropy (P.run z n l).law (fun a => z a.val) (q l) := by |
| induction l with |
| | zero => |
| have hh := s.pointEntropy_nonneg P.law (fun a => z a.val) (q 0) |
| simp only [pow_zero,sub_self,zero_sub,TimeLaw.run_zero] |
| have hneg : -(40*g)*(q 0:ℝ)*s.meanLog ≤ 0 := by |
| apply mul_nonpos_of_nonpos_of_nonneg |
| · exact mul_nonpos_of_nonpos_of_nonneg (by linarith only [hg]) (Nat.cast_nonneg (q 0)) |
| · linarith only [hL] |
| exact hneg.trans hh |
| | succ l ih => |
| have hi := ih (fun j hj => hm j (by omega)) |
| have hh := (P.run z n l).geometric_step_deficit s hne z hinj hD hT hstep hpT |
| hg hg1 hL (hm l (by omega)) (e := (1/2:ℝ)^l+40*g) (by |
| convert hi using 1; ring) |
| rw [TimeLaw.run_succ] |
| convert hh using 1; ring |
|
|
| theorem TimeLaw.advance_entropy (P : TimeLaw) (K : ForwardKernel) (s : SplitSieve) |
| (z : ℕ → GaussianInt) {D : ℝ} (hD : 1 ≤ D) |
| (hstep : ∀ t, dist (z t:ℂ) (z (t+1):ℂ) ≤ D) (hK : 1 ≤ K.bound) (b : ℕ) : |
| s.pointEntropy P.law (fun a => z a.val) b - |
| (Real.log 36+2*Real.log (D*K.bound)) ≤ |
| s.pointEntropy (P.advance K).law (fun a => z a.val) b := by |
| let Q := P.law.joint (fun a => K.law a.val) |
| have hh := s.pointEntropy_shift Q (fun v => z v.1.val) |
| (fun v => z (v.1.val+v.2.val)) b |
| have hfst := s.pointEntropy_joint_fst P.law (fun a => K.law a.val) (fun a => z a.val) b |
| change s.pointEntropy Q (fun v => z v.1.val) b = _ at hfst |
| rw [hfst] at hh |
| have he : s.pointEntropy (P.advance K).law (fun a => z a.val) b = |
| s.pointEntropy Q (fun v => z (v.1.val+v.2.val)) b := by |
| unfold TimeLaw.advance |
| rw [s.pointEntropy_map] |
| rfl |
| rw [he] |
| have hc := P.advance_displacement_entropy K z hD hstep hK |
| linarith only [hh,hc] |
|
|
| theorem TimeLaw.run_future_entropy (P : TimeLaw) (K : ForwardKernel) (s : SplitSieve) |
| (hne : s.primes.Nonempty) (z : ℕ → GaussianInt) (hinj : Function.Injective z) |
| {D T g : ℝ} (hD : 1 ≤ D) (hT : 5 ≤ T) |
| (hstep : ∀ t, dist (z t:ℂ) (z (t+1):ℂ) ≤ D) |
| (hpT : ∀ p ∈ s.primes, T ≤ (p:ℝ) ∧ (p:ℝ) ≤ 2*T) |
| (hg : 0 < g) (hg1 : g ≤ 1/100) (hL : 1 ≤ s.meanLog) |
| (n q : ℕ → ℕ) (l : ℕ) (hm : ∀ j<l, EnrichmentMargins s D g (n j) (q (j+1)) (q j)) |
| (hK : 1 ≤ K.bound) {e : ℝ} |
| (hcost : Real.log 36+2*Real.log (D*K.bound) ≤ e*(q l:ℝ)*s.meanLog) : |
| (1-(1/2:ℝ)^l-40*g-e)*(q l:ℝ)*s.meanLog ≤ |
| s.pointEntropy ((P.run z n l).advance K).law (fun a => z a.val) (q l) := by |
| have h1 := P.run_entropy s hne z hinj hD hT hstep hpT hg hg1 hL n q l hm |
| have h2 := (P.run z n l).advance_entropy K s z hD hstep hK (q l) |
| nlinarith only [h1,h2,hcost] |
|
|
| noncomputable def TimeLaw.observe {α : Type uAlpha} [Fintype α] (P : TimeLaw) (f : ℕ → α) : FinLaw α := |
| P.law.map (fun t => f t.val) |
|
|
| lemma TimeLaw.ext_observe (P Q : TimeLaw) (hl : P.last=Q.last) |
| (h : ∀ {α : Type} [Fintype α] (f : ℕ → α), P.observe f=Q.observe f) : P=Q := by |
| cases P with | mk n p => |
| cases Q with | mk m q => |
| dsimp only at hl |
| subst m |
| congr 1 |
| let f : ℕ → Fin (n+1) := fun t => ⟨min t n,by omega⟩ |
| have hh := h f |
| have he : (fun t : Fin (n+1) => f t.val)=id := by |
| funext t |
| apply Fin.ext |
| exact Nat.min_eq_left (by omega) |
| unfold observe at hh |
| simpa only [he,FinLaw.map_id] using hh |
|
|
| lemma TimeLaw.observe_advance {α : Type uAlpha} [Fintype α] |
| (P : TimeLaw) (K : ForwardKernel) (f : ℕ → α) : |
| (P.advance K).observe f=P.law.mix (fun a => (K.law a.val).map (fun t => f (a.val+t.val))) := by |
| unfold observe advance |
| rw [FinLaw.map_comp,FinLaw.joint_observation_fun] |
| rfl |
|
|
| lemma ForwardKernel.then_observe {α : Type uAlpha} [Fintype α] |
| (K R : ForwardKernel) (a : ℕ) (f : ℕ → α) : |
| ((K.then R).law a).map (fun t => f (a+t.val))= |
| (K.law a).mix (fun t => (R.law (a+t.val)).map (fun u => f (a+t.val+u.val))) := by |
| unfold ForwardKernel.then |
| rw [FinLaw.map_comp,FinLaw.joint_observation_fun] |
| congr 1 |
| funext t |
| congr 1 |
| funext u |
| simp only [Function.comp_def,addOffsets,Nat.add_assoc] |
|
|
| lemma TimeLaw.advance_then (P : TimeLaw) (K R : ForwardKernel) : |
| P.advance (K.then R)=(P.advance K).advance R := by |
| apply TimeLaw.ext_observe |
| · exact (Nat.add_assoc _ _ _).symm |
| · intro α _ f |
| rw [TimeLaw.observe_advance,TimeLaw.observe_advance] |
| change P.law.mix _ = (((P.law.joint (fun a => K.law a.val)).map |
| (addOffsets P.last K.bound))).mix (fun a : Fin (P.last+K.bound+1) => |
| (R.law a.val).map (fun t => f (a.val+t.val))) |
| rw [FinLaw.mix_map_left] |
| have hj := FinLaw.joint_observation (P.law) (fun a => K.law a.val) |
| (fun a t => (a,t)) |
| clear hj |
| have hmix : ((P.law.joint (fun a => K.law a.val))).mix |
| (fun v => (R.law (v.1.val+v.2.val)).map (fun u => f (v.1.val+v.2.val+u.val))) = |
| P.law.mix (fun a => (K.law a.val).mix |
| (fun t => (R.law (a.val+t.val)).map (fun u => f (a.val+t.val+u.val)))) := by |
| ext x |
| simp only [FinLaw.mix_mass,FinLaw.joint_mass,Fintype.sum_prod_type,Finset.mul_sum,mul_assoc] |
| change P.law.mix _ = (P.law.joint (fun a => K.law a.val)).mix |
| (fun v => (R.law (v.1.val+v.2.val)).map (fun u => f (v.1.val+v.2.val+u.val))) |
| rw [hmix] |
| congr 1 |
| funext a |
| exact K.then_observe R a.val f |
|
|
| lemma TimeLaw.advance_common_cons (P : TimeLaw) (z : ℕ → GaussianInt) |
| (n : ℕ) (ns : List ℕ) (N : ℕ) : |
| P.advance (commonSchedule z (n::ns) N)=(P.step z n).advance (commonSchedule z ns N) := by |
| rw [commonSchedule_cons,TimeLaw.advance_then,TimeLaw.advance_difference] |
|
|
| lemma TimeLaw.advance_common_append (P : TimeLaw) (z : ℕ → GaussianInt) |
| (ns ms : List ℕ) (N : ℕ) : |
| P.advance (commonSchedule z (ns++ms) N)= |
| (ns.foldl (fun Q k => Q.step z k) P).advance (commonSchedule z ms N) := by |
| induction ns generalizing P with |
| | nil => rfl |
| | cons k ks hk => |
| rw [List.cons_append,TimeLaw.advance_common_cons,hk,List.foldl_cons] |
|
|
| lemma TimeLaw.foldl_ofFn (P : TimeLaw) (z : ℕ → GaussianInt) |
| (n : ℕ → ℕ) (l : ℕ) : |
| (List.ofFn (fun i : Fin l => n i.val)).foldl (fun Q k => Q.step z k) P=P.run z n l := by |
| induction l with |
| | zero => rfl |
| | succ l hl => |
| rw [List.ofFn_succ_last,List.foldl_append,List.foldl_cons,List.foldl_nil] |
| simp only [Fin.val_castSucc,Fin.val_last] |
| rw [hl,TimeLaw.run_succ] |
|
|
| lemma TimeLaw.run_common (P : TimeLaw) (z : ℕ → GaussianInt) |
| (n : ℕ → ℕ) (l N : ℕ) : |
| P.advance (commonSchedule z (List.ofFn (fun i : Fin l => n i.val)) N)= |
| (P.run z n l).advance (smoothingKernel N) := by |
| have h := P.advance_common_append z (List.ofFn (fun i : Fin l => n i.val)) [] N |
| simpa only [List.append_nil,TimeLaw.foldl_ofFn,commonSchedule,List.foldr_nil] using h |
|
|
| lemma log_floor_exp {x : ℝ} (hx : 2 ≤ x) : |
| 1 ≤ ⌊Real.exp x⌋₊ ∧ x-1 ≤ Real.log (⌊Real.exp x⌋₊:ℝ) ∧ |
| Real.log (⌊Real.exp x⌋₊:ℝ) ≤ x := by |
| have he : 2 ≤ Real.exp x := by linarith only [Real.add_one_le_exp x,hx] |
| have hn : 1 ≤ ⌊Real.exp x⌋₊ := Nat.floor_pos.mpr (by linarith only [he]) |
| have hnp : (0:ℝ)<⌊Real.exp x⌋₊ := by exact_mod_cast hn |
| have hlow : Real.exp x/2 ≤ (⌊Real.exp x⌋₊:ℝ) := by |
| have h := Nat.lt_floor_add_one (Real.exp x) |
| linarith only [he,h] |
| have hlo := Real.log_le_log (div_pos (Real.exp_pos x) (by norm_num : (0:ℝ)<2)) hlow |
| rw [Real.log_div (Real.exp_ne_zero x) (by norm_num : (2:ℝ)≠0),Real.log_exp] at hlo |
| have hl2 : Real.log 2 ≤ 1 := by |
| have h := Real.log_le_sub_one_of_pos (by norm_num : (0:ℝ)<2) |
| linarith only [h] |
| have hhi := Real.log_le_log hnp (Nat.floor_le (Real.exp_nonneg x)) |
| rw [Real.log_exp] at hhi |
| exact ⟨hn,by linarith only [hlo,hl2],hhi⟩ |
|
|
| theorem EnrichmentMargins.from_scale (s : SplitSieve) {D U g : ℝ} |
| (hD : 1 ≤ D) (hg : 0 < g) (hg1 : g ≤ 1/200) (hL : 1 ≤ s.meanLog) |
| (hU : 0 < U) |
| (hlog : 2*(1+Real.log 18) ≤ g*U) |
| (hlarge : 640*s.meanLog ≤ g^5*U) |
| (hsize : Real.log 16+Real.log (max D ((latticeBall (4*D)).card:ℝ)) ≤ g^2*U) |
| (hdisp : 4*Real.log D+2*Real.log 36 ≤ 4*g*U) |
| (hgeom : 2*Real.log 16+4*Real.log D ≤ U/4) |
| (hcap : ⌊U/s.meanLog⌋₊ ≤ s.primes.card) : |
| EnrichmentMargins s D (2*g) ⌊Real.exp (g*U)⌋₊ |
| ⌊g^2*U/s.meanLog⌋₊ ⌊U/s.meanLog⌋₊ := by |
| let L := s.meanLog |
| let n := ⌊Real.exp (g*U)⌋₊ |
| let q := ⌊U/L⌋₊ |
| let b := ⌊g^2*U/L⌋₊ |
| have hLp : 0 < L := by dsimp [L]; linarith only [hL] |
| have hg_le : g ≤ 1 := by linarith only [hg1] |
| have hg2 : g^2 ≤ 1 := pow_le_one₀ hg.le hg_le |
| have hg3 : g^3 ≤ 1 := pow_le_one₀ hg.le hg_le |
| have h52 : g^5*U ≤ g^2*U := by |
| have hpow : g^5=g^2*g^3 := by ring |
| rw [hpow] |
| nlinarith only [hg3,mul_nonneg (sq_nonneg g) hU.le] |
| have h2U : g^2*U ≤ U := by nlinarith only [hg2,hU] |
| have hLU : L ≤ U/2 := by |
| change 640*L ≤ g^5*U at hlarge |
| linarith only [hlarge,h52,h2U,hLp] |
| have hbL : L ≤ g^2*U := by |
| change 640*L ≤ g^5*U at hlarge |
| linarith only [hlarge,h52,hLp] |
| have he2 : 2 ≤ g*U := by |
| have hh := Real.log_nonneg (by norm_num : (1:ℝ)≤18) |
| linarith only [hh,hlog] |
| obtain ⟨hn,hnlo,hnhi⟩ := log_floor_exp he2 |
| have hnlo' : g*U/2 ≤ Real.log n-Real.log 18 := by |
| change g*U-1 ≤ Real.log n at hnlo |
| linarith only [hnlo,hlog] |
| have hu : 0 < Real.log n-Real.log 18 := |
| lt_of_lt_of_le (div_pos (mul_pos hg hU) (by norm_num)) hnlo' |
| have hqL : U-L ≤ (q:ℝ)*L := by |
| have hf := Nat.lt_floor_add_one (U/L) |
| have hm := mul_lt_mul_of_pos_right hf hLp |
| rw [div_mul_cancel₀ _ hLp.ne',add_mul,one_mul] at hm |
| linarith only [hm] |
| have hqU : U/2 ≤ (q:ℝ)*L := by linarith only [hqL,hLU] |
| have hqpos : 0 < q := by |
| have : (0:ℝ)<q := by nlinarith only [hqU,hU,hLp] |
| exact_mod_cast this |
| have hbpos : 0 < b := by |
| apply Nat.floor_pos.mpr |
| exact (le_div_iff₀ hLp).mpr (by simpa only [one_mul] using hbL) |
| have hbup : (b:ℝ)*L ≤ g^2*U := by |
| exact (le_div_iff₀ hLp).mp (Nat.floor_le (by positivity : 0 ≤ g^2*U/L)) |
| have hratio : (b:ℝ) ≤ (2*g)*q := by |
| have h1 := mul_le_mul_of_nonneg_left hqU (show 0 ≤ 2*g by positivity) |
| have h2 : g^2*U ≤ g*U := by |
| have hh := mul_le_mul_of_nonneg_right |
| (mul_le_mul_of_nonneg_left hg_le hg.le) hU.le |
| simpa only [mul_one,pow_two] using hh |
| apply (mul_le_mul_iff_left₀ hLp).mp |
| nlinarith only [hbup,h1,h2] |
| have hbq : b < q := by |
| have hqr : (0:ℝ)<q := by exact_mod_cast hqpos |
| have : (b:ℝ)<q := by nlinarith only [hratio,hg1,hqr] |
| exact_mod_cast this |
| refine ⟨hn,hbpos,hbq,hcap,hratio,hu,?_,?_,?_,?_,?_,?_⟩ |
| · have hm := mul_le_mul_of_nonneg_left hnlo' (show 0 ≤ 2*g by positivity) |
| dsimp only [L] at hbL |
| nlinarith only [hbL,hm] |
| · have hm := mul_le_mul_of_nonneg_left hnlo' (show 0 ≤ (2*g)^4 by positivity) |
| nlinarith only [hlarge,hm] |
| · have hm := mul_le_mul_of_nonneg_left hnlo' (show 0 ≤ 2*g by positivity) |
| change (b:ℝ)*L ≤ _ |
| nlinarith only [hbup,hm] |
| · have hm := mul_le_mul_of_nonneg_left hnlo' (show 0 ≤ 2*g by positivity) |
| linarith only [hsize,hm] |
| · have hqcap : (q:ℝ)*L ≤ s.primes.card*L := |
| mul_le_mul_of_nonneg_right (by exact_mod_cast hcap) hLp.le |
| have hgU := mul_le_mul_of_nonneg_right hg1 hU.le |
| change 2*(2*Real.log n+Real.log 16+2*Real.log D) ≤ s.primes.card*L |
| change Real.log n ≤ g*U at hnhi |
| nlinarith only [hnhi,hgeom,hqU,hqcap,hgU,hU] |
| · have hm := mul_le_mul_of_nonneg_left hqU (show 0 ≤ 16*g by positivity) |
| have hDn : D≠0 := by linarith only [hD] |
| have hnR : (n:ℝ)≠0 := by exact_mod_cast (show n≠0 by omega) |
| rw [Real.log_mul hDn hnR] |
| change Real.log n ≤ g*U at hnhi |
| change 2*(Real.log 36+2*(Real.log D+Real.log n)) ≤ 8*(2*g)*q*L |
| nlinarith only [hnhi,hdisp,hm] |
| |
| noncomputable def bandScale (g U : ℝ) (j : ℕ) : ℝ := (g^2)^j*U |
| noncomputable def bandLength (g U : ℝ) (j : ℕ) : ℕ := ⌊Real.exp (g*bandScale g U j)⌋₊ |
| noncomputable def bandSize (s : SplitSieve) (g U : ℝ) (j : ℕ) : ℕ := ⌊bandScale g U j/s.meanLog⌋₊ |
| |
| lemma bandScale_pos {g U : ℝ} (hg : 0<g) (hU : 0<U) (j : ℕ) : |
| 0<bandScale g U j := mul_pos (pow_pos (sq_pos_of_pos hg) _) hU |
| |
| lemma bandScale_antitone {g U : ℝ} (hg : 0≤g) (hg1 : g≤1) (hU : 0≤U) : |
| Antitone (bandScale g U) := by |
| intro i j hij |
| exact mul_le_mul_of_nonneg_right |
| (pow_le_pow_of_le_one (sq_nonneg g) (pow_le_one₀ hg hg1) hij) hU |
| |
| lemma bandScale_succ (g U : ℝ) (j : ℕ) : |
| bandScale g U (j+1)=g^2*bandScale g U j := by |
| unfold bandScale |
| rw [pow_succ] |
| ring |
| |
| theorem geometric_band_margins (s : SplitSieve) {D U g : ℝ} {l : ℕ} |
| (hD : 1≤D) (hg : 0<g) (hg1 : g≤1/200) (hL : 1 ≤ s.meanLog) (hU : 0<U) |
| (hlog : 2*(1+Real.log 18) ≤ g*bandScale g U l) |
| (hlarge : 640*s.meanLog ≤ g^5*bandScale g U l) |
| (hsize : Real.log 16+Real.log (max D ((latticeBall (4*D)).card:ℝ)) ≤ g^2*bandScale g U l) |
| (hdisp : 4*Real.log D+2*Real.log 36 ≤ 4*g*bandScale g U l) |
| (hgeom : 2*Real.log 16+4*Real.log D ≤ bandScale g U l/4) |
| (hcap : ⌊U/s.meanLog⌋₊ ≤ s.primes.card) : |
| ∀ j<l, EnrichmentMargins s D (2*g) (bandLength g U j) |
| (bandSize s g U (j+1)) (bandSize s g U j) := by |
| intro j hj |
| have hmono := bandScale_antitone hg.le (show g≤1 by linarith only [hg1]) hU.le |
| have hlow := hmono hj.le |
| have hhigh := hmono (Nat.zero_le j) |
| simp only [bandScale,pow_zero,one_mul] at hhigh |
| unfold bandLength bandSize |
| rw [bandScale_succ] |
| apply EnrichmentMargins.from_scale s hD hg hg1 hL (bandScale_pos hg hU j) |
| · exact hlog.trans (mul_le_mul_of_nonneg_left hlow hg.le) |
| · exact hlarge.trans (mul_le_mul_of_nonneg_left hlow (pow_nonneg hg.le _)) |
| · exact hsize.trans (mul_le_mul_of_nonneg_left hlow (sq_nonneg g)) |
| · exact hdisp.trans (mul_le_mul_of_nonneg_left hlow (by positivity)) |
| · exact hgeom.trans (div_le_div_of_nonneg_right hlow (by norm_num)) |
| · exact (Nat.floor_mono (div_le_div_of_nonneg_right hhigh (by linarith only [hL]))).trans hcap |
| |
| theorem TimeLaw.geometric_band_entropy (P : TimeLaw) (s : SplitSieve) |
| (hne : s.primes.Nonempty) (z : ℕ → GaussianInt) (hinj : Function.Injective z) |
| {D T U g : ℝ} {l : ℕ} (hD : 1≤D) (hT : 5≤T) |
| (hs : ∀ t, dist (z t:ℂ) (z (t+1):ℂ)≤D) |
| (hpT : ∀ p∈s.primes, T≤(p:ℝ) ∧ (p:ℝ)≤2*T) |
| (hg : 0<g) (hg1 : g≤1/200) (hL : 1 ≤ s.meanLog) (hU : 0<U) |
| (hlog : 2*(1+Real.log 18) ≤ g*bandScale g U l) |
| (hlarge : 640*s.meanLog ≤ g^5*bandScale g U l) |
| (hsize : Real.log 16+Real.log (max D ((latticeBall (4*D)).card:ℝ)) ≤ g^2*bandScale g U l) |
| (hdisp : 4*Real.log D+2*Real.log 36 ≤ 4*g*bandScale g U l) |
| (hgeom : 2*Real.log 16+4*Real.log D ≤ bandScale g U l/4) |
| (hcap : ⌊U/s.meanLog⌋₊ ≤ s.primes.card) : |
| (1-(1/2:ℝ)^l-80*g)*(bandSize s g U l:ℝ)*s.meanLog ≤ |
| s.pointEntropy (P.run z (bandLength g U) l).law (fun a => z a.val) (bandSize s g U l) := by |
| have hm := geometric_band_margins s hD hg hg1 hL hU hlog hlarge hsize hdisp hgeom hcap |
| have hh := P.run_entropy s hne z hinj hD hT hs hpT (by positivity : 0<2*g) |
| (by linarith only [hg1] : 2*g≤1/100) hL (bandLength g U) (bandSize s g U) l hm |
| convert hh using 1; ring |
| |
| lemma commonSchedule_log_bound (z : ℕ → GaussianInt) (ns : List ℕ) (N : ℕ) {x : ℝ} |
| (hns : ∀ n∈ns, (n:ℝ)≤Real.exp x) (hN : (N:ℝ)≤Real.exp x) |
| (hlen : (ns.length+2:ℝ)≤Real.exp x) : |
| Real.log (1+(commonSchedule z ns N).bound:ℝ) ≤ 2*x := by |
| have hsum : (ns.sum:ℝ)≤(ns.length:ℝ)*Real.exp x := by |
| induction ns with |
| | nil => simp |
| | cons n ns ih => |
| have hn := hns n (by simp) |
| have ht := ih (fun k hk => hns k (by simp [hk])) |
| (by simp only [List.length_cons,Nat.cast_add,Nat.cast_one] at hlen; linarith only [hlen]) |
| simp only [List.sum_cons,List.length_cons,Nat.cast_add,Nat.cast_one] |
| nlinarith only [hn,ht] |
| have hx : (1:ℝ)≤Real.exp x := by |
| have hlen0 : (0:ℝ)≤ns.length := Nat.cast_nonneg _ |
| linarith only [hlen,hlen0] |
| have hall : (1+(commonSchedule z ns N).bound:ℝ)≤Real.exp (2*x) := by |
| rw [commonSchedule_bound,Nat.cast_add] |
| have hm := mul_le_mul_of_nonneg_right hlen (Real.exp_nonneg x) |
| rw [show 2*x=x+x by ring,Real.exp_add] |
| nlinarith only [hsum,hN,hm,hx] |
| have hlog := Real.log_le_log (by positivity : (0:ℝ)<1+(commonSchedule z ns N).bound) hall |
| simpa only [Real.log_exp] using hlog |
| |
| lemma suffix_entropy_cost {D g V L : ℝ} {q S : ℕ} |
| (hD : 1≤D) (hg : 0≤g) (hS : 1≤S) |
| (hq : V/2≤(q:ℝ)*L) (hlog : Real.log (1+(S:ℝ))≤2*g*V) |
| (hconst : Real.log 36+2*Real.log D≤g*V) : |
| Real.log 36+2*Real.log (D*S)≤10*g*q*L := by |
| have hSp : (0:ℝ)<S := by exact_mod_cast hS |
| have hSl := Real.log_le_log hSp (show (S:ℝ)≤1+S by linarith) |
| rw [Real.log_mul (by linarith only [hD] : D≠0) hSp.ne'] |
| have hq' := mul_le_mul_of_nonneg_left hq (show 0≤10*g by positivity) |
| nlinarith only [hSl,hlog,hconst,hq'] |
|
|
| end GaussianMoat |
|
|
| end OAI |
|
|
