lean/OAI/Probability/GaussianReplacement/ArrayBounds.lean

import OAI.Probability.GaussianReplacement.RowOrder

namespace OAI

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


def arrayReference {d k : ℕ} {W : Type*} [MeasurableSpace W]
    (P : Measure ((Sphere d×W)×Rows k d)) : ℝ≥0∞ :=
  conditionalReferenceKL (observationSignalLaw P).fst (gaussianObservations k d)

lemma observationSignalLaw_fst_as_observed {d k : ℕ} {W : Type*} [MeasurableSpace W]
    (P : Measure ((Sphere d×W)×Rows k d)) :
    (observationSignalLaw P).fst = (observedMessage P).map
      (MeasurableEquiv.prodComm.trans ((MeasurableEquiv.refl W).prodCongr (observationEquiv k d))) := by
  rw [observationSignalLaw,Measure.fst,Measure.map_map measurable_fst measurable_observationSignalMap,
    observedMessage,Measure.map_map (MeasurableEquiv.measurable _) measurable_observedMessageMap]
  rfl

lemma arrayReference_eq {d k : ℕ} {W : Type*} [MeasurableSpace W]
    (P : Measure ((Sphere d×W)×Rows k d)) [IsProbabilityMeasure P] :
    arrayReference P = observationReferenceKL P := by
  let e := MeasurableEquiv.prodComm.trans ((MeasurableEquiv.refl W).prodCongr (observationEquiv k d))
  have href : (((gaussianRows k d).prod (gaussianLabels k)).prod P.fst.snd).map e =
      P.fst.snd.prod (gaussianObservations k d) := by
    change ((((gaussianRows k d).prod (gaussianLabels k)).prod P.fst.snd)).map
      ((Prod.map id (observationEquiv k d)) ∘ Prod.swap) = _
    rw [←Measure.map_map (measurable_id.prodMap (observationEquiv k d).measurable) measurable_swap,
      Measure.prod_swap,←Measure.map_prod_map _ _ measurable_id (observationEquiv k d).measurable,
      Measure.map_id,←gaussianObservations_eq]
  rw [arrayReference,conditionalReferenceKL,observationSignalLaw_context,
    observationSignalLaw_fst_as_observed,←href]
  exact klDiv_map_equiv _ _ e

lemma freshArrayLaw_assoc_first {d k r : ℕ} {W : Type*} [MeasurableSpace W]
    (P : Measure ((Sphere d×W)×Rows k d)) [IsProbabilityMeasure P] :
    ((freshArrayLaw (observationSignalLaw P) r).map MeasurableEquiv.prodAssoc).map
      (Prod.map id Prod.fst) = (observationSignalLaw P).fst := by
  rw [Measure.map_map (measurable_id.prodMap measurable_fst) MeasurableEquiv.prodAssoc.measurable]
  change (freshArrayLaw (observationSignalLaw P) r).fst = _
  rw [freshArrayLaw_fst]

lemma freshArrayLaw_aligned {d k r : ℕ} {W : Type*} [MeasurableSpace W]
    (P : Measure ((Sphere d×W)×Rows k d)) [IsProbabilityMeasure P] :
    ((freshArrayLaw (observationSignalLaw P) r).map MeasurableEquiv.prodAssoc).map
      (Prod.map id (appendEquiv (Vector d×ℝ) k r)) =
      (observationSignalLaw (alignedExperiment (r:=r) P)).fst := by
  rw [freshArrayLaw_eq,observationSignalLaw,
    show (P.map observationSignalMap).prod (gaussianRows r d) =
      (P.prod (gaussianRows r d)).map (Prod.map observationSignalMap id) by
        rw [←Measure.map_prod_map _ _ measurable_observationSignalMap measurable_id,Measure.map_id],
    Measure.map_map (by fun_prop) (measurable_observationSignalMap.prodMap measurable_id),
    Measure.map_map MeasurableEquiv.prodAssoc.measurable (by fun_prop),
    Measure.map_map (measurable_id.prodMap (appendEquiv _ _ _).measurable) (by fun_prop),
    observationSignalLaw,alignedExperiment,Measure.fst,
    Measure.map_map measurable_fst measurable_observationSignalMap,
    Measure.map_map (measurable_fst.comp measurable_observationSignalMap) measurable_alignedMap]
  congr 1
  funext z
  dsimp [actualExperiment,observationSignalMap]
  rw [ownObservations_append]
  rfl

lemma arrayReference_aligned {d k r : ℕ} {W : Type*} [MeasurableSpace W]
    (P : Measure ((Sphere d×W)×Rows k d)) [IsProbabilityMeasure P] :
    arrayReference (alignedExperiment (r:=r) P) =
      arrayReference P + freshReference (observationSignalLaw P) r := by
  let Q := (freshArrayLaw (observationSignalLaw P) r).map MeasurableEquiv.prodAssoc
  let : IsProbabilityMeasure Q := inferInstance
  have he := conditionalReferenceKL_outcome_equiv Q
    ((gaussianObservations k d).prod (gaussianObservations r d)) (appendEquiv (Vector d×ℝ) k r)
  rw [gaussianObservations_append] at he
  dsimp only [Q] at he
  rw [freshArrayLaw_aligned,conditionalReferenceKL_chain,freshArrayLaw_assoc_first,
    MeasurableEquiv.map_symm_map] at he
  exact he

lemma arrayReference_prefix_step {d m : ℕ} {W : Type*} [MeasurableSpace W]
    (P : Measure ((Sphere d×W)×Rows m d)) [IsProbabilityMeasure P] (i : ℕ) (hi : i < m) :
    arrayReference (prefixLaw P (i+1) (Nat.succ_le_of_lt hi)) =
      arrayReference (prefixLaw P i (Nat.le_of_lt hi)) + singleReference (nextActualRowLaw P i hi) := by
  let Q := (singleObservationLaw (nextActualRowLaw P i hi)).map MeasurableEquiv.prodAssoc
  let : IsProbabilityMeasure Q := inferInstance
  have hfirst : Q.map (Prod.map id Prod.fst) = (observationSignalLaw (prefixLaw P i (Nat.le_of_lt hi))).fst := by
    rw [Measure.map_map (measurable_id.prodMap measurable_fst) MeasurableEquiv.prodAssoc.measurable]
    change (singleObservationLaw (nextActualRowLaw P i hi)).fst = _
    rw [singleObservationLaw_fst,nextActualRowLaw_fst]
  have htotal : Q.map (Prod.map id (snocEquiv (Vector d×ℝ) i)) =
      (observationSignalLaw (prefixLaw P (i+1) (Nat.succ_le_of_lt hi))).fst := by
    have he := congrArg (fun μ : Measure ((W×Observations (i+1) d)×Sphere d) => μ.fst)
      (nextActualRowLaw_single P i hi)
    rw [Measure.fst,Measure.map_map measurable_fst ((MeasurableEquiv.measurable _).prodMap measurable_id)] at he
    dsimp only [Q,singleObservationLaw]
    rw [Measure.map_map (measurable_id.prodMap (snocEquiv _ _).measurable) MeasurableEquiv.prodAssoc.measurable,
      Measure.fst,Measure.map_map (by fun_prop) measurable_fst]
    exact he
  have he := conditionalReferenceKL_outcome_equiv Q
    ((gaussianObservations i d).prod (gaussianObservation d)) (snocEquiv (Vector d×ℝ) i)
  rw [show (((gaussianObservations i d).prod (gaussianObservation d)).map (snocEquiv (Vector d×ℝ) i)) =
      gaussianObservations (i+1) d from snocEquiv_map (gaussianObservation d) i,htotal,
    conditionalReferenceKL_chain,hfirst] at he
  dsimp only [Q] at he
  rw [MeasurableEquiv.map_symm_map] at he
  exact he



def baselineCost (d k : ℕ) : ℝ≥0∞ :=
  klDiv (projectionJoint (uniformSphere d) (gaussianRows k d))
    ((gaussianRows k d).prod (gaussianLabels k))

def hybridBaselineConstant : ℝ := 20 + |Real.log (normalizer 1)+1/2|

lemma hybridBaselineConstant_pos : 0 < hybridBaselineConstant := by
  unfold hybridBaselineConstant
  positivity

lemma baselineCost_finite {d k : ℕ} (hk : 2 ≤ k) (hkd : k < d-1) :
    baselineCost d k ≠ ∞ ∧ (baselineCost d k).toReal ≤ hybridBaselineConstant*d := by
  have hd : 2 ≤ d := by omega
  have hdim : AdmissibleDimensions d 1 (k-1) 1 := by
    unfold AdmissibleDimensions
    omega
  have he : 1+(k-1) = k := by omega
  have h := sphere_projection_reference_finite hdim hd
  rw [he] at h
  refine ⟨h.1,h.2.trans ?_⟩
  have hcast : (k:ℝ) ≤ d := by exact_mod_cast (show k ≤ d by omega)
  have hg := le_abs_self (Real.log (normalizer 1)+1/2)
  have hg0 := abs_nonneg (Real.log (normalizer 1)+1/2)
  dsimp [hybridBaselineConstant]
  nlinarith

lemma arrayReference_finite_bound {d k : ℕ} {W : Type*}
    [MeasurableSpace W] [StandardBorelSpace W] [Nonempty W]
    [Countable W] [MeasurableSingletonClass W]
    (P : Measure ((Sphere d×W)×Rows k d)) [IsProbabilityMeasure P]
    (hd : 1 ≤ d) (hInd : (P.map swapLast).fst = (uniformSphere d).prod (gaussianRows k d))
    {B : ℝ} (hB : 0 ≤ B) (hH : shannonEntropy P.fst.snd ≤ ENNReal.ofReal B)
    (hk : 2 ≤ k) (hkd : k < d-1) :
    arrayReference P ≠ ∞ ∧ (arrayReference P).toReal ≤ hybridBaselineConstant*d+B := by
  let : IsProbabilityMeasure (uniformSphere d) := uniformSphere_probability_of_pos hd
  have hHf : shannonEntropy (observedMessage P).snd ≠ ∞ := by
    rw [observedMessage_snd]
    exact ne_top_of_le_ne_top ENNReal.ofReal_ne_top hH
  have hI := countable_information_le_entropy (observedMessage P) hHf
  have hbase := baselineCost_finite hk hkd
  rw [arrayReference_eq,observationReferenceKL_decomposition P (uniformSphere d) hInd]
  change baselineCost d k + mutualInformation (observedMessage P) ≠ ∞ ∧
    (baselineCost d k + mutualInformation (observedMessage P)).toReal ≤ hybridBaselineConstant*d+B
  have hIf : mutualInformation (observedMessage P) ≠ ∞ := hI.1
  refine ⟨ENNReal.add_ne_top.mpr ⟨hbase.1,hI.1⟩,?_⟩
  rw [ENNReal.toReal_add hbase.1 hIf]
  have hHb := ENNReal.toReal_mono ENNReal.ofReal_ne_top hH
  rw [ENNReal.toReal_ofReal hB] at hHb
  apply add_le_add hbase.2
  apply hI.2.trans
  simpa only [observedMessage_snd] using hHb

lemma arrayReference_exposed_chain {d k : ℕ} {W : Type*}
    [MeasurableSpace W] [StandardBorelSpace W] [Nonempty W] [Nonempty (Sphere d)]
    (P : Measure ((Sphere d×W)×Rows k d)) [IsProbabilityMeasure P]
    (hd : 1 ≤ d) (hInd : (P.map swapLast).fst = (uniformSphere d).prod (gaussianRows k d)) :
    arrayReference P + exposedInformation P =
      baselineCost d k + mutualInformation P.fst + rowInformation P (gaussianRows k d) := by
  let : IsProbabilityMeasure (uniformSphere d) := uniformSphere_probability_of_pos hd
  rw [arrayReference_eq]
  exact observationReferenceKL_chain_exposed P (uniformSphere d) hInd

lemma exposedInformation_finite {d k : ℕ} {W : Type*}
    [MeasurableSpace W] [StandardBorelSpace W] [Nonempty W] [Nonempty (Sphere d)]
    [Countable W] [MeasurableSingletonClass W]
    (P : Measure ((Sphere d×W)×Rows k d)) [IsProbabilityMeasure P]
    (hH : shannonEntropy P.fst.snd ≠ ∞) : exposedInformation P ≠ ∞ := by
  have he := exposedInformation_chain P
  let : IsProbabilityMeasure (P.map swapLast) := inferInstance
  have hi := countable_information_le_entropy (P.map swapLast) (by rwa [swapLast_snd])
  exact ne_top_of_le_ne_top hi.1 (by change exposedInformation P ≤ mutualInformation (P.map swapLast); rw [he]; exact le_add_left le_rfl)

lemma rowInformation_finite_bound {d k : ℕ} {W : Type*}
    [MeasurableSpace W] [Countable W] [MeasurableSingletonClass W]
    (P : Measure ((Sphere d×W)×Rows k d)) [IsProbabilityMeasure P]
    (hd : 1 ≤ d) (hInd : (P.map swapLast).fst = (uniformSphere d).prod (gaussianRows k d))
    {B : ℝ} (hB : 0 ≤ B) (hH : shannonEntropy P.fst.snd ≤ ENNReal.ofReal B) :
    rowInformation P (gaussianRows k d) ≠ ∞ ∧ (rowInformation P (gaussianRows k d)).toReal ≤ B := by
  let : IsProbabilityMeasure (uniformSphere d) := uniformSphere_probability_of_pos hd
  have h := rowInformation_le_entropy P (uniformSphere d) (gaussianRows k d) hInd
    (by rw [swapLast_snd]; exact ne_top_of_le_ne_top ENNReal.ofReal_ne_top hH)
  rw [swapLast_snd] at h
  have hHb := ENNReal.toReal_mono ENNReal.ofReal_ne_top hH
  rw [ENNReal.toReal_ofReal hB] at hHb
  exact ⟨h.1,h.2.trans hHb⟩

lemma freshReference_from_array_bound {d i r : ℕ} {W : Type*}
    [MeasurableSpace W] [StandardBorelSpace W] [Nonempty W]
    [Countable W] [MeasurableSingletonClass W]
    (P : Measure ((Sphere d×W)×Rows i d)) [IsProbabilityMeasure P]
    (hd : 1 ≤ d) (hInd : (P.map swapLast).fst = (uniformSphere d).prod (gaussianRows i d))
    {B : ℝ} (hB : 0 ≤ B) (hH : shannonEntropy P.fst.snd ≤ ENNReal.ofReal B)
    (hk : 2 ≤ i+r) (hkd : i+r < d-1) :
    freshReference (observationSignalLaw P) r ≠ ∞ ∧
      (freshReference (observationSignalLaw P) r).toReal ≤ hybridBaselineConstant*d+B := by
  let : IsProbabilityMeasure (uniformSphere d) := uniformSphere_probability_of_pos hd
  have h := arrayReference_finite_bound (alignedExperiment (r:=r) P) hd
    (alignedExperiment_independence P (uniformSphere d) hInd) hB
    (by rwa [alignedExperiment_fst]) hk hkd
  have hl : freshReference (observationSignalLaw P) r ≤ arrayReference (alignedExperiment (r:=r) P) := by
    rw [arrayReference_aligned]
    exact le_add_left le_rfl
  exact ⟨ne_top_of_le_ne_top h.1 hl,(ENNReal.toReal_mono h.1 hl).trans h.2⟩

lemma freshSlope_from_array_bound {d i r : ℕ} {W : Type*}
    [MeasurableSpace W] [StandardBorelSpace W] [Nonempty W]
    [Countable W] [MeasurableSingletonClass W]
    (P : Measure ((Sphere d×W)×Rows i d)) [IsProbabilityMeasure P]
    (hd : 16 ≤ d) (hInd : (P.map swapLast).fst = (uniformSphere d).prod (gaussianRows i d))
    {B : ℝ} (hB : 0 ≤ B) (hH : shannonEntropy P.fst.snd ≤ ENNReal.ofReal B)
    (hk : 2 ≤ i+r+d/8) (hkd : i+r+d/8 < d-1) :
    freshSlope (observationSignalLaw P) r ≠ ∞ ∧
      (freshSlope (observationSignalLaw P) r).toReal ≤ 16*hybridBaselineConstant+B/(d/8:ℕ) := by
  have h := freshReference_from_array_bound (r:=r+d/8) P (by omega) hInd hB hH (by omega) (by omega)
  have ha := freshSlope_average (observationSignalLaw P) r (d/8) (by omega) h.1
  refine ⟨ha.1,ha.2.trans ?_⟩
  have hp : (0:ℝ)<(d/8:ℕ) := by exact_mod_cast (show 0<d/8 by omega)
  have hratio : (d:ℝ) ≤ 16*(d/8:ℕ) := by exact_mod_cast (show d ≤ 16*(d/8) by omega)
  have hbpos := hybridBaselineConstant_pos
  apply (div_le_iff₀ hp).mpr
  calc
    (freshReference (observationSignalLaw P) (r+d/8)).toReal ≤ hybridBaselineConstant*d+B := h.2
    _ ≤ (16*hybridBaselineConstant+B/(d/8:ℕ))*(d/8:ℕ) := by
      rw [add_mul,div_mul_cancel₀ _ hp.ne']
      nlinarith


lemma arrayReference_actual_step {d m : ℕ} {W : Type*} [MeasurableSpace W]
    (P : Measure ((Sphere d×W)×Rows m d)) [IsProbabilityMeasure P] (i : ℕ) (hi : i < m) (r : ℕ) :
    arrayReference (alignedExperiment (r:=r) (prefixLaw P (i+1) (Nat.succ_le_of_lt hi))) =
      arrayReference (alignedExperiment (r:=r) (prefixLaw P i (Nat.le_of_lt hi))) +
      singleReference (liftActualLaw (nextActualRowLaw P i hi) r) := by
  have hc : freshReference (observationSignalLaw (prefixLaw P (i+1) (Nat.succ_le_of_lt hi))) r =
      freshReference (singleSignalLaw (nextActualRowLaw P i hi)) r := by
    rw [←nextActualRowLaw_single P i hi]
    exact freshReference_context _ _ _
  rw [arrayReference_aligned,arrayReference_aligned,arrayReference_prefix_step,hc,add_assoc,
    actual_fresh_diamond,nextActualRowLaw_fst,←add_assoc]

lemma nextActualRowLaw_signal_row {d m : ℕ} {W : Type*} [MeasurableSpace W]
    (P : Measure ((Sphere d×W)×Rows m d)) [IsProbabilityMeasure P]
    (ν : Measure (Sphere d)) [IsProbabilityMeasure ν]
    (hInd : (P.map swapLast).fst = ν.prod (gaussianRows m d)) (i : ℕ) (hi : i < m) :
    (nextActualRowLaw P i hi).map (fun z => (z.1.2,z.2)) = ν.prod (stdGaussian (Vector d)) := by
  have he := congrArg (fun μ : Measure (Sphere d×Rows m d) => μ.map (Prod.map id (fun X => X ⟨i,hi⟩))) hInd
  rw [←Measure.map_prod_map _ _ measurable_id (measurable_pi_apply _),Measure.map_id] at he
  have hev : (gaussianRows m d).map (fun X => X ⟨i,hi⟩) = stdGaussian (Vector d) :=
    (measurePreserving_eval (fun _ : Fin m => stdGaussian (Vector d)) ⟨i,hi⟩).map_eq
  rw [hev] at he
  rw [nextActualRowLaw,Measure.map_map (measurable_fst.snd.prodMk measurable_snd) (measurable_nextActualRow hi)]
  rw [Measure.fst,Measure.map_map measurable_fst swapLast.measurable,
    Measure.map_map (measurable_id.prodMap (measurable_pi_apply _)) (measurable_fst.comp swapLast.measurable)] at he
  exact he

lemma gaussian_sphere_inner_mixture {d : ℕ} (ν : Measure (Sphere d)) [IsProbabilityMeasure ν] :
    (ν.prod (stdGaussian (Vector d))).map (fun z => ⟪(z.1:Vector d),z.2⟫) = gaussianReal 0 1 := by
  ext t ht
  rw [Measure.map_apply (by fun_prop) ht,Measure.prod_apply (ht.preimage (by fun_prop))]
  have he (s : Sphere d) : stdGaussian (Vector d) {x | ⟪(s:Vector d),x⟫ ∈ t} = gaussianReal 0 1 t := by
    have h := congrArg (fun μ : Measure ℝ => μ t) (gaussian_inner_map_sphere s)
    rwa [Measure.map_apply (by fun_prop) ht] at h
  change (∫⁻ s : Sphere d, stdGaussian (Vector d) {x | ⟪(s:Vector d),x⟫ ∈ t} ∂ν) = _
  simp_rw [he]
  simp

lemma nextActualRowLaw_label {d m : ℕ} {W : Type*} [MeasurableSpace W]
    (P : Measure ((Sphere d×W)×Rows m d)) [IsProbabilityMeasure P]
    (ν : Measure (Sphere d)) [IsProbabilityMeasure ν]
    (hInd : (P.map swapLast).fst = ν.prod (gaussianRows m d)) (i : ℕ) (hi : i < m) (r : ℕ) :
    (residualLabelLaw (nextActualRowLaw P i hi) r).snd = gaussianReal 0 1 := by
  rw [residualLabelLaw,Measure.snd,Measure.map_map measurable_snd measurable_residualLabelObservation]
  have hel : Measurable (fun z : ((W×Observations i d)×Sphere d)×Vector d => ⟪(z.1.2:Vector d),z.2⟫) := by fun_prop
  change ((nextActualRowLaw P i hi).prod (gaussianRows r d)).map ((fun z => ⟪(z.1.2:Vector d),z.2⟫) ∘ Prod.fst) = _
  rw [←Measure.map_map hel measurable_fst,←Measure.fst,Measure.fst_prod]
  have he := congrArg (fun μ : Measure (Sphere d×Vector d) => μ.map (fun z => ⟪(z.1:Vector d),z.2⟫))
    (nextActualRowLaw_signal_row P ν hInd i hi)
  rw [Measure.map_map (by fun_prop) (measurable_fst.snd.prodMk measurable_snd),gaussian_sphere_inner_mixture] at he
  exact he

lemma hybrid_one_step {d m i r q : ℕ} {W : Type*}
    [MeasurableSpace W] [StandardBorelSpace W] [Nonempty W]
    [Countable W] [MeasurableSingletonClass W]
    (P : Measure ((Sphere d×W)×Rows m d)) [IsProbabilityMeasure P]
    (hd : 16 ≤ d) (hInd : (P.map swapLast).fst = (uniformSphere d).prod (gaussianRows m d))
    {B : ℝ} (hB : 0 ≤ B) (hH : shannonEntropy P.fst.snd ≤ ENNReal.ofReal B)
    (hi : i < m) (hr : r ≤ d) (hd8 : d ≤ 8*r) (hq : 1 ≤ q)
    (hqr : 2*q ≤ r) (hmargin : 2 ≤ r-q) (htotal : i+r+2 < d-1) :
    (exposedInformation (alignedExperiment (r:=r+1) (prefixLaw P i (Nat.le_of_lt hi)))).toReal -
      (exposedInformation (alignedExperiment (r:=r) (prefixLaw P (i+1) (Nat.succ_le_of_lt hi)))).toReal ≤
        hybridRowConstant +
        (klDiv (nextActualRowLaw P i hi) ((nextActualRowLaw P i hi).fst.prod (stdGaussian (Vector d)))).toReal/q +
        (freshSlope (observationSignalLaw (prefixLaw P i (Nat.le_of_lt hi))) (r+1)).toReal -
        (freshSlope (observationSignalLaw (prefixLaw P i (Nat.le_of_lt hi))) r).toReal := by
  let : IsProbabilityMeasure (uniformSphere d) := uniformSphere_probability_of_pos (by omega)
  let : Nonempty (Sphere d) := nonempty_of_isProbabilityMeasure (uniformSphere d)
  let P0 := prefixLaw P i (Nat.le_of_lt hi)
  let P1 := prefixLaw P (i+1) (Nat.succ_le_of_lt hi)
  have hI0 : (P0.map swapLast).fst = (uniformSphere d).prod (gaussianRows i d) :=
    prefixLaw_independence P (uniformSphere d) hInd _ _
  have hI1 : (P1.map swapLast).fst = (uniformSphere d).prod (gaussianRows (i+1) d) :=
    prefixLaw_independence P (uniformSphere d) hInd _ _
  have hH0 : shannonEntropy P0.fst.snd ≤ ENNReal.ofReal B := by rwa [prefixLaw_fst]
  have hH1 : shannonEntropy P1.fst.snd ≤ ENNReal.ofReal B := by rwa [prefixLaw_fst]
  have hR0 := rowInformation_finite_bound P0 (by omega) hI0 hB hH0
  have hR1 := rowInformation_finite_bound P1 (by omega) hI1 hB hH1
  have hKchain := prefix_rowInformation_step P i hi
  change rowInformation P1 _ = rowInformation P0 _ + _ at hKchain
  have hK : klDiv (nextActualRowLaw P i hi) ((nextActualRowLaw P i hi).fst.prod (stdGaussian (Vector d))) ≠ ∞ :=
    ne_top_of_le_ne_top hR1.1 (by rw [hKchain]; exact le_add_left le_rfl)
  have hF0 := freshReference_from_array_bound (r:=r+1) P0 (by omega) hI0 hB hH0 (by omega) (by omega)
  have hF1 := freshReference_from_array_bound (r:=r+1+1) P0 (by omega) hI0 hB hH0 (by omega) (by omega)
  have hT0 := (freshSlope_average (observationSignalLaw P0) r 1 (by omega) hF0.1).1
  have hT1 := (freshSlope_average (observationSignalLaw P0) (r+1) 1 (by omega) hF1.1).1
  have hcross := actual_fresh_row_bound (nextActualRowLaw P i hi) hK hr hd8 hq hqr hmargin
    (by rwa [nextActualRowLaw_fst]) (by rwa [nextActualRowLaw_fst])
    (nextActualRowLaw_label P (uniformSphere d) hInd i hi r)
  rw [nextActualRowLaw_fst] at hcross
  have hA0 := arrayReference_finite_bound (alignedExperiment (r:=r) P0) (by omega)
    (alignedExperiment_independence P0 (uniformSphere d) hI0) hB (by rwa [alignedExperiment_fst]) (by omega) (by omega)
  have hAl := arrayReference_finite_bound (alignedExperiment (r:=r+1) P0) (by omega)
    (alignedExperiment_independence P0 (uniformSphere d) hI0) hB (by rwa [alignedExperiment_fst]) (by omega) (by omega)
  have hAr := arrayReference_finite_bound (alignedExperiment (r:=r) P1) (by omega)
    (alignedExperiment_independence P1 (uniformSphere d) hI1) hB (by rwa [alignedExperiment_fst]) (by omega) (by omega)
  have hJ0 := exposedInformation_finite (alignedExperiment (r:=r+1) P0)
    (by rw [alignedExperiment_fst]; exact ne_top_of_le_ne_top ENNReal.ofReal_ne_top hH0)
  have hJ1 := exposedInformation_finite (alignedExperiment (r:=r) P1)
    (by rw [alignedExperiment_fst]; exact ne_top_of_le_ne_top ENNReal.ofReal_ne_top hH1)
  have hMI : mutualInformation P.fst ≠ ∞ := (countable_information_le_entropy P.fst (ne_top_of_le_ne_top ENNReal.ofReal_ne_top hH)).1
  have hbase := (baselineCost_finite (d:=d) (k:=i+(r+1)) (by omega) (by omega)).1
  have hc0 := arrayReference_exposed_chain (alignedExperiment (r:=r+1) P0) (by omega)
    (alignedExperiment_independence P0 (uniformSphere d) hI0)
  have hc1 := arrayReference_exposed_chain (alignedExperiment (r:=r) P1) (by omega)
    (alignedExperiment_independence P1 (uniformSphere d) hI1)
  rw [alignedExperiment_fst,rowInformation_alignedExperiment] at hc0 hc1
  change _ = baselineCost d (i+(r+1)) + mutualInformation P0.fst + _ at hc0
  change _ = baselineCost d (i+1+r) + mutualInformation P1.fst + _ at hc1
  have hPf0 : P0.fst = P.fst := prefixLaw_fst _ _ _
  have hPf1 : P1.fst = P.fst := prefixLaw_fst _ _ _
  rw [hPf0] at hc0
  have hbe : baselineCost d (i+1+r) = baselineCost d (i+(r+1)) := congrArg (baselineCost d) (by omega)
  rw [hPf1,hbe] at hc1
  have hc0r := congrArg ENNReal.toReal hc0
  have hc1r := congrArg ENNReal.toReal hc1
  rw [ENNReal.toReal_add hAl.1 hJ0,ENNReal.toReal_add (ENNReal.add_ne_top.mpr ⟨hbase,hMI⟩) hR0.1,
    ENNReal.toReal_add hbase hMI] at hc0r
  rw [ENNReal.toReal_add hAr.1 hJ1,ENNReal.toReal_add (ENNReal.add_ne_top.mpr ⟨hbase,hMI⟩) hR1.1,
    ENNReal.toReal_add hbase hMI] at hc1r
  have hKreal := congrArg ENNReal.toReal hKchain
  rw [ENNReal.toReal_add hR0.1 hK] at hKreal
  have har := arrayReference_actual_step P i hi r
  have harr := congrArg ENNReal.toReal har
  rw [ENNReal.toReal_add hA0.1 hcross.1] at harr
  have hal : arrayReference (alignedExperiment (r:=r+1) P0) =
      arrayReference (alignedExperiment (r:=r) P0) + freshSlope (observationSignalLaw P0) r := by
    rw [arrayReference_aligned,arrayReference_aligned,freshReference_succ,add_assoc]
  have halr := congrArg ENNReal.toReal hal
  rw [ENNReal.toReal_add hA0.1 hT0] at halr
  change _ ≤ hybridRowConstant + _ + (freshSlope (observationSignalLaw P0) (r+1)).toReal -
    (freshSlope (observationSignalLaw P0) r).toReal
  rw [nextActualRowLaw_fst] at hKreal ⊢
  linarith [hcross.2]



end CurrentProjection

end

end OAI