import Mathlib
import OAI.Probability.Perceptron.Variational.ContactGGRate

namespace OAI

noncomputable section
namespace SphericalPerceptronFreeEnergy
open MeasureTheory ProbabilityTheory Filter Set
open scoped Topology NNReal ENNReal BigOperators BoundedContinuousFunction

section

section
variable {A S : Type*} [MeasurableSpace A] [MeasurableSpace S]
variable (κ : Kernel A S) [IsMarkovKernel κ]

lemma kernelFiniteProduct_measurable (ι : Type*) [Fintype ι] :
    Measurable (fun a => Measure.pi (fun _ : ι => κ a)) := by
  apply Measurable.measure_of_isPiSystem_of_isProbabilityMeasure generateFrom_pi.symm isPiSystem_pi
  rintro _ ⟨s,hs,rfl⟩
  simp_rw [Measure.pi_pi]
  exact Finset.measurable_prod _ fun i _ => κ.measurable_coe (hs i (mem_univ i))

lemma kernelInfiniteReplica_measurable (ι : Type*) :
    Measurable (fun a => Measure.infinitePi (fun _ : ι => κ a)) := by
  apply Measurable.measure_of_isPiSystem_of_isProbabilityMeasure
    generateFrom_measurableCylinders.symm isPiSystem_measurableCylinders
  intro s hs
  obtain ⟨I,E,hE,rfl⟩ := (mem_measurableCylinders s).mp hs
  have hm := (Measure.measurable_coe hE).comp (kernelFiniteProduct_measurable κ I)
  convert hm using 1
  funext a
  change (Measure.infinitePi (fun _ : ι => κ a)) (I.restrict ⁻¹' E) =
    (Measure.pi (fun _ : I => κ a)) E
  have hmI : Measurable (I.restrict : (ι → S) → I → S) := by fun_prop
  rw [← Measure.map_apply (f := I.restrict) hmI hE,Measure.infinitePi_map_restrict]

def kernelInfiniteReplica (ι : Type*) : Kernel A (ι → S) :=
  ⟨(fun a => Measure.infinitePi (fun _ : ι => κ a)),kernelInfiniteReplica_measurable κ ι⟩

instance (ι : Type*) : IsMarkovKernel (kernelInfiniteReplica κ ι) := ⟨fun _ => by
  change IsProbabilityMeasure (Measure.infinitePi _)
  infer_instance⟩

lemma infiniteReplica_prefix_preserving (μ : Measure S) [IsProbabilityMeasure μ] (r : ℕ) :
    MeasurePreserving (fun x : ℕ → S => fun i : Fin r => x i.val)
      (Measure.infinitePi (fun _ : ℕ => μ)) (Measure.pi (fun _ : Fin r => μ)) := by
  let e : (Finset.range r) ≃ Fin r :=
    { toFun := fun i => ⟨i.val,Finset.mem_range.mp i.property⟩
      invFun := fun i => ⟨i.val,Finset.mem_range.mpr i.isLt⟩
      left_inv := fun _ => rfl
      right_inv := fun _ => rfl }
  have hp : MeasurePreserving ((Finset.range r).restrict : (ℕ → S) → (Finset.range r) → S)
      (Measure.infinitePi (fun _ : ℕ => μ)) (Measure.pi (fun _ : (Finset.range r) => μ)) :=
    ⟨by fun_prop,Measure.infinitePi_map_restrict _⟩
  have he := measurePreserving_piCongrLeft (fun _ : Fin r => μ) e
  exact he.comp hp

lemma kernelInfiniteReplica_prefix_integral (a : A) (r : ℕ) {G : (Fin r → S) → ℝ}
    (hG : Measurable G) :
    (∫ x, G (fun i => x i.val) ∂kernelInfiniteReplica κ ℕ a) =
      ∫ x, G x ∂Measure.pi (fun _ : Fin r => κ a) := by
  have hp := infiniteReplica_prefix_preserving (κ a) r
  rw [← hp.map_eq,integral_map hp.measurable.aemeasurable hG.aestronglyMeasurable]
  rfl

end
variable {A S : Type*} [MeasurableSpace A] [MeasurableSpace S]
variable (κ : Kernel A S) [IsMarkovKernel κ] (P : Measure A) [IsProbabilityMeasure P]
variable (H : A → S → ℝ) (hH : Measurable (Function.uncurry H))

def annealedInfiniteReplicaMeasure : Measure (A × (ℕ → S)) := by
  letI : IsMarkovKernel (gibbsProbabilityKernel κ H) := gibbsProbabilityKernel_markov κ H hH
  exact P ⊗ₘ kernelInfiniteReplica (gibbsProbabilityKernel κ H) ℕ

instance : IsProbabilityMeasure (annealedInfiniteReplicaMeasure κ P H hH) := by
  let : IsMarkovKernel (gibbsProbabilityKernel κ H) := gibbsProbabilityKernel_markov κ H hH
  unfold annealedInfiniteReplicaMeasure
  infer_instance

lemma annealedInfiniteReplica_prefix_integral (r : ℕ) {G : (Fin r → S) → ℝ}
    (hG : Measurable G) {B : ℝ} (hGB : ∀ x, |G x|≤B) :
    (∫ a, G (fun i => a.2 i.val) ∂annealedInfiniteReplicaMeasure κ P H hH) =
      ∫ a, (∫ x, G x ∂Measure.pi (fun _ : Fin r => gibbsProbabilityKernel κ H a)) ∂P := by
  let : IsMarkovKernel (gibbsProbabilityKernel κ H) := gibbsProbabilityKernel_markov κ H hH
  have hm : Measurable (fun a : A × (ℕ → S) => G (fun i : Fin r => a.2 i.val)) :=
    hG.comp (by fun_prop)
  have hi : Integrable (fun a : A × (ℕ → S) => G (fun i : Fin r => a.2 i.val))
      (annealedInfiniteReplicaMeasure κ P H hH) :=
    (integrable_const B).mono' hm.aestronglyMeasurable (Eventually.of_forall fun a => by
      simpa only [Real.norm_eq_abs] using hGB (fun i => a.2 i.val))
  rw [annealedInfiniteReplicaMeasure,Measure.integral_compProd hi]
  apply integral_congr_ae
  exact Eventually.of_forall fun a => kernelInfiniteReplica_prefix_integral _ a r hG

lemma annealedInfiniteReplica_gibbs_prefix (hexp : ∀ᵐ a ∂P,
    Integrable (fun x => Real.exp (H a x)) (κ a)) (r : ℕ) {G : (Fin r → S) → ℝ}
    (hG : Measurable G) {B : ℝ} (hGB : ∀ x, |G x|≤B) :
    (∫ a, G (fun i => a.2 i.val) ∂annealedInfiniteReplicaMeasure κ P H hH) =
      ∫ a, gibbsReplicaMean (κ a) (H a) r G ∂P := by
  rw [annealedInfiniteReplica_prefix_integral κ P H hH r hG hGB]
  apply integral_congr_ae
  filter_upwards [hexp] with a ha
  exact gibbsProbabilityKernel_replica_integral κ H hH a ha r G

end

def sourceJointOverlap {N k : ℕ} (x y : NormalizedSpin N×IndexedLeaf k) : CompactJointOverlap :=
  (⟨spinOverlap x.1 y.1,abs_le.mp (spinOverlap_abs_le x.1 y.1)⟩,
    ⟨((indexedCommonDepth k y.2 x.2).val:ℝ)/(k+1:ℕ),by
      constructor
      · positivity
      · apply (div_le_one (by positivity : (0:ℝ)<(k+1:ℕ))).mpr
        exact_mod_cast (indexedCommonDepth k y.2 x.2).isLt.le⟩)

lemma sourceJointOverlap_measurable (N k : ℕ) :
    Measurable (Function.uncurry (sourceJointOverlap (N:=N) (k:=k))) := by
  apply Measurable.prodMk
  · apply Measurable.subtype_mk
    exact (measurable_fst.fst.subtype_val.inner measurable_snd.fst.subtype_val)
  · apply Measurable.subtype_mk
    have hm : Measurable (fun a : IndexedLeaf k × IndexedLeaf k =>
      ((indexedCommonDepth k a.2 a.1).val:ℝ)/(k+1:ℕ)) := measurable_of_countable _
    exact hm.comp (measurable_fst.snd.prodMk measurable_snd.snd)

def sourceJointArray {N k : ℕ} (x : ℕ → NormalizedSpin N×IndexedLeaf k) : CompactArray CompactJointOverlap :=
  fun i j => sourceJointOverlap (x i) (x j)

lemma sourceJointArray_measurable (N k : ℕ) : Measurable (sourceJointArray (N:=N) (k:=k)) := by
  apply Measurable.of_eval
  intro i
  apply Measurable.of_eval
  intro j
  exact (sourceJointOverlap_measurable N k).comp (show Measurable (fun x : ℕ → NormalizedSpin N×IndexedLeaf k => (x i,x j)) from by fun_prop)

def sourceGibbsArrayLaw (n k : ℕ) (f : ℝ →ᵇ ℝ) (p d : Fin (n+1) → ℕ)
    (h : Fin (k+1) → ℝ) (u : Fin (n+1) → ℝ) (z : Fin k → ℝ) (t : ℝ≥0) :
    ProbabilityMeasure (CompactArray CompactJointOverlap) :=
  let P := (sourceBaseDataLaw n k z t).prod countableGaussianLaw
  let H := sourceCouplingHamiltonian n k f p d h u
  let μ := annealedInfiniteReplicaMeasure (sourceFullSpinLeafKernel n k) P H
    (sourceCouplingHamiltonian_measurable n k f p d h u)
  ⟨μ.map (fun a => sourceJointArray a.2),inferInstance⟩

lemma sourceGibbsArray_integral (n k : ℕ) (f : ℝ →ᵇ ℝ) (p d : Fin (n+1) → ℕ)
    (h : Fin (k+1) → ℝ) (u : Fin (n+1) → ℝ) (z : Fin k → ℝ) (t : ℝ≥0)
    {F : CompactArray CompactJointOverlap → ℝ} (hF : Measurable F) :
    (∫ Q, F Q ∂sourceGibbsArrayLaw n k f p d h u z t) =
      ∫ a, F (sourceJointArray a.2) ∂annealedInfiniteReplicaMeasure (sourceFullSpinLeafKernel n k)
        ((sourceBaseDataLaw n k z t).prod countableGaussianLaw)
        (sourceCouplingHamiltonian n k f p d h u) (sourceCouplingHamiltonian_measurable n k f p d h u) := by
  exact integral_map ((sourceJointArray_measurable (n+1) k).comp measurable_snd).aemeasurable hF.aestronglyMeasurable

lemma sourceGibbsArray_block_integral (n k : ℕ) (f : ℝ →ᵇ ℝ) (p d : Fin (n+1) → ℕ)
    (h : Fin (k+1) → ℝ) (hh0 : ∀ l, 0≤h l) (hh : Monotone h)
    (u : Fin (n+1) → ℝ) (z : Fin k → ℝ) (t : ℝ≥0) (r : ℕ)
    {F : CompactBlock CompactJointOverlap r → ℝ} (hF : Measurable F)
    {B : ℝ} (hFB : ∀ Q, |F Q|≤B) :
    (∫ Q, F (compactBlock r Q) ∂sourceGibbsArrayLaw n k f p d h u z t) =
      ∫ a, gibbsReplicaMean (sourceFullSpinLeafKernel n k a)
        (sourceCouplingHamiltonian n k f p d h u a) r
        (fun x => F (fun i j => sourceJointOverlap (x i) (x j)))
        ∂(sourceBaseDataLaw n k z t).prod countableGaussianLaw := by
  rw [sourceGibbsArray_integral n k f p d h u z t (F:=fun Q => F (compactBlock r Q))
    (hF.comp (compactBlock_continuous r).measurable)]
  have he := sourceCoupling_all_exp_ae n k f p d h hh0 hh u 0 z t
  have he0 : ∀ᵐ a ∂(sourceBaseDataLaw n k z t).prod countableGaussianLaw,
      Integrable (fun x => Real.exp (sourceCouplingHamiltonian n k f p d h u a x))
        (sourceFullSpinLeafKernel n k a) := by
    filter_upwards [he] with a ha
    simpa only [sourceFullSpinLeafKernel,Kernel.comap_apply,zero_mul,add_zero] using ha 0
  exact annealedInfiniteReplica_gibbs_prefix (sourceFullSpinLeafKernel n k)
    ((sourceBaseDataLaw n k z t).prod countableGaussianLaw) _
    (sourceCouplingHamiltonian_measurable n k f p d h u) he0 r
    (hF.comp (Measurable.of_eval fun row => Measurable.of_eval fun column =>
      (sourceJointOverlap_measurable (n+1) k).comp
        ((measurable_pi_apply row).prodMk (measurable_pi_apply column))))
    (fun x => hFB _)

end SphericalPerceptronFreeEnergy

end

end OAI