| import Mathlib |
| import OAI.Probability.IsingPerceptron.VariationalDefs |
|
|
| namespace OAI |
|
|
| /-! Bounded Tilt Average. -/ |
|
|
| 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 exp_mul_integrable_of_bound {Ω : Type*} [MeasurableSpace Ω] |
| (P : Measure Ω) [IsFiniteMeasure P] {U : Ω → ℝ} (hU : Measurable U) |
| {K : ℝ} (hK : ∀ x, |U x| ≤ K) (d : ℝ) : |
| Integrable (fun x => Real.exp (d*U x)) P := by |
| apply Integrable.of_bound ((measurable_const.mul hU).exp).aestronglyMeasurable (Real.exp (|d| * K)) |
| filter_upwards [] with x |
| rw [Real.norm_eq_abs,abs_of_pos (Real.exp_pos _)] |
| exact Real.exp_le_exp.mpr ((le_abs_self _).trans (by |
| change |d * U x| ≤ |d| * K |
| rw [abs_mul]; exact mul_le_mul_of_nonneg_left (hK x) (abs_nonneg _))) |
|
|
| lemma integral_pos_exp_of_bound {Ω : Type*} [MeasurableSpace Ω] |
| (P : Measure Ω) [IsProbabilityMeasure P] {U : Ω → ℝ} (hU : Measurable U) |
| {K : ℝ} (hK : ∀ x, |U x| ≤ K) (d : ℝ) : |
| 0 < ∫ x, Real.exp (d*U x) ∂P := by |
| exact integral_pos_iff_support_of_nonneg (fun x => (Real.exp_pos _).le) |
| (exp_mul_integrable_of_bound P hU hK d) |>.mpr (by simp [Function.support,Real.exp_ne_zero]) |
|
|
| lemma bounded_tilted_integral_abs {Ω : Type*} [MeasurableSpace Ω] |
| (P : Measure Ω) [IsProbabilityMeasure P] {U A : Ω → ℝ} (hU : Measurable U) |
| {K C : ℝ} (hK : ∀ x, |U x| ≤ K) (hA : Measurable A) (hC : ∀ x, |A x| ≤ C) (d : ℝ) : |
| |∫ x, A x ∂P.tilted (fun x => d*U x)| ≤ C := by |
| let := isProbabilityMeasure_tilted (exp_mul_integrable_of_bound P hU hK d) |
| exact abs_integral_le_integral_abs.trans (by |
| calc |
| (∫ x, |A x| ∂P.tilted (fun x => d*U x)) ≤ ∫ _ : Ω, C ∂P.tilted (fun x => d*U x) := |
| integral_mono (Integrable.of_bound hA.abs.aestronglyMeasurable C |
| (ae_of_all _ (fun x => by simpa only [Real.norm_eq_abs,abs_abs] using hC x))) |
| (integrable_const _) hC |
| _ = C := by simp) |
|
|
| lemma integral_tilted_eq_div {Ω : Type*} [MeasurableSpace Ω] |
| (P : Measure Ω) (U A : Ω → ℝ) : |
| (∫ x, A x ∂P.tilted U) = (∫ x, Real.exp (U x)*A x ∂P) / (∫ x, Real.exp (U x) ∂P) := by |
| rw [integral_tilted] |
| simp only [smul_eq_mul,div_mul_eq_mul_div,integral_div] |
|
|
| |
|
|
| def gaussianTiltAverage (s d : ℝ) (U A : ℝ → ℝ) (x : ℝ) : ℝ := |
| ∫ z, A (x+Real.sqrt s*z) ∂(gaussianReal 0 1).tilted (fun z => d*U (x+Real.sqrt s*z)) |
|
|
| lemma gaussianTiltAverage_abs_le (s d : ℝ) {U A : ℝ → ℝ} |
| (hU : Measurable U) {K C : ℝ} (hK : ∀ x, |U x| ≤ K) |
| (hA : Measurable A) (hC : ∀ x, |A x| ≤ C) (x : ℝ) : |
| |gaussianTiltAverage s d U A x| ≤ C := |
| bounded_tilted_integral_abs _ (hU.comp (by fun_prop)) (fun z => hK _) (hA.comp (by fun_prop)) |
| (fun z => hC _) d |
|
|
| lemma gaussianTiltAverage_zero (s : ℝ) (U A : ℝ → ℝ) (x : ℝ) : |
| gaussianTiltAverage s 0 U A x = ∫ z, A (x+Real.sqrt s*z) ∂gaussianReal 0 1 := by |
| simp [gaussianTiltAverage] |
|
|
| lemma gaussianTiltAverage_eq_div (s d : ℝ) (U A : ℝ → ℝ) (x : ℝ) : |
| gaussianTiltAverage s d U A x = |
| (∫ z, Real.exp (d*U (x+Real.sqrt s*z))*A (x+Real.sqrt s*z) ∂gaussianReal 0 1) / |
| (∫ z, Real.exp (d*U (x+Real.sqrt s*z)) ∂gaussianReal 0 1) := |
| integral_tilted_eq_div _ _ _ |
|
|
| end IsingPerceptron |
|
|
| |
|
|
| |
|
|
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped BigOperators Topology ENNReal NNReal |
| namespace IsingPerceptron |
|
|
| lemma bounded_integrable {Ω : Type*} [MeasurableSpace Ω] |
| (P : Measure Ω) [IsFiniteMeasure P] {U : Ω → ℝ} (hU : Measurable U) |
| {K : ℝ} (hK : ∀ x, |U x| ≤ K) : Integrable U P := |
| Integrable.of_bound hU.aestronglyMeasurable K (ae_of_all _ (fun x => by simpa using hK x)) |
|
|
| lemma bounded_integral_hasDerivAt {Ω : Type*} [MeasurableSpace Ω] |
| (P : Measure Ω) [IsFiniteMeasure P] {U D : ℝ → Ω → ℝ} {S : Set ℝ} {x : ℝ} |
| (hS : S ∈ 𝓝 x) (hU : ∀ y, Measurable (U y)) (hD : Measurable (D x)) |
| {K C : ℝ} (hK : ∀ z, |U x z| ≤ K) (hC : ∀ y ∈ S, ∀ z, |D y z| ≤ C) |
| (hd : ∀ y ∈ S, ∀ z, HasDerivAt (fun t => U t z) (D y z) y) : |
| HasDerivAt (fun t => ∫ z, U t z ∂P) (∫ z, D x z ∂P) x := by |
| exact (hasDerivAt_integral_of_dominated_loc_of_deriv_le hS |
| (Eventually.of_forall (fun y => (hU y).aestronglyMeasurable)) |
| (bounded_integrable P (hU x) hK) hD.aestronglyMeasurable |
| (ae_of_all _ (fun z y hy => by simpa using hC y hy z)) (integrable_const C) |
| (ae_of_all _ (fun z y hy => hd y hy z))).2 |
|
|
| lemma bounded_exp_integral_hasDerivAt {Ω : Type*} [MeasurableSpace Ω] |
| (P : Measure Ω) [IsFiniteMeasure P] {U D : ℝ → Ω → ℝ} {S : Set ℝ} {x : ℝ} |
| (hS : S ∈ 𝓝 x) (hU : ∀ y, Measurable (U y)) (hD : Measurable (D x)) |
| {K C : ℝ} (hK : ∀ y ∈ S, ∀ z, |U y z| ≤ K) |
| (hC : ∀ y ∈ S, ∀ z, |D y z| ≤ C) |
| (hd : ∀ y ∈ S, ∀ z, HasDerivAt (fun t => U t z) (D y z) y) : |
| HasDerivAt (fun t => ∫ z, Real.exp (U t z) ∂P) |
| (∫ z, Real.exp (U x z) * D x z ∂P) x := by |
| apply bounded_integral_hasDerivAt P hS (fun y => (hU y).exp) ((hU x).exp.mul hD) |
| (K := Real.exp K) (C := Real.exp K * C) |
| · intro z |
| rw [abs_of_pos (Real.exp_pos _)] |
| exact Real.exp_le_exp.mpr ((le_abs_self _).trans (hK x (mem_of_mem_nhds hS) z)) |
| · intro y hy z |
| rw [abs_mul,abs_of_pos (Real.exp_pos _)] |
| exact mul_le_mul (Real.exp_le_exp.mpr ((le_abs_self _).trans (hK y hy z))) |
| (hC y hy z) (abs_nonneg _) (Real.exp_pos _).le |
| · exact fun y hy z => (hd y hy z).exp |
|
|
| lemma gaussianTransform_hasDerivAt {U D : ℝ → ℝ} |
| (hU : Measurable U) (hD : Measurable D) {K C : ℝ} |
| (hK : ∀ y, |U y| ≤ K) (hC : ∀ y, |D y| ≤ C) |
| (hd : ∀ y, HasDerivAt U (D y) y) (s d x : ℝ) : |
| HasDerivAt (gaussianTransform s d U) (gaussianTiltAverage s d U D x) x := by |
| have hd0 : ∀ y ∈ (Set.univ : Set ℝ), ∀ z, |
| HasDerivAt (fun t => U (t + Real.sqrt s*z)) (D (y+Real.sqrt s*z)) y := by |
| intro y _ z |
| convert (hd (y+Real.sqrt s*z)).comp y ((hasDerivAt_id y).add_const _) using 1 <;> |
| first | rfl | simp only [mul_one] |
| by_cases hdv : d = 0 |
| · subst d |
| rw [show gaussianTransform s 0 U = (fun t => ∫ z, U (t+Real.sqrt s*z) ∂gaussianReal 0 1) from |
| funext (fun t => by simp only [gaussianTransform,ite_true]), gaussianTiltAverage_zero] |
| exact |
| bounded_integral_hasDerivAt (gaussianReal 0 1) (Filter.univ_mem : Set.univ ∈ 𝓝 x) |
| (fun y => hU.comp (by fun_prop)) (hD.comp (by fun_prop)) |
| (fun z => hK _) (fun y _ z => hC _) hd0 |
| · have hh := bounded_exp_integral_hasDerivAt (gaussianReal 0 1) |
| (U := fun t z => d*U (t+Real.sqrt s*z)) (D := fun t z => d*D (t+Real.sqrt s*z)) |
| (Filter.univ_mem : Set.univ ∈ 𝓝 x) |
| (fun y => measurable_const.mul (hU.comp (by fun_prop))) |
| (measurable_const.mul (hD.comp (by fun_prop))) |
| (K := |d| * K) (C := |d| * C) |
| (fun y _ z => by rw [abs_mul]; exact mul_le_mul_of_nonneg_left (hK _) (abs_nonneg _)) |
| (fun y _ z => by rw [abs_mul]; exact mul_le_mul_of_nonneg_left (hC _) (abs_nonneg _)) |
| (fun y hy z => (hd0 y hy z).const_mul d) |
| have hp := integral_pos_exp_of_bound (gaussianReal 0 1) |
| (hU.comp (by fun_prop : Measurable (fun z => x+Real.sqrt s*z))) (fun z => hK _) d |
| convert (hh.log hp.ne').div_const d using 1 <;> try rfl |
| · ext y |
| simp only [gaussianTransform,hdv,ite_false] |
| · rw [gaussianTiltAverage_eq_div] |
| have he : (∫ z, Real.exp (d*U (x+Real.sqrt s*z))*(d*D (x+Real.sqrt s*z)) ∂gaussianReal 0 1) = |
| d*(∫ z, Real.exp (d*U (x+Real.sqrt s*z))*D (x+Real.sqrt s*z) ∂gaussianReal 0 1) := by |
| rw [← integral_const_mul] |
| congr 1; ext z; ring |
| rw [he] |
| field_simp [hdv] |
|
|
| end IsingPerceptron |
|
|
| |
|
|
| |
|
|
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped BigOperators Topology ENNReal NNReal |
| namespace IsingPerceptron |
|
|
| lemma bounded_exp_mul_integrable {Ω : Type*} [MeasurableSpace Ω] |
| (P : Measure Ω) [IsFiniteMeasure P] {U A : Ω → ℝ} |
| (hU : Measurable U) (hA : Measurable A) {K C : ℝ} |
| (hK : ∀ z, |U z| ≤ K) (hC : ∀ z, |A z| ≤ C) (d : ℝ) : |
| Integrable (fun z => Real.exp (d*U z)*A z) P := by |
| apply bounded_integrable P ((measurable_const.mul hU).exp.mul hA) |
| (K := Real.exp (|d| * K) * C) |
| intro z |
| change |Real.exp (d*U z)*A z| ≤ _ |
| rw [abs_mul,abs_of_pos (Real.exp_pos _)] |
| refine mul_le_mul ?_ (hC z) (abs_nonneg _) (Real.exp_pos _).le |
| exact Real.exp_le_exp.mpr ((le_abs_self _).trans (by |
| rw [abs_mul]; exact mul_le_mul_of_nonneg_left (hK z) (abs_nonneg _))) |
|
|
| lemma bounded_tilt_hasDerivAt {Ω : Type*} [MeasurableSpace Ω] |
| (P : Measure Ω) [IsProbabilityMeasure P] {U A DU DA : ℝ → Ω → ℝ} |
| {S : Set ℝ} {x : ℝ} (hS : S ∈ 𝓝 x) |
| (hU : ∀ t, Measurable (U t)) (hA : ∀ t, Measurable (A t)) |
| (hDU : Measurable (DU x)) (hDA : Measurable (DA x)) |
| {K M C L : ℝ} (hK : ∀ t ∈ S, ∀ z, |U t z| ≤ K) |
| (hM : ∀ t ∈ S, ∀ z, |A t z| ≤ M) |
| (hC : ∀ t ∈ S, ∀ z, |DU t z| ≤ C) |
| (hL : ∀ t ∈ S, ∀ z, |DA t z| ≤ L) |
| (dU : ∀ t ∈ S, ∀ z, HasDerivAt (fun a => U a z) (DU t z) t) |
| (dA : ∀ t ∈ S, ∀ z, HasDerivAt (fun a => A a z) (DA t z) t) (d : ℝ) : |
| HasDerivAt (fun t => ∫ z, A t z ∂P.tilted (fun z => d*U t z)) |
| ((∫ z, DA x z ∂P.tilted (fun z => d*U x z)) + |
| d*((∫ z, A x z*DU x z ∂P.tilted (fun z => d*U x z)) - |
| (∫ z, A x z ∂P.tilted (fun z => d*U x z))* |
| (∫ z, DU x z ∂P.tilted (fun z => d*U x z)))) x := by |
| have hx := mem_of_mem_nhds hS |
| have hE : ∀ t ∈ S, ∀ z, Real.exp (d*U t z) ≤ Real.exp (|d| * K) := by |
| intro t ht z |
| apply Real.exp_le_exp.mpr |
| exact (le_abs_self _).trans (by rw [abs_mul]; exact mul_le_mul_of_nonneg_left (hK t ht z) (abs_nonneg _)) |
| have hAD : ∀ t ∈ S, ∀ z, |A t z*DU t z| ≤ M*C := by |
| intro t ht z; rw [abs_mul] |
| exact mul_le_mul (hM t ht z) (hC t ht z) (abs_nonneg _) ((abs_nonneg _).trans (hM t ht z)) |
| have hden := bounded_exp_integral_hasDerivAt P hS |
| (U := fun t z => d*U t z) (D := fun t z => d*DU t z) |
| (fun t => measurable_const.mul (hU t)) (measurable_const.mul hDU) |
| (K := |d| * K) (C := |d| * C) |
| (fun t ht z => by rw [abs_mul]; exact mul_le_mul_of_nonneg_left (hK t ht z) (abs_nonneg _)) |
| (fun t ht z => by rw [abs_mul]; exact mul_le_mul_of_nonneg_left (hC t ht z) (abs_nonneg _)) |
| (fun t ht z => (dU t ht z).const_mul d) |
| have hnum := bounded_integral_hasDerivAt P hS |
| (U := fun t z => Real.exp (d*U t z)*A t z) |
| (D := fun t z => Real.exp (d*U t z)*DA t z + d*(Real.exp (d*U t z)*(A t z*DU t z))) |
| (fun t => (measurable_const.mul (hU t)).exp.mul (hA t)) |
| (((measurable_const.mul (hU x)).exp.mul hDA).add |
| (measurable_const.mul ((measurable_const.mul (hU x)).exp.mul ((hA x).mul hDU)))) |
| (K := Real.exp (|d| * K)*M) (C := Real.exp (|d| * K)*L + |d| * (Real.exp (|d| * K)*(M*C))) |
| (fun z => by |
| rw [abs_mul,abs_of_pos (Real.exp_pos _)] |
| exact mul_le_mul (hE x hx z) (hM x hx z) (abs_nonneg _) (Real.exp_pos _).le) |
| (fun t ht z => by |
| refine (abs_add_le _ _).trans (add_le_add ?_ ?_) |
| · rw [abs_mul,abs_of_pos (Real.exp_pos _)] |
| exact mul_le_mul (hE t ht z) (hL t ht z) (abs_nonneg _) (Real.exp_pos _).le |
| · rw [abs_mul,abs_mul,abs_of_pos (Real.exp_pos _)] |
| exact mul_le_mul_of_nonneg_left |
| (mul_le_mul (hE t ht z) (hAD t ht z) (abs_nonneg _) (Real.exp_pos _).le) (abs_nonneg _)) |
| (fun t ht z => by |
| convert (((dU t ht z).const_mul d).exp).mul (dA t ht z) using 1; first | rfl | ring) |
| have hp := integral_pos_exp_of_bound P (hU x) (hK x hx) d |
| have h1 := bounded_exp_mul_integrable P (hU x) hDA (hK x hx) (hL x hx) d |
| have h2 := bounded_exp_mul_integrable P (hU x) ((hA x).mul hDU) (hK x hx) (hAD x hx) d |
| change Integrable (fun z => Real.exp (d*U x z)*(A x z*DU x z)) P at h2 |
| have hde : (∫ z, Real.exp (d*U x z)*(d*DU x z) ∂P) = |
| d*(∫ z, Real.exp (d*U x z)*DU x z ∂P) := by |
| rw [← integral_const_mul]; congr 1; ext z; ring |
| have hne : (∫ z, Real.exp (d*U x z)*DA x z + d*(Real.exp (d*U x z)*(A x z*DU x z)) ∂P) = |
| (∫ z, Real.exp (d*U x z)*DA x z ∂P) + d*(∫ z, Real.exp (d*U x z)*(A x z*DU x z) ∂P) := by |
| rw [integral_add h1 (h2.const_mul d),integral_const_mul] |
| convert hnum.div hden hp.ne' using 1 <;> try rfl |
| · ext t; exact integral_tilted_eq_div _ _ _ |
| · simp only [integral_tilted_eq_div] |
| rw [hde,hne] |
| field_simp |
| ring |
|
|
| lemma gaussianTiltAverage_hasDerivAt {U D A B : ℝ → ℝ} |
| (hU : Measurable U) (hD : Measurable D) (hA : Measurable A) (hB : Measurable B) |
| {K C M L : ℝ} (hK : ∀ y, |U y| ≤ K) (hC : ∀ y, |D y| ≤ C) |
| (hM : ∀ y, |A y| ≤ M) (hL : ∀ y, |B y| ≤ L) |
| (dU : ∀ y, HasDerivAt U (D y) y) (dA : ∀ y, HasDerivAt A (B y) y) (s d x : ℝ) : |
| HasDerivAt (gaussianTiltAverage s d U A) |
| (gaussianTiltAverage s d U B x + d*(gaussianTiltAverage s d U (fun y => A y*D y) x - |
| gaussianTiltAverage s d U A x*gaussianTiltAverage s d U D x)) x := by |
| exact bounded_tilt_hasDerivAt (gaussianReal 0 1) |
| (U := fun t z => U (t+Real.sqrt s*z)) (A := fun t z => A (t+Real.sqrt s*z)) |
| (DU := fun t z => D (t+Real.sqrt s*z)) (DA := fun t z => B (t+Real.sqrt s*z)) |
| (Filter.univ_mem : Set.univ ∈ 𝓝 x) |
| (fun t => hU.comp (by fun_prop)) (fun t => hA.comp (by fun_prop)) |
| (hD.comp (by fun_prop)) (hB.comp (by fun_prop)) |
| (fun _ _ z => hK _) (fun _ _ z => hM _) (fun _ _ z => hC _) (fun _ _ z => hL _) |
| (fun t _ z => by convert (dU (t+Real.sqrt s*z)).comp t ((hasDerivAt_id t).add_const _) using 1 <;> first | rfl | simp only [mul_one]) |
| (fun t _ z => by convert (dA (t+Real.sqrt s*z)).comp t ((hasDerivAt_id t).add_const _) using 1 <;> first | rfl | simp only [mul_one]) d |
|
|
| end IsingPerceptron |
|
|
| |
|
|
| |
|
|
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped BigOperators Topology ENNReal NNReal |
| namespace IsingPerceptron |
|
|
| lemma bounded_generator {D DD : ℝ → ℝ} {C L : ℝ} |
| (hC : ∀ y, |D y| ≤ C) (hL : ∀ y, |DD y| ≤ L) (d y : ℝ) : |
| |DD y + d*(D y)^2| ≤ L + |d| * C^2 := by |
| refine (abs_add_le _ _).trans (add_le_add (hL y) ?_) |
| rw [abs_mul,abs_pow] |
| exact mul_le_mul_of_nonneg_left (sq_le_sq₀ (abs_nonneg _) ((abs_nonneg _).trans (hC y)) |>.mpr (hC y)) (abs_nonneg _) |
|
|
| lemma gaussian_tilted_ibp {U D DD : ℝ → ℝ} |
| (hU : Measurable U) (hD : Measurable D) (hDD : Measurable DD) |
| {K C L : ℝ} (hK : ∀ y, |U y| ≤ K) (hC : ∀ y, |D y| ≤ C) |
| (hL : ∀ y, |DD y| ≤ L) |
| (dU : ∀ y, HasDerivAt U (D y) y) (dD : ∀ y, HasDerivAt D (DD y) y) |
| (r d x : ℝ) : |
| (∫ z, z*D (x+r*z) ∂(gaussianReal 0 1).tilted (fun z => d*U (x+r*z))) = |
| r*(∫ z, DD (x+r*z)+d*(D (x+r*z))^2 |
| ∂(gaussianReal 0 1).tilted (fun z => d*U (x+r*z))) := by |
| let F := fun z => Real.exp (d*U (x+r*z))*D (x+r*z) |
| let DF := fun z => r*(Real.exp (d*U (x+r*z))*(DD (x+r*z)+d*(D (x+r*z))^2)) |
| have hm : Measurable DF := by dsimp [DF]; fun_prop |
| have he : ∀ z, Real.exp (d*U (x+r*z)) ≤ Real.exp (|d| * K) := by |
| intro z |
| exact Real.exp_le_exp.mpr ((le_abs_self _).trans (by |
| rw [abs_mul]; exact mul_le_mul_of_nonneg_left (hK _) (abs_nonneg _))) |
| have hF : ∀ z, |F z| ≤ Real.exp (|d| * K)*C := by |
| intro z |
| dsimp [F] |
| rw [abs_mul,abs_of_pos (Real.exp_pos _)] |
| exact mul_le_mul (he z) (hC _) (abs_nonneg _) (Real.exp_pos _).le |
| have hDF : ∀ z, |DF z| ≤ |r| * Real.exp (|d| * K)*(L+|d| * C^2) := by |
| intro z |
| dsimp [DF] |
| rw [abs_mul,abs_mul,abs_of_pos (Real.exp_pos _)] |
| rw [← mul_assoc] |
| exact mul_le_mul |
| (mul_le_mul_of_nonneg_left (he z) (abs_nonneg _)) |
| (bounded_generator hC hL d _) (abs_nonneg _) |
| (mul_nonneg (abs_nonneg _) (Real.exp_pos _).le) |
| have hd : ∀ z, HasDerivAt F (DF z) z := by |
| intro z |
| have ha : HasDerivAt (fun z => x+r*z) r z := by |
| convert (((hasDerivAt_id z).const_mul r).const_add x) using 1 <;> first | rfl | simp |
| have h1 := (dU (x+r*z)).comp z ha |
| have h2 := (dD (x+r*z)).comp z ha |
| convert ((h1.const_mul d).exp).mul h2 using 1 <;> first | rfl | dsimp [F,DF]; ring |
| have hibp := gaussian_integration_by_parts_bounded hd hm hF hDF |
| dsimp [F,DF] at hibp |
| simp only [integral_tilted_eq_div] |
| have hnum : (∫ z, Real.exp (d*U (x+r*z))*(z*D (x+r*z)) ∂gaussianReal 0 1) = |
| r*(∫ z, Real.exp (d*U (x+r*z))*(DD (x+r*z)+d*(D (x+r*z))^2) ∂gaussianReal 0 1) := by |
| rw [← integral_const_mul] |
| calc |
| _ = ∫ z, z*(Real.exp (d*U (x+r*z))*D (x+r*z)) ∂gaussianReal 0 1 := by |
| congr 1; ext z; ring |
| _ = _ := hibp |
| rw [hnum] |
| ring |
|
|
| end IsingPerceptron |
|
|
| |
|
|
| |
|
|
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped BigOperators Topology ENNReal NNReal |
| namespace IsingPerceptron |
|
|
| lemma bounded_expIntegral_hasFDerivAt {Ω E : Type*} [MeasurableSpace Ω] |
| [NormedAddCommGroup E] [NormedSpace ℝ E] |
| (P : Measure Ω) [IsFiniteMeasure P] {U : E → Ω → ℝ} |
| {D : E → Ω → E →L[ℝ] ℝ} {S : Set E} {x : E} |
| (hS : S ∈ 𝓝 x) (hU : ∀ y, Measurable (U y)) |
| (hD : AEStronglyMeasurable (D x) P) {K : ℝ} {B : Ω → ℝ} |
| (hK : ∀ y ∈ S, ∀ z, |U y z| ≤ K) |
| (hB : ∀ y ∈ S, ∀ z, ‖D y z‖ ≤ B z) (hBi : Integrable B P) |
| (hd : ∀ y ∈ S, ∀ z, HasFDerivAt (fun t => U t z) (D y z) y) : |
| HasFDerivAt (fun t => ∫ z, Real.exp (U t z) ∂P) |
| (∫ z, Real.exp (U x z) • D x z ∂P) x := by |
| apply hasFDerivAt_integral_of_dominated_of_fderiv_le hS |
| (Eventually.of_forall (fun y => (hU y).exp.aestronglyMeasurable)) |
| (bounded_integrable P (hU x).exp (K := Real.exp K) (fun z => by |
| rw [abs_of_pos (Real.exp_pos _)] |
| exact Real.exp_le_exp.mpr ((le_abs_self _).trans (hK x (mem_of_mem_nhds hS) z)))) |
| ((hU x).exp.aestronglyMeasurable.smul hD) (bound := fun z => Real.exp K * B z) |
| · exact ae_of_all _ (fun z y hy => by |
| rw [norm_smul,Real.norm_eq_abs,abs_of_pos (Real.exp_pos _)] |
| exact mul_le_mul (Real.exp_le_exp.mpr ((le_abs_self _).trans (hK y hy z))) |
| (hB y hy z) (norm_nonneg _) (Real.exp_pos _).le) |
| · exact hBi.const_mul _ |
| · exact ae_of_all _ (fun z y hy => (hd y hy z).exp) |
|
|
| lemma bounded_logIntegral_hasFDerivAt {Ω E : Type*} [MeasurableSpace Ω] |
| [NormedAddCommGroup E] [NormedSpace ℝ E] |
| (P : Measure Ω) [IsProbabilityMeasure P] {U : E → Ω → ℝ} |
| {D : E → Ω → E →L[ℝ] ℝ} {S : Set E} {x : E} |
| (hS : S ∈ 𝓝 x) (hU : ∀ y, Measurable (U y)) |
| (hD : AEStronglyMeasurable (D x) P) {K : ℝ} {B : Ω → ℝ} |
| (hK : ∀ y ∈ S, ∀ z, |U y z| ≤ K) |
| (hB : ∀ y ∈ S, ∀ z, ‖D y z‖ ≤ B z) (hBi : Integrable B P) |
| (hd : ∀ y ∈ S, ∀ z, HasFDerivAt (fun t => U t z) (D y z) y) : |
| HasFDerivAt (fun t => Real.log (∫ z, Real.exp (U t z) ∂P)) |
| (∫ z, D x z ∂P.tilted (U x)) x := by |
| have hh := bounded_expIntegral_hasFDerivAt P hS hU hD hK hB hBi hd |
| have hp := integral_pos_exp_of_bound P (hU x) (hK x (mem_of_mem_nhds hS)) 1 |
| simp only [one_mul] at hp |
| have he : (∫ z, D x z ∂P.tilted (U x)) = |
| (∫ z, Real.exp (U x z) ∂P)⁻¹ • (∫ z, Real.exp (U x z) • D x z ∂P) := by |
| rw [integral_tilted,← integral_smul] |
| congr 1; ext z |
| rw [smul_smul] |
| congr 1; ring_nf |
| rw [he] |
| exact hh.log hp.ne' |
|
|
| lemma bounded_average_hasFDerivAt {Ω E : Type*} [MeasurableSpace Ω] |
| [NormedAddCommGroup E] [NormedSpace ℝ E] |
| (P : Measure Ω) [IsProbabilityMeasure P] {U : E → Ω → ℝ} |
| {D : E → Ω → E →L[ℝ] ℝ} {S : Set E} {x : E} |
| (hS : S ∈ 𝓝 x) (hU : ∀ y, Measurable (U y)) |
| (hD : AEStronglyMeasurable (D x) P) {K : ℝ} {B : Ω → ℝ} |
| (hK : ∀ y ∈ S, ∀ z, |U y z| ≤ K) |
| (hB : ∀ y ∈ S, ∀ z, ‖D y z‖ ≤ B z) (hBi : Integrable B P) |
| (hd : ∀ y ∈ S, ∀ z, HasFDerivAt (fun t => U t z) (D y z) y) (d : ℝ) : |
| HasFDerivAt (fun t => if d = 0 then ∫ z, U t z ∂P |
| else Real.log (∫ z, Real.exp (d*U t z) ∂P) / d) |
| (∫ z, D x z ∂P.tilted (fun z => d*U x z)) x := by |
| by_cases hz : d = 0 |
| · subst d |
| simp only [ite_true,zero_mul,tilted_const] |
| exact hasFDerivAt_integral_of_dominated_of_fderiv_le hS |
| (Eventually.of_forall (fun y => (hU y).aestronglyMeasurable)) |
| (bounded_integrable P (hU x) (hK x (mem_of_mem_nhds hS))) hD |
| (ae_of_all _ (fun z y hy => hB y hy z)) hBi (ae_of_all _ (fun z y hy => hd y hy z)) |
| · have hh := bounded_logIntegral_hasFDerivAt P hS |
| (U := fun t z => d*U t z) (D := fun t z => d • D t z) |
| (fun y => measurable_const.mul (hU y)) (hD.const_smul d) |
| (K := |d| * K) (B := fun z => |d| * B z) |
| (fun y hy z => by rw [abs_mul]; exact mul_le_mul_of_nonneg_left (hK y hy z) (abs_nonneg _)) |
| (fun y hy z => by rw [norm_smul,Real.norm_eq_abs]; exact mul_le_mul_of_nonneg_left (hB y hy z) (abs_nonneg _)) |
| (hBi.const_mul _) (fun y hy z => (hd y hy z).const_mul d) |
| convert hh.const_mul d⁻¹ using 1 <;> try rfl |
| · ext y; simp only [hz,ite_false]; ring |
| · rw [integral_smul,smul_smul,inv_mul_cancel₀ hz,one_smul] |
|
|
| end IsingPerceptron |
|
|
| |
|
|
| |
|
|
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped BigOperators Topology ENNReal NNReal |
| namespace IsingPerceptron |
|
|
| lemma gaussianTransform_abs_le {U : ℝ → ℝ} (hU : Measurable U) |
| {K : ℝ} (hK : ∀ y, |U y| ≤ K) (s : ℝ) {d : ℝ} (hd : 0 ≤ d) (x : ℝ) : |
| |gaussianTransform s d U x| ≤ K := by |
| by_cases hz : d = 0 |
| · subst d |
| simp only [gaussianTransform,ite_true] |
| simpa [Real.norm_eq_abs] using |
| norm_integral_le_of_norm_le_const (μ := gaussianReal 0 1) |
| (f := fun z => U (x+Real.sqrt s*z)) (C := K) |
| (ae_of_all _ (fun z => by simpa only [Real.norm_eq_abs] using hK (x+Real.sqrt s*z))) |
| · have hdpos : 0 < d := lt_of_le_of_ne hd (Ne.symm hz) |
| let Z := ∫ z, Real.exp (d*U (x+Real.sqrt s*z)) ∂gaussianReal 0 1 |
| have hi := exp_mul_integrable_of_bound (gaussianReal 0 1) |
| (hU.comp (by fun_prop : Measurable (fun z => x+Real.sqrt s*z))) (fun z => hK _) d |
| have hlo : Real.exp (-d*K) ≤ Z := by |
| calc |
| _ = ∫ _ : ℝ, Real.exp (-d*K) ∂gaussianReal 0 1 := by simp |
| _ ≤ Z := integral_mono (integrable_const _) hi (fun z => Real.exp_le_exp.mpr (by |
| have h := (abs_le.mp (hK (x+Real.sqrt s*z))).1 |
| nlinarith)) |
| have hhi : Z ≤ Real.exp (d*K) := by |
| calc |
| Z ≤ ∫ _ : ℝ, Real.exp (d*K) ∂gaussianReal 0 1 := |
| integral_mono hi (integrable_const _) (fun z => Real.exp_le_exp.mpr |
| (mul_le_mul_of_nonneg_left (abs_le.mp (hK _)).2 hd)) |
| _ = _ := by simp |
| have hZ : 0 < Z := (Real.exp_pos _).trans_le hlo |
| have hloglo := Real.log_le_log (Real.exp_pos _) hlo |
| have hloghi := Real.log_le_log hZ hhi |
| simp only [Real.log_exp] at hloglo hloghi |
| simp only [gaussianTransform,hz,ite_false] |
| change |Real.log Z/d| ≤ K |
| apply abs_le.mpr |
| exact ⟨(le_div_iff₀ hdpos).mpr (by nlinarith), (div_le_iff₀ hdpos).mpr (by nlinarith)⟩ |
|
|
| lemma measurable_gaussianTransform_param {E : Type*} [MeasurableSpace E] |
| {U : E → ℝ → ℝ} {s x : E → ℝ} |
| (hU : Measurable (fun p : E × ℝ => U p.1 p.2)) (hs : Measurable s) |
| (hx : Measurable x) (d : ℝ) : |
| Measurable (fun t => gaussianTransform (s t) d (U t) (x t)) := by |
| have hm : Measurable (fun p : E × ℝ => U p.1 (x p.1+Real.sqrt (s p.1)*p.2)) := |
| hU.comp (f := fun p : E × ℝ => (p.1,x p.1+Real.sqrt (s p.1)*p.2)) (by fun_prop) |
| by_cases hz : d = 0 |
| · subst d |
| simp only [gaussianTransform,ite_true] |
| exact hm.stronglyMeasurable.integral_prod_right'.measurable |
| · simp only [gaussianTransform,hz,ite_false] |
| exact ((measurable_const.mul hm).exp.stronglyMeasurable.integral_prod_right'.measurable.log).div_const _ |
|
|
| lemma measurable_gaussianTiltAverage_param {E : Type*} [MeasurableSpace E] |
| {U A : E → ℝ → ℝ} {s x : E → ℝ} |
| (hU : Measurable (fun p : E × ℝ => U p.1 p.2)) |
| (hA : Measurable (fun p : E × ℝ => A p.1 p.2)) (hs : Measurable s) |
| (hx : Measurable x) (d : ℝ) : |
| Measurable (fun t => gaussianTiltAverage (s t) d (U t) (A t) (x t)) := by |
| have hm : Measurable (fun p : E × ℝ => U p.1 (x p.1+Real.sqrt (s p.1)*p.2)) := |
| hU.comp (f := fun p : E × ℝ => (p.1,x p.1+Real.sqrt (s p.1)*p.2)) (by fun_prop) |
| have hn : Measurable (fun p : E × ℝ => A p.1 (x p.1+Real.sqrt (s p.1)*p.2)) := |
| hA.comp (f := fun p : E × ℝ => (p.1,x p.1+Real.sqrt (s p.1)*p.2)) (by fun_prop) |
| simp only [gaussianTiltAverage_eq_div] |
| exact ((measurable_const.mul hm).exp.mul hn).stronglyMeasurable.integral_prod_right'.measurable.div |
| ((measurable_const.mul hm).exp.stronglyMeasurable.integral_prod_right'.measurable) |
|
|
| end IsingPerceptron |
|
|
| |
|
|
| |
|
|
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped BigOperators Topology ENNReal NNReal |
| namespace IsingPerceptron |
|
|
| def pairLinear (a b : ℝ) : (ℝ × ℝ) →L[ℝ] ℝ := |
| a • ContinuousLinearMap.fst ℝ ℝ ℝ + b • ContinuousLinearMap.snd ℝ ℝ ℝ |
|
|
| @[simp] lemma pairLinear_apply (a b : ℝ) (p : ℝ × ℝ) : |
| pairLinear a b p = a*p.1+b*p.2 := rfl |
|
|
| lemma norm_pairLinear_le (a b : ℝ) : ‖pairLinear a b‖ ≤ |a|+|b| := by |
| refine (norm_add_le _ _).trans (add_le_add ?_ ?_) |
| · rw [norm_smul,Real.norm_eq_abs] |
| exact (mul_le_mul_of_nonneg_left (ContinuousLinearMap.norm_fst_le ℝ ℝ ℝ) (abs_nonneg _)).trans_eq (mul_one _) |
| · rw [norm_smul,Real.norm_eq_abs] |
| exact (mul_le_mul_of_nonneg_left (ContinuousLinearMap.norm_snd_le ℝ ℝ ℝ) (abs_nonneg _)).trans_eq (mul_one _) |
|
|
| lemma measurable_pairLinear {Ω : Type*} [MeasurableSpace Ω] {A B : Ω → ℝ} |
| (hA : Measurable A) (hB : Measurable B) : Measurable (fun z => pairLinear (A z) (B z)) := by |
| exact (hA.smul measurable_const).add (hB.smul measurable_const) |
|
|
| lemma integral_pairLinear {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) |
| {A B : Ω → ℝ} (hA : Integrable A P) (hB : Integrable B P) : |
| (∫ z, pairLinear (A z) (B z) ∂P) = pairLinear (∫ z, A z ∂P) (∫ z, B z ∂P) := by |
| simp only [pairLinear] |
| rw [integral_add (hA.smul_const _) (hB.smul_const _),integral_smul_const,integral_smul_const] |
|
|
| lemma integrable_tilt_of_bound {Ω E : Type*} [MeasurableSpace Ω] |
| [NormedAddCommGroup E] [NormedSpace ℝ E] |
| (P : Measure Ω) [IsFiniteMeasure P] {U : Ω → ℝ} {A : Ω → E} {B : Ω → ℝ} |
| (hU : Measurable U) (hA : AEStronglyMeasurable A P) {K : ℝ} |
| (hK : ∀ z, |U z| ≤ K) (hB : ∀ z, ‖A z‖ ≤ B z) (hBi : Integrable B P) (d : ℝ) : |
| Integrable A (P.tilted (fun z => d*U z)) := by |
| rw [integrable_tilted_iff (exp_mul_integrable_of_bound P hU hK d)] |
| apply (hBi.const_mul (Real.exp (|d| * K))).mono' |
| ((measurable_const.mul hU).exp.aestronglyMeasurable.smul hA) |
| exact ae_of_all _ (fun z => by |
| change ‖Real.exp (d*U z) • A z‖ ≤ _ |
| rw [norm_smul,Real.norm_eq_abs,abs_of_pos (Real.exp_pos _)] |
| apply mul_le_mul _ (hB z) (norm_nonneg _) (Real.exp_pos _).le |
| exact Real.exp_le_exp.mpr ((le_abs_self _).trans (by |
| rw [abs_mul]; exact mul_le_mul_of_nonneg_left (hK z) (abs_nonneg _)))) |
|
|
| end IsingPerceptron |
|
|
| |
|
|
| |
|
|
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped BigOperators Topology ENNReal NNReal |
| namespace IsingPerceptron |
|
|
| lemma abs_div_two_sqrt_le {m s : ℝ} (hm : 0 < m) (hs : m ≤ s) (v : ℝ) : |
| |v / (2*Real.sqrt s)| ≤ |v| / (2*Real.sqrt m) := by |
| rw [abs_div,abs_of_pos (mul_pos (by norm_num) (Real.sqrt_pos.2 (hm.trans_le hs)))] |
| exact div_le_div_of_nonneg_left (abs_nonneg _) (by positivity) |
| (mul_le_mul_of_nonneg_left (Real.sqrt_le_sqrt hs) (by norm_num)) |
|
|
| lemma affine_gaussian_shift_hasFDerivAt {U T X : ℝ × ℝ → ℝ} {I : Set ℝ} |
| (hd : ∀ p, p.1 ∈ I → HasFDerivAt U (pairLinear (T p) (X p)) p) |
| (a v z : ℝ) {p : ℝ × ℝ} (hp : p.1 ∈ I) (hs : 0 < a+v*p.1) : |
| HasFDerivAt (fun q : ℝ × ℝ => U (q.1,q.2+Real.sqrt (a+v*q.1)*z)) |
| (pairLinear (T (p.1,p.2+Real.sqrt (a+v*p.1)*z) + |
| X (p.1,p.2+Real.sqrt (a+v*p.1)*z)*(v/(2*Real.sqrt (a+v*p.1))*z)) |
| (X (p.1,p.2+Real.sqrt (a+v*p.1)*z))) p := by |
| have hf : HasFDerivAt (fun q : ℝ × ℝ => q.1) (ContinuousLinearMap.fst ℝ ℝ ℝ) p := hasFDerivAt_fst |
| have hg : HasFDerivAt (fun q : ℝ × ℝ => q.2) (ContinuousLinearMap.snd ℝ ℝ ℝ) p := hasFDerivAt_snd |
| have hr := ((hf.const_mul v).const_add a).sqrt hs.ne' |
| have hh := (hd (p.1,p.2+Real.sqrt (a+v*p.1)*z) hp).comp p (hf.prodMk (hg.add (hr.mul_const z))) |
| convert hh using 1 <;> try rfl |
| all_goals |
| apply ContinuousLinearMap.ext |
| intro w |
| simp [pairLinear] |
| ring |
|
|
| lemma gaussianFamily_raw_hasFDerivAt {U T X : ℝ × ℝ → ℝ} {I : Set ℝ} |
| (hI : IsOpen I) (hU : Measurable U) (hT : Measurable T) (hX : Measurable X) |
| {K CT CX : ℝ} (hK : ∀ p, |U p| ≤ K) |
| (hCT : ∀ p, p.1 ∈ I → |T p| ≤ CT) (hCX : ∀ p, |X p| ≤ CX) |
| (hd : ∀ p, p.1 ∈ I → HasFDerivAt U (pairLinear (T p) (X p)) p) |
| (a v d : ℝ) {m : ℝ} (hm : 0 < m) (hs : ∀ t ∈ I, m ≤ a+v*t) |
| {p : ℝ × ℝ} (hp : p.1 ∈ I) : |
| HasFDerivAt (fun q : ℝ × ℝ => gaussianTransform (a+v*q.1) d (fun y => U (q.1,y)) q.2) |
| (∫ z, pairLinear (T (p.1,p.2+Real.sqrt (a+v*p.1)*z) + |
| X (p.1,p.2+Real.sqrt (a+v*p.1)*z)*(v/(2*Real.sqrt (a+v*p.1))*z)) |
| (X (p.1,p.2+Real.sqrt (a+v*p.1)*z)) |
| ∂(gaussianReal 0 1).tilted (fun z => d*U (p.1,p.2+Real.sqrt (a+v*p.1)*z))) p := by |
| let S : Set (ℝ × ℝ) := Prod.fst ⁻¹' I |
| let R := |v|/(2*Real.sqrt m) |
| have hCX0 : 0 ≤ CX := (abs_nonneg _).trans (hCX (0,0)) |
| have hR : 0 ≤ R := by dsimp [R]; positivity |
| have hnm : S ∈ 𝓝 p := (hI.preimage continuous_fst).mem_nhds hp |
| apply bounded_average_hasFDerivAt (gaussianReal 0 1) hnm |
| (U := fun q z => U (q.1,q.2+Real.sqrt (a+v*q.1)*z)) |
| (D := fun q z => pairLinear (T (q.1,q.2+Real.sqrt (a+v*q.1)*z) + |
| X (q.1,q.2+Real.sqrt (a+v*q.1)*z)*(v/(2*Real.sqrt (a+v*q.1))*z)) |
| (X (q.1,q.2+Real.sqrt (a+v*q.1)*z))) |
| (fun q => hU.comp (by fun_prop)) |
| ((measurable_pairLinear ((hT.comp (by fun_prop)).add ((hX.comp (by fun_prop)).mul (by fun_prop))) |
| (hX.comp (by fun_prop))).aestronglyMeasurable) |
| (K := K) (B := fun z => CT+CX*(R*|z|)+CX) |
| (fun q _ z => hK _) ?_ ?_ ?_ d |
| · intro q hq z |
| refine (norm_pairLinear_le _ _).trans (add_le_add ?_ (hCX _)) |
| refine (abs_add_le _ _).trans (add_le_add (hCT _ hq) ?_) |
| rw [abs_mul,abs_mul] |
| exact mul_le_mul (hCX _) (mul_le_mul_of_nonneg_right (abs_div_two_sqrt_le hm (hs q.1 hq) v) (abs_nonneg _)) |
| (mul_nonneg (abs_nonneg _) (abs_nonneg _)) hCX0 |
| · exact ((integrable_const CT).add (((memLp_id_gaussianReal 1).integrable le_rfl).abs.const_mul R |>.const_mul CX)).add |
| (integrable_const CX) |
| · intro q hq z |
| exact affine_gaussian_shift_hasFDerivAt hd a v z hq (hm.trans_le (hs q.1 hq)) |
|
|
| end IsingPerceptron |
|
|
| end |
|
|
| end OAI |
|
|
