lean/OAI/NumberTheory/GaussianMoat/KernelComposition.lean

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<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)
    (hcost : Real.log 36+2*Real.log (D*((post.sum+N:ℕ)+1)) ≤
      e*(bandSize s g U l:ℝ)*s.meanLog) :
    (1-(1/2:ℝ)^l-80*g-e)*(bandSize s g U l:ℝ)*s.meanLog ≤
      s.pointEntropy ((commonSchedule z
        (pre++List.ofFn (fun i : Fin l => 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