import Mathlib
import OAI.Probability.Ballisticity.Estimates.MeasurableCountableSample

namespace OAI

section
open MeasureTheory ProbabilityTheory Filter
open scoped ENNReal NNReal Topology BigOperators

namespace TailDecorrelation

section Randomization
variable {D I A J E : Type*} [MeasurableSpace D] [MeasurableSpace A]
variable [MeasurableSpace E] [MeasurableSpace J] [Countable J] [MeasurableSingletonClass J]
variable (δ : Measure D) (σ : Measure E) (ν : Measure A)
variable [IsProbabilityMeasure δ] [IsProbabilityMeasure σ] [IsProbabilityMeasure ν]

lemma randomization_projection_preserving :
    MeasurePreserving (fun x : (D × E) × (I → A) => (x.1.1, x.2))
      ((δ.prod σ).prod (Measure.infinitePi (fun _ : I => ν)))
      (δ.prod (Measure.infinitePi (fun _ : I => ν))) := by
  exact measurePreserving_fst.prod (MeasurePreserving.id _)

lemma randomized_density {f : D × (I → A) → ℝ}
    (hf : Measurable f) (hfi : Integrable f (δ.prod (Measure.infinitePi (fun _ : I => ν))))
    (hH : Integrable (fun x => entropyPlus (f x)) (δ.prod (Measure.infinitePi (fun _ : I => ν)))) :
    Integrable (fun x : (D × E) × (I → A) => f (x.1.1, x.2))
      ((δ.prod σ).prod (Measure.infinitePi (fun _ : I => ν))) ∧
    Integrable (fun x : (D × E) × (I → A) => entropyPlus (f (x.1.1, x.2)))
      ((δ.prod σ).prod (Measure.infinitePi (fun _ : I => ν))) ∧
    (∫ x : (D × E) × (I → A), f (x.1.1, x.2)
      ∂(δ.prod σ).prod (Measure.infinitePi (fun _ : I => ν))) =
      (∫ x, f x ∂δ.prod (Measure.infinitePi (fun _ : I => ν))) := by
  have hp := randomization_projection_preserving δ σ ν (I := I)
  refine ⟨(hp.integrable_comp hf.aestronglyMeasurable).mpr hfi,
    (hp.integrable_comp (measurable_entropyPlus.comp hf).aestronglyMeasurable).mpr hH, ?_⟩
  have hh : AEStronglyMeasurable f
      (((δ.prod σ).prod (Measure.infinitePi (fun _ : I => ν))).map
        (fun x : (D × E) × (I → A) => (x.1.1, x.2))) := by
    rw [hp.map_eq]
    exact hf.aestronglyMeasurable
  have he := integral_map hp.measurable.aemeasurable hh
  rw [hp.map_eq] at he
  exact he.symm

end Randomization
end TailDecorrelation

namespace TailDecorrelation

lemma measurableSet_eventually_nat {X : Type*} [MeasurableSpace X]
    {p : ℕ → X → Prop} (hp : ∀ n, MeasurableSet {x | p n x}) :
    MeasurableSet {x | ∀ᶠ n in atTop, p n x} := by
  simp only [eventually_atTop, Set.ofPred_exists, Set.ofPred_forall]
  exact MeasurableSet.iUnion fun n => MeasurableSet.iInter fun m =>
    MeasurableSet.iInter fun _ => hp m

section KernelTransfer
variable {D E W J : Type*} [MeasurableSpace D] [MeasurableSpace E]
variable [MeasurableSpace W] [MeasurableSpace J] [Countable J] [MeasurableSingletonClass J]
variable (δ : Measure D) (σ : Measure E) (P : Measure W)
variable [IsProbabilityMeasure δ] [IsProbabilityMeasure σ] [IsProbabilityMeasure P]

lemma integral_comp_preserving {X Y : Type*} [MeasurableSpace X] [MeasurableSpace Y]
    {μ : Measure X} {ρ : Measure Y} {T : X → Y} (hT : MeasurePreserving T μ ρ)
    {g : Y → ℝ} (hg : Measurable g) :
    (∫ x, g (T x) ∂μ) = ∫ y, g y ∂ρ := by
  have hm : AEStronglyMeasurable g (μ.map T) := by
    rw [hT.map_eq]
    exact hg.aestronglyMeasurable
  have he := integral_map hT.measurable.aemeasurable hm
  rw [hT.map_eq] at he
  exact he.symm

lemma swap_seed_preserving :
    MeasurePreserving (fun x : (D × W) × E => ((x.1.1,x.2),x.1.2))
      ((δ.prod P).prod σ) ((δ.prod σ).prod P) := by
  exact ((measurePreserving_prodAssoc δ σ P).symm MeasurableEquiv.prodAssoc).comp
    (((MeasurePreserving.id δ).prod Measure.measurePreserving_swap).comp
      (measurePreserving_prodAssoc δ P σ))

lemma sampled_kernel_integral (κ : Kernel D J) (s : D → E → J)
    (hs : Measurable (Function.uncurry s)) (hmap : ∀ d, σ.map (s d) = κ d)
    {f : D × W → ℝ} (hf : Measurable f) {Z : J → W → ℝ}
    (hZ : ∀ a, Measurable (Z a))
    (hi : Integrable (fun x : (D × E) × W => f (x.1.1,x.2) * Z (s x.1.1 x.1.2) x.2)
      ((δ.prod σ).prod P)) :
    (∫ x : (D × E) × W, f (x.1.1,x.2) * Z (s x.1.1 x.1.2) x.2 ∂(δ.prod σ).prod P) =
      (∫ x : D × W, f x * (∫ a, Z a x.2 ∂κ x.1) ∂δ.prod P) := by
  have hz : Measurable (Function.uncurry Z) := measurable_from_prod_countable_right hZ
  let G : (D × E) × W → ℝ := fun x => f (x.1.1,x.2) * Z (s x.1.1 x.1.2) x.2
  have hG : Measurable G :=
    (hf.comp ((measurable_fst.comp measurable_fst).prodMk measurable_snd)).mul
      (hz.comp ((hs.comp measurable_fst).prodMk measurable_snd))
  have hp := swap_seed_preserving δ σ P
  have hj : Integrable (fun x : (D × W) × E => f x.1 * Z (s x.1.1 x.2) x.1.2)
      ((δ.prod P).prod σ) := (hp.integrable_comp hG.aestronglyMeasurable).mpr hi
  rw [← integral_comp_preserving hp hG]
  change (∫ x : (D × W) × E, f x.1 * Z (s x.1.1 x.2) x.1.2 ∂(δ.prod P).prod σ) = _
  rw [integral_prod _ hj]
  apply integral_congr_ae
  apply Eventually.of_forall
  intro x
  change (∫ u, f x * Z (s x.1 u) x.2 ∂σ) = f x * (∫ a, Z a x.2 ∂κ x.1)
  rw [integral_const_mul]
  congr 1
  have he := integral_map ((hs.comp measurable_prodMk_left).aemeasurable)
    (show AEStronglyMeasurable (fun a => Z a x.2) (σ.map (s x.1)) from
      Measurable.of_discrete.aestronglyMeasurable)
  change (∫ a, Z a x.2 ∂σ.map (s x.1)) = (∫ u, Z (s x.1 u) x.2 ∂σ) at he
  rw [hmap] at he
  exact he.symm

lemma sampled_kernel_integrable (κ : Kernel D J) (s : D → E → J)
    (hs : Measurable (Function.uncurry s)) (hmap : ∀ d, σ.map (s d) = κ d)
    {f : D × W → ℝ} (hf : Measurable f) {Z : J → W → ℝ}
    (hZ : ∀ a, Measurable (Z a))
    (hi : Integrable (fun x : (D × E) × W => f (x.1.1,x.2) * Z (s x.1.1 x.1.2) x.2)
      ((δ.prod σ).prod P)) :
    Integrable (fun x : D × W => f x * (∫ a, Z a x.2 ∂κ x.1)) (δ.prod P) := by
  have hz : Measurable (Function.uncurry Z) := measurable_from_prod_countable_right hZ
  let G : (D × E) × W → ℝ := fun x => f (x.1.1,x.2) * Z (s x.1.1 x.1.2) x.2
  have hG : Measurable G :=
    (hf.comp ((measurable_fst.comp measurable_fst).prodMk measurable_snd)).mul
      (hz.comp ((hs.comp measurable_fst).prodMk measurable_snd))
  have hp := swap_seed_preserving δ σ P
  have hj : Integrable (fun x : (D × W) × E => f x.1 * Z (s x.1.1 x.2) x.1.2)
      ((δ.prod P).prod σ) := (hp.integrable_comp hG.aestronglyMeasurable).mpr hi
  apply hj.integral_prod_left.congr
  apply Eventually.of_forall
  intro x
  change (∫ u, f x * Z (s x.1 u) x.2 ∂σ) = f x * (∫ a, Z a x.2 ∂κ x.1)
  rw [integral_const_mul]
  congr 1
  have he := integral_map ((hs.comp measurable_prodMk_left).aemeasurable)
    (show AEStronglyMeasurable (fun a => Z a x.2) (σ.map (s x.1)) from
      Measurable.of_discrete.aestronglyMeasurable)
  change (∫ a, Z a x.2 ∂σ.map (s x.1)) = (∫ u, Z (s x.1 u) x.2 ∂σ) at he
  rw [hmap] at he
  exact he.symm

omit [IsProbabilityMeasure δ] in
lemma kernel_escape_sampled (κ : ℕ → Kernel D J) (s : ℕ → D → E → J)
    (hs : ∀ r, Measurable (Function.uncurry (s r)))
    (hmap : ∀ r d, σ.map (s r d) = κ r d)
    (good : ℕ → J → Prop)
    (hesc : ∀ᵐ d ∂δ, ∀ᶠ r in atTop, ∀ᵐ a ∂κ r d, good r a) :
    ∀ᵐ x ∂δ.prod σ, ∀ᶠ r in atTop, good r (s r x.1 x.2) := by
  have hm : ∀ r, MeasurableSet {x : D × E | good r (s r x.1 x.2)} := fun r =>
    (hs r) (Set.to_countable _).measurableSet
  apply (Measure.ae_prod_iff_ae_ae (measurableSet_eventually_nat hm)).mpr
  filter_upwards [hesc] with d hd
  obtain ⟨N,hN⟩ := eventually_atTop.mp hd
  have hforall : ∀ r : ℕ, ∀ᵐ u ∂σ, N ≤ r → good r (s r d u) := by
    intro r
    by_cases hr : N ≤ r
    · have hh := hN r hr
      rw [← hmap r d] at hh
      have htrans := (ae_map_iff (hs r |>.comp measurable_prodMk_left |>.aemeasurable)
        (Set.to_countable _).measurableSet).mp hh
      exact htrans.mono fun u hu _ => hu
    · exact Eventually.of_forall fun _ h => (hr h).elim
  filter_upwards [ae_all_iff.mpr hforall] with u hu
  exact eventually_atTop.mpr ⟨N,hu⟩

end KernelTransfer
end TailDecorrelation

namespace TailDecorrelation
section KernelCompletion
variable {D I A J : Type*} [MeasurableSpace D] [MeasurableSpace A] [Encodable I]
variable [MeasurableSpace J] [Countable J] [MeasurableSingletonClass J]
variable [Nonempty J] [StandardBorelSpace J]
variable (δ : Measure D) (ν : Measure A) [IsProbabilityMeasure δ] [IsProbabilityMeasure ν]

omit [Encodable I] in
lemma kernel_density_integrable {f : D × (I → A) → ℝ} {Z : J → (I → A) → ℝ}
    {c Q : ℝ} (hc : 0 < c)
    (hf : Measurable f) (hf0 : ∀ x, 0 ≤ f x)
    (hfi : Integrable f (δ.prod (Measure.infinitePi (fun _ : I => ν))))
    (hH : Integrable (fun x => entropyPlus (f x)) (δ.prod (Measure.infinitePi (fun _ : I => ν))))
    (hZ : ∀ a, Measurable (Z a)) (hZ0 : ∀ a ω, 0 ≤ Z a ω)
    (he : ∀ a, Integrable (fun ω => Real.exp (c * Z a ω)) (Measure.infinitePi (fun _ : I => ν)))
    (heQ : ∀ a, (∫ ω, Real.exp (c * Z a ω) ∂Measure.infinitePi (fun _ : I => ν)) ≤ Q)
    (κ : Kernel D J) [IsMarkovKernel κ] :
    Integrable (fun x : D × (I → A) => f x * (∫ a, Z a x.2 ∂κ x.1))
      (δ.prod (Measure.infinitePi (fun _ : I => ν))) := by
  obtain ⟨s,hs,hmap⟩ := Kernel.exists_measurable_map_eq_unitInterval κ
  let σ : Measure unitInterval := volume
  let g : (D × unitInterval) × (I → A) → ℝ := fun x => f (x.1.1,x.2)
  have hg : Measurable g := hf.comp ((measurable_fst.comp measurable_fst).prodMk measurable_snd)
  obtain ⟨_,hgH,_⟩ := randomized_density δ σ ν hf hfi hH
  have hi := integrable_density_mul_of_entropy hc hg
    (measurable_countable_sample hZ hs) (fun x => hf0 _) (fun x => hZ0 _ _) hgH
    (sampled_exponential_integrable (δ.prod σ) ν hZ he heQ hs).1
  exact sampled_kernel_integrable δ σ (Measure.infinitePi (fun _ : I => ν))
    κ s hs hmap hf hZ hi

lemma kernel_entropy_decorrelation {f : D × (I → A) → ℝ} {Z : J → (I → A) → ℝ}
    {c Q C : ℝ} (hc : 0 < c) (hC : 0 ≤ C)
    (hf : Measurable f) (hf0 : ∀ x, 0 ≤ f x)
    (hfi : Integrable f (δ.prod (Measure.infinitePi (fun _ : I => ν))))
    (hf1 : (∫ x, f x ∂δ.prod (Measure.infinitePi (fun _ : I => ν))) = 1)
    (hH : Integrable (fun x => entropyPlus (f x)) (δ.prod (Measure.infinitePi (fun _ : I => ν))))
    (hZ : ∀ a, Measurable (Z a)) (hZ0 : ∀ a ω, 0 ≤ Z a ω)
    (he : ∀ a, Integrable (fun ω => Real.exp ((2 * c) * Z a ω)) (Measure.infinitePi (fun _ : I => ν)))
    (heQ : ∀ a, (∫ ω, Real.exp ((2 * c) * Z a ω) ∂Measure.infinitePi (fun _ : I => ν)) ≤ Q)
    (hZi : ∀ a, Integrable (Z a) (Measure.infinitePi (fun _ : I => ν)))
    (hZC : ∀ a, (∫ ω, Z a ω ∂Measure.infinitePi (fun _ : I => ν)) ≤ C)
    (N : ℕ → J → Set I) (κ : ℕ → Kernel D J) [∀ r, IsMarkovKernel (κ r)]
    (hloc : ∀ K η : ℝ, 0 < K → 0 < η → ∃ n : ℕ, ∃ F : J → (I → A) → ℝ,
      (∀ a, @Measurable _ _ (rows (N n a)) _ (F a)) ∧
      (∀ a ω, 0 ≤ F a ω ∧ F a ω ≤ K) ∧
      (∀ a, (∫ ω, |min K (Z a ω) - F a ω| ∂Measure.infinitePi (fun _ : I => ν)) ≤ η))
    (hescape : ∀ n (S : Set I), S.Finite → ∀ᵐ d ∂δ,
      ∀ᶠ r in atTop, ∀ᵐ a ∂κ r d, Disjoint S (N n a)) :
    ∀ ε > 0, ∀ᶠ r in atTop,
      (∫ x : D × (I → A), f x * (∫ a, Z a x.2 ∂κ r x.1)
        ∂δ.prod (Measure.infinitePi (fun _ : I => ν))) ≤ C + ε := by
  classical
  let σ : Measure unitInterval := volume
  choose s hs hmap using fun r => Kernel.exists_measurable_map_eq_unitInterval (κ r)
  let g : (D × unitInterval) × (I → A) → ℝ := fun x => f (x.1.1,x.2)
  have hg : Measurable g := hf.comp ((measurable_fst.comp measurable_fst).prodMk measurable_snd)
  obtain ⟨hgi,hgH,hg1⟩ := randomized_density δ σ ν hf hfi hH
  have hesc : ∀ n (S : Set I), S.Finite → ∀ᵐ d ∂δ.prod σ,
      ∀ᶠ r in atTop, Disjoint S (N n (s r d.1 d.2)) := by
    intro n S hS
    exact kernel_escape_sampled δ σ κ s hs hmap (fun _ a => Disjoint S (N n a)) (hescape n S hS)
  have hbound := sampled_entropy_decorrelation (δ.prod σ) ν hc hC hg
    (fun x => hf0 _) hgi (hg1.trans hf1) hgH hZ hZ0 he heQ hZi hZC N
    (fun r => Function.uncurry (s r)) hs hloc hesc
  have heq : ∀ r, (∫ x : (D × unitInterval) × (I → A),
      g x * Z (s r x.1.1 x.1.2) x.2 ∂(δ.prod σ).prod (Measure.infinitePi (fun _ : I => ν))) =
      (∫ x : D × (I → A), f x * (∫ a, Z a x.2 ∂κ r x.1)
        ∂δ.prod (Measure.infinitePi (fun _ : I => ν))) := by
    intro r
    have hi := integrable_density_mul_of_entropy (by linarith : 0 < 2*c) hg
      (measurable_countable_sample hZ (hs r)) (fun x => hf0 _) (fun x => hZ0 _ _) hgH
      (sampled_exponential_integrable (δ.prod σ) ν hZ he heQ (hs r)).1
    exact sampled_kernel_integral δ σ (Measure.infinitePi (fun _ : I => ν))
      (κ r) (s r) (hs r) (hmap r) hf hZ hi
  intro ε hε
  filter_upwards [hbound ε hε] with r hr
  rw [← heq r]
  exact hr

end KernelCompletion
end TailDecorrelation

end

end OAI