lean/OAI/Probability/IsingPerceptron/EnrichedCGF.lean

import Mathlib
import OAI.Probability.IsingPerceptron.NamespaceSplit

namespace OAI

/-! Enriched C G F. -/

noncomputable section

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

lemma integral_comp_preserving_ae {A B : Type*} [MeasurableSpace A] [MeasurableSpace B]
    {μ : Measure A} {ν : Measure B} {f : A → B} (hf : MeasurePreserving f μ ν)
    {F : B → ℝ} (hF : AEStronglyMeasurable F ν) :
    (∫ x, F (f x) ∂μ) = ∫ y, F y ∂ν := by
  have h := integral_map hf.measurable.aemeasurable (hf.map_eq.symm ▸ hF)
  rw [hf.map_eq] at h
  exact h.symm

def enrichedMeanPressure {N : ℕ} {A : Type*} [MeasurableSpace A]
    (P : Measure A) (r : ℝ≥0) (n : ℕ) (b h : ℕ → ℝ)
    (u : Fin N → ℝ) (ν : Measure (Spin N)) (φ : A → Spin N → ℝ) : ℝ :=
  ∫ p, enrichedCylinderPressure n h u ν φ p ∂enrichedCylinderLaw P r n b

def enrichedCGF {N : ℕ} {A : Type*} (n : ℕ) (h : ℕ → ℝ)
    (u : Fin N → ℝ) (j : Fin N) (ν : Measure (Spin N)) (φ : A → Spin N → ℝ)
    (v : ℝ) (p : EnrichedFrozenData n j A × (ℕ → ℝ)) : ℝ :=
  cgf (fun s => cylinderField (monomialCoefficients n (monomialIndex j).1 (monomialIndex j).2 s) p.2)
    (enrichedFrozenReference n h u j ν φ p.1) (perturbationAmplitude N j*v)

theorem enrichedCGF_integral {N : ℕ} (hN : 0 < N) (n : ℕ) (b : ℕ → ℝ)
    (hb : CascadeExponents n b) {h : ℕ → ℝ} (hh : Monotone h) (h0 : 0 ≤ h 0)
    (u : Fin N → ℝ) (hu : ∀ j, |u j| ≤ 2) (j : Fin N) {v : ℝ} (hv : |v| ≤ 2)
    (ν : Measure (Spin N)) [IsProbabilityMeasure ν]
    {A : Type*} [MeasurableSpace A] (P : Measure A) [IsProbabilityMeasure P]
    {φ : A → Spin N → ℝ} (hm : Measurable φ) {K : ℝ} (hK : 0 ≤ K)
    (hφ : ∀ y x, |φ y x| ≤ K) (r : ℝ≥0) :
    let Q := (enrichedFrozenLaw P r n b j).prod gaussianCoordinates
    MemLp (enrichedCGF n h u j ν φ v) 2 Q ∧
      (∫ z, enrichedCGF n h u j ν φ v z ∂Q) =
      N*(enrichedMeanPressure P r n b h (Function.update u j v) ν φ -
        enrichedMeanPressure P r n b h (Function.update u j 0) ν φ) := by
  have hn : (0:ℝ) < N := by exact_mod_cast hN
  have hv1 := (enrichedCylinderPressure_field_cap hN n b hb hh h0 (le_refl (h n))
    (Function.update u j v) (update_abs_le_two hu j hv) ν P hm hK hφ r
    (α := (r:ℝ)/N) (by rw [div_mul_cancel₀ _ hn.ne'])).1
  have h01 := (enrichedCylinderPressure_field_cap hN n b hb hh h0 (le_refl (h n))
    (Function.update u j 0) (update_abs_le_two hu j (by norm_num)) ν P hm hK hφ r
    (α := (r:ℝ)/N) (by rw [div_mul_cancel₀ _ hn.ne'])).1
  have hp := enrichedInsert_preserving P r n b j
  have hv2 := hv1.comp_measurePreserving hp
  have h02 := h01.comp_measurePreserving hp
  have he := enriched_cgf_eq_pressure_difference hN n b hh h0 u hu j hv ν P hK hφ r
  change enrichedCGF n h u j ν φ v =ᵐ[(enrichedFrozenLaw P r n b j).prod gaussianCoordinates]
    (fun p => N*(enrichedCylinderPressure n h (Function.update u j v) ν φ (enrichedInsert n j p) -
      enrichedCylinderPressure n h (Function.update u j 0) ν φ (enrichedInsert n j p))) at he
  have hL := (hv2.sub h02).const_mul (N:ℝ)
  refine ⟨MemLp.ae_eq he.symm hL, ?_⟩
  rw [integral_congr_ae he, integral_const_mul]
  have hisub := integral_sub (hv2.integrable (by norm_num)) (h02.integrable (by norm_num))
  dsimp only [Function.comp_def] at hisub
  rw [hisub]
  rw [integral_comp_preserving_ae hp hv1.aestronglyMeasurable,
    integral_comp_preserving_ae hp h01.aestronglyMeasurable]
  rfl

theorem enrichedCGF_center_bound {N : ℕ} (hN : 0 < N) (n : ℕ) (b : ℕ → ℝ)
    (hb : CascadeExponents n b) {h : ℕ → ℝ} (hh : Monotone h) (h0 : 0 ≤ h 0)
    {H : ℝ} (hH : h n ≤ H) (u : Fin N → ℝ) (hu : ∀ j, |u j| ≤ 2)
    (j : Fin N) {v : ℝ} (hv : |v| ≤ 2)
    (ν : Measure (Spin N)) [IsProbabilityMeasure ν]
    {A : Type*} [MeasurableSpace A] (P : Measure A) [IsProbabilityMeasure P]
    {φ : A → Spin N → ℝ} (hm : Measurable φ) {K : ℝ} (hK : 0 ≤ K)
    (hφ : ∀ y x, |φ y x| ≤ K) (r : ℝ≥0) {α : ℝ} (hr : (r:ℝ) ≤ α*N) :
    let Q := (enrichedFrozenLaw P r n b j).prod gaussianCoordinates
    let C := 4*∫ T, (Real.log (rawTreeTotal n T).toReal)^2 ∂(rawCascadeLaw n b : Measure (RawTree n))
    (∫ z, |enrichedCGF n h u j ν φ v z - ∫ z', enrichedCGF n h u j ν φ v z' ∂Q| ∂Q) ≤
      2*N*Real.sqrt ((C+H+4+5*K^2*α)/N) := by
  let Q := (enrichedFrozenLaw P r n b j).prod gaussianCoordinates
  let F := enrichedCylinderPressure n h (Function.update u j v) ν φ ∘ enrichedInsert n j
  let B := enrichedCylinderPressure n h (Function.update u j 0) ν φ ∘ enrichedInsert n j
  let δ := Real.sqrt ((4*(∫ T, (Real.log (rawTreeTotal n T).toReal)^2
    ∂(rawCascadeLaw n b : Measure (RawTree n)))+H+4+5*K^2*α)/N)
  have hv1 := enrichedCylinderPressure_field_cap hN n b hb hh h0 hH
    (Function.update u j v) (update_abs_le_two hu j hv) ν P hm hK hφ r hr
  have h01 := enrichedCylinderPressure_field_cap hN n b hb hh h0 hH
    (Function.update u j 0) (update_abs_le_two hu j (by norm_num)) ν P hm hK hφ r hr
  have hp := enrichedInsert_preserving P r n b j
  have hF : MemLp F 2 Q := hv1.1.comp_measurePreserving hp
  have hB : MemLp B 2 Q := h01.1.comp_measurePreserving hp
  have hvF : Var[F;Q] ≤ (4*(∫ T, (Real.log (rawTreeTotal n T).toReal)^2
    ∂(rawCascadeLaw n b : Measure (RawTree n)))+H+4+5*K^2*α)/N := by
    have ht := variance_map (X := enrichedCylinderPressure n h (Function.update u j v) ν φ)
      (hp.map_eq.symm ▸ hv1.1.aemeasurable) hp.measurable.aemeasurable
    rw [hp.map_eq] at ht
    rw [← ht]
    exact hv1.2
  have hvB : Var[B;Q] ≤ (4*(∫ T, (Real.log (rawTreeTotal n T).toReal)^2
    ∂(rawCascadeLaw n b : Measure (RawTree n)))+H+4+5*K^2*α)/N := by
    have ht := variance_map (X := enrichedCylinderPressure n h (Function.update u j 0) ν φ)
      (hp.map_eq.symm ▸ h01.1.aemeasurable) hp.measurable.aemeasurable
    rw [hp.map_eq] at ht
    rw [← ht]
    exact h01.2
  have hcF : (∫ z, |F z-∫ z', F z' ∂Q| ∂Q) ≤ δ :=
    (l1_center_le_sqrt_variance hF).trans (Real.sqrt_le_sqrt hvF)
  have hcB : (∫ z, |B z-∫ z', B z' ∂Q| ∂Q) ≤ δ :=
    (l1_center_le_sqrt_variance hB).trans (Real.sqrt_le_sqrt hvB)
  have hc := centered_sub_L1_bound Q (hF.integrable (by norm_num))
    (hB.integrable (by norm_num)) hcF hcB
  have he := enriched_cgf_eq_pressure_difference hN n b hh h0 u hu j hv ν P hK hφ r
  change enrichedCGF n h u j ν φ v =ᵐ[Q] (fun z => N*(F z-B z)) at he
  have hem : (∫ z, enrichedCGF n h u j ν φ v z ∂Q) =
      N*(∫ z, F z-B z ∂Q) := by
    rw [integral_congr_ae he, integral_const_mul]
  change (∫ z, |enrichedCGF n h u j ν φ v z - ∫ z', enrichedCGF n h u j ν φ v z' ∂Q| ∂Q) ≤ _
  rw [hem]
  calc
    _ = (∫ z, (N:ℝ)*|F z-B z-∫ z', F z'-B z' ∂Q| ∂Q) := by
      apply integral_congr_ae
      filter_upwards [he] with z hz
      change enrichedCGF n h u j ν φ v z = N*(F z-B z) at hz
      rw [hz, ← mul_sub, abs_mul, abs_of_nonneg (Nat.cast_nonneg N)]
    _ = N*(∫ z, |F z-B z-∫ z', F z'-B z' ∂Q| ∂Q) := integral_const_mul _ _
    _ ≤ N*(δ+δ) := mul_le_mul_of_nonneg_left hc (Nat.cast_nonneg N)
    _ = _ := by change N*(δ+δ) = 2*N*δ; ring

end IsingPerceptron

 

 

open MeasureTheory ProbabilityTheory Filter Set
open scoped BigOperators Topology ENNReal NNReal
namespace IsingPerceptron
variable {I : Type} [Fintype I] [MeasurableSpace I] [MeasurableSingletonClass I]

lemma noise_energy_exp_integrable (n : ℕ) (b : ℕ → ℝ) (hb : CascadeExponents n b)
    (μ : ℕ → ProbabilityMeasure (I → ℝ)) (ν : Measure I) [IsProbabilityMeasure ν]
    (hμ : ∀ i < n, ExponentialNormMoments (μ i : Measure (I → ℝ))) (H : I → ℝ) :
    ∀ᵐ T ∂(noiseCascadeLaw (I → ℝ) n b μ : Measure (NoiseTree (I → ℝ) n)),
      Integrable (fun v => Real.exp (noiseLeafTerminal n (fun _ => finiteLogIntegral ν)
        (fun _ p => p.1+p.2) H v)) (noiseLeafKernel (I → ℝ) n T) := by
  have hfin := (linearGrowth_noiseCascade_recursion n b hb μ hμ
    (measurable_finiteLogIntegral ν) (finiteLogIntegral_linearGrowth ν) H).1
  have hfac := noiseTreeFactor_leafIntegral n b hb μ
    (X := fun _ => finiteLogIntegral ν) (u := fun _ p => p.1+p.2)
    (fun _ => measurable_finiteLogIntegral ν) (fun _ => measurable_fst.add measurable_snd) H
  have htot : ∀ᵐ T ∂(noiseCascadeLaw (I → ℝ) n b μ : Measure (NoiseTree (I → ℝ) n)),
      0 < noiseTreeTotal (I → ℝ) n T ∧ noiseTreeTotal (I → ℝ) n T < ∞ := by
    apply ae_of_ae_map (p := fun T : RawTree n => 0 < rawTreeTotal n T ∧ rawTreeTotal n T < ∞)
      (measurable_noiseTreeForget (I → ℝ) n).aemeasurable
    rw [noiseCascadeLaw_forget]
    exact (rawCascade_total_moments n b hb).1
  filter_upwards [hfin,hfac,htot] with T hf he ht
  simp only [noiseTreeFactor_terminal] at he
  have hx : (∫⁻ v, ENNReal.ofReal (Real.exp (noiseLeafTerminal n (fun _ => finiteLogIntegral ν)
      (fun _ p => p.1+p.2) H v)) ∂noiseLeafKernel (I → ℝ) n T) < ∞ := by
    by_contra! hx
    rw [top_le_iff.mp hx, ENNReal.mul_top ht.1.ne'] at he
    exact hf.2.ne he
  constructor
  · exact (((measurable_noiseLeafTerminal n (fun _ => measurable_finiteLogIntegral ν)
      (fun _ => measurable_fst.add measurable_snd)).comp
      (measurable_const.prodMk measurable_id)).exp.aestronglyMeasurable)
  · rw [hasFiniteIntegral_iff_enorm]
    simpa only [Real.enorm_eq_ofReal_abs,abs_of_pos (Real.exp_pos _)] using hx

lemma labeled_energy_exp_integrable (n : ℕ) (b : ℕ → ℝ) (hb : CascadeExponents n b)
    (μ : ℕ → ProbabilityMeasure (I → ℝ)) (ν : Measure I) [IsProbabilityMeasure ν]
    (hμ : ∀ i < n, ExponentialNormMoments (μ i : Measure (I → ℝ))) (H : I → ℝ) :
    ∀ᵐ p ∂((labeledCascadeLaw n b : Measure (LabeledTree n)).prod (markForestLaw (I → ℝ) n μ)),
      Integrable (fun s : I × LabeledLeaf n => Real.exp (labeledEnergy n p.2 s.2 H s.1))
        (labeledSpinReference n ν p.1) := by
  have hp : MeasurePreserving (labeledNoiseJoin (I → ℝ) n)
      ((labeledCascadeLaw n b : Measure (LabeledTree n)).prod (markForestLaw (I → ℝ) n μ))
      (noiseCascadeLaw (I → ℝ) n b μ : Measure (NoiseTree (I → ℝ) n)) :=
    ⟨measurable_labeledNoiseJoin _ _,labeledNoiseJoin_law _ _ _ _⟩
  have hg := hp.quasiMeasurePreserving.tendsto_ae.eventually (noiseCascade_good (I → ℝ) n b hb μ)
  have ht : ∀ᵐ p ∂((labeledCascadeLaw n b : Measure (LabeledTree n)).prod (markForestLaw (I → ℝ) n μ)),
      0 < noiseTreeTotal (I → ℝ) n (labeledNoiseJoin (I → ℝ) n p) ∧
      noiseTreeTotal (I → ℝ) n (labeledNoiseJoin (I → ℝ) n p) < ∞ := by
    apply hp.quasiMeasurePreserving.tendsto_ae.eventually (p := fun T =>
      0 < noiseTreeTotal (I → ℝ) n T ∧ noiseTreeTotal (I → ℝ) n T < ∞)
    apply ae_of_ae_map (p := fun T : RawTree n => 0 < rawTreeTotal n T ∧ rawTreeTotal n T < ∞)
      (measurable_noiseTreeForget (I → ℝ) n).aemeasurable
    rw [noiseCascadeLaw_forget]
    exact (rawCascade_total_moments n b hb).1
  have hi := hp.quasiMeasurePreserving.tendsto_ae.eventually
    (noise_energy_exp_integrable n b hb μ ν hμ H)
  filter_upwards [hg,ht,hi] with p hg ht hi
  have hm : Measurable (fun v => Real.exp (noiseLeafTerminal n (fun _ => finiteLogIntegral ν)
      (fun _ p => p.1+p.2) H v)) :=
    (((measurable_noiseLeafTerminal n (fun _ => measurable_finiteLogIntegral ν)
      (fun _ => measurable_fst.add measurable_snd)).comp
      (measurable_const.prodMk measurable_id)).exp)
  have hl := integrable_map_measure (μ := labeledLeafLaw n p.1) hm.aestronglyMeasurable
    (measurable_of_countable (labeledNoiseLeaf (I → ℝ) n p)).aemeasurable
  rw [labeledLeafLaw_noiseMap (I → ℝ) n p.1 p.2 hg ht] at hl
  have hf : Integrable (fun γ => Real.exp (finiteLogIntegral ν (labeledEnergy n p.2 γ H)))
      (labeledLeafLaw n p.1) := by
    apply (hl.mp hi).congr
    exact ae_of_all _ (fun γ => congrArg Real.exp (labeledEnergy_terminal n p.1 p.2 γ (finiteLogIntegral ν) H))
  change Integrable _ (ν.prod (labeledLeafLaw n p.1))
  change Integrable ((fun s : LabeledLeaf n × I => Real.exp (labeledEnergy n p.2 s.1 H s.2)) ∘ Prod.swap) _
  apply integrable_swap_iff.mpr
  apply (integrable_prod_iff (by exact (measurable_of_countable _).aestronglyMeasurable)).mpr
  constructor
  · exact ae_of_all _ (fun _ => Integrable.of_finite)
  · simpa only [Prod.swap_prod_mk, Real.norm_eq_abs,abs_of_pos (Real.exp_pos _),finiteLogIntegral,
      Real.exp_log (MeasureTheory.integral_exp_pos Integrable.of_finite)] using hf

 
def cascadeCoordinateLaw (n : ℕ) (b : ℕ → ℝ) (μ : ℕ → ProbabilityMeasure (I → ℝ)) :
    Measure (LabeledTree n × (ForestVertex n → I → ℝ)) :=
  (labeledCascadeLaw n b : Measure (LabeledTree n)).prod
    (Measure.infinitePi (fun v : ForestVertex n => (μ (forestVertexDepth n v) : Measure (I → ℝ))))

instance cascadeCoordinateLaw_probability (n : ℕ) (b : ℕ → ℝ)
    (μ : ℕ → ProbabilityMeasure (I → ℝ)) : IsProbabilityMeasure (cascadeCoordinateLaw n b μ) := by
  unfold cascadeCoordinateLaw; infer_instance

omit [MeasurableSpace I] [MeasurableSingletonClass I] in
lemma cascadeCoordinates_preserving (n : ℕ) (b : ℕ → ℝ) (μ : ℕ → ProbabilityMeasure (I → ℝ)) :
    MeasurePreserving (fun p : LabeledTree n × (ForestVertex n → I → ℝ) =>
      (p.1,markForestOfCoords (I → ℝ) n p.2)) (cascadeCoordinateLaw n b μ)
      ((labeledCascadeLaw n b : Measure (LabeledTree n)).prod (markForestLaw (I → ℝ) n μ)) :=
  (MeasurePreserving.id _).prod ⟨measurable_markForestOfCoords _ _,markForestOfCoords_law _ _ _⟩

def cascadeCoordinateEnergy (n : ℕ) (H : I → ℝ)
    (p : LabeledTree n × (ForestVertex n → I → ℝ)) (s : I × LabeledLeaf n) : ℝ :=
  H s.1+∑ i : Fin n, p.2 (edgeAt n s.2 i) s.1

omit [Fintype I] [MeasurableSpace I] [MeasurableSingletonClass I] in
lemma cascadeCoordinateEnergy_eq (n : ℕ) (H : I → ℝ)
    (p : LabeledTree n × (ForestVertex n → I → ℝ)) (s : I × LabeledLeaf n) :
    cascadeCoordinateEnergy n H p s = labeledEnergy n (markForestOfCoords (I → ℝ) n p.2) s.2 H s.1 :=
  (labeledEnergy_edge_sum n p.2 s.2 H s.1).symm

lemma cascadeCoordinate_exp_integrable (n : ℕ) (b : ℕ → ℝ) (hb : CascadeExponents n b)
    (μ : ℕ → ProbabilityMeasure (I → ℝ)) (ν : Measure I) [IsProbabilityMeasure ν]
    (hμ : ∀ i < n, ExponentialNormMoments (μ i : Measure (I → ℝ))) (H : I → ℝ) :
    ∀ᵐ p ∂cascadeCoordinateLaw n b μ,
      Integrable (fun s => Real.exp (cascadeCoordinateEnergy n H p s)) (labeledSpinReference n ν p.1) := by
  simpa only [cascadeCoordinateEnergy_eq] using
    (cascadeCoordinates_preserving n b μ).quasiMeasurePreserving.tendsto_ae.eventually
      (labeled_energy_exp_integrable n b hb μ ν hμ H)

lemma cascadeCoordinate_log_integral (n : ℕ) (b : ℕ → ℝ) (hb : CascadeExponents n b)
    (μ : ℕ → ProbabilityMeasure (I → ℝ)) (ν : Measure I) [IsProbabilityMeasure ν]
    (hμ : ∀ i < n, ExponentialNormMoments (μ i : Measure (I → ℝ))) (H : I → ℝ) :
    Integrable (fun p => Real.log (∫ s, Real.exp (cascadeCoordinateEnergy n H p s)
      ∂labeledSpinReference n ν p.1)) (cascadeCoordinateLaw n b μ) ∧
    (∫ p, Real.log (∫ s, Real.exp (cascadeCoordinateEnergy n H p s)
      ∂labeledSpinReference n ν p.1) ∂cascadeCoordinateLaw n b μ) = energyRecursion n b μ ν H := by
  let hp := (show MeasurePreserving (labeledNoiseJoin (I → ℝ) n)
    ((labeledCascadeLaw n b : Measure (LabeledTree n)).prod (markForestLaw (I → ℝ) n μ))
    (noiseCascadeLaw (I → ℝ) n b μ : Measure (NoiseTree (I → ℝ) n)) from
    ⟨measurable_labeledNoiseJoin _ _,labeledNoiseJoin_law _ _ _ _⟩).comp
      (cascadeCoordinates_preserving n b μ)
  have h := cascadeEnergyLog_conditional n b hb μ ν hμ H
  have he := (cascadeCoordinates_preserving n b μ).quasiMeasurePreserving.tendsto_ae.eventually
    (labeledEnergyLog_eq_cascade n b hb μ ν H)
  have he' : (fun p => Real.log (∫ s, Real.exp (cascadeCoordinateEnergy n H p s)
      ∂labeledSpinReference n ν p.1)) =ᵐ[cascadeCoordinateLaw n b μ]
      (fun p => cascadeEnergyLog n b μ ν H (labeledNoiseJoin (I → ℝ) n
        (p.1,markForestOfCoords (I → ℝ) n p.2))) := by
    filter_upwards [he] with p hp
    simpa only [cascadeCoordinateEnergy_eq,labeledEnergyLog] using hp
  refine ⟨(hp.integrable_comp_of_integrable h.1).congr he'.symm,?_⟩
  rw [integral_congr_ae he']
  exact (integral_comp_preserving_ae hp h.1.aestronglyMeasurable).trans h.2.1

end IsingPerceptron

 

 

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

lemma cylinder_weighted_variant_eq {ι : Type*} [Fintype ι]
    (a b : ι → ℕ →₀ ℝ) (hc : ∀ i j, cylinderCross (a i) (a j) = cylinderCross (b i) (b j))
    (c : ι → ℝ) :
    (∑ i, c i • a i).sum (fun _ v => v^2) = (∑ i, c i • b i).sum (fun _ v => v^2) := by
  classical
  simp only [← cylinderCross_self,cylinderCross_finset_left,cylinderCross_sum_right,cylinderCross_smul,hc]

lemma dual_cylinderField {ι : Type*} [Fintype ι] [DecidableEq ι]
    (L : (ι → ℝ) →L[ℝ] ℝ) (a : ι → ℕ →₀ ℝ) (g : ℕ → ℝ) :
    L (fun i => cylinderField (a i) g) =
      cylinderField (∑ i, L (Pi.single i 1) • a i) g := by
  have hv : (fun i => cylinderField (a i) g) =
      ∑ i, cylinderField (a i) g • Pi.single i (1:ℝ) := by
    ext j
    simp [Pi.single_apply]
  rw [hv,map_sum,cylinderField_finset_sum]
  apply Finset.sum_congr rfl
  intro i _
  rw [map_smul,cylinderField_smul,smul_eq_mul,mul_comm]

 

lemma cylinder_finite_law_eq {ι : Type*} [Fintype ι]
    (a b : ι → ℕ →₀ ℝ) (hc : ∀ i j, cylinderCross (a i) (a j) = cylinderCross (b i) (b j)) :
    gaussianCoordinates.map (fun g i => cylinderField (a i) g) =
      gaussianCoordinates.map (fun g i => cylinderField (b i) g) := by
  classical
  have ha : Measurable (fun g i => cylinderField (a i) g) :=
    Measurable.of_eval (fun coordinate => measurable_cylinderField (a coordinate))
  have hb : Measurable (fun g i => cylinderField (b i) g) :=
    Measurable.of_eval (fun coordinate => measurable_cylinderField (b coordinate))
  apply Measure.ext_of_charFunDual
  funext L
  rw [charFunDual_apply,charFunDual_apply,integral_map ha.aemeasurable (by fun_prop),
    integral_map hb.aemeasurable (by fun_prop)]
  simp only [dual_cylinderField]
  rw [← integral_map (measurable_cylinderField _).aemeasurable
    (by fun_prop : AEStronglyMeasurable (fun x : ℝ => Complex.exp ((x:ℂ)*Complex.I)) (gaussianCoordinates.map _)),
    ← integral_map (measurable_cylinderField _).aemeasurable
    (by fun_prop : AEStronglyMeasurable (fun x : ℝ => Complex.exp ((x:ℂ)*Complex.I)) (gaussianCoordinates.map _)),
    cylinderField_law,cylinderField_law,cylinder_weighted_variant_eq a b hc]

 

theorem cylinder_fields_law_eq {X : Type*}
    (a b : X → ℕ →₀ ℝ) (hc : ∀ x y, cylinderCross (a x) (a y) = cylinderCross (b x) (b y)) :
    gaussianCoordinates.map (fun g x => cylinderField (a x) g) =
      gaussianCoordinates.map (fun g x => cylinderField (b x) g) := by
  classical
  apply (map_eq_iff_forall_finset_map_restrict_eq
    (Measurable.of_eval (fun coordinate => measurable_cylinderField (a coordinate))).aemeasurable
    (Measurable.of_eval (fun coordinate => measurable_cylinderField (b coordinate))).aemeasurable).mpr
  intro I
  exact cylinder_finite_law_eq (fun i : I => a i) (fun i : I => b i) (fun i j => hc i j)

end IsingPerceptron

 

 

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

def gaussianPair (g : ℕ → ℝ) : (ℕ → ℝ) × (ℕ → ℝ) :=
  ((fun i => g (Nat.pair 0 i)),fun i => g (Nat.pair 1 i))

lemma gaussianPair_preserving : MeasurePreserving gaussianPair gaussianCoordinates
    (gaussianCoordinates.prod gaussianCoordinates) := by
  have hs : MeasurePreserving (gaussianNamespaceSplit 0) gaussianCoordinates
      (gaussianCoordinates.prod (otherNamespacesLaw 0)) :=
    ⟨measurable_gaussianNamespaceSplit 0,gaussianNamespaceSplit_law 0⟩
  have he := measurePreserving_eval_infinitePi
    (fun _ : {k : ℕ // k ≠ 0} => gaussianCoordinates) ⟨1,by decide⟩
  exact ((MeasurePreserving.id gaussianCoordinates).prod he).comp hs

def gaussianSumCoefficients {X : Type*} (a b : X → ℕ →₀ ℝ) (t : ℝ) (x : X) : ℕ →₀ ℝ :=
  ∑ i : Fin 2, tagCoefficients i (Fin.cases (a x) (fun _ => t • b x) i)

lemma gaussianSumCoefficients_field {X : Type*} (a b : X → ℕ →₀ ℝ) (t : ℝ) (x : X) (g : ℕ → ℝ) :
    cylinderField (gaussianSumCoefficients a b t x) g =
      cylinderField (a x) (gaussianPair g).1 + t*cylinderField (b x) (gaussianPair g).2 := by
  unfold gaussianSumCoefficients
  rw [cylinderField_finset_sum,Fin.sum_univ_two]
  simp only [show (1 : Fin 2) = Fin.succ (0 : Fin 1) from rfl,Fin.cases_succ,Fin.cases_zero]
  simp [cylinderField_tag,cylinderField_smul,gaussianPair]

lemma gaussianSumCoefficients_cross {X : Type*} (a b : X → ℕ →₀ ℝ) (t : ℝ) (x y : X) :
    cylinderCross (gaussianSumCoefficients a b t x) (gaussianSumCoefficients a b t y) =
      cylinderCross (a x) (a y)+t^2*cylinderCross (b x) (b y) := by
  unfold gaussianSumCoefficients
  rw [cylinderCross_tagged_sum,Fin.sum_univ_two]
  simp only [show (1 : Fin 2) = Fin.succ (0 : Fin 1) from rfl,Fin.cases_succ,Fin.cases_zero]
  simp [cylinderCross_smul,pow_two]

 

theorem cylinder_independent_sum_law {X : Type*} (a b c : X → ℕ →₀ ℝ) (t : ℝ)
    (hc : ∀ x y, cylinderCross (c x) (c y) = cylinderCross (a x) (a y)+t^2*cylinderCross (b x) (b y)) :
    (gaussianCoordinates.prod gaussianCoordinates).map
      (fun g x => cylinderField (a x) g.1+t*cylinderField (b x) g.2) =
      gaussianCoordinates.map (fun g x => cylinderField (c x) g) := by
  rw [← gaussianPair_preserving.map_eq,Measure.map_map (by
    apply Measurable.of_eval; intro x
    exact ((measurable_cylinderField (a x)).comp measurable_fst).add
      (((measurable_cylinderField (b x)).comp measurable_snd).const_mul t)) gaussianPair_preserving.measurable]
  have he : (fun g x => cylinderField (a x) (gaussianPair g).1+t*cylinderField (b x) (gaussianPair g).2) =
      (fun g x => cylinderField (gaussianSumCoefficients a b t x) g) := by
    funext g x; exact (gaussianSumCoefficients_field a b t x g).symm
  change gaussianCoordinates.map (fun g x => cylinderField (a x) (gaussianPair g).1+
    t*cylinderField (b x) (gaussianPair g).2) = _
  rw [he]
  exact cylinder_fields_law_eq _ _ (fun x y => (gaussianSumCoefficients_cross a b t x y).trans (hc x y).symm)

end IsingPerceptron

 

 

 

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

lemma hasDerivAt_mean_cgf {Ω X : Type*} [MeasurableSpace Ω] [MeasurableSpace X]
    {P : Measure Ω} (ν : Ω → Measure X) (Y : Ω → X → ℝ)
    (he : ∀ᵐ ω ∂P, ∀ t : ℝ, Integrable (fun x => Real.exp (t*Y ω x)) (ν ω))
    (hi : ∀ t, Integrable (fun ω => cgf (Y ω) (ν ω) t) P)
    (hd : ∀ t, Integrable (fun ω => ∫ x, Y ω x ∂(ν ω).tilted (fun x => t*Y ω x)) P)
    (v : ℝ) :
    HasDerivAt (fun t => ∫ ω, cgf (Y ω) (ν ω) t ∂P)
      (∫ ω, ∫ x, Y ω x ∂(ν ω).tilted (fun x => v*Y ω x) ∂P) v := by
  let D : ℝ → Ω → ℝ := fun t ω => ∫ x, Y ω x ∂(ν ω).tilted (fun x => t*Y ω x)
  let B : Ω → ℝ := fun ω => |D (v-1) ω|+|D (v+1) ω|
  have hderiv : ∀ᵐ ω ∂P, ∀ t : ℝ, HasDerivAt (cgf (Y ω) (ν ω)) (D t ω) t := by
    filter_upwards [he] with ω hω
    intro t
    dsimp [D]
    rw [integral_tilted_mul_self (mem_interior_integrableExpSet_of_all hω t)]
    exact (analyticAt_cgf (mem_interior_integrableExpSet_of_all hω t)).differentiableAt.hasDerivAt
  have hB : Integrable B P := (hd (v-1)).abs.add (hd (v+1)).abs
  apply (hasDerivAt_integral_of_dominated_loc_of_deriv_le
    (s := Ioo (v-1) (v+1)) (Ioo_mem_nhds (by linarith) (by linarith))
    (Eventually.of_forall (fun t => (hi t).aestronglyMeasurable)) (hi v)
    (hd v).aestronglyMeasurable (bound := B) ?_ hB ?_).2
  · filter_upwards [he,hderiv] with ω hω hdω
    intro t ht
    have hmono := (convexOn_cgf_of_all_exp hω).monotoneOn_deriv
      (fun x _ => (hdω x).differentiableAt)
    have hlo := hmono (mem_univ _) (mem_univ _) ht.1.le
    have hhi := hmono (mem_univ _) (mem_univ _) ht.2.le
    rw [(hdω (v-1)).deriv,(hdω t).deriv] at hlo
    rw [(hdω t).deriv,(hdω (v+1)).deriv] at hhi
    simp only [Real.norm_eq_abs]
    exact abs_le.mpr ⟨by dsimp [B]; linarith [neg_abs_le (D (v-1) ω),abs_nonneg (D (v+1) ω)],
      by dsimp [B]; linarith [le_abs_self (D (v+1) ω),abs_nonneg (D (v-1) ω)]⟩
  · filter_upwards [hderiv] with ω hω
    exact fun t _ => hω t

lemma integral_tilted_eq_single_replica {X : Type*} [MeasurableSpace X] [Countable X]
    [MeasurableSingletonClass X] (ν : Measure X) [IsProbabilityMeasure ν]
    {Y : X → ℝ} {t : ℝ} (he : Integrable (fun x => Real.exp (t*Y x)) ν)
    (hi : Integrable Y (ν.tilted (fun x => t*Y x))) :
    (∫ x, Y x ∂ν.tilted (fun x => t*Y x)) =
      referenceReplicaMean ν (fun x => t*Y x) (fun σ : Fin 1 → X => Y (σ 0)) := by
  rw [referenceReplicaMean_eq_tilted ν _ he]
  let : IsProbabilityMeasure (ν.tilted (fun x => t*Y x)) := isProbabilityMeasure_tilted he
  exact (integral_comp_eval (μ := fun _ : Fin 1 => ν.tilted (fun x => t*Y x)) (i := 0) hi.aestronglyMeasurable).symm

lemma integrable_random_cylinder_tilted_mean {Ω X : Type*}
    [MeasurableSpace Ω] [MeasurableSpace X] [Countable X] [MeasurableSingletonClass X]
    {P : Measure Ω} [IsProbabilityMeasure P] {ν : Ω → Measure X}
    (hν : Measurable ν) [∀ ω, IsProbabilityMeasure (ν ω)]
    (a : X → ℕ →₀ ℝ) {K : ℝ} (ha : ∀ x, (a x).sum (fun _ c => c^2) ≤ K) (t : ℝ) :
    Integrable (fun z : Ω × (ℕ → ℝ) => ∫ x, cylinderField (a x) z.2
      ∂(ν z.1).tilted (fun x => t*cylinderField (a x) z.2)) (P.prod gaussianCoordinates) := by
  have hh := integrable_joint_cylinder_insertion (P := P) hν (fun x => t • a x) a
    (fun x => by rw [cylinder_norm_smul]; exact mul_le_mul_of_nonneg_left (ha x) (sq_nonneg t))
    ha (fun _ : Fin 1 → X => (1:ℝ)) (c := 1) (by norm_num) (by intro; norm_num)
  simp only [mul_one,cylinderField_smul] at hh
  apply hh.congr
  filter_upwards [random_cylinder_all_exp_ae (P := P) hν a ha] with z hz
  exact (integral_tilted_eq_single_replica (ν z.1) (hz t)
    ((memLp_tilted_mul (mem_interior_integrableExpSet_of_all hz t) (1:ℝ≥0)).integrable (by norm_num))).symm

 

theorem hasDerivAt_random_cylinder_cgf {Ω X : Type*}
    [MeasurableSpace Ω] [MeasurableSpace X] [Countable X] [MeasurableSingletonClass X]
    {P : Measure Ω} [IsProbabilityMeasure P] {ν : Ω → Measure X}
    (hν : Measurable ν) [∀ ω, IsProbabilityMeasure (ν ω)]
    (a : X → ℕ →₀ ℝ) {K : ℝ} (ha : ∀ x, (a x).sum (fun _ c => c^2) ≤ K) (t : ℝ) :
    HasDerivAt (fun t => ∫ z : Ω × (ℕ → ℝ), cgf (fun x => cylinderField (a x) z.2) (ν z.1) t
      ∂P.prod gaussianCoordinates)
      (∫ z : Ω × (ℕ → ℝ), ∫ x, cylinderField (a x) z.2
        ∂(ν z.1).tilted (fun x => t*cylinderField (a x) z.2) ∂P.prod gaussianCoordinates) t := by
  apply hasDerivAt_mean_cgf (P := P.prod gaussianCoordinates)
    (fun z : Ω × (ℕ → ℝ) => ν z.1) (fun z x => cylinderField (a x) z.2)
  · exact random_cylinder_all_exp_ae (P := P) hν a ha
  · exact integrable_random_cylinder_cgf (P := P) hν a ha
  · exact integrable_random_cylinder_tilted_mean (P := P) hν a ha

lemma cylinder_tilted_mean_eq_energy {Ω X : Type*}
    [MeasurableSpace Ω] [MeasurableSpace X] [Countable X] [MeasurableSingletonClass X]
    {P : Measure Ω} [IsProbabilityMeasure P] {ν : Ω → Measure X}
    (hν : Measurable ν) [∀ ω, IsProbabilityMeasure (ν ω)]
    (a : X → ℕ →₀ ℝ) {K : ℝ} (ha : ∀ x, (a x).sum (fun _ c => c^2) ≤ K) (t : ℝ) :
    (∫ z : Ω × (ℕ → ℝ), ∫ x, cylinderField (a x) z.2
      ∂(ν z.1).tilted (fun x => t*cylinderField (a x) z.2) ∂P.prod gaussianCoordinates) =
      randomReplicaEnergy P ν a t (fun _ : Fin 1 → X => 1) := by
  unfold randomReplicaEnergy
  apply integral_congr_ae
  filter_upwards [random_cylinder_all_exp_ae (P := P) hν a ha] with z hz
  simpa only [mul_one] using integral_tilted_eq_single_replica (ν z.1) (hz t)
    ((memLp_tilted_mul (mem_interior_integrableExpSet_of_all hz t) (1:ℝ≥0)).integrable (by norm_num))

 

theorem hasDerivAt_random_cylinder_covariance {Ω X : Type*}
    [MeasurableSpace Ω] [MeasurableSpace X] [Countable X] [MeasurableSingletonClass X]
    {P : Measure Ω} [IsProbabilityMeasure P] {ν : Ω → Measure X}
    (hν : Measurable ν) [∀ ω, IsProbabilityMeasure (ν ω)]
    (a : X → ℕ →₀ ℝ) {K d : ℝ} (ha : ∀ x, (a x).sum (fun _ c => c^2) ≤ K)
    (hdiag : ∀ x, cylinderCross (a x) (a x) = d) (t : ℝ) :
    HasDerivAt (fun t => ∫ z : Ω × (ℕ → ℝ), cgf (fun x => cylinderField (a x) z.2) (ν z.1) t
      ∂P.prod gaussianCoordinates)
      (t*(d-randomReplicaAverage P ν a t (fun σ : Fin 2 → X => cylinderCross (a (σ 1)) (a (σ 0))))) t := by
  have hd := hasDerivAt_random_cylinder_cgf (P := P) hν a ha t
  rw [cylinder_tilted_mean_eq_energy hν a ha t,
    randomReplicaEnergy_identity hν a ha hdiag t (fun _ : Fin 1 → X => (1:ℝ)) (c := 1)
      (by norm_num) (by intro; norm_num)] at hd
  simp only [Finset.univ_eq_empty,Finset.sum_empty,mul_zero,one_mul,Nat.reduceAdd,Nat.cast_one,
    Fin.tail,Fin.succ_zero_eq_one] at hd
  rw [randomReplicaAverage_const hν a ha,randomReplicaAverage_const hν a ha] at hd
  simpa only [mul_one,add_zero,Nat.reduceAdd,Nat.cast_one,one_mul,Fin.tail,Fin.succ_zero_eq_one] using hd

end IsingPerceptron

 

 

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

lemma exp_mul_le_endpoints {v t y : ℝ} (ht : t ∈ Icc (v-1) (v+1)) :
    Real.exp (t*y) ≤ Real.exp ((v-1)*y)+Real.exp ((v+1)*y) := by
  by_cases hy : 0 ≤ y
  · exact (Real.exp_le_exp.mpr (mul_le_mul_of_nonneg_right ht.2 hy)).trans
      (le_add_of_nonneg_left (Real.exp_pos _).le)
  · exact (Real.exp_le_exp.mpr (mul_le_mul_of_nonpos_right ht.1 (le_of_not_ge hy))).trans
      (le_add_of_nonneg_right (Real.exp_pos _).le)

lemma continuous_bounded_exponential_integral {X : Type*} [MeasurableSpace X]
    (ν : Measure X) {Y D : X → ℝ} (hY : Measurable Y) (hD : Measurable D)
    (he : ∀ t, Integrable (fun x => Real.exp (t*Y x)) ν)
    {C : ℝ} (_hC : 0 ≤ C) (hb : ∀ x, |D x| ≤ C) :
    Continuous (fun t : ℝ => ∫ x, Real.exp (t*Y x)*D x ∂ν) := by
  apply continuous_iff_continuousAt.mpr
  intro v
  apply continuousAt_of_dominated (bound := fun x =>
    (Real.exp ((v-1)*Y x)+Real.exp ((v+1)*Y x))*C)
  · exact Eventually.of_forall (fun t => ((hY.const_mul t).exp.mul hD).aestronglyMeasurable)
  · filter_upwards [Ioo_mem_nhds (show v-1 < v by linarith) (show v < v+1 by linarith)] with t ht
    refine ae_of_all _ (fun x => ?_)
    rw [Real.norm_eq_abs,abs_mul,abs_of_pos (Real.exp_pos _)]
    exact mul_le_mul (exp_mul_le_endpoints ⟨ht.1.le,ht.2.le⟩) (hb x) (abs_nonneg _) (by positivity)
  · exact ((he (v-1)).add (he (v+1))).mul_const C
  · exact ae_of_all _ (fun x => by fun_prop)

lemma replica_all_exp {X : Type*} [MeasurableSpace X] (ν : Measure X) [IsProbabilityMeasure ν]
    {Y : X → ℝ} (he : ∀ t, Integrable (fun x => Real.exp (t*Y x)) ν) (r : ℕ) (t : ℝ) :
    Integrable (fun σ : Fin r → X => Real.exp (t*∑ i, Y (σ i))) (Measure.pi (fun _ => ν)) := by
  simpa only [Finset.mul_sum,Real.exp_sum] using
    Integrable.fintype_prod (μ := fun _ : Fin r => ν) (fun _ : Fin r => he t)

lemma continuous_referenceReplicaMean {X : Type*} [MeasurableSpace X] [Countable X]
    [MeasurableSingletonClass X] (ν : Measure X) [IsProbabilityMeasure ν]
    {Y : X → ℝ} (he : ∀ t, Integrable (fun x => Real.exp (t*Y x)) ν)
    {r : ℕ} (D : (Fin r → X) → ℝ) {C : ℝ} (hC : 0 ≤ C) (hD : ∀ σ, |D σ| ≤ C) :
    Continuous (fun t : ℝ => referenceReplicaMean ν (fun x => t*Y x) D) := by
  have hnum := continuous_bounded_exponential_integral (Measure.pi (fun _ : Fin r => ν))
    (measurable_of_countable (fun σ : Fin r → X => ∑ i, Y (σ i))) (measurable_of_countable D)
    (replica_all_exp ν he r) hC hD
  have hden : Continuous (fun t : ℝ => ∫ x, Real.exp (t*Y x) ∂ν) := by
    simpa only [mul_one] using continuous_bounded_exponential_integral ν
      (measurable_of_countable Y) (measurable_const : Measurable (fun _ : X => (1:ℝ)))
      he (C := 1) (by norm_num) (by intro; norm_num)
  convert hnum.div (hden.pow r) (fun t => pow_ne_zero r (MeasureTheory.integral_exp_pos (he t)).ne') using 1
  funext t
  simp [referenceReplicaMean,referencePartition,Finset.mul_sum]

 

lemma continuous_randomReplicaAverage {Ω X : Type*}
    [MeasurableSpace Ω] [MeasurableSpace X] [Countable X] [MeasurableSingletonClass X]
    {P : Measure Ω} [IsProbabilityMeasure P] {ν : Ω → Measure X}
    (hν : Measurable ν) [∀ ω, IsProbabilityMeasure (ν ω)]
    (a : X → ℕ →₀ ℝ) {K : ℝ} (ha : ∀ x, (a x).sum (fun _ c => c^2) ≤ K)
    {r : ℕ} (D : (Fin r → X) → ℝ) {C : ℝ} (hC : 0 ≤ C) (hD : ∀ σ, |D σ| ≤ C) :
    Continuous (fun t : ℝ => randomReplicaAverage P ν a t D) := by
  apply continuous_iff_continuousAt.mpr
  intro v
  apply continuousAt_of_dominated (bound := fun _ : Ω × (ℕ → ℝ) => C)
  · filter_upwards [] with t
    exact (integrable_random_scaled_mean (P := P) hν a t D hC hD).aestronglyMeasurable
  · exact Eventually.of_forall (fun t => ae_of_all _ (fun z => by
      simpa only [Real.norm_eq_abs] using referenceReplicaMean_abs_le (ν z.1) _ D
        (measurable_of_countable D) hC hD))
  · exact integrable_const _
  · filter_upwards [random_cylinder_all_exp_ae (P := P) hν a ha] with z hz
    exact (continuous_referenceReplicaMean (ν z.1) hz D hC hD).continuousAt

end IsingPerceptron

end

end OAI