Download data/lean/OAI/Probability/LogConcave/JetEstimates/ForestTensor.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 20.2 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Probability/LogConcave/JetEstimates/ForestTensor.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Probability/LogConcave/JetEstimates/ForestTensor.lean
-
curl -L -o ForestTensor.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Probability/LogConcave/JetEstimates/ForestTensor.lean
20.2 kB
| import Mathlib | |
| import OAI.Probability.LogConcave.Sampling.SpatialTensor | |
| namespace OAI | |
| section | |
| section | |
| noncomputable section | |
| namespace LogConcaveSampling.TensorEnergy | |
| open scoped Classical BigOperators | |
| lemma AllSplitBound.singleContract_frobenius {d : β} {S T : Type} | |
| [Fintype S] [Nonempty S] [Fintype T] | |
| {A : (S β Unit β Fin d) β β} {M : β} | |
| (hA : AllSplitBound A M) (B : (T β Unit β Fin d) β β) : | |
| (βc,(TensorEnergy.singleContract A B c)^2)β€M^2*(βc,(B c)^2) := by | |
| have ha : Bound (fun (s : S β Fin d) (z : Fin d) => A (Sum.elim s (fun _ => z))) (M^2) := by | |
| convert (hA Unit S (Equiv.sumComm S Unit)).reindex | |
| (Equiv.refl (S β Fin d)) (Equiv.funUnique Unit (Fin d)).symm using 1 | |
| funext s z | |
| congr 1 | |
| funext t | |
| cases t <;> rfl | |
| have he (t : T β Fin d) : | |
| (βs : S β Fin d,(βz : Fin d,A (Sum.elim s (fun _ => z))*B (Sum.elim t (fun _ => z)))^2)β€ | |
| M^2*βz : Fin d,(B (Sum.elim t (fun _ => z)))^2 := ha (fun z => B (Sum.elim t (fun _ => z))) | |
| have hu := Equiv.sum_comp (Equiv.sumArrowEquivProdArrow S T (Fin d)).symm | |
| (fun c => (TensorEnergy.singleContract A B c)^2) | |
| rw [Fintype.sum_prod_type] at hu | |
| rw [βhu,Finset.sum_comm] | |
| have hb := Equiv.sum_comp (appendCoordinate (d:=d) T) (fun c => (B c)^2) | |
| rw [Fintype.sum_prod_type] at hb | |
| rw [βhb,Finset.mul_sum] | |
| exact Finset.sum_le_sum (fun t _ => he t) | |
| end LogConcaveSampling.TensorEnergy | |
| end | |
| end | |
| section | |
| noncomputable section | |
| namespace LogConcaveSampling.TensorEnergy | |
| open scoped Classical BigOperators | |
| def forestTensor {d n : β} {S : Type} (P : Fin n β Type) [βi,Fintype (P i)] | |
| (A : (S β Fin n β Fin d) β β) | |
| (B : βi,(P i β Unit β Fin d) β β) (c : S β (Ξ£i,P i) β Fin d) : β := | |
| βa : Fin n β Fin d,A (Sum.elim (fun s => c (Sum.inl s)) a) * | |
| βi,B i (Sum.elim (fun p => c (Sum.inr β¨i,pβ©)) (fun _ => a i)) | |
| def forestRoot {n : β} (S : Type) : S β Fin (n+1) β (S β Unit) β Fin n where | |
| toFun := Sum.elim (fun s => Sum.inl (Sum.inl s)) | |
| (Fin.cases (Sum.inl (Sum.inr ())) Sum.inr) | |
| invFun := Sum.elim (Sum.elim Sum.inl (fun _ => Sum.inr 0)) (fun i => Sum.inr i.succ) | |
| left_inv := by | |
| intro s | |
| rcases s with s|i | |
| Β· rfl | |
| Β· refine Fin.cases ?_ (fun i => ?_) i <;> rfl | |
| right_inv := by | |
| rintro ((s|u)|i) <;> rfl | |
| def forestBranches {n : β} (P : Fin (n+1) β Type) : | |
| (Ξ£i,P i) β P 0 β (Ξ£i : Fin n,P i.succ) where | |
| toFun p := Fin.cases (fun z => Sum.inl z) (fun i z => Sum.inr β¨i,zβ©) p.1 p.2 | |
| invFun := Sum.elim (fun z => β¨0,zβ©) (fun z => β¨z.1.succ,z.2β©) | |
| left_inv := by | |
| rintro β¨i,zβ© | |
| revert z | |
| refine Fin.cases ?_ (fun i => ?_) i <;> intro z <;> rfl | |
| right_inv := by rintro (z|β¨i,zβ©) <;> rfl | |
| def forestShuffle (S T : Type) : (S β Unit) β T β (S β T) β Unit := | |
| ((Equiv.sumAssoc S Unit T).trans | |
| ((Equiv.refl S).sumCongr (Equiv.sumComm Unit T))).trans (Equiv.sumAssoc S T Unit).symm | |
| def forestOutput {n : β} (S : Type) (P : Fin (n+1) β Type) : | |
| (S β (Ξ£i : Fin n,P i.succ)) β P 0 β S β (Ξ£i,P i) := | |
| ((Equiv.sumAssoc S (Ξ£i : Fin n,P i.succ) (P 0)).trans | |
| ((Equiv.refl S).sumCongr (Equiv.sumComm _ _))).trans | |
| ((Equiv.refl S).sumCongr (forestBranches P).symm) | |
| def forestColours (d n : β) : (Fin (n+1) β Fin d) β Fin d Γ (Fin n β Fin d) where | |
| toFun a := (a 0,fun i => a i.succ) | |
| invFun a := Fin.cons a.1 a.2 | |
| left_inv a := by funext i; exact Fin.cases rfl (fun _ => rfl) i | |
| right_inv a := rfl | |
| lemma forestTensor_succ {d n : β} {S : Type} (P : Fin (n+1) β Type) [βi,Fintype (P i)] | |
| (A : (S β Fin (n+1) β Fin d) β β) (B : βi,(P i β Unit β Fin d) β β) | |
| (c : S β (Ξ£i,P i) β Fin d) : | |
| forestTensor P A B c = singleContract | |
| (fun z => forestTensor (fun i : Fin n => P i.succ) | |
| (fun a => A (a β forestRoot S)) (fun i => B i.succ) (z β forestShuffle S _)) | |
| (B 0) (c β forestOutput S P) := by | |
| unfold forestTensor singleContract | |
| rw [β(forestColours d n).symm.sum_comp] | |
| rw [Fintype.sum_prod_type] | |
| simp only [show βa,(forestColours d n).symm a=Fin.cons a.1 a.2 from fun _ => rfl, | |
| Fin.prod_univ_succ,Fin.cons_zero,Fin.cons_succ] | |
| apply Finset.sum_congr rfl | |
| intro z _ | |
| rw [Finset.sum_mul] | |
| apply Finset.sum_congr rfl | |
| intro a _ | |
| have hA : Sum.elim (fun s => c (Sum.inl s)) (Fin.cons z a) = | |
| (Sum.elim | |
| (fun s => Sum.elim | |
| (fun s => (c β forestOutput S P) (Sum.inl s)) (fun _ => z) | |
| (forestShuffle S (Ξ£i : Fin n,P i.succ) (Sum.inl s))) a) β forestRoot S := by | |
| funext s | |
| rcases s with s|i | |
| Β· rfl | |
| Β· refine Fin.cases ?_ (fun i => ?_) i <;> rfl | |
| rw [hA] | |
| have hB (i : Fin n) : | |
| B i.succ (Sum.elim (fun p => c (Sum.inr β¨i.succ,pβ©)) (fun _ => a i)) = | |
| B i.succ (Sum.elim | |
| (fun p => Sum.elim (fun s => (c β forestOutput S P) (Sum.inl s)) (fun _ => z) | |
| (forestShuffle S (Ξ£i : Fin n,P i.succ) (Sum.inr β¨i,pβ©))) (fun _ => a i)) := rfl | |
| simp only [hB] | |
| have h0 : B 0 (Sum.elim (fun p => c (Sum.inr β¨0,pβ©)) (fun _ => z)) = | |
| B 0 (Sum.elim (fun p => (c β forestOutput S P) (Sum.inr p)) (fun _ => z)) := rfl | |
| rw [h0] | |
| simp only [Function.comp_def] | |
| ring | |
| theorem AllSplitBound.forest {d n : β} {S : Type} [Fintype S] [Nonempty S] | |
| (P : Fin n β Type) [βi,Fintype (P i)] [βi,Nonempty (P i)] | |
| {A : (S β Fin n β Fin d) β β} {B : βi,(P i β Unit β Fin d) β β} | |
| {M : β} {N : Fin n β β} (hA : AllSplitBound A M) (hB : βi,AllSplitBound (B i) (N i)) : | |
| AllSplitBound (forestTensor P A B) (M*βi,N i) := by | |
| induction n generalizing S with | |
| | zero => | |
| let e : S β (Ξ£i : Fin 0,P i) β S β Fin 0 := | |
| (Equiv.refl S).sumCongr (Equiv.equivOfIsEmpty _ _) | |
| have hh := hA.reindex e.symm | |
| have he : forestTensor P A B = fun c => A (c β e.symm) := by | |
| funext c | |
| simp only [forestTensor,Fin.prod_univ_zero,mul_one,Fintype.sum_unique] | |
| congr 1 | |
| funext s | |
| rcases s with s|i | |
| Β· rfl | |
| Β· exact Fin.elim0 i | |
| rw [he,Fin.prod_univ_zero,mul_one] | |
| exact hh | |
| | succ n ih => | |
| have ha := hA.reindex (forestRoot S) | |
| have ht := ih (fun i : Fin n => P i.succ) ha (fun i => hB i.succ) | |
| have hs := ht.reindex (forestShuffle S (Ξ£i : Fin n,P i.succ)) | |
| have hc := (hs.singleContract (hB 0)).reindex (forestOutput S P) | |
| have he : (M*(βi : Fin n,N i.succ))*N 0=M*βi,N i := by | |
| rw [Fin.prod_univ_succ]; ring | |
| rw [he] at hc | |
| convert hc using 1 | |
| ext c | |
| exact forestTensor_succ P A B c | |
| end LogConcaveSampling.TensorEnergy | |
| end | |
| end | |
| section | |
| noncomputable section | |
| namespace LogConcaveSampling.TensorEnergy | |
| open scoped Classical BigOperators RealInnerProductSpace | |
| def multilinearTensor {d : β} {I : Type} (A : ContinuousMultilinearMap β (fun _ : I => Point d) (Point d)) | |
| (c : Unit β I β Fin d) : β := | |
| inner β (EuclideanSpace.basisFun (Fin d) β (c (Sum.inl ()))) | |
| (A (fun i => EuclideanSpace.basisFun (Fin d) β (c (Sum.inr i)))) | |
| lemma multilinear_coordinate_expansion {d : β} {I : Type} [Fintype I] [DecidableEq I] | |
| (A : ContinuousMultilinearMap β (fun _ : I => Point d) (Point d)) | |
| (v : I β Point d) (o : Fin d) : | |
| inner β (EuclideanSpace.basisFun (Fin d) β o) (A v) = | |
| βa : I β Fin d, | |
| inner β (EuclideanSpace.basisFun (Fin d) β o) | |
| (A (fun i => EuclideanSpace.basisFun (Fin d) β (a i))) * | |
| βi,inner β (EuclideanSpace.basisFun (Fin d) β (a i)) (v i) := by | |
| let b := EuclideanSpace.basisFun (Fin d) β | |
| have hv : v=fun i => βj : Fin d,inner β (b j) (v i) β’ b j := by | |
| funext i | |
| exact (b.sum_repr' (v i)).symm | |
| conv_lhs => rw [hv] | |
| rw [A.map_sum] | |
| simp only [inner_sum,A.map_smul_univ,inner_smul_right] | |
| apply Finset.sum_congr rfl | |
| intro a _ | |
| exact mul_comm _ _ | |
| lemma multilinearTensor_compAlong {d n : β} (c : OrderedFinpartition n) | |
| (A : ContinuousMultilinearMap β (fun _ : Fin c.length => Point d) (Point d)) | |
| (B : βi,ContinuousMultilinearMap β (fun _ : Fin (c.partSize i) => Point d) (Point d)) | |
| (a : Unit β Fin n β Fin d) : | |
| multilinearTensor (c.compAlongOrderedFinpartition A B) a = | |
| forestTensor (fun i => Fin (c.partSize i)) (multilinearTensor A) | |
| (fun i q => multilinearTensor (B i) (q β Equiv.sumComm Unit (Fin (c.partSize i)))) | |
| (a β (Equiv.refl Unit).sumCongr c.equivSigma) := by | |
| unfold multilinearTensor forestTensor | |
| rw [OrderedFinpartition.compAlongOrderFinpartition_apply,multilinear_coordinate_expansion] | |
| exact Fintype.sum_equiv (Equiv.refl _) _ _ (fun _ => rfl) | |
| theorem AllSplitBound.compAlong {d n : β} (c : OrderedFinpartition n) | |
| (A : ContinuousMultilinearMap β (fun _ : Fin c.length => Point d) (Point d)) | |
| (B : βi,ContinuousMultilinearMap β (fun _ : Fin (c.partSize i) => Point d) (Point d)) | |
| {M : β} {N : Fin c.length β β} | |
| (hA : AllSplitBound (multilinearTensor A) M) | |
| (hB : βi,AllSplitBound (multilinearTensor (B i)) (N i)) : | |
| AllSplitBound (multilinearTensor (c.compAlongOrderedFinpartition A B)) (M*βi,N i) := by | |
| let (i : Fin c.length) : Nonempty (Fin (c.partSize i)) := Fin.pos_iff_nonempty.mp (c.partSize_pos i) | |
| have hf := hA.forest (fun i => Fin (c.partSize i)) | |
| (fun i => (hB i).reindex (Equiv.sumComm Unit (Fin (c.partSize i)))) | |
| have hh := hf.reindex ((Equiv.refl Unit).sumCongr c.equivSigma) | |
| convert hh using 1 | |
| ext a | |
| exact multilinearTensor_compAlong c A B a | |
| theorem iteratedFDeriv_comp_allSplit {d n : β} {f g : Point d β Point d} (x : Point d) | |
| (hf : ContDiffAt β (n:WithTop ββ) f x) (hg : ContDiffAt β (n:WithTop ββ) g (f x)) | |
| (M N : β β β) (hM : βk,0β€M k) (hN : βk,0β€N k) | |
| (hG : βkβ€n,AllSplitBound (multilinearTensor (iteratedFDeriv β k g (f x))) (M k)) | |
| (hF : βkβ€n,AllSplitBound (multilinearTensor (iteratedFDeriv β k f x)) (N k)) : | |
| AllSplitBound (multilinearTensor (iteratedFDeriv β n (g β f) x)) | |
| (βc : OrderedFinpartition n,M c.length * βi,N (c.partSize i)) := by | |
| rw [iteratedFDeriv_comp hg hf (by exact_mod_cast le_rfl)] | |
| have hh := AllSplitBound.finite_sum | |
| (fun c : OrderedFinpartition n => mul_nonneg (hM _) (Finset.prod_nonneg (fun i _ => hN _))) | |
| (fun c : OrderedFinpartition n => (hG c.length c.length_le).compAlong c _ _ | |
| (fun i => hF (c.partSize i) (c.partSize_le i))) | |
| convert hh using 1 | |
| funext a | |
| simp only [FormalMultilinearSeries.taylorComp,multilinearTensor, | |
| sum_apply,inner_sum,FormalMultilinearSeries.compAlongOrderedFinpartition,ftaylorSeries] | |
| end LogConcaveSampling.TensorEnergy | |
| end | |
| end | |
| section | |
| noncomputable section | |
| namespace LogConcaveSampling | |
| open scoped Classical BigOperators RealInnerProductSpace NNReal | |
| namespace JetCalculus | |
| variable {E : Type*} [NormedAddCommGroup E] [NormedSpace β E] | |
| lemma jet_eq_iteratedFDeriv {ΞΉ : Type*} {f : E β β} | |
| (hf : ContDiff β (β€:ββ) f) (v : ΞΉ β E) (l : List ΞΉ) (x : E) : | |
| jet v l f x=iteratedFDeriv β l.length f x (fun i => v (l.get i)) := by | |
| induction l generalizing x with | |
| | nil => rfl | |
| | cons i l ih => | |
| have he : jet v l f=fun z => iteratedFDeriv β l.length f z (fun i => v (l.get i)) := funext ih | |
| simp only [jet,he,List.length_cons] | |
| rw [(hf.differentiable_iteratedFDeriv (by exact_mod_cast ENat.natCast_lt_top l.length : (l.length:WithTop ββ)<(β€:ββ)) x).iteratedFDeriv_succ_apply_left'] | |
| rfl | |
| lemma jet_finRange_eq_iteratedFDeriv {n : β} {f : E β β} | |
| (hf : ContDiff β (β€:ββ) f) (v : Fin n β E) (x : E) : | |
| jet v (List.finRange n) f x=iteratedFDeriv β n f x v := by | |
| induction n generalizing x with | |
| | zero => rfl | |
| | succ n ih => | |
| rw [List.finRange_succ] | |
| simp only [jet,jet_map] | |
| have he : jet (v β Fin.succ) (List.finRange n) f=fun z => iteratedFDeriv β n f z (Fin.tail v) := | |
| funext (fun z => ih _ z) | |
| rw [he,(hf.differentiable_iteratedFDeriv (by exact_mod_cast ENat.natCast_lt_top n) x).iteratedFDeriv_succ_apply_left'] | |
| rfl | |
| end JetCalculus | |
| lemma multilinearTensor_iterated_mean {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) | |
| (n : β) (y : Point d) (c : Unit β Fin n β Fin d) : | |
| TensorEnergy.multilinearTensor (iteratedFDeriv β n (conditionalFieldMean F x r Ο) y) c= | |
| Ο^n*((lam:β)*r)*normalizedTensor F x r Ο ((lam:β)*r) y | |
| (Sum.elim (fun _ => false) (fun _ => true)) | |
| ((List.finRange n).map Sum.inl++[Sum.inr ()]) (c β Equiv.sumComm (Fin n) Unit) := by | |
| let L := innerSL β (EuclideanSpace.basisFun (Fin d) β (c (Sum.inl ()))) | |
| have hm := conditionalFieldMean_smooth hF x hr.le hl hΟ0 hΟ1 | |
| have hh := conditionalFieldMean_jet_normalized hF x hr hlam hl hΟ0 hΟ1 y | |
| (List.finRange n) (by simp) (c β Equiv.sumComm (Fin n) Unit) | |
| change JetCalculus.jet (fun i => EuclideanSpace.basisFun (Fin d) β (c (Sum.inr i))) | |
| (List.finRange n) (L β conditionalFieldMean F x r Ο) y=_ at hh | |
| rw [JetCalculus.jet_finRange_eq_iteratedFDeriv (L.contDiff.comp hm)] at hh | |
| rw [L.iteratedFDeriv_comp_left hm.contDiffAt (by exact_mod_cast (le_top : (n:ββ)β€β€))] at hh | |
| simpa only [Fintype.card_fin,ContinuousLinearMap.compContinuousMultilinearMap_coe, Function.comp_apply, L, | |
| innerSL_apply_apply,TensorEnergy.multilinearTensor] using hh | |
| lemma conditionalMean_iterated_allSplit {d n : β} {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) : | |
| TensorEnergy.AllSplitBound | |
| (TensorEnergy.multilinearTensor (iteratedFDeriv β n (conditionalFieldMean F x r Ο) y)) | |
| (((lam:β)*r)*normalizedTensorMajorant (n+1) (1-Ο^2)) := by | |
| have hb := normalizedTensor_allSplit hF x hr hlam hl hΟ0 hΟ1 y | |
| (Sum.elim (fun _ : Fin n => false) (fun _ : Unit => true)) | |
| ((List.finRange n).map Sum.inl++[Sum.inr ()]) | |
| (by | |
| simpa using JetCalculus.nodup_sum_append (List.nodup_finRange n) | |
| (by simp : ([()] : List Unit).Nodup)) (by intro t; cases t <;> simp) | |
| have hrb := (hb.reindex (Equiv.sumComm (Fin n) Unit)).const_mul (Ο^n*((lam:β)*r)) | |
| simp only [Fintype.card_sum,Fintype.card_fin,Fintype.card_unique] at hrb | |
| have hh := hrb.mono (mul_nonneg (by positivity) (normalizedTensorMajorant_nonneg _ _)) (show | |
| Ο^n*((lam:β)*r)*normalizedTensorMajorant (n+1) (1-Ο^2)β€ | |
| ((lam:β)*r)*normalizedTensorMajorant (n+1) (1-Ο^2) by | |
| rw [mul_assoc] | |
| exact mul_le_of_le_one_left (mul_nonneg (by positivity) (normalizedTensorMajorant_nonneg _ _)) | |
| (pow_le_oneβ hΟ0 hΟ1.le)) | |
| convert hh using 1 | |
| funext c | |
| exact multilinearTensor_iterated_mean hF x hr hlam hl hΟ0 hΟ1 n y c | |
| end LogConcaveSampling | |
| end | |
| end | |
| section | |
| noncomputable section | |
| namespace LogConcaveSampling.TensorEnergy | |
| open scoped Classical BigOperators RealInnerProductSpace | |
| def arrayTensor {d : β} {S I : Type} | |
| (A : ContinuousMultilinearMap β (fun _ : I => Point d) ((S β Fin d) β β)) | |
| (c : S β I β Fin d) : β := | |
| A (fun i => EuclideanSpace.basisFun (Fin d) β (c (Sum.inr i))) | |
| (fun s => c (Sum.inl s)) | |
| lemma arrayTensor_coordinate_expansion {d : β} {S I : Type} [Fintype S] [DecidableEq S] [Fintype I] [DecidableEq I] | |
| (A : ContinuousMultilinearMap β (fun _ : I => Point d) ((S β Fin d) β β)) | |
| (v : I β Point d) (o : S β Fin d) : | |
| A v o=βa : I β Fin d,A (fun i => EuclideanSpace.basisFun (Fin d) β (a i)) o* | |
| βi,inner β (EuclideanSpace.basisFun (Fin d) β (a i)) (v i) := by | |
| let b := EuclideanSpace.basisFun (Fin d) β | |
| have hv : v=fun i => βj : Fin d,inner β (b j) (v i) β’ b j := by | |
| funext i | |
| exact (b.sum_repr' (v i)).symm | |
| conv_lhs => rw [hv] | |
| rw [A.map_sum] | |
| simp only [A.map_smul_univ,Finset.sum_apply,Pi.smul_apply,smul_eq_mul] | |
| exact Finset.sum_congr rfl (fun _ _ => mul_comm _ _) | |
| lemma arrayTensor_compAlong {d n : β} {S : Type} [Fintype S] [DecidableEq S] (c : OrderedFinpartition n) | |
| (A : ContinuousMultilinearMap β (fun _ : Fin c.length => Point d) ((S β Fin d) β β)) | |
| (B : βi,ContinuousMultilinearMap β (fun _ : Fin (c.partSize i) => Point d) (Point d)) | |
| (a : S β Fin n β Fin d) : | |
| arrayTensor (c.compAlongOrderedFinpartition A B) a= | |
| forestTensor (fun i => Fin (c.partSize i)) (arrayTensor A) | |
| (fun i q => multilinearTensor (B i) (q β Equiv.sumComm Unit (Fin (c.partSize i)))) | |
| (a β (Equiv.refl S).sumCongr c.equivSigma) := by | |
| unfold arrayTensor forestTensor | |
| rw [OrderedFinpartition.compAlongOrderFinpartition_apply,arrayTensor_coordinate_expansion] | |
| exact Fintype.sum_equiv (Equiv.refl _) _ _ (fun _ => rfl) | |
| lemma AllSplitBound.array_compAlong {d n : β} {S : Type} [Fintype S] [DecidableEq S] [Nonempty S] | |
| (c : OrderedFinpartition n) | |
| (A : ContinuousMultilinearMap β (fun _ : Fin c.length => Point d) ((S β Fin d) β β)) | |
| (B : βi,ContinuousMultilinearMap β (fun _ : Fin (c.partSize i) => Point d) (Point d)) | |
| {M : β} {N : Fin c.length β β} | |
| (hA : AllSplitBound (arrayTensor A) M) | |
| (hB : βi,AllSplitBound (multilinearTensor (B i)) (N i)) : | |
| AllSplitBound (arrayTensor (c.compAlongOrderedFinpartition A B)) (M*βi,N i) := by | |
| let (i : Fin c.length) : Nonempty (Fin (c.partSize i)) := Fin.pos_iff_nonempty.mp (c.partSize_pos i) | |
| have hf := hA.forest (fun i => Fin (c.partSize i)) | |
| (fun i => (hB i).reindex (Equiv.sumComm Unit (Fin (c.partSize i)))) | |
| have hh := hf.reindex ((Equiv.refl S).sumCongr c.equivSigma) | |
| convert hh using 1 | |
| ext a | |
| exact arrayTensor_compAlong c A B a | |
| lemma iteratedFDeriv_array_comp_allSplit {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 : ContDiffAt β (n:WithTop ββ) f x) (hg : ContDiffAt β (n:WithTop ββ) g (f x)) | |
| (M N : β β β) (hM : βk,0β€M k) (hN : βk,0β€N k) | |
| (hG : βkβ€n,AllSplitBound (arrayTensor (iteratedFDeriv β k g (f x))) (M k)) | |
| (hF : βkβ€n,AllSplitBound (multilinearTensor (iteratedFDeriv β k f x)) (N k)) : | |
| AllSplitBound (arrayTensor (iteratedFDeriv β n (g β f) x)) | |
| (βc : OrderedFinpartition n,M c.length*βi,N (c.partSize i)) := by | |
| rw [iteratedFDeriv_comp hg hf (by exact_mod_cast le_rfl)] | |
| have hh := AllSplitBound.finite_sum | |
| (fun c : OrderedFinpartition n => mul_nonneg (hM _) (Finset.prod_nonneg (fun i _ => hN _))) | |
| (fun c : OrderedFinpartition n => (hG c.length c.length_le).array_compAlong c _ _ | |
| (fun i => hF (c.partSize i) (c.partSize_le i))) | |
| convert hh using 1 | |
| funext a | |
| simp only [FormalMultilinearSeries.taylorComp,arrayTensor, | |
| sum_apply,Finset.sum_apply,FormalMultilinearSeries.compAlongOrderedFinpartition,ftaylorSeries] | |
| lemma spatialTensor_eq_arrayTensor {d n : β} {S : Type} [Fintype S] [DecidableEq S] | |
| {g : Point d β (S β Fin d) β β} (hg : ContDiff β (β€:ββ) g) (y : Point d) : | |
| spatialTensor (fun c z => g z c) (List.finRange n) y= | |
| fun c => arrayTensor (iteratedFDeriv β n g y) (c β Equiv.sumComm S (Fin n)) := by | |
| funext c | |
| let L : ((S β Fin d) β β) βL[β] β := ContinuousLinearMap.proj (fun s => c (Sum.inr s)) | |
| dsimp [spatialTensor] | |
| change JetCalculus.jet _ _ (L β g) y=_ | |
| rw [JetCalculus.jet_finRange_eq_iteratedFDeriv (L.contDiff.comp hg), | |
| L.iteratedFDeriv_comp_left hg.contDiffAt (by exact_mod_cast (le_top : (n:ββ)β€β€))] | |
| rfl | |
| lemma AllSplitBound.of_spatialTensor {d n : β} {S : Type} [Fintype S] [DecidableEq S] | |
| {g : Point d β (S β Fin d) β β} (hg : ContDiff β (β€:ββ) g) (y : Point d) {C : β} | |
| (h : AllSplitBound (spatialTensor (fun c z => g z c) (List.finRange n) y) C) : | |
| AllSplitBound (arrayTensor (iteratedFDeriv β n g y)) C := by | |
| rw [spatialTensor_eq_arrayTensor hg y] at h | |
| have hh := h.reindex (Equiv.sumComm (Fin n) S) | |
| simpa only [Function.comp_def,Equiv.sumComm_apply,Sum.swap_swap] using hh | |
| end LogConcaveSampling.TensorEnergy | |
| end | |
| end | |
| end | |
| end OAI | |