| import Mathlib |
|
|
| namespace OAI |
|
|
| /-! Poisson Cloud. -/ |
|
|
| noncomputable section |
|
|
|
|
|
|
| |
|
|
| |
|
|
| |
|
|
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped BigOperators Topology ENNReal NNReal BoundedContinuousFunction |
|
|
| |
| namespace IsingPerceptron |
|
|
| lemma poisson_probability_generating (r : ℝ≥0) (q : ℝ) : |
| (∫ n : ℕ, q ^ n ∂poissonMeasure r) = Real.exp ((r : ℝ) * (q - 1)) := by |
| rw [integral_poissonMeasure] |
| simp only [smul_eq_mul] |
| calc |
| (∑' n : ℕ, (Real.exp (-(r : ℝ)) * (r : ℝ)^n / (n.factorial : ℝ)) * q^n) = |
| Real.exp (-(r : ℝ)) * ∑' n : ℕ, ((r : ℝ)*q)^n / (n.factorial : ℝ) := by |
| rw [← tsum_mul_left] |
| congr 1 |
| ext n |
| rw [mul_pow] |
| ring |
| _ = Real.exp (-(r : ℝ)) * Real.exp ((r : ℝ)*q) := by |
| rw [(NormedSpace.expSeries_div_hasSum_exp ((r : ℝ)*q)).tsum_eq, |
| ← Real.exp_eq_exp_ℝ] |
| _ = Real.exp ((r : ℝ)*(q-1)) := by rw [← Real.exp_add]; congr 1; ring |
|
|
| variable {E : Type*} [MeasurableSpace E] |
|
|
| def finitePoissonCloud (r : ℝ≥0) (μ : Measure E) : Measure (ℕ × (ℕ → E)) := |
| (poissonMeasure r).prod (Measure.infinitePi (fun _ : ℕ => μ)) |
|
|
| instance finitePoissonCloud_probability (r : ℝ≥0) (μ : Measure E) [IsProbabilityMeasure μ] : |
| IsProbabilityMeasure (finitePoissonCloud r μ) := by |
| unfold finitePoissonCloud |
| infer_instance |
|
|
| def cloudSum (ψ : E → ℝ) (p : ℕ × (ℕ → E)) : ℝ := |
| ∑ i : Fin p.1, ψ (p.2 i) |
|
|
| lemma measurable_cloudSum {ψ : E → ℝ} (hψ : Measurable ψ) : |
| Measurable (cloudSum ψ) := by |
| apply measurable_from_prod_countable_right |
| intro n |
| change Measurable (fun y : ℕ → E => ∑ i : Fin n, ψ (y i)) |
| exact Finset.measurable_sum (Finset.univ : Finset (Fin n)) |
| (fun i _ => hψ.comp (measurable_pi_apply (i : ℕ))) |
|
|
| lemma iid_finite_laplace (μ : Measure E) [IsProbabilityMeasure μ] |
| {ψ : E → ℝ} (hψ : Measurable ψ) (n : ℕ) : |
| (∫ ω : ℕ → E, Real.exp (-(∑ i : Fin n, ψ (ω i))) |
| ∂Measure.infinitePi (fun _ : ℕ => μ)) = |
| (∫ x, Real.exp (-ψ x) ∂μ)^n := by |
| let X : ℕ → (ℕ → E) → ℝ := fun i ω => Real.exp (-ψ (ω i)) |
| have hind : iIndepFun X (Measure.infinitePi (fun _ : ℕ => μ)) := |
| iIndepFun_infinitePi (fun _ => hψ.neg.exp) |
| have hind' : iIndepFun (fun i : Fin n => X i) (Measure.infinitePi (fun _ : ℕ => μ)) := |
| hind.precomp Fin.val_injective |
| have hm (i : Fin n) : AEStronglyMeasurable (X i) |
| (Measure.infinitePi (fun _ : ℕ => μ)) := |
| ((hψ.neg.exp).comp (measurable_pi_apply (i : ℕ))).aestronglyMeasurable |
| have he i : (∫ ω, X i ω ∂Measure.infinitePi (fun _ : ℕ => μ)) = |
| ∫ x, Real.exp (-ψ x) ∂μ := by |
| have mp := measurePreserving_eval_infinitePi (fun _ : ℕ => μ) i |
| exact mp.hasLaw.integral_comp hψ.neg.exp.aestronglyMeasurable |
| have hh := hind'.integral_fun_prod_eq_prod_integral hm |
| simpa only [X, ← Real.exp_sum, ← Finset.sum_neg_distrib, he, Finset.prod_const, |
| Finset.card_univ, Fintype.card_fin] using hh |
|
|
| |
| theorem finitePoissonCloud_laplace (r : ℝ≥0) (μ : Measure E) [IsProbabilityMeasure μ] |
| {ψ : E → ℝ} (hψ : Measurable ψ) (hpos : ∀ x, 0 ≤ ψ x) : |
| (∫ p, Real.exp (-cloudSum ψ p) ∂finitePoissonCloud r μ) = |
| Real.exp ((r : ℝ) * ((∫ x, Real.exp (-ψ x) ∂μ) - 1)) := by |
| have hi : Integrable (fun p => Real.exp (-cloudSum ψ p)) (finitePoissonCloud r μ) := by |
| apply Integrable.of_bound (measurable_cloudSum hψ |>.neg.exp.aestronglyMeasurable) 1 |
| apply ae_of_all |
| intro p |
| rw [Real.norm_eq_abs, abs_of_pos (Real.exp_pos _)] |
| apply Real.exp_le_one_iff.mpr |
| exact neg_nonpos.mpr (Finset.sum_nonneg (fun _ _ => hpos _)) |
| rw [finitePoissonCloud, integral_prod _ hi] |
| simp_rw [cloudSum, iid_finite_laplace μ hψ] |
| exact poisson_probability_generating r _ |
|
|
| lemma poisson_complex_generating (r : ℝ≥0) (q : ℂ) : |
| (∫ n : ℕ, q ^ n ∂poissonMeasure r) = Complex.exp ((r : ℂ) * (q - 1)) := by |
| rw [integral_poissonMeasure] |
| simp only [Complex.real_smul, Complex.ofReal_div, Complex.ofReal_mul, |
| Complex.ofReal_pow, Complex.ofReal_natCast, Complex.ofReal_exp, Complex.ofReal_neg] |
| calc |
| (∑' n : ℕ, (Complex.exp (-(r : ℂ)) * (r : ℂ)^n / (n.factorial : ℂ)) * q^n) = |
| Complex.exp (-(r : ℂ)) * ∑' n : ℕ, ((r : ℂ)*q)^n / (n.factorial : ℂ) := by |
| rw [← tsum_mul_left] |
| congr 1 |
| ext n |
| rw [mul_pow] |
| ring |
| _ = Complex.exp (-(r : ℂ)) * Complex.exp ((r : ℂ)*q) := by |
| rw [(NormedSpace.expSeries_div_hasSum_exp ((r : ℂ)*q)).tsum_eq, |
| ← Complex.exp_eq_exp_ℂ] |
| _ = Complex.exp ((r : ℂ)*(q-1)) := by rw [← Complex.exp_add]; congr 1; ring |
|
|
| lemma iid_finite_fourier (μ : Measure E) [IsProbabilityMeasure μ] |
| {ψ : E → ℝ} (hψ : Measurable ψ) (n : ℕ) : |
| (∫ ω : ℕ → E, Complex.exp ((∑ i : Fin n, ψ (ω i)) * Complex.I) |
| ∂Measure.infinitePi (fun _ : ℕ => μ)) = |
| (∫ x, Complex.exp (ψ x * Complex.I) ∂μ)^n := by |
| let X : ℕ → (ℕ → E) → ℂ := fun i ω => Complex.exp (ψ (ω i) * Complex.I) |
| have hmψ : Measurable (fun x => Complex.exp (ψ x * Complex.I)) := by fun_prop |
| have hind : iIndepFun X (Measure.infinitePi (fun _ : ℕ => μ)) := |
| iIndepFun_infinitePi (fun _ => hmψ) |
| have hind' : iIndepFun (fun i : Fin n => X i) (Measure.infinitePi (fun _ : ℕ => μ)) := |
| hind.precomp Fin.val_injective |
| have hm (i : Fin n) : AEStronglyMeasurable (X i) |
| (Measure.infinitePi (fun _ : ℕ => μ)) := |
| (hmψ.comp (measurable_pi_apply (i : ℕ))).aestronglyMeasurable |
| have he i : (∫ ω, X i ω ∂Measure.infinitePi (fun _ : ℕ => μ)) = |
| ∫ x, Complex.exp (ψ x * Complex.I) ∂μ := by |
| exact (measurePreserving_eval_infinitePi (fun _ : ℕ => μ) i).hasLaw.integral_comp |
| hmψ.aestronglyMeasurable |
| have hh := hind'.integral_fun_prod_eq_prod_integral hm |
| simpa only [X, ← Complex.exp_sum, ← Finset.sum_mul, ← Complex.ofReal_sum, he, |
| Finset.prod_const, Finset.card_univ, Fintype.card_fin] using hh |
|
|
| |
| theorem finitePoissonCloud_fourier (r : ℝ≥0) (μ : Measure E) [IsProbabilityMeasure μ] |
| {ψ : E → ℝ} (hψ : Measurable ψ) : |
| (∫ p, Complex.exp (cloudSum ψ p * Complex.I) ∂finitePoissonCloud r μ) = |
| Complex.exp ((r : ℂ) * ((∫ x, Complex.exp (ψ x * Complex.I) ∂μ) - 1)) := by |
| have hi : Integrable (fun p => Complex.exp (cloudSum ψ p * Complex.I)) |
| (finitePoissonCloud r μ) := by |
| apply Integrable.of_bound |
| ((((measurable_cloudSum hψ).complex_ofReal).mul_const Complex.I).cexp.aestronglyMeasurable) 1 |
| exact ae_of_all _ (fun p => (Complex.norm_exp_ofReal_mul_I _).le) |
| rw [finitePoissonCloud, integral_prod _ hi] |
| simp_rw [cloudSum, iid_finite_fourier μ hψ] |
| exact poisson_complex_generating r _ |
|
|
| def enegExp (x : ℝ≥0∞) : ℝ≥0∞ := EReal.exp (-(x : EReal)) |
| def negExp (x : ℝ≥0∞) : ℝ := (enegExp x).toReal |
|
|
| lemma enegExp_le_one (x : ℝ≥0∞) : enegExp x ≤ 1 := by |
| exact EReal.exp_le_one_iff.mpr (EReal.neg_le_zero.mpr (EReal.coe_ennreal_nonneg x)) |
| lemma enegExp_ne_top (x : ℝ≥0∞) : enegExp x ≠ ∞ := |
| ne_top_of_le_ne_top ENNReal.one_ne_top (enegExp_le_one x) |
| lemma continuous_enegExp : Continuous enegExp := |
| ENNReal.continuous_exp.comp continuous_coe_ennreal_ereal.neg |
| lemma continuous_negExp : Continuous negExp := |
| continuous_iff_continuousAt.mpr fun x => |
| (ENNReal.continuousAt_toReal (enegExp_ne_top x)).comp continuous_enegExp.continuousAt |
| lemma negExp_nonneg (x : ℝ≥0∞) : 0 ≤ negExp x := ENNReal.toReal_nonneg |
| lemma negExp_le_one (x : ℝ≥0∞) : negExp x ≤ 1 := by |
| exact (ENNReal.toReal_le_toReal (enegExp_ne_top x) ENNReal.one_ne_top).mpr |
| (enegExp_le_one x) |
| lemma negExp_injective : Function.Injective negExp := by |
| intro x y h |
| apply EReal.coe_ennreal_injective |
| apply neg_injective |
| apply EReal.exp_strictMono.injective |
| exact (ENNReal.toReal_eq_toReal_iff' (enegExp_ne_top x) (enegExp_ne_top y)).mp h |
| @[simp] lemma enegExp_zero : enegExp 0 = 1 := by simp [enegExp] |
| @[simp] lemma enegExp_top : enegExp ∞ = 0 := by simp [enegExp] |
| @[simp] lemma negExp_zero : negExp 0 = 1 := by simp [negExp] |
| @[simp] lemma negExp_top : negExp ∞ = 0 := by simp [negExp] |
| lemma negExp_ofReal {x : ℝ} (hx : 0 ≤ x) : |
| negExp (ENNReal.ofReal x) = Real.exp (-x) := by |
| simp [negExp, enegExp, EReal.coe_ennreal_ofReal, max_eq_left hx, |
| ← EReal.coe_neg, Real.exp_nonneg] |
| lemma enegExp_add (x y : ℝ≥0∞) : enegExp (x+y) = enegExp x * enegExp y := by |
| by_cases hx : x = ∞ |
| · simp [hx] |
| by_cases hy : y = ∞ |
| · simp [hy] |
| rw [← ENNReal.ofReal_toReal hx, ← ENNReal.ofReal_toReal hy] |
| rw [← ENNReal.ofReal_add ENNReal.toReal_nonneg ENNReal.toReal_nonneg] |
| simp only [enegExp, EReal.coe_ennreal_ofReal] |
| rw [max_eq_left (by positivity), max_eq_left (by positivity), max_eq_left (by positivity)] |
| rw [← EReal.coe_neg, ← EReal.coe_neg, ← EReal.coe_neg, EReal.exp_coe, |
| EReal.exp_coe, EReal.exp_coe, neg_add, Real.exp_add, |
| ENNReal.ofReal_mul (Real.exp_nonneg _)] |
| lemma negExp_add (x y : ℝ≥0∞) : negExp (x+y) = negExp x * negExp y := by |
| simp only [negExp, enegExp_add, ENNReal.toReal_mul] |
| lemma negExp_sum {ι : Type*} (s : Finset ι) (f : ι → ℝ≥0∞) : |
| negExp (∑ i ∈ s, f i) = ∏ i ∈ s, negExp (f i) := by |
| classical |
| induction s using Finset.induction_on with |
| | empty => simp |
| | @insert a s ha ih => simp [ha, negExp_add, ih] |
| lemma negExp_nat_mul (n : ℕ) (x : ℝ≥0∞) : negExp (n*x) = negExp x ^ n := by |
| induction n with |
| | zero => simp |
| | succ n ih => rw [Nat.cast_add, Nat.cast_one, add_mul, one_mul, negExp_add, ih, pow_succ] |
|
|
| |
| def finiteCloudMeasure (p : ℕ × (ℕ → E)) : Measure E := |
| ∑ i : Fin p.1, Measure.dirac (p.2 i) |
|
|
| lemma measurable_finiteCloudMeasure : Measurable (finiteCloudMeasure (E := E)) := by |
| apply measurable_from_prod_countable_right |
| intro n |
| change Measurable (fun ω : ℕ → E => ∑ i : Fin n, Measure.dirac (ω i)) |
| exact Finset.measurable_sum _ (fun i _ => Measure.measurable_dirac.comp |
| (measurable_pi_apply (i : ℕ))) |
|
|
| lemma finiteCloudMeasure_lintegral (p : ℕ × (ℕ → E)) {ψ : E → ℝ≥0∞} |
| (hψ : Measurable ψ) : (∫⁻ x, ψ x ∂finiteCloudMeasure p) = ∑ i : Fin p.1, ψ (p.2 i) := by |
| simp [finiteCloudMeasure, lintegral_finsetSum_measure, lintegral_dirac' _ hψ] |
|
|
| variable [Nonempty E] |
|
|
| |
| def finitePoissonLaw (μ : FiniteMeasure E) : Measure (Measure E) := |
| (finitePoissonCloud μ.mass (μ.normalize : Measure E)).map finiteCloudMeasure |
|
|
| instance finitePoissonLaw_probability (μ : FiniteMeasure E) : |
| IsProbabilityMeasure (finitePoissonLaw μ) := by |
| unfold finitePoissonLaw |
| infer_instance |
|
|
| lemma finiteMeasure_mass_normalize (μ : FiniteMeasure E) : |
| (μ : Measure E) = (μ.mass : ℝ≥0∞) • (μ.normalize : Measure E) := by |
| ext s hs |
| simpa using congrArg (fun m : FiniteMeasure E => (m : Measure E) s) |
| μ.self_eq_mass_smul_normalize |
|
|
| lemma finitePoissonLaw_laplace (μ : FiniteMeasure E) {ψ : E → ℝ} |
| (hψ : Measurable ψ) (hpos : ∀ x, 0 ≤ ψ x) : |
| (∫ ν, negExp (∫⁻ x, ENNReal.ofReal (ψ x) ∂ν) ∂finitePoissonLaw μ) = |
| negExp (∫⁻ x, ENNReal.ofReal (1-Real.exp (-ψ x)) ∂(μ : Measure E)) := by |
| have hcost : ∀ x, 0 ≤ 1-Real.exp (-ψ x) := fun x => |
| sub_nonneg.mpr (Real.exp_le_one_iff.mpr (neg_nonpos.mpr (hpos x))) |
| have hi : Integrable (fun x => Real.exp (-ψ x)) (μ.normalize : Measure E) := by |
| apply Integrable.of_bound hψ.neg.exp.aestronglyMeasurable 1 |
| exact ae_of_all _ fun x => by |
| rw [Real.norm_eq_abs, abs_of_pos (Real.exp_pos _)] |
| exact Real.exp_le_one_iff.mpr (neg_nonpos.mpr (hpos x)) |
| have hicost : Integrable (fun x => 1-Real.exp (-ψ x)) (μ.normalize : Measure E) := |
| (integrable_const 1).sub hi |
| have hmeas : Measurable (fun ν : Measure E => negExp (∫⁻ x, ENNReal.ofReal (ψ x) ∂ν)) := |
| continuous_negExp.measurable.comp (Measure.measurable_lintegral hψ.ennreal_ofReal) |
| rw [finitePoissonLaw, integral_map measurable_finiteCloudMeasure.aemeasurable |
| hmeas.aestronglyMeasurable] |
| have hs (p : ℕ × (ℕ → E)) : |
| negExp (∫⁻ x, ENNReal.ofReal (ψ x) ∂finiteCloudMeasure p) = |
| Real.exp (-cloudSum ψ p) := by |
| rw [finiteCloudMeasure_lintegral p hψ.ennreal_ofReal, |
| ← ENNReal.ofReal_sum_of_nonneg (s := Finset.univ) |
| (fun (i : Fin p.1) _ => hpos (p.2 i)), negExp_ofReal] |
| · rfl |
| · exact Finset.sum_nonneg (fun i _ => hpos (p.2 i)) |
| simp_rw [hs] |
| rw [finitePoissonCloud_laplace μ.mass _ hψ hpos] |
| rw [finiteMeasure_mass_normalize μ, lintegral_smul_measure] |
| rw [← ofReal_integral_eq_lintegral_ofReal hicost (ae_of_all _ hcost)] |
| rw [smul_eq_mul, ← ENNReal.ofReal_coe_nnreal, ← ENNReal.ofReal_mul μ.mass.coe_nonneg, |
| negExp_ofReal (mul_nonneg μ.mass.coe_nonneg (integral_nonneg hcost))] |
| rw [integral_sub (integrable_const 1) hi, integral_const] |
| simp only [Measure.real, measure_univ, ENNReal.toReal_one, smul_eq_mul, one_mul] |
| congr 1 |
| ring |
|
|
| |
| def poissonComponentLaw (μ : Measure E) [SFinite μ] (n : ℕ) : Measure (Measure E) := |
| finitePoissonLaw ⟨sfiniteSeq μ n, inferInstance⟩ |
|
|
| instance poissonComponentLaw_probability (μ : Measure E) [SFinite μ] (n : ℕ) : |
| IsProbabilityMeasure (poissonComponentLaw μ n) := by |
| exact finitePoissonLaw_probability ⟨sfiniteSeq μ n, inferInstance⟩ |
|
|
| def poissonProductLaw (μ : Measure E) [SFinite μ] : Measure (ℕ → Measure E) := |
| Measure.infinitePi (poissonComponentLaw μ) |
|
|
| instance poissonProductLaw_probability (μ : Measure E) [SFinite μ] : |
| IsProbabilityMeasure (poissonProductLaw μ) := by unfold poissonProductLaw; infer_instance |
|
|
| omit [Nonempty E] in |
| lemma measurable_measureSum : Measurable (Measure.sum : (ℕ → Measure E) → Measure E) := by |
| apply Measure.measurable_of_measurable_coe |
| intro s hs |
| simp only [Measure.sum_apply _ hs] |
| exact Measurable.tsum fun n => (Measure.measurable_coe hs).comp (measurable_pi_apply n) |
|
|
| |
| def poissonLaw (μ : Measure E) [SFinite μ] : Measure (Measure E) := |
| (poissonProductLaw μ).map Measure.sum |
|
|
| instance poissonLaw_probability (μ : Measure E) [SFinite μ] : IsProbabilityMeasure (poissonLaw μ) := by |
| unfold poissonLaw |
| infer_instance |
|
|
| omit [Nonempty E] in |
| lemma laplace_partial_tendsto (P : Measure (ℕ → Measure E)) [IsFiniteMeasure P] |
| {a : Measure E → ℝ≥0∞} (ha : Measurable a) : |
| Tendsto (fun n => ∫ ω, negExp (∑ i : Fin n, a (ω i)) ∂P) |
| atTop (𝓝 (∫ ω, negExp (∑' i, a (ω i)) ∂P)) := by |
| apply tendsto_integral_of_dominated_convergence (fun _ => 1) |
| · intro n |
| have hm : Measurable (fun ω : ℕ → Measure E => ∑ i : Fin n, a (ω i)) := |
| Finset.measurable_sum (Finset.univ : Finset (Fin n)) |
| (fun i _ => ha.comp (measurable_pi_apply (i : ℕ))) |
| exact (continuous_negExp.measurable.comp hm).aestronglyMeasurable |
| · exact integrable_const 1 |
| · intro n |
| exact ae_of_all _ fun ω => by |
| rw [Real.norm_eq_abs, abs_of_nonneg (negExp_nonneg _)] |
| exact negExp_le_one _ |
| · exact ae_of_all _ fun ω => by |
| simp_rw [Fin.sum_univ_eq_sum_range (fun i => a (ω i))] |
| exact continuous_negExp.continuousAt.tendsto.comp (ENNReal.tendsto_nat_tsum _) |
|
|
| lemma poissonProductLaw_laplace_partial (μ : Measure E) [SFinite μ] {ψ : E → ℝ} |
| (hψ : Measurable ψ) (hpos : ∀ x, 0 ≤ ψ x) (n : ℕ) : |
| (∫ ω, negExp (∑ i : Fin n, ∫⁻ x, ENNReal.ofReal (ψ x) ∂ω i) ∂poissonProductLaw μ) = |
| negExp (∑ i : Fin n, ∫⁻ x, ENNReal.ofReal (1-Real.exp (-ψ x)) ∂sfiniteSeq μ i) := by |
| let a : Measure E → ℝ≥0∞ := fun ν => ∫⁻ x, ENNReal.ofReal (ψ x) ∂ν |
| let c : E → ℝ≥0∞ := fun x => ENNReal.ofReal (1-Real.exp (-ψ x)) |
| have ha : Measurable a := Measure.measurable_lintegral hψ.ennreal_ofReal |
| have heval : Measurable (fun ν => negExp (a ν)) := continuous_negExp.measurable.comp ha |
| have hind : iIndepFun (fun i (ω : ℕ → Measure E) => negExp (a (ω i))) (poissonProductLaw μ) := |
| iIndepFun_infinitePi (fun _ => heval) |
| have hh := (hind.precomp Fin.val_injective).integral_fun_prod_eq_prod_integral |
| (fun i : Fin n => (heval.comp (measurable_pi_apply (i : ℕ))).aestronglyMeasurable) |
| have hei (i : ℕ) : |
| (∫ ω, negExp (a (ω i)) ∂poissonProductLaw μ) = |
| negExp (∫⁻ x, c x ∂sfiniteSeq μ i) := by |
| calc |
| _ = ∫ ν, negExp (a ν) ∂poissonComponentLaw μ i := |
| (measurePreserving_eval_infinitePi (poissonComponentLaw μ) i).hasLaw.integral_comp |
| heval.aestronglyMeasurable |
| _ = _ := finitePoissonLaw_laplace ⟨sfiniteSeq μ i, inferInstance⟩ hψ hpos |
| simpa only [negExp_sum, hei] using hh |
|
|
| |
|
|
| theorem poissonLaw_laplace (μ : Measure E) [SFinite μ] {ψ : E → ℝ} |
| (hψ : Measurable ψ) (hpos : ∀ x, 0 ≤ ψ x) : |
| (∫ ν, negExp (∫⁻ x, ENNReal.ofReal (ψ x) ∂ν) ∂poissonLaw μ) = |
| negExp (∫⁻ x, ENNReal.ofReal (1-Real.exp (-ψ x)) ∂μ) := by |
| let a : Measure E → ℝ≥0∞ := fun ν => ∫⁻ x, ENNReal.ofReal (ψ x) ∂ν |
| let c : E → ℝ≥0∞ := fun x => ENNReal.ofReal (1-Real.exp (-ψ x)) |
| have ha : Measurable a := Measure.measurable_lintegral hψ.ennreal_ofReal |
| have heval : Measurable (fun ν => negExp (a ν)) := continuous_negExp.measurable.comp ha |
| have hlim := laplace_partial_tendsto (poissonProductLaw μ) ha |
| have hr : Tendsto (fun n => negExp (∑ i : Fin n, ∫⁻ x, c x ∂sfiniteSeq μ i)) |
| atTop (𝓝 (negExp (∫⁻ x, c x ∂μ))) := by |
| have hsum : (∑' i, ∫⁻ x, c x ∂sfiniteSeq μ i) = ∫⁻ x, c x ∂μ := by |
| rw [← lintegral_sum_measure, sum_sfiniteSeq] |
| simp_rw [Fin.sum_univ_eq_sum_range (fun i => ∫⁻ x, c x ∂sfiniteSeq μ i)] |
| rw [← hsum] |
| exact continuous_negExp.continuousAt.tendsto.comp (ENNReal.tendsto_nat_tsum _) |
| rw [poissonLaw, integral_map measurable_measureSum.aemeasurable |
| heval.aestronglyMeasurable] |
| change (∫ ω, negExp (∫⁻ x, ENNReal.ofReal (ψ x) ∂Measure.sum ω) ∂poissonProductLaw μ) = _ |
| simp_rw [lintegral_sum_measure] |
| exact tendsto_nhds_unique (by |
| simpa only [a, poissonProductLaw_laplace_partial μ hψ hpos] using hlim) hr |
|
|
| |
| def negExpBCF : ℝ≥0∞ →ᵇ ℝ := |
| BoundedContinuousFunction.ofNormedAddCommGroup negExp continuous_negExp 1 |
| (fun x => by rw [Real.norm_eq_abs, abs_of_nonneg (negExp_nonneg x)]; exact negExp_le_one x) |
|
|
| lemma laplace_finite_coordinates_unique {ι : Type*} [Fintype ι] |
| (P Q : Measure (ι → ℝ≥0∞)) [IsFiniteMeasure P] [IsFiniteMeasure Q] |
| (h : ∀ k : ι → ℕ, |
| (∫ x, negExp (∑ i, (k i : ℝ≥0∞) * x i) ∂P) = |
| ∫ x, negExp (∑ i, (k i : ℝ≥0∞) * x i) ∂Q) : P = Q := by |
| classical |
| let g : ι → ((ι → ℝ≥0∞) →ᵇ ℝ) := fun i => |
| negExpBCF.compContinuous ⟨fun x => x i, continuous_apply i⟩ |
| let ev : MvPolynomial ι ℝ →ₐ[ℝ] ((ι → ℝ≥0∞) →ᵇ ℝ) := MvPolynomial.aeval g |
| let A : StarSubalgebra ℝ ((ι → ℝ≥0∞) →ᵇ ℝ) := |
| { ev.range with |
| star_mem' := by |
| intro f hf |
| have hs : star f = f := by ext x; simp |
| rw [hs] |
| exact hf } |
| have hap (i : ι) (x : ι → ℝ≥0∞) : g i x = negExp (x i) := rfl |
| have hsep : (A.map (BoundedContinuousFunction.toContinuousMapStarₐ ℝ)).SeparatesPoints := by |
| intro x y hxy |
| obtain ⟨i, hi⟩ : ∃ i, x i ≠ y i := by contrapose! hxy; exact funext hxy |
| refine ⟨g i, ?_, ?_⟩ |
| · refine ⟨(g i).toContinuousMap, ?_, rfl⟩ |
| exact ⟨g i, ⟨MvPolynomial.X i, by simp [ev]⟩, rfl⟩ |
| · simpa only [hap] using |
| (fun h => hi (negExp_injective h)) |
| apply ext_of_forall_mem_subalgebra_integral_eq_of_polish hsep |
| intro f hf |
| obtain ⟨p, rfl⟩ := hf |
| induction p using MvPolynomial.induction_on' with |
| | add p q hp hq => |
| simpa only [map_add, BoundedContinuousFunction.coe_add, Pi.add_apply, |
| integral_add (BoundedContinuousFunction.integrable _ _) (BoundedContinuousFunction.integrable _ _)] |
| using congrArg₂ (· + ·) hp hq |
| | monomial k r => |
| have hev (x : ι → ℝ≥0∞) : ev (MvPolynomial.monomial k r) x = |
| r * negExp (∑ i, (k i : ℝ≥0∞) * x i) := by |
| simp only [ev, MvPolynomial.aeval_monomial] |
| rw [negExp_sum] |
| simp only [negExp_nat_mul] |
| simp [Finsupp.prod_fintype, hap] |
| change (∫ x, ev (MvPolynomial.monomial k r) x ∂P) = |
| ∫ x, ev (MvPolynomial.monomial k r) x ∂Q |
| simp only [hev, integral_const_mul] |
| exact congrArg (r * ·) (h fun i => k i) |
|
|
| lemma measure_eq_of_map_eq_comap {E F : Type*} [mE : MeasurableSpace E] |
| [mF : MeasurableSpace F] {f : E → F} |
| (hf : mE = mF.comap f) {P Q : Measure E} (h : P.map f = Q.map f) : P = Q := by |
| have hfm : Measurable f := measurable_iff_comap_le.mpr hf.ge |
| ext s hs |
| rw [hf] at hs |
| obtain ⟨t, ht, rfl⟩ := MeasurableSpace.measurableSet_comap.mp hs |
| exact (Measure.map_apply hfm ht).symm.trans ((congrArg (fun μ : Measure F => μ t) h).trans |
| (Measure.map_apply hfm ht)) |
|
|
| def measureCoordinates (ν : Measure E) (s : {s : Set E // MeasurableSet s}) : ℝ≥0∞ := ν s.1 |
|
|
| omit [Nonempty E] in |
| lemma measurable_measureCoordinates : Measurable (measureCoordinates (E := E)) := |
| Measurable.of_eval fun coordinate => Measure.measurable_coe coordinate.2 |
|
|
| omit [Nonempty E] in |
| lemma measureSpace_eq_comap_coordinates : |
| (inferInstance : MeasurableSpace (Measure E)) = |
| MeasurableSpace.comap measureCoordinates (inferInstance : MeasurableSpace |
| ({s : Set E // MeasurableSet s} → ℝ≥0∞)) := by |
| apply le_antisymm |
| · let m := MeasurableSpace.comap (measureCoordinates (E := E)) inferInstance |
| have hc : @Measurable (Measure E) _ m _ measureCoordinates := |
| measurable_iff_comap_le.mpr le_rfl |
| have hi : @Measurable (Measure E) (Measure E) m Measure.instMeasurableSpace id := by |
| apply @Measure.measurable_of_measurable_coe E (Measure E) _ m id |
| intro s hs |
| change @Measurable (Measure E) ℝ≥0∞ m _ |
| (fun ν => measureCoordinates ν ⟨s, hs⟩) |
| exact (measurable_pi_apply ⟨s, hs⟩).comp hc |
| simpa only [MeasurableSpace.comap_id] using hi.comap_le |
| · exact measurable_measureCoordinates.comap_le |
|
|
| omit [Nonempty E] in |
| |
| theorem randomMeasure_laplace_unique (P Q : Measure (Measure E)) |
| [IsFiniteMeasure P] [IsFiniteMeasure Q] |
| (h : ∀ ψ : E → ℝ, Measurable ψ → (∀ x, 0 ≤ ψ x) → |
| (∫ ν, negExp (∫⁻ x, ENNReal.ofReal (ψ x) ∂ν) ∂P) = |
| ∫ ν, negExp (∫⁻ x, ENNReal.ofReal (ψ x) ∂ν) ∂Q) : P = Q := by |
| classical |
| apply measure_eq_of_map_eq_comap measureSpace_eq_comap_coordinates |
| apply IsProjectiveLimit.unique (P := fun I => |
| (P.map measureCoordinates).map I.restrict) (fun _ => rfl) |
| intro I |
| change (Q.map measureCoordinates).map I.restrict = (P.map measureCoordinates).map I.restrict |
| rw [Measure.map_map I.measurable_restrict |
| measurable_measureCoordinates, |
| Measure.map_map I.measurable_restrict |
| measurable_measureCoordinates] |
| let e : Measure E → (I → ℝ≥0∞) := fun ν i => ν i.1.1 |
| have he : Measurable e := Measurable.of_eval fun coordinate => |
| Measure.measurable_coe coordinate.1.2 |
| change Q.map e = P.map e |
| apply laplace_finite_coordinates_unique |
| intro k |
| let ψ : E → ℝ := fun x => ∑ i : I, i.1.1.indicator (fun _ => (k i : ℝ)) x |
| have hposi (i : I) (x : E) : 0 ≤ i.1.1.indicator (fun _ => (k i : ℝ)) x := by |
| apply indicator_nonneg |
| intro _ _ |
| positivity |
| have hpos (x : E) : 0 ≤ ψ x := Finset.sum_nonneg (fun i _ => hposi i x) |
| have hm : Measurable ψ := Finset.measurable_sum _ (fun i _ => |
| measurable_const.indicator i.1.2) |
| have hoint (ν : Measure E) : |
| (∫⁻ x, ENNReal.ofReal (ψ x) ∂ν) = ∑ i : I, (k i : ℝ≥0∞) * e ν i := by |
| have ho (x : E) : ENNReal.ofReal (ψ x) = |
| ∑ i : I, i.1.1.indicator (fun _ => (k i : ℝ≥0∞)) x := by |
| change ENNReal.ofReal (∑ i : I, i.1.1.indicator (fun _ => (k i : ℝ)) x) = _ |
| rw [ENNReal.ofReal_sum_of_nonneg (fun i _ => hposi i x)] |
| apply Finset.sum_congr rfl |
| intro i _ |
| by_cases hx : x ∈ i.1.1 <;> simp [hx] |
| simp_rw [ho] |
| rw [lintegral_finsetSum _ (fun i _ => measurable_const.indicator i.1.2)] |
| apply Finset.sum_congr rfl |
| intro i _ |
| rw [lintegral_indicator i.1.2, lintegral_const, Measure.restrict_apply_univ] |
| have hcm : Measurable (fun x : I → ℝ≥0∞ => negExp (∑ i, (k i : ℝ≥0∞) * x i)) := |
| continuous_negExp.measurable.comp (Finset.measurable_sum _ |
| (fun i _ => measurable_const.mul (measurable_pi_apply i))) |
| rw [integral_map he.aemeasurable hcm.aestronglyMeasurable, |
| integral_map he.aemeasurable hcm.aestronglyMeasurable] |
| simpa only [hoint] using (h ψ hm hpos).symm |
|
|
| end IsingPerceptron |
|
|
| |
| namespace IsingPerceptron |
|
|
| |
|
|
| theorem poissonLaw_map {E F : Type*} [MeasurableSpace E] [MeasurableSpace F] |
| [Nonempty E] [Nonempty F] (μ : Measure E) [SFinite μ] {T : E → F} |
| (hT : Measurable T) [SFinite (μ.map T)] : |
| (poissonLaw μ).map (fun ν => ν.map T) = poissonLaw (μ.map T) := by |
| apply randomMeasure_laplace_unique |
| intro ψ hψ hpos |
| have hm : Measurable (fun ν : Measure F => negExp (∫⁻ y, ENNReal.ofReal (ψ y) ∂ν)) := |
| continuous_negExp.measurable.comp (Measure.measurable_lintegral hψ.ennreal_ofReal) |
| rw [integral_map (Measure.measurable_map T hT).aemeasurable hm.aestronglyMeasurable] |
| simp_rw [lintegral_map hψ.ennreal_ofReal hT] |
| rw [poissonLaw_laplace μ (ψ := fun x => ψ (T x)) (hψ.comp hT) (fun x => hpos (T x)), |
| poissonLaw_laplace (μ.map T) hψ hpos, |
| lintegral_map (by fun_prop) hT] |
|
|
| end IsingPerceptron |
|
|
| end |
|
|
| end OAI |
|
|
