Download data/lean/OAI/Probability/LogConcave/JetEstimates/Material.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 7.11 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Probability/LogConcave/JetEstimates/Material.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Probability/LogConcave/JetEstimates/Material.lean
-
curl -L -o Material.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Probability/LogConcave/JetEstimates/Material.lean
7.11 kB
| import Mathlib | |
| import OAI.Probability.LogConcave.JetEstimates.TensorTerm | |
| namespace OAI | |
| section | |
| section | |
| noncomputable section | |
| namespace LogConcaveSampling | |
| open scoped Classical BigOperators NNReal | |
| namespace TensorSum | |
| variable {S T : Type} | |
| lemma weightLE_pure (A : TensorAtom S) {w : β} (h : A.expression.weightβ€w) : | |
| (pure A).weightLE w := fun _ => h | |
| lemma weightLE_add {A B : TensorSum S} {w : β} (hA : A.weightLE w) (hB : B.weightLE w) : | |
| (A.add B).weightLE w := by | |
| intro i; cases i with | |
| | inl i => exact hA i | |
| | inr i => exact hB i | |
| lemma weightLE_scale {A : TensorSum S} {w : β} (hA : A.weightLE w) (n : β) (P : Polynomial β) : | |
| (A.scale n P).weightLE w := hA | |
| lemma weightLE_relabel {A : TensorSum S} {w : β} (hA : A.weightLE w) (e : S β T) : | |
| (A.relabel e).weightLE w := hA | |
| lemma weightLE_adjoint [Fintype S] (hn : 2β€Fintype.card S) {A : TensorSum (S β Unit)} | |
| {w : β} (hA : A.weightLE w) : (A.adjoint hn).weightLE (w+1) := by | |
| intro i | |
| change ((A.term i).atom.adjoint hn).expression.weightβ€w+1 | |
| rw [TensorAtom.adjoint_weight] | |
| exact Nat.add_le_add_right (hA i) 1 | |
| lemma weightLE_contract [Fintype S] [Fintype T] [Nonempty S] [Nonempty T] | |
| {A : TensorSum (S β Unit)} {B : TensorSum (T β Unit)} {w z : β} | |
| (hA : A.weightLE w) (hB : B.weightLE z) : (A.contract B).weightLE (w+z) := by | |
| intro i | |
| change ((A.term i.1).atom.contract (B.term i.2).atom).expression.weightβ€w+z | |
| rw [TensorAtom.contract_weight] | |
| exact Nat.add_le_add (hA _) (hB _) | |
| lemma weightLE_mono {A : TensorSum S} {w z : β} (hA : A.weightLE w) (h : wβ€z) : | |
| A.weightLE z := fun i => (hA i).trans h | |
| end TensorSum | |
| namespace TensorAtom | |
| variable {S T : Type} | |
| def HasMaterial (A : TensorAtom S) (B : TensorSum S) : Prop := | |
| β{d : β} {F : Point d β β} {lam : ββ₯0}, Primitive F lam β | |
| β(x : Point d) {r Ο : β}, 0<r β 0<lam β (lam:β)*r^2β€1/2 β 0β€Ο β Ο<1 β | |
| β(c : S β Fin d) (y : Point d), | |
| JetCalculus.mdir (1,0) jointSpace r (jointMean F x r) | |
| (A.eval F x r ((lam:β)*r) c) (Ο,y)=B.eval F x r ((lam:β)*r) c (Ο,y) | |
| lemma timeSmooth {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) (A : TensorAtom S) (c : S β Fin d) : | |
| JetCalculus.TimeSmooth (A.eval F x r ((lam:β)*r) c) := | |
| A.expression.jointEval_timeSmooth hF x hr hlam hl _ | |
| lemma HasMaterial.relabel {A : TensorAtom S} {B : TensorSum S} (h : A.HasMaterial B) (e : S β T) : | |
| (A.relabel e).HasMaterial (B.relabel e) := by | |
| intro d F lam hF x r Ο hr hlam hl h0 h1 c y | |
| exact h hF x hr hlam hl h0 h1 (c β e) y | |
| lemma HasMaterial.contract [Fintype S] [Fintype T] [Nonempty S] [Nonempty T] | |
| {A : TensorAtom (S β Unit)} {B : TensorAtom (T β Unit)} | |
| {DA : TensorSum (S β Unit)} {DB : TensorSum (T β Unit)} | |
| (hA : A.HasMaterial DA) (hB : B.HasMaterial DB) : | |
| (A.contract B).HasMaterial ((DA.contract (TensorSum.pure B)).add ((TensorSum.pure A).contract DB)) := by | |
| intro d F lam hF x r Ο hr hlam hl h0 h1 c y | |
| have hsA (k : Fin d) := A.timeSmooth hF x hr hlam hl | |
| (Sum.elim (fun s => c (Sum.inl s)) (fun _ => k)) (Ο,y) (by dsimp; linarith) h1 | |
| have hsB (k : Fin d) := B.timeSmooth hF x hr hlam hl | |
| (Sum.elim (fun s => c (Sum.inr s)) (fun _ => k)) (Ο,y) (by dsimp; linarith) h1 | |
| have he : (A.contract B).eval F x r ((lam:β)*r) c=fun p => | |
| βk : Fin d,A.eval F x r ((lam:β)*r) (Sum.elim (fun s => c (Sum.inl s)) (fun _ => k)) p* | |
| B.eval F x r ((lam:β)*r) (Sum.elim (fun s => c (Sum.inr s)) (fun _ => k)) p := | |
| funext (contract_eval A B F x r _ c) | |
| rw [he,JetCalculus.mdir_sum_at Finset.univ _ _ _ _ (fun k _ => ((hsA k).mul (hsB k)).differentiableAt (by simp))] | |
| simp_rw [JetCalculus.mdir_mul_at _ _ _ _ ((hsA _).differentiableAt (by simp)) ((hsB _).differentiableAt (by simp)), | |
| hA hF x hr hlam hl h0 h1,hB hF x hr hlam hl h0 h1] | |
| rw [TensorSum.add_eval,TensorSum.contract_eval,TensorSum.contract_eval] | |
| simp_rw [TensorSum.pure_eval] | |
| exact Finset.sum_add_distrib | |
| lemma HasMaterial.adjoint [Fintype S] [Nonempty S] (hn : 2β€Fintype.card S) | |
| {A : TensorAtom (S β Unit)} {DA : TensorSum (S β Unit)} (hA : A.HasMaterial DA) : | |
| (A.adjoint hn).HasMaterial ((DA.adjoint hn).add | |
| ((TensorSum.pure (A.insertOne.adjoint hn)).scale 1 Polynomial.X)) := by | |
| intro d F lam hF x r Ο hr hlam hl h0 h1 c y | |
| let L : β := (lam:β)*r | |
| let V : Fin d β β Γ Point d β β := fun k => A.eval F x r L (Sum.elim c (fun _ => k)) | |
| let W : Fin d β β Γ Point d β β := fun k => DA.eval F x r L (Sum.elim c (fun _ => k)) | |
| have hV (k : Fin d) : ContDiffAt β (β€:ββ) (V k) (Ο,y) := | |
| A.timeSmooth hF x hr hlam hl _ (Ο,y) (by dsimp; linarith) h1 | |
| have hW (k : Fin d) : ContDiffAt β (β€:ββ) (W k) (Ο,y) := | |
| DA.timeSmooth hF x hr hlam hl _ (Ο,y) (by dsimp; linarith) h1 | |
| have hp : Ο^2<1 := by nlinarith | |
| have hM := jointMean_smooth_at hF x hr.le hl (p:=(Ο,y)) hp | |
| have hda : JetCalculus.gadj jointSpace (jointScore F x r) | |
| (fun k => JetCalculus.mdir (1,0) jointSpace r (jointMean F x r) (V k)) (Ο,y)= | |
| JetCalculus.gadj jointSpace (jointScore F x r) W (Ο,y) := by | |
| apply JetCalculus.gadj_slice_congr_at _ | |
| Β· intro k; exact (JetCalculus.smooth_mdir_at _ _ _ hM (hV k)).differentiableAt (by simp) | |
| Β· intro k; exact (hW k).differentiableAt (by simp) | |
| Β· intro k z; exact hA hF x hr hlam hl h0 h1 _ z | |
| let I : Fin d β β Γ Point d β β := fun k => A.insertOne.eval F x r L (Sum.elim c (fun _ => k)) | |
| have hI (k : Fin d) : ContDiffAt β (β€:ββ) (I k) (Ο,y) := | |
| A.insertOne.timeSmooth hF x hr hlam hl _ (Ο,y) (by dsimp; linarith) h1 | |
| have hdi : JetCalculus.gadj jointSpace (jointScore F x r) | |
| (fun k p => βi,JetCalculus.dir (jointSpace i) (jointMean F x r k) p*V i p) (Ο,y)= | |
| L*Ο*JetCalculus.gadj jointSpace (jointScore F x r) I (Ο,y) := by | |
| rw [βJetCalculus.gadj_scalar_at _ _ (fun k => (hI k).differentiableAt (by simp)) (L*Ο)] | |
| apply JetCalculus.gadj_slice_congr_at _ | |
| Β· intro k; exact (ContDiffAt.sum (fun i _ => | |
| (JetCalculus.smooth_dir_at (hM k) _).mul (hV i))).differentiableAt (by simp) | |
| Β· intro k; exact (contDiffAt_const.mul (hI k)).differentiableAt (by simp) | |
| Β· intro k z | |
| have hh := insertOne_mean hF x hr hlam hl h0 h1 A (Sum.elim c (fun _ => k)) z | |
| simpa only [Sum.elim_inl,Sum.elim_inr] using hh | |
| rw [adjoint_eval,physical_material_adjoint_nonneg hF x hr hlam hl h0 h1 hV] | |
| change JetCalculus.gadj jointSpace (jointScore F x r) | |
| (fun k => JetCalculus.mdir (1,0) jointSpace r (jointMean F x r) (V k)) (Ο,y)+ | |
| r*JetCalculus.gadj jointSpace (jointScore F x r) | |
| (fun k p => βi,JetCalculus.dir (jointSpace i) (jointMean F x r k) p*V i p) (Ο,y)=_ | |
| rw [hda,hdi,TensorSum.add_eval,TensorSum.adjoint_eval hF x hr hlam hl h0 h1, | |
| TensorSum.scale_eval,TensorSum.pure_eval,adjoint_eval] | |
| simp only [pow_one,Polynomial.eval_X] | |
| dsimp only [W,I,L] | |
| ring | |
| end TensorAtom | |
| end LogConcaveSampling | |
| end | |
| end | |
| end | |
| end OAI | |