import Mathlib
import OAI.Probability.IsingPerceptron.GaussianIntegration

namespace OAI

/-! Countable Monomial G G. -/

noncomputable section

open MeasureTheory ProbabilityTheory Filter Set
open scoped BigOperators Topology ENNReal NNReal BoundedContinuousFunction
namespace IsingPerceptron

section
variable {S : Type*} [Fintype S]

def replicaEnergyMean {n r : ℕ} (w B : S → ℝ) (A C : S → Fin n → ℝ)
    (D : (Fin (r+1) → S) → ℝ) (g : Fin n → ℝ) : ℝ :=
  ∑ σ, D σ*(linearGaussian A g (σ 0)*replicaGibbs w B C g σ)

def expectedReplicaEnergy {n r : ℕ} (w B : S → ℝ) (A C : S → Fin n → ℝ)
    (D : (Fin (r+1) → S) → ℝ) : ℝ :=
  ∫ g, replicaEnergyMean w B A C D g ∂Measure.pi (fun _ : Fin n => gaussianReal 0 1)

def gibbsEnergyMean {n : ℕ} (w B : S → ℝ) (A C : S → Fin n → ℝ)
    (g : Fin n → ℝ) : ℝ := ∑ x, gaussianGibbs w B C g x*linearGaussian A g x

def expectedEnergy {n : ℕ} (w B : S → ℝ) (A C : S → Fin n → ℝ) : ℝ :=
  ∫ g, gibbsEnergyMean w B A C g ∂Measure.pi (fun _ : Fin n => gaussianReal 0 1)

def freshCovarianceMean {n r : ℕ} (w B : S → ℝ) (C : S → Fin n → ℝ)
    (κ : S → S → ℝ) (D : (Fin (r+1) → S) → ℝ) (g : Fin n → ℝ) : ℝ :=
  ∑ σ, replicaGibbs w B C g σ*D σ*(∑ z, gaussianGibbs w B C g z*κ (σ 0) z)

def expectedFreshCovariance {n r : ℕ} (w B : S → ℝ) (C : S → Fin n → ℝ)
    (κ : S → S → ℝ) (D : (Fin (r+1) → S) → ℝ) : ℝ :=
  ∫ g, freshCovarianceMean w B C κ D g ∂Measure.pi (fun _ : Fin n => gaussianReal 0 1)

lemma integrable_replicaEnergyMean {n r : ℕ} {w : S → ℝ} (hw : GibbsReference w)
    (B : S → ℝ) (A C : S → Fin n → ℝ) (D : (Fin (r+1) → S) → ℝ) :
    Integrable (replicaEnergyMean w B A C D) (Measure.pi (fun _ : Fin n => gaussianReal 0 1)) :=
  integrable_finsetSum _ (fun σ _ => (integrable_linear_mul_replica hw B A C (σ 0) σ).const_mul (D σ))

lemma expectedReplicaEnergy_const {n r : ℕ} {w : S → ℝ} (hw : GibbsReference w)
    (B : S → ℝ) (A C : S → Fin n → ℝ) :
    expectedReplicaEnergy w B A C (fun _ : Fin (r+1) → S => 1) = expectedEnergy w B A C := by
  apply integral_congr_ae
  apply ae_of_all
  intro g
  change (∑ σ : Fin (r+1) → S, 1*(linearGaussian A g (σ 0)*replicaGibbs w B C g σ)) = _
  simpa only [replicaMean, gibbsEnergyMean, one_mul, mul_comm] using
    replicaMean_marginal_zero (r := r) hw B C (linearGaussian A g) g

lemma integrable_gibbsEnergyMean {n : ℕ} {w : S → ℝ} (hw : GibbsReference w)
    (B : S → ℝ) (A C : S → Fin n → ℝ) :
    Integrable (gibbsEnergyMean w B A C) (Measure.pi (fun _ : Fin n => gaussianReal 0 1)) := by
  apply integrable_finsetSum
  intro x _
  simpa only [mul_comm] using integrable_linearGaussian_mul_gibbs hw B A C x x

lemma integrable_freshCovarianceMean {n r : ℕ} {w : S → ℝ} (hw : GibbsReference w)
    (B : S → ℝ) (C : S → Fin n → ℝ) (κ : S → S → ℝ) (D : (Fin (r+1) → S) → ℝ) :
    Integrable (freshCovarianceMean w B C κ D) (Measure.pi (fun _ : Fin n => gaussianReal 0 1)) := by
  have hm : AEStronglyMeasurable (freshCovarianceMean w B C κ D)
      (Measure.pi (fun _ : Fin n => gaussianReal 0 1)) :=
    (continuous_finsetSum _ (fun σ _ => ((continuous_replicaGibbs hw B C σ).mul continuous_const).mul
      (continuous_finsetSum _ (fun z _ => (continuous_gaussianGibbs hw B C z).mul continuous_const)))).aestronglyMeasurable
  apply Integrable.of_bound hm ((∑ σ, |D σ|)*(∑ p : S × S, |κ p.1 p.2|))
  apply ae_of_all
  intro g
  rw [Real.norm_eq_abs]
  calc
    _ ≤ ∑ σ, |replicaGibbs w B C g σ*D σ*(∑ z, gaussianGibbs w B C g z*κ (σ 0) z)| :=
      Finset.abs_sum_le_sum_abs ..
    _ ≤ ∑ σ : Fin (r+1) → S, |D σ| *(∑ p : S × S, |κ p.1 p.2|) := by
      apply Finset.sum_le_sum
      intro σ _
      rw [abs_mul, abs_mul, abs_of_nonneg (replicaGibbs_nonneg hw B C g σ)]
      have hk := finiteGibbs_average_bound hw (fun x => B x+linearGaussian C g x)
        (κ (σ 0)) (K := ∑ p : S × S, |κ p.1 p.2|) (fun z =>
          Finset.single_le_sum (fun (p : S × S) _ => abs_nonneg (κ p.1 p.2))
            (Finset.mem_univ (σ 0,z)))
      have hprod := mul_le_mul_of_nonneg_right (replicaGibbs_le_one hw B C g σ) (abs_nonneg (D σ))
      exact mul_le_mul (by simpa only [one_mul] using hprod) hk (abs_nonneg _) (abs_nonneg _)
    _ = _ := (Finset.sum_mul ..).symm

theorem gaussian_replica_energy_formula {n r : ℕ} {w : S → ℝ} (hw : GibbsReference w)
    (B : S → ℝ) (A C : S → Fin (n+1) → ℝ) (κ : S → S → ℝ) (t d : ℝ)
    (hcov : ∀ x y, gaussianCross A C x y = t*κ x y) (hdiag : ∀ x, κ x x = d)
    (D : (Fin (r+1) → S) → ℝ) :
    expectedReplicaEnergy w B A C D = t*(d*expectedReplica w B C D +
      (∑ l : Fin r, expectedReplica w B C (fun σ => D σ*κ (σ 0) (σ l.succ))) -
      (r+1 : ℕ)*expectedFreshCovariance w B C κ D) := by
  rw [expectedReplicaEnergy, show (∫ g, replicaEnergyMean w B A C D g
      ∂Measure.pi (fun _ : Fin (n+1) => gaussianReal 0 1)) = _ from
    gaussian_replica_test_insertion hw B A C D]
  have he (g : Fin (n+1) → ℝ) :
      (∑ σ : Fin (r+1) → S, D σ*(replicaGibbs w B C g σ*
        (∑ l, (gaussianCross A C (σ 0) (σ l)-∑ z, gaussianGibbs w B C g z*gaussianCross A C (σ 0) z)))) =
      t*(d*replicaMean w B C D g+
        (∑ l : Fin r, replicaMean w B C (fun σ => D σ*κ (σ 0) (σ l.succ)) g)-
        (r+1 : ℕ)*freshCovarianceMean w B C κ D g) := by
    simp_rw [hcov]
    simp only [Finset.sum_sub_distrib, Finset.sum_const, Finset.card_univ, Fintype.card_fin, nsmul_eq_mul]
    simp_rw [show ∀ σ : Fin (r+1) → S,
      (∑ z, gaussianGibbs w B C g z*(t*κ (σ 0) z)) = t*∑ z, gaussianGibbs w B C g z*κ (σ 0) z by
        intro σ; simp_rw [mul_left_comm (gaussianGibbs w B C g _) t]; rw [Finset.mul_sum]]
    simp_rw [← Finset.mul_sum, Fin.sum_univ_succ, hdiag]
    unfold replicaMean freshCovarianceMean
    rw [Finset.sum_comm]
    simp only [mul_add, mul_sub, Finset.mul_sum, Finset.sum_add_distrib, Finset.sum_sub_distrib]
    congr 1
    · congr 1
      · apply Finset.sum_congr rfl
        intro σ _
        ring
      · apply Finset.sum_congr rfl
        intro σ _
        apply Finset.sum_congr rfl
        intro l _
        ring
    · apply Finset.sum_congr rfl
      intro σ _
      apply Finset.sum_congr rfl
      intro z _
      ring
  simp_rw [he]
  have hiSum : Integrable (fun g => ∑ l : Fin r,
      replicaMean w B C (fun σ => D σ*κ (σ 0) (σ l.succ)) g)
      (Measure.pi (fun _ : Fin (n+1) => gaussianReal 0 1)) :=
    integrable_finsetSum _ (fun l _ => integrable_replicaMean hw B C _)
  simp only [integral_const_mul]
  congr 1
  change (∫ a, (d * replicaMean w B C D a + (∑ l : Fin r, replicaMean w B C (fun σ => D σ * κ (σ 0) (σ l.succ)) a)) -
    (r+1 : ℕ) * freshCovarianceMean w B C κ D a ∂Measure.pi (fun _ : Fin (n+1) => gaussianReal 0 1)) = _
  calc
    _ = (∫ a, d * replicaMean w B C D a +
        (∑ l : Fin r, replicaMean w B C (fun σ => D σ * κ (σ 0) (σ l.succ)) a)
        ∂Measure.pi (fun _ : Fin (n+1) => gaussianReal 0 1)) -
        ∫ a, (r+1 : ℕ) * freshCovarianceMean w B C κ D a
          ∂Measure.pi (fun _ : Fin (n+1) => gaussianReal 0 1) := by
      exact integral_sub (((integrable_replicaMean hw B C D).const_mul d).add hiSum)
        ((integrable_freshCovarianceMean hw B C κ D).const_mul (r+1 : ℕ))
    _ = _ := by
      congr 1
      · calc
          _ = (∫ a, d * replicaMean w B C D a ∂Measure.pi (fun _ : Fin (n+1) => gaussianReal 0 1)) +
            ∫ a, (∑ l : Fin r, replicaMean w B C (fun σ => D σ * κ (σ 0) (σ l.succ)) a)
              ∂Measure.pi (fun _ : Fin (n+1) => gaussianReal 0 1) :=
            integral_add ((integrable_replicaMean hw B C D).const_mul d) hiSum
          _ = _ := by
            rw [integral_const_mul, integral_finsetSum _ (fun l _ => integrable_replicaMean hw B C _)]
            rfl
      · rw [integral_const_mul]
        rfl

lemma expectedReplica_one {n r : ℕ} {w : S → ℝ} (hw : GibbsReference w)
    (B : S → ℝ) (C : S → Fin n → ℝ) :
    expectedReplica w B C (fun _ : Fin r → S => 1) = 1 := by
  unfold expectedReplica replicaMean
  simp only [mul_one, replicaGibbs_sum hw]
  simp

def pairCovariance {n : ℕ} (w B : S → ℝ) (C : S → Fin n → ℝ) (κ : S → S → ℝ) : ℝ :=
  expectedFreshCovariance w B C κ (fun _ : Fin 1 → S => 1)

lemma gaussian_single_energy_formula {n : ℕ} {w : S → ℝ} (hw : GibbsReference w)
    (B : S → ℝ) (A C : S → Fin (n+1) → ℝ) (κ : S → S → ℝ) (t d : ℝ)
    (hcov : ∀ x y, gaussianCross A C x y = t*κ x y) (hdiag : ∀ x, κ x x = d) :
    expectedEnergy w B A C = t*(d-pairCovariance w B C κ) := by
  have hh := gaussian_replica_energy_formula (r := 0) hw B A C κ t d hcov hdiag (fun _ => 1)
  simpa [expectedReplicaEnergy_const hw, expectedReplica_one hw, pairCovariance] using hh

theorem gaussian_gg_residual_identity {n r : ℕ} {w : S → ℝ} (hw : GibbsReference w)
    (B : S → ℝ) (A C : S → Fin (n+1) → ℝ) (κ : S → S → ℝ) (t d : ℝ)
    (hcov : ∀ x y, gaussianCross A C x y = t*κ x y) (hdiag : ∀ x, κ x x = d)
    (D : (Fin (r+1) → S) → ℝ) :
    t * ((r+1 : ℕ)*expectedFreshCovariance w B C κ D -
      expectedReplica w B C D * pairCovariance w B C κ -
      (∑ l : Fin r, expectedReplica w B C (fun σ => D σ*κ (σ 0) (σ l.succ)))) =
    expectedEnergy w B A C * expectedReplica w B C D - expectedReplicaEnergy w B A C D := by
  rw [gaussian_single_energy_formula hw B A C κ t d hcov hdiag,
    gaussian_replica_energy_formula hw B A C κ t d hcov hdiag]
  ring

def energyFluctuation {n : ℕ} (w B : S → ℝ) (A C : S → Fin n → ℝ) : ℝ :=
  ∫ g, ∑ x, gaussianGibbs w B C g x * |linearGaussian A g x - expectedEnergy w B A C|
    ∂Measure.pi (fun _ : Fin n => gaussianReal 0 1)

lemma integrable_gibbs_centered_abs_energy {n : ℕ} {w : S → ℝ} (hw : GibbsReference w)
    (B : S → ℝ) (A C : S → Fin n → ℝ) (m : ℝ) (x : S) :
    Integrable (fun g => gaussianGibbs w B C g x * |linearGaussian A g x-m|)
      (Measure.pi (fun _ : Fin n => gaussianReal 0 1)) := by
  have hi := ((integrable_linearGaussian A x).sub (integrable_const m)).abs.mul_bdd
    (continuous_gaussianGibbs hw B C x).aestronglyMeasurable (c := 1)
    (ae_of_all _ (fun g => by
      rw [Real.norm_eq_abs]
      change |finiteGibbs w (fun x => B x+linearGaussian C g x) x| ≤ 1
      rw [abs_of_nonneg (finiteGibbs_nonneg hw _ x)]
      exact finiteGibbs_le_one hw _ x))
  simpa only [mul_comm, Pi.sub_apply] using hi

lemma energy_covariance_bound {n r : ℕ} {w : S → ℝ} (hw : GibbsReference w)
    (B : S → ℝ) (A C : S → Fin n → ℝ) {D : (Fin (r+1) → S) → ℝ}
    {K : ℝ} (hD : ∀ σ, |D σ| ≤ K) :
    |expectedReplicaEnergy w B A C D - expectedEnergy w B A C * expectedReplica w B C D| ≤
      K * energyFluctuation w B A C := by
  let m := expectedEnergy w B A C
  have hi : Integrable (fun g => replicaEnergyMean w B A C D g - m*replicaMean w B C D g)
      (Measure.pi (fun _ : Fin n => gaussianReal 0 1)) :=
    (integrable_replicaEnergyMean hw B A C D).sub ((integrable_replicaMean hw B C D).const_mul m)
  have hb : Integrable (fun g => K*(∑ x, gaussianGibbs w B C g x*|linearGaussian A g x-m|))
      (Measure.pi (fun _ : Fin n => gaussianReal 0 1)) :=
    (integrable_finsetSum _ (fun x _ => integrable_gibbs_centered_abs_energy hw B A C m x)).const_mul K
  have he g : replicaEnergyMean w B A C D g - m*replicaMean w B C D g =
      ∑ σ, replicaGibbs w B C g σ*D σ*(linearGaussian A g (σ 0)-m) := by
    simp only [replicaEnergyMean, replicaMean, Finset.mul_sum, ← Finset.sum_sub_distrib]
    apply Finset.sum_congr rfl
    intro σ _
    ring
  calc
    _ = |∫ g, replicaEnergyMean w B A C D g - m*replicaMean w B C D g
        ∂Measure.pi (fun _ : Fin n => gaussianReal 0 1)| := by
      rw [integral_sub (integrable_replicaEnergyMean hw B A C D)
          ((integrable_replicaMean hw B C D).const_mul m), integral_const_mul]
      rfl
    _ ≤ ∫ g, |replicaEnergyMean w B A C D g - m*replicaMean w B C D g|
        ∂Measure.pi (fun _ : Fin n => gaussianReal 0 1) := abs_integral_le_integral_abs
    _ ≤ ∫ g, K*(∑ x, gaussianGibbs w B C g x*|linearGaussian A g x-m|)
        ∂Measure.pi (fun _ : Fin n => gaussianReal 0 1) := by
      apply integral_mono hi.abs hb
      intro g
      dsimp only
      rw [he]
      calc
        _ ≤ ∑ σ, |replicaGibbs w B C g σ*D σ*(linearGaussian A g (σ 0)-m)| :=
          Finset.abs_sum_le_sum_abs ..
        _ ≤ ∑ σ : Fin (r+1) → S, K*(replicaGibbs w B C g σ*|linearGaussian A g (σ 0)-m|) := by
          apply Finset.sum_le_sum
          intro σ _
          rw [abs_mul, abs_mul, abs_of_nonneg (replicaGibbs_nonneg hw B C g σ)]
          calc
            _ ≤ replicaGibbs w B C g σ*K*|linearGaussian A g (σ 0)-m| := by
              exact mul_le_mul_of_nonneg_right
                (mul_le_mul_of_nonneg_left (hD σ) (replicaGibbs_nonneg hw B C g σ)) (abs_nonneg _)
            _ = _ := by ring
        _ = _ := by
          rw [← Finset.mul_sum]
          congr 1
          exact replicaMean_marginal_zero hw B C (fun x => |linearGaussian A g x-m|) g
    _ = _ := by rw [integral_const_mul]; rfl

theorem gaussian_gg_residual_bound {n r : ℕ} {w : S → ℝ} (hw : GibbsReference w)
    (B : S → ℝ) (A C : S → Fin (n+1) → ℝ) (κ : S → S → ℝ) (t d : ℝ)
    (hcov : ∀ x y, gaussianCross A C x y = t*κ x y) (hdiag : ∀ x, κ x x = d)
    {D : (Fin (r+1) → S) → ℝ} {K : ℝ} (hD : ∀ σ, |D σ| ≤ K) :
    |t| * |(r+1 : ℕ)*expectedFreshCovariance w B C κ D -
      expectedReplica w B C D * pairCovariance w B C κ -
      (∑ l : Fin r, expectedReplica w B C (fun σ => D σ*κ (σ 0) (σ l.succ)))| ≤
      K * energyFluctuation w B A C := by
  rw [← abs_mul, gaussian_gg_residual_identity hw B A C κ t d hcov hdiag D, abs_sub_comm]
  exact energy_covariance_bound hw B A C hD

end

def referencePartition {X : Type*} [MeasurableSpace X] (ν : Measure X) (H : X → ℝ) : ℝ :=
  ∫ x, Real.exp (H x) ∂ν

def referenceReplicaMean {X : Type*} [MeasurableSpace X] {r : ℕ}
    (ν : Measure X) (H : X → ℝ) (D : (Fin r → X) → ℝ) : ℝ :=
  (∫ σ, Real.exp (∑ i, H (σ i))*D σ ∂Measure.pi (fun _ : Fin r => ν)) /
    (referencePartition ν H)^r

lemma reference_replica_partition {X : Type*} [MeasurableSpace X]
    (ν : Measure X) [SigmaFinite ν] (H : X → ℝ) (r : ℕ) :
    (∫ σ : Fin r → X, Real.exp (∑ i, H (σ i)) ∂Measure.pi (fun _ => ν)) =
      (referencePartition ν H)^r := by
  simp_rw [Real.exp_sum]
  simpa only [Fintype.card_fin,referencePartition] using
    (integral_fintype_prod_eq_pow (ι := Fin r) (μ := ν) (fun x => Real.exp (H x)))

lemma referenceReplicaMean_eq_ratio {X : Type*} [MeasurableSpace X]
    (ν : Measure X) [SigmaFinite ν] (H : X → ℝ) {r : ℕ} (D : (Fin r → X) → ℝ) :
    referenceReplicaMean ν H D =
      (∫ σ, Real.exp (∑ i, H (σ i))*D σ ∂Measure.pi (fun _ : Fin r => ν)) /
      (∫ σ, Real.exp (∑ i, H (σ i)) ∂Measure.pi (fun _ : Fin r => ν)) := by
  rw [reference_replica_partition]; rfl

lemma finite_reference_weights_sum {S : Type*} [Fintype S] [MeasurableSpace S]
    [MeasurableSingletonClass S] (ν : Measure S) [IsProbabilityMeasure ν] :
    ∑ x, ν.real {x} = 1 := by
  have h := integral_fintype (μ := ν) (f := fun _ => (1:ℝ)) Integrable.of_finite
  simpa only [smul_eq_mul,mul_one,integral_const,measureReal_def,measure_univ,ENNReal.toReal_one,one_smul] using h.symm

lemma finite_reference_weight_pos {S : Type*} [Fintype S] [MeasurableSpace S]
    [MeasurableSingletonClass S] (ν : Measure S) [IsProbabilityMeasure ν] :
    ∃ x, 0 < ν.real {x} := by
  have hsum := finite_reference_weights_sum ν
  have h := Finset.sum_pos_iff_of_nonneg (fun (x:S) (_:x ∈ Finset.univ) => (measureReal_nonneg : 0 ≤ ν.real {x}))
  obtain ⟨x, _,hx⟩ := h.mp (show 0 < ∑ x, ν.real {x} by rw [hsum]; norm_num)
  exact ⟨x,hx⟩

lemma referencePartition_finite {S : Type*} [Fintype S] [MeasurableSpace S]
    [MeasurableSingletonClass S] (ν : Measure S) [IsFiniteMeasure ν] (H : S → ℝ) :
    referencePartition ν H = ∑ x, ν.real {x}*Real.exp (H x) := by
  exact integral_fintype Integrable.of_finite

lemma referenceReplicaMean_finite {S : Type*} [Fintype S] [MeasurableSpace S]
    [MeasurableSingletonClass S] (ν : Measure S) [IsFiniteMeasure ν] (H : S → ℝ)
    {r : ℕ} (D : (Fin r → S) → ℝ) :
    referenceReplicaMean ν H D =
      ∑ σ : Fin r → S, (∏ i, ν.real {σ i}*Real.exp (H (σ i))/referencePartition ν H)*D σ := by
  classical
  rw [referenceReplicaMean, integral_fintype Integrable.of_finite, Finset.sum_div]
  apply Finset.sum_congr rfl
  intro σ _
  simp only [measureReal_def,Measure.pi_singleton,ENNReal.toReal_prod,smul_eq_mul,
    Real.exp_sum,Finset.prod_div_distrib,Finset.prod_const,
    Finset.card_univ,Fintype.card_fin]
  rw [Finset.prod_mul_distrib]
  ring

lemma referencePartition_map {S X : Type*} [MeasurableSpace S] [MeasurableSpace X]
    {μ : Measure S} {ν : Measure X} {f : S → X} (hf : MeasurePreserving f μ ν)
    {H : X → ℝ} (hmH : Measurable H) :
    referencePartition μ (H ∘ f) = referencePartition ν H := by
  exact hf.hasLaw.integral_comp hmH.exp.aestronglyMeasurable

lemma referenceReplicaMean_map {S X : Type*} [MeasurableSpace S] [MeasurableSpace X]
    {μ : Measure S} {ν : Measure X} [IsProbabilityMeasure μ] [IsProbabilityMeasure ν]
    {f : S → X} (hf : MeasurePreserving f μ ν)
    {H : X → ℝ} (hmH : Measurable H) {r : ℕ} {D : (Fin r → X) → ℝ}
    (hmD : Measurable D) :
    referenceReplicaMean μ (H ∘ f) (fun σ => D (fun i => f (σ i))) =
      referenceReplicaMean ν H D := by
  have hpi : MeasurePreserving (fun σ : Fin r → S => fun i => f (σ i))
      (Measure.pi (fun _ : Fin r => μ)) (Measure.pi (fun _ : Fin r => ν)) := by
    refine ⟨Measurable.of_eval (fun index => hf.measurable.comp (measurable_pi_apply index)),?_⟩
    have hmap : IsProbabilityMeasure (μ.map f) := hf.map_eq.symm ▸ inferInstance
    simpa only [hf.map_eq] using Measure.pi_map_pi (μ := fun _ : Fin r => μ) (f := fun _ : Fin r => f) (fun _ : Fin r => hf.measurable.aemeasurable)
  unfold referenceReplicaMean
  rw [referencePartition_map hf hmH]
  congr 1
  exact hpi.hasLaw.integral_comp ((by fun_prop : Measurable
    (fun σ : Fin r → X => Real.exp (∑ i, H (σ i))*D σ)).aestronglyMeasurable)

lemma finite_reference_GibbsReference {S : Type*} [Fintype S] [MeasurableSpace S]
    [MeasurableSingletonClass S] (ν : Measure S) [IsProbabilityMeasure ν] :
    GibbsReference (fun x => ν.real {x}) :=
  ⟨fun _ => measureReal_nonneg,finite_reference_weight_pos ν⟩

lemma referenceReplicaMean_eq_finite {S : Type*} [Fintype S] [MeasurableSpace S]
    [MeasurableSingletonClass S] (ν : Measure S) [IsProbabilityMeasure ν]
    {n r : ℕ} (B : S → ℝ) (C : S → Fin n → ℝ) (D : (Fin r → S) → ℝ) (g : Fin n → ℝ) :
    referenceReplicaMean ν (fun x => B x+linearGaussian C g x) D =
      replicaMean (fun x => ν.real {x}) B C D g := by
  rw [referenceReplicaMean_finite]
  simp only [referencePartition_finite,replicaMean,replicaGibbs,gaussianGibbs,finiteGibbs,finitePartition]

lemma replicaMean_fresh_eq {S : Type*} [Fintype S] {n r : ℕ}
    (w B : S → ℝ) (C : S → Fin n → ℝ) (κ : S → S → ℝ)
    (D : (Fin (r+1) → S) → ℝ) (g : Fin n → ℝ) :
    replicaMean w B C (fun τ : Fin (r+1+1) → S =>
      D (Fin.tail τ)*κ ((Fin.tail τ) 0) (τ 0)) g = freshCovarianceMean w B C κ D g := by
  classical
  have hp (z:S) (σ:Fin (r+1) → S) : replicaGibbs w B C g (Fin.cons z σ) =
      gaussianGibbs w B C g z*replicaGibbs w B C g σ := by
    simp only [replicaGibbs,Fin.prod_univ_succ,Fin.cons_zero,Fin.cons_succ]
  unfold replicaMean
  rw [← Equiv.sum_comp (Fin.consEquiv (fun _ : Fin (r+1+1) => S)),Fintype.sum_prod_type]
  change (∑ z, ∑ σ : Fin (r+1) → S,
    replicaGibbs w B C g (Fin.cons z σ : Fin (r+1+1) → S)*(D σ*κ (σ 0) z)) = _
  simp only [hp]
  rw [Finset.sum_comm]
  unfold freshCovarianceMean
  apply Finset.sum_congr rfl
  intro σ _
  rw [Finset.mul_sum]
  apply Finset.sum_congr rfl
  intro z _
  ring

theorem finite_gaussian_reference_insertion {S : Type*} [Fintype S] [MeasurableSpace S]
    [MeasurableSingletonClass S] (ν : Measure S) [IsProbabilityMeasure ν]
    {n r : ℕ} (B : S → ℝ) (A C : S → Fin (n+1) → ℝ) (D : (Fin (r+1) → S) → ℝ) :
    (∫ g, referenceReplicaMean ν (fun x => B x+linearGaussian C g x)
      (fun σ => linearGaussian A g (σ 0)*D σ) ∂Measure.pi (fun _ : Fin (n+1) => gaussianReal 0 1)) =
    (∫ g, referenceReplicaMean ν (fun x => B x+linearGaussian C g x)
      (fun σ => D σ*(∑ i, gaussianCross A C (σ 0) (σ i)))
        ∂Measure.pi (fun _ : Fin (n+1) => gaussianReal 0 1)) -
    (r+1 : ℕ)*(∫ g, referenceReplicaMean ν (fun x => B x+linearGaussian C g x)
      (fun τ : Fin (r+1+1) → S => D (Fin.tail τ)*gaussianCross A C ((Fin.tail τ) 0) (τ 0))
        ∂Measure.pi (fun _ : Fin (n+1) => gaussianReal 0 1)) := by
  classical
  let w := fun x => ν.real {x}
  have hw : GibbsReference w := finite_reference_GibbsReference ν
  simp_rw [referenceReplicaMean_eq_finite]
  have hi := gaussian_replica_test_insertion hw B A C D
  have he g : (∑ σ : Fin (r+1) → S, D σ*(replicaGibbs w B C g σ*
      (∑ i, (gaussianCross A C (σ 0) (σ i)-∑ z, gaussianGibbs w B C g z*gaussianCross A C (σ 0) z)))) =
      replicaMean w B C (fun σ => D σ*(∑ i, gaussianCross A C (σ 0) (σ i))) g -
      (r+1 : ℕ)*freshCovarianceMean w B C (gaussianCross A C) D g := by
    simp only [Finset.sum_sub_distrib,Finset.sum_const,Finset.card_univ,Fintype.card_fin,nsmul_eq_mul]
    unfold replicaMean freshCovarianceMean
    rw [Finset.mul_sum,← Finset.sum_sub_distrib]
    apply Finset.sum_congr rfl
    intro σ _
    ring
  have hleft g : (∑ σ : Fin (r+1) → S, D σ*(linearGaussian A g (σ 0)*replicaGibbs w B C g σ)) =
      replicaMean w B C (fun σ => linearGaussian A g (σ 0)*D σ) g := by
    apply Finset.sum_congr rfl
    intro σ _
    ring
  simp_rw [he,hleft] at hi
  rw [integral_sub (integrable_replicaMean hw B C _) ((integrable_freshCovarianceMean hw B C _ D).const_mul _),
    integral_const_mul] at hi
  simpa only [replicaMean_fresh_eq] using hi

lemma gaussian_weighted_sum_law {ι : Type*} [Fintype ι] (a : ι → ℝ) :
    HasLaw (fun g : ι → ℝ => ∑ i, a i * g i)
      (gaussianReal 0 ((∑ i, a i ^ 2).toNNReal))
      (Measure.pi (fun _ : ι => gaussianReal 0 1)) := by
  have hi : iIndepFun (fun i => fun g : ι → ℝ => a i * g i)
      (Measure.pi (fun _ : ι => gaussianReal 0 1)) :=
    iIndepFun_pi (fun _ => by fun_prop)
  have hl i : HasLaw (fun g : ι → ℝ => g i) (gaussianReal 0 1)
      (Measure.pi (fun _ : ι => gaussianReal 0 1)) :=
    (measurePreserving_eval (fun _ : ι => gaussianReal 0 1) i).hasLaw
  have hg := hi.hasGaussianLaw_fun_sum (fun i => (gaussianReal_const_mul (hl i) (a i)).hasGaussianLaw)
  refine ⟨(by fun_prop : Measurable (fun g : ι → ℝ => ∑ i, a i * g i)).aemeasurable, ?_⟩
  rw [hg.map_eq_gaussianReal]
  congr 1
  · have hI i : Integrable (fun g : ι → ℝ => a i * g i)
        (Measure.pi (fun _ : ι => gaussianReal 0 1)) :=
      ((measurePreserving_eval (fun _ : ι => gaussianReal 0 1) i).integrable_comp_of_integrable
        ((memLp_id_gaussianReal 1).integrable le_rfl)).const_mul (a i)
    rw [integral_finsetSum _ (fun i _ => hI i)]
    simp_rw [integral_const_mul]
    have hz i : (∫ g : ι → ℝ, g i ∂Measure.pi (fun _ : ι => gaussianReal 0 1)) = 0 := by
      simpa using (hl i).integral_eq
    simp [hz]
  · congr 1
    have hv i : Var[fun x : ℝ => a i*x; gaussianReal 0 1] = a i^2 := by
      simpa only [id_eq, variance_id_gaussianReal, NNReal.coe_one, mul_one] using
        (variance_const_mul (a i) id (gaussianReal 0 1))
    have hvsum := variance_sum_pi (μ := fun _ : ι => gaussianReal 0 1)
      (X := fun i x => a i * x) (fun i => (memLp_id_gaussianReal 2).const_mul (a i))
    rw [show (∑ i : ι, fun ω : ι → ℝ => a i * ω i) =
      (fun ω => ∑ i, a i * ω i) from by ext; simp] at hvsum
    simpa only [hv] using hvsum

def gaussianCoordinates : Measure (ℕ → ℝ) :=
  Measure.infinitePi (fun _ : ℕ => gaussianReal 0 1)

instance gaussianCoordinates_probability : IsProbabilityMeasure gaussianCoordinates :=
  inferInstanceAs (IsProbabilityMeasure (Measure.infinitePi (fun _ : ℕ => gaussianReal 0 1)))

lemma gaussian_prefix_measurePreserving (n : ℕ) :
    MeasurePreserving (fun g : ℕ → ℝ => fun i : Fin n => g i)
      gaussianCoordinates (Measure.pi (fun _ : Fin n => gaussianReal 0 1)) := by
  refine ⟨by fun_prop, ?_⟩
  have hi : iIndepFun (fun i : ℕ => fun g : ℕ → ℝ => g i) gaussianCoordinates :=
    iIndepFun_infinitePi (fun _ => measurable_id)
  have hs := hi.precomp (g := fun i : Fin n => (i:ℕ)) Fin.val_injective
  have he := hs.map_fun_eq_pi_map (fun _ => (by fun_prop : Measurable _).aemeasurable)
  simpa only [gaussianCoordinates,Measure.infinitePi_map_eval] using he

def cylinderField (a : ℕ →₀ ℝ) (g : ℕ → ℝ) : ℝ :=
  a.sum (fun i c => c*g i)

lemma measurable_cylinderField (a : ℕ →₀ ℝ) : Measurable (cylinderField a) := by
  classical
  change Measurable (fun g : ℕ → ℝ => ∑ i ∈ a.support, a i*g i)
  fun_prop

lemma measurable_cylinderFields {X : Type*} [MeasurableSpace X] [Countable X]
    [MeasurableSingletonClass X] (a : X → ℕ →₀ ℝ) :
    Measurable (fun z : (ℕ → ℝ) × X => cylinderField (a z.2) z.1) :=
  measurable_from_prod_countable_left (fun x => measurable_cylinderField (a x))

lemma cylinderField_eq_prefix (a : ℕ →₀ ℝ) {n : ℕ}
    (ha : ∀ i ∈ a.support, i < n) (g : ℕ → ℝ) :
    cylinderField a g = ∑ i : Fin n, a i*g i := by
  classical
  rw [cylinderField, a.sum_of_support_subset (s := Finset.range n)
    (fun i hi => Finset.mem_range.mpr (ha i hi)) (fun i c => c*g i) (fun _ _ => zero_mul _)]
  exact (Fin.sum_univ_eq_sum_range _ n).symm

lemma finite_family_support_bound {X : Type*} [Fintype X] (a : X → ℕ →₀ ℝ) :
    ∃ n : ℕ, ∀ x i, a x i ≠ 0 → i < n+1 := by
  classical
  let s := Finset.univ.biUnion (fun x => (a x).support)
  refine ⟨s.sup id,fun x i hi => ?_⟩
  have hm : i ∈ s := Finset.mem_biUnion.mpr ⟨x,Finset.mem_univ _,Finsupp.mem_support_iff.mpr hi⟩
  exact Nat.lt_succ_of_le (Finset.le_sup (f := id) hm)

lemma cylinderField_law (a : ℕ →₀ ℝ) :
    gaussianCoordinates.map (cylinderField a) =
      gaussianReal 0 ((a.sum (fun _ c => c^2)).toNNReal) := by
  classical
  let n := a.support.sup id+1
  have ha : ∀ i ∈ a.support, i < n := fun i hi => Nat.lt_succ_of_le (Finset.le_sup (f := id) hi)
  have he : cylinderField a = (fun g : Fin n → ℝ => ∑ i : Fin n, a i*g i) ∘
      (fun g : ℕ → ℝ => fun i : Fin n => g i) := by
    funext g
    exact cylinderField_eq_prefix a ha g
  rw [he,← Measure.map_map (by fun_prop) (by fun_prop),
    (gaussian_prefix_measurePreserving n).map_eq,(gaussian_weighted_sum_law (fun i : Fin n => a i)).map_eq]
  congr 2
  rw [a.sum_of_support_subset (s := Finset.range n)
    (fun i hi => Finset.mem_range.mpr (ha i hi)) (fun _ c => c^2) (fun _ _ => by norm_num)]
  exact Fin.sum_univ_eq_sum_range (fun i : ℕ => a i^2) n

lemma cylinderField_finset_sum {ι : Type*} (s : Finset ι) (a : ι → ℕ →₀ ℝ)
    (g : ℕ → ℝ) : cylinderField (∑ i ∈ s, a i) g = ∑ i ∈ s, cylinderField (a i) g := by
  let L : (ℕ →₀ ℝ) →+ ℝ :=
    { toFun := fun a => cylinderField a g
      map_zero' := by simp [cylinderField]
      map_add' := fun a b => by
        exact Finsupp.sum_add_index' (fun _ => zero_mul _) (fun _ _ _ => add_mul ..) }
  exact map_sum L _ _

lemma cylinder_variance_prefix (a : ℕ →₀ ℝ) {n : ℕ}
    (ha : ∀ i ∈ a.support, i < n) :
    a.sum (fun _ c => c^2) = ∑ i : Fin n, (a i)^2 := by
  rw [a.sum_of_support_subset (s := Finset.range n)
    (fun i hi => Finset.mem_range.mpr (ha i hi)) (fun _ c => c^2) (fun _ _ => by norm_num)]
  exact (Fin.sum_univ_eq_sum_range (fun i : ℕ => (a i)^2) n).symm

lemma cylinder_variance_sum_le {ι : Type*} [Fintype ι] (a : ι → ℕ →₀ ℝ)
    {K : ℝ} (ha : ∀ i, (a i).sum (fun _ c => c^2) ≤ K) :
    (∑ i, a i).sum (fun _ c => c^2) ≤ (Fintype.card ι : ℝ)^2*K := by
  classical
  obtain ⟨n, hn⟩ := finite_family_support_bound a
  have hs : ∀ j ∈ (∑ i, a i).support, j < n+1 := by
    intro j hj
    by_contra hjn
    have hz i : a i j = 0 := by
      by_contra h
      exact hjn (hn i j h)
    have hz' : (∑ i, a i) j = 0 := by simp only [Finsupp.finsetSum_apply,hz,Finset.sum_const_zero]
    exact Finsupp.mem_support_iff.mp hj hz'
  rw [cylinder_variance_prefix _ hs]
  simp only [Finsupp.finsetSum_apply]
  calc
    _ ≤ ∑ j : Fin (n+1), (Fintype.card ι : ℝ)*(∑ i, (a i j)^2) := by
      apply Finset.sum_le_sum
      intro j _
      simpa using Finset.sum_mul_sq_le_sq_mul_sq (Finset.univ : Finset ι)
        (fun _ => (1:ℝ)) (fun i => a i j)
    _ = (Fintype.card ι : ℝ)*∑ i, ∑ j : Fin (n+1), (a i j)^2 := by
      rw [← Finset.mul_sum,Finset.sum_comm]
    _ ≤ (Fintype.card ι : ℝ)*∑ _i : ι, K := by
      apply mul_le_mul_of_nonneg_left _ (Nat.cast_nonneg _)
      apply Finset.sum_le_sum
      intro i _
      rw [← cylinder_variance_prefix (a i) (fun j hj => hn i j (Finsupp.mem_support_iff.mp hj))]
      exact ha i
    _ = _ := by simp only [Finset.sum_const,Finset.card_univ,nsmul_eq_mul]; ring

def cylinderCross (a b : ℕ →₀ ℝ) : ℝ := a.sum (fun i c => c*b i)

lemma cylinderCross_prefix (a b : ℕ →₀ ℝ) {n : ℕ}
    (ha : ∀ i ∈ a.support, i < n) :
    cylinderCross a b = ∑ i : Fin n, a i*b i := by
  rw [cylinderCross,a.sum_of_support_subset (s := Finset.range n)
    (fun i hi => Finset.mem_range.mpr (ha i hi)) (fun i c => c*b i) (fun _ _ => zero_mul _)]
  exact (Fin.sum_univ_eq_sum_range (fun i : ℕ => a i*b i) n).symm

lemma abs_cylinderCross_le (a b : ℕ →₀ ℝ) :
    |cylinderCross a b| ≤ (a.sum (fun _ c => c^2)+b.sum (fun _ c => c^2))/2 := by
  classical
  let n := a.support.sup id+b.support.sup id+1
  have ha : ∀ i ∈ a.support, i < n := by
    intro i hi
    have := Finset.le_sup (f := id) hi
    dsimp only [id_eq] at this
    omega
  have hb : ∀ i ∈ b.support, i < n := by
    intro i hi
    have := Finset.le_sup (f := id) hi
    dsimp only [id_eq] at this
    omega
  rw [cylinderCross_prefix a b ha,cylinder_variance_prefix a ha,cylinder_variance_prefix b hb]
  calc
    _ ≤ ∑ i : Fin n, |a i*b i| := Finset.abs_sum_le_sum_abs _ _
    _ ≤ ∑ i : Fin n, ((a i)^2+(b i)^2)/2 := by
      apply Finset.sum_le_sum
      intro i _
      rw [abs_mul]
      nlinarith [sq_abs (a i),sq_abs (b i),sq_nonneg (|a i|-|b i|)]
    _ = _ := by rw [← Finset.sum_div,Finset.sum_add_distrib]

lemma measurable_referenceReplicaMean {Ω X : Type*} [MeasurableSpace Ω] [MeasurableSpace X]
    (ν : Measure X) [IsProbabilityMeasure ν] {r : ℕ} {H : Ω × X → ℝ}
    {D : Ω × (Fin r → X) → ℝ} (hmH : Measurable H) (hmD : Measurable D) :
    Measurable (fun ω => referenceReplicaMean ν (fun x => H (ω,x)) (fun σ => D (ω,σ))) := by
  have hrep : Measurable (fun z : Ω × (Fin r → X) => ∑ i, H (z.1,z.2 i)) := by
    apply Finset.measurable_sum
    intro i _
    exact hmH.comp (measurable_fst.prodMk ((measurable_pi_apply i).comp measurable_snd))
  exact (hrep.exp.mul hmD).stronglyMeasurable.integral_prod_right'.measurable.div
    (hmH.exp.stronglyMeasurable.integral_prod_right'.measurable.pow_const r)

theorem finite_cylinder_reference_insertion {S : Type*} [Fintype S] [MeasurableSpace S]
    [MeasurableSingletonClass S] (ν : Measure S) [IsProbabilityMeasure ν]
    (a b : S → ℕ →₀ ℝ) {r : ℕ} (D : (Fin (r+1) → S) → ℝ) :
    (∫ g, referenceReplicaMean ν (fun x => cylinderField (a x) g)
      (fun σ => cylinderField (b (σ 0)) g*D σ) ∂gaussianCoordinates) =
    (∫ g, referenceReplicaMean ν (fun x => cylinderField (a x) g)
      (fun σ => D σ*(∑ i, cylinderCross (b (σ 0)) (a (σ i)))) ∂gaussianCoordinates) -
    (r+1 : ℕ)*(∫ g, referenceReplicaMean ν (fun x => cylinderField (a x) g)
      (fun τ : Fin (r+1+1) → S => D (Fin.tail τ)*cylinderCross (b ((Fin.tail τ) 0)) (a (τ 0)))
      ∂gaussianCoordinates) := by
  classical
  obtain ⟨n₁,hn₁⟩ := finite_family_support_bound a
  obtain ⟨n₂,hn₂⟩ := finite_family_support_bound b
  let n := n₁+n₂
  let C : S → Fin (n+1) → ℝ := fun x i => a x i
  let B : S → Fin (n+1) → ℝ := fun x i => b x i
  have ha x : ∀ i ∈ (a x).support, i < n+1 := by
    intro i hi
    have := hn₁ x i (Finsupp.mem_support_iff.mp hi)
    omega
  have hb x : ∀ i ∈ (b x).support, i < n+1 := by
    intro i hi
    have := hn₂ x i (Finsupp.mem_support_iff.mp hi)
    omega
  have hC (g : ℕ → ℝ) x : linearGaussian C (fun i : Fin (n+1) => g i) x = cylinderField (a x) g :=
    (cylinderField_eq_prefix (a x) (ha x) g).symm
  have hB (g : ℕ → ℝ) x : linearGaussian B (fun i : Fin (n+1) => g i) x = cylinderField (b x) g :=
    (cylinderField_eq_prefix (b x) (hb x) g).symm
  have hcov x y : gaussianCross B C x y = cylinderCross (b x) (a y) :=
    (cylinderCross_prefix (b x) (a y) (hb x)).symm
  have hmC : Measurable (fun z : (Fin (n+1) → ℝ) × S => linearGaussian C z.1 z.2) :=
    measurable_from_prod_countable_left (fun x => by unfold linearGaussian; fun_prop)
  have hmL : Measurable (fun z : (Fin (n+1) → ℝ) × (Fin (r+1) → S) =>
      linearGaussian B z.1 (z.2 0)*D z.2) :=
    measurable_from_prod_countable_left (fun σ => by unfold linearGaussian; fun_prop)
  have hp := (gaussian_prefix_measurePreserving (n+1)).hasLaw
  have hL := hp.integral_comp (measurable_referenceReplicaMean ν hmC hmL).aestronglyMeasurable
  have hR₁ := hp.integral_comp (measurable_referenceReplicaMean ν hmC
    (measurable_of_countable (fun σ : Fin (r+1) → S =>
      D σ*(∑ i, cylinderCross (b (σ 0)) (a (σ i)))) |>.comp measurable_snd)).aestronglyMeasurable
  have hR₂ := hp.integral_comp (measurable_referenceReplicaMean ν hmC
    (measurable_of_countable (fun τ : Fin (r+1+1) → S =>
      D (Fin.tail τ)*cylinderCross (b ((Fin.tail τ) 0)) (a (τ 0))) |>.comp measurable_snd)).aestronglyMeasurable
  have hfinite := finite_gaussian_reference_insertion ν (fun _ => 0) B C D
  simp only [zero_add] at hfinite
  simp_rw [hcov] at hfinite
  simp only [Function.comp_apply,hB,hC] at hL hR₁ hR₂
  rw [hL,hR₁,hR₂]
  exact hfinite

end IsingPerceptron

end

end OAI