| import Mathlib |
| import OAI.Probability.IsingPerceptron.PoissonCloud |
|
|
| namespace OAI |
|
|
| /-! Map With Density Equiv. -/ |
|
|
| noncomputable section |
|
|
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped BigOperators Topology ENNReal NNReal BoundedContinuousFunction |
| namespace IsingPerceptron |
|
|
| lemma map_withDensity_equiv {E F : Type*} [MeasurableSpace E] [MeasurableSpace F] |
| (e : E ≃ᵐ F) (μ : Measure E) {w : E → ℝ≥0∞} (hw : Measurable w) : |
| (μ.withDensity w).map e = (μ.map e).withDensity (w ∘ e.symm) := by |
| apply Measure.ext_of_lintegral |
| intro f hf |
| calc |
| _ = ∫⁻ x, w x * f (e x) ∂μ := by |
| rw [lintegral_map hf e.measurable] |
| exact lintegral_withDensity_eq_lintegral_mul μ hw |
| (show Measurable (fun x => f (e x)) from hf.comp e.measurable) |
| _ = ∫⁻ x, (w (e.symm x) * f x) ∂μ.map e := by |
| simpa only [Pi.mul_apply, Function.comp_apply, e.symm_apply_apply] using |
| (lintegral_map (μ := μ) ((hw.comp e.symm.measurable).mul hf) e.measurable).symm |
| _ = _ := (lintegral_withDensity_eq_lintegral_mul _ |
| (hw.comp e.symm.measurable) hf).symm |
|
|
| def powerIntensityDensity (b : ℝ) (x : ℝ) : ℝ≥0∞ := |
| ENNReal.ofReal (if 0 < x then b * x ^ (-1-b) else 0) |
|
|
| def powerIntensity (b : ℝ) : Measure ℝ := volume.withDensity (powerIntensityDensity b) |
|
|
| lemma measurable_powerIntensityDensity (b : ℝ) : Measurable (powerIntensityDensity b) := by |
| unfold powerIntensityDensity |
| apply Measurable.ennreal_ofReal |
| apply Measurable.ite (measurableSet_lt measurable_const measurable_id) |
| · fun_prop |
| · fun_prop |
|
|
| lemma powerIntensityDensity_scale {b c : ℝ} (hc : 0 < c) (x : ℝ) : |
| ENNReal.ofReal c⁻¹ * powerIntensityDensity b (c⁻¹ * x) = |
| ENNReal.ofReal (c ^ b) * powerIntensityDensity b x := by |
| have hpos : 0 < c⁻¹ * x ↔ 0 < x := mul_pos_iff_of_pos_left (inv_pos.mpr hc) |
| unfold powerIntensityDensity |
| by_cases hx : 0 < x |
| · simp only [ite_eq_left hx, ite_eq_left (hpos.mpr hx)] |
| rw [← ENNReal.ofReal_mul (inv_nonneg.mpr hc.le), |
| ← ENNReal.ofReal_mul (Real.rpow_nonneg hc.le b)] |
| congr 1 |
| rw [Real.mul_rpow (inv_nonneg.mpr hc.le) hx.le, |
| Real.inv_rpow hc.le, ← Real.rpow_neg hc.le] |
| have he : c⁻¹ * c ^ (-(-1-b)) = c ^ b := by |
| rw [show -(-1-b) = b + 1 by ring, Real.rpow_add hc] |
| simp only [Real.rpow_one] |
| field_simp |
| calc |
| c⁻¹ * (b * (c ^ (-(-1-b)) * x ^ (-1-b))) = |
| b * (c⁻¹ * c ^ (-(-1-b))) * x ^ (-1-b) := by ring |
| _ = c ^ b * (b * x ^ (-1-b)) := by rw [he]; ring |
| · simp only [ite_eq_right hx, ite_eq_right (fun h => hx (hpos.mp h)), ENNReal.ofReal_zero, |
| mul_zero] |
| |
| theorem map_powerIntensity_mul {b c : ℝ} (hc : 0 < c) : |
| (powerIntensity b).map (fun x => c*x) = |
| ENNReal.ofReal (c ^ b) • powerIntensity b := by |
| let e := MeasurableEquiv.mulLeft₀ c hc.ne' |
| have hm := map_withDensity_equiv e volume (measurable_powerIntensityDensity b) |
| change (volume.withDensity (powerIntensityDensity b)).map e = _ |
| rw [hm] |
| change (volume.map (fun x => c*x)).withDensity |
| (fun x => powerIntensityDensity b (c⁻¹*x)) = _ |
| unfold powerIntensity |
| rw [Real.map_volume_mul_left hc.ne', abs_of_pos (inv_pos.mpr hc), |
| withDensity_smul_measure, ← withDensity_smul (ENNReal.ofReal c⁻¹) |
| (show Measurable (fun x => powerIntensityDensity b (c⁻¹*x)) from |
| (measurable_powerIntensityDensity b).comp (measurable_const_mul c⁻¹)), |
| ← withDensity_smul (ENNReal.ofReal (c^b)) (measurable_powerIntensityDensity b)] |
| congr 1 |
| funext x |
| exact powerIntensityDensity_scale hc x |
|
|
| instance powerIntensity_sigmaFinite (b : ℝ) : SigmaFinite (powerIntensity b) := by |
| unfold powerIntensity powerIntensityDensity |
| infer_instance |
|
|
| theorem map_marked_powerIntensity {E : Type*} [MeasurableSpace E] |
| (b : ℝ) (μ : Measure E) [SFinite μ] {a : E → ℝ} |
| (ha : Measurable a) (hpos : ∀ y, 0 < a y) : |
| ((powerIntensity b).prod μ).map (fun p : ℝ × E => (a p.2 * p.1, p.2)) = |
| (powerIntensity b).prod (μ.withDensity (fun y => ENNReal.ofReal (a y ^ b))) := by |
| have hw : Measurable (fun y => ENNReal.ofReal (a y ^ b)) := by fun_prop |
| have hT : Measurable (fun p : ℝ × E => (a p.2 * p.1, p.2)) := by fun_prop |
| apply Measure.ext_of_lintegral |
| intro f hf |
| calc |
| _ = ∫⁻ y, ∫⁻ x, f (a y*x,y) ∂powerIntensity b ∂μ := by |
| rw [lintegral_map hf hT] |
| exact lintegral_prod_symm _ (hf.comp hT).aemeasurable |
| _ = ∫⁻ y, ENNReal.ofReal (a y ^ b) * |
| (∫⁻ x, f (x,y) ∂powerIntensity b) ∂μ := by |
| apply lintegral_congr |
| intro y |
| have hy : Measurable (fun x : ℝ => f (x,y)) := hf.comp (measurable_id.prodMk measurable_const) |
| rw [← lintegral_map hy (measurable_const_mul (a y)), map_powerIntensity_mul (hpos y), |
| lintegral_smul_measure] |
| rfl |
| _ = ∫⁻ y, ∫⁻ x, f (x,y) ∂powerIntensity b |
| ∂μ.withDensity (fun y => ENNReal.ofReal (a y ^ b)) := by |
| exact (lintegral_withDensity_eq_lintegral_mul μ hw hf.lintegral_prod_left').symm |
| _ = _ := (lintegral_prod_symm f hf.aemeasurable).symm |
|
|
| lemma poissonLaw_congr {E : Type*} [MeasurableSpace E] [Nonempty E] |
| {μ ν : Measure E} [SFinite μ] [SFinite ν] (h : μ = ν) : poissonLaw μ = poissonLaw ν := by |
| subst ν |
| rfl |
|
|
| theorem poissonLaw_marked_power {E : Type*} [MeasurableSpace E] [Nonempty E] |
| (b : ℝ) (μ : Measure E) [SFinite μ] {a : E → ℝ} |
| (ha : Measurable a) (hpos : ∀ y, 0 < a y) : |
| (poissonLaw ((powerIntensity b).prod μ)).map |
| (fun ν => ν.map (fun p : ℝ × E => (a p.2 * p.1, p.2))) = |
| poissonLaw ((powerIntensity b).prod (μ.withDensity (fun y => ENNReal.ofReal (a y ^ b)))) := by |
| have hT : Measurable (fun p : ℝ × E => (a p.2 * p.1, p.2)) := by fun_prop |
| exact (poissonLaw_map _ hT).trans |
| (poissonLaw_congr (map_marked_powerIntensity b μ ha hpos)) |
|
|
| open Set |
|
|
| lemma integrable_power_min {b : ℝ} (hb : 0 < b) (hb1 : b < 1) : |
| Integrable (fun x : ℝ => min 1 (max x 0)) (powerIntensity b) := by |
| rw [powerIntensity, integrable_withDensity_iff (measurable_powerIntensityDensity b) |
| (ae_of_all _ (fun _ => ENNReal.ofReal_lt_top))] |
| have hi : IntegrableOn (fun x : ℝ => x ^ (-b)) (Ioc 0 1) := by |
| rw [integrableOn_Ioc_iff_integrableOn_Ioo] |
| exact (intervalIntegral.integrableOn_Ioo_rpow_iff (by norm_num)).mpr (by linarith) |
| have hj : IntegrableOn (fun x : ℝ => x ^ (-1-b)) (Ioi 1) := |
| integrableOn_Ioi_rpow_of_lt (by linarith) (by norm_num) |
| have H₁ : Integrable ((Ioc (0:ℝ) 1).indicator (fun x => b * x ^ (-b))) := |
| (integrable_indicator_iff measurableSet_Ioc).mpr (hi.const_mul b) |
| have H₂ : Integrable ((Ioi (1:ℝ)).indicator (fun x => b * x ^ (-1-b))) := |
| (integrable_indicator_iff measurableSet_Ioi).mpr (hj.const_mul b) |
| have H := H₁.add H₂ |
| apply H.congr |
| apply ae_of_all |
| intro x |
| symm |
| simp only [Pi.add_apply] |
| by_cases hx : 0 < x |
| · simp only [powerIntensityDensity, ite_eq_left hx, |
| ENNReal.toReal_ofReal (mul_nonneg hb.le (Real.rpow_nonneg hx.le _)), max_eq_left hx.le] |
| by_cases hx1 : x ≤ 1 |
| · rw [min_eq_right hx1, indicator_of_mem (show x ∈ Ioc (0:ℝ) 1 from ⟨hx,hx1⟩), |
| indicator_of_notMem (show x ∉ Ioi (1:ℝ) from not_lt.mpr hx1), add_zero] |
| have hp : x * x ^ (-1-b) = x ^ (-b) := by |
| calc |
| x * x ^ (-1-b) = x ^ (1 + (-1-b)) := by rw [Real.rpow_add hx, Real.rpow_one] |
| _ = x ^ (-b) := by congr 1; ring |
| nlinarith [hp] |
| · rw [min_eq_left (le_of_lt (lt_of_not_ge hx1)), one_mul, |
| indicator_of_notMem (show x ∉ Ioc (0:ℝ) 1 from fun h => hx1 h.2), |
| indicator_of_mem (show x ∈ Ioi (1:ℝ) from lt_of_not_ge hx1), zero_add] |
| · simp [powerIntensityDensity, hx, max_eq_right (le_of_not_gt hx), |
| indicator_of_notMem (show x ∉ Ioi (1:ℝ) from fun h => hx (lt_trans zero_lt_one h))] |
|
|
| def stableLaplaceCost (x : ℝ) : ℝ := 1 - Real.exp (-max x 0) |
|
|
| def stableLaplaceConstant (b : ℝ) : ℝ≥0∞ := |
| ∫⁻ x, ENNReal.ofReal (stableLaplaceCost x) ∂powerIntensity b |
|
|
| lemma measurable_stableLaplaceCost : Measurable stableLaplaceCost := by |
| unfold stableLaplaceCost |
| fun_prop |
|
|
| lemma stableLaplaceCost_nonneg (x : ℝ) : 0 ≤ stableLaplaceCost x := by |
| unfold stableLaplaceCost |
| exact sub_nonneg.mpr (Real.exp_le_one_iff.mpr (neg_nonpos.mpr (le_max_right _ _))) |
|
|
| lemma stableLaplaceCost_le_min (x : ℝ) : stableLaplaceCost x ≤ min 1 (max x 0) := by |
| unfold stableLaplaceCost |
| exact le_min (by linarith [Real.exp_pos (-max x 0)]) |
| (by linarith [Real.add_one_le_exp (-max x 0)]) |
|
|
| lemma integrable_stableLaplaceCost {b : ℝ} (hb : 0 < b) (hb1 : b < 1) : |
| Integrable stableLaplaceCost (powerIntensity b) := by |
| apply (integrable_power_min hb hb1).mono' measurable_stableLaplaceCost.aestronglyMeasurable |
| exact ae_of_all _ fun x => by |
| rw [Real.norm_eq_abs, abs_of_nonneg (stableLaplaceCost_nonneg x)] |
| exact stableLaplaceCost_le_min x |
|
|
| lemma stableLaplaceConstant_lt_top {b : ℝ} (hb : 0 < b) (hb1 : b < 1) : |
| stableLaplaceConstant b < ∞ := by |
| exact (hasFiniteIntegral_iff_ofReal (ae_of_all _ stableLaplaceCost_nonneg)).mp |
| (integrable_stableLaplaceCost hb hb1).hasFiniteIntegral |
|
|
| lemma stableLaplaceConstant_pos {b : ℝ} (hb : 0 < b) : 0 < stableLaplaceConstant b := by |
| unfold stableLaplaceConstant powerIntensity |
| rw [lintegral_withDensity_eq_lintegral_mul _ (measurable_powerIntensityDensity b) |
| measurable_stableLaplaceCost.ennreal_ofReal] |
| apply (lintegral_pos_iff_support ((measurable_powerIntensityDensity b).mul |
| measurable_stableLaplaceCost.ennreal_ofReal)).mpr |
| have hs : Function.support (powerIntensityDensity b * (fun x => ENNReal.ofReal (stableLaplaceCost x))) = |
| Ioi (0:ℝ) := by |
| ext x |
| by_cases hx : 0 < x |
| · have hp : 0 < b * x ^ (-1-b) := mul_pos hb (Real.rpow_pos_of_pos hx _) |
| have hc : 0 < 1 - Real.exp (-x) := sub_pos.mpr (Real.exp_lt_one_iff.mpr (neg_neg_of_pos hx)) |
| simp [Function.mem_support, powerIntensityDensity, stableLaplaceCost, hx, |
| max_eq_left hx.le, ne_of_gt (ENNReal.ofReal_pos.mpr hp), ne_of_gt (ENNReal.ofReal_pos.mpr hc)] |
| · simp [Function.mem_support, powerIntensityDensity, hx] |
| rw [hs] |
| simp |
|
|
| end IsingPerceptron |
|
|
| namespace IsingPerceptron |
|
|
| lemma integrable_negExp {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) [IsFiniteMeasure P] |
| {X : Ω → ℝ≥0∞} (hX : Measurable X) : Integrable (fun ω => negExp (X ω)) P := by |
| apply Integrable.mono' (integrable_const (1 : ℝ)) |
| (continuous_negExp.measurable.comp hX).aestronglyMeasurable |
| exact ae_of_all _ fun ω => by |
| change ‖negExp (X ω)‖ ≤ 1 |
| rw [Real.norm_eq_abs, abs_of_nonneg (negExp_nonneg _)] |
| exact negExp_le_one _ |
|
|
| lemma measure_zero_of_integral_tests {Ω : Type*} [MeasurableSpace Ω] |
| (P : Measure Ω) [IsFiniteMeasure P] {A : Set Ω} (hA : MeasurableSet A) |
| {f : ℕ → Ω → ℝ} (hfi : ∀ n, Integrable (f n) P) |
| (hfpos : ∀ n ω, 0 ≤ f n ω) (hb : ∀ n ω, ω ∈ A → 1 ≤ f n ω) |
| (ht : Tendsto (fun n => ∫ ω, f n ω ∂P) atTop (𝓝 0)) : P A = 0 := by |
| apply (measureReal_eq_zero_iff (μ := P) (s := A)).mp |
| apply le_antisymm _ measureReal_nonneg |
| apply ge_of_tendsto' ht |
| intro n |
| rw [← integral_indicator_one hA] |
| apply integral_mono ((integrable_const (1 : ℝ)).indicator hA) (hfi n) |
| intro ω |
| by_cases hω : ω ∈ A |
| · simpa only [indicator_of_mem hω, Pi.one_apply] using hb n ω hω |
| · simpa only [indicator_of_notMem hω] using hfpos n ω |
|
|
| theorem stable_laplace_finite_positive {Ω : Type*} [MeasurableSpace Ω] |
| (P : Measure Ω) [IsProbabilityMeasure P] {X : Ω → ℝ≥0∞} |
| (hX : Measurable X) {C b : ℝ} (hC : 0 < C) (hb : 0 < b) |
| (hl : ∀ t : ℝ, 0 < t → |
| (∫ ω, negExp (ENNReal.ofReal t * X ω) ∂P) = Real.exp (-C * t ^ b)) : |
| ∀ᵐ ω ∂P, 0 < X ω ∧ X ω < ∞ := by |
| have hi (t : ℝ) : Integrable (fun ω => negExp (ENNReal.ofReal t * X ω)) P := |
| integrable_negExp P (measurable_const.mul hX) |
| have hfinite : P {ω | X ω = ∞} = 0 := by |
| let t : ℕ → ℝ := fun n => 1 / ((n:ℝ)+1) |
| have htpos (n : ℕ) : 0 < t n := by dsimp [t]; positivity |
| apply measure_zero_of_integral_tests P (hX (measurableSet_singleton ∞)) |
| (f := fun n ω => 1 - negExp (ENNReal.ofReal (t n) * X ω)) |
| · intro n |
| exact (integrable_const 1).sub (hi (t n)) |
| · intro n ω |
| exact sub_nonneg.mpr (negExp_le_one _) |
| · intro n ω hω |
| change X ω = ∞ at hω |
| simp [hω, ENNReal.mul_top (ne_of_gt (ENNReal.ofReal_pos.mpr (htpos n)))] |
| · have ht : Tendsto t atTop (𝓝 0) := tendsto_one_div_add_atTop_nhds_zero_nat |
| have hr : Tendsto (fun n => (t n)^b) atTop (𝓝 0) := by |
| simpa only [Function.comp_def, Real.zero_rpow hb.ne'] using (Real.continuous_rpow_const hb.le).continuousAt.tendsto.comp ht |
| have he : Tendsto (fun n => 1 - Real.exp (-C * (t n)^b)) atTop (𝓝 0) := by |
| simpa only [Function.comp_def, mul_zero, Real.exp_zero, sub_self] using |
| (tendsto_const_nhds (x := (1:ℝ))).sub (Real.continuous_exp.continuousAt.tendsto.comp (hr.const_mul (-C))) |
| convert he using 1 |
| ext n |
| rw [integral_sub (integrable_const 1) (hi (t n)), hl _ (htpos n), integral_const] |
| simp |
| have hpositive : P {ω | X ω = 0} = 0 := by |
| let t : ℕ → ℝ := fun n => (n:ℝ)+1 |
| have htpos (n : ℕ) : 0 < t n := by dsimp [t]; positivity |
| apply measure_zero_of_integral_tests P (hX (measurableSet_singleton 0)) |
| (f := fun n ω => negExp (ENNReal.ofReal (t n) * X ω)) |
| · exact fun n => hi (t n) |
| · exact fun _ _ => negExp_nonneg _ |
| · intro n ω hω |
| change X ω = 0 at hω |
| simp [hω] |
| · have ht : Tendsto t atTop atTop := tendsto_atTop_add_const_right _ 1 tendsto_natCast_atTop_atTop |
| have hr := (tendsto_rpow_atTop hb).comp ht |
| have he := Real.tendsto_exp_atBot.comp |
| (tendsto_neg_atTop_atBot.comp (Filter.Tendsto.const_mul_atTop hC hr)) |
| simpa only [hl _ (htpos _), Function.comp_def, neg_mul] using he |
| have hf : ∀ᵐ ω ∂P, X ω ≠ ∞ := by simpa only [ae_iff, not_not] using hfinite |
| have hp : ∀ᵐ ω ∂P, X ω ≠ 0 := by simpa only [ae_iff, not_not] using hpositive |
| filter_upwards [hf, hp] with ω hf hp |
| exact ⟨pos_iff_ne_zero.mpr hp, lt_top_iff_ne_top.mpr hf⟩ |
|
|
| def poissonTotal (ν : Measure ℝ) : ℝ≥0∞ := ∫⁻ x, ENNReal.ofReal (max x 0) ∂ν |
|
|
| lemma measurable_poissonTotal : Measurable poissonTotal := |
| Measure.measurable_lintegral (by fun_prop) |
|
|
| lemma stableLaplaceCost_scale (t x : ℝ) (ht : 0 ≤ t) : |
| stableLaplaceCost (t*x) = 1-Real.exp (-t * max x 0) := by |
| have hm : max (t*x) 0 = t * max x 0 := by |
| simpa only [mul_zero] using (mul_max_of_nonneg x 0 ht).symm |
| rw [stableLaplaceCost, hm] |
| congr 2 |
| ring |
|
|
| lemma powerIntensity_laplace_scale {b t : ℝ} (ht : 0 < t) : |
| (∫⁻ x, ENNReal.ofReal (1-Real.exp (-t * max x 0)) ∂powerIntensity b) = |
| ENNReal.ofReal (t^b) * stableLaplaceConstant b := by |
| simp_rw [← stableLaplaceCost_scale t _ ht.le] |
| rw [← lintegral_map measurable_stableLaplaceCost.ennreal_ofReal |
| (measurable_const_mul t), map_powerIntensity_mul ht, lintegral_smul_measure] |
| rfl |
|
|
| theorem poissonTotal_laplace (b : ℝ) {t : ℝ} (ht : 0 < t) : |
| (∫ ν, negExp (ENNReal.ofReal t * poissonTotal ν) ∂poissonLaw (powerIntensity b)) = |
| negExp (ENNReal.ofReal (t^b) * stableLaplaceConstant b) := by |
| have hm : Measurable (fun x : ℝ => t * max x 0) := by fun_prop |
| have h := poissonLaw_laplace (powerIntensity b) hm (fun x => mul_nonneg ht.le (le_max_right _ _)) |
| simpa only [ENNReal.ofReal_mul ht.le, lintegral_const_mul' _ _ ENNReal.ofReal_ne_top, |
| poissonTotal, ← neg_mul, powerIntensity_laplace_scale ht] using h |
|
|
| theorem poissonTotal_finite_positive {b : ℝ} (hb : 0 < b) (hb1 : b < 1) : |
| ∀ᵐ ν ∂poissonLaw (powerIntensity b), 0 < poissonTotal ν ∧ poissonTotal ν < ∞ := by |
| have hfin := stableLaplaceConstant_lt_top hb hb1 |
| have hpos := stableLaplaceConstant_pos hb |
| apply stable_laplace_finite_positive _ measurable_poissonTotal |
| (ENNReal.toReal_pos hpos.ne' hfin.ne) hb |
| intro t ht |
| rw [poissonTotal_laplace b ht, ← ENNReal.ofReal_toReal hfin.ne, |
| ← ENNReal.ofReal_mul (Real.rpow_nonneg ht.le _), negExp_ofReal (by positivity)] |
| simp only [ENNReal.toReal_ofReal ENNReal.toReal_nonneg] |
| congr 1 |
| ring |
|
|
| lemma integrable_exp_neg_mul {Ω : Type*} [MeasurableSpace Ω] |
| (P : Measure Ω) [IsFiniteMeasure P] {X : Ω → ℝ} |
| (hX : Measurable X) (hpos : ∀ᵐ ω ∂P, 0 ≤ X ω) {t : ℝ} (ht : 0 ≤ t) : |
| Integrable (fun ω => Real.exp (-t * X ω)) P := by |
| apply (integrable_const (1 : ℝ)).mono' (by fun_prop) |
| filter_upwards [hpos] with ω hω |
| rw [Real.norm_eq_abs, abs_of_pos (Real.exp_pos _)] |
| exact Real.exp_le_one_iff.mpr (mul_nonpos_of_nonpos_of_nonneg (neg_nonpos.mpr ht) hω) |
|
|
| lemma measureReal_mul_le_integral {Ω : Type*} [MeasurableSpace Ω] |
| (P : Measure Ω) [IsFiniteMeasure P] {A : Set Ω} (hA : MeasurableSet A) |
| {f : Ω → ℝ} (hf : Integrable f P) (hfpos : 0 ≤ᵐ[P] f) (c : ℝ) |
| (hc : ∀ᵐ ω ∂P, ω ∈ A → c ≤ f ω) : P.real A * c ≤ ∫ ω, f ω ∂P := by |
| rw [← smul_eq_mul, ← integral_indicator_const c hA] |
| apply integral_mono_ae ((integrable_const c).indicator hA) hf |
| filter_upwards [hfpos, hc] with ω hp hb |
| by_cases hω : ω ∈ A |
| · simpa only [indicator_of_mem hω] using hb hω |
| · simpa only [indicator_of_notMem hω, Pi.zero_apply] using hp |
|
|
| lemma stable_laplace_upper_tail {Ω : Type*} [MeasurableSpace Ω] |
| (P : Measure Ω) [IsProbabilityMeasure P] {X : Ω → ℝ} |
| (hX : Measurable X) (hpos : ∀ᵐ ω ∂P, 0 ≤ X ω) {C b : ℝ} |
| (hl : ∀ t : ℝ, 0 < t → (∫ ω, Real.exp (-t * X ω) ∂P) = Real.exp (-C*t^b)) |
| {s : ℝ} (hs : 0 < s) : |
| P {ω | s < X ω} ≤ ENNReal.ofReal (C / (1-Real.exp (-1)) * s^(-b)) := by |
| have hc : 0 < 1-Real.exp (-1) := sub_pos.mpr (Real.exp_lt_one_iff.mpr (by norm_num)) |
| have hi := integrable_exp_neg_mul P hX hpos (inv_nonneg.mpr hs.le) |
| have h := measureReal_mul_le_integral P (measurableSet_lt measurable_const hX) |
| ((integrable_const 1).sub hi) (by |
| filter_upwards [hpos] with ω hω |
| exact sub_nonneg.mpr (Real.exp_le_one_iff.mpr (by nlinarith [inv_nonneg.mpr hs.le]))) |
| (1-Real.exp (-1)) (by |
| filter_upwards [] with ω hω |
| apply sub_le_sub_left |
| apply Real.exp_le_exp.mpr |
| have hmul : 1 < s⁻¹ * X ω := by |
| rw [← div_eq_inv_mul, lt_div_iff₀ hs] |
| simpa using hω |
| linarith) |
| simp only [Pi.sub_apply] at h |
| rw [integral_sub (integrable_const 1) hi, integral_const, hl _ (inv_pos.mpr hs)] at h |
| simp only [probReal_univ, smul_eq_mul, one_mul] at h |
| have hbnd : P.real {ω | s < X ω} ≤ C / (1-Real.exp (-1)) * s^(-b) := by |
| have he := Real.add_one_le_exp (-C * (s⁻¹)^b) |
| have hp : (s⁻¹)^b = s^(-b) := by rw [Real.inv_rpow hs.le, Real.rpow_neg hs.le] |
| rw [hp] at h he |
| apply (le_of_mul_le_mul_right _ hc) |
| calc |
| _ ≤ 1-Real.exp (-C * s^(-b)) := h |
| _ ≤ C * s^(-b) := by linarith |
| _ = (C / (1-Real.exp (-1)) * s^(-b)) * (1-Real.exp (-1)) := by field_simp |
| rw [← ENNReal.ofReal_toReal (measure_ne_top P _)] |
| exact ENNReal.ofReal_le_ofReal hbnd |
|
|
| lemma stable_laplace_inverse_tail {Ω : Type*} [MeasurableSpace Ω] |
| (P : Measure Ω) [IsProbabilityMeasure P] {X : Ω → ℝ} |
| (hX : Measurable X) (hpos : ∀ᵐ ω ∂P, 0 < X ω) {C b : ℝ} |
| (hl : ∀ t : ℝ, 0 < t → (∫ ω, Real.exp (-t * X ω) ∂P) = Real.exp (-C*t^b)) |
| {s : ℝ} (hs : 0 < s) : |
| P {ω | s < (X ω)⁻¹} ≤ ENNReal.ofReal (Real.exp 1 * Real.exp (-C*s^b)) := by |
| have hi := integrable_exp_neg_mul P hX (hpos.mono fun _ h => h.le) hs.le |
| have h := measureReal_mul_le_integral P (measurableSet_lt measurable_const hX.inv) hi |
| (ae_of_all _ fun _ => (Real.exp_pos _).le) (Real.exp (-1)) (by |
| filter_upwards [hpos] with ω hp hω |
| apply Real.exp_le_exp.mpr |
| have hmul : s * X ω < 1 := by |
| simpa only [mul_one] using (lt_inv_mul_iff₀' hp).mp (show s < (X ω)⁻¹ * 1 by simpa using hω) |
| linarith) |
| rw [hl _ hs] at h |
| have hbnd : P.real {ω | s < (X ω)⁻¹} ≤ Real.exp 1 * Real.exp (-C*s^b) := by |
| apply le_of_mul_le_mul_right _ (Real.exp_pos (-1)) |
| calc |
| _ ≤ Real.exp (-C*s^b) := h |
| _ = (Real.exp 1 * Real.exp (-C*s^b)) * Real.exp (-1) := by |
| rw [mul_comm (Real.exp 1), mul_assoc, ← Real.exp_add] |
| simp |
| rw [← ENNReal.ofReal_toReal (measure_ne_top P _)] |
| exact ENNReal.ofReal_le_ofReal hbnd |
|
|
| lemma integrable_rpow_of_power_tail {Ω : Type*} [MeasurableSpace Ω] |
| (P : Measure Ω) [IsProbabilityMeasure P] {X : Ω → ℝ} |
| (hX : Measurable X) (hpos : ∀ᵐ ω ∂P, 0 ≤ X ω) |
| {K b r : ℝ} (hK : 0 ≤ K) (hr : 0 < r) (hrb : r < b) |
| (htail : ∀ t : ℝ, 0 < t → P {ω | t < X ω} ≤ ENNReal.ofReal (K*t^(-b))) : |
| Integrable (fun ω => X ω ^ r) P := by |
| have hpow : ∀ᵐ ω ∂P, 0 ≤ X ω ^ r := hpos.mono fun _ h => Real.rpow_nonneg h _ |
| refine ⟨(hX.pow measurable_const).aestronglyMeasurable, ?_⟩ |
| rw [hasFiniteIntegral_iff_ofReal hpow, lintegral_rpow_eq_lintegral_meas_lt_mul P hpos hX.aemeasurable hr] |
| apply ENNReal.mul_lt_top ENNReal.ofReal_lt_top |
| let B : ℝ → ℝ := fun t => (Ioc (0:ℝ) 1).indicator (fun u => u^(r-1)) t + |
| (Ioi (1:ℝ)).indicator (fun u => K*u^(r-b-1)) t |
| have h₁ : IntegrableOn (fun t : ℝ => t^(r-1)) (Ioc 0 1) := by |
| rw [integrableOn_Ioc_iff_integrableOn_Ioo] |
| exact (intervalIntegral.integrableOn_Ioo_rpow_iff (by norm_num)).mpr (by linarith) |
| have h₂ : IntegrableOn (fun t : ℝ => K*t^(r-b-1)) (Ioi 1) := |
| (integrableOn_Ioi_rpow_of_lt (by linarith) (by norm_num)).const_mul K |
| have hB : Integrable B (volume.restrict (Ioi 0)) := |
| (((integrable_indicator_iff measurableSet_Ioc).mpr h₁).add |
| ((integrable_indicator_iff measurableSet_Ioi).mpr h₂)).restrict |
| have hBpos : ∀ t, 0 ≤ B t := by |
| intro t |
| apply add_nonneg |
| · exact (indicator_nonneg (s := Ioc (0:ℝ) 1) (fun u hu => Real.rpow_nonneg hu.1.le (r-1))) t |
| · exact (indicator_nonneg (s := Ioi (1:ℝ)) (fun u hu => mul_nonneg hK (Real.rpow_nonneg (le_trans zero_le_one (le_of_lt hu)) (r-b-1)))) t |
| have hfin := (hasFiniteIntegral_iff_ofReal (ae_of_all _ hBpos)).mp hB.hasFiniteIntegral |
| apply lt_of_le_of_lt _ hfin |
| apply lintegral_mono_ae |
| filter_upwards [ae_restrict_mem measurableSet_Ioi] with t ht |
| have ht0 : 0 < t := ht |
| by_cases ht1 : t ≤ 1 |
| · have hb : B t = t^(r-1) := by |
| simp only [B, indicator_of_mem (show t ∈ Ioc (0:ℝ) 1 from ⟨ht0,ht1⟩), |
| indicator_of_notMem (show t ∉ Ioi (1:ℝ) from not_lt.mpr ht1), add_zero] |
| rw [hb] |
| exact mul_le_of_le_one_left' prob_le_one |
| · have hb : B t = K*t^(r-b-1) := by |
| simp only [B, indicator_of_notMem (show t ∉ Ioc (0:ℝ) 1 from fun h => ht1 h.2), |
| indicator_of_mem (show t ∈ Ioi (1:ℝ) from lt_of_not_ge ht1), zero_add] |
| rw [hb] |
| calc |
| _ ≤ ENNReal.ofReal (K*t^(-b)) * ENNReal.ofReal (t^(r-1)) := |
| mul_le_mul_of_nonneg_right (htail t ht0) zero_le |
| _ = ENNReal.ofReal (K*t^(r-b-1)) := by |
| rw [← ENNReal.ofReal_mul (mul_nonneg hK (Real.rpow_nonneg ht0.le _)), |
| mul_assoc, ← Real.rpow_add ht0] |
| rw [show -b + (r-1) = r-b-1 by ring] |
|
|
| lemma integrable_rpow_of_exp_tail {Ω : Type*} [MeasurableSpace Ω] |
| (P : Measure Ω) [IsProbabilityMeasure P] {X : Ω → ℝ} |
| (hX : Measurable X) (hpos : ∀ᵐ ω ∂P, 0 ≤ X ω) |
| {K C b r : ℝ} (hK : 0 ≤ K) (hC : 0 < C) (hb : 0 < b) (hr : 0 < r) |
| (htail : ∀ t : ℝ, 0 < t → |
| P {ω | t < X ω} ≤ ENNReal.ofReal (K*Real.exp (-C*t^b))) : |
| Integrable (fun ω => X ω ^ r) P := by |
| have hpow : ∀ᵐ ω ∂P, 0 ≤ X ω ^ r := hpos.mono fun _ h => Real.rpow_nonneg h _ |
| refine ⟨(hX.pow measurable_const).aestronglyMeasurable, ?_⟩ |
| rw [hasFiniteIntegral_iff_ofReal hpow, lintegral_rpow_eq_lintegral_meas_lt_mul P hpos hX.aemeasurable hr] |
| apply ENNReal.mul_lt_top ENNReal.ofReal_lt_top |
| have hi : IntegrableOn (fun t : ℝ => K * (t^(r-1) * Real.exp (-C*t^b))) (Ioi 0) := |
| (integrableOn_rpow_mul_exp_neg_mul_rpow (by linarith) hb hC).const_mul K |
| have hnonneg : ∀ᵐ t ∂volume.restrict (Ioi (0:ℝ)), 0 ≤ K * (t^(r-1) * Real.exp (-C*t^b)) := by |
| filter_upwards [ae_restrict_mem measurableSet_Ioi] with t ht |
| exact mul_nonneg hK (mul_nonneg (Real.rpow_nonneg ht.le _) (Real.exp_nonneg _)) |
| apply lt_of_le_of_lt _ ((hasFiniteIntegral_iff_ofReal hnonneg).mp hi.hasFiniteIntegral) |
| apply lintegral_mono_ae |
| filter_upwards [ae_restrict_mem measurableSet_Ioi] with t ht |
| calc |
| _ ≤ ENNReal.ofReal (K*Real.exp (-C*t^b)) * ENNReal.ofReal (t^(r-1)) := |
| mul_le_mul_of_nonneg_right (htail t ht) zero_le |
| _ = ENNReal.ofReal (K*(t^(r-1)*Real.exp (-C*t^b))) := by |
| rw [← ENNReal.ofReal_mul (mul_nonneg hK (Real.exp_nonneg _))] |
| congr 1 |
| ring |
|
|
| lemma log_sq_le_powers {x r : ℝ} (hx : 0 < x) (hr : 0 < r) : |
| (Real.log x)^2 ≤ (2/r)^2 * (x^r + (x⁻¹)^r) := by |
| have he : 0 < r/2 := by positivity |
| have hpow (y : ℝ) (hy : 0 ≤ y) : (y^(r/2)/(r/2))^2 = (2/r)^2 * y^r := by |
| rw [div_pow, ← Real.rpow_mul_natCast hy] |
| norm_num |
| field_simp |
| by_cases hlog : 0 ≤ Real.log x |
| · have h := (sq_le_sq₀ hlog (div_nonneg (Real.rpow_nonneg hx.le _) he.le)).mpr |
| (Real.log_le_rpow_div hx.le he) |
| rw [hpow x hx.le] at h |
| nlinarith [Real.rpow_nonneg (inv_nonneg.mpr hx.le) r, sq_nonneg (2/r)] |
| · have hlog' : 0 ≤ Real.log x⁻¹ := by rw [Real.log_inv]; linarith |
| have h := (sq_le_sq₀ hlog' (div_nonneg (Real.rpow_nonneg (inv_nonneg.mpr hx.le) _) he.le)).mpr |
| (Real.log_le_rpow_div (inv_nonneg.mpr hx.le) he) |
| rw [hpow x⁻¹ (inv_nonneg.mpr hx.le), Real.log_inv, neg_sq] at h |
| nlinarith [Real.rpow_nonneg hx.le r, sq_nonneg (2/r)] |
|
|
| theorem integrable_log_sq_of_moments {Ω : Type*} [MeasurableSpace Ω] |
| (P : Measure Ω) {X : Ω → ℝ} (hX : Measurable X) |
| (hpos : ∀ᵐ ω ∂P, 0 < X ω) {r : ℝ} (hr : 0 < r) |
| (hi : Integrable (fun ω => X ω ^ r) P) |
| (hj : Integrable (fun ω => (X ω)⁻¹ ^ r) P) : |
| Integrable (fun ω => (Real.log (X ω))^2) P := by |
| apply ((hi.add hj).const_mul ((2/r)^2)).mono' ((hX.log.pow_const 2).aestronglyMeasurable) |
| filter_upwards [hpos] with ω hω |
| rw [Real.norm_eq_abs, abs_of_nonneg (sq_nonneg _)] |
| exact log_sq_le_powers hω hr |
|
|
| lemma stable_positive_moment {Ω : Type*} [MeasurableSpace Ω] |
| (P : Measure Ω) [IsProbabilityMeasure P] {X : Ω → ℝ} |
| (hX : Measurable X) (hpos : ∀ᵐ ω ∂P, 0 ≤ X ω) {C b r : ℝ} |
| (hC : 0 < C) (hr : 0 < r) (hrb : r < b) |
| (hl : ∀ t : ℝ, 0 < t → (∫ ω, Real.exp (-t * X ω) ∂P) = Real.exp (-C*t^b)) : |
| Integrable (fun ω => X ω ^ r) P := by |
| apply integrable_rpow_of_power_tail P hX hpos (K := C/(1-Real.exp (-1))) |
| (div_nonneg hC.le (sub_nonneg.mpr (Real.exp_le_one_iff.mpr (by norm_num)))) hr hrb |
| exact fun _ ht => stable_laplace_upper_tail P hX hpos hl ht |
|
|
| lemma stable_negative_moment {Ω : Type*} [MeasurableSpace Ω] |
| (P : Measure Ω) [IsProbabilityMeasure P] {X : Ω → ℝ} |
| (hX : Measurable X) (hpos : ∀ᵐ ω ∂P, 0 < X ω) {C b r : ℝ} |
| (hC : 0 < C) (hb : 0 < b) (hr : 0 < r) |
| (hl : ∀ t : ℝ, 0 < t → (∫ ω, Real.exp (-t * X ω) ∂P) = Real.exp (-C*t^b)) : |
| Integrable (fun ω => (X ω)⁻¹ ^ r) P := by |
| apply integrable_rpow_of_exp_tail P hX.inv (hpos.mono fun _ h => (inv_pos.mpr h).le) |
| (Real.exp_nonneg 1) hC hb hr |
| exact fun _ ht => stable_laplace_inverse_tail P hX hpos hl ht |
|
|
| lemma negExp_eq_exp_toReal {x : ℝ≥0∞} (hx : x ≠ ∞) : negExp x = Real.exp (-x.toReal) := by |
| conv_lhs => rw [← ENNReal.ofReal_toReal hx, negExp_ofReal ENNReal.toReal_nonneg] |
|
|
| lemma poissonTotal_real_laplace {b : ℝ} (hb : 0 < b) (hb1 : b < 1) |
| {t : ℝ} (ht : 0 < t) : |
| (∫ ν, Real.exp (-t * (poissonTotal ν).toReal) ∂poissonLaw (powerIntensity b)) = |
| Real.exp (-(stableLaplaceConstant b).toReal * t^b) := by |
| calc |
| _ = ∫ ν, negExp (ENNReal.ofReal t * poissonTotal ν) ∂poissonLaw (powerIntensity b) := by |
| apply integral_congr_ae |
| filter_upwards [poissonTotal_finite_positive hb hb1] with ν hν |
| rw [negExp_eq_exp_toReal (ENNReal.mul_ne_top ENNReal.ofReal_ne_top hν.2.ne), |
| ENNReal.toReal_mul, ENNReal.toReal_ofReal ht.le, neg_mul] |
| _ = _ := by |
| rw [poissonTotal_laplace b ht, |
| negExp_eq_exp_toReal (ENNReal.mul_ne_top ENNReal.ofReal_ne_top (stableLaplaceConstant_lt_top hb hb1).ne), |
| ENNReal.toReal_mul, ENNReal.toReal_ofReal (Real.rpow_nonneg ht.le b)] |
| congr 1 |
| ring |
|
|
| lemma poissonTotal_real_pos {b : ℝ} (hb : 0 < b) (hb1 : b < 1) : |
| ∀ᵐ ν ∂poissonLaw (powerIntensity b), 0 < (poissonTotal ν).toReal := by |
| filter_upwards [poissonTotal_finite_positive hb hb1] with ν hν |
| exact ENNReal.toReal_pos hν.1.ne' hν.2.ne |
|
|
| lemma poissonTotal_positive_moment {b r : ℝ} (hb : 0 < b) (hb1 : b < 1) |
| (hr : 0 < r) (hrb : r < b) : |
| Integrable (fun ν => (poissonTotal ν).toReal ^ r) (poissonLaw (powerIntensity b)) := |
| stable_positive_moment _ measurable_poissonTotal.ennreal_toReal |
| (ae_of_all _ fun _ => ENNReal.toReal_nonneg) |
| (ENNReal.toReal_pos (stableLaplaceConstant_pos hb).ne' (stableLaplaceConstant_lt_top hb hb1).ne) |
| hr hrb (fun _ ht => poissonTotal_real_laplace hb hb1 ht) |
|
|
| lemma poissonTotal_negative_moment {b r : ℝ} (hb : 0 < b) (hb1 : b < 1) (hr : 0 < r) : |
| Integrable (fun ν => ((poissonTotal ν).toReal)⁻¹ ^ r) (poissonLaw (powerIntensity b)) := |
| stable_negative_moment _ measurable_poissonTotal.ennreal_toReal |
| (poissonTotal_real_pos hb hb1) |
| (ENNReal.toReal_pos (stableLaplaceConstant_pos hb).ne' (stableLaplaceConstant_lt_top hb hb1).ne) |
| hb hr (fun _ ht => poissonTotal_real_laplace hb hb1 ht) |
|
|
| theorem poissonTotal_log_square {b : ℝ} (hb : 0 < b) (hb1 : b < 1) : |
| Integrable (fun ν => (Real.log (poissonTotal ν).toReal)^2) (poissonLaw (powerIntensity b)) := |
| integrable_log_sq_of_moments _ measurable_poissonTotal.ennreal_toReal |
| (poissonTotal_real_pos hb hb1) (show 0 < b/2 by linarith) |
| (poissonTotal_positive_moment hb hb1 (by linarith) (by linarith)) |
| (poissonTotal_negative_moment hb hb1 (by linarith)) |
|
|
| end IsingPerceptron |
|
|
| end |
|
|
| end OAI |
|
|
