| import Mathlib |
| import OAI.Probability.LogConcave.Sampling.StateLaw |
| import OAI.Probability.LogConcave.Sampling.NoiseKernel |
|
|
| namespace OAI |
|
|
| section |
| noncomputable section |
| namespace LogConcaveSampling |
| open MeasureTheory ProbabilityTheory Function |
| open scoped Classical |
|
|
| variable {E R : Type*} [MeasurableSpace E] [MeasurableSpace R] |
|
|
| def changingChain (κ : ℕ → Kernel E E) (μ : Measure E) : ℕ → Measure E |
| | 0 => μ |
| | n+1 => κ n ∘ₘ changingChain κ μ n |
| |
| instance changingChain_probability (κ : ℕ → Kernel E E) [∀n,IsMarkovKernel (κ n)] |
| (μ : Measure E) [IsProbabilityMeasure μ] (n : ℕ) : IsProbabilityMeasure (changingChain κ μ n) := by |
| induction n with |
| | zero => exact inferInstanceAs (IsProbabilityMeasure μ) |
| | succ n ih => let := ih; exact inferInstanceAs (IsProbabilityMeasure (κ n ∘ₘ changingChain κ μ n)) |
| |
| lemma changingChain_constant (κ : Kernel E E) (μ : Measure E) (n : ℕ) : |
| changingChain (fun _ => κ) μ n=markovChain κ μ n := by |
| induction n with |
| | zero => rfl |
| | succ n ih => rw [changingChain,markovChain,ih] |
| |
| lemma changingChain_tv (κ : ℕ → Kernel E E) [∀n,IsMarkovKernel (κ n)] |
| {μ ν : Measure E} [IsProbabilityMeasure μ] [IsProbabilityMeasure ν] {e : ℝ} |
| (he : TVAtMost μ ν e) (n : ℕ) : |
| TVAtMost (changingChain κ μ n) (changingChain κ ν n) e := by |
| induction n with |
| | zero => exact he |
| | succ n ih => exact ih.kernel (κ n) |
| |
| lemma stateLaw_eq_changingChain (μ : Measure E) (γ : Measure R) |
| [IsProbabilityMeasure μ] [IsProbabilityMeasure γ] |
| (f : ℕ → E × R → E) (hf : ∀n,Measurable (f n)) |
| (κ : ℕ → Kernel E E) [∀n,IsMarkovKernel (κ n)] |
| (hk : ∀n x,κ n x=γ.map (fun r => f n (x,r))) (n : ℕ) : |
| stateLaw μ γ f n=changingChain κ μ n := by |
| induction n with |
| | zero => rfl |
| | succ n ih => |
| rw [stateLaw,changingChain,ih] |
| apply measure_eq_of_bounded_integral |
| intro g hg hb |
| rw [kernel_integral_comp _ _ hg hb,integral_map (hf n).aemeasurable hg.aestronglyMeasurable] |
| rw [integral_prod _ (show Integrable (fun p => g (f n p)) _ from bounded_integrable (hg.comp (hf n)) (fun p => hb _))] |
| apply integral_congr_ae |
| filter_upwards [] with x |
| rw [hk] |
| exact (integral_map ((hf n).comp (show Measurable (fun r : R => (x,r)) by fun_prop)).aemeasurable hg.aestronglyMeasurable).symm |
| |
| end LogConcaveSampling |
| |
| end |
| |
| end |
| |
| section |
| |
| noncomputable section |
| namespace LogConcaveSampling |
| open MeasureTheory ProbabilityTheory Function |
| open scoped Classical |
| |
| variable {d : ℕ} |
| |
| lemma integral_norm_le_sqrt_moment {E : Type*} [NormedAddCommGroup E] |
| [MeasurableSpace E] [BorelSpace E] {μ : Measure E} [IsProbabilityMeasure μ] |
| (hm : MemLp (fun x : E => x) 2 μ) : |
| (∫x,‖x‖ ∂μ)≤Real.sqrt (∫x,‖x‖^2 ∂μ) := by |
| have hh := integral_mul_sq_le hm.norm (memLp_const (1:ℝ) (μ:=μ)) |
| simp only [mul_one,one_pow,integral_const,probReal_univ,smul_eq_mul] at hh |
| exact (Real.le_sqrt (integral_nonneg (fun _ => norm_nonneg _)) |
| (integral_nonneg (fun _ => sq_nonneg _))).2 hh |
| |
| lemma Admissible.first_moment_bound {V : Point d → ℝ} (hV : Admissible V) : |
| Integrable (fun x => ‖x‖) (gibbs V) ∧ (∫x,‖x‖ ∂gibbs V)≤Real.sqrt d := by |
| let := hV.isProbabilityMeasure_gibbs |
| have hm : MemLp (fun x : Point d => x) 2 (gibbs V) := |
| (memLp_two_iff_integrable_sq_norm (by fun_prop)).2 hV.second_moment_bound.1 |
| exact ⟨hm.norm.integrable (by norm_num),(integral_norm_le_sqrt_moment hm).trans |
| (Real.sqrt_le_sqrt hV.second_moment_bound.2)⟩ |
| |
| lemma stdGaussian_first_moment_bound (d : ℕ) : |
| (∫x : Point d,‖x‖ ∂stdGaussian (Point d))≤Real.sqrt d := by |
| simpa only [stdGaussian_sq_norm] using |
| integral_norm_le_sqrt_moment (IsGaussian.memLp_two_id (μ:=stdGaussian (Point d))) |
| |
| lemma noisedLaw_first_moment {V : Point d → ℝ} (hV : Admissible V) (h : ℝ) : |
| Integrable (fun x => ‖x‖) (noisedLaw V h) ∧ |
| (∫x,‖x‖ ∂noisedLaw V h)≤(1+Real.sqrt h)*Real.sqrt d := by |
| let := hV.isProbabilityMeasure_gibbs |
| have hiX : Integrable (fun p : Point d × Point d => ‖p.1‖) |
| ((gibbs V).prod (stdGaussian (Point d))) := hV.first_moment_bound.1.comp_fst _ |
| have hiG : Integrable (fun p : Point d × Point d => ‖p.2‖) |
| ((gibbs V).prod (stdGaussian (Point d))) := |
| (IsGaussian.memLp_two_id (μ:=stdGaussian (Point d))).norm.integrable (by norm_num) |>.comp_snd _ |
| have hi : Integrable (fun p : Point d × Point d => ‖p.1+Real.sqrt h • p.2‖) |
| ((gibbs V).prod (stdGaussian (Point d))) := |
| (hiX.add (hiG.const_mul (Real.sqrt h))).mono' (by fun_prop) (Filter.Eventually.of_forall (fun p => by |
| rw [Real.norm_eq_abs,abs_of_nonneg (norm_nonneg _)] |
| change ‖p.1+Real.sqrt h • p.2‖≤‖p.1‖+Real.sqrt h*‖p.2‖ |
| simpa only [norm_smul,Real.norm_eq_abs,abs_of_nonneg (Real.sqrt_nonneg _)] using |
| norm_add_le p.1 (Real.sqrt h • p.2))) |
| refine ⟨(integrable_map_measure (by fun_prop) (by fun_prop)).2 hi,?_⟩ |
| rw [noisedLaw,integral_map (by fun_prop) (by fun_prop)] |
| calc |
| _ ≤ ∫p : Point d × Point d,‖p.1‖+Real.sqrt h*‖p.2‖ ∂((gibbs V).prod (stdGaussian (Point d))) := by |
| apply integral_mono hi (hiX.add (hiG.const_mul _)) |
| intro p |
| change ‖p.1+Real.sqrt h • p.2‖≤‖p.1‖+Real.sqrt h*‖p.2‖ |
| simpa only [norm_smul,Real.norm_eq_abs,abs_of_nonneg (Real.sqrt_nonneg _)] using |
| norm_add_le p.1 (Real.sqrt h • p.2) |
| _ = (∫x,‖x‖ ∂gibbs V)+Real.sqrt h*(∫x : Point d,‖x‖ ∂stdGaussian (Point d)) := by |
| rw [integral_add hiX (hiG.const_mul _),integral_const_mul] |
| simp only [integral_fun_fst,integral_fun_snd,probReal_univ,one_smul] |
| _ ≤ Real.sqrt d+Real.sqrt h*Real.sqrt d := by |
| exact add_le_add hV.first_moment_bound.2 |
| (mul_le_mul_of_nonneg_left (stdGaussian_first_moment_bound d) (Real.sqrt_nonneg _)) |
| _ = _ := by ring |
| |
| end LogConcaveSampling |
| |
| end |
| |
| end |
| |
| section |
| |
| noncomputable section |
| namespace LogConcaveSampling |
| open MeasureTheory ProbabilityTheory Function |
| open scoped Classical ENNReal RealInnerProductSpace |
| |
| variable {d : ℕ} |
| |
| lemma Admissible.value_difference_bound {V : Point d → ℝ} (hV : Admissible V) |
| (x g : Point d) {s : ℝ} (hs : 0 ≤ s) : |
| |V (x+s • g)-V x|≤ s*‖x‖^2+(s+s^2)*‖g‖^2 := by |
| have ht := quadratic_remainder_of_gradient_lipschitz hV.smooth hV.gradient_lipschitz x (s • g) |
| have hi := abs_real_inner_le_norm (s • g) (gradient V x) |
| have hg := hV.gradient_norm_le x |
| simp only [norm_smul,Real.norm_eq_abs,abs_of_nonneg hs,NNReal.coe_ofNat] at ht hi |
| have hh := abs_add_le (V (x+s • g)-V x-inner ℝ (s • g) (gradient V x)) |
| (inner ℝ (s • g) (gradient V x)) |
| have hm := mul_le_mul_of_nonneg_left hg (mul_nonneg hs (norm_nonneg g)) |
| have hsq := mul_nonneg hs (sq_nonneg (‖x‖-‖g‖)) |
| ring_nf at hh |
| nlinarith |
| |
| theorem noisedLaw_tv {V : Point d → ℝ} (hV : Admissible V) {h : ℝ} (hh : 0<h) : |
| TVAtMost (noisedLaw V h) (gibbs V) (2*(2*Real.sqrt h+h)*d) := by |
| let := hV.isProbabilityMeasure_gibbs |
| have hVm := hV.smooth.continuous.measurable |
| let := jointPosteriorLaw_probability hV h |
| let H := fun p : Point d × Point d => -V p.1-‖p.2-p.1‖^2/(2*h) |
| let c := (partition V)⁻¹*EulerDensity.noiseCoefficient d (Real.sqrt h) |
| have hm : Measurable H := by have := hV.smooth.continuous.measurable; dsimp [H]; fun_prop |
| have hc0 : c≠0 := mul_ne_zero (ENNReal.inv_ne_zero.mpr hV.partition_ne_top) |
| (EulerDensity.noiseCoefficient_positive d (Real.sqrt_pos.mpr hh).ne').ne' |
| have hct : c≠⊤ := ENNReal.mul_ne_top (ENNReal.inv_ne_top.mpr hV.partition_pos.ne') |
| (EulerDensity.noiseCoefficient_finite _ _) |
| have hd : jointPosteriorLaw V h=MetropolisBalance.densityLaw volume c H := by |
| have hd := EulerDensity.joint_density hV.smooth.continuous.measurable |
| (fun z : Point d => z) measurable_id (Real.sqrt_pos.mpr hh).ne' |
| simpa only [jointPosteriorLaw,MetropolisBalance.densityLaw,c,H,Real.sq_sqrt hh.le] using hd |
| have he (p : Point d × Point d) : |H (p.1,p.1+Real.sqrt h • p.2)-H (p.1+Real.sqrt h • p.2,p.1)| |
| =|V (p.1+Real.sqrt h • p.2)-V p.1| := by |
| dsimp [H] |
| rw [norm_sub_rev p.1 (p.1+Real.sqrt h • p.2)] |
| congr 1 |
| ring |
| let b := fun p : Point d × Point d => Real.sqrt h*‖p.1‖^2+(Real.sqrt h+h)*‖p.2‖^2 |
| have hib : Integrable b ((gibbs V).prod (stdGaussian (Point d))) := |
| (hV.second_moment_bound.1.comp_fst _ |>.const_mul _).add |
| (((memLp_two_iff_integrable_sq_norm (by fun_prop)).mp (IsGaussian.memLp_two_id (μ:=stdGaussian (Point d)))).comp_snd _ |>.const_mul _) |
| have hb (p : Point d × Point d) : |V (p.1+Real.sqrt h • p.2)-V p.1|≤b p := by |
| simpa only [Real.sq_sqrt hh.le] using hV.value_difference_bound p.1 p.2 (Real.sqrt_nonneg h) |
| have hir : Integrable (fun p : Point d × Point d => |H p-H p.swap|) (jointPosteriorLaw V h) := by |
| apply (integrable_map_measure (by fun_prop) (by fun_prop)).2 |
| apply hib.mono' (by fun_prop) |
| exact Filter.Eventually.of_forall (fun p => by simpa only [comp_apply,Prod.swap_prod_mk,Real.norm_eq_abs,abs_abs,he] using hb p) |
| have hr : (∫p,|H p-H p.swap| ∂jointPosteriorLaw V h)≤(2*Real.sqrt h+h)*d := by |
| rw [jointPosteriorLaw,integral_map (by fun_prop) (by fun_prop)] |
| simp only [Prod.swap_prod_mk] |
| simp_rw [he] |
| have hi : Integrable (fun p : Point d × Point d => |V (p.1+Real.sqrt h • p.2)-V p.1|) |
| ((gibbs V).prod (stdGaussian (Point d))) := |
| hib.mono' (by fun_prop) (Filter.Eventually.of_forall (fun p => by simpa only [Real.norm_eq_abs,abs_abs] using hb p)) |
| calc |
| _ ≤ ∫p,b p ∂((gibbs V).prod (stdGaussian (Point d))) := integral_mono hi hib hb |
| _ = Real.sqrt h*(∫x,‖x‖^2 ∂gibbs V)+(Real.sqrt h+h)*d := by |
| dsimp only [b] |
| rw [integral_add] |
| · rw [integral_const_mul,integral_const_mul,integral_fun_fst (fun x : Point d => ‖x‖^2),integral_fun_snd (fun x : Point d => ‖x‖^2)] |
| simp only [probReal_univ,one_smul,stdGaussian_sq_norm] |
| · exact hV.second_moment_bound.1.comp_fst _ |>.const_mul _ |
| · simpa only [id_eq] using ((memLp_two_iff_integrable_sq_norm (by fun_prop)).mp (IsGaussian.memLp_two_id (μ:=stdGaussian (Point d)))).comp_snd ((gibbs V)) |>.const_mul (Real.sqrt h+h) |
| _ ≤ _ := by nlinarith [mul_le_mul_of_nonneg_left hV.second_moment_bound.2 (Real.sqrt_nonneg h)] |
| let : IsFiniteMeasure (MetropolisBalance.densityLaw volume c H) := hd ▸ inferInstance |
| intro A hA |
| let f : Point d → ℝ := A.indicator (fun _ => 1) |
| have hf : Measurable f := measurable_const.indicator hA |
| have hbf (x) : |f x|≤1 := by by_cases hx : x∈A <;> simp [f,hx] |
| have ht := MetropolisBalance.probability_one_step_defect volume hm hc0 hct |
| (hd ▸ hir) hf (by norm_num : (0:ℝ)≤1) hbf |
| rw [←hd] at ht |
| have hs : (∫p : Point d × Point d,f p.2 ∂jointPosteriorLaw V h)=(noisedLaw V h).real A := by |
| rw [←jointPosterior_snd (V:=V) h,←integral_map measurable_snd.aemeasurable hf.aestronglyMeasurable] |
| simp only [f,integral_indicator hA,setIntegral_const,smul_eq_mul,mul_one] |
| have ht' : (∫p : Point d × Point d,f p.1 ∂jointPosteriorLaw V h)=(gibbs V).real A := by |
| rw [←jointPosterior_fst (V:=V) h,←integral_map measurable_fst.aemeasurable hf.aestronglyMeasurable] |
| simp only [f,integral_indicator hA,setIntegral_const,smul_eq_mul,mul_one] |
| rw [hs,ht'] at ht |
| nlinarith |
| |
| end LogConcaveSampling |
| |
| end |
| |
| end |
| |
| section |
| |
| noncomputable section |
| namespace LogConcaveSampling |
| open MeasureTheory ProbabilityTheory Function |
| open scoped Classical |
| |
| variable {d : ℕ} |
| |
| def descentScale (h : ℝ) (j : ℕ) : ℝ := h/2^j |
| lemma descentScale_pos {h : ℝ} (hh : 0<h) (j : ℕ) : 0<descentScale h j := by unfold descentScale; positivity |
| lemma descentScale_le {h : ℝ} (hh : 0≤h) (j : ℕ) : descentScale h j≤h := by |
| exact div_le_self hh (one_le_pow₀ (by norm_num)) |
| @[simp] lemma descentScale_zero (h : ℝ) : descentScale h 0=h := by simp [descentScale] |
| lemma descentScale_succ (h : ℝ) (j : ℕ) : descentScale h (j+1)=descentScale h j/2 := by simp [descentScale,pow_succ,div_div] |
| |
| lemma halving_chain_error {V : Point d → ℝ} (hV : Admissible V) {h e : ℝ} |
| (hh : 0<h) (hh1 : h≤1) (he : 0≤e) |
| (κ : ℕ → Kernel (Point d) (Point d)) [∀j,IsMarkovKernel (κ j)] |
| (hc : ∀j x,TVAtMost (κ j x) (halvingKernel V hV (descentScale h j) x) |
| (2*e*(Real.sqrt d+2*Real.sqrt (descentScale h j)*‖x‖))) (j : ℕ) : |
| TVAtMost (changingChain κ (noisedLaw V h) j) (noisedLaw V (descentScale h j)) |
| (j*(10*e*Real.sqrt d)) := by |
| let := noisedLaw_probability hV h |
| induction j with |
| | zero => intro A hA; simp [changingChain] |
| | succ j ih => |
| let hj := descentScale h j |
| have hjp : 0<hj := descentScale_pos hh j |
| have hj1 : hj≤1 := (descentScale_le hh.le j).trans hh1 |
| have hs : Real.sqrt hj≤1 := by simpa using Real.sqrt_le_sqrt hj1 |
| let := noisedLaw_probability hV hj |
| let := halvingKernel_markov hV hjp |
| let ei := fun x : Point d => 2*e*(Real.sqrt d+2*Real.sqrt hj*‖x‖) |
| have hei : Integrable ei (noisedLaw V hj) := by |
| exact ((integrable_const _).add ((noisedLaw_first_moment hV hj).1.const_mul _)).const_mul _ |
| have heint : (∫x,ei x ∂noisedLaw V hj)≤10*e*Real.sqrt d := by |
| have hx := (noisedLaw_first_moment hV hj).2 |
| have hx' : (∫x,‖x‖ ∂noisedLaw V hj)≤2*Real.sqrt d := by |
| nlinarith [Real.sqrt_nonneg (d:ℝ)] |
| have hxs : Real.sqrt hj*(∫x,‖x‖ ∂noisedLaw V hj)≤2*Real.sqrt d := by |
| exact (mul_le_mul_of_nonneg_right hs (integral_nonneg (fun _ => norm_nonneg _))).trans (by simpa using hx') |
| dsimp only [ei] |
| rw [integral_const_mul,integral_add (integrable_const _) ((noisedLaw_first_moment hV hj).1.const_mul _),integral_const_mul] |
| simp only [integral_const,probReal_univ,smul_eq_mul,one_mul] |
| nlinarith |
| have hl := TVAtMost.kernel_mixture (noisedLaw V hj) (κ j) (halvingKernel V hV hj) hei (hc j) |
| rw [halvingKernel_invariant hV hjp] at hl |
| have ht := (ih.kernel (κ j)).trans hl |
| change TVAtMost _ (noisedLaw V (hj/2)) _ at ht |
| rw [changingChain,descentScale_succ] |
| apply ht.mono |
| push_cast |
| nlinarith |
| |
| namespace OracleCompiler |
| lemma approximateHalvingKernel_program (S : ReservedProgram d) (h : ℝ) |
| {V : Point d → ℝ} (hV : Admissible V) (x : Point d) : |
| approximateHalvingKernel S h V hV x=(gaussianTape d S.full.slots).map |
| (fun g => (halvingProgram S h).run V (x,g)) := by |
| have hm : Measurable (fun g => (proximalProgram S h).run V (x,g)) := |
| ((proximalProgram S h).measurable_run V hV.continuous_firstOrderReply.measurable).comp (by fun_prop) |
| rw [approximateHalvingKernel_apply,approximateProximalKernel_apply,Measure.map_map (by fun_prop) hm] |
| congr 1 |
| funext g |
| rw [halvingProgram,Program.map_run] |
| rfl |
| end OracleCompiler |
| end LogConcaveSampling |
| |
| end |
| |
| end |
| |
| end OAI |
| |
