import OAI.Probability.GaussianReplacement.Telescopes

namespace OAI

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


lemma shannonEntropy_finite {W : Type*} [Fintype W] [MeasurableSpace W]
    [MeasurableSingletonClass W] (π : Measure W) [IsProbabilityMeasure π] :
    shannonEntropy π ≠ ∞ := by
  rw [shannonEntropy,lintegral_fintype]
  apply ENNReal.sum_ne_top.mpr
  intro w hw
  exact ENNReal.mul_ne_top ENNReal.ofReal_ne_top (measure_ne_top π _)

lemma freshInformation_finite {d k : ℕ} {W : Type*}
    [Fintype W] [MeasurableSpace W] [MeasurableSingletonClass W]
    [Nonempty W] [Nonempty (Sphere d)]
    (P : Measure (Sphere d×W)) [IsProbabilityMeasure P] : freshInformation P k ≠ ∞ := by
  apply exposedInformation_finite
  rw [Measure.fst_prod]
  exact shannonEntropy_finite P.snd

lemma hybrid_block_bound {d m : ℕ} (hd : 256 ≤ d) (hm : m ≤ d/8)
    {U V : Type*} [Fintype U] [Fintype V]
    [MeasurableSpace U] [MeasurableSpace V]
    [MeasurableSingletonClass U] [MeasurableSingletonClass V]
    (P : Measure (Sphere d×U)) [IsProbabilityMeasure P]
    (hS : P.fst = uniformSphere d)
    (κ : Kernel (U×(Rows m d×(Fin m→ℝ))) V) [IsMarkovKernel κ]
    {B : ℝ} (hB : 0 ≤ B)
    (hH : shannonEntropy (endingSignalLaw P κ).snd ≤ ENNReal.ofReal B) :
    averagedFreshInformation (endingSignalLaw P κ)-averagedFreshInformation P ≤
      hybridRowConstant*m+(m:ℝ)/hybridCount d*(16*hybridBaselineConstant+B/(d/8:ℕ))+B/(d/32:ℕ) := by
  let : IsProbabilityMeasure (uniformSphere d) := uniformSphere_probability_of_pos (by omega)
  let : Nonempty (Sphere d) := nonempty_of_isProbabilityMeasure (uniformSphere d)
  let : Nonempty U := nonempty_of_isProbabilityMeasure P.snd
  let : Nonempty V := nonempty_of_isProbabilityMeasure (endingSignalLaw P κ).snd
  have hi : ((endingRowLaw P κ).map swapLast).fst = (uniformSphere d).prod (gaussianRows m d) := by
    rw [endingRowLaw_independence,hS]
  have hh : shannonEntropy (endingRowLaw P κ).fst.snd ≤ ENNReal.ofReal B := by
    rwa [endingRowLaw_fst]
  have h := hybrid_average_ending (endingRowLaw P κ) hd hm hi hB hh
  simp_rw [exposedInformation_prefix_zero,endingRowLaw_fst] at h
  have hle : (∑ k ∈ Finset.Icc (hybridFirst d) (hybridLast d),
      (exposedInformation (alignedExperiment (r:=k-m) (endingRowLaw P κ))).toReal) / hybridCount d ≤
      averagedFreshInformation P := by
    apply div_le_div_of_nonneg_right _ (Nat.cast_nonneg _)
    apply Finset.sum_le_sum
    intro k hk
    have hkm : m ≤ k := by
      obtain ⟨hk,_⟩ := Finset.mem_Icc.mp hk
      unfold hybridFirst at hk
      omega
    have hl := block_exposed_le_fresh (r:=k-m) P κ
    have hfresh : freshInformation P (m+(k-m)) = freshInformation P k :=
      congrArg (freshInformation P) (Nat.add_sub_of_le hkm)
    rw [hfresh] at hl
    exact ENNReal.toReal_mono (freshInformation_finite P) hl
  change averagedFreshInformation (endingSignalLaw P κ) - _ ≤ _ at h
  linarith

lemma hybrid_block_numeric {d m : ℕ} {B C : ℝ}
    (hd : 256 ≤ d) (hm : m ≤ d/8) (hB : 0 ≤ B) (hBd : B ≤ (d:ℝ)^2)
    (hC : 0 ≤ C) :
    C*m+(m:ℝ)/hybridCount d*(C+B/(d/8:ℕ))+B/(d/32:ℕ) ≤ (100*C+100)*d := by
  have hh0 : (0:ℝ)<(d/8:ℕ) := by exact_mod_cast (show 0<d/8 by omega)
  have hq0 : (0:ℝ)<(d/32:ℕ) := by exact_mod_cast (show 0<d/32 by omega)
  have hN0 : (0:ℝ)<hybridCount d := by unfold hybridCount; positivity
  have hm0 : (0:ℝ) ≤ m := Nat.cast_nonneg m
  have hd0 : (0:ℝ) ≤ d := Nat.cast_nonneg d
  have hmd : (m:ℝ) ≤ d := by exact_mod_cast (show m≤d by omega)
  have hdh : (d:ℝ) ≤ 16*(d/8:ℕ) := by exact_mod_cast (show d≤16*(d/8) by omega)
  have hdq : (d:ℝ) ≤ 64*(d/32:ℕ) := by exact_mod_cast (show d≤64*(d/32) by omega)
  have hmN : (m:ℝ) ≤ hybridCount d := by
    exact_mod_cast (show m≤hybridCount d by unfold hybridCount hybridFirst hybridLast; omega)
  have hmN' : (m:ℝ)/hybridCount d ≤ 1 := (div_le_one hN0).mpr hmN
  have hBh : B/(d/8:ℕ) ≤ 16*d := by
    apply (div_le_iff₀ hh0).mpr
    nlinarith
  have hBq : B/(d/32:ℕ) ≤ 64*d := by
    apply (div_le_iff₀ hq0).mpr
    nlinarith
  have hmul : (m:ℝ)/hybridCount d*(C+B/(d/8:ℕ)) ≤ C+16*d := by
    calc
      _ ≤ 1*(C+B/(d/8:ℕ)) := mul_le_mul_of_nonneg_right hmN' (add_nonneg hC (div_nonneg hB hh0.le))
      _ ≤ C+16*d := by linarith
  have hCm := mul_le_mul_of_nonneg_left hmd hC
  have hd1 : (1:ℝ)≤d := by exact_mod_cast (show 1≤d by omega)
  nlinarith

theorem hybridBlockMain : HybridBlockMain := by
  let C := 1+|hybridRowConstant|+16*hybridBaselineConstant
  have hbase := hybridBaselineConstant_pos
  have hC : 0 < C := by dsimp [C]; positivity
  refine ⟨C,100*C+100,256,hC,by positivity,?_⟩
  intro d hd m hm1 hm U V _ _ _ _ _ _ P _ hS κ _ B hB hH
  have h := hybrid_block_bound hd hm P hS κ hB hH
  have hrow : hybridRowConstant ≤ C := by
    have h := le_abs_self hybridRowConstant
    dsimp [C]
    linarith
  have hbaseline : 16*hybridBaselineConstant ≤ C := by
    dsimp [C]
    linarith [abs_nonneg hybridRowConstant]
  have hbound : averagedFreshInformation (endingSignalLaw P κ)-averagedFreshInformation P ≤
    C*m+(m:ℝ)/hybridCount d*(C+B/(d/8:ℕ))+B/(d/32:ℕ) := by
    apply h.trans
    apply add_le_add _ le_rfl
    apply add_le_add
    · exact mul_le_mul_of_nonneg_right hrow (Nat.cast_nonneg _)
    · exact mul_le_mul_of_nonneg_left (add_le_add hbaseline le_rfl) (by positivity)
  refine ⟨hbound,fun hBd => hbound.trans (hybrid_block_numeric hd hm hB hBd hC.le)⟩



end CurrentProjection

end

end OAI