Download data/lean/OAI/Probability/LogConcave/JetEstimates/SpaceBasis.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 25.9 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Probability/LogConcave/JetEstimates/SpaceBasis.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Probability/LogConcave/JetEstimates/SpaceBasis.lean
-
curl -L -o SpaceBasis.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Probability/LogConcave/JetEstimates/SpaceBasis.lean
25.9 kB
| import Mathlib | |
| import OAI.Probability.LogConcave.Sampling.MaterialScalar | |
| import OAI.Probability.LogConcave.JetEstimates.Mdir | |
| import OAI.Probability.LogConcave.Sampling.SmoothTimeLocalization | |
| import OAI.Probability.LogConcave.Analysis.GaussianMarginalLowerTail | |
| import OAI.Probability.LogConcave.Sampling.DirectionalBasisSum | |
| namespace OAI | |
| section | |
| section | |
| noncomputable section | |
| namespace LogConcaveSampling | |
| open MeasureTheory | |
| open scoped Classical BigOperators NNReal RealInnerProductSpace | |
| lemma PolySmooth.linear {d : β} (L : Point d βL[β] β) : PolySmooth L := by | |
| apply PolySmooth.of_basis_growth L.contDiff | |
| intro l | |
| cases l with | |
| | nil => exact growth_of_lipschitz L.lipschitzWith | |
| | cons i l => | |
| change HasPolynomialGrowth (LogConcaveSampling.directional (EuclideanSpace.basisFun (Fin d) β i) | |
| (JetCalculus.jet (EuclideanSpace.basisFun (Fin d) β) l L)) | |
| rw [βjet_directional L.contDiff] | |
| have he : LogConcaveSampling.directional (EuclideanSpace.basisFun (Fin d) β i) L= | |
| fun _ => L (EuclideanSpace.basisFun (Fin d) β i) := by | |
| funext y | |
| simp [LogConcaveSampling.directional] | |
| rw [he,JetCalculus.jet_const] | |
| split_ifs <;> exact growth_const _ | |
| lemma growth_potential_of_gradient_lipschitz {d : β} {H : Point d β β} {K : ββ₯0} | |
| (hH : ContDiff β 2 H) (hK : LipschitzWith K (gradient H)) : HasPolynomialGrowth H := by | |
| let C := |H 0|+βgradient H 0β+(K:β)+1 | |
| have hC : 0β€C := by dsimp [C]; positivity | |
| refine β¨C,hC,2,fun y => ?_β© | |
| have ht := quadratic_remainder_of_gradient_lipschitz hH hK 0 y | |
| rw [zero_add] at ht | |
| have hi := abs_real_inner_le_norm y (gradient H 0) | |
| have hb : |H y|β€|H 0|+βyβ*βgradient H 0β+(K:β)*βyβ^2/2 := by | |
| have he : H y=(H y-H 0-inner β y (gradient H 0))+H 0+inner β y (gradient H 0) := by ring | |
| calc | |
| |H y| = |(H y-H 0-inner β y (gradient H 0))+H 0+inner β y (gradient H 0)| := congrArg abs he | |
| _ β€ |H y-H 0-inner β y (gradient H 0)|+|H 0|+|inner β y (gradient H 0)| := | |
| (abs_add_le _ _).trans (add_le_add (abs_add_le _ _) le_rfl) | |
| _ β€ _ := by linarith | |
| have hy : βyββ€1+βyβ^2 := by nlinarith [sq_nonneg (βyβ-1)] | |
| have hh := mul_le_mul_of_nonneg_right hy (norm_nonneg (gradient H 0)) | |
| change βH yββ€C*(1+βyβ^2) | |
| rw [Real.norm_eq_abs] | |
| dsimp [C] | |
| nlinarith [mul_nonneg (abs_nonneg (H 0)) (sq_nonneg βyβ), | |
| mul_nonneg (show (0:β)β€K from K.coe_nonneg) (sq_nonneg βyβ)] | |
| lemma interpolationPotential_polySmooth {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) : | |
| PolySmooth (interpolationPotential F x r Ο) := by | |
| have hs := interpolationPotential_smooth hF x hr.le hl hΟ0 hΟ1 | |
| apply PolySmooth.of_basis_growth hs | |
| intro l | |
| cases l with | |
| | nil => | |
| exact growth_potential_of_gradient_lipschitz (hs.of_le (WithTop.coe_le_coe.mpr (show (2:ββ)β€β€ from le_top))) | |
| (interpolationPotential_gradient_lipschitz hF x hr.le hl hΟ0 hΟ1) | |
| | cons i l => | |
| let v := EuclideanSpace.basisFun (Fin d) β i | |
| change HasPolynomialGrowth (directional v | |
| (JetCalculus.jet (EuclideanSpace.basisFun (Fin d) β) l (interpolationPotential F x r Ο))) | |
| rw [βjet_directional hs] | |
| have he : directional v (interpolationPotential F x r Ο)=fun y => | |
| inner β v y+(r*Ο)*inner β v (conditionalFieldMean F x r Ο y) := by | |
| funext y | |
| rw [directional_gradient,interpolationPotential_gradient hF x hr.le hl hΟ0 hΟ1, | |
| real_inner_comm,inner_add_right,inner_smul_right] | |
| rw [he] | |
| exact ((PolySmooth.linear (innerSL β v)).add ((PolySmooth.const (r*Ο)).mul | |
| (conditionalFieldMean_component_polySmooth hF x hr hlam hl hΟ0 hΟ1 i))).jet_growth _ l | |
| end LogConcaveSampling | |
| end | |
| end | |
| section | |
| noncomputable section | |
| namespace LogConcaveSampling | |
| open scoped Classical BigOperators RealInnerProductSpace NNReal | |
| namespace JetCalculus | |
| variable {E : Type*} [NormedAddCommGroup E] [NormedSpace β E] | |
| lemma dir_right_slice_at {A : β Γ E β β} {t : β} {y : E} | |
| (hA : DifferentiableAt β A (t,y)) (v : E) : | |
| dir v (fun z => A (t,z)) y=dir (0,v) A (t,y) := by | |
| have hh := hA.hasFDerivAt.comp y ((hasFDerivAt_const t y).prodMk (hasFDerivAt_id y)) | |
| unfold dir | |
| change (fderiv β (A β Prod.mk t) y) v=_ | |
| rw [hh.fderiv] | |
| simp | |
| lemma dir_left_slice_at {A : β Γ E β β} {t : β} {y : E} | |
| (hA : DifferentiableAt β A (t,y)) : | |
| deriv (fun s => A (s,y)) t=dir (1,0) A (t,y) := by | |
| have hh := hA.hasFDerivAt.comp_hasDerivAt t | |
| ((hasDerivAt_id t).prodMk (hasDerivAt_const t y)) | |
| exact hh.deriv | |
| end JetCalculus | |
| lemma joint_mdir_eq_material {d : β} (F : Point d β β) (x : Point d) (r : β) | |
| {A : β Γ Point d β β} {Ο : β} {y : Point d} | |
| (hA : DifferentiableAt β A (Ο,y)) : | |
| JetCalculus.mdir (1,0) (fun i => (0,EuclideanSpace.basisFun (Fin d) β i)) r | |
| (fun i p => inner β (EuclideanSpace.basisFun (Fin d) β i) | |
| (conditionalFieldMean F x r p.1 p.2)) A (Ο,y)= | |
| materialScalar F x r (fun t y => A (t,y)) Ο y := by | |
| unfold JetCalculus.mdir materialScalar | |
| rw [JetCalculus.dir_left_slice_at hA,directional_basis_sum] | |
| congr 2 | |
| apply Finset.sum_congr rfl | |
| intro i _ | |
| rw [βJetCalculus.dir_right_slice_at hA] | |
| simp only [OrthonormalBasis.repr_apply_apply] | |
| rfl | |
| lemma dir_inner_map {E : Type*} [NormedAddCommGroup E] [NormedSpace β E] | |
| {d : β} {A : E β Point d} {y : E} (hA : DifferentiableAt β A y) (u : Point d) (v : E) : | |
| JetCalculus.dir v (fun z => inner β u (A z)) y=inner β u ((fderiv β A y) v) := by | |
| unfold JetCalculus.dir | |
| change (fderiv β ((innerSL β u) β A) y) v=_ | |
| rw [((innerSL β u).hasFDerivAt.comp y hA.hasFDerivAt).fderiv] | |
| rfl | |
| theorem conditionalFieldMean_directional_symm {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 u v : Point d) : | |
| JetCalculus.dir v (fun y => inner β u (conditionalFieldMean F x r Ο y)) y= | |
| JetCalculus.dir u (fun y => inner β v (conditionalFieldMean F x r Ο y)) y := by | |
| have hm := (conditionalFieldMean_smooth hF x hr.le hl hΟ0.le hΟ1).differentiable (by simp) | |
| rw [dir_inner_map (hm y),dir_inner_map (hm y)] | |
| have hg : gradient (interpolationPotential F x r Ο)= | |
| fun y => y+(r*Ο) β’ conditionalFieldMean F x r Ο y := | |
| funext (interpolationPotential_gradient hF x hr.le hl hΟ0.le hΟ1) | |
| have hd : fderiv β (gradient (interpolationPotential F x r Ο)) y= | |
| ContinuousLinearMap.id β (Point d)+(r*Ο) β’ fderiv β (conditionalFieldMean F x r Ο) y := by | |
| rw [hg] | |
| exact ((hasFDerivAt_id y).add ((hm y).hasFDerivAt.const_smul (r*Ο))).fderiv | |
| have hsym := ContDiff.isSymmetric_gradient_derivative | |
| ((interpolationPotential_smooth hF x hr.le hl hΟ0.le hΟ1).of_le (by norm_cast)) y u v | |
| change inner β ((fderiv β (gradient (interpolationPotential F x r Ο)) y) u) v= | |
| inner β u ((fderiv β (gradient (interpolationPotential F x r Ο)) y) v) at hsym | |
| rw [hd] at hsym | |
| simp only [add_apply,smul_apply,ContinuousLinearMap.id_apply, | |
| inner_add_left,inner_add_right,real_inner_smul_left,inner_smul_right] at hsym | |
| rw [real_inner_comm v ((fderiv β (conditionalFieldMean F x r Ο) y) u)] at hsym | |
| have hp : 0<r*Ο := mul_pos hr hΟ0 | |
| nlinarith | |
| end LogConcaveSampling | |
| end | |
| end | |
| section | |
| noncomputable section | |
| namespace LogConcaveSampling.JetCalculus | |
| open scoped Classical BigOperators RealInnerProductSpace | |
| abbrev spaceBasis (d : β) := EuclideanSpace.basisFun (Fin d) β | |
| def linearScore {d : β} (i : Fin d) (y : Point d) : β := inner β (spaceBasis d i) y | |
| def euler {d : β} (f : Point d β β) (y : Point d) : β := | |
| βi,linearScore i y*dir (spaceBasis d i) f y | |
| lemma linearScore_smooth {d : β} (i : Fin d) : ContDiff β (β€:ββ) (linearScore i) := | |
| (innerSL β (spaceBasis d i)).contDiff | |
| lemma dir_linearScore {d : β} (i : Fin d) (v y : Point d) : | |
| dir v (linearScore i) y=inner β (spaceBasis d i) v := by | |
| change (fderiv β (innerSL β (spaceBasis d i)) y) v=_ | |
| rw [(innerSL β (spaceBasis d i)).fderiv] | |
| rfl | |
| lemma smooth_euler {d : β} {f : Point d β β} (hf : ContDiff β (β€:ββ) f) : | |
| ContDiff β (β€:ββ) (euler f) := | |
| ContDiff.sum fun i _ => (linearScore_smooth i).mul (smooth_dir hf _) | |
| lemma dir_euler {d : β} {f : Point d β β} (hf : ContDiff β (β€:ββ) f) (v : Point d) : | |
| dir v (euler f)=fun y => euler (dir v f) y+dir v f y := by | |
| unfold euler | |
| rw [dir_sum Finset.univ (fun i _ => ((linearScore_smooth i).mul (smooth_dir hf _)).differentiable (by simp))] | |
| simp_rw [dir_mul ((linearScore_smooth _).differentiable (by simp)) | |
| ((smooth_dir hf _).differentiable (by simp)),dir_dir hf v] | |
| funext y | |
| simp only [dir_linearScore,Finset.sum_add_distrib] | |
| have he : (βi,inner β (spaceBasis d i) v*dir (spaceBasis d i) f y)=dir v f y := by | |
| simpa only [OrthonormalBasis.repr_apply_apply,spaceBasis,dir,directional] using (congrFun (directional_basis_sum v f) y).symm | |
| rw [he] | |
| ring | |
| lemma jet_euler {d : β} {ΞΊ : Type*} {f : Point d β β} | |
| (hf : ContDiff β (β€:ββ) f) (v : ΞΊ β Point d) (l : List ΞΊ) : | |
| jet v l (euler f)=fun y => euler (jet v l f) y+(l.length:β)*jet v l f y := by | |
| induction l with | |
| | nil => simp [jet] | |
| | cons i l ih => | |
| simp only [jet,ih] | |
| rw [dir_add ((smooth_euler (smooth_jet hf v l)).differentiable (by simp)) | |
| ((contDiff_const.mul (smooth_jet hf v l)).differentiable (by simp)), | |
| dir_euler (smooth_jet hf v l),dir_const_mul ((smooth_jet hf v l).differentiable (by simp))] | |
| funext y | |
| simp only [List.length_cons,Nat.cast_add,Nat.cast_one] | |
| ring | |
| lemma gadj_linearScore {d : β} (f : Point d β β) : | |
| gadj (spaceBasis d) linearScore (fun i => dir (spaceBasis d i) f)= | |
| fun y => -(βi,dir (spaceBasis d i) (dir (spaceBasis d i) f) y)+euler f y := by | |
| funext y | |
| simp [gadj,cadj,euler,Finset.sum_add_distrib,Finset.sum_neg_distrib] | |
| lemma jet_gadj_linearScore {d : β} {ΞΊ : Type*} {f : Point d β β} | |
| (hf : ContDiff β (β€:ββ) f) (v : ΞΊ β Point d) (l : List ΞΊ) : | |
| jet v l (gadj (spaceBasis d) linearScore (fun i => dir (spaceBasis d i) f))= | |
| fun y => gadj (spaceBasis d) linearScore (fun i => dir (spaceBasis d i) (jet v l f)) y+ | |
| (l.length:β)*jet v l f y := by | |
| rw [gadj_linearScore] | |
| have hs : ContDiff β (β€:ββ) (fun y => βi,dir (spaceBasis d i) (dir (spaceBasis d i) f) y) := | |
| ContDiff.sum fun i _ => smooth_dir (smooth_dir hf _) _ | |
| have he : (fun y => -(βi,dir (spaceBasis d i) (dir (spaceBasis d i) f) y)+euler f y)= | |
| fun y => (-1)*(βi,dir (spaceBasis d i) (dir (spaceBasis d i) f) y)+euler f y := by | |
| funext y; ring | |
| rw [he,jet_add (contDiff_const.mul hs) (smooth_euler hf),jet_const_mul hs, | |
| jet_sum Finset.univ (fun i _ => smooth_dir (smooth_dir hf _) _),jet_euler hf,gadj_linearScore] | |
| simp_rw [jet_dir (smooth_dir hf _),jet_dir hf] | |
| funext y | |
| ring | |
| lemma gadj_perturb {d : β} (M : Fin d β Point d β β) (c : β) (f : Point d β β) : | |
| gadj (spaceBasis d) (fun i y => linearScore i y+c*M i y) (fun i => dir (spaceBasis d i) f)= | |
| fun y => gadj (spaceBasis d) linearScore (fun i => dir (spaceBasis d i) f) y+ | |
| c*βi,M i y*dir (spaceBasis d i) f y := by | |
| unfold gadj cadj | |
| funext y | |
| rw [Finset.mul_sum,βFinset.sum_add_distrib] | |
| apply Finset.sum_congr rfl | |
| intro i _ | |
| ring | |
| theorem jet_gadj_gradient {d : β} {ΞΊ : Type*} [DecidableEq ΞΊ] | |
| {M : Fin d β Point d β β} (hM : βi,ContDiff β (β€:ββ) (M i)) | |
| {f : Point d β β} (hf : ContDiff β (β€:ββ) f) (c : β) | |
| (v : ΞΊ β Point d) (l : List ΞΊ) (hl : l.Nodup) : | |
| jet v l (gadj (spaceBasis d) (fun i y => linearScore i y+c*M i y) | |
| (fun i => dir (spaceBasis d i) f))= | |
| fun y => gadj (spaceBasis d) (fun i y => linearScore i y+c*M i y) | |
| (fun i => dir (spaceBasis d i) (jet v l f)) y+ | |
| (l.length:β)*jet v l f y+ | |
| c*βsβl.toFinset.powerset.erase β ,βi, | |
| jet v (l.filter (fun j => jβs)) (M i) y* | |
| dir (spaceBasis d i) (jet v (l.filter (fun j => jβs)) f) y := by | |
| have hs : ContDiff β (β€:ββ) (fun y => βi,M i y*dir (spaceBasis d i) f y) := | |
| ContDiff.sum fun i _ => (hM i).mul (smooth_dir hf _) | |
| have hga : ContDiff β (β€:ββ) | |
| (gadj (spaceBasis d) linearScore (fun i => dir (spaceBasis d i) f)) := | |
| ContDiff.sum fun i _ => smooth_cadj _ (linearScore_smooth i) (smooth_dir hf _) | |
| rw [gadj_perturb,jet_add hga (contDiff_const.mul hs),jet_const_mul hs, | |
| jet_gadj_linearScore hf,jet_sum Finset.univ (fun i _ => (hM i).mul (smooth_dir hf _))] | |
| simp_rw [jet_mul (hM _) (smooth_dir hf _) v l hl,jet_dir hf] | |
| funext y | |
| rw [Finset.sum_comm,βFinset.add_sum_erase _ _ (by simp : (β :Finset ΞΊ)βl.toFinset.powerset)] | |
| simp only [Finset.notMem_empty,decide_false,List.filter_false,not_false_eq_true,decide_true,List.filter_true,jet] | |
| rw [gadj_perturb] | |
| ring | |
| end LogConcaveSampling.JetCalculus | |
| end | |
| end | |
| section | |
| noncomputable section | |
| namespace LogConcaveSampling.JetCalculus | |
| open scoped Classical BigOperators | |
| variable {E : Type*} [NormedAddCommGroup E] [NormedSpace β E] | |
| variable {ΞΉ : Type*} [Fintype ΞΉ] | |
| lemma smooth_dir_at {f : E β β} {p : E} (hf : ContDiffAt β (β€:ββ) f p) (v : E) : | |
| ContDiffAt β (β€:ββ) (dir v f) p := | |
| (hf.fderiv_right (by simp)).clm_apply contDiffAt_const | |
| lemma dir_dir_at {f : E β β} {p : E} (hf : ContDiffAt β (β€:ββ) f p) (v w : E) : | |
| dir v (dir w f) p=dir w (dir v f) p := by | |
| have hs : ContDiffAt β (β€:ββ) (fderiv β f) p := hf.fderiv_right (by simp) | |
| have hd := hs.differentiableAt (by simp) | |
| change (fderiv β (fun y => fderiv β f y w) p) v = | |
| (fderiv β (fun y => fderiv β f y v) p) w | |
| rw [fderiv_clm_apply hd (differentiableAt_const _), | |
| fderiv_clm_apply hd (differentiableAt_const _)] | |
| simpa only [add_apply,ContinuousLinearMap.comp_apply, | |
| zero_apply,ContinuousLinearMap.map_zero,zero_add, | |
| ContinuousLinearMap.flip_apply,fderiv_const_apply] using | |
| (hf.isSymmSndFDerivAt (by | |
| simp only [minSmoothness_of_isRCLikeNormedField] | |
| exact WithTop.coe_le_coe.mpr (show (2:ββ)β€β€ from le_top))).eq v w | |
| lemma dir_add_at {f g : E β β} {p : E} (hf : DifferentiableAt β f p) | |
| (hg : DifferentiableAt β g p) (v : E) : | |
| dir v (fun x => f x+g x) p=dir v f p+dir v g p := by | |
| unfold dir | |
| rw [show (fun x => f x+g x)=f+g from rfl,fderiv_add hf hg] | |
| rfl | |
| lemma dir_sub_at {f g : E β β} {p : E} (hf : DifferentiableAt β f p) | |
| (hg : DifferentiableAt β g p) (v : E) : | |
| dir v (fun x => f x-g x) p=dir v f p-dir v g p := by | |
| unfold dir | |
| rw [show (fun x => f x-g x)=f-g from rfl,fderiv_sub hf hg] | |
| rfl | |
| lemma dir_mul_at {f g : E β β} {p : E} (hf : DifferentiableAt β f p) | |
| (hg : DifferentiableAt β g p) (v : E) : | |
| dir v (fun x => f x*g x) p=dir v f p*g p+f p*dir v g p := by | |
| unfold dir | |
| rw [show (fun x => f x*g x)=f*g from rfl,(hf.hasFDerivAt.mul hg.hasFDerivAt).fderiv] | |
| simp only [add_apply,smul_apply,smul_eq_mul] | |
| ring | |
| lemma dir_const_mul_at {f : E β β} {p : E} (hf : DifferentiableAt β f p) (v : E) (c : β) : | |
| dir v (fun x => c*f x) p=c*dir v f p := by | |
| unfold dir | |
| rw [hf.hasFDerivAt.const_mul c |>.fderiv] | |
| rfl | |
| lemma dir_sum_at {N : Type*} (s : Finset N) {f : N β E β β} {p : E} | |
| (hf : βnβs,DifferentiableAt β (f n) p) (v : E) : | |
| dir v (fun x => βnβs,f n x) p=βnβs,dir v (f n) p := by | |
| simp only [dir,(HasFDerivAt.fun_sum (fun n hn => (hf n hn).hasFDerivAt)).fderiv,sum_apply] | |
| lemma smooth_mdir_at (w : E) (b : ΞΉ β E) (r : β) {M : ΞΉ β E β β} {f : E β β} {p : E} | |
| (hM : βi,ContDiffAt β (β€:ββ) (M i) p) (hf : ContDiffAt β (β€:ββ) f p) : | |
| ContDiffAt β (β€:ββ) (mdir w b r M f) p := | |
| (smooth_dir_at hf w).sub (contDiffAt_const.mul | |
| (ContDiffAt.sum fun i _ => (hM i).mul (smooth_dir_at hf _))) | |
| lemma mdir_sum_at {N : Type*} (s : Finset N) (w : E) (b : ΞΉ β E) (r : β) | |
| (M : ΞΉ β E β β) {f : N β E β β} {p : E} (hf : βnβs,DifferentiableAt β (f n) p) : | |
| mdir w b r M (fun p => βnβs,f n p) p=βnβs,mdir w b r M (f n) p := by | |
| unfold mdir | |
| simp_rw [dir_sum_at s hf] | |
| simp only [Finset.sum_sub_distrib,Finset.mul_sum] | |
| rw [Finset.sum_comm] | |
| lemma mdir_add_at (w : E) (b : ΞΉ β E) (r : β) (M : ΞΉ β E β β) | |
| {f g : E β β} {p : E} (hf : DifferentiableAt β f p) (hg : DifferentiableAt β g p) : | |
| mdir w b r M (fun p => f p+g p) p=mdir w b r M f p+mdir w b r M g p := by | |
| unfold mdir | |
| simp_rw [dir_add_at hf hg] | |
| simp only [mul_add,Finset.sum_add_distrib] | |
| ring | |
| lemma mdir_const_mul_at (w : E) (b : ΞΉ β E) (r : β) (M : ΞΉ β E β β) | |
| {f : E β β} {p : E} (hf : DifferentiableAt β f p) (c : β) : | |
| mdir w b r M (fun p => c*f p) p=c*mdir w b r M f p := by | |
| unfold mdir | |
| simp_rw [dir_const_mul_at hf] | |
| have he : (βi,M i p*(c*dir (b i) f p))=c*βi,M i p*dir (b i) f p := by | |
| rw [Finset.mul_sum] | |
| apply Finset.sum_congr rfl | |
| intro i _ | |
| ring | |
| rw [he] | |
| ring | |
| lemma mdir_mul_at (w : E) (b : ΞΉ β E) (r : β) (M : ΞΉ β E β β) | |
| {f g : E β β} {p : E} (hf : DifferentiableAt β f p) (hg : DifferentiableAt β g p) : | |
| mdir w b r M (fun p => f p*g p) p= | |
| mdir w b r M f p*g p+f p*mdir w b r M g p := by | |
| unfold mdir | |
| simp_rw [dir_mul_at hf hg] | |
| have he : (βi,M i p*(dir (b i) f p*g p+f p*dir (b i) g p))= | |
| (βi,M i p*dir (b i) f p)*g p+f p*βi,M i p*dir (b i) g p := by | |
| rw [Finset.mul_sum,Finset.sum_mul,βFinset.sum_add_distrib] | |
| apply Finset.sum_congr rfl | |
| intro i _ | |
| ring | |
| rw [he] | |
| ring | |
| lemma mdir_dir_at (w : E) (b : ΞΉ β E) (r : β) {M : ΞΉ β E β β} {f : E β β} {p : E} | |
| (hM : βi,ContDiffAt β (β€:ββ) (M i) p) (hf : ContDiffAt β (β€:ββ) f p) (v : E) : | |
| mdir w b r M (dir v f) p=dir v (mdir w b r M f) p+ | |
| r*βi,dir v (M i) p*dir (b i) f p := by | |
| have hMi : βi,DifferentiableAt β (M i) p := fun i => (hM i).differentiableAt (by simp) | |
| have hdf : βz,DifferentiableAt β (dir z f) p := fun z => (smooth_dir_at hf z).differentiableAt (by simp) | |
| have hterm (i : ΞΉ) : DifferentiableAt β (fun y => M i y*dir (b i) f y) p := | |
| (hMi i).mul (hdf (b i)) | |
| have hsum : DifferentiableAt β (fun y => βi,M i y*dir (b i) f y) p := | |
| DifferentiableAt.fun_sum fun i _ => hterm i | |
| have he : dir v (mdir w b r M f) p=dir v (dir w f) p- | |
| r*βi,(dir v (M i) p*dir (b i) f p+M i p*dir v (dir (b i) f) p) := by | |
| unfold mdir | |
| rw [dir_sub_at (hdf w) (hsum.const_mul r),dir_const_mul_at hsum, | |
| dir_sum_at Finset.univ (fun i _ => hterm i)] | |
| simp_rw [dir_mul_at (hMi _) (hdf _)] | |
| rw [he] | |
| unfold mdir | |
| simp_rw [dir_dir_at hf v] | |
| rw [Finset.sum_add_distrib] | |
| ring | |
| lemma smooth_cadj_at (v : E) {s f : E β β} {p : E} | |
| (hs : ContDiffAt β (β€:ββ) s p) (hf : ContDiffAt β (β€:ββ) f p) : | |
| ContDiffAt β (β€:ββ) (cadj v s f) p := | |
| (smooth_dir_at hf v).neg.add (hs.mul hf) | |
| lemma gadj_mul_at (b : ΞΉ β E) (s : ΞΉ β E β β) {V : ΞΉ β E β β} {p : E} | |
| (hV : βi,DifferentiableAt β (V i) p) {f : E β β} (hf : DifferentiableAt β f p) : | |
| gadj b s (fun i p => V i p*f p) p=gadj b s V p*f p-βi,V i p*dir (b i) f p := by | |
| unfold gadj cadj | |
| simp_rw [dir_mul_at (hV _) hf] | |
| rw [Finset.sum_mul,βFinset.sum_sub_distrib] | |
| apply Finset.sum_congr rfl | |
| intro i _ | |
| ring | |
| lemma gadj_sum_at {N : Type*} (a : Finset N) (b : ΞΉ β E) (s : ΞΉ β E β β) | |
| {V : N β ΞΉ β E β β} {p : E} (hV : βnβa,βi,DifferentiableAt β (V n i) p) : | |
| gadj b s (fun i p => βnβa,V n i p) p=βnβa,gadj b s (V n) p := by | |
| unfold gadj cadj | |
| simp_rw [dir_sum_at a (fun n hn => hV n hn _)] | |
| simp only [Finset.mul_sum] | |
| rw [Finset.sum_comm] | |
| simp only [Finset.sum_add_distrib,Finset.sum_neg_distrib] | |
| theorem mdir_cadj_at (w : E) (b : ΞΉ β E) (r : β) | |
| {M s : ΞΉ β E β β} {f : E β β} {p : E} | |
| (hM : βi,ContDiffAt β (β€:ββ) (M i) p) | |
| (hs : βi,ContDiffAt β (β€:ββ) (s i) p) (hf : ContDiffAt β (β€:ββ) f p) (i : ΞΉ) | |
| (hsi : mdir w b r M (s i) p=r*gadj b s (fun k => dir (b i) (M k)) p) : | |
| mdir w b r M (cadj (b i) (s i) f) p= | |
| cadj (b i) (s i) (mdir w b r M f) p+ | |
| r*gadj b s (fun k p => dir (b i) (M k) p*f p) p := by | |
| have hdf := smooth_dir_at hf (b i) | |
| have hMi (k : ΞΉ) := smooth_dir_at (hM k) (b i) | |
| have he : cadj (b i) (s i) f=fun p => (-1)*dir (b i) f p+s i p*f p := by | |
| funext p; simp [cadj] | |
| rw [he,mdir_add_at w b r M ((contDiffAt_const.mul hdf).differentiableAt (by simp)) | |
| (((hs i).mul hf).differentiableAt (by simp))] | |
| rw [mdir_const_mul_at w b r M (hdf.differentiableAt (by simp)), | |
| mdir_mul_at w b r M ((hs i).differentiableAt (by simp)) (hf.differentiableAt (by simp)), | |
| mdir_dir_at w b r hM hf,hsi, | |
| gadj_mul_at b s (fun k => (hMi k).differentiableAt (by simp)) (hf.differentiableAt (by simp))] | |
| simp only [cadj] | |
| ring | |
| theorem mdir_gadj_at (w : E) (b : ΞΉ β E) (r : β) | |
| {M s V : ΞΉ β E β β} {p : E} | |
| (hM : βi,ContDiffAt β (β€:ββ) (M i) p) | |
| (hs : βi,ContDiffAt β (β€:ββ) (s i) p) (hV : βi,ContDiffAt β (β€:ββ) (V i) p) | |
| (hscore : βi,mdir w b r M (s i) p=r*gadj b s (fun k => dir (b i) (M k)) p) : | |
| mdir w b r M (gadj b s V) p= | |
| gadj b s (fun i => mdir w b r M (V i)) p+ | |
| r*gadj b s (fun k p => βi,dir (b i) (M k) p*V i p) p := by | |
| change mdir w b r M (fun p => βi,cadj (b i) (s i) (V i) p) p=_ | |
| rw [mdir_sum_at Finset.univ w b r M (fun i _ => | |
| (smooth_cadj_at (b i) (hs i) (hV i)).differentiableAt (by simp))] | |
| simp_rw [mdir_cadj_at w b r hM hs (hV _) _ (hscore _)] | |
| have hD (i k : ΞΉ) : DifferentiableAt β (fun p => dir (b i) (M k) p*V i p) p := | |
| ((smooth_dir_at (hM k) (b i)).mul (hV i)).differentiableAt (by simp) | |
| rw [gadj_sum_at Finset.univ b s (fun i _ k => hD i k)] | |
| simp only [Finset.sum_add_distrib,Finset.mul_sum,gadj] | |
| end LogConcaveSampling.JetCalculus | |
| end | |
| end | |
| section | |
| noncomputable section | |
| namespace LogConcaveSampling.JetCalculus | |
| open Filter | |
| open scoped Topology Classical BigOperators | |
| variable {E : Type*} [NormedAddCommGroup E] [NormedSpace β E] | |
| variable {ΞΉ ΞΊ : Type*} [Fintype ΞΉ] | |
| lemma dir_eventuallyEq {f g : E β β} {p : E} (h : f=αΆ [nhds p]g) (v : E) : | |
| dir v f=αΆ [nhds p]dir v g := by | |
| filter_upwards [h.fderiv (π:=β)] with y hy | |
| simp only [dir,hy] | |
| lemma jet_eventuallyEq {f g : E β β} {p : E} (h : f=αΆ [nhds p]g) (v : ΞΊ β E) (l : List ΞΊ) : | |
| jet v l f=αΆ [nhds p]jet v l g := by | |
| induction l with | |
| | nil => exact h | |
| | cons i l ih => exact dir_eventuallyEq ih (v i) | |
| lemma mdir_eventuallyEq (w : E) (b : ΞΉ β E) (r : β) | |
| {M N : ΞΉ β E β β} {f g : E β β} {p : E} | |
| (hM : βi,M i=αΆ [nhds p]N i) (hf : f=αΆ [nhds p]g) : | |
| mdir w b r M f=αΆ [nhds p]mdir w b r N g := by | |
| have hMd : βαΆ y in nhds p,βi,M i y=N i y := eventually_all.mpr hM | |
| have hfd : βαΆ y in nhds p,βi,dir (b i) f y=dir (b i) g y := | |
| eventually_all.mpr (fun i => dir_eventuallyEq hf (b i)) | |
| filter_upwards [hMd,hfd,dir_eventuallyEq hf w] with y hM hf hw | |
| simp only [mdir,hM,hf,hw] | |
| lemma gadj_eventuallyEq (b : ΞΉ β E) {s t V W : ΞΉ β E β β} {p : E} | |
| (hs : βi,s i=αΆ [nhds p]t i) (hV : βi,V i=αΆ [nhds p]W i) : | |
| gadj b s V=αΆ [nhds p]gadj b t W := by | |
| have hs' : βαΆ y in nhds p,βi,s i y=t i y := eventually_all.mpr hs | |
| have hV' : βαΆ y in nhds p,βi,V i y=W i y := eventually_all.mpr hV | |
| have hVd : βαΆ y in nhds p,βi,dir (b i) (V i) y=dir (b i) (W i) y := | |
| eventually_all.mpr (fun i => dir_eventuallyEq (hV i) (b i)) | |
| filter_upwards [hs',hV',hVd] with y hs hV hVd | |
| simp only [gadj,cadj,hs,hV,hVd] | |
| lemma smooth_jet_at {f : E β β} {p : E} (hf : ContDiffAt β (β€:ββ) f p) | |
| (v : ΞΊ β E) (l : List ΞΊ) : ContDiffAt β (β€:ββ) (jet v l f) p := by | |
| induction l with | |
| | nil => exact hf | |
| | cons i l ih => exact smooth_dir_at ih (v i) | |
| def TimeSmooth (f : β Γ E β β) : Prop := | |
| βp : β Γ E,-1<p.1 β p.1<1 β ContDiffAt β (β€:ββ) f p | |
| lemma TimeSmooth.localize {f : β Γ E β β} (hf : TimeSmooth f) {p : β Γ E} | |
| (h0 : -1<p.1) (h1 : p.1<1) : | |
| βg : β Γ E β β, ContDiff β (β€:ββ) g β§ g=αΆ [nhds p]f := by | |
| obtain β¨g,hg,heβ© := smooth_time_localization h0 h1 hf | |
| refine β¨g,hg,?_β© | |
| have hh := (continuousAt_fst (p:=p)).eventually he | |
| filter_upwards [hh] with q hq | |
| exact hq q.2 | |
| theorem mdir_jet_time [DecidableEq ΞΊ] (w : β Γ E) (b : ΞΉ β β Γ E) (r : β) | |
| {M : ΞΉ β β Γ E β β} (hM : βi,TimeSmooth (M i)) | |
| {f : β Γ E β β} (hf : TimeSmooth f) | |
| (v : ΞΊ β β Γ E) (l : List ΞΊ) (hl : l.Nodup) | |
| {p : β Γ E} (h0 : -1<p.1) (h1 : p.1<1) : | |
| mdir w b r M (jet v l f) p=jet v l (mdir w b r M f) p+ | |
| r*βsβl.toFinset.powerset.erase β ,βi, | |
| jet v (l.filter (fun j => jβs)) (M i) p* | |
| dir (b i) (jet v (l.filter (fun j => jβs)) f) p := by | |
| choose N hN heN using fun i => (hM i).localize h0 h1 | |
| obtain β¨g,hg,hegβ© := hf.localize h0 h1 | |
| have hleft := (mdir_eventuallyEq w b r heN (jet_eventuallyEq heg v l)).eq_of_nhds | |
| have hright := (jet_eventuallyEq (mdir_eventuallyEq w b r heN heg) v l).eq_of_nhds | |
| rw [βhleft,congrFun (mdir_jet w b r hN hg v l hl) p,hright] | |
| congr 1 | |
| congr 1 | |
| apply Finset.sum_congr rfl | |
| intro s _ | |
| apply Finset.sum_congr rfl | |
| intro i _ | |
| rw [(jet_eventuallyEq (heN i) v _).eq_of_nhds, | |
| (dir_eventuallyEq (jet_eventuallyEq heg v _) (b i)).eq_of_nhds] | |
| end LogConcaveSampling.JetCalculus | |
| end | |
| end | |
| end | |
| end OAI | |