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:ℝ) 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 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