lean/OAI/Probability/IsingPerceptron/GaussianVariance.lean

import Mathlib
import OAI.Probability.IsingPerceptron.NodalGaussianLipschitz

namespace OAI

/-! Gaussian Variance. -/

noncomputable section

namespace IsingPerceptron.Main
open MeasureTheory ProbabilityTheory Real
open scoped BigOperators Topology

def CoordinateLipschitz {n : ℕ} (c : Fin n → ℝ) (F : (Fin n → ℝ) → ℝ) : Prop :=
  ∀i x y,(∀j,j≠i → x j=y j) → |F x-F y|≤c i*|x i-y i|

lemma coordinateLipschitz_global {n : ℕ} {c : Fin n → ℝ} {F : (Fin n → ℝ) → ℝ}
    (hc : CoordinateLipschitz c F) (x y : Fin n → ℝ) :
    |F x-F y|≤∑i,c i*|x i-y i| := by
  induction n with
  | zero => have he : x=y := Subsingleton.elim _ _; simp [he]
  | succ n ih =>
    let z := Fin.cons (y 0) (Fin.tail x)
    have h0 : |F x-F z|≤c 0*|x 0-y 0| := by
      apply hc 0
      intro j
      refine Fin.cases ?_ (fun i => ?_) j
      · intro h; exact (h rfl).elim
      · intro _; rfl
    have ht : CoordinateLipschitz (fun i : Fin n => c i.succ)
        (fun v => F (Fin.cons (y 0) v)) := by
      intro i u v huv
      apply hc i.succ
      intro j
      refine Fin.cases ?_ (fun k => ?_) j
      · intro _; rfl
      · intro hk; exact huv k (fun h => hk (congrArg Fin.succ h))
    have h1 := ih ht (Fin.tail x) (Fin.tail y)
    rw [Fin.cons_self_tail] at h1
    rw [Fin.sum_univ_succ]
    calc _ ≤ |F x-F z|+|F z-F y| := abs_sub_le _ _ _
      _ ≤ _ := add_le_add h0 h1

lemma coordinateLipschitz_memLp {n : ℕ} {c : Fin n → ℝ} {F : (Fin n → ℝ) → ℝ}
    (hF : Measurable F) (hc0 : ∀i,0≤c i) (hc : CoordinateLipschitz c F) :
    MemLp F 2 (Measure.pi (fun _ => gaussianReal 0 1)) := by
  have hs : MemLp (fun g : Fin n → ℝ => ∑i,c i*|g i|) 2
      (Measure.pi (fun _ => gaussianReal 0 1)) :=
    memLp_finsetSum _ (fun i _ =>
      ((memLp_id_gaussianReal (μ:=0) (v:=1) 2).comp_measurePreserving
        (measurePreserving_eval (fun _ : Fin n => gaussianReal 0 1) i)).abs.const_mul (c i))
  apply ((memLp_const |F 0|).add hs).mono hF.aestronglyMeasurable
  filter_upwards [] with g
  have h := coordinateLipschitz_global hc g 0
  simp only [Pi.zero_apply,sub_zero] at h
  simp only [Pi.add_apply,Real.norm_eq_abs]
  rw [abs_of_nonneg (add_nonneg (abs_nonneg _)
    (Finset.sum_nonneg (fun i _ => mul_nonneg (hc0 i) (abs_nonneg _))))]
  have ht := abs_add_le (F g-F 0) (F 0)
  simp only [sub_add_cancel] at ht
  linarith

lemma standardGaussian_second_moment :
    (∫x : ℝ,x^2 ∂gaussianReal 0 1)=1 := by
  have h := variance_eq_sub (memLp_id_gaussianReal (μ:=0) (v:=1) 2)
  simpa only [variance_id_gaussianReal,NNReal.coe_one,Pi.pow_apply,id_eq,
    integral_id_gaussianReal,zero_pow (by decide : 2≠0),sub_zero] using h.symm

lemma gaussian_variance_le_square {F : ℝ → ℝ} (hF : Measurable F) {c : ℝ}
    (h : ∀x,|F x-F 0|≤c*|x|) : variance F (gaussianReal 0 1)≤c^2 := by
  have hi : MemLp (fun x => c*|x|) 2 (gaussianReal 0 1) :=
    (memLp_id_gaussianReal 2).abs.const_mul c
  have hF0 : MemLp (fun x => F x-F 0) 2 (gaussianReal 0 1) := by
    apply hi.mono (hF.sub measurable_const).aestronglyMeasurable
    exact ae_of_all _ fun x => by
      simp only [Real.norm_eq_abs]
      exact (h x).trans (le_abs_self _)
  have hb : (∫x,(F x-F 0)^2 ∂gaussianReal 0 1) ≤
      ∫x,c^2*x^2 ∂gaussianReal 0 1 := by
    apply integral_mono hF0.integrable_sq
      ((memLp_id_gaussianReal 2).integrable_sq.const_mul (c^2))
    intro x
    calc (F x-F 0)^2 = |F x-F 0|^2 := (sq_abs _).symm
      _ ≤ (c*|x|)^2 := pow_le_pow_left₀ (abs_nonneg _) (h x) 2
      _ = c^2*x^2 := by rw [mul_pow,sq_abs]
  rw [integral_const_mul,standardGaussian_second_moment,mul_one] at hb
  rw [← variance_sub_const hF.aestronglyMeasurable (F 0)]
  exact (variance_le_expectation_sq (hF.sub measurable_const).aestronglyMeasurable).trans hb

lemma variance_prod_le_of_slices {A B : Type*} [MeasurableSpace A] [MeasurableSpace B]
    (μ : Measure A) (ν : Measure B) [IsProbabilityMeasure μ] [IsProbabilityMeasure ν]
    {F : A × B → ℝ} (hF : MemLp F 2 (μ.prod ν))
    (hSlices : ∀y,MemLp (fun x => F (x,y)) 2 μ)
    (hG : MemLp (fun y => ∫x,F (x,y) ∂μ) 2 ν) {c : ℝ}
    (hc : ∀y,variance (fun x => F (x,y)) μ≤c) :
    variance F (μ.prod ν) ≤ c+variance (fun y => ∫x,F (x,y) ∂μ) ν := by
  have hiF := hF.integrable (by norm_num)
  have hiF2 := hF.integrable_sq
  have hiG2 := hG.integrable_sq
  have hs (y : B) : (∫x,F (x,y)^2 ∂μ)≤c+(∫x,F (x,y) ∂μ)^2 := by
    have h := hc y
    rw [variance_eq_sub (hSlices y)] at h
    simp only [Pi.pow_apply] at h
    linarith
  have hb := integral_mono hiF2.integral_prod_right ((integrable_const c).add hiG2) hs
  simp only [Pi.add_apply] at hb
  rw [integral_add (integrable_const _) hiG2,integral_const] at hb
  simp only [Measure.real,measure_univ,ENNReal.toReal_one,one_smul] at hb
  rw [variance_eq_sub hF,variance_eq_sub hG]
  simp only [Pi.pow_apply]
  rw [integral_prod_symm _ hiF2,integral_prod_symm _ hiF]
  linarith

theorem gaussian_pi_variance_le {n : ℕ} {c : Fin n → ℝ} {F : (Fin n → ℝ) → ℝ}
    (hF : Measurable F) (hc0 : ∀i,0≤c i) (hc : CoordinateLipschitz c F) :
    variance F (Measure.pi (fun _ => gaussianReal 0 1)) ≤ ∑i,c i^2 := by
  induction n with
  | zero =>
    have he : F=fun _ => F Fin.elim0 := by funext x; congr 1; exact Subsingleton.elim _ _
    rw [he,variance_eq_integral measurable_const.aemeasurable]
    simp
  | succ n ih =>
    let ν : Measure (Fin n → ℝ) := Measure.pi (fun _ => gaussianReal 0 1)
    let H : ℝ × (Fin n → ℝ) → ℝ := fun p => F (Fin.cons p.1 p.2)
    have hmH : Measurable H := by
      apply hF.comp
      apply Measurable.of_eval
      intro i
      refine Fin.cases ?_ (fun j => ?_) i
      · exact measurable_fst
      · exact (measurable_pi_apply j).comp measurable_snd
    have hmp := (measurePreserving_piFinSuccAbove (fun _ : Fin (n+1) => gaussianReal 0 1) 0).symm
    have he (p : ℝ × (Fin n → ℝ)) :
        (MeasurableEquiv.piFinSuccAbove (fun _ : Fin (n+1) => ℝ) 0).symm p=Fin.cons p.1 p.2 := by
      simp [MeasurableEquiv.piFinSuccAbove_symm_apply,Fin.insertNthEquiv]
    have hH : MemLp H 2 ((gaussianReal 0 1).prod ν) := by
      have hh := (coordinateLipschitz_memLp hF hc0 hc).comp_measurePreserving hmp
      have hhfun : F ∘ (MeasurableEquiv.piFinSuccAbove (fun _ : Fin (n+1) => ℝ) 0).symm=H := by
        funext p; exact congrArg F (he p)
      rw [hhfun] at hh
      exact hh
    have hslice (y : Fin n → ℝ) : ∀x,|H (x,y)-H (0,y)|≤c 0*|x| := by
      intro x
      have ht := hc 0 (Fin.cons x y) (Fin.cons 0 y) (by
        intro j; refine Fin.cases ?_ (fun k => ?_) j
        · intro h; exact (h rfl).elim
        · intro _; rfl)
      simpa only [Fin.cons_zero,sub_zero] using ht
    have hmSlice (y : Fin n → ℝ) : Measurable (fun x => H (x,y)) :=
      hmH.comp (measurable_id.prodMk measurable_const)
    have hiSlice (y : Fin n → ℝ) : MemLp (fun x => H (x,y)) 2 (gaussianReal 0 1) := by
      apply ((memLp_const |H (0,y)|).add ((memLp_id_gaussianReal 2).abs.const_mul (c 0))).mono
        (hmSlice y).aestronglyMeasurable
      filter_upwards [] with x
      simp only [Pi.add_apply,Real.norm_eq_abs,Pi.abs_apply,id_eq]
      rw [abs_of_nonneg (add_nonneg (abs_nonneg _) (mul_nonneg (hc0 _) (abs_nonneg _)))]
      have h := hslice y x
      have ht := abs_add_le (H (x,y)-H (0,y)) (H (0,y))
      simp only [sub_add_cancel] at ht
      linarith
    let G : (Fin n → ℝ) → ℝ := fun y => ∫x,H (x,y) ∂gaussianReal 0 1
    have hmG : Measurable G := hmH.stronglyMeasurable.integral_prod_left'.measurable
    have hcG : CoordinateLipschitz (fun i : Fin n => c i.succ) G := by
      intro i x y hxy
      dsimp only [G]
      rw [← integral_sub ((hiSlice x).integrable (by norm_num)) ((hiSlice y).integrable (by norm_num))]
      apply bounded_mean
      intro a
      have ht := hc i.succ (Fin.cons a x) (Fin.cons a y) (by
        intro j; refine Fin.cases ?_ (fun k => ?_) j
        · intro _; rfl
        · intro h; exact hxy k (fun he => h (congrArg Fin.succ he)))
      exact ht
    have hG := coordinateLipschitz_memLp hmG (fun i => hc0 i.succ) hcG
    have hb := variance_prod_le_of_slices (gaussianReal 0 1) ν hH hiSlice hG
      (fun y => gaussian_variance_le_square (hmSlice y) (hslice y))
    have hvar : variance F (Measure.pi (fun _ => gaussianReal 0 1))=
        variance H ((gaussianReal 0 1).prod ν) := by
      rw [← hmp.map_eq,variance_map hF.aemeasurable hmp.measurable.aemeasurable]
      congr 1; funext p; exact congrArg F (he p)
    rw [hvar,Fin.sum_univ_succ]
    exact hb.trans (add_le_add le_rfl (ih hmG (fun i => hc0 i.succ) hcG))

end IsingPerceptron.Main

namespace IsingPerceptron
namespace Main
open MeasureTheory ProbabilityTheory Filter
open scoped BigOperators Topology

abbrev Spins (N : ℕ) := Fin N → Bool

def spin {N : ℕ} (x : Spins N) (i : Fin N) : ℝ := if x i then 1 else -1

def patternCount (α : ℝ) (N : ℕ) : ℕ := ⌊α * N⌋₊

abbrev Disorder (α : ℝ) (N : ℕ) := Fin (patternCount α N) → Fin N → ℝ

def disorderLaw (α : ℝ) (N : ℕ) : Measure (Disorder α N) :=
  Measure.pi fun _ => Measure.pi fun _ => gaussianReal 0 1

def patternEvaluation {α : ℝ} {N : ℕ} (g : Disorder α N)
    (a : Fin (patternCount α N)) (x : Spins N) : ℝ :=
  (∑ i : Fin N, g a i * spin x i) / Real.sqrt N

def partitionFunction (α : ℝ) (f : ℝ → ℝ) (N : ℕ) (g : Disorder α N) : ℝ :=
  (∑ x : Spins N, Real.exp (∑ a, f (patternEvaluation g a x))) / (2 : ℝ) ^ N

def pressure (α : ℝ) (f : ℝ → ℝ) (N : ℕ) (g : Disorder α N) : ℝ :=
  Real.log (partitionFunction α f N g) / N

def meanPressure (α : ℝ) (f : ℝ → ℝ) (N : ℕ) : ℝ :=
  ∫ g, pressure α f N g ∂disorderLaw α N

structure Partition where
  count : ℕ
  positive : 0 < count
  ζ : Fin (count + 1) → ℝ
  strictMono : StrictMono ζ
  first : ζ 0 = 0
  last : ζ (Fin.last count) = 1

structure StepPath where
  partition : Partition
  value : Fin partition.count → ℝ
  monotone : Monotone value

def StepPath.stepValue (h : StepPath) (u : ℝ) : ℝ :=
  ∑ i : Fin h.partition.count,
    if h.partition.ζ i.castSucc ≤ u ∧ u < h.partition.ζ i.succ then h.value i else 0

abbrev StepField := {h : StepPath // ∀ i, 0 ≤ h.value i}
abbrev StepOverlap := {q : StepPath // ∀ i, q.value i ∈ Set.Icc (0 : ℝ) 1}

def gaussianTransform (s d : ℝ) (U : ℝ → ℝ) (x : ℝ) : ℝ :=
  if d = 0 then ∫ G, U (x + Real.sqrt s * G) ∂gaussianReal 0 1
  else (Real.log (∫ G, Real.exp (d * U (x + Real.sqrt s * G)) ∂gaussianReal 0 1)) / d

def StepPath.increment (q : StepPath) (top : ℝ) (i : ℕ) : ℝ :=
  (if hi : i < q.partition.count then q.value ⟨i, hi⟩ else top) -
  (if i = 0 then 0 else
    if hi : i - 1 < q.partition.count then q.value ⟨i - 1, hi⟩ else top)

def stepPattern (f : ℝ → ℝ) (q : StepOverlap) : ℝ :=
  ((List.finRange (q.val.partition.count + 1)).foldr
    (fun (i : Fin (q.val.partition.count + 1)) U => gaussianTransform (q.val.increment 1 i) (q.val.partition.ζ i) U) f) 0

def fieldFunctional (h : StepField) : ℝ :=
  let last := h.val.value ⟨h.val.partition.count - 1, by have := h.val.partition.positive; omega⟩
  ((List.finRange h.val.partition.count).foldr
    (fun (i : Fin h.val.partition.count) U => gaussianTransform (h.val.increment last i) (h.val.partition.ζ i.castSucc) U)
    (fun x => Real.log (Real.cosh x) - last / 2)) 0

abbrev OpenUnit := Set.Ioo (0 : ℝ) 1
abbrev OverlapRep := OpenUnit →o Set.Icc (0 : ℝ) 1

def extendRep (q : OverlapRep) (u : ℝ) : ℝ :=
  if hu : u ∈ Set.Ioo (0 : ℝ) 1 then (q ⟨u, hu⟩ : ℝ) else 0

def pathSetoid : Setoid OverlapRep where
  r q r := extendRep q =ᵐ[volume.restrict (Set.Ioo (0 : ℝ) 1)] extendRep r
  iseqv := ⟨fun _ => Filter.EventuallyEq.rfl,
    fun h => h.symm, fun h₁ h₂ => h₁.trans h₂⟩

def OverlapPath := Quotient pathSetoid

def uniformPartition (m : ℕ) (hm : 0 < m) : Partition where
  count := m
  positive := hm
  ζ i := (i : ℝ) / m
  strictMono := by
    intro i j hij
    exact div_lt_div_of_pos_right (by exact_mod_cast hij) (by exact_mod_cast hm)
  first := by simp
  last := by simp [ne_of_gt hm]

def midpoint (m : ℕ) (hm : 0 < m) (i : Fin m) : OpenUnit :=
  ⟨((i : ℝ) + 1 / 2) / m, by
    have hm' : 0 < (m : ℝ) := by exact_mod_cast hm
    have hi' : (i : ℝ) < m := by exact_mod_cast i.isLt
    constructor
    · exact div_pos (by positivity) hm'
    · apply (div_lt_one hm').mpr
      have hi'' : (i : ℝ) + 1 ≤ m := by exact_mod_cast i.isLt
      linarith⟩

lemma midpoint_monotone (m : ℕ) (hm : 0 < m) : Monotone (midpoint m hm) := by
  intro i j hij
  change ((i : ℝ) + 1 / 2) / m ≤ ((j : ℝ) + 1 / 2) / m
  apply div_le_div_of_nonneg_right _ (by positivity)
  have : (i : ℝ) ≤ j := by exact_mod_cast hij
  linarith

def dyadicStep (q : OverlapPath) (n : ℕ) : StepOverlap :=
  let m := 2 ^ n
  have hm : 0 < m := pow_pos (by decide) _
  ⟨⟨uniformPartition m hm,
      (fun i => (q.out (midpoint m hm i) : ℝ)),
      fun i j hij => (q.out.monotone (midpoint_monotone m hm hij))⟩,
    fun i => (q.out (midpoint m hm i)).property⟩

def patternFunctional (f : ℝ → ℝ) (q : OverlapPath) : ℝ :=
  Filter.limUnder atTop (fun n => stepPattern f (dyadicStep q n))

def isingEntropy (q : OverlapPath) : EReal :=
  ⨆ h : StepField,
    ((fieldFunctional h + (1 / 2) *
      ∫ u in Set.Ioo (0 : ℝ) 1, h.val.stepValue u * extendRep q.out u) : ℝ)

def variationalValue (α : ℝ) (f : ℝ → ℝ) : EReal :=
  ⨅ q : OverlapPath, ((α * patternFunctional f q : ℝ) : EReal) + isingEntropy q

def PressureConvergesInProbability (α : ℝ) (f : ℝ → ℝ) (p : ℝ) : Prop :=
  ∀ ε : ℝ, 0 < ε → Tendsto
    (fun N => disorderLaw α N {g | ε < |pressure α f N g - p|}) atTop (𝓝 0)

end Main
end IsingPerceptron

namespace IsingPerceptron.Main
open MeasureTheory ProbabilityTheory Filter Set Real
open scoped BigOperators NNReal ENNReal Topology Classical

lemma spin_card (N : ℕ) : Fintype.card (Spins N) = 2^N := by simp [Spins]

lemma finite_exp_average_pos {S : Type*} [Fintype S] [Nonempty S] (H : S → ℝ) :
    0 < (∑x,exp (H x))/(Fintype.card S : ℝ) := by
  apply div_pos
  · exact Finset.sum_pos (fun x _ => exp_pos _) Finset.univ_nonempty
  · exact_mod_cast Fintype.card_pos

lemma finite_log_average_le {S : Type*} [Fintype S] [Nonempty S]
    (H K : S → ℝ) (d : ℝ) (h : ∀x,H x≤K x+d) :
    log ((∑x,exp (H x))/(Fintype.card S : ℝ)) ≤
    log ((∑x,exp (K x))/(Fintype.card S : ℝ))+d := by
  have hsum : ∑x,exp (H x) ≤ exp d * ∑x,exp (K x) := by
    rw [Finset.mul_sum]
    apply Finset.sum_le_sum
    intro x _
    calc exp (H x) ≤ exp (K x+d) := exp_le_exp.mpr (h x)
      _ = exp d*exp (K x) := by rw [exp_add,mul_comm]
  have hcard : (0:ℝ)<Fintype.card S := by exact_mod_cast Fintype.card_pos
  have hl := log_le_log (finite_exp_average_pos H)
    (div_le_div_of_nonneg_right hsum hcard.le)
  rw [mul_div_assoc,log_mul (exp_pos _).ne' (finite_exp_average_pos K).ne',log_exp] at hl
  linarith

lemma finite_log_average_abs {S : Type*} [Fintype S] [Nonempty S]
    (H : S → ℝ) (d : ℝ) (h : ∀x,|H x|≤d) :
    |log ((∑x,exp (H x))/(Fintype.card S : ℝ))|≤d := by
  have hcard : (Fintype.card S : ℝ)≠0 := by exact_mod_cast Fintype.card_ne_zero
  have hu := finite_log_average_le H (fun _ => 0) d (fun x => by simpa using (abs_le.mp (h x)).2)
  have hl := finite_log_average_le (fun _ => 0) H d (fun x => by have := (abs_le.mp (h x)).1; linarith)
  simp only [exp_zero,Finset.sum_const,Finset.card_univ,nsmul_eq_mul,mul_one,div_self hcard,log_one] at hu hl
  exact abs_le.mpr ⟨by linarith,by linarith⟩

lemma finite_log_average_difference {S : Type*} [Fintype S] [Nonempty S]
    (H K : S → ℝ) (d : ℝ) (h : ∀x,|H x-K x|≤d) :
    |log ((∑x,exp (H x))/(Fintype.card S : ℝ))-
      log ((∑x,exp (K x))/(Fintype.card S : ℝ))|≤d := by
  have hu := finite_log_average_le H K d (fun x => by have := (abs_le.mp (h x)).2; linarith)
  have hl := finite_log_average_le K H d (fun x => by have := (abs_le.mp (h x)).1; linarith)
  exact abs_le.mpr ⟨by linarith,by linarith⟩

lemma pressure_measurable (α : ℝ) {f : ℝ → ℝ} (hf : Measurable f) (N : ℕ) :
    Measurable (pressure α f N) := by
  unfold pressure partitionFunction patternEvaluation
  fun_prop

lemma pressure_bounded (α : ℝ) {f : ℝ → ℝ} {C : ℝ} (hC : ∀x,|f x|≤C)
    (N : ℕ) (g : Disorder α N) :
    |pressure α f N g| ≤ (patternCount α N : ℝ)*C/N := by
  have hH (x : Spins N) : |∑a,f (patternEvaluation g a x)|≤(patternCount α N : ℝ)*C := by
    calc |∑a,f (patternEvaluation g a x)| ≤ ∑a,|f (patternEvaluation g a x)| := Finset.abs_sum_le_sum_abs _ _
      _ ≤ ∑_a : Fin (patternCount α N),C := Finset.sum_le_sum (fun a _ => hC _)
      _ = _ := by simp
  have hL := finite_log_average_abs (fun x : Spins N => ∑a,f (patternEvaluation g a x)) _ hH
  rw [spin_card] at hL
  simpa only [pressure,partitionFunction,abs_div,abs_of_nonneg (show (0:ℝ)≤N from Nat.cast_nonneg N),Nat.cast_pow,Nat.cast_ofNat] using
    div_le_div_of_nonneg_right hL (Nat.cast_nonneg N)

lemma pressure_row_difference (α : ℝ) {f : ℝ → ℝ} {C : ℝ} (hC : ∀x,|f x|≤C)
    (N : ℕ) (a : Fin (patternCount α N)) (g g' : Disorder α N)
    (heq : ∀b,b≠a → g b=g' b) :
    |pressure α f N g-pressure α f N g'|≤2*C/N := by
  have hH (x : Spins N) :
      |(∑b,f (patternEvaluation g b x))-(∑b,f (patternEvaluation g' b x))|≤2*C := by
    rw [← Finset.sum_sub_distrib,Finset.sum_eq_single a]
    · calc |f (patternEvaluation g a x)-f (patternEvaluation g' a x)| ≤
          |f (patternEvaluation g a x)|+|f (patternEvaluation g' a x)| := abs_sub _ _
        _ ≤ _ := by linarith [hC (patternEvaluation g a x),hC (patternEvaluation g' a x)]
    · intro b _ hba
      have hargument : patternEvaluation g b x=patternEvaluation g' b x := by
        unfold patternEvaluation
        rw [heq b hba]
      rw [hargument,sub_self]
    · simp
  have hL := finite_log_average_difference
    (fun x : Spins N => ∑b,f (patternEvaluation g b x))
    (fun x : Spins N => ∑b,f (patternEvaluation g' b x)) (2*C) hH
  rw [spin_card] at hL
  simpa only [pressure,partitionFunction,← sub_div,abs_div,abs_of_nonneg (show (0:ℝ)≤N from Nat.cast_nonneg N),Nat.cast_pow,Nat.cast_ofNat] using
    div_le_div_of_nonneg_right hL (Nat.cast_nonneg N)

theorem pressure_variance_bound (α : ℝ) {f : ℝ → ℝ} (hf : Measurable f)
    {C : ℝ} (hC : ∀x,|f x|≤C) (N : ℕ) :
    variance (pressure α f N) (disorderLaw α N) ≤
      (patternCount α N : ℝ)*(2*C/N)^2 := by
  have h := variance_pi_bounded_differences
    (fun _ : Fin (patternCount α N) => (Measure.pi fun _ : Fin N => gaussianReal 0 1))
    (pressure_measurable α hf N) (pressure_bounded α hC N)
    (fun _ => 2*C/N) (pressure_row_difference α hC N)
  simpa only [disorderLaw,Finset.sum_const,Finset.card_univ,Fintype.card_fin,nsmul_eq_mul] using h

lemma pressure_variance_rate (α : ℝ) (hα : 0≤α) {f : ℝ → ℝ} (hf : Measurable f)
    {C : ℝ} (hC : ∀x,|f x|≤C) {N : ℕ} (hN : 0<N) :
    variance (pressure α f N) (disorderLaw α N) ≤ 4*α*C^2/N := by
  have hNr : (0:ℝ)<N := by exact_mod_cast hN
  refine (pressure_variance_bound α hf hC N).trans ?_
  calc (patternCount α N : ℝ)*(2*C/N)^2 ≤ α*N*(2*C/N)^2 :=
      mul_le_mul_of_nonneg_right (Nat.floor_le (mul_nonneg hα hNr.le)) (sq_nonneg _)
    _ = _ := by field_simp; ring

theorem pressure_tail_bound (α : ℝ) (hα : 0≤α) {f : ℝ → ℝ} (hf : Measurable f)
    {C : ℝ} (hC : ∀x,|f x|≤C) {N : ℕ} (hN : 0<N) {ε : ℝ} (hε : 0<ε) :
    disorderLaw α N {g | ε < |pressure α f N g-meanPressure α f N|} ≤
      ENNReal.ofReal ((4*α*C^2/ε^2)/N) := by
  have : IsProbabilityMeasure (disorderLaw α N) := by
    dsimp [disorderLaw]; infer_instance
  have hL := meas_ge_le_variance_div_sq
    (bounded_memLp (disorderLaw α N) (pressure_measurable α hf N) (pressure_bounded α hC N)) hε
  have hsubset : {g | ε < |pressure α f N g-meanPressure α f N|} ⊆
      {g | ε ≤ |pressure α f N g-meanPressure α f N|} := by
    intro g hg
    exact (show ε < |pressure α f N g-meanPressure α f N| from hg).le
  refine (measure_mono hsubset).trans (hL.trans ?_)
  apply ENNReal.ofReal_le_ofReal
  calc variance (pressure α f N) (disorderLaw α N)/ε^2 ≤ (4*α*C^2/N)/ε^2 :=
      div_le_div_of_nonneg_right (pressure_variance_rate α hα hf hC hN) (sq_nonneg _)
    _ = _ := by ring

theorem pressure_centered_concentration (α : ℝ) (hα : 0≤α) {f : ℝ → ℝ}
    (hf : Measurable f) (hbounded : ∃C,∀x,|f x|≤C) {ε : ℝ} (hε : 0<ε) :
    Tendsto (fun N => disorderLaw α N
      {g | ε < |pressure α f N g-meanPressure α f N|}) atTop (𝓝 0) := by
  obtain ⟨C,hC⟩ := hbounded
  have hrate : Tendsto (fun N : ℕ => ENNReal.ofReal ((4*α*C^2/ε^2)/N)) atTop (𝓝 0) := by
    simpa only [ENNReal.ofReal_zero] using
      ENNReal.tendsto_ofReal (tendsto_const_div_atTop_nhds_zero_nat (4*α*C^2/ε^2))
  apply tendsto_of_tendsto_of_tendsto_of_le_of_le' tendsto_const_nhds hrate
  · exact Eventually.of_forall (fun _ => bot_le)
  · filter_upwards [eventually_gt_atTop (0:ℕ)] with N hN
    exact pressure_tail_bound α hα hf hC hN hε

end IsingPerceptron.Main

namespace IsingPerceptron.Main
open MeasureTheory ProbabilityTheory Real
open scoped BigOperators Topology
variable {S : Type*} [Fintype S] [Nonempty S]

def finiteGibbs (H V : S → ℝ) : ℝ := (∑x,exp (H x)*V x)/(∑x,exp (H x))

lemma finiteGibbs_den_pos (H : S → ℝ) : 0<∑x,exp (H x) :=
  Finset.sum_pos (fun _ _ => exp_pos _) Finset.univ_nonempty

lemma finiteGibbs_abs (H V : S → ℝ) {C : ℝ} (h : ∀x,|V x|≤C) :
    |finiteGibbs H V|≤C := by
  rw [finiteGibbs,abs_div,abs_of_pos (finiteGibbs_den_pos H)]
  apply (div_le_iff₀ (finiteGibbs_den_pos H)).mpr
  calc |∑x,exp (H x)*V x| ≤ ∑x,|exp (H x)*V x| := Finset.abs_sum_le_sum_abs _ _
    _ ≤ ∑x,exp (H x)*C := Finset.sum_le_sum (fun x _ => by
      rw [abs_mul,abs_of_pos (exp_pos _)]; exact mul_le_mul_of_nonneg_left (h x) (exp_pos _).le)
    _ = C*∑x,exp (H x) := by rw [← Finset.sum_mul,mul_comm]

omit [Nonempty S] in
lemma finiteGibbs_add (H V W : S → ℝ) :
    finiteGibbs H (fun x => V x+W x)=finiteGibbs H V+finiteGibbs H W := by
  simp only [finiteGibbs,mul_add,Finset.sum_add_distrib,add_div]

omit [Nonempty S] in
lemma finiteGibbs_mul_const (H V : S → ℝ) (c : ℝ) :
    finiteGibbs H (fun x => V x*c)=finiteGibbs H V*c := by
  simp only [finiteGibbs,← mul_assoc,← Finset.sum_mul]
  ring

omit [Nonempty S] in
lemma finiteGibbs_div_const (H V : S → ℝ) (c : ℝ) :
    finiteGibbs H (fun x => V x/c)=finiteGibbs H V/c := by
  simp only [div_eq_mul_inv,finiteGibbs_mul_const]

omit [Nonempty S] in
lemma finiteGibbs_measurable {A : Type*} [MeasurableSpace A]
    {H V : A → S → ℝ} (hH : ∀x,Measurable (fun a => H a x))
    (hV : ∀x,Measurable (fun a => V a x)) :
    Measurable (fun a => finiteGibbs (H a) (V a)) := by
  unfold finiteGibbs
  fun_prop

theorem finiteGibbs_derivative {H V : ℝ → S → ℝ} {HD VD : S → ℝ} {t : ℝ}
    (hH : ∀x,HasDerivAt (fun t => H t x) (HD x) t)
    (hV : ∀x,HasDerivAt (fun t => V t x) (VD x) t) :
    HasDerivAt (fun t => finiteGibbs (H t) (V t))
      (finiteGibbs (H t) (fun x => VD x+V t x*HD x)-
        finiteGibbs (H t) (V t)*finiteGibbs (H t) HD) t := by
  have hnum := HasDerivAt.fun_sum (u:=Finset.univ)
    (fun x _ => (hH x).exp.mul (hV x))
  have hden := HasDerivAt.fun_sum (u:=Finset.univ) (fun x _ => (hH x).exp)
  apply (hnum.fun_div hden (finiteGibbs_den_pos (H t)).ne').congr_deriv
  simp only [finiteGibbs,Pi.mul_apply]
  have he : (∑x,(exp (H t x)*HD x*V t x+exp (H t x)*VD x))=
      ∑x,exp (H t x)*(VD x+V t x*HD x) := by
    apply Finset.sum_congr rfl; intro x _; ring
  rw [he]
  field_simp [(finiteGibbs_den_pos (H t)).ne']

omit [Nonempty S] in
lemma finiteGibbs_sum {I : Type*} (s : Finset I) (H : S → ℝ) (V : I → S → ℝ) :
    finiteGibbs H (fun x => ∑i ∈ s,V i x)=∑i ∈ s,finiteGibbs H (V i) := by
  simp only [finiteGibbs,Finset.mul_sum,Finset.sum_div]
  exact Finset.sum_comm

omit [Nonempty S] in
lemma finiteGibbs_const_mul (H V : S → ℝ) (c : ℝ) :
    finiteGibbs H (fun x => c*V x)=c*finiteGibbs H V := by
  simpa only [mul_comm] using finiteGibbs_mul_const H V c

def finiteGibbsPair (H : S → ℝ) (V : S → S → ℝ) : ℝ :=
  finiteGibbs H (fun x => finiteGibbs H (V x))

end IsingPerceptron.Main

namespace IsingPerceptron.Main
open MeasureTheory ProbabilityTheory Filter Real
open scoped Topology

lemma standardDensity_derivative (x : ℝ) :
    HasDerivAt (gaussianPDFReal 0 1) (-x*gaussianPDFReal 0 1 x) x := by
  have heq : gaussianPDFReal 0 1 =
      (fun y : ℝ => (Real.sqrt (2*Real.pi))⁻¹ * Real.exp (-(y^2)/2)) := by
    funext y
    simp [gaussianPDFReal]
  rw [heq]
  have h : HasDerivAt (fun y : ℝ => Real.exp (-(y^2)/2))
      (-x*Real.exp (-(x^2)/2)) x := by
    convert! ((hasDerivAt_id x).pow 2 |>.neg |>.div_const 2).exp using 1
    simp only [Pi.neg_apply, Pi.pow_apply, id_eq]; ring
  exact (h.const_mul ((Real.sqrt (2*Real.pi))⁻¹)).congr_deriv (by ring)

lemma standardDensity_times_id_integrable :
    Integrable (fun x : ℝ => gaussianPDFReal 0 1 x*x) := by
  have h := (integrable_mul_exp_neg_mul_sq (b:=(1:ℝ)/2) (by positivity)).const_mul
    ((Real.sqrt (2*Real.pi))⁻¹)
  convert h using 1
  ext x
  simp [gaussianPDFReal]
  ring_nf

theorem gaussian_integration_by_parts {F F' : ℝ → ℝ} {C D : ℝ}
    (hd : ∀x,HasDerivAt F (F' x) x) (hm : Measurable F')
    (hC : ∀x,|F x|≤C) (hD : ∀x,|F' x|≤D) :
    (∫x,x*F x ∂gaussianReal 0 1) = ∫x,F' x ∂gaussianReal 0 1 := by
  have hF : Measurable F := (continuous_iff_continuousAt.mpr (fun x => (hd x).continuousAt)).measurable
  have hbase : Integrable (fun x => gaussianPDFReal 0 1 x*F x) :=
    (integrable_gaussianPDFReal 0 1).mul_bdd hF.aestronglyMeasurable
      (ae_of_all _ fun x => hC x)
  have hfirst : Integrable (fun x => gaussianPDFReal 0 1 x*F' x) :=
    (integrable_gaussianPDFReal 0 1).mul_bdd hm.aestronglyMeasurable
      (ae_of_all _ fun x => hD x)
  have hsecond : Integrable (fun x => gaussianPDFReal 0 1 x*(x*F x)) := by
    simpa only [mul_assoc] using standardDensity_times_id_integrable.mul_bdd
      hF.aestronglyMeasurable (ae_of_all _ fun x => hC x)
  have hderiv (x : ℝ) : HasDerivAt (fun x => gaussianPDFReal 0 1 x*F x)
      (gaussianPDFReal 0 1 x*F' x-gaussianPDFReal 0 1 x*(x*F x)) x := by
    exact ((standardDensity_derivative x).mul (hd x)).congr_deriv (by ring)
  have hi := integral_eq_zero_of_hasDerivAt_of_integrable hderiv
    (hfirst.sub hsecond) hbase
  rw [integral_sub hfirst hsecond] at hi
  rw [integral_gaussianReal_eq_integral_smul (by norm_num : (1:NNReal)≠0),
    integral_gaussianReal_eq_integral_smul (by norm_num : (1:NNReal)≠0)]
  simpa only [smul_eq_mul] using (sub_eq_zero.mp hi).symm

theorem gaussian_pi_integration_by_parts {n : ℕ} (i : Fin (n+1))
    {F D : (Fin (n+1) → ℝ) → ℝ} (hF : Measurable F) (hD : Measurable D)
    {C E : ℝ} (hC : ∀g,|F g|≤C) (hE : ∀g,|D g|≤E)
    (hd : ∀(y : Fin n → ℝ) t,
      HasDerivAt (fun t => F (i.insertNth t y)) (D (i.insertNth t y)) t) :
    (∫g,g i*F g ∂Measure.pi (fun _ => gaussianReal 0 1)) =
      ∫g,D g ∂Measure.pi (fun _ => gaussianReal 0 1) := by
  let e := MeasurableEquiv.piFinSuccAbove (fun _ : Fin (n+1) => ℝ) i
  let ν : Measure (Fin n → ℝ) := Measure.pi (fun _ => gaussianReal 0 1)
  have hm := (measurePreserving_piFinSuccAbove
    (fun _ : Fin (n+1) => gaussianReal 0 1) i).symm
  have hmap (p : ℝ × (Fin n → ℝ)) : e.symm p=i.insertNth p.1 p.2 := rfl
  have hf : Measurable (fun p : ℝ × (Fin n → ℝ) => F (i.insertNth p.1 p.2)) :=
    hF.comp e.symm.measurable
  have hdM : Measurable (fun p : ℝ × (Fin n → ℝ) => D (i.insertNth p.1 p.2)) :=
    hD.comp e.symm.measurable
  have hi : Integrable (fun p : ℝ × (Fin n → ℝ) => p.1*F (i.insertNth p.1 p.2))
      ((gaussianReal 0 1).prod ν) :=
    (IsGaussian.integrable_id (μ:=gaussianReal 0 1)).comp_fst ν |>.mul_bdd
      hf.aestronglyMeasurable (ae_of_all _ fun p => hC _)
  have hiD : Integrable (fun p : ℝ × (Fin n → ℝ) => D (i.insertNth p.1 p.2))
      ((gaussianReal 0 1).prod ν) :=
    Integrable.of_bound hdM.aestronglyMeasurable E
      (ae_of_all _ fun p => by simpa only [Real.norm_eq_abs] using hE (i.insertNth p.1 p.2))
  rw [← hm.integral_comp' (fun g => g i*F g), ← hm.integral_comp' D]
  simp only [MeasurableEquiv.piFinSuccAbove_symm_apply,Fin.insertNthEquiv,
    Equiv.coe_fn_mk,Fin.insertNth_apply_same]
  change (∫p,p.1*F (i.insertNth p.1 p.2) ∂(gaussianReal 0 1).prod ν) =
    ∫p,D (i.insertNth p.1 p.2) ∂(gaussianReal 0 1).prod ν
  rw [integral_prod_symm _ hi,integral_prod_symm _ hiD]
  apply integral_congr_ae
  exact ae_of_all _ fun y => gaussian_integration_by_parts (hd y)
    (hdM.comp (measurable_id.prodMk measurable_const)) (fun t => hC _) (fun t => hE _)

end IsingPerceptron.Main

end

end OAI