Download data/lean/OAI/Probability/LogConcave/Sampling/DirectionalBasisSum.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 9.9 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Probability/LogConcave/Sampling/DirectionalBasisSum.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Probability/LogConcave/Sampling/DirectionalBasisSum.lean
-
curl -L -o DirectionalBasisSum.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Probability/LogConcave/Sampling/DirectionalBasisSum.lean
9.9 kB
| import Mathlib | |
| import OAI.Probability.LogConcave.JetEstimates.PolySmooth | |
| import OAI.Probability.LogConcave.Sampling.NormalizedTensor | |
| import OAI.Probability.LogConcave.JetEstimates.ContractLeftSplit | |
| namespace OAI | |
| section | |
| section | |
| noncomputable section | |
| namespace LogConcaveSampling | |
| open MeasureTheory | |
| open scoped Classical BigOperators RealInnerProductSpace | |
| lemma directional_basis_sum {d : β} (v : Point d) (f : Point d β β) : | |
| directional v f=fun x => βi : Fin d, | |
| (EuclideanSpace.basisFun (Fin d) β).repr v i * | |
| directional (EuclideanSpace.basisFun (Fin d) β i) f x := by | |
| funext x | |
| unfold directional | |
| conv_lhs => arg 2; rw [β(EuclideanSpace.basisFun (Fin d) β).sum_repr v] | |
| simp only [map_sum,map_smul,smul_eq_mul] | |
| lemma basis_jet_growth_all {d : β} {f : Point d β β} | |
| (hf : ContDiff β (β€ : ββ) f) | |
| (hg : βl : List (Fin d),HasPolynomialGrowth | |
| (JetCalculus.jet (EuclideanSpace.basisFun (Fin d) β) l f)) | |
| (l : List (Point d)) : HasPolynomialGrowth (JetCalculus.jet id l f) := by | |
| induction l generalizing f with | |
| | nil => exact hg [] | |
| | cons v l ih => | |
| change HasPolynomialGrowth (directional v (JetCalculus.jet id l f)) | |
| rw [βjet_directional hf,directional_basis_sum, | |
| JetCalculus.jet_sum Finset.univ (fun i _ => | |
| contDiff_const.mul (directional_smooth hf _))] | |
| apply Appell.HasGrowth.sum | |
| intro i _ | |
| rw [JetCalculus.jet_const_mul (directional_smooth hf _)] | |
| apply Appell.HasGrowth.mul (growth_const _) | |
| apply ih (directional_smooth hf _) | |
| intro k | |
| have hh := hg (k++[i]) | |
| have he : JetCalculus.jet (EuclideanSpace.basisFun (Fin d) β) [i] f= | |
| directional (EuclideanSpace.basisFun (Fin d) β i) f := rfl | |
| rw [JetCalculus.jet_append,he] at hh | |
| exact hh | |
| lemma PolySmooth.of_basis_growth {d : β} {f : Point d β β} | |
| (hf : ContDiff β (β€ : ββ) f) | |
| (hg : βl : List (Fin d),HasPolynomialGrowth | |
| (JetCalculus.jet (EuclideanSpace.basisFun (Fin d) β) l f)) : PolySmooth f := | |
| β¨hf,basis_jet_growth_all hf hgβ© | |
| lemma growth_of_bounded {d : β} {f : Point d β β} {B : β} | |
| (hB : 0β€B) (h : βx,|f x|β€B) : HasPolynomialGrowth f := by | |
| refine β¨B,hB,0,fun x => ?_β© | |
| simp only [pow_zero,Real.norm_eq_abs] | |
| exact (h x).trans (by linarith) | |
| end LogConcaveSampling | |
| end | |
| end | |
| section | |
| noncomputable section | |
| namespace LogConcaveSampling | |
| open MeasureTheory | |
| open scoped Classical BigOperators NNReal RealInnerProductSpace | |
| universe u | |
| lemma normalizedTensor_spatial_allSplit {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) | |
| (y : Point d) {S K : Type u} [Fintype S] [Fintype K] | |
| (mask : S β Bool) (l : List S) (hlne : lβ []) | |
| (hlN : l.Nodup) (hlall : βs,sβl) (k : List K) (hkN : k.Nodup) (hkall : βi,iβk) : | |
| TensorEnergy.AllSplitBound (fun c : K β S β Fin d => | |
| JetCalculus.jet (fun i => EuclideanSpace.basisFun (Fin d) β (c (Sum.inl i))) k | |
| (fun y => normalizedTensor F x r Ο ((lam:β)*r) y mask l (fun s => c (Sum.inr s))) y) | |
| (normalizedTensorMajorant (Fintype.card K+Fintype.card S) (1-Ο^2)) := by | |
| have hS : 0<Fintype.card S := by | |
| rw [βlist_length_full l hlN hlall] | |
| exact List.length_pos_iff.mpr hlne | |
| have he := normalizedTensor_spatial_jet hF x hr hlam hl hΟ0 hΟ1 y mask l hlne hS | |
| k (list_length_full k hkN hkall) | |
| simp_rw [he] | |
| have hN : (k.map Sum.inl++l.map Sum.inr).Nodup := JetCalculus.nodup_sum_append hkN hlN | |
| have hall : βt : K β S,tβk.map Sum.inl++l.map Sum.inr := by | |
| intro t | |
| cases t <;> simp [hkall,hlall] | |
| have hh := (normalizedTensor_allSplit hF x hr hlam hl hΟ0 hΟ1 y | |
| (Sum.elim (fun _ => false) mask) (k.map Sum.inl++l.map Sum.inr) hN hall).const_mul | |
| (Ο^(Fintype.card K)) | |
| simp only [Fintype.card_sum] at hh | |
| apply hh.mono (mul_nonneg (pow_nonneg hΟ0 _) (normalizedTensorMajorant_nonneg _ _)) | |
| exact mul_le_of_le_one_left (normalizedTensorMajorant_nonneg _ _) | |
| (pow_le_oneβ hΟ0 hΟ1.le) | |
| lemma normalizedTensor_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) | |
| {S : Type} [Fintype S] (mask : S β Bool) (l : List S) | |
| (hlN : l.Nodup) (hlall : βs,sβl) (hS : 2β€Fintype.card S) (c : S β Fin d) : | |
| PolySmooth (fun y => normalizedTensor F x r Ο ((lam:β)*r) y mask l c) := by | |
| have hlne : lβ [] := by | |
| intro he | |
| have hh := list_length_full l hlN hlall | |
| simp [he] at hh | |
| omega | |
| apply PolySmooth.of_basis_growth (normalizedTensor_smooth hF x hr hlam hl hΟ0 hΟ1 mask l hlne c) | |
| intro k | |
| apply growth_of_bounded (normalizedTensorMajorant_nonneg (k.length+Fintype.card S) (1-Ο^2)) | |
| intro y | |
| have hh := (normalizedTensor_spatial_allSplit hF x hr hlam hl hΟ0 hΟ1 y mask l hlne hlN hlall | |
| (List.finRange k.length) (List.nodup_finRange _) (by simp)).entry_le | |
| (normalizedTensorMajorant_nonneg _ _) (by simp only [Fintype.card_sum,Fintype.card_fin]; omega) | |
| (Sum.elim k.get c) | |
| simp only [Sum.elim_inl,Sum.elim_inr,Fintype.card_fin] at hh | |
| change |JetCalculus.jet ((EuclideanSpace.basisFun (Fin d) β) β k.get) | |
| (List.finRange k.length) (fun y => normalizedTensor F x r Ο ((lam:β)*r) y mask l c) y|β€_ at hh | |
| rw [βJetCalculus.jet_map, List.map_get_finRange] at hh | |
| exact hh | |
| end LogConcaveSampling | |
| end | |
| end | |
| section | |
| noncomputable section | |
| namespace LogConcaveSampling | |
| open MeasureTheory | |
| open scoped Classical BigOperators NNReal RealInnerProductSpace | |
| lemma conditionalFieldMean_jet_normalized {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) | |
| (y : Point d) {S : Type} [Fintype S] (l : List S) (hlen : l.length=Fintype.card S) | |
| (c : S β Unit β Fin d) : | |
| JetCalculus.jet (fun s => EuclideanSpace.basisFun (Fin d) β (c (Sum.inl s))) l | |
| (fun y => inner β (EuclideanSpace.basisFun (Fin d) β (c (Sum.inr ()))) | |
| (conditionalFieldMean F x r Ο y)) y= | |
| Ο^(Fintype.card S)*((lam:β)*r)*normalizedTensor F x r Ο ((lam:β)*r) y | |
| (Sum.elim (fun _ => false) (fun _ => true)) (l.map Sum.inl++[Sum.inr ()]) c := by | |
| have hi : (fun y => inner β (EuclideanSpace.basisFun (Fin d) β (c (Sum.inr ()))) | |
| (conditionalFieldMean F x r Ο y))= | |
| conditionalMeanScalar F x r Ο (fun z => inner β | |
| (EuclideanSpace.basisFun (Fin d) β (c (Sum.inr ()))) (primitiveField F x r z)) := | |
| funext (conditionalFieldMean_inner hF x hr.le hl hΟ0 hΟ1 _) | |
| rw [hi,conditionalFieldMean_jet_U hF x hr hlam hl hΟ0 hΟ1] | |
| unfold conditionalU normalizedTensor | |
| rw [JetCalculus.jet_append,JetCalculus.jet_map] | |
| simp only [Fintype.card_sum,Fintype.card_unique,add_tsub_cancel_right,hlen, | |
| Function.comp_def] | |
| have hv : (fun s => jointPosition d (EuclideanSpace.basisFun (Fin d) β (c (Sum.inl s))))= | |
| (fun s => EuclideanSpace.basisFun (Fin d β Fin d) β | |
| (conditionalSlotEmbedding d (Sum.elim (fun _ => false) (fun _ => true)) c (Sum.inl s))) := by | |
| funext s | |
| exact jointPosition_basis _ | |
| rw [hv,jointField_basis] | |
| have he : conditionalSlotEmbedding d (Sum.elim (fun _ : S => false) (fun _ : Unit => true)) c | |
| (Sum.inr ())=Sum.inr (c (Sum.inr ())) := rfl | |
| simp only [JetCalculus.jet,he] | |
| ring | |
| lemma conditionalFieldMean_component_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) | |
| (i : Fin d) : PolySmooth (fun y => inner β (EuclideanSpace.basisFun (Fin d) β i) | |
| (conditionalFieldMean F x r Ο y)) := by | |
| let v := EuclideanSpace.basisFun (Fin d) β i | |
| have hs := (innerSL β v).contDiff.comp (conditionalFieldMean_smooth hF x hr.le hl hΟ0 hΟ1) | |
| apply PolySmooth.of_basis_growth hs | |
| intro k | |
| by_cases hk : k=[] | |
| Β· subst k | |
| exact growth_of_lipschitz ((innerSL β v).lipschitzWith.comp | |
| (conditionalFieldMean_lipschitz hF x hr.le hl hΟ0 hΟ1)) | |
| Β· let c : Fin k.length β Unit β Fin d := Sum.elim k.get (fun _ => i) | |
| have he : JetCalculus.jet (EuclideanSpace.basisFun (Fin d) β) k | |
| (fun y => inner β v (conditionalFieldMean F x r Ο y))= | |
| fun y => Ο^k.length*((lam:β)*r)*normalizedTensor F x r Ο ((lam:β)*r) y | |
| (Sum.elim (fun _ => false) (fun _ => true)) | |
| ((List.finRange k.length).map Sum.inl++[Sum.inr ()]) c := by | |
| funext y | |
| have hh := conditionalFieldMean_jet_normalized hF x hr hlam hl hΟ0 hΟ1 y | |
| (List.finRange k.length) (by simp) c | |
| simp only [c,Sum.elim_inl,Sum.elim_inr,Fintype.card_fin] at hh | |
| change JetCalculus.jet ((EuclideanSpace.basisFun (Fin d) β) β k.get) | |
| (List.finRange k.length) _ y=_ at hh | |
| rw [βJetCalculus.jet_map,List.map_get_finRange] at hh | |
| exact hh | |
| change HasPolynomialGrowth (JetCalculus.jet (EuclideanSpace.basisFun (Fin d) β) k | |
| (fun y => inner β v (conditionalFieldMean F x r Ο y))) | |
| rw [he] | |
| apply Appell.HasGrowth.mul (growth_const _) | |
| have hN : ((List.finRange k.length).map (Sum.inl : Fin k.length β Fin k.length β Unit)++ | |
| [Sum.inr ()]).Nodup := by | |
| simpa using JetCalculus.nodup_sum_append (List.nodup_finRange k.length) | |
| (by simp : ([()] : List Unit).Nodup) | |
| have hall : βt : Fin k.length β Unit,tβ(List.finRange k.length).map Sum.inl++[Sum.inr ()] := by | |
| intro t; cases t <;> simp | |
| exact (normalizedTensor_polySmooth hF x hr hlam hl hΟ0 hΟ1 _ _ hN hall | |
| (by simp; exact List.length_pos_iff.mpr hk) c).growth [] | |
| end LogConcaveSampling | |
| end | |
| end | |
| end | |
| end OAI | |