import OAI.Probability.GaussianReplacement.ArrayBounds

namespace OAI

open MeasureTheory ProbabilityTheory Set Filter
open scoped ENNReal NNReal RealInnerProductSpace Topology
noncomputable section
namespace CurrentProjection
open InnerProductSpace
open InformationTheory


lemma averaged_telescope_block {m a b : ℕ} (hab : a ≤ b)
    (J T : ℕ → ℕ → ℝ) (K : ℕ → ℝ) (C S B q : ℝ) (hq : 0 < q)
    (hstep : ∀ i < m, ∀ k ∈ Finset.Icc a b,
      J i k-J (i+1) k ≤ C+K i/q+T i (k+1)-T i k)
    (hfirst : ∀ i < m, 0 ≤ T i a)
    (hlast : ∀ i < m, T i (b+1) ≤ S)
    (hK : ∑ i ∈ Finset.range m, K i ≤ B) :
    (∑ k ∈ Finset.Icc a b, J 0 k)/(b-a+1:ℕ) -
      (∑ k ∈ Finset.Icc a b, J m k)/(b-a+1:ℕ) ≤
        C*m+(m:ℝ)/(b-a+1:ℕ)*S+B/q := by
  let N : ℝ := (b-a+1:ℕ)
  have hN : 0 < N := by dsimp [N]; positivity
  have hcard : ((Finset.Icc a b).card:ℝ) = N := by
    dsimp [N]
    simp only [Nat.card_Icc]
    congr 1
    omega
  have he : Finset.Icc a b = Finset.Ico a (b+1) := by
    ext k
    simp only [Finset.mem_Icc,Finset.mem_Ico]
    omega
  have hs (i : ℕ) : ∑ k ∈ Finset.Icc a b, (T i (k+1)-T i k) = T i (b+1)-T i a := by
    rw [he]
    exact Finset.sum_Ico_sub _ (by omega)
  let F : ℕ → ℝ := fun i => (∑ k ∈ Finset.Icc a b, J i k)/N
  have hrow (i : ℕ) (hi : i < m) : F i-F (i+1) ≤ C+S/N+K i/q := by
    have h := Finset.sum_le_sum (fun k hk => hstep i hi k hk)
    have hrepr : ∑ k ∈ Finset.Icc a b, (C+K i/q+T i (k+1)-T i k) =
        N*(C+K i/q)+T i (b+1)-T i a := by
      simp_rw [show ∀ k, C+K i/q+T i (k+1)-T i k = (C+K i/q)+(T i (k+1)-T i k) by intro k; ring]
      rw [Finset.sum_add_distrib,hs,Finset.sum_const,nsmul_eq_mul,hcard]
      ring
    rw [hrepr,Finset.sum_sub_distrib] at h
    dsimp only [F]
    rw [←sub_div]
    apply (div_le_iff₀ hN).mpr
    have hfirst' := hfirst i hi
    have hlast' := hlast i hi
    calc
      _ ≤ N*(C+K i/q)+S := by linarith
      _ = (C+S/N+K i/q)*N := by field_simp; ring
  have hsum := Finset.sum_le_sum (fun i hi => hrow i (Finset.mem_range.mp hi))
  rw [Finset.sum_range_sub'] at hsum
  have hsumr : ∑ i ∈ Finset.range m, (C+S/N+K i/q) =
      (m:ℝ)*(C+S/N)+(∑ i ∈ Finset.range m, K i)/q := by
    rw [Finset.sum_add_distrib,Finset.sum_div,Finset.sum_const,Finset.card_range,nsmul_eq_mul]
  rw [hsumr] at hsum
  have hKq := div_le_div_of_nonneg_right hK hq.le
  change F 0-F m ≤ C*m+(m:ℝ)/N*S+B/q
  calc
    _ ≤ (m:ℝ)*(C+S/N)+(∑ i ∈ Finset.range m, K i)/q := hsum
    _ ≤ (m:ℝ)*(C+S/N)+B/q := add_le_add_right hKq _
    _ = _ := by ring



lemma prefix_charge_sum {d m : ℕ} {W : Type*} [MeasurableSpace W]
    [Countable W] [MeasurableSingletonClass W]
    (P : Measure ((Sphere d×W)×Rows m d)) [IsProbabilityMeasure P]
    (hd : 1 ≤ d) (hInd : (P.map swapLast).fst = (uniformSphere d).prod (gaussianRows m d))
    {B : ℝ} (hB : 0 ≤ B) (hH : shannonEntropy P.fst.snd ≤ ENNReal.ofReal B) :
    (∑ i ∈ Finset.range m, (if hi : i < m then
      (klDiv (nextActualRowLaw P i hi) ((nextActualRowLaw P i hi).fst.prod (stdGaussian (Vector d)))).toReal else 0)) ≤ B := by
  classical
  let : IsProbabilityMeasure (uniformSphere d) := uniformSphere_probability_of_pos hd
  let R : ℕ → ℝ := fun i => if hi : i ≤ m then
    (rowInformation (prefixLaw P i hi) (gaussianRows i d)).toReal else 0
  have hR (i : ℕ) (hi : i ≤ m) := rowInformation_finite_bound (prefixLaw P i hi) hd
    (prefixLaw_independence P (uniformSphere d) hInd i hi) hB (by rwa [prefixLaw_fst])
  have hstep (i : ℕ) (hi : i < m) :
      (klDiv (nextActualRowLaw P i hi) ((nextActualRowLaw P i hi).fst.prod (stdGaussian (Vector d)))).toReal = R (i+1)-R i := by
    have he := prefix_rowInformation_step P i hi
    have hK : klDiv (nextActualRowLaw P i hi) ((nextActualRowLaw P i hi).fst.prod (stdGaussian (Vector d))) ≠ ∞ :=
      ne_top_of_le_ne_top (hR (i+1) (by omega)).1 (by rw [he]; exact le_add_left le_rfl)
    have her := congrArg ENNReal.toReal he
    rw [ENNReal.toReal_add (hR i (by omega)).1 hK] at her
    simp only [R,dite_eq_left (Nat.le_of_lt hi),dite_eq_left (Nat.succ_le_of_lt hi)]
    linarith
  have he : (∑ i ∈ Finset.range m, (if hi : i < m then
      (klDiv (nextActualRowLaw P i hi) ((nextActualRowLaw P i hi).fst.prod (stdGaussian (Vector d)))).toReal else 0)) = R m-R 0 := by
    calc
      _ = ∑ i ∈ Finset.range m, (R (i+1)-R i) := by
        apply Finset.sum_congr rfl
        intro i hi
        rw [dite_eq_left (Finset.mem_range.mp hi),hstep i (Finset.mem_range.mp hi)]
      _ = _ := Finset.sum_range_sub R m
  rw [he]
  have h0 : 0 ≤ R 0 := by simp only [R,dite_eq_left (Nat.zero_le m)]; exact ENNReal.toReal_nonneg
  have hm : R m ≤ B := by simp only [R,dite_eq_left le_rfl]; exact (hR m le_rfl).2
  linarith

lemma hybrid_average_ending {d m : ℕ} {W : Type*}
    [MeasurableSpace W] [StandardBorelSpace W] [Nonempty W]
    [Countable W] [MeasurableSingletonClass W]
    (P : Measure ((Sphere d×W)×Rows m d)) [IsProbabilityMeasure P]
    (hd : 256 ≤ d) (hm : m ≤ d/8)
    (hInd : (P.map swapLast).fst = (uniformSphere d).prod (gaussianRows m d))
    {B : ℝ} (hB : 0 ≤ B) (hH : shannonEntropy P.fst.snd ≤ ENNReal.ofReal B) :
    (∑ k ∈ Finset.Icc (hybridFirst d) (hybridLast d),
      (exposedInformation (alignedExperiment (r:=k) (prefixLaw P 0 (Nat.zero_le m)))).toReal)/hybridCount d -
    (∑ k ∈ Finset.Icc (hybridFirst d) (hybridLast d),
      (exposedInformation (alignedExperiment (r:=k-m) P)).toReal)/hybridCount d ≤
      hybridRowConstant*m + (m:ℝ)/hybridCount d*(16*hybridBaselineConstant+B/(d/8:ℕ))+B/(d/32:ℕ) := by
  classical
  let : IsProbabilityMeasure (uniformSphere d) := uniformSphere_probability_of_pos (by omega)
  let J : ℕ → ℕ → ℝ := fun i k => if hi : i ≤ m then
    (exposedInformation (alignedExperiment (r:=k-i) (prefixLaw P i hi))).toReal else 0
  let T : ℕ → ℕ → ℝ := fun i k => if hi : i ≤ m then
    (freshSlope (observationSignalLaw (prefixLaw P i hi)) (k-i-1)).toReal else 0
  let K : ℕ → ℝ := fun i => if hi : i < m then
    (klDiv (nextActualRowLaw P i hi) ((nextActualRowLaw P i hi).fst.prod (stdGaussian (Vector d)))).toReal else 0
  have hab : hybridFirst d ≤ hybridLast d := by unfold hybridFirst hybridLast; omega
  have hstep (i : ℕ) (hi : i < m) (k : ℕ) (hk : k ∈ Finset.Icc (hybridFirst d) (hybridLast d)) :
      J i k-J (i+1) k ≤ hybridRowConstant+K i/(d/32:ℕ)+T i (k+1)-T i k := by
    obtain ⟨hka,hkb⟩ := Finset.mem_Icc.mp hk
    dsimp [hybridFirst,hybridLast] at hka hkb
    have h := hybrid_one_step (r:=k-(i+1)) (q:=d/32) P (by omega) hInd hB hH hi
      (by omega) (by omega) (by omega) (by omega) (by omega) (by omega)
    simp only [J,T,K,dite_eq_left (Nat.le_of_lt hi),dite_eq_left (Nat.succ_le_of_lt hi),dite_eq_left hi]
    have hsub0 : k-i = k-(i+1)+1 := by omega
    have hsub1 : k+1-i-1 = k-(i+1)+1 := by omega
    have hsub2 : k-i-1 = k-(i+1) := by omega
    rw [hsub1,hsub2,hsub0]
    exact h
  have hfirst (i : ℕ) (hi : i < m) : 0 ≤ T i (hybridFirst d) := by
    simp only [T,dite_eq_left (Nat.le_of_lt hi)]
    exact ENNReal.toReal_nonneg
  have hlast (i : ℕ) (hi : i < m) : T i (hybridLast d+1) ≤ 16*hybridBaselineConstant+B/(d/8:ℕ) := by
    simp only [T,dite_eq_left (Nat.le_of_lt hi)]
    apply (freshSlope_from_array_bound (prefixLaw P i (Nat.le_of_lt hi)) (by omega)
      (prefixLaw_independence P (uniformSphere d) hInd i _) hB (by rwa [prefixLaw_fst]) ?_ ?_).2
    · unfold hybridLast; omega
    · unfold hybridLast; omega
  have hsum := averaged_telescope_block hab J T K hybridRowConstant
    (16*hybridBaselineConstant+B/(d/8:ℕ)) B (d/32:ℕ) (by exact_mod_cast (show 0 < d/32 by omega))
      hstep hfirst hlast (prefix_charge_sum P (by omega) hInd hB hH)
  simpa only [J,dite_eq_left (Nat.zero_le m),dite_eq_left le_rfl,Nat.sub_zero,prefixLaw_self,hybridCount] using hsum



def processedKernel {Z A B C : Type*} [MeasurableSpace Z] [MeasurableSpace A]
    [MeasurableSpace B] [MeasurableSpace C] (α : Kernel Z (A×B))
    (η : Kernel (Z×B) C) : Kernel Z (A×C) :=
  (α ⊗ₖ η.comap (Prod.map id Prod.snd) (measurable_id.prodMap measurable_snd)).map
    (fun z => (z.1.1,z.2))

instance processedKernel_markov {Z A B C : Type*} [MeasurableSpace Z] [MeasurableSpace A]
    [MeasurableSpace B] [MeasurableSpace C] (α : Kernel Z (A×B)) [IsMarkovKernel α]
    (η : Kernel (Z×B) C) [IsMarkovKernel η] : IsMarkovKernel (processedKernel α η) := by
  unfold processedKernel
  exact Kernel.IsMarkovKernel.map _ (measurable_fst.fst.prodMk measurable_snd)

lemma processedKernel_apply_prod {Z A B C : Type*} [MeasurableSpace Z] [MeasurableSpace A]
    [MeasurableSpace B] [MeasurableSpace C] (α : Kernel Z (A×B)) [IsMarkovKernel α]
    (η : Kernel (Z×B) C) [IsMarkovKernel η] (z : Z)
    {s : Set A} {t : Set C} (hs : MeasurableSet s) (ht : MeasurableSet t) :
    processedKernel α η z (s×ˢt) = ∫⁻ p in s×ˢSet.univ, η (z,p.2) t ∂α z := by
  rw [processedKernel,Kernel.map_apply _ (measurable_fst.fst.prodMk measurable_snd),Measure.map_apply (measurable_fst.fst.prodMk measurable_snd) (hs.prod ht)]
  rw [show (fun p : (A×B)×C => (p.1.1,p.2)) ⁻¹' (s×ˢt) = (s×ˢSet.univ)×ˢt by ext p; simp]
  rw [Kernel.compProd_apply_prod (hs.prod MeasurableSet.univ) ht]
  rfl

lemma processedKernel_fst {Z A B C : Type*} [MeasurableSpace Z] [MeasurableSpace A]
    [MeasurableSpace B] [MeasurableSpace C] (α : Kernel Z (A×B)) [IsMarkovKernel α]
    (η : Kernel (Z×B) C) [IsMarkovKernel η] : (processedKernel α η).fst = α.fst := by
  rw [processedKernel,Kernel.fst_eq,←Kernel.map_comp_right _ (measurable_fst.fst.prodMk measurable_snd) measurable_fst]
  change (α ⊗ₖ η.comap (Prod.map id Prod.snd) (measurable_id.prodMap measurable_snd)).map (Prod.fst ∘ Prod.fst) = _
  rw [Kernel.map_comp_right _ measurable_fst measurable_fst]
  rw [←Kernel.fst_eq,←Kernel.fst_eq,Kernel.fst_compProd]

lemma processedKernel_snd_apply {Z A B C : Type*} [MeasurableSpace Z] [MeasurableSpace A]
    [MeasurableSpace B] [MeasurableSpace C] (α : Kernel Z (A×B)) [IsMarkovKernel α]
    (η : Kernel (Z×B) C) [IsMarkovKernel η] (z : Z) {t : Set C} (ht : MeasurableSet t) :
    (processedKernel α η).snd z t = ∫⁻ b, η (z,b) t ∂α.snd z := by
  rw [Kernel.snd_apply' _ _ ht]
  rw [show (Prod.snd : A×C → C) ⁻¹' t = Set.univ×ˢt by ext p; simp]
  rw [processedKernel_apply_prod α η z MeasurableSet.univ ht]
  simp only [Set.univ_prod_univ,Measure.restrict_univ]
  rw [Kernel.snd_eq,Kernel.map_apply _ measurable_snd]
  rw [lintegral_map (by exact (η.measurable_coe ht).comp (measurable_const.prodMk measurable_id)) measurable_snd]

lemma processedKernel_reference {Z A B C : Type*} [MeasurableSpace Z] [MeasurableSpace A]
    [MeasurableSpace B] [MeasurableSpace C] (α : Kernel Z (A×B)) [IsMarkovKernel α]
    (η : Kernel (Z×B) C) [IsMarkovKernel η] :
    processedKernel (α.fst ×ₖ α.snd) η = (processedKernel α η).fst ×ₖ (processedKernel α η).snd := by
  rw [processedKernel_fst]
  ext z : 1
  apply Measure.ext_prod
  intro s t hs ht
  rw [processedKernel_apply_prod _ _ _ hs ht,Kernel.prod_apply_prod,processedKernel_snd_apply _ _ _ ht,
    Kernel.prod_apply,←Measure.prod_restrict (s:=s) (t:=Set.univ),Measure.restrict_univ]
  rw [lintegral_prod _ (by exact ((η.measurable_coe ht).comp (measurable_const.prodMk measurable_snd)).aemeasurable)]
  simp only [lintegral_const,Measure.restrict_apply_univ]
  rw [mul_comm]

lemma compProd_processedKernel {Z A B C : Type*} [MeasurableSpace Z] [MeasurableSpace A]
    [MeasurableSpace B] [MeasurableSpace C] (μ : Measure Z) [IsFiniteMeasure μ]
    (α : Kernel Z (A×B)) [IsMarkovKernel α] (η : Kernel (Z×B) C) [IsMarkovKernel η] :
    μ ⊗ₘ processedKernel α η =
      ((μ ⊗ₘ α) ⊗ₘ η.comap (Prod.map id Prod.snd) (measurable_id.prodMap measurable_snd)).map
        (fun z => (z.1.1,(z.1.2.1,z.2))) := by
  rw [processedKernel,Measure.compProd_map (measurable_fst.fst.prodMk measurable_snd),
    ←Measure.compProd_assoc,Measure.map_map
      (measurable_fst.fst.prodMk (measurable_fst.snd.fst.prodMk measurable_snd))
      MeasurableEquiv.prodAssoc.symm.measurable]
  rfl

lemma conditionalMutualInformation_processedKernel_le {Z A B C : Type*}
    [MeasurableSpace Z] [MeasurableSpace A] [MeasurableSpace B] [MeasurableSpace C]
    [StandardBorelSpace A] [StandardBorelSpace B] [StandardBorelSpace C]
    [Nonempty A] [Nonempty B] [Nonempty C]
    (μ : Measure Z) [IsProbabilityMeasure μ]
    (α : Kernel Z (A×B)) [IsMarkovKernel α] (η : Kernel (Z×B) C) [IsMarkovKernel η] :
    conditionalMutualInformation (μ ⊗ₘ processedKernel α η) ≤ conditionalMutualInformation (μ ⊗ₘ α) := by
  rw [conditionalMutualInformation_compProd,conditionalMutualInformation_compProd,
    ←processedKernel_reference,compProd_processedKernel,compProd_processedKernel]
  calc
    _ ≤ klDiv ((μ ⊗ₘ α) ⊗ₘ η.comap (Prod.map id Prod.snd) (measurable_id.prodMap measurable_snd))
      ((μ ⊗ₘ (α.fst ×ₖ α.snd)) ⊗ₘ η.comap (Prod.map id Prod.snd) (measurable_id.prodMap measurable_snd)) :=
      klDiv_map_le _ _ (measurable_fst.fst.prodMk (measurable_fst.snd.fst.prodMk measurable_snd))
    _ = _ := klDiv_compProd_left _ _ _

def processedLaw {Z A B C : Type*} [MeasurableSpace Z] [MeasurableSpace A]
    [MeasurableSpace B] [MeasurableSpace C] (P : Measure (Z×(A×B)))
    (η : Kernel (Z×B) C) : Measure (Z×(A×C)) :=
  (P ⊗ₘ η.comap (Prod.map id Prod.snd) (measurable_id.prodMap measurable_snd)).map
    (fun z => (z.1.1,(z.1.2.1,z.2)))

instance processedLaw_probability {Z A B C : Type*} [MeasurableSpace Z] [MeasurableSpace A]
    [MeasurableSpace B] [MeasurableSpace C] (P : Measure (Z×(A×B))) [IsProbabilityMeasure P]
    (η : Kernel (Z×B) C) [IsMarkovKernel η] : IsProbabilityMeasure (processedLaw P η) := by
  exact (Measure.isProbabilityMeasure_map_iff
    (measurable_fst.fst.prodMk (measurable_fst.snd.fst.prodMk measurable_snd)).aemeasurable).mpr
    inferInstance

lemma conditionalMutualInformation_processed_le {Z A B C : Type*}
    [MeasurableSpace Z] [MeasurableSpace A] [MeasurableSpace B] [MeasurableSpace C]
    [StandardBorelSpace A] [StandardBorelSpace B] [StandardBorelSpace C]
    [Nonempty A] [Nonempty B] [Nonempty C]
    (P : Measure (Z×(A×B))) [IsProbabilityMeasure P] (η : Kernel (Z×B) C) [IsMarkovKernel η] :
    conditionalMutualInformation (processedLaw P η) ≤ conditionalMutualInformation P := by
  have h := conditionalMutualInformation_processedKernel_le P.fst P.condKernel η
  simpa only [compProd_processedKernel,P.disintegrate P.condKernel,processedLaw] using h



lemma compProd_map_base {A B C : Type*} [MeasurableSpace A] [MeasurableSpace B]
    [MeasurableSpace C] (μ : Measure A) [IsProbabilityMeasure μ]
    (κ : Kernel B C) [IsMarkovKernel κ] (f : A → B) (hf : Measurable f) :
    μ.map f ⊗ₘ κ = (μ ⊗ₘ κ.comap f hf).map (Prod.map f id) := by
  apply Measure.ext_prod
  intro s t hs ht
  rw [Measure.compProd_apply_prod hs ht,Measure.map_apply (hf.prodMap measurable_id) (hs.prod ht)]
  change _ = (μ ⊗ₘ κ.comap f hf) ((f ⁻¹' s)×ˢt)
  rw [Measure.compProd_apply_prod (hs.preimage hf) ht,setLIntegral_map hs (κ.measurable_coe ht) hf]
  rfl

lemma compProd_independent_swap {A B C : Type*} [MeasurableSpace A] [MeasurableSpace B]
    [MeasurableSpace C] (μ : Measure A) [IsProbabilityMeasure μ]
    (κ : Kernel A B) [IsMarkovKernel κ] (γ : Measure C) [IsProbabilityMeasure γ] :
    ((μ ⊗ₘ κ).prod γ).map (fun z => ((z.1.1,z.2),z.1.2)) =
      (μ.prod γ) ⊗ₘ κ.comap Prod.fst measurable_fst := by
  apply Measure.ext_prod₃'
  intro s t u hs ht hu
  rw [Measure.map_apply ((measurable_fst.fst.prodMk measurable_snd).prodMk measurable_fst.snd) ((hs.prod ht).prod hu)]
  have he : (fun z : (A×B)×C => ((z.1.1,z.2),z.1.2)) ⁻¹' ((s×ˢt)×ˢu) = (s×ˢu)×ˢt := by
    ext z; simp only [Set.mem_preimage,Set.mem_prod]; tauto
  rw [he,Measure.prod_prod,Measure.compProd_apply_prod hs hu,Measure.compProd_apply_prod (hs.prod ht) hu,
    ←Measure.prod_restrict,lintegral_prod _ (by exact ((κ.measurable_coe hu).comp measurable_fst).aemeasurable)]
  simp only [Kernel.comap_apply,lintegral_const,Measure.restrict_apply_univ]
  rw [lintegral_mul_const _ (κ.measurable_coe hu)]

lemma probability_prod_subsingleton {A B : Type*} [MeasurableSpace A] [MeasurableSpace B]
    [Subsingleton B] (μ : Measure (A×B)) [IsProbabilityMeasure μ]
    (γ : Measure B) [IsProbabilityMeasure γ] : μ = μ.fst.prod γ := by
  apply Measure.ext_prod
  intro s t hs ht
  by_cases ht0 : t = ∅
  · simp [ht0]
  · have ht1 : t = Set.univ := (Set.nonempty_iff_ne_empty.mpr ht0).eq_univ
    rw [ht1,Measure.prod_prod,measure_univ,mul_one]
    rw [Measure.fst_apply hs]
    congr 1
    ext z; simp

lemma alignedExperiment_fresh {d m r : ℕ} {W : Type*} [MeasurableSpace W]
    (P : Measure (Sphere d×W)) [IsProbabilityMeasure P] :
    alignedExperiment (r:=r) (P.prod (gaussianRows m d)) = P.prod (gaussianRows (m+r) d) := by
  change Measure.map ((Prod.map id (fun p : Rows m d×Rows r d => Fin.append p.1 p.2)) ∘
    MeasurableEquiv.prodAssoc) ((P.prod (gaussianRows m d)).prod (gaussianRows r d)) = _
  rw [←Measure.map_map (measurable_id.prodMap (measurable_append (E:=Vector d) m r))
    MeasurableEquiv.prodAssoc.measurable,Measure.prodAssoc_prod,
    ←Measure.map_prod_map _ _ measurable_id (measurable_append (E:=Vector d) m r),Measure.map_id]
  rw [show ((gaussianRows m d).prod (gaussianRows r d)).map (fun p => Fin.append p.1 p.2) =
    gaussianRows (m+r) d from map_append_pi (stdGaussian (Vector d)) m r]

lemma exposedInformation_prefix_zero {d m k : ℕ} {W : Type*}
    [MeasurableSpace W] [StandardBorelSpace W]
    (P : Measure ((Sphere d×W)×Rows m d)) [IsProbabilityMeasure P] :
    exposedInformation (alignedExperiment (r:=k) (prefixLaw P 0 (Nat.zero_le m))) = freshInformation P.fst k := by
  have he := probability_prod_subsingleton (prefixLaw P 0 (Nat.zero_le m)) (gaussianRows 0 d)
  rw [prefixLaw_fst] at he
  simp only [he,alignedExperiment_fresh]
  change freshInformation P.fst (0+k) = freshInformation P.fst k
  rw [Nat.zero_add]




def endingRowLaw {d m : ℕ} {U V : Type*} [MeasurableSpace U] [MeasurableSpace V]
    (P : Measure (Sphere d×U))
    (κ : Kernel (U×(Rows m d×(Fin m→ℝ))) V) : Measure ((Sphere d×V)×Rows m d) :=
  (blockLaw P κ).map (fun z => ((z.1.1.1,z.2),z.1.2))

lemma measurable_endingRowMap {d m : ℕ} {U V : Type*} [MeasurableSpace U] [MeasurableSpace V] :
    Measurable (fun z : (((Sphere d×U)×Rows m d)×V) => ((z.1.1.1,z.2),z.1.2)) :=
  (measurable_fst.fst.fst.prodMk measurable_snd).prodMk measurable_fst.snd

instance endingRowLaw_probability {d m : ℕ} {U V : Type*} [MeasurableSpace U] [MeasurableSpace V]
    (P : Measure (Sphere d×U)) [IsProbabilityMeasure P]
    (κ : Kernel (U×(Rows m d×(Fin m→ℝ))) V) [IsMarkovKernel κ] : IsProbabilityMeasure (endingRowLaw P κ) := by
  exact (Measure.isProbabilityMeasure_map_iff
    measurable_endingRowMap.aemeasurable).mpr inferInstance

lemma endingRowLaw_fst {d m : ℕ} {U V : Type*} [MeasurableSpace U] [MeasurableSpace V]
    (P : Measure (Sphere d×U))
    (κ : Kernel (U×(Rows m d×(Fin m→ℝ))) V) :
    (endingRowLaw P κ).fst = endingSignalLaw P κ := by
  rw [endingRowLaw,Measure.fst,Measure.map_map measurable_fst measurable_endingRowMap]
  rfl

lemma endingRowLaw_independence {d m : ℕ} {U V : Type*} [MeasurableSpace U] [MeasurableSpace V]
    (P : Measure (Sphere d×U)) [IsProbabilityMeasure P]
    (κ : Kernel (U×(Rows m d×(Fin m→ℝ))) V) [IsMarkovKernel κ] :
    ((endingRowLaw P κ).map swapLast).fst = P.fst.prod (gaussianRows m d) := by
  rw [endingRowLaw,Measure.fst,Measure.map_map measurable_fst swapLast.measurable,
    Measure.map_map (measurable_fst.comp swapLast.measurable) measurable_endingRowMap]
  change (blockLaw P κ).map ((Prod.map Prod.fst id) ∘ Prod.fst) = _
  rw [←Measure.map_map (measurable_fst.prodMap measurable_id) measurable_fst,←Measure.fst]
  change (((P.prod (gaussianRows m d)) ⊗ₘ κ.comap blockInput measurable_blockInput).fst).map _ = _
  rw [Measure.fst_compProd,←Measure.map_prod_map _ _ measurable_fst measurable_id,Measure.map_id]
  rfl

def blockObservedInput {d m r : ℕ} {U : Type*}
    (z : (Rows (m+r) d×(Fin (m+r)→ℝ))×U) : U×(Rows m d×(Fin m→ℝ)) :=
  (z.2, (fun j => z.1.1 (Fin.castAdd r j)), (fun j => z.1.2 (Fin.castAdd r j)))

lemma measurable_blockObservedInput {d m r : ℕ} {U : Type*} [MeasurableSpace U] :
    Measurable (blockObservedInput (d:=d) (m:=m) (r:=r) (U:=U)) := by
  unfold blockObservedInput
  fun_prop

def blockExposedBaseMap {d m r : ℕ} {U : Type*}
    (z : ((Sphere d×U)×Rows m d)×Rows r d) :
    (Rows (m+r) d×(Fin (m+r)→ℝ))×(Sphere d×U) :=
  exposedJointMap (z.1.1,Fin.append z.1.2 z.2)

lemma measurable_blockExposedBaseMap {d m r : ℕ} {U : Type*} [MeasurableSpace U] :
    Measurable (blockExposedBaseMap (d:=d) (m:=m) (r:=r) (U:=U)) :=
  measurable_exposedJointMap.comp measurable_alignedMap

lemma blockObservedInput_exposed {d m r : ℕ} {U : Type*}
    (z : ((Sphere d×U)×Rows m d)×Rows r d) :
    blockObservedInput ((blockExposedBaseMap z).1,(blockExposedBaseMap z).2.2) = blockInput z.1 := by
  unfold blockObservedInput blockExposedBaseMap exposedJointMap blockInput
  congr 2
  · funext j; simp
  · funext j; simp [label]

lemma block_exposed_processed {d m r : ℕ} {U V : Type*} [MeasurableSpace U] [MeasurableSpace V]
    (P : Measure (Sphere d×U)) [IsProbabilityMeasure P]
    (κ : Kernel (U×(Rows m d×(Fin m→ℝ))) V) [IsMarkovKernel κ] :
    processedLaw ((P.prod (gaussianRows (m+r) d)).map exposedJointMap)
      (κ.comap (blockObservedInput (r:=r)) measurable_blockObservedInput) =
      (alignedExperiment (r:=r) (endingRowLaw P κ)).map exposedJointMap := by
  let μ := P.prod (gaussianRows m d)
  let γ := gaussianRows r d
  let K := κ.comap blockInput measurable_blockInput
  let H := blockExposedBaseMap (d:=d) (m:=m) (r:=r) (U:=U)
  have hH : Measurable H := measurable_blockExposedBaseMap
  have hInput : (μ.prod γ).map H = (P.prod (gaussianRows (m+r) d)).map exposedJointMap := by
    rw [←alignedExperiment_fresh (r:=r) (m:=m) P,alignedExperiment,
      Measure.map_map measurable_exposedJointMap measurable_alignedMap]
    rfl
  have hK : ((κ.comap (blockObservedInput (r:=r)) measurable_blockObservedInput).comap
      (Prod.map id Prod.snd) (measurable_id.prodMap measurable_snd)).comap H hH =
      K.comap Prod.fst measurable_fst := by
    ext z t ht
    change κ (blockObservedInput ((H z).1,(H z).2.2)) t = κ (blockInput z.1) t
    rw [show blockObservedInput ((H z).1,(H z).2.2) = blockInput z.1 from blockObservedInput_exposed z]
  rw [processedLaw,←hInput,compProd_map_base _ _ H hH,hK,
    Measure.map_map (measurable_fst.fst.prodMk (measurable_fst.snd.fst.prodMk measurable_snd))
      (hH.prodMap measurable_id),←compProd_independent_swap μ K γ,
    Measure.map_map ((measurable_fst.fst.prodMk (measurable_fst.snd.fst.prodMk measurable_snd)).comp
      (hH.prodMap measurable_id)) ((measurable_fst.fst.prodMk measurable_snd).prodMk measurable_fst.snd)]
  rw [alignedExperiment,Measure.map_map measurable_exposedJointMap measurable_alignedMap,actualExperiment,endingRowLaw]
  have he : ((blockLaw P κ).map (fun z => ((z.1.1.1,z.2),z.1.2))).prod (gaussianRows r d) =
      ((blockLaw P κ).prod (gaussianRows r d)).map (Prod.map (fun z => ((z.1.1.1,z.2),z.1.2)) id) := by
    rw [←Measure.map_prod_map _ _ measurable_endingRowMap measurable_id,Measure.map_id]
  rw [he,Measure.map_map (measurable_exposedJointMap.comp measurable_alignedMap)
    (measurable_endingRowMap.prodMap measurable_id)]
  rfl

lemma block_exposed_le_fresh {d m r : ℕ} {U V : Type*}
    [MeasurableSpace U] [MeasurableSpace V] [StandardBorelSpace U] [StandardBorelSpace V]
    [Nonempty U] [Nonempty V] [Nonempty (Sphere d)]
    (P : Measure (Sphere d×U)) [IsProbabilityMeasure P]
    (κ : Kernel (U×(Rows m d×(Fin m→ℝ))) V) [IsMarkovKernel κ] :
    exposedInformation (alignedExperiment (r:=r) (endingRowLaw P κ)) ≤ freshInformation P (m+r) := by
  let : IsProbabilityMeasure ((P.prod (gaussianRows (m+r) d)).map exposedJointMap) :=
    inferInstance
  have h := conditionalMutualInformation_processed_le ((P.prod (gaussianRows (m+r) d)).map exposedJointMap)
    (κ.comap (blockObservedInput (r:=r)) measurable_blockObservedInput)
  simpa only [block_exposed_processed,exposedInformation,freshInformation] using h



end CurrentProjection

end

end OAI