| import Mathlib |
| import OAI.Probability.LogConcave.Sampling.ConditionalMeanScalar |
| import OAI.Probability.LogConcave.JetEstimates.DirLogLaplace |
| import OAI.Probability.LogConcave.Sampling.JointPosition |
| import OAI.Probability.LogConcave.JetEstimates.MixedJetAdd |
|
|
| 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 |
|
|
| namespace LogConcaveSampling |
| open MeasureTheory |
| open scoped RealInnerProductSpace Topology |
|
|
| lemma primitiveField_inner_growth {d : ℕ} {F : Point d → ℝ} {lam : ℝ≥0} |
| (hF : Primitive F lam) (x u : Point d) {r : ℝ} (hr : 0≤r) : |
| Appell.HasGrowth (fun z => inner ℝ u (primitiveField F x r z)) := |
| Appell.HasGrowth.lipschitz ((innerSL ℝ u).lipschitzWith.comp (primitiveField_lipschitz hF x hr)) |
|
|
| theorem conditionalFieldMean_logLaplace {d : ℕ} {F : Point d → ℝ} {lam : ℝ≥0} |
| (hF : Primitive F lam) (x : Point d) {r ρ : ℝ} (hr : 0<r) |
| (hlam : 0<lam) (hl : (lam:ℝ)*r^2≤1/2) (hρ0 : 0≤ρ) (hρ1 : ρ<1) |
| (u y h : Point d) : |
| conditionalMeanScalar F x r ρ (fun z => inner ℝ u (primitiveField F x r z)) (y+h)= |
| ((lam:ℝ)*r)*JetCalculus.dir (jointField d u) |
| (fun θ => Real.log (Appell.laplace (jointConditionalLaw F x r ρ y ((lam:ℝ)*r)) |
| (fun _ => (1:ℝ)) θ)) (jointPosition d ((ρ/(1-ρ^2)) • h)) := by |
| obtain ⟨hp,hm,_⟩ := jointConditionalLaw_properties hF x hr hlam hl hρ0 hρ1 y |
| let := hp |
| rw [Appell.dir_log_laplace hm] |
| change _=((lam:ℝ)*r)*Appell.normalizedLaplace |
| ((gibbs (conditionalPotential F x r ρ y)).map (jointImage (primitiveField F x r) ((lam:ℝ)*r))) |
| (fun z => inner ℝ (jointField d u) z) (jointPosition d ((ρ/(1-ρ^2)) • h)) |
| rw [joint_normalizedLaplace (primitiveField_contDiff hF x r).continuous, |
| ← mul_assoc,mul_inv_cancel₀ (by positivity : (lam:ℝ)*r≠0),one_mul] |
| exact conditionalMeanScalar_shift hF x hr.le hl hρ0 hρ1 _ y h |
|
|
| theorem conditionalFieldMean_jet {d : ℕ} {F : Point d → ℝ} {lam : ℝ≥0} |
| (hF : Primitive F lam) (x : Point d) {r ρ : ℝ} (hr : 0<r) |
| (hlam : 0<lam) (hl : (lam:ℝ)*r^2≤1/2) (hρ0 : 0≤ρ) (hρ1 : ρ<1) |
| (u y : Point d) {ι : Type*} (v : ι → Point d) (l : List ι) : |
| JetCalculus.jet v l |
| (conditionalMeanScalar F x r ρ (fun z => inner ℝ u (primitiveField F x r z))) y= |
| ((lam:ℝ)*r)*(ρ/(1-ρ^2))^l.length* |
| JetCalculus.jet (fun i => jointPosition d (v i)) l |
| (JetCalculus.dir (jointField d u) |
| (fun θ => Real.log (Appell.laplace (jointConditionalLaw F x r ρ y ((lam:ℝ)*r)) |
| (fun _ => (1:ℝ)) θ))) 0 := by |
| obtain ⟨hp,hm,_⟩ := jointConditionalLaw_properties hF x hr hlam hl hρ0 hρ1 y |
| let := hp |
| let f : JointPoint d → ℝ := fun θ => Real.log |
| (Appell.laplace (jointConditionalLaw F x r ρ y ((lam:ℝ)*r)) (fun _ => (1:ℝ)) θ) |
| have hfs : ContDiff ℝ (⊤ : ℕ∞) f := |
| (Appell.contDiff_laplace hm continuous_const (Appell.HasGrowth.const _)).log |
| (fun θ => (Appell.laplace_one_pos hm θ).ne') |
| have hds := JetCalculus.smooth_dir hfs (jointField d u) |
| let B : Point d →L[ℝ] JointPoint d := (ρ/(1-ρ^2)) • jointPosition d |
| have hcomp : ContDiff ℝ (⊤ : ℕ∞) (fun h => JetCalculus.dir (jointField d u) f (B h+0)) := |
| hds.comp (by fun_prop) |
| have hs := conditionalMeanScalar_smooth hF x hr.le hl hρ0 hρ1 |
| (continuous_const.inner (primitiveField_contDiff hF x r).continuous) |
| (primitiveField_inner_growth hF x u hr.le) |
| have htrans := congrFun (JetCalculus.jet_comp_affine hs (ContinuousLinearMap.id ℝ (Point d)) |
| y v l) 0 |
| have he : (fun h => conditionalMeanScalar F x r ρ |
| (fun z => inner ℝ u (primitiveField F x r z)) (h+y))= |
| fun h => ((lam:ℝ)*r)*JetCalculus.dir (jointField d u) f (B h+0) := by |
| funext h |
| simpa only [add_comm h y,B,smul_apply,map_smul,add_zero] |
| using conditionalFieldMean_logLaplace hF x hr hlam hl hρ0 hρ1 u y h |
| simp only [ContinuousLinearMap.id_apply,zero_add] at htrans |
| rw [← htrans,he,JetCalculus.jet_const_mul hcomp, |
| JetCalculus.jet_comp_affine hds B 0] |
| simp only [map_zero,zero_add] |
| have hB : (fun i => B (v i))=fun i => (ρ/(1-ρ^2)) • jointPosition d (v i) := rfl |
| rw [hB,JetCalculus.jet_smul hds] |
| ring |
| |
| end LogConcaveSampling |
| |
| namespace LogConcaveSampling |
| open MeasureTheory ProbabilityTheory |
| open scoped RealInnerProductSpace |
| |
| lemma covariance_sq_le {Ω : Type*} [MeasurableSpace Ω] {μ : Measure Ω} |
| [IsProbabilityMeasure μ] {f g : Ω → ℝ} (hf : MemLp f 2 μ) (hg : MemLp g 2 μ) : |
| (cov[f,g;μ])^2 ≤ Var[f;μ]*Var[g;μ] := by |
| rw [covariance,variance_eq_integral hf.aemeasurable,variance_eq_integral hg.aemeasurable] |
| exact integral_mul_sq_le (hf.sub (memLp_const _)) (hg.sub (memLp_const _)) |
| |
| namespace Appell |
| variable {E : Type} [NormedAddCommGroup E] [InnerProductSpace ℝ E] |
| [MeasurableSpace E] [BorelSpace E] [SecondCountableTopology E] |
| |
| lemma powerset_singleton {ι : Type*} [DecidableEq ι] (i : ι) : |
| ({i}:Finset ι).powerset={∅,{i}} := by |
| ext s |
| simp [Finset.subset_singleton_iff] |
| |
| lemma inverseMoment_singleton {ι : Type*} [DecidableEq ι] (m : Finset ι → ℝ) (i : ι) : |
| inverseMoment m {i} = -m {i} := by |
| rw [inverseMoment_nonempty _ (Finset.singleton_nonempty i).ne_empty] |
| rw [powerset_singleton] |
| simp |
| |
| lemma polynomial_singleton {ι : Type*} [DecidableEq ι] (m : Finset ι → ℝ) (i : ι) (z : ι → ℝ) : |
| polynomial m {i} z=z i-m {i} := by |
| simp [polynomial, powerset_singleton, inverseMoment_singleton,sub_eq_add_neg] |
| |
| lemma dir_normalizedLaplace_zero {μ : Measure E} [IsProbabilityMeasure μ] |
| (hμ : HasExpMoments μ) {f : E → ℝ} (hf : Continuous f) (hg : HasGrowth f) (v : E) : |
| JetCalculus.dir v (normalizedLaplace μ f) 0= |
| cov[(fun z => inner ℝ v z),f;μ] := by |
| have hh := jet_normalizedLaplace_zero hμ hf hg (fun _ : Unit => v) [()] |
| (by simp) |
| simp only [JetCalculus.jet,List.toFinset_cons,List.toFinset_nil,Finset.insert_empty, |
| polynomial_singleton,moments,Finset.prod_singleton] at hh |
| rw [hh] |
| let g : E → ℝ := fun z => inner ℝ v z |
| have hgm : MemLp g 2 μ := (HasGrowth.linear (innerSL ℝ v)).memLp |
| (by fun_prop) hμ.hasMoments |
| have hfm := hg.memLp hf.aestronglyMeasurable hμ.hasMoments |
| rw [covariance_eq_sub hgm hfm] |
| simp only [sub_mul] |
| change (∫ x, g x*f x-(∫ z, g z ∂μ)*f x ∂μ)=_ |
| simpa only [Pi.mul_apply,integral_const_mul] using |
| integral_sub (hgm.integrable_mul hfm) |
| ((hfm.integrable (by norm_num)).const_mul (∫ z, g z ∂μ)) |
| |
| end Appell |
| |
| theorem conditionalFieldMean_dir_cov {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) (u v y : Point d) : |
| JetCalculus.dir v |
| (conditionalMeanScalar F x r ρ (fun z => inner ℝ u (primitiveField F x r z))) y= |
| (ρ/(1-ρ^2))*cov[(fun z => inner ℝ v z), |
| (fun z => inner ℝ u (primitiveField F x r z));gibbs (conditionalPotential F x r ρ y)] := by |
| let μ := gibbs (conditionalPotential F x r ρ y) |
| let := conditionalLaw_probability hF x hr hl hρ0 hρ1 y |
| have hm := conditionalLaw_hasExpMoments hF x hr hl hρ0 hρ1 y |
| let f : Point d → ℝ := fun z => inner ℝ u (primitiveField F x r z) |
| have hfc : Continuous f := continuous_const.inner (primitiveField_contDiff hF x r).continuous |
| have hfg : Appell.HasGrowth f := primitiveField_inner_growth hF x u hr |
| have hmean := conditionalMeanScalar_smooth hF x hr hl hρ0 hρ1 hfc hfg |
| have hs := Appell.smooth_normalizedLaplace hm hfc hfg |
| have he : (fun h => conditionalMeanScalar F x r ρ f (h+y))= |
| fun h => Appell.normalizedLaplace μ f ((ρ/(1-ρ^2)) • h) := by |
| funext h |
| simpa only [add_comm h y] using conditionalMeanScalar_shift hF x hr hl hρ0 hρ1 f y h |
| have htr := congrFun (JetCalculus.dir_comp_affine |
| (hmean.differentiable (by simp)) (ContinuousLinearMap.id ℝ (Point d)) y v) 0 |
| simp only [ContinuousLinearMap.id_apply,zero_add] at htr |
| rw [← htr,he] |
| let B : Point d →L[ℝ] Point d := (ρ/(1-ρ^2)) • ContinuousLinearMap.id ℝ (Point d) |
| have heB : (fun h => Appell.normalizedLaplace μ f ((ρ/(1-ρ^2)) • h))= |
| fun h => Appell.normalizedLaplace μ f (B h+0) := by |
| funext h; simp [B] |
| rw [heB] |
| rw [JetCalculus.dir_comp_affine (hs.differentiable (by simp))] |
| simp only [map_zero,zero_add] |
| change JetCalculus.dir ((ρ/(1-ρ^2)) • v) (Appell.normalizedLaplace μ f) 0=_ |
| rw [JetCalculus.dir_smul] |
| change (ρ/(1-ρ^2))*JetCalculus.dir v (Appell.normalizedLaplace μ f) 0=_ |
| rw [Appell.dir_normalizedLaplace_zero hm hfc hfg] |
| |
| end LogConcaveSampling |
| |
| namespace LogConcaveSampling |
| open MeasureTheory ProbabilityTheory |
| open scoped RealInnerProductSpace |
| |
| def conditionalFieldMean {d : ℕ} (F : Point d → ℝ) (x : Point d) (r ρ : ℝ) |
| (y : Point d) : Point d := ∫ z, primitiveField F x r z ∂gibbs (conditionalPotential F x r ρ y) |
| |
| lemma conditionalField_integrable {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) : |
| Integrable (primitiveField F x r) (gibbs (conditionalPotential F x r ρ y)) := by |
| let := conditionalLaw_probability hF x hr hl hρ0 hρ1 y |
| exact (Appell.HasGrowth.lipschitz (primitiveField_lipschitz hF x hr)).integrable |
| (primitiveField_contDiff hF x r).continuous.aestronglyMeasurable |
| (conditionalLaw_hasExpMoments hF x hr hl hρ0 hρ1 y).hasMoments |
| |
| lemma conditionalFieldMean_inner {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) (u y : Point d) : |
| inner ℝ u (conditionalFieldMean F x r ρ y)= |
| conditionalMeanScalar F x r ρ (fun z => inner ℝ u (primitiveField F x r z)) y := by |
| exact (integral_inner (conditionalField_integrable hF x hr hl hρ0 hρ1 y) u).symm |
| |
| lemma conditionalFieldMean_smooth {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) : |
| ContDiff ℝ (⊤ : ℕ∞) (conditionalFieldMean F x r ρ) := by |
| let b := EuclideanSpace.basisFun (Fin d) ℝ |
| have he : conditionalFieldMean F x r ρ = fun y => ∑ i : Fin d, |
| conditionalMeanScalar F x r ρ (fun z => inner ℝ (b i) (primitiveField F x r z)) y • b i := by |
| funext y |
| simp_rw [← conditionalFieldMean_inner hF x hr hl hρ0 hρ1, |
| ← b.repr_apply_apply] |
| exact (b.sum_repr _).symm |
| rw [he] |
| apply ContDiff.sum |
| intro i _ |
| exact (conditionalMeanScalar_smooth hF x hr hl hρ0 hρ1 |
| (continuous_const.inner (primitiveField_contDiff hF x r).continuous) |
| (primitiveField_inner_growth hF x (b i) hr)).smul contDiff_const |
| |
| lemma conditional_covariance_le {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) (u v y : Point d) : |
| |cov[(fun z => inner ℝ v z), (fun z => inner ℝ u (primitiveField F x r z)); |
| gibbs (conditionalPotential F x r ρ y)]| ≤ |
| ((Real.pi^2/2)*(1-ρ^2))*((lam:ℝ)*r)*‖u‖*‖v‖ := by |
| let μ := gibbs (conditionalPotential F x r ρ y) |
| let := conditionalLaw_probability hF x hr hl hρ0 hρ1 y |
| have hm := (conditionalLaw_hasExpMoments hF x hr hl hρ0 hρ1 y).hasMoments |
| let f : Point d → ℝ := fun z => inner ℝ v z |
| let g : Point d → ℝ := fun z => inner ℝ u (primitiveField F x r z) |
| have hf : MemLp f 2 μ := (Appell.HasGrowth.linear (innerSL ℝ v)).memLp (by fun_prop) hm |
| have hg : MemLp g 2 μ := (primitiveField_inner_growth hF x u hr).memLp |
| (continuous_const.inner (primitiveField_contDiff hF x r).continuous).aestronglyMeasurable hm |
| have hP := conditionalLaw_hasPoincare hF x hr hl hρ0 hρ1 y |
| have hβ : 0≤(Real.pi^2/2)*(1-ρ^2) := mul_nonneg (by positivity) (probability_time hρ0 hρ1).1.le |
| have hv := hP.lipschitz_variance hβ (innerSL ℝ v).contDiff (innerSL ℝ v).lipschitzWith hf |
| have hu := hP.lipschitz_variance hβ ((innerSL ℝ u).contDiff.comp (primitiveField_contDiff hF x r)) |
| ((innerSL ℝ u).lipschitzWith.comp (primitiveField_lipschitz hF x hr)) hg |
| simp only [NNReal.coe_mul,coe_nnnorm,innerSL_apply_norm,NNReal.coe_mk] at hv hu |
| change Var[f;μ] ≤ _ at hv |
| change Var[g;μ] ≤ _ at hu |
| have hb := (covariance_sq_le hf hg).trans |
| (mul_le_mul hv hu (variance_nonneg g μ) (mul_nonneg hβ (sq_nonneg _))) |
| change |cov[f,g;μ]| ≤ _ |
| have hh : 0≤((Real.pi^2/2)*(1-ρ^2))*((lam:ℝ)*r)*‖u‖*‖v‖ := by positivity |
| apply (sq_le_sq₀ (abs_nonneg _) hh).mp |
| rw [sq_abs] |
| convert! hb using 1 |
| ring |
| |
| lemma conditionalFieldMean_inner_deriv {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) (u v y : Point d) : |
| inner ℝ u (fderiv ℝ (conditionalFieldMean F x r ρ) y v)= |
| (ρ/(1-ρ^2))*cov[(fun z => inner ℝ v z), (fun z => inner ℝ u (primitiveField F x r z)); |
| gibbs (conditionalPotential F x r ρ y)] := by |
| have he : (fun y => inner ℝ u (conditionalFieldMean F x r ρ y))= |
| conditionalMeanScalar F x r ρ (fun z => inner ℝ u (primitiveField F x r z)) := |
| funext (conditionalFieldMean_inner hF x hr hl hρ0 hρ1 u) |
| have hd := (conditionalFieldMean_smooth hF x hr hl hρ0 hρ1).differentiable (by simp) |
| have hh := (innerSL ℝ u).hasFDerivAt.comp y (hd y).hasFDerivAt |
| have hh' := congrArg (fun A : Point d →L[ℝ] ℝ => A v) hh.fderiv |
| change JetCalculus.dir v (fun y => inner ℝ u (conditionalFieldMean F x r ρ y)) y= |
| inner ℝ u (fderiv ℝ (conditionalFieldMean F x r ρ) y v) at hh' |
| rw [←hh',he] |
| exact conditionalFieldMean_dir_cov hF x hr hl hρ0 hρ1 u v y |
|
|
| theorem conditionalFieldMean_lipschitz {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) : |
| LipschitzWith ⟨(Real.pi^2/2)*ρ*((lam:ℝ)*r), by positivity⟩ |
| (conditionalFieldMean F x r ρ) := by |
| have hd := (conditionalFieldMean_smooth hF x hr hl hρ0 hρ1).differentiable (by simp) |
| apply lipschitzWith_of_nnnorm_fderiv_le hd |
| intro y |
| apply (show ‖fderiv ℝ (conditionalFieldMean F x r ρ) y‖ ≤ (Real.pi^2/2)*ρ*((lam:ℝ)*r) from ?_) |
| apply ContinuousLinearMap.opNorm_le_bound _ (by positivity) |
| intro v |
| let w := fderiv ℝ (conditionalFieldMean F x r ρ) y v |
| have he := conditionalFieldMean_inner_deriv hF x hr hl hρ0 hρ1 w v y |
| have hb := mul_le_mul_of_nonneg_left (conditional_covariance_le hF x hr hl hρ0 hρ1 w v y) |
| (div_nonneg hρ0 (probability_time hρ0 hρ1).1.le) |
| have hh : ‖w‖^2 ≤ ((Real.pi^2/2)*ρ*((lam:ℝ)*r))*‖w‖*‖v‖ := by |
| rw [←real_inner_self_eq_norm_sq w,he] |
| calc |
| _ ≤ (ρ/(1-ρ^2))*|cov[(fun z => inner ℝ v z), |
| (fun z => inner ℝ w (primitiveField F x r z));gibbs (conditionalPotential F x r ρ y)]| := |
| mul_le_mul_of_nonneg_left (le_abs_self _) (div_nonneg hρ0 (probability_time hρ0 hρ1).1.le) |
| _ ≤ _ := by |
| convert! hb using 1 |
| field_simp [(probability_time hρ0 hρ1).1.ne'] |
| change ‖w‖ ≤ _ |
| by_cases hw : ‖w‖=0 |
| · rw [hw]; positivity |
| · apply (mul_le_mul_iff_left₀ (lt_of_le_of_ne (norm_nonneg w) (Ne.symm hw))).mp |
| convert! hh using 1 <;> ring |
| |
| end LogConcaveSampling |
| |
| namespace LogConcaveSampling |
| open MeasureTheory |
| open scoped RealInnerProductSpace |
| |
| def quadraticTilt {d : ℕ} {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| (H : Point d → ℝ) (h : Point d → E) (p : Point d × ℝ) : E := |
| ∫ z, Real.exp (inner ℝ p.1 z-p.2*‖z‖^2-H z) • h z |
| |
| def quadraticLinear {d : ℕ} (z : Point d) : (Point d × ℝ) →L[ℝ] ℝ := |
| (innerSL ℝ z).comp (ContinuousLinearMap.fst ℝ (Point d) ℝ) - |
| ‖z‖^2 • ContinuousLinearMap.snd ℝ (Point d) ℝ |
| |
| def quadraticDerivative {d : ℕ} {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| (h : Point d → E) (z : Point d) : (Point d × ℝ) →L[ℝ] E := |
| (quadraticLinear z).smulRight (h z) |
| |
| lemma quadraticLinear_apply {d : ℕ} (z : Point d) (p : Point d × ℝ) : |
| quadraticLinear z p=inner ℝ p.1 z-p.2*‖z‖^2 := by |
| simp [quadraticLinear,real_inner_comm,mul_comm] |
| |
| lemma continuous_quadraticLinear {d : ℕ} : Continuous (quadraticLinear (d:=d)) := by |
| exact ((innerSL ℝ).continuous.clm_comp continuous_const).sub |
| ((continuous_norm.pow 2).smul continuous_const) |
| |
| lemma norm_quadraticLinear {d : ℕ} (z : Point d) : |
| ‖quadraticLinear z‖ ≤ ‖z‖+‖z‖^2 := by |
| apply ContinuousLinearMap.opNorm_le_bound _ (by positivity) |
| intro p |
| rw [quadraticLinear_apply] |
| calc |
| ‖inner ℝ p.1 z-p.2*‖z‖^2‖ ≤ ‖p.1‖*‖z‖+‖p.2‖*‖z‖^2 := by |
| exact (norm_sub_le _ _).trans (add_le_add (norm_inner_le_norm _ _) (by simp [norm_mul])) |
| _ ≤ ‖p‖*‖z‖+‖p‖*‖z‖^2 := add_le_add |
| (mul_le_mul_of_nonneg_right (norm_fst_le p) (norm_nonneg _)) |
| (mul_le_mul_of_nonneg_right (norm_snd_le p) (sq_nonneg _)) |
| _ = (‖z‖+‖z‖^2)*‖p‖ := by ring |
| |
| section |
| variable {d : ℕ} {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| |
| lemma continuous_quadraticDerivative {h : Point d → E} (hh : Continuous h) : |
| Continuous (quadraticDerivative h) := |
| isBoundedBilinearMap_smulRight.continuous.comp (continuous_quadraticLinear.prodMk hh) |
| |
| lemma growth_quadraticDerivative {h : Point d → E} (hg : HasPolynomialGrowth h) : |
| HasPolynomialGrowth (quadraticDerivative h) := by |
| obtain ⟨C,hC,n,hn⟩ := hg |
| refine ⟨4*C,by positivity,n+2,fun z => ?_⟩ |
| have hz := norm_nonneg z |
| have hb : ‖quadraticDerivative h z‖ ≤ (‖z‖+‖z‖^2)*(C*(1+‖z‖^n)) := by |
| rw [quadraticDerivative,ContinuousLinearMap.norm_smulRight_apply] |
| exact mul_le_mul (norm_quadraticLinear z) (hn z) (norm_nonneg _) (by positivity) |
| by_cases h1 : ‖z‖ ≤ 1 |
| · have hp : ‖z‖^n ≤ 1 := pow_le_one₀ hz h1 |
| have h2 : ‖z‖^2 ≤ 1 := pow_le_one₀ hz h1 |
| calc |
| _ ≤ (‖z‖+‖z‖^2)*(C*(1+‖z‖^n)) := hb |
| _ ≤ 2*(C*2) := mul_le_mul (by linarith) (mul_le_mul_of_nonneg_left (by linarith) hC) |
| (by positivity) (by norm_num) |
| _ ≤ _ := by nlinarith [mul_nonneg hC (pow_nonneg hz (n+2))] |
| · have h1' : 1 ≤ ‖z‖ := le_of_not_ge h1 |
| have he (k : ℕ) (hk : k ≤ n+2) : ‖z‖^k ≤ ‖z‖^(n+2) := pow_le_pow_right₀ h1' hk |
| have hA := he 1 (by omega) |
| have hB := he 2 (by omega) |
| have hD := he (n+1) (by omega) |
| simp only [pow_one] at hA |
| calc |
| _ ≤ (‖z‖+‖z‖^2)*(C*(1+‖z‖^n)) := hb |
| _ = C*(‖z‖+‖z‖^2+‖z‖^(n+1)+‖z‖^(n+2)) := by |
| simp only [pow_add,pow_one]; ring |
| _ ≤ C*(4*‖z‖^(n+2)) := mul_le_mul_of_nonneg_left (by linarith) hC |
| _ ≤ _ := by nlinarith |
| |
| lemma integrable_quadraticTilt {H : Point d → ℝ} {h : Point d → E} |
| (hH : Continuous H) (hh : Continuous h) {m C : ℝ} |
| (ht : ∀ z, m*‖z‖^2 ≤ H z+C) (hg : HasPolynomialGrowth h) |
| (p : Point d × ℝ) (hp : 0 < m+p.2) : |
| Integrable (fun z => Real.exp (inner ℝ p.1 z-p.2*‖z‖^2-H z) • h z) := by |
| have ht' : HasGaussianLowerTail (fun z => H z+p.2*‖z‖^2) := |
| ⟨m+p.2,hp,C,fun z => by nlinarith [ht z]⟩ |
| convert! integrable_tilted _ (hH.add (continuous_const.mul (continuous_norm.pow 2))) hh ht' hg p.1 using 1 |
| funext z; congr 2; dsimp; ring |
| |
| lemma hasFDerivAt_quadraticTilt {H : Point d → ℝ} {h : Point d → E} |
| (hH : Continuous H) (hh : Continuous h) {m C : ℝ} |
| (ht : ∀ z, m*‖z‖^2 ≤ H z+C) (hg : HasPolynomialGrowth h) |
| (p : Point d × ℝ) (hp : 0 < m+p.2) : |
| HasFDerivAt (quadraticTilt H h) (quadraticTilt H (quadraticDerivative h) p) p := by |
| let δ := (m+p.2)/2 |
| have hδ : 0 < δ := by dsimp [δ]; linarith |
| let M := ‖p.1‖+1 |
| obtain ⟨K,hK,n,hg'⟩ := growth_quadraticDerivative hg |
| let B := Real.exp (C+M^2/(2*δ))*K |
| let b : Point d → ℝ := fun z => B*(Real.exp (-(δ/2)*‖z‖^2)+‖z‖^n*Real.exp (-(δ/2)*‖z‖^2)) |
| have hi : Integrable b := ((integrable_gaussian_envelope d (b:=δ/2) (by positivity)).add |
| (integrable_norm_pow_gaussian d n (b:=δ/2) (by positivity))).const_mul B |
| let U : Set (Point d × ℝ) := {q | ‖q.1‖ < M ∧ p.2-δ < q.2} |
| have hopen : IsOpen U := (isOpen_lt (continuous_fst.norm) continuous_const).inter |
| (isOpen_lt continuous_const continuous_snd) |
| have hU : U∈nhds p := by |
| apply hopen.mem_nhds |
| change ‖p.1‖ < M ∧ p.2-δ < p.2 |
| exact ⟨by dsimp [M]; linarith,by linarith⟩ |
| have hd (z : Point d) (q : Point d × ℝ) : |
| HasFDerivAt (fun t => Real.exp (inner ℝ t.1 z-t.2*‖z‖^2-H z) • h z) |
| (Real.exp (inner ℝ q.1 z-q.2*‖z‖^2-H z) • quadraticDerivative h z) q := by |
| have hh' := (((quadraticLinear z).hasFDerivAt (x:=q)).sub_const (H z)).exp.smul_const (h z) |
| convert! hh' using 1 |
| · funext t; rw [quadraticLinear_apply] |
| · apply ContinuousLinearMap.ext; intro t |
| simp [quadraticDerivative,quadraticLinear_apply,smul_smul] |
| apply hasFDerivAt_integral_of_dominated_of_fderiv_le |
| (F':=fun q z => Real.exp (inner ℝ q.1 z-q.2*‖z‖^2-H z) • quadraticDerivative h z) |
| (bound:=b) hU |
| · exact Filter.Eventually.of_forall fun q => |
| ((Real.continuous_exp.comp (((continuous_const.inner continuous_id).sub |
| (continuous_const.mul (continuous_norm.pow 2))).sub hH)).smul hh).aestronglyMeasurable |
| · exact integrable_quadraticTilt hH hh ht hg p hp |
| · exact (integrable_quadraticTilt hH (continuous_quadraticDerivative hh) ht |
| (growth_quadraticDerivative hg) p hp).aestronglyMeasurable |
| · filter_upwards [] with z q hq |
| have ht' : ∀ z, δ*‖z‖^2 ≤ (H z+q.2*‖z‖^2)+C := by |
| intro z |
| have hq' : δ ≤ m+q.2 := by dsimp [U,δ] at *; linarith [hq.2] |
| nlinarith [ht z,mul_nonneg (sub_nonneg.mpr hq') (sq_nonneg ‖z‖)] |
| have he := mul_le_mul (gaussian_tilt_bound hδ (by dsimp [M]; positivity) ht' hq.1.le z) |
| (hg' z) (norm_nonneg _) (by positivity) |
| rw [norm_smul,Real.norm_eq_abs,abs_of_pos (Real.exp_pos _)] |
| convert! he using 1 |
| · congr 2; ring |
| · dsimp [b,B]; ring |
| · exact hi |
| · exact Filter.Eventually.of_forall fun z q _ => hd z q |
|
|
| theorem contDiffAt_quadraticTilt {H : Point d → ℝ} {h : Point d → E} |
| (hH : Continuous H) (hh : Continuous h) {m C : ℝ} |
| (ht : ∀ z, m*‖z‖^2 ≤ H z+C) (hg : HasPolynomialGrowth h) |
| (p : Point d × ℝ) (hp : 0 < m+p.2) : |
| ContDiffAt ℝ (⊤ : ℕ∞) (quadraticTilt H h) p := by |
| apply contDiffAt_infty.mpr |
| intro n |
| induction n generalizing E h with |
| | zero => |
| apply contDiffAt_zero.mpr |
| refine ⟨{q | 0 < m+q.2},?_,fun q hq => |
| (hasFDerivAt_quadraticTilt hH hh ht hg q hq).continuousAt.continuousWithinAt⟩ |
| exact (isOpen_lt continuous_const (continuous_const.add continuous_snd)).mem_nhds hp |
| | succ n ih => |
| rw [Nat.cast_add,Nat.cast_one,contDiffAt_succ_iff_hasFDerivAt] |
| refine ⟨quadraticTilt H (quadraticDerivative h),?_,ih |
| (continuous_quadraticDerivative hh) (growth_quadraticDerivative hg)⟩ |
| refine ⟨{q | 0 < m+q.2},?_,fun q hq => hasFDerivAt_quadraticTilt hH hh ht hg q hq⟩ |
| exact (isOpen_lt continuous_const (continuous_const.add continuous_snd)).mem_nhds hp |
|
|
| end |
| end LogConcaveSampling |
|
|
| end UpperProof |
| end |
| end |
| end |
|
|
| end OAI |
|
|
