| import Mathlib |
| import OAI.Probability.Perceptron.Model |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped ENNReal NNReal Topology BigOperators BoundedContinuousFunction |
| open MeasureTheory ProbabilityTheory Set Filter |
| open scoped ENNReal NNReal BigOperators Topology RealInnerProductSpace |
| open scoped Pointwise |
| namespace SphericalPerceptronFreeEnergy |
| open Matrix |
| open scoped RealInnerProductSpace MatrixOrder |
|
|
| abbrev CovarianceMatrix (ι : Type*) [Fintype ι] [DecidableEq ι] := {C : Matrix ι ι ℝ |
|
|
| instance covarianceMatrixMeasurableSpace (ι : Type*) [Fintype ι] [DecidableEq ι] : |
| MeasurableSpace (CovarianceMatrix ι) := |
| inferInstanceAs (MeasurableSpace {C : ι → ι → ℝ |
|
|
| instance covarianceMatrixBorelSpace (ι : Type*) [Fintype ι] [DecidableEq ι] : |
| BorelSpace (CovarianceMatrix ι) := |
| inferInstanceAs (BorelSpace {C : ι → ι → ℝ |
|
|
| def gaussianCovarianceLaw {ι : Type*} [Fintype ι] [DecidableEq ι] (p : EuclideanSpace ℝ ι × CovarianceMatrix ι) : |
| ProbabilityMeasure (EuclideanSpace ℝ ι) := ⟨multivariateGaussian p.1 p.2.val, inferInstance⟩ |
|
|
| lemma gaussianCovarianceLaw_continuous {ι : Type*} [Fintype ι] [DecidableEq ι] : |
| Continuous (gaussianCovarianceLaw (ι := ι)) := by |
| classical |
| have : SequentialSpace (EuclideanSpace ℝ ι × CovarianceMatrix ι) := |
| inferInstanceAs (SequentialSpace (EuclideanSpace ℝ ι × {C : ι → ι → ℝ |
| rw [continuous_iff_seqContinuous] |
| intro p p₀ hp |
| apply ProbabilityMeasure.tendsto_of_tendsto_charFun |
| intro t |
| change Tendsto (fun n => charFun (multivariateGaussian (p n).1 (p n).2.val) t) atTop |
| (𝓝 (charFun (multivariateGaussian p₀.1 p₀.2.val) t)) |
| simp_rw [charFun_multivariateGaussian (p _).2.property,charFun_multivariateGaussian p₀.2.property] |
| have hc : Continuous (fun q : EuclideanSpace ℝ ι × CovarianceMatrix ι => |
| Complex.exp (((inner ℝ t q.1 : ℝ) : ℂ)*Complex.I - |
| ((∑ i, t i * ∑ j, q.2.val i j * t j : ℝ) : ℂ)/2)) := by |
| have he (i j : ι) : Continuous (fun q : EuclideanSpace ℝ ι × CovarianceMatrix ι => q.2.val i j) := |
| (show Continuous (fun q : EuclideanSpace ℝ ι × CovarianceMatrix ι => q.2.val) from |
| continuous_subtype_val.comp continuous_snd).matrix_elem i j |
| have hi : Continuous (fun q : EuclideanSpace ℝ ι × CovarianceMatrix ι => inner ℝ t q.1) := |
| continuous_const.inner continuous_fst |
| exact ((Complex.continuous_ofReal.comp hi).mul continuous_const |>.sub |
| ((Complex.continuous_ofReal.comp (continuous_finsetSum _ fun i _ => continuous_const.mul |
| (continuous_finsetSum _ fun j _ => (he i j).mul continuous_const))).div_const 2)).cexp |
| exact hc.continuousAt.tendsto.comp hp |
|
|
| lemma gaussianCovariance_integral_continuous {ι : Type*} [Fintype ι] [DecidableEq ι] |
| (f : EuclideanSpace ℝ ι →ᵇ ℝ) : |
| Continuous (fun p : EuclideanSpace ℝ ι × CovarianceMatrix ι => |
| ∫ x, f x ∂multivariateGaussian p.1 p.2.val) := |
| (ProbabilityMeasure.continuous_integral_boundedContinuousFunction f).comp gaussianCovarianceLaw_continuous |
|
|
| lemma gaussianCovariance_integral_tendsto {ι : Type*} [Fintype ι] [DecidableEq ι] |
| {m : ℕ → EuclideanSpace ℝ ι} {m₀ : EuclideanSpace ℝ ι} |
| {C : ℕ → CovarianceMatrix ι} {C₀ : CovarianceMatrix ι} |
| (hm : Tendsto m atTop (𝓝 m₀)) (hC : Tendsto C atTop (𝓝 C₀)) |
| (f : EuclideanSpace ℝ ι →ᵇ ℝ) : |
| Tendsto (fun n => ∫ x, f x ∂multivariateGaussian (m n) (C n).val) atTop |
| (𝓝 (∫ x, f x ∂multivariateGaussian m₀ C₀.val)) := |
| (gaussianCovariance_integral_continuous f).continuousAt.tendsto.comp (hm.prodMk_nhds hC) |
|
|
| section GaussianRows |
| variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E] [FiniteDimensional ℝ E] |
| [MeasurableSpace E] [BorelSpace E] {ι : Type*} [Fintype ι] [DecidableEq ι] |
|
|
| def gaussianRows (v : ι → E) : E →L[ℝ] EuclideanSpace ℝ ι := |
| (PiLp.continuousLinearEquiv 2 ℝ (fun _ : ι => ℝ)).symm.toContinuousLinearMap.comp |
| (ContinuousLinearMap.pi fun i => innerSL ℝ (v i)) |
|
|
| omit [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E] [Fintype ι] [DecidableEq ι] in |
| lemma gaussianRows_apply (v : ι → E) (x : E) (i : ι) : |
| gaussianRows v x i = inner ℝ (v i) x := rfl |
|
|
| omit [MeasurableSpace E] [BorelSpace E] in |
| lemma gaussianRows_adjoint_basis (v : ι → E) (i : ι) : |
| (gaussianRows v).adjoint (EuclideanSpace.basisFun ι ℝ i) = v i := by |
| apply ext_inner_left ℝ |
| intro x |
| rw [ContinuousLinearMap.adjoint_inner_right] |
| simp [PiLp.inner_apply, gaussianRows_apply,real_inner_comm] |
|
|
| lemma gaussianRows_map_stdGaussian (v : ι → E) : |
| (stdGaussian E).map (gaussianRows v) = multivariateGaussian 0 (Matrix.gram ℝ v) := by |
| apply IsGaussian.ext |
| · simp only [id_eq] |
| rw [ContinuousLinearMap.integral_id_map IsGaussian.integrable_id] |
| simp only [integral_id_stdGaussian,map_zero,integral_id_multivariateGaussian] |
| rw [← ContinuousLinearMap.toBilinForm_inj] |
| apply LinearMap.BilinForm.ext_basis (EuclideanSpace.basisFun ι ℝ).toBasis |
| intro i j |
| simp only [ContinuousLinearMap.toBilinForm_apply,OrthonormalBasis.coe_toBasis] |
| rw [covarianceBilin_map IsGaussian.memLp_two_id,gaussianRows_adjoint_basis, |
| gaussianRows_adjoint_basis,covarianceBilin_stdGaussian, |
| covarianceBilin_multivariateGaussian (Matrix.posSemidef_gram ℝ v)] |
| simp |
| rfl |
|
|
| end GaussianRows |
|
|
| def gaussianReplicaTest {ι : Type*} [Fintype ι] (f : ℝ →ᵇ ℝ) : EuclideanSpace ℝ ι →ᵇ ℝ := |
| ∏ i, f.compContinuous ⟨fun z => z i, by fun_prop⟩ |
|
|
| lemma gaussianReplicaTest_apply {ι : Type*} [Fintype ι] (f : ℝ →ᵇ ℝ) (z : EuclideanSpace ℝ ι) : |
| gaussianReplicaTest f z = ∏ i, f (z i) := by simp [gaussianReplicaTest] |
|
|
| lemma freshPattern_moment_covariance_integral |
| {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E] [FiniteDimensional ℝ E] |
| [MeasurableSpace E] [BorelSpace E] (μ : Measure E) [IsProbabilityMeasure μ] |
| (f : ℝ →ᵇ ℝ) (n : ℕ) : |
| (∫ g, (∫ x, f (inner ℝ x g) ∂μ)^n ∂stdGaussian E) = |
| ∫ xs : Fin n → E, ∫ z, gaussianReplicaTest f z |
| ∂multivariateGaussian 0 (Matrix.gram ℝ xs) ∂Measure.pi (fun _ => μ) := by |
| classical |
| let F : (E × (Fin n → E)) →ᵇ ℝ := |
| ∏ i, f.compContinuous ⟨fun p => inner ℝ (p.2 i) p.1, by fun_prop⟩ |
| have hF (g : E) (xs : Fin n → E) : F (g,xs) = ∏ i, f (inner ℝ (xs i) g) := by simp [F] |
| calc |
| _ = ∫ g, ∫ xs : Fin n → E, F (g,xs) ∂Measure.pi (fun _ => μ) ∂stdGaussian E := by |
| apply integral_congr_ae |
| filter_upwards [] with g |
| simp only [hF] |
| simpa only [Fintype.card_fin] using |
| (integral_fintype_prod_eq_pow (ι := Fin n) (fun x : E => f (inner ℝ x g)) (μ := μ)).symm |
| _ = ∫ xs : Fin n → E, ∫ g, F (g,xs) ∂stdGaussian E ∂Measure.pi (fun _ => μ) := |
| integral_integral_swap (F.integrable _) |
| _ = _ := by |
| apply integral_congr_ae |
| filter_upwards [] with xs |
| rw [← gaussianRows_map_stdGaussian xs, |
| integral_map (gaussianRows xs).continuous.measurable.aemeasurable |
| (gaussianReplicaTest f).continuous.aestronglyMeasurable] |
| apply integral_congr_ae |
| filter_upwards [] with g |
| simp only [hF,gaussianReplicaTest_apply,gaussianRows_apply] |
|
|
| def gramCovariance {ι E : Type*} [Fintype ι] [DecidableEq ι] |
| [NormedAddCommGroup E] [InnerProductSpace ℝ E] (v : ι → E) : CovarianceMatrix ι := |
| ⟨Matrix.gram ℝ v,Matrix.posSemidef_gram ℝ v⟩ |
|
|
| lemma gramCovariance_continuous {ι E : Type*} [Fintype ι] [DecidableEq ι] |
| [NormedAddCommGroup E] [InnerProductSpace ℝ E] : |
| Continuous (gramCovariance (ι := ι) (E := E)) := by |
| apply Continuous.subtype_mk |
| exact continuous_pi fun i => continuous_pi fun j => |
| (continuous_apply i).inner (continuous_apply j) |
|
|
| def gaussianCovarianceKernel {ι : Type*} [Fintype ι] [DecidableEq ι] |
| (f : EuclideanSpace ℝ ι →ᵇ ℝ) : CovarianceMatrix ι →ᵇ ℝ := |
| BoundedContinuousFunction.mkOfBound |
| ⟨fun C => ∫ z, f z ∂multivariateGaussian 0 C.val, |
| (gaussianCovariance_integral_continuous f).comp (continuous_const.prodMk continuous_id)⟩ |
| (2*‖f‖) (by |
| intro C D |
| calc |
| dist (∫ z, f z ∂multivariateGaussian 0 C.val) (∫ z, f z ∂multivariateGaussian 0 D.val) ≤ |
| ‖∫ z, f z ∂multivariateGaussian 0 C.val‖ + ‖∫ z, f z ∂multivariateGaussian 0 D.val‖ := by rw [dist_eq_norm]; exact norm_sub_le _ _ |
| _ ≤ ‖f‖ + ‖f‖ := add_le_add (f.norm_integral_le_norm _) (f.norm_integral_le_norm _) |
| _ = 2*‖f‖ := by ring) |
|
|
| def gramReplicaLaw {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E] |
| [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E] |
| (μ : Measure E) [IsProbabilityMeasure μ] (n : ℕ) : ProbabilityMeasure (CovarianceMatrix (Fin n)) := |
| ⟨(Measure.pi (fun _ : Fin n => μ)).map gramCovariance, |
| inferInstance⟩ |
|
|
| lemma freshPattern_moment_tendsto_of_gram_laws |
| {E : ℕ → Type*} [∀ N, NormedAddCommGroup (E N)] [∀ N, InnerProductSpace ℝ (E N)] |
| [∀ N, FiniteDimensional ℝ (E N)] [∀ N, MeasurableSpace (E N)] [∀ N, BorelSpace (E N)] |
| (μ : (N : ℕ) → Measure (E N)) [∀ N, IsProbabilityMeasure (μ N)] |
| (f : ℝ →ᵇ ℝ) (n : ℕ) (ν : ProbabilityMeasure (CovarianceMatrix (Fin n))) |
| (h : Tendsto (fun N => gramReplicaLaw (μ N) n) atTop (𝓝 ν)) : |
| Tendsto (fun N => ∫ g, (∫ x, f (inner ℝ x g) ∂μ N)^n ∂stdGaussian (E N)) atTop |
| (𝓝 (∫ C, gaussianCovarianceKernel (gaussianReplicaTest (ι := Fin n) f) C ∂ν)) := by |
| have hh := (ProbabilityMeasure.continuous_integral_boundedContinuousFunction |
| (gaussianCovarianceKernel (gaussianReplicaTest (ι := Fin n) f))).continuousAt.tendsto.comp h |
| convert hh using 1 |
| funext N |
| change (∫ g, (∫ x, f (inner ℝ x g) ∂μ N)^n ∂stdGaussian (E N)) = |
| ∫ C, gaussianCovarianceKernel (gaussianReplicaTest (ι := Fin n) f) C |
| ∂(Measure.pi (fun _ : Fin n => μ N)).map gramCovariance |
| rw [freshPattern_moment_covariance_integral, |
| integral_map gramCovariance_continuous.measurable.aemeasurable |
| (gaussianCovarianceKernel (gaussianReplicaTest (ι := Fin n) f)).continuous.aestronglyMeasurable] |
| rfl |
|
|
| open TopologicalSpace |
|
|
| abbrev CompactOverlap := Set.Icc (-1 : ℝ) 1 |
| abbrev CompactJointOverlap := CompactOverlap × unitInterval |
| abbrev CompactArray (K : Type*) := ℕ → ℕ → K |
| abbrev CompactBlock (K : Type*) (n : ℕ) := Fin n → Fin n → K |
|
|
| def compactBlock {K : Type*} (n : ℕ) (Q : CompactArray K) : CompactBlock K n := |
| fun i j => Q i j |
|
|
| lemma compactBlock_continuous {K : Type*} [TopologicalSpace K] (n : ℕ) : |
| Continuous (compactBlock (K := K) n) := by unfold compactBlock; fun_prop |
|
|
| lemma compact_array_law_subsequence {K : Type*} [TopologicalSpace K] [MeasurableSpace K] |
| [BorelSpace K] [CompactSpace K] [MetrizableSpace K] [SecondCountableTopology K] |
| (μ : ℕ → ProbabilityMeasure (CompactArray K)) : |
| ∃ ν : ProbabilityMeasure (CompactArray K), ∃ s : ℕ → ℕ, |
| StrictMono s ∧ Tendsto (μ ∘ s) atTop (𝓝 ν) := by |
| obtain ⟨ν, -, s, hs, hμ⟩ := isCompact_univ.isSeqCompact (fun n => mem_univ (μ n)) |
| exact ⟨ν,s,hs,hμ⟩ |
|
|
| lemma weak_limit_closed_full {K : Type*} [TopologicalSpace K] [MeasurableSpace K] |
| [BorelSpace K] [HasOuterApproxClosed K] |
| {μ : ℕ → ProbabilityMeasure K} {ν : ProbabilityMeasure K} |
| (hμ : Tendsto μ atTop (𝓝 ν)) {F : Set K} (hF : IsClosed F) |
| (hfull : ∀ n, μ n F = 1) : ν F = 1 := by |
| apply le_antisymm (ProbabilityMeasure.apply_le_one _ _) |
| have h := ProbabilityMeasure.limsup_measure_closed_le_of_tendsto hμ hF |
| have hf (n : ℕ) : (μ n : Measure K) F = 1 := by |
| rw [← ProbabilityMeasure.ennreal_coeFn_eq_coeFn_toMeasure,hfull n,ENNReal.coe_one] |
| simp only [hf,limsup_const] at h |
| rw [← ProbabilityMeasure.ennreal_coeFn_eq_coeFn_toMeasure] at h |
| exact_mod_cast h |
|
|
| def compactGGDefect {K : Type*} [TopologicalSpace K] [MeasurableSpace K] |
| [BorelSpace K] [SecondCountableTopology K] (μ : ProbabilityMeasure (CompactArray K)) (n : ℕ) (i : Fin n) |
| (f : CompactBlock K n →ᵇ ℝ) (g : K →ᵇ ℝ) : ℝ := |
| (n : ℝ)*(∫ Q, f (compactBlock n Q)*g (Q i n) ∂μ) - |
| (∫ Q, f (compactBlock n Q) ∂μ)*(∫ Q : CompactArray K, g (Q 0 1) ∂μ) - |
| ∑ j ∈ Finset.univ.erase i, ∫ Q, f (compactBlock n Q)*g (Q i j) ∂μ |
|
|
| lemma compactGGDefect_continuous {K : Type*} [TopologicalSpace K] [MeasurableSpace K] |
| [BorelSpace K] [SecondCountableTopology K] (n : ℕ) (i : Fin n) |
| (f : CompactBlock K n →ᵇ ℝ) (g : K →ᵇ ℝ) : |
| Continuous (fun μ : ProbabilityMeasure (CompactArray K) => compactGGDefect μ n i f g) := by |
| let f' : CompactArray K →ᵇ ℝ := f.compContinuous ⟨compactBlock n,compactBlock_continuous n⟩ |
| let g' (i j : ℕ) : CompactArray K →ᵇ ℝ := g.compContinuous ⟨fun Q => Q i j,by fun_prop⟩ |
| have hf := ProbabilityMeasure.continuous_integral_boundedContinuousFunction f' |
| have hg (i j : ℕ) := ProbabilityMeasure.continuous_integral_boundedContinuousFunction (g' i j) |
| have hfg (i j : ℕ) := ProbabilityMeasure.continuous_integral_boundedContinuousFunction (f' * g' i j) |
| exact (continuous_const.mul (hfg i n) |>.sub (hf.mul (hg 0 1))).sub |
| (continuous_finsetSum _ fun j _ => hfg i j) |
|
|
| lemma compactGGDefect_limit {K : Type*} [TopologicalSpace K] [MeasurableSpace K] |
| [BorelSpace K] [SecondCountableTopology K] {μ : ℕ → ProbabilityMeasure (CompactArray K)} |
| {ν : ProbabilityMeasure (CompactArray K)} (hμ : Tendsto μ atTop (𝓝 ν)) |
| (n : ℕ) (i : Fin n) (f : CompactBlock K n →ᵇ ℝ) (g : K →ᵇ ℝ) |
| (hdef : Tendsto (fun k => compactGGDefect (μ k) n i f g) atTop (𝓝 0)) : |
| compactGGDefect ν n i f g = 0 := |
| tendsto_nhds_unique ((compactGGDefect_continuous n i f g).continuousAt.tendsto.comp hμ) hdef |
|
|
| lemma compactGG_joint_law {K : Type*} [TopologicalSpace K] [MeasurableSpace K] |
| [BorelSpace K] [MetrizableSpace K] [SecondCountableTopology K] |
| (μ : ProbabilityMeasure (CompactArray K)) {n : ℕ} (hn : 0 < n) (i : Fin n) |
| (hGG : ∀ (f : CompactBlock K n →ᵇ ℝ) (g : K →ᵇ ℝ), compactGGDefect μ n i f g = 0) : |
| (μ : Measure (CompactArray K)).map (fun Q => (compactBlock n Q, Q i n)) = |
| ((n : ℝ≥0)⁻¹) • |
| (((μ : Measure (CompactArray K)).map (compactBlock n)).prod |
| ((μ : Measure (CompactArray K)).map (fun Q => Q 0 1)) + |
| ∑ j ∈ Finset.univ.erase i, |
| (μ : Measure (CompactArray K)).map (fun Q => (compactBlock n Q, Q i j))) := by |
| classical |
| have hb := (compactBlock_continuous (K := K) n).measurable |
| have he (k l : ℕ) : Measurable (fun Q : CompactArray K => Q k l) := by fun_prop |
| apply Measure.ext_of_integral_mul_boundedContinuousFunction |
| intro f g |
| let F : (CompactBlock K n × K) →ᵇ ℝ := |
| (f.compContinuous ⟨Prod.fst,continuous_fst⟩) * (g.compContinuous ⟨Prod.snd,continuous_snd⟩) |
| have hF : ∀ ρ : Measure (CompactBlock K n × K), IsFiniteMeasure ρ → Integrable F ρ := by |
| intro ρ hρ |
| exact F.integrable ρ |
| change ∫ p, F p ∂_ = ∫ p, F p ∂_ |
| rw [integral_smul_nnreal_measure,integral_add_measure (hF _ inferInstance) (hF _ inferInstance), |
| integral_finsetSum_measure] |
| · simp_rw [integral_map (hb.prodMk (he _ _)).aemeasurable F.continuous.aestronglyMeasurable] |
| simp only [F,BoundedContinuousFunction.mul_apply,BoundedContinuousFunction.compContinuous_apply, |
| ContinuousMap.coe_mk,NNReal.smul_def,NNReal.coe_inv,NNReal.coe_natCast,smul_eq_mul] |
| rw [integral_prod_mul,integral_map hb.aemeasurable f.continuous.aestronglyMeasurable, |
| integral_map (he 0 1).aemeasurable g.continuous.aestronglyMeasurable] |
| have hn' : (n : ℝ) ≠ 0 := by exact_mod_cast hn.ne' |
| have h := hGG f g |
| unfold compactGGDefect at h |
| apply (mul_right_inj' hn').mp |
| rw [←mul_assoc,mul_inv_cancel₀ hn',one_mul] |
| linarith [h] |
| · intro j hj |
| exact hF _ inferInstance |
| |
| open scoped Polynomial |
| |
| lemma integral_continuous_tendsto_of_moments {a b : ℝ} |
| (μ : ℕ → Measure (Icc a b)) (ν : Measure (Icc a b)) |
| [∀ n, IsProbabilityMeasure (μ n)] [IsProbabilityMeasure ν] |
| (h : ∀ k : ℕ, Tendsto (fun n => ∫ x, (x.val)^k ∂μ n) atTop |
| (𝓝 (∫ x, (x.val)^k ∂ν))) (f : C(Icc a b, ℝ)) : |
| Tendsto (fun n => ∫ x, f x ∂μ n) atTop (𝓝 (∫ x, f x ∂ν)) := by |
| have hi (ρ : Measure (Icc a b)) [IsFiniteMeasure ρ] (p : ℝ[X]) : |
| Integrable (fun x : Icc a b => p.eval x.val) ρ := |
| (p.continuous.comp continuous_subtype_val).integrable_of_hasCompactSupport (HasCompactSupport.of_compactSpace _) |
| have hp (p : ℝ[X]) : Tendsto (fun n => ∫ x, p.eval x.val ∂μ n) atTop |
| (𝓝 (∫ x, p.eval x.val ∂ν)) := by |
| induction p using Polynomial.induction_on' with |
| | add p q hp hq => |
| simpa only [Polynomial.eval_add,integral_add (hi _ p) (hi _ q)] using hp.add hq |
| | monomial k c => |
| simpa only [Polynomial.eval_monomial,integral_const_mul] using tendsto_const_nhds.mul (h k) |
| rw [Metric.tendsto_atTop] |
| intro ε hε |
| obtain ⟨p, hpε⟩ := exists_polynomial_near_continuousMap a b f (ε/3) (by positivity) |
| obtain ⟨N, hN⟩ := (Metric.tendsto_atTop.mp (hp p)) (ε/3) (by positivity) |
| refine ⟨N, fun n hn => ?_⟩ |
| have hbnd (ρ : Measure (Icc a b)) [IsProbabilityMeasure ρ] : |
| |(∫ x, p.eval x.val ∂ρ) - ∫ x, f x ∂ρ| < ε/3 := by |
| rw [← integral_sub (hi ρ p) (f.continuous.integrable_of_hasCompactSupport (HasCompactSupport.of_compactSpace _))] |
| · calc |
| |∫ x, p.eval x.val - f x ∂ρ| ≤ ‖p.toContinuousMapOn (Icc a b)-f‖ := by |
| simpa only [Measure.real,measure_univ,ENNReal.toReal_one,mul_one,Real.norm_eq_abs,ContinuousMap.sub_apply,Polynomial.toContinuousMapOn_apply,Polynomial.toContinuousMap_apply] using |
| (norm_integral_le_of_norm_le_const (μ := ρ) |
| (Filter.Eventually.of_forall fun x => ContinuousMap.norm_coe_le_norm |
| (p.toContinuousMapOn (Icc a b)-f) x)) |
| _ < ε/3 := hpε |
| have h₁ := hbnd (μ n) |
| have h₂ := hbnd ν |
| have h₃ := hN n hn |
| rw [Real.dist_eq] at h₃ ⊢ |
| calc |
| |(∫ x, f x ∂μ n) - ∫ x, f x ∂ν| ≤ |
| |(∫ x, f x ∂μ n) - ∫ x, p.eval x.val ∂μ n| + |
| |(∫ x, p.eval x.val ∂μ n) - ∫ x, p.eval x.val ∂ν| + |
| |(∫ x, p.eval x.val ∂ν) - ∫ x, f x ∂ν| := by |
| calc |
| _ ≤ |(∫ x, f x ∂μ n) - ∫ x, p.eval x.val ∂μ n| + |
| |(∫ x, p.eval x.val ∂μ n) - ∫ x, f x ∂ν| := abs_sub_le _ _ _ |
| _ ≤ _ := by |
| linarith [abs_sub_le (∫ x, p.eval x.val ∂μ n) |
| (∫ x, p.eval x.val ∂ν) (∫ x, f x ∂ν)] |
| _ < ε := by rw [abs_sub_comm (∫ x, f x ∂μ n)] ; linarith |
|
|
| lemma trial_integrable (m : Trial) : Integrable m timeLaw := by |
| change Integrable m (volume : Measure Time) |
| apply (integrable_const (1 : ℝ)).mono' m.measurable.aestronglyMeasurable |
| exact Eventually.of_forall fun t => by |
| rw [Real.norm_eq_abs,abs_of_nonneg (m.nonneg t)] |
| exact m.le_one t |
| |
| lemma tailIntegral_mono {m n : Trial} (h : ∀ t, m t ≤ n t) (t : Time) : |
| tailIntegral m t ≤ tailIntegral n t := |
| integral_mono (trial_integrable m).integrableOn (trial_integrable n).integrableOn h |
| |
| lemma entropy_antitone {m n : Trial} (h : ∀ t, m t ≤ n t) : entropy n ≤ entropy m := by |
| apply ENNReal.div_le_div_right |
| apply lintegral_mono |
| intro t |
| exact tsub_le_tsub_right (ENNReal.inv_le_inv.mpr (ENNReal.ofReal_le_ofReal (tailIntegral_mono h t))) _ |
| |
| def upperRoundedTrial (m : Trial) (n : ℕ) : Trial where |
| toFun := fun t => (⌈((n+1 : ℕ) : ℝ)*m t⌉₊ : ℝ) / (n+1 : ℕ) |
| monotone := by |
| intro s t hst |
| apply div_le_div_of_nonneg_right _ (by positivity) |
| exact_mod_cast Nat.ceil_mono (mul_le_mul_of_nonneg_left (m.monotone hst) (by positivity)) |
| measurable := |
| ((measurable_of_countable (fun k : ℕ => (k : ℝ))).comp |
| (Nat.measurable_ceil.comp (measurable_const.mul m.measurable))).div_const _ |
| nonneg := by intro t; positivity |
| le_one := by |
| intro t |
| apply (div_le_one (by positivity)).mpr |
| exact_mod_cast (Nat.ceil_le.mpr (show (((n+1 : ℕ) : ℝ)*m t) ≤ ((n+1 : ℕ) : ℝ) by |
| nlinarith [m.le_one t])) |
| |
| lemma le_upperRoundedTrial (m : Trial) (n : ℕ) (t : Time) : m t ≤ upperRoundedTrial m n t := by |
| apply (le_div_iff₀ (by positivity : (0 : ℝ) < (n+1 : ℕ))).mpr |
| simpa only [mul_comm] using (Nat.le_ceil (((n+1 : ℕ) : ℝ)*m t)) |
| |
| lemma upperRoundedTrial_sub_le (m : Trial) (n : ℕ) (t : Time) : |
| upperRoundedTrial m n t - m t ≤ 1/((n+1 : ℕ) : ℝ) := by |
| have h := Nat.ceil_lt_add_one (show (0 : ℝ) ≤ ((n+1 : ℕ) : ℝ)*m t from mul_nonneg (by positivity) (m.nonneg t)) |
| change (⌈((n+1 : ℕ) : ℝ)*m t⌉₊ : ℝ) / (n+1 : ℕ) - m t ≤ _ |
| apply (le_div_iff₀ (by positivity : (0 : ℝ) < (n+1 : ℕ))).mpr |
| have hn : (((n+1 : ℕ) : ℝ)) ≠ 0 := by positivity |
| field_simp |
| nlinarith |
| |
| lemma upperRoundedTrial_finite_range (m : Trial) (n : ℕ) : |
| (Set.range (upperRoundedTrial m n)).Finite := by |
| apply (Set.finite_Iic (n+1)).image (fun k : ℕ => (k : ℝ)/((n+1 : ℕ) : ℝ)) |>.subset |
| rintro _ ⟨t,rfl⟩ |
| refine ⟨⌈((n+1 : ℕ) : ℝ)*m t⌉₊, ?_, rfl⟩ |
| exact Nat.ceil_le.mpr (by nlinarith [m.le_one t]) |
| |
| def terminalTrial (m : Trial) (r : Time) : Trial where |
| toFun := fun t => if r ≤ t then 1 else m t |
| monotone := by |
| intro s t hst |
| by_cases hs : r ≤ s |
| · simp only [ite_eq_left hs,ite_eq_left (hs.trans hst)] |
| exact le_rfl |
| · by_cases ht : r ≤ t |
| · simpa only [ite_eq_right hs,ite_eq_left ht] using m.le_one s |
| · simpa only [ite_eq_right hs,ite_eq_right ht] using m.monotone hst |
| measurable := Measurable.ite measurableSet_Ici measurable_const m.measurable |
| nonneg := by intro t; split_ifs; norm_num; exact m.nonneg t |
| le_one := by intro t; split_ifs; exact le_rfl; exact m.le_one t |
| |
| end SphericalPerceptronFreeEnergy |
| |
| end |
| |
| end OAI |
| |
