import OAI.NumberTheory.GaussianMoat.MultiscaleSchedule namespace OAI universe uOmega uAlpha uBeta namespace GaussianMoat open scoped BigOperators Classical namespace FinLaw noncomputable def pure {Ω : Type uOmega} [Fintype Ω] (ω : Ω) : FinLaw Ω where mass ν := if ν=ω then 1 else 0 nonneg _ := by split_ifs <;> norm_num sum_one := by simp lemma mix_pure {Ω : Type uOmega} {α : Type uAlpha} [Fintype Ω] [Fintype α] (ω : Ω) (q : Ω → FinLaw α) : (pure ω).mix q=q ω := by ext a simp [mix_mass,pure] lemma joint_pure_observation {Ω : Type uOmega} {α : Type uAlpha} {β : Type uBeta} [Fintype Ω] [Fintype α] [Fintype β] (ω : Ω) (q : Ω → FinLaw α) (F : Ω × α → β) : ((pure ω).joint q).map F=(q ω).map (fun a => F (ω,a)) := by rw [joint_observation_fun,mix_pure] end FinLaw noncomputable def TimeLaw.at (a : ℕ) : TimeLaw where last := a law := FinLaw.pure ⟨a,by omega⟩ lemma TimeLaw.at_advance (a : ℕ) (K : ForwardKernel) : ((TimeLaw.at a).advance K).law= (K.law a).map (fun t => (⟨a+t.val,by omega⟩ : Fin (a+K.bound+1))) := by change ((FinLaw.pure (⟨a,by omega⟩ : Fin (a+1))).joint (fun t => K.law t.val)).map (addOffsets a K.bound)=_ rw [FinLaw.joint_pure_observation] rfl lemma SplitSieve.pointEntropy_exact_start (s : SplitSieve) (K : ForwardKernel) (z : ℕ → GaussianInt) (a b : ℕ) : s.pointEntropy ((TimeLaw.at a).advance K).law (fun t => z t.val) b= s.pointEntropy (K.law a) (fun t => z (a+t.val)) b := by rw [TimeLaw.at_advance] change s.pointEntropy ((K.law a).map (fun t => (⟨a+t.val,by omega⟩ : Fin (a+K.bound+1)))) (fun t => z t.val) b = _ rw [s.pointEntropy_map] rfl theorem TimeLaw.advance_entropy_succ (P : TimeLaw) (K : ForwardKernel) (s : SplitSieve) (z : ℕ → GaussianInt) {D : ℝ} (hD : 1≤D) (hs : ∀ t, dist (z t:ℂ) (z (t+1):ℂ)≤D) (b : ℕ) : s.pointEntropy P.law (fun a => z a.val) b- (Real.log 36+2*Real.log (D*(K.bound+1))) ≤ 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 hf := 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 hf rw [hf] 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 have hc : Q.Hf (fun v => z (v.1.val+v.2.val)-z v.1.val) ≤ Real.log 36+2*Real.log (D*(K.bound+1)) := by apply displacement_entropy_le · exact one_le_mul_of_one_le_of_one_le hD (by exact_mod_cast Nat.le_add_left 1 K.bound) · intro v have hd := walk_pair_displacement z (by linarith only [hD]) hs v.1.val (K.bound+1) v.2.val 0 (by omega) (by omega) simpa only [Nat.add_zero,Nat.cast_add,Nat.cast_one] using hd rw [he] linarith only [hh,hc] theorem commonSchedule_subband_entropy (s : SplitSieve) (hne : s.primes.Nonempty) (z : ℕ → GaussianInt) (hinj : Function.Injective z) (pre post : List ℕ) (a N : ℕ) {D T U g e : ℝ} {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 bandLength g U i.val)++post) N).law a) (fun t => z (a+t.val)) (bandSize s g U l) := by rw [← s.pointEntropy_exact_start] rw [List.append_assoc,TimeLaw.advance_common_append,TimeLaw.advance_common_append, TimeLaw.foldl_ofFn] let P := pre.foldl (fun Q k => Q.step z k) (TimeLaw.at a) have h1 := P.geometric_band_entropy s hne z hinj hD hT hs hpT hg hg1 hL hU hlog hlarge hsize hdisp hgeom hcap have h2 := (P.run z (bandLength g U) l).advance_entropy_succ (commonSchedule z post N) s z hD hs (bandSize s g U l) rw [commonSchedule_bound] at h2 change _ ≤ s.pointEntropy ((P.run z (bandLength g U) l).advance (commonSchedule z post N)).law (fun a => z a.val) (bandSize s g U l) simp only [Nat.cast_add] at hcost h2 nlinarith only [h1,h2,hcost] lemma ForwardKernel.ext_observe (K R : ForwardKernel) (hb : K.bound=R.bound) (h : ∀ (a : ℕ) {α : Type} [Fintype α] (f : ℕ → α), (K.law a).map (fun t => f (a+t.val))=(R.law a).map (fun t => f (a+t.val))) : K=R := by cases K with | mk n p => cases R with | mk m q => dsimp only at hb subst m congr 1 funext a let f : ℕ → Fin (n+1) := fun t => ⟨min (t-a) n,by omega⟩ have hh := h a f have he : (fun t : Fin (n+1) => f (a+t.val))=id := by funext t apply Fin.ext dsimp only [f,id_eq] omega simpa only [he,FinLaw.map_id] using hh lemma ForwardKernel.then_assoc (K R S : ForwardKernel) : (K.then R).then S=K.then (R.then S) := by apply ForwardKernel.ext_observe · exact Nat.add_assoc _ _ _ · intro a α _ f rw [ForwardKernel.then_observe,ForwardKernel.then_observe] have hl : ((K.then R).law a).mix (fun t => (S.law (a+t.val)).map (fun u => f (a+t.val+u.val))) = (K.law a).mix (fun t => (R.law (a+t.val)).mix (fun u => (S.law (a+t.val+u.val)).map (fun v => f (a+t.val+u.val+v.val)))) := by unfold ForwardKernel.then rw [FinLaw.mix_map_left] ext x simp only [FinLaw.mix_mass,FinLaw.joint_mass,Fintype.sum_prod_type,Finset.mul_sum, addOffsets,Nat.add_assoc,mul_assoc] rw [hl] congr 1 funext t exact (R.then_observe S (a+t.val) f).symm lemma FinLaw.map_pure {Ω : Type uOmega} {α : Type uAlpha} [Fintype Ω] [Fintype α] (ω : Ω) (f : Ω → α) : (FinLaw.pure ω).map f=FinLaw.pure (f ω) := by ext a simp only [FinLaw.map_mass,FinLaw.pure] rw [Finset.sum_eq_single ω] · simp only [ite_true,eq_comm] · intro ν _ hν simp [hν] · simp lemma FinLaw.mix_pure_right {Ω : Type uOmega} {α : Type uAlpha} [Fintype Ω] [Fintype α] (p : FinLaw Ω) (f : Ω → α) : p.mix (fun ω => FinLaw.pure (f ω))=p.map f := by ext a simp only [FinLaw.mix_mass,FinLaw.pure,FinLaw.map_mass,mul_ite,mul_one,mul_zero] apply Finset.sum_congr rfl intro ω _ simp only [eq_comm] lemma smoothingKernel_zero_law (a : ℕ) : (smoothingKernel 0).law a=FinLaw.pure (0 : Fin 1) := by change FinLaw.uniform (Fin 1)=FinLaw.pure (0 : Fin 1) ext x have hx : x=0 := Subsingleton.elim _ _ simp [FinLaw.uniform,FinLaw.pure,hx] lemma ForwardKernel.then_zero (K : ForwardKernel) : K.then (smoothingKernel 0)=K := by apply ForwardKernel.ext_observe · exact Nat.add_zero _ · intro a α _ f rw [ForwardKernel.then_observe] change (K.law a).mix (fun t => (FinLaw.uniform (Fin 1)).map (fun u => f (a+t.val+u.val)))=_ have hu : FinLaw.uniform (Fin 1)=FinLaw.pure (0 : Fin 1) := smoothingKernel_zero_law 0 simp only [hu,FinLaw.map_pure,Fin.val_zero,Nat.add_zero] exact FinLaw.mix_pure_right _ _ lemma ForwardKernel.zero_then (K : ForwardKernel) : (smoothingKernel 0).then K=K := by apply ForwardKernel.ext_observe · exact Nat.zero_add _ · intro a α _ f rw [ForwardKernel.then_observe] change (FinLaw.uniform (Fin 1)).mix (fun t => (K.law (a+t.val)).map (fun u => f (a+t.val+u.val)))=_ have hu : FinLaw.uniform (Fin 1)=FinLaw.pure (0 : Fin 1) := smoothingKernel_zero_law 0 rw [hu,FinLaw.mix_pure] rfl lemma commonSchedule_append (z : ℕ → GaussianInt) (ns ms : List ℕ) (N : ℕ) : commonSchedule z (ns++ms) N=(commonSchedule z ns 0).then (commonSchedule z ms N) := by induction ns with | nil => exact (ForwardKernel.zero_then _).symm | cons n ns ih => rw [List.cons_append,commonSchedule_cons,commonSchedule_cons,ih,ForwardKernel.then_assoc] end GaussianMoat end OAI