Download data/lean/OAI/Probability/LogConcave/JetEstimates/SplitBundle.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 13.2 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Probability/LogConcave/JetEstimates/SplitBundle.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Probability/LogConcave/JetEstimates/SplitBundle.lean
-
curl -L -o SplitBundle.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Probability/LogConcave/JetEstimates/SplitBundle.lean
13.2 kB
| import Mathlib | |
| import OAI.Probability.LogConcave.JetEstimates.ForestTensor | |
| namespace OAI | |
| section | |
| section | |
| noncomputable section | |
| namespace LogConcaveSampling.TensorEnergy | |
| open scoped Classical BigOperators | |
| lemma _root_.OAI.OrderedFinpartition.sum_partSize {n : β} (c : OrderedFinpartition n) : | |
| βi,c.partSize i=n := by | |
| simpa using Fintype.card_congr c.equivSigma | |
| lemma _root_.OAI.OrderedFinpartition.unique_of_partSize_eq {n : β} (c : OrderedFinpartition n) | |
| (i : Fin c.length) (hi : c.partSize i=n) (j : Fin c.length) : j=i := by | |
| by_contra hji | |
| have hs := Finset.sum_erase_add Finset.univ (fun k => c.partSize k) (Finset.mem_univ i) | |
| rw [_root_.OAI.OrderedFinpartition.sum_partSize c,hi] at hs | |
| have hz : βkβFinset.univ.erase i,c.partSize k=0 := by omega | |
| have hh := Finset.single_le_sum (fun k (_ : kβFinset.univ.erase i) => Nat.zero_le (c.partSize k)) | |
| (Finset.mem_erase.mpr β¨hji,Finset.mem_univ jβ©) | |
| rw [hz] at hh | |
| have := c.partSize_pos j | |
| omega | |
| lemma _root_.OAI.OrderedFinpartition.length_eq_one_of_partSize_eq {n : β} (c : OrderedFinpartition n) | |
| (i : Fin c.length) (hi : c.partSize i=n) : c.length=1 := by | |
| have hp : 0<c.length := Nat.zero_lt_of_lt i.isLt | |
| have hle : c.lengthβ€1 := by | |
| by_contra h | |
| have hgt : 1<c.length := by omega | |
| have he := (_root_.OAI.OrderedFinpartition.unique_of_partSize_eq c i hi β¨0,hpβ©).trans | |
| (_root_.OAI.OrderedFinpartition.unique_of_partSize_eq c i hi β¨1,hgtβ©).symm | |
| have hh := congrArg Fin.val he | |
| change (0:β)=1 at hh | |
| omega | |
| omega | |
| lemma partition_majorant_linear {n : β} {M B N : β β β} {z : β} | |
| (hM : βk,0β€M k) (hB : βk,0β€B k) (hz : 0β€z) | |
| (hN : βk<n,N k=B k) (hNz : N n=z) : | |
| (βc : OrderedFinpartition n,M c.length*βi,N (c.partSize i))β€ | |
| (Fintype.card (OrderedFinpartition n):β)*M 1*z+ | |
| βc : OrderedFinpartition n,M c.length*βi,B (c.partSize i) := by | |
| have hb (c : OrderedFinpartition n) : M c.length*(βi,N (c.partSize i))β€ | |
| M 1*z+M c.length*βi,B (c.partSize i) := by | |
| by_cases hh : βi,c.partSize i=n | |
| Β· obtain β¨i,hiβ© := hh | |
| have hp : (βj,N (c.partSize j))=z := by | |
| rw [Finset.prod_eq_single i] | |
| Β· rw [hi,hNz] | |
| Β· intro j _ hji | |
| exact (hji (_root_.OAI.OrderedFinpartition.unique_of_partSize_eq c i hi j)).elim | |
| Β· simp | |
| have hMl : M c.length=M 1 := congrArg M (_root_.OAI.OrderedFinpartition.length_eq_one_of_partSize_eq c i hi) | |
| rw [hp,hMl] | |
| exact le_add_of_nonneg_right (mul_nonneg (hM 1) (Finset.prod_nonneg (fun j _ => hB _))) | |
| Β· have hp : (βi,N (c.partSize i))=βi,B (c.partSize i) := by | |
| apply Finset.prod_congr rfl | |
| intro i _ | |
| exact hN _ (lt_of_le_of_ne (c.partSize_le i) (fun he => hh β¨i,heβ©)) | |
| rw [hp] | |
| exact le_add_of_nonneg_left (mul_nonneg (hM 1) hz) | |
| calc | |
| _ β€ βc : OrderedFinpartition n,(M 1*z+M c.length*βi,B (c.partSize i)) := | |
| Finset.sum_le_sum (fun c _ => hb c) | |
| _ = _ := by rw [Finset.sum_add_distrib]; simp [mul_assoc] | |
| end LogConcaveSampling.TensorEnergy | |
| end | |
| end | |
| section | |
| noncomputable section | |
| namespace LogConcaveSampling.TensorEnergy | |
| open Set Function | |
| open scoped BigOperators Classical Matrix.Norms.L2Operator | |
| universe u | |
| variable {S : Type u} [Fintype S] {d : β} | |
| abbrev SplitBundle (S : Type u) [Fintype S] (d : β) := | |
| βp : ProperSplit S, Matrix (OutSlots p β Fin d) (InSlots p β Fin d) β | |
| def splitBundleLinear : ((S β Fin d) β β) ββ[β] SplitBundle S d where | |
| toFun T p := splitMatrix T p | |
| map_add' _ _ := rfl | |
| map_smul' _ _ := rfl | |
| def splitBundle : ((S β Fin d) β β) βL[β] SplitBundle S d := | |
| splitBundleLinear.toContinuousLinearMap | |
| lemma allSplitBound_bundle (T : (S β Fin d) β β) : | |
| AllSplitBound T βsplitBundle Tβ := by | |
| intro I O _ _ _ _ _ _ e | |
| have h := (bound_norm (splitMatrix T (properOfEquiv e))).mono | |
| (pow_le_pow_leftβ (norm_nonneg _) (norm_le_pi_norm (splitBundle T) (properOfEquiv e)) 2) | |
| have h' := h.reindex (Equiv.arrowCongr (rightOfEquiv e) (Equiv.refl (Fin d))) | |
| (Equiv.arrowCongr (leftOfEquiv e) (Equiv.refl (Fin d))) | |
| convert h' using 1 | |
| ext o i | |
| unfold splitMatrix | |
| congr 1 | |
| funext s | |
| rw [splitEquiv_ofEquiv] | |
| cases e s <;> simp | |
| lemma bundle_norm_le {T : (S β Fin d) β β} {M : β} | |
| (hM : 0β€M) (h : AllSplitBound T M) : βsplitBundle Tββ€M := by | |
| have hp (p : ProperSplit S) : βsplitMatrix T pββ€M := by | |
| have hh : Bound (splitMatrix T p) (M^2) := h (InSlots p) (OutSlots p) (splitEquiv p) | |
| exact @Bound.norm_le (OutSlots p β Fin d) (InSlots p β Fin d) _ _ (splitMatrix T p) M hM hh | |
| exact (pi_norm_le_iff_of_nonneg hM).mpr hp | |
| theorem allSplit_gronwall {T D : β β (S β Fin d) β β} {a b Ξ΄ K Ξ΅ : β} | |
| (hc : ContinuousOn T (Icc a b)) | |
| (hd : βtβIco a b,HasDerivWithinAt T (D t) (Ici t) t) | |
| (hΞ΄ : 0β€Ξ΄) (hΞ΅ : 0β€Ξ΅) (hK : 0β€K) | |
| (hinit : AllSplitBound (T a) Ξ΄) | |
| (hbound : βtβIco a b,AllSplitBound (D t) (K*βsplitBundle (T t)β+Ξ΅)) | |
| {t : β} (ht : tβIcc a b) : | |
| AllSplitBound (T t) (gronwallBound Ξ΄ K Ξ΅ (t-a)) := by | |
| have hb := norm_le_gronwallBound_of_norm_deriv_right_le | |
| (splitBundle.continuous.comp_continuousOn hc) | |
| (fun u hu => splitBundle.hasFDerivAt.comp_hasDerivWithinAt u (hd u hu)) | |
| (bundle_norm_le hΞ΄ hinit) | |
| (fun u hu => bundle_norm_le (by positivity) (hbound u hu)) t ht | |
| exact (allSplitBound_bundle (T t)).mono | |
| (norm_nonneg _) hb | |
| end LogConcaveSampling.TensorEnergy | |
| end | |
| end | |
| section | |
| noncomputable section | |
| namespace LogConcaveSampling.TensorEnergy | |
| open scoped Classical BigOperators | |
| lemma _root_.OAI.OrderedFinpartition.sum_pred_partSize {n : β} (c : OrderedFinpartition n) : | |
| (βi,(c.partSize i-1))+c.length=n := by | |
| have he : (βi,(c.partSize i-1))+(β_i : Fin c.length,1)=βi,c.partSize i := by | |
| rw [βFinset.sum_add_distrib] | |
| exact Finset.sum_congr rfl (fun i _ => Nat.sub_add_cancel (c.partSize_pos i)) | |
| simpa only [Finset.sum_const,Finset.card_univ,Fintype.card_fin,smul_eq_mul,mul_one, _root_.OAI.OrderedFinpartition.sum_partSize c] using he | |
| lemma partition_scale {n : β} (hn : 0<n) (c : OrderedFinpartition n) | |
| (A B : β β β) (R : β) : | |
| (A c.length/R^(c.length-1))*(βi,B (c.partSize i)/R^(c.partSize i-1))= | |
| (A c.length*(βi,B (c.partSize i)))/R^(n-1) := by | |
| rw [Finset.prod_div_distrib,βmul_div_mul_comm,Finset.prod_pow_eq_pow_sum,βpow_add] | |
| have he : c.length-1+(βi,(c.partSize i-1))=n-1 := by | |
| have := _root_.OAI.OrderedFinpartition.sum_pred_partSize c | |
| have := c.length_pos hn | |
| omega | |
| rw [he] | |
| lemma partition_sum_scale {n : β} (hn : 0<n) (A B : β β β) (R : β) : | |
| (βc : OrderedFinpartition n,(A c.length/R^(c.length-1))*(βi,B (c.partSize i)/R^(c.partSize i-1)))= | |
| (βc : OrderedFinpartition n,A c.length*(βi,B (c.partSize i)))/R^(n-1) := by | |
| simp only [partition_scale hn,Finset.sum_div] | |
| lemma gronwallBound_div (Ξ΄ K Ξ΅ t q : β) : | |
| gronwallBound (Ξ΄/q) K (Ξ΅/q) t=gronwallBound Ξ΄ K Ξ΅ t/q := by | |
| by_cases hK : K=0 | |
| Β· simp only [hK,gronwallBound_K0]; ring | |
| Β· simp only [gronwallBound_of_K_ne_0 hK]; ring | |
| end LogConcaveSampling.TensorEnergy | |
| end | |
| end | |
| section | |
| noncomputable section | |
| namespace LogConcaveSampling.TensorEnergy | |
| open scoped Classical BigOperators | |
| lemma partition_array_scale {n : β} (c : OrderedFinpartition n) | |
| (A B : β β β) (R : β) (w : β) : | |
| (A c.length/R^(c.length+w))*(βi,B (c.partSize i)/R^(c.partSize i-1))= | |
| (A c.length*(βi,B (c.partSize i)))/R^(n+w) := by | |
| rw [Finset.prod_div_distrib,βmul_div_mul_comm,Finset.prod_pow_eq_pow_sum,βpow_add] | |
| have he : c.length+w+(βi,(c.partSize i-1))=n+w := by | |
| have := _root_.OAI.OrderedFinpartition.sum_pred_partSize c | |
| omega | |
| rw [he] | |
| lemma array_composition_scale {d n : β} {S : Type} [Fintype S] [DecidableEq S] [Nonempty S] | |
| {f : Point d β Point d} {g : Point d β (S β Fin d) β β} (x : Point d) | |
| (hf : ContDiff β (β€:ββ) f) (hg : ContDiff β (β€:ββ) g) | |
| (A B : β β β) (hA : βk,0β€A k) (hB : βk,0β€B k) | |
| (R : β) (hR : 0<R) (w : β) | |
| (hG : βkβ€n,AllSplitBound (arrayTensor (iteratedFDeriv β k g (f x))) (A k/R^(k+w))) | |
| (hF : βkβ€n,AllSplitBound (multilinearTensor (iteratedFDeriv β k f x)) (B k/R^(k-1))) : | |
| AllSplitBound (arrayTensor (iteratedFDeriv β n (g β f) x)) | |
| ((βc : OrderedFinpartition n,A c.length*βi,B (c.partSize i))/R^(n+w)) := by | |
| have hh := iteratedFDeriv_array_comp_allSplit x | |
| (hf.contDiffAt.of_le (by exact_mod_cast (le_top : (n:ββ)β€β€))) | |
| (hg.contDiffAt.of_le (by exact_mod_cast (le_top : (n:ββ)β€β€))) | |
| (fun k => A k/R^(k+w)) (fun k => B k/R^(k-1)) | |
| (fun k => div_nonneg (hA _) (pow_nonneg hR.le _)) | |
| (fun k => div_nonneg (hB _) (pow_nonneg hR.le _)) hG hF | |
| simpa only [partition_array_scale,Finset.sum_div] using hh | |
| end LogConcaveSampling.TensorEnergy | |
| end | |
| end | |
| section | |
| noncomputable section | |
| namespace LogConcaveSampling | |
| open Set Function | |
| open scoped Classical BigOperators RealInnerProductSpace NNReal | |
| namespace JetCalculus | |
| variable {E : Type*} [NormedAddCommGroup E] [NormedSpace β E] | |
| lemma time_deriv_spatial_jet {ΞΉ : Type*} {A : β Γ E β β} | |
| (hA : ContDiff β (β€:ββ) A) (v : ΞΉ β E) (l : List ΞΉ) (t : β) (y : E) : | |
| HasDerivAt (fun u => jet v l (fun z => A (u,z)) y) | |
| (jet v l (fun z => dir (1,0) A (t,z)) y) t := by | |
| let J := jet (fun i => (0,v i)) l A | |
| have hJ := smooth_jet hA (fun i => (0,v i)) l | |
| have he : (fun u => jet v l (fun z => A (u,z)) y)=fun u => J (u,y) := by | |
| funext u | |
| exact congrFun (jet_right_slice_at (fun z => hA.contDiffAt) v l) y | |
| rw [he] | |
| have hj := ((hJ.differentiable (by simp) (t,y)).hasFDerivAt).comp_hasDerivAt t | |
| ((hasDerivAt_id t).prodMk (hasDerivAt_const t y)) | |
| have hd : jet v l (fun z => dir (1,0) A (t,z)) y=dir (1,0) J (t,y) := by | |
| rw [jet_right_slice_at (fun z => (smooth_dir hA (1,0)).contDiffAt),jet_dir hA] | |
| exact hd.symm βΈ hj | |
| end JetCalculus | |
| lemma multilinearTensor_iterated_eq_jet {d n : β} {f : Point d β Point d} | |
| (hf : ContDiff β (β€:ββ) f) (y : Point d) (c : Unit β Fin n β Fin d) : | |
| TensorEnergy.multilinearTensor (iteratedFDeriv β n f y) c= | |
| JetCalculus.jet (fun i => EuclideanSpace.basisFun (Fin d) β (c (Sum.inr i))) | |
| (List.finRange n) (fun z => inner β (EuclideanSpace.basisFun (Fin d) β (c (Sum.inl ()))) (f z)) y := by | |
| let L := innerSL β (EuclideanSpace.basisFun (Fin d) β (c (Sum.inl ()))) | |
| change _=JetCalculus.jet _ _ (L β f) y | |
| rw [JetCalculus.jet_finRange_eq_iteratedFDeriv (L.contDiff.comp hf), L.iteratedFDeriv_comp_left hf.contDiffAt (by exact_mod_cast (le_top : (n:ββ)β€β€))] | |
| simp only [ContinuousLinearMap.compContinuousMultilinearMap_coe, Function.comp_apply,L, innerSL_apply_apply,TensorEnergy.multilinearTensor] | |
| lemma spatialTensor_time_deriv {d n : β} {X : β Γ Point d β Point d} | |
| (hX : ContDiff β (β€:ββ) X) (V : Point d β Point d) (t : β) | |
| (hODE : βy,HasDerivAt (fun u => X (u,y)) (V (X (t,y))) t) (y : Point d) : | |
| HasDerivAt | |
| (fun u => TensorEnergy.multilinearTensor (iteratedFDeriv β n (fun z => X (u,z)) y)) | |
| (TensorEnergy.multilinearTensor (iteratedFDeriv β n (fun z => V (X (t,z))) y)) t := by | |
| apply hasDerivAt_pi.mpr | |
| intro c | |
| let L := innerSL β (EuclideanSpace.basisFun (Fin d) β (c (Sum.inl ()))) | |
| let A := L β X | |
| have hA : ContDiff β (β€:ββ) A := L.contDiff.comp hX | |
| have hslice (u : β) : ContDiff β (β€:ββ) (fun z => X (u,z)) := | |
| hX.comp (contDiff_const.prodMk contDiff_id) | |
| have hd := JetCalculus.time_deriv_spatial_jet hA | |
| (fun i => EuclideanSpace.basisFun (Fin d) β (c (Sum.inr i))) (List.finRange n) t y | |
| have he : (fun z => JetCalculus.dir (1,0) A (t,z))=fun z => L (V (X (t,z))) := by | |
| funext z | |
| have hleft := ((hA.differentiable (by simp) (t,z)).hasFDerivAt).comp_hasDerivAt t | |
| ((hasDerivAt_id t).prodMk (hasDerivAt_const t z)) | |
| exact hleft.unique (L.hasFDerivAt.comp_hasDerivAt t (hODE z)) | |
| rw [he] at hd | |
| have hm : ContDiff β (β€:ββ) (fun z => L (V (X (t,z)))) := by | |
| rw [βhe] | |
| exact (JetCalculus.smooth_dir hA (1,0)).comp (contDiff_const.prodMk contDiff_id) | |
| have hf : (fun u => TensorEnergy.multilinearTensor (iteratedFDeriv β n (fun z => X (u,z)) y) c)= | |
| fun u => JetCalculus.jet (fun i => EuclideanSpace.basisFun (Fin d) β (c (Sum.inr i))) | |
| (List.finRange n) (fun z => L (X (u,z))) y := by | |
| funext u | |
| exact multilinearTensor_iterated_eq_jet (hslice u) y c | |
| rw [hf] | |
| have hV : ContDiff β (β€:ββ) (fun z => V (X (t,z))) := by | |
| have heV : (fun z => V (X (t,z)))=fun z => (fderiv β X (t,z)) (1,0) := by | |
| funext z | |
| exact (hODE z).unique (((hX.differentiable (by simp) (t,z)).hasFDerivAt).comp_hasDerivAt t | |
| ((hasDerivAt_id t).prodMk (hasDerivAt_const t z))) | |
| rw [heV] | |
| exact ((hX.fderiv_right (by simp)).comp (contDiff_const.prodMk contDiff_id)).clm_apply contDiff_const | |
| rw [multilinearTensor_iterated_eq_jet hV] | |
| exact hd | |
| end LogConcaveSampling | |
| end | |
| end | |
| end | |
| end OAI | |