| import Mathlib |
| import OAI.Probability.LogConcave.Sampling.ProbabilityVelocity |
|
|
| namespace OAI |
|
|
| section |
| section |
| noncomputable section |
| open MeasureTheory Filter |
| open scoped ENNReal NNReal Topology |
|
|
| section UpperProof |
| open MeasureTheory ProbabilityTheory Filter |
| open scoped ENNReal NNReal RealInnerProductSpace Topology |
| open Function MeasureTheory Set Filter |
| open scoped Topology NNReal |
|
|
| namespace LogConcaveSampling |
| open MeasureTheory ProbabilityTheory |
| open scoped RealInnerProductSpace |
|
|
| lemma integral_abs_center_le_sqrt {Ω : Type*} [MeasurableSpace Ω] {μ : Measure Ω} |
| [IsProbabilityMeasure μ] {f : Ω → ℝ} (hf : MemLp f 2 μ) : |
| (∫ z, |f z-∫ w,f w ∂μ| ∂μ) ≤ Real.sqrt (Var[f;μ]) := by |
| have hm := (hf.sub (memLp_const (∫ w,f w ∂μ))).norm |
| have hh := integral_mul_sq_le hm (memLp_const (1:ℝ) (μ:=μ)) |
| simp only [Pi.sub_apply,Real.norm_eq_abs,mul_one,one_pow,integral_const, |
| probReal_univ,smul_eq_mul,sq_abs] at hh |
| rw [← variance_eq_integral hf.aemeasurable] at hh |
| exact (Real.le_sqrt (integral_nonneg (fun _ => abs_nonneg _)) (variance_nonneg f μ)).2 hh |
|
|
| lemma poincare_integral_norm_center {d : ℕ} {μ : Measure (Point d)} |
| [IsProbabilityMeasure μ] {β : ℝ} (hβ : 0≤β) (hP : HasPoincare μ β) |
| (hm : Appell.HasMoments μ) : |
| (∫ z, ‖z-∫ w,w ∂μ‖ ∂μ) ≤ (d:ℝ)*Real.sqrt β := by |
| classical |
| let b := EuclideanSpace.basisFun (Fin d) ℝ |
| have hi : Integrable (fun z : Point d => z) μ := |
| (Appell.HasGrowth.linear (ContinuousLinearMap.id ℝ (Point d))).integrable |
| continuous_id.aestronglyMeasurable hm |
| have hei (i : Fin d) : Integrable (fun z => |inner ℝ (b i) (z-∫ w,w ∂μ)|) μ := |
| ((innerSL ℝ (b i)).integrable_comp (hi.sub (integrable_const _))).norm |
| have hv (i : Fin d) : (∫ z, |inner ℝ (b i) (z-∫ w,w ∂μ)| ∂μ) ≤ Real.sqrt β := by |
| have hmi : MemLp (fun z => inner ℝ (b i) z) 2 μ := |
| (Appell.HasGrowth.linear (innerSL ℝ (b i))).memLp (by fun_prop) hm |
| have hp := hP.lipschitz_variance hβ (innerSL ℝ (b i)).contDiff |
| (innerSL ℝ (b i)).lipschitzWith hmi |
| simp only [coe_nnnorm,innerSL_apply_norm,b.norm_eq_one,one_pow,mul_one] at hp |
| have hh := (integral_abs_center_le_sqrt hmi).trans (Real.sqrt_le_sqrt hp) |
| simpa only [inner_sub_right,integral_inner hi] using hh |
| calc |
| _ ≤ ∫ z, ∑ i : Fin d, |inner ℝ (b i) (z-∫ w,w ∂μ)| ∂μ := by |
| apply integral_mono (hi.sub (integrable_const _)).norm (integrable_finsetSum _ (fun i _ => hei i)) |
| intro z |
| change ‖z-∫ w,w ∂μ‖ ≤ _ |
| calc |
| _ = ‖∑ i : Fin d, inner ℝ (b i) (z-∫ w,w ∂μ) • b i‖ := by |
| exact congrArg norm (by simpa only [b.repr_apply_apply] using (b.sum_repr (z-∫ w,w ∂μ)).symm) |
| _ ≤ ∑ i : Fin d, ‖inner ℝ (b i) (z-∫ w,w ∂μ) • b i‖ := norm_sum_le _ _ |
| _ = _ := by simp only [norm_smul,b.norm_eq_one,mul_one,Real.norm_eq_abs] |
| _ = ∑ i : Fin d, ∫ z, |inner ℝ (b i) (z-∫ w,w ∂μ)| ∂μ := integral_finsetSum _ (fun i _ => hei i) |
| _ ≤ ∑ _i : Fin d, Real.sqrt β := Finset.sum_le_sum (fun i _ => hv i) |
| _ = _ := by simp |
|
|
| end LogConcaveSampling |
|
|
| namespace LogConcaveSampling |
| open MeasureTheory |
| open scoped RealInnerProductSpace |
|
|
| lemma norm_integral_sub_map_mean_le {d : ℕ} {E : Type*} [NormedAddCommGroup E] |
| [NormedSpace ℝ E] [CompleteSpace E] {μ : Measure (Point d)} [IsProbabilityMeasure μ] |
| {f : Point d → E} {L : ℝ≥0} (hf : LipschitzWith L f) |
| (hi : Integrable (fun z : Point d => z) μ) : |
| ‖(∫ z,f z ∂μ)-f (∫ z,z ∂μ)‖ ≤ (L:ℝ)*(∫ z,‖z-∫ w,w ∂μ‖ ∂μ) := by |
| have hfi : Integrable f μ := integrable_lipschitz_comp_of_integrable hi hf |
| have hd := hi.sub (integrable_const (∫ w,w ∂μ)) |
| have he : (∫ z,f z-f (∫ w,w ∂μ) ∂μ)=(∫ z,f z ∂μ)-f (∫ w,w ∂μ) := by |
| rw [integral_sub hfi (integrable_const _),integral_const,probReal_univ,one_smul] |
| rw [← he] |
| apply (norm_integral_le_integral_norm _).trans |
| rw [← integral_const_mul] |
| apply integral_mono (hfi.sub (integrable_const _)).norm (hd.norm.const_mul _) |
| intro z |
| simpa only [dist_eq_norm,Pi.sub_apply] using hf.dist_le_mul z (∫ w,w ∂μ) |
|
|
| lemma conditionalFieldMean_center_error {d : ℕ} {F : Point d → ℝ} {lam : ℝ≥0} |
| (hF : Primitive F lam) (x : Point d) {r ρ : ℝ} (hr : 0≤r) |
| (hl : (lam:ℝ)*r^2≤1/2) (hρ0 : 0≤ρ) (hρ1 : ρ<1) (y : Point d) : |
| ‖conditionalFieldMean F x r ρ y-primitiveField F x r |
| (ρ • y-((1-ρ^2)*r) • conditionalFieldMean F x r ρ y)‖ ≤ |
| ((lam:ℝ)*r)*((d:ℝ)*Real.sqrt ((Real.pi^2/2)*(1-ρ^2))) := by |
| let := conditionalLaw_probability hF x hr hl hρ0 hρ1 y |
| have hh := norm_integral_sub_map_mean_le (primitiveField_lipschitz hF x hr) |
| (conditional_identity_integrable hF x hr hl hρ0 hρ1 y) |
| have hb := poincare_integral_norm_center |
| (mul_nonneg (by positivity) (probability_time hρ0 hρ1).1.le) |
| (conditionalLaw_hasPoincare hF x hr hl hρ0 hρ1 y) |
| (conditionalLaw_hasExpMoments hF x hr hl hρ0 hρ1 y).hasMoments |
| have hg := hh.trans (mul_le_mul_of_nonneg_left hb (mul_nonneg lam.coe_nonneg hr)) |
| simpa only [conditional_mean_identity hF x hr hl hρ0 hρ1 y,NNReal.coe_mul,NNReal.coe_mk,conditionalFieldMean] using hg |
|
|
| lemma conditionalFieldMean_error {d : ℕ} {F : Point d → ℝ} {lam : ℝ≥0} |
| (hF : Primitive F lam) (x : Point d) {r ρ : ℝ} (hr : 0≤r) |
| (hl : (lam:ℝ)*r^2≤1/2) (hρ0 : 0≤ρ) (hρ1 : ρ<1) (y : Point d) : |
| ‖conditionalFieldMean F x r ρ y-primitiveField F x r y‖ ≤ |
| ((lam:ℝ)*r)*((d:ℝ)*Real.sqrt ((Real.pi^2/2)*(1-ρ^2)))+ |
| ((lam:ℝ)*r)*((1-ρ)*‖y‖+((1-ρ^2)*r)*‖conditionalFieldMean F x r ρ y‖) := by |
| let M := conditionalFieldMean F x r ρ y |
| let z := ρ • y-((1-ρ^2)*r) • M |
| have he := conditionalFieldMean_center_error hF x hr hl hρ0 hρ1 y |
| have hh := (primitiveField_lipschitz hF x hr).dist_le_mul z y |
| rw [dist_eq_norm,dist_eq_norm] at hh |
| have hb : ‖z-y‖≤(1-ρ)*‖y‖+((1-ρ^2)*r)*‖M‖ := by |
| have hz : z-y=-( (1-ρ) • y+((1-ρ^2)*r) • M) := by |
| dsimp [z]; simp only [sub_smul,one_smul]; abel |
| rw [hz,norm_neg] |
| exact (norm_add_le _ _).trans_eq (by rw [norm_smul,norm_smul,Real.norm_eq_abs, |
| Real.norm_eq_abs,abs_of_nonneg (by linarith),abs_of_nonneg |
| (mul_nonneg (probability_time hρ0 hρ1).1.le hr)]) |
| calc |
| _ ≤ ‖M-primitiveField F x r z‖+‖primitiveField F x r z-primitiveField F x r y‖ := norm_sub_le_norm_sub_add_norm_sub _ _ _ |
| _ ≤ _ := add_le_add he (hh.trans (mul_le_mul_of_nonneg_left hb (mul_nonneg lam.coe_nonneg hr))) |
|
|
| end LogConcaveSampling |
|
|
| namespace LogConcaveSampling |
| open MeasureTheory |
|
|
| lemma conditionalFieldMean_norm_bound {d : ℕ} {F : Point d → ℝ} {lam : ℝ≥0} |
| (hF : Primitive F lam) (x : Point d) {r ρ : ℝ} (hr : 0≤r) |
| (hl : (lam:ℝ)*r^2≤1/2) (hρ0 : 0≤ρ) (hρ1 : ρ<1) (y : Point d) : |
| ‖conditionalFieldMean F x r ρ y‖ ≤ |
| 2*(‖primitiveField F x r y‖+((lam:ℝ)*r)* |
| ((d:ℝ)*Real.sqrt ((Real.pi^2/2)*(1-ρ^2)))+((lam:ℝ)*r)*(1-ρ)*‖y‖) := by |
| have hh := conditionalFieldMean_error hF x hr hl hρ0 hρ1 y |
| have ht := norm_le_norm_add_norm_sub' (conditionalFieldMean F x r ρ y) (primitiveField F x r y) |
| have hc : ((lam:ℝ)*r)*((1-ρ^2)*r)≤1/2 := by |
| have hb := mul_le_mul_of_nonneg_left (probability_time hρ0 hρ1).2 |
| (mul_nonneg lam.coe_nonneg (sq_nonneg r)) |
| nlinarith |
| have hb := mul_le_mul_of_nonneg_right hc (norm_nonneg (conditionalFieldMean F x r ρ y)) |
| nlinarith |
| |
| lemma conditionalFieldMean_endpoint_error {d : ℕ} {F : Point d → ℝ} {lam : ℝ≥0} |
| (hF : Primitive F lam) (x : Point d) {r ρ : ℝ} (hr : 0≤r) |
| (hl : (lam:ℝ)*r^2≤1/2) (hρ0 : 0≤ρ) (hρ1 : ρ<1) (y : Point d) : |
| ‖conditionalFieldMean F x r ρ y-primitiveField F x r y‖ ≤ |
| ((lam:ℝ)*r)*((d:ℝ)*Real.sqrt ((Real.pi^2/2)*(1-ρ^2)))+ |
| ((lam:ℝ)*r)*((1-ρ)*‖y‖+((1-ρ^2)*r)* |
| (2*(‖primitiveField F x r y‖+((lam:ℝ)*r)* |
| ((d:ℝ)*Real.sqrt ((Real.pi^2/2)*(1-ρ^2)))+((lam:ℝ)*r)*(1-ρ)*‖y‖))) := by |
| apply (conditionalFieldMean_error hF x hr hl hρ0 hρ1 y).trans |
| gcongr |
| · exact mul_nonneg (probability_time hρ0 hρ1).1.le hr |
| · exact conditionalFieldMean_norm_bound hF x hr hl hρ0 hρ1 y |
| end LogConcaveSampling |
| |
| namespace LogConcaveSampling |
| open MeasureTheory Filter |
| open scoped Topology |
| |
| lemma conditionalFieldMean_tendsto_endpoint {d : ℕ} {F : Point d → ℝ} {lam : ℝ≥0} |
| (hF : Primitive F lam) (x : Point d) {r : ℝ} (hr : 0≤r) |
| (hl : (lam:ℝ)*r^2≤1/2) {ι : Type*} {l : Filter ι} {ρ : ι → ℝ} |
| {y : ι → Point d} {y₀ : Point d} (ht : Tendsto ρ l (𝓝 1)) (hy : Tendsto y l (𝓝 y₀)) |
| (hρ : ∀ᶠ i in l,0≤ρ i ∧ ρ i<1) : |
| Tendsto (fun i => conditionalFieldMean F x r (ρ i) (y i)) l (𝓝 (primitiveField F x r y₀)) := by |
| have hg := (primitiveField_contDiff hF x r).continuous.continuousAt.tendsto.comp hy |
| have he : Tendsto (fun i => conditionalFieldMean F x r (ρ i) (y i)-primitiveField F x r (y i)) l (𝓝 0) := by |
| apply squeeze_zero_norm' (hρ.mono (fun i hi => conditionalFieldMean_endpoint_error hF x hr hl hi.1 hi.2 (y i))) |
| have hsq : Tendsto (fun i => 1-ρ i^2) l (𝓝 0) := by |
| simpa using (tendsto_const_nhds (x:=(1:ℝ))).sub (ht.pow 2) |
| have hs : Tendsto (fun i => Real.sqrt ((Real.pi^2/2)*(1-ρ i^2))) l (𝓝 0) := by |
| simpa using (tendsto_const_nhds.mul hsq).sqrt |
| convert! ((tendsto_const_nhds.mul (tendsto_const_nhds.mul hs)).add |
| (tendsto_const_nhds.mul (((tendsto_const_nhds.sub ht).mul hy.norm).add |
| ((hsq.mul tendsto_const_nhds).mul |
| (tendsto_const_nhds.mul ((hg.norm.add |
| (tendsto_const_nhds.mul (tendsto_const_nhds.mul hs))).add |
| ((tendsto_const_nhds.mul (tendsto_const_nhds.sub ht)).mul hy.norm))))))) using 1; simp |
| simpa only [Function.comp_apply,sub_add_cancel,zero_add] using he.add hg |
| end LogConcaveSampling |
| namespace LogConcaveSampling |
| open Set Filter Function |
| open scoped Topology |
|
|
| def closedFieldMean {d : ℕ} (F : Point d → ℝ) (x : Point d) (r ρ : ℝ) |
| (y : Point d) : Point d := |
| if ρ<1 then conditionalFieldMean F x r ρ y else primitiveField F x r y |
|
|
| lemma closedFieldMean_continuous {d : ℕ} {F : Point d → ℝ} {lam : ℝ≥0} |
| (hF : Primitive F lam) (x : Point d) {r : ℝ} (hr : 0≤r) |
| (hl : (lam:ℝ)*r^2≤1/2) : |
| Continuous (fun p : Icc (0:ℝ) 1 × Point d => closedFieldMean F x r p.1 p.2) := by |
| apply continuous_iff_continuousAt.mpr |
| intro p |
| have ht : Continuous (fun p : Icc (0:ℝ) 1 × Point d => (p.1:ℝ)) := continuous_subtype_val.comp continuous_fst |
| have hy : Continuous (fun p : Icc (0:ℝ) 1 × Point d => p.2) := continuous_snd |
| by_cases hp : (p.1:ℝ)<1 |
| · have hs := (conditionalFieldMean_joint_smooth hF x hr (by linarith) ((p.1:ℝ),p.2) |
| (by have ha := (probability_time p.1.2.1 hp).1; linarith)).continuousAt |
| have he : (fun q : Icc (0:ℝ) 1 × Point d => closedFieldMean F x r q.1 q.2) =ᶠ[𝓝 p] |
| (fun q => conditionalFieldMean F x r q.1 q.2) := by |
| filter_upwards [ht.continuousAt (eventually_lt_nhds hp)] with q hq |
| change (q.1:ℝ)<1 at hq |
| simp only [closedFieldMean,ite_eq_left hq] |
| exact ((hs.comp (f:=fun q : Icc (0:ℝ) 1 × Point d => ((q.1:ℝ),q.2)) (ht.continuousAt.prodMk hy.continuousAt))).congr_of_eventuallyEq he |
| · have hp1 : (p.1:ℝ)=1 := le_antisymm p.1.2.2 (le_of_not_gt hp) |
| change Tendsto _ (𝓝 p) (𝓝 (closedFieldMean F x r p.1 p.2)) |
| rw [closedFieldMean,ite_eq_right hp] |
| apply Filter.Tendsto.if |
| · apply conditionalFieldMean_tendsto_endpoint hF x hr hl |
| · simpa only [hp1] using (ht.continuousAt (x:=p)).tendsto.mono_left inf_le_left |
| · exact hy.continuousAt.tendsto.mono_left inf_le_left |
| · filter_upwards [self_mem_nhdsWithin] with q hq |
| exact ⟨q.1.2.1,hq⟩ |
| · exact ((primitiveField_contDiff hF x r).continuous.comp hy).continuousAt.tendsto.mono_left inf_le_left |
|
|
| def fullProbabilityVelocity {d : ℕ} (F : Point d → ℝ) (x : Point d) (r t : ℝ) |
| (z : Point d) : Point d := |
| -r • closedFieldMean F x r (projIcc 0 1 (by norm_num) t) z |
|
|
| lemma fullProbabilityVelocity_continuous {d : ℕ} {F : Point d → ℝ} {lam : ℝ≥0} |
| (hF : Primitive F lam) (x : Point d) {r : ℝ} (hr : 0≤r) |
| (hl : (lam:ℝ)*r^2≤1/2) : Continuous (uncurry (fullProbabilityVelocity F x r)) := by |
| have ht : Continuous (fun p : ℝ × Point d => projIcc (0:ℝ) 1 (by norm_num) p.1) := |
| continuous_projIcc.comp continuous_fst |
| exact (continuous_const (y:=(-r:ℝ))).smul ((closedFieldMean_continuous hF x hr hl).comp |
| (ht.prodMk continuous_snd)) |
|
|
| lemma fullProbabilityVelocity_eq {d : ℕ} (F : Point d → ℝ) (x : Point d) (r : ℝ) |
| {t : ℝ} (ht0 : 0≤t) (ht1 : t<1) (z : Point d) : |
| fullProbabilityVelocity F x r t z=probabilityVelocity F x r t z := by |
| simp only [fullProbabilityVelocity,projIcc_of_mem _ ⟨ht0,ht1.le⟩,closedFieldMean,ite_eq_left ht1,probabilityVelocity] |
|
|
| lemma fullProbabilityVelocity_endpoint {d : ℕ} (F : Point d → ℝ) (x : Point d) |
| (r : ℝ) (z : Point d) : fullProbabilityVelocity F x r 1 z= -r • primitiveField F x r z := by |
| simp [fullProbabilityVelocity,closedFieldMean] |
|
|
| lemma fullProbabilityVelocity_lipschitz {d : ℕ} {F : Point d → ℝ} {lam : ℝ≥0} |
| (hF : Primitive F lam) (x : Point d) {r : ℝ} (hr : 0≤r) |
| (hl : (lam:ℝ)*r^2≤1/2) (t : ℝ) : |
| LipschitzWith ⟨(Real.pi^2/2)*(lam:ℝ)*r^2,by positivity⟩ (fullProbabilityVelocity F x r t) := by |
| let s := projIcc 0 1 (by norm_num) t |
| by_cases hs : (s:ℝ)<1 |
| · have he : fullProbabilityVelocity F x r t=probabilityVelocity F x r s := by |
| funext z |
| simp only [fullProbabilityVelocity,closedFieldMean,probabilityVelocity,s,ite_eq_left hs] |
| rw [he] |
| exact probabilityVelocity_lipschitz hF x hr hl ⟨s.2.1,le_rfl⟩ hs |
| · have he : fullProbabilityVelocity F x r t=fun z => -r • primitiveField F x r z := by |
| funext z |
| simp only [fullProbabilityVelocity,closedFieldMean,s,ite_eq_right hs] |
| rw [he] |
| apply LipschitzWith.of_dist_le_mul |
| intro u v |
| rw [dist_eq_norm,← smul_sub,norm_smul,Real.norm_eq_abs,abs_neg,abs_of_nonneg hr] |
| have hh := (primitiveField_lipschitz hF x hr).dist_le_mul u v |
| rw [dist_eq_norm] at hh |
| calc |
| _ ≤ r*((lam:ℝ)*r*dist u v) := mul_le_mul_of_nonneg_left hh hr |
| _ ≤ ((Real.pi^2/2)*(lam:ℝ)*r^2)*dist u v := by |
| have hp : 1≤Real.pi^2/2 := by nlinarith [Real.pi_gt_three] |
| have hnon : 0≤(lam:ℝ)*r^2*dist u v := by positivity |
| nlinarith |
| end LogConcaveSampling |
|
|
| end UpperProof |
| end |
| end |
| end |
|
|
| end OAI |
|
|
