| import Mathlib |
| import OAI.Probability.LogConcave.Numerics.Correction |
|
|
| namespace OAI |
|
|
| section |
| section |
| noncomputable section |
| namespace LogConcaveSampling.FinitePicard |
| open MeasureTheory |
| open scoped BigOperators NNReal RealInnerProductSpace |
|
|
| variable {Ω E I : Type*} [MeasurableSpace Ω] {ν : Measure Ω} [IsFiniteMeasure ν] |
| [NormedAddCommGroup E] |
|
|
| lemma lipschitz_zero_shift {K : ℝ≥0} {φ : E → E} (hφ : LipschitzWith K φ) : |
| LipschitzWith K (fun x => φ x-φ 0) := by |
| apply LipschitzWith.of_dist_le_mul |
| intro x y |
| simpa only [dist_sub_right] using hφ.dist_le_mul x y |
|
|
| def nodeLp {K : ℝ≥0} {φ : E → E} (hφ : LipschitzWith K φ) (f : Lp E 2 ν) : Lp E 2 ν := |
| (lipschitz_zero_shift hφ).compLp (by simp) f + Lp.const 2 ν (φ 0) |
|
|
| lemma nodeLp_ae {K : ℝ≥0} {φ : E → E} (hφ : LipschitzWith K φ) (f : Lp E 2 ν) : |
| (nodeLp hφ f : Ω → E)=ᵐ[ν] fun z => φ (f z) := by |
| filter_upwards [Lp.coeFn_add ((lipschitz_zero_shift hφ).compLp (by simp) f) |
| (Lp.const 2 ν (φ 0)), |
| (lipschitz_zero_shift hφ).coeFn_compLp (by simp) f, |
| Lp.coeFn_const 2 ν (φ 0)] with z hz hφz hc |
| simp only [nodeLp,hz,Pi.add_apply,hφz,Function.comp_apply,hc,Function.const_apply,sub_add_cancel] |
|
|
| lemma nodeLp_lipschitz {K : ℝ≥0} {φ : E → E} (hφ : LipschitzWith K φ) : |
| LipschitzWith K (nodeLp (ν:=ν) hφ) := by |
| apply LipschitzWith.of_dist_le_mul |
| intro f g |
| simpa only [nodeLp,dist_add_right] using |
| ((lipschitz_zero_shift hφ).lipschitzWith_compLp (by simp)).dist_le_mul f g |
|
|
| variable [NormedSpace ℝ E] [Fintype I] |
|
|
| def stepLp (w : I → I → ℝ) (φ : I → E → E) {K : ℝ≥0} |
| (hφ : ∀i,LipschitzWith K (φ i)) (a z : I → Lp E 2 ν) : I → Lp E 2 ν := |
| step w (fun j => nodeLp (hφ j)) a z |
|
|
| lemma stepLp_lipschitz (w : I → I → ℝ) (φ : I → E → E) {A K : ℝ≥0} |
| (hφ : ∀i,LipschitzWith K (φ i)) (a : I → Lp E 2 ν) |
| (hw : ∀i,∑j,|w i j|≤A) : LipschitzWith (A*K) (stepLp w φ hφ a) := |
| step_lipschitz w _ a hw (fun j => nodeLp_lipschitz (hφ j)) |
|
|
| lemma stepLp_ae (w : I → I → ℝ) (φ : I → E → E) {K : ℝ≥0} |
| (hφ : ∀i,LipschitzWith K (φ i)) (a z : I → Lp E 2 ν) (i : I) : |
| (stepLp w φ hφ a z i : Ω → E)=ᵐ[ν] |
| fun ω => step w φ (fun j => a j ω) (fun j => z j ω) i := by |
| classical |
| have ha := Lp.coeFn_add (a i) (∑j,w i j • nodeLp (hφ j) (z j)) |
| have hs := Lp.coeFn_fun_finsetSum Finset.univ (fun j => w i j • nodeLp (hφ j) (z j)) |
| have hm : ∀ᵐω ∂ν,∀j,(w i j • nodeLp (hφ j) (z j) : Lp E 2 ν) ω= |
| w i j • φ j (z j ω) := by |
| rw [ae_all_iff] |
| intro j |
| filter_upwards [Lp.coeFn_smul (w i j) (nodeLp (hφ j) (z j)),nodeLp_ae (hφ j) (z j)] with ω h1 h2 |
| simp only [h1,Pi.smul_apply,h2] |
| filter_upwards [ha,hs,hm] with ω h1 h2 h3 |
| simp only [stepLp,step,correction,Pi.add_apply,h1,h2,h3] |
|
|
| theorem rms_picard_defect (w : I → I → ℝ) (φ : I → E → E) {A K : ℝ≥0} |
| (hφ : ∀i,LipschitzWith K (φ i)) (a e : I → Lp E 2 ν) |
| (hw : ∀i,∑j,|w i j|≤A) (hq : (A*K:ℝ≥0)≤1/2) |
| {D : ℝ} (hD : 0≤D) (he : ∀i,dist (stepLp w φ hφ a e i) (e i)≤D) (n : ℕ) : |
| dist ((stepLp w φ hφ a)^[n] a) e≤2*D+(A*K:ℝ≥0)^n*dist a e := by |
| apply iterate_defect (stepLp_lipschitz w φ hφ a hw) (by exact_mod_cast hq) a e hD |
| ((dist_pi_le_iff hD).mpr he) n |
|
|
| section Inner |
| omit [NormedSpace ℝ E] [IsFiniteMeasure ν] |
| variable [InnerProductSpace ℝ E] |
|
|
| lemma lp_norm_sq_integral (f : Lp E 2 ν) : ‖f‖^2=∫ω,‖f ω‖^2 ∂ν := by |
| rw [←real_inner_self_eq_norm_sq,L2.inner_def] |
| simp only [real_inner_self_eq_norm_sq] |
|
|
| lemma nodewise_rms_le {f g : Lp E 2 ν} {B : ℝ} (hB : 0≤B) |
| (h : (∫ω,‖f ω-g ω‖^2 ∂ν)≤B^2) : dist f g≤B := by |
| rw [dist_eq_norm] |
| have he : ‖f-g‖^2=∫ω,‖f ω-g ω‖^2 ∂ν := by |
| rw [lp_norm_sq_integral] |
| apply integral_congr_ae |
| filter_upwards [Lp.coeFn_sub f g] with ω hω |
| simp only [hω,Pi.sub_apply] |
| nlinarith [norm_nonneg (f-g)] |
| end Inner |
| end LogConcaveSampling.FinitePicard |
|
|
| end |
|
|
| end |
|
|
| section |
|
|
| noncomputable section |
| namespace LogConcaveSampling.FinitePicard |
| open MeasureTheory |
| open scoped BigOperators NNReal RealInnerProductSpace |
|
|
| variable {Ω E I : Type*} [MeasurableSpace Ω] {ν : Measure Ω} [IsFiniteMeasure ν] |
| [NormedAddCommGroup E] [InnerProductSpace ℝ E] [Fintype I] |
|
|
| omit [IsFiniteMeasure ν] in |
| lemma lp_rms_eq (f g : Lp E 2 ν) {u v : Ω → E} |
| (hf : (f : Ω → E)=ᵐ[ν] u) (hg : (g : Ω → E)=ᵐ[ν] v) : |
| Integrable (fun ω => ‖u ω-v ω‖^2) ν ∧ |
| (∫ω,‖u ω-v ω‖^2 ∂ν)=dist f g^2 := by |
| have he : (fun ω => (f-g : Lp E 2 ν) ω)=ᵐ[ν] fun ω => u ω-v ω := by |
| filter_upwards [Lp.coeFn_sub f g,hf,hg] with ω h1 h2 h3 |
| simp only [h1,Pi.sub_apply,h2,h3] |
| have hi := (Lp.memLp (f-g)).integrable_norm_pow (by norm_num : (2:ℕ)≠0) |
| have hn : (fun ω => ‖(f-g : Lp E 2 ν) ω‖^2)=ᵐ[ν] fun ω => ‖u ω-v ω‖^2 := |
| he.fun_comp (fun z => ‖z‖^2) |
| refine ⟨hi.congr hn,?_⟩ |
| rw [dist_eq_norm,lp_norm_sq_integral] |
| exact integral_congr_ae hn.symm |
|
|
| lemma iterateLp_nodes_ae (w : I → I → ℝ) (φ : I → E → E) {K : ℝ≥0} |
| (hφ : ∀i,LipschitzWith K (φ i)) (a : I → Ω → E) (aLp : I → Lp E 2 ν) |
| (ha : ∀i,(aLp i : Ω → E)=ᵐ[ν] a i) (N : ℕ) (i : I) : |
| ((stepLp w φ hφ aLp)^[N] aLp i : Ω → E)=ᵐ[ν] |
| fun ω => nodes w φ (fun ω j => a j ω) N ω i := by |
| induction N generalizing i with |
| | zero => simpa only [Function.iterate_zero_apply,nodes] using ha i |
| | succ N ih => |
| rw [Function.iterate_succ_apply'] |
| have hia : ∀ᵐω ∂ν,∀j,aLp j ω=a j ω := ae_all_iff.mpr ha |
| have hii : ∀ᵐω ∂ν,∀j,((stepLp w φ hφ aLp)^[N] aLp j : Ω → E) ω= |
| nodes w φ (fun ω j => a j ω) N ω j := ae_all_iff.mpr ih |
| filter_upwards [stepLp_ae w φ hφ aLp ((stepLp w φ hφ aLp)^[N] aLp) i,hia,hii] with ω h1 h2 h3 |
| simp only [h1,nodes,step,correction,Pi.add_apply,h2,h3] |
|
|
| theorem nodes_rms (w : I → I → ℝ) (φ : I → E → E) {A K : ℝ≥0} |
| (hφ : ∀i,LipschitzWith K (φ i)) (a e : I → Ω → E) |
| (ha : ∀i,MemLp (a i) 2 ν) (he : ∀i,MemLp (e i) 2 ν) |
| (hw : ∀i,∑j,|w i j|≤A) (hq : (A*K:ℝ≥0)≤1/2) |
| {D H : ℝ} (hD : 0≤D) (hH : 0≤H) |
| (hdef : ∀i,(∫ω,‖step w φ (fun j => a j ω) (fun j => e j ω) i-e i ω‖^2 ∂ν)≤D^2) |
| (hinit : ∀i,(∫ω,‖a i ω-e i ω‖^2 ∂ν)≤H^2) (N : ℕ) (i : I) : |
| Integrable (fun ω => ‖nodes w φ (fun ω j => a j ω) N ω i-e i ω‖^2) ν ∧ |
| (∫ω,‖nodes w φ (fun ω j => a j ω) N ω i-e i ω‖^2 ∂ν)≤ |
| (2*D+(A*K:ℝ≥0)^N*H)^2 := by |
| let aLp : I → Lp E 2 ν := fun j => (ha j).toLp (a j) |
| let eLp : I → Lp E 2 ν := fun j => (he j).toLp (e j) |
| have ha' (j : I) : (aLp j : Ω → E)=ᵐ[ν] a j := (ha j).coeFn_toLp |
| have he' (j : I) : (eLp j : Ω → E)=ᵐ[ν] e j := (he j).coeFn_toLp |
| have hstep (j : I) : (stepLp w φ hφ aLp eLp j : Ω → E)=ᵐ[ν] |
| fun ω => step w φ (fun i => a i ω) (fun i => e i ω) j := by |
| filter_upwards [stepLp_ae w φ hφ aLp eLp j,ae_all_iff.mpr ha',ae_all_iff.mpr he'] with ω h1 h2 h3 |
| simpa only [h2,h3] using h1 |
| have hdef' (j : I) : dist (stepLp w φ hφ aLp eLp j) (eLp j)≤D := by |
| have hh := (lp_rms_eq _ _ (hstep j) (he' j)).2 |
| have hb := hdef j |
| rw [hh] at hb |
| nlinarith [dist_nonneg (x:=stepLp w φ hφ aLp eLp j) (y:=eLp j)] |
| have hinit' : dist aLp eLp≤H := by |
| apply (dist_pi_le_iff hH).mpr |
| intro j |
| have hh := (lp_rms_eq _ _ (ha' j) (he' j)).2 |
| have hb := hinit j |
| rw [hh] at hb |
| nlinarith [dist_nonneg (x:=aLp j) (y:=eLp j)] |
| have hb := rms_picard_defect w φ hφ aLp eLp hw hq hD hdef' N |
| have hrms := lp_rms_eq _ _ (iterateLp_nodes_ae w φ hφ a aLp ha' N i) (he' i) |
| refine ⟨hrms.1,?_⟩ |
| rw [hrms.2] |
| apply pow_le_pow_left₀ dist_nonneg _ 2 |
| exact (dist_le_pi_dist _ _ i).trans (hb.trans |
| (add_le_add le_rfl (mul_le_mul_of_nonneg_left hinit' (show 0≤((A*K:ℝ≥0):ℝ)^N from by positivity)))) |
| end LogConcaveSampling.FinitePicard |
|
|
| end |
|
|
| end |
|
|
| end |
|
|
| end OAI |
|
|
