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