Download data/lean/OAI/Probability/LogConcave/JetEstimates/JetMaterial.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 25.7 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Probability/LogConcave/JetEstimates/JetMaterial.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Probability/LogConcave/JetEstimates/JetMaterial.lean
-
curl -L -o JetMaterial.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Probability/LogConcave/JetEstimates/JetMaterial.lean
25.7 kB
| import Mathlib | |
| import OAI.Probability.LogConcave.JetEstimates.Material | |
| namespace OAI | |
| section | |
| section | |
| noncomputable section | |
| namespace LogConcaveSampling | |
| open scoped Classical BigOperators NNReal | |
| namespace TensorAtom | |
| variable {S T : Type} | |
| @[simp] lemma lastEquiv_symm_inl {n : β} (e : Fin n β S) (s : S) : | |
| (lastEquiv e).symm (Sum.inl s)=(e.symm s).castSucc := by | |
| apply (lastEquiv e).injective | |
| simp | |
| @[simp] lemma lastEquiv_symm_inr {n : β} (e : Fin n β S) (s : Unit) : | |
| (lastEquiv e).symm (Sum.inr s)=Fin.last n := by | |
| cases s | |
| apply (lastEquiv e).injective | |
| simp | |
| lemma HasMaterial.congr {A A' : TensorAtom S} {B : TensorSum S} | |
| (h : A.HasMaterial B) | |
| (he : β{d : β} (F : Point d β β) (x : Point d) (r L : β) (c : S β Fin d), | |
| A'.eval F x r L c=A.eval F x r L c) : A'.HasMaterial B := by | |
| intro d F lam hF x r Ο hr hlam hl h0 h1 c y | |
| rw [he] | |
| exact h hF x hr hlam hl h0 h1 c y | |
| variable [Fintype S] | |
| def jetMaterial (l : List S) (hN : l.Nodup) (hall : βs,sβl) (hne : lβ []) : TensorSum (S β Unit) := | |
| (TensorSum.pure ((extendedU l hN hall).adjoint (jetCard l hN hall hne))).add | |
| β¨SplitIndex l,inferInstance,fun a => β¨1,Polynomial.C 2*Polynomial.X,splitAtom l hN hall aβ©β© | |
| lemma jetMaterial_weight (l : List S) (hN : l.Nodup) (hall : βs,sβl) (hne : lβ []) : | |
| (jetMaterial l hN hall hne).weightLE ((jetList l hN hall hne).expression.weight+2) := by | |
| apply TensorSum.weightLE_add | |
| Β· apply TensorSum.weightLE_pure | |
| rw [adjoint_weight,extendedU_weight,jetList_weight] | |
| have := List.length_pos_iff.mpr hne | |
| omega | |
| Β· intro a | |
| change (splitAtom l hN hall a).expression.weightβ€_ | |
| rw [splitAtom_weight,jetList_weight] | |
| omega | |
| lemma hasMaterial_jetList (l : List S) (hN : l.Nodup) (hall : βs,sβl) (hne : lβ []) : | |
| (jetList l hN hall hne).HasMaterial (jetMaterial l hN hall hne) := by | |
| intro d F lam hF x r Ο hr hlam hl h0 h1 c y | |
| rw [material_jetList hF x hr hlam hl h0 h1] | |
| unfold jetMaterial | |
| rw [TensorSum.add_eval,TensorSum.pure_eval] | |
| congr 1 | |
| change 2*(r*((lam:β)*r))*Ο*(βa : SplitIndex l,(splitAtom l hN hall a).eval F x r ((lam:β)*r) c (Ο,y))= | |
| βa : SplitIndex l,(r*((lam:β)*r))^1*(Polynomial.C (2:β)*Polynomial.X).eval Ο* | |
| (splitAtom l hN hall a).eval F x r ((lam:β)*r) c (Ο,y) | |
| rw [Finset.mul_sum] | |
| apply Finset.sum_congr rfl | |
| intro a _ | |
| simp only [Polynomial.eval_mul,Polynomial.eval_C,Polynomial.eval_X,pow_one] | |
| ring | |
| end TensorAtom | |
| namespace TensorExpression | |
| def atom {n : β} (A : TensorExpression n) : TensorAtom (Fin n) := β¨n,A,Equiv.refl _β© | |
| lemma atom_eval {d n : β} (A : TensorExpression n) (F : Point d β β) (x : Point d) (r L : β) | |
| (c : Fin n β Fin d) : A.atom.eval F x r L c=A.jointEval F x r L c := rfl | |
| @[simp] lemma atom_weight {n : β} (A : TensorExpression n) : A.atom.expression.weight=A.weight := rfl | |
| lemma jet_atom_eval {d : β} (q : β) (F : Point d β β) (x : Point d) (r L : β) | |
| (c : Fin (q+2) β Fin d) : | |
| (jet q).atom.eval F x r L c= | |
| ((TensorAtom.jetList (List.finRange (q+1)) (List.nodup_finRange _) (by simp) (by simp)).relabel (TensorAtom.lastEquiv (Equiv.refl (Fin (q+1)))).symm).eval F x r L c := by | |
| rw [TensorAtom.relabel_eval,TensorAtom.jetList_eval] | |
| change (fun p => Lβ»ΒΉ*jointU F x r L _ _ _ p)=_ | |
| simp only [Function.comp_apply,TensorAtom.lastEquiv_symm_inl,TensorAtom.lastEquiv_symm_inr,Equiv.refl_symm,Equiv.refl_apply] | |
| rfl | |
| lemma jet_hasMaterial (q : β) : βB : TensorSum (Fin (q+2)), | |
| B.weightLE (q+2) β§ (jet q).atom.HasMaterial B := by | |
| let l := List.finRange (q+1) | |
| let hN : l.Nodup := List.nodup_finRange _ | |
| let hall : βs,sβl := by simp [l] | |
| let hne : lβ [] := by simp [l] | |
| let e := (TensorAtom.lastEquiv (Equiv.refl (Fin (q+1)))).symm | |
| refine β¨(TensorAtom.jetMaterial l hN hall hne).relabel e,?_,?_β© | |
| Β· have h := TensorSum.weightLE_relabel (TensorAtom.jetMaterial_weight l hN hall hne) e | |
| simpa only [TensorAtom.jetList_weight,l,List.length_finRange,Nat.add_sub_cancel] using h | |
| Β· exact TensorAtom.HasMaterial.congr | |
| (TensorAtom.HasMaterial.relabel (TensorAtom.hasMaterial_jetList l hN hall hne) e) (jet_atom_eval q) | |
| end TensorExpression | |
| end LogConcaveSampling | |
| end | |
| end | |
| section | |
| noncomputable section | |
| namespace LogConcaveSampling | |
| open scoped Classical BigOperators NNReal | |
| namespace TensorExpression | |
| lemma atom_contract_eval {d m n : β} (hm : 0 < m) (hn : 0 < n) | |
| [Nonempty (Fin m)] [Nonempty (Fin n)] (A : TensorExpression (m+1)) (B : TensorExpression (n+1)) | |
| (F : Point d β β) (x : Point d) (r L : β) (c : Fin (m+n) β Fin d) : | |
| (TensorExpression.contract hm hn A B).atom.eval F x r L c= | |
| (((A.atom.relabel (TensorAtom.lastEquiv (Equiv.refl (Fin m)))).contract | |
| (B.atom.relabel (TensorAtom.lastEquiv (Equiv.refl (Fin n))))).relabel finSumFinEquiv).eval F x r L c := by | |
| rw [TensorAtom.relabel_eval] | |
| funext p | |
| rw [TensorAtom.contract_eval] | |
| change (βk : Fin d,A.jointEval F x r L _ p*B.jointEval F x r L _ p)=_ | |
| apply Finset.sum_congr rfl | |
| intro k _ | |
| simp only [TensorAtom.relabel_eval,atom_eval] | |
| congr 2 | |
| Β· funext j | |
| induction j using Fin.lastCases <;> simp [TensorExpression.atom] | |
| rfl | |
| Β· funext j | |
| induction j using Fin.lastCases <;> simp [TensorExpression.atom] | |
| rfl | |
| lemma atom_adjoint_eval {d n : β} (hn : 2β€n) (A : TensorExpression (n+1)) | |
| (F : Point d β β) (x : Point d) (r L : β) (c : Fin n β Fin d) : | |
| (TensorExpression.adjoint hn A).atom.eval F x r L c= | |
| ((A.atom.relabel (TensorAtom.lastEquiv (Equiv.refl (Fin n)))).adjoint | |
| (by simpa using hn)).eval F x r L c := by | |
| rw [TensorAtom.adjoint_eval] | |
| change JetCalculus.gadj jointSpace (jointScore F x r) (fun k => A.jointEval F x r L (Fin.snoc c k))=_ | |
| congr 1 | |
| funext k | |
| rw [TensorAtom.relabel_eval,atom_eval] | |
| congr 1 | |
| funext j | |
| induction j using Fin.lastCases <;> simp | |
| theorem hasMaterial {n : β} (A : TensorExpression n) : | |
| βB : TensorSum (Fin n), B.weightLE (A.weight+2) β§ A.atom.HasMaterial B := by | |
| induction A with | |
| | jet q => exact jet_hasMaterial q | |
| | perm e A ih => | |
| obtain β¨B,hB,hβ© := ih | |
| refine β¨B.relabel e,TensorSum.weightLE_relabel hB e,?_β© | |
| apply TensorAtom.HasMaterial.congr (TensorAtom.HasMaterial.relabel h e) | |
| intros | |
| rfl | |
| | @contract m n hm hn A B ihA ihB => | |
| let : NeZero m := β¨Nat.ne_of_gt hmβ© | |
| let : NeZero n := β¨Nat.ne_of_gt hnβ© | |
| obtain β¨DA,hDA,hAβ© := ihA | |
| obtain β¨DB,hDB,hBβ© := ihB | |
| let eA := TensorAtom.lastEquiv (Equiv.refl (Fin m)) | |
| let eB := TensorAtom.lastEquiv (Equiv.refl (Fin n)) | |
| let AA := A.atom.relabel eA | |
| let BB := B.atom.relabel eB | |
| let RA := DA.relabel eA | |
| let RB := DB.relabel eB | |
| let D := (RA.contract (TensorSum.pure BB)).add ((TensorSum.pure AA).contract RB) | |
| refine β¨D.relabel finSumFinEquiv,?_,?_β© | |
| Β· apply TensorSum.weightLE_relabel | |
| apply TensorSum.weightLE_add | |
| Β· have hh := TensorSum.weightLE_contract (TensorSum.weightLE_relabel hDA eA) | |
| (TensorSum.weightLE_pure BB (Nat.le_refl BB.expression.weight)) | |
| convert hh using 1 | |
| simp only [BB,TensorAtom.relabel,atom_weight,weight] | |
| omega | |
| Β· have hh := TensorSum.weightLE_contract (TensorSum.weightLE_pure AA (Nat.le_refl AA.expression.weight)) | |
| (TensorSum.weightLE_relabel hDB eB) | |
| convert hh using 1 | |
| simp only [AA,TensorAtom.relabel,atom_weight,weight] | |
| omega | |
| Β· exact TensorAtom.HasMaterial.congr | |
| (TensorAtom.HasMaterial.relabel | |
| (TensorAtom.HasMaterial.contract (TensorAtom.HasMaterial.relabel hA eA) | |
| (TensorAtom.HasMaterial.relabel hB eB)) finSumFinEquiv) | |
| (atom_contract_eval hm hn A B) | |
| | @adjoint n hn A ih => | |
| let : NeZero n := β¨by omegaβ© | |
| obtain β¨DA,hDA,hAβ© := ih | |
| let e := TensorAtom.lastEquiv (Equiv.refl (Fin n)) | |
| let AA := A.atom.relabel e | |
| let hcard : 2β€Fintype.card (Fin n) := by simpa using hn | |
| refine β¨((DA.relabel e).adjoint hcard).add | |
| ((TensorSum.pure (AA.insertOne.adjoint hcard)).scale 1 Polynomial.X),?_,?_β© | |
| Β· apply TensorSum.weightLE_add | |
| Β· simpa only [weight,Nat.add_assoc,Nat.add_comm,Nat.add_left_comm] using | |
| TensorSum.weightLE_adjoint hcard (TensorSum.weightLE_relabel hDA e) | |
| Β· apply TensorSum.weightLE_scale | |
| apply TensorSum.weightLE_pure | |
| rw [TensorAtom.adjoint_weight,TensorAtom.insertOne_weight] | |
| change A.weight+1β€A.weight+1+2 | |
| omega | |
| Β· exact TensorAtom.HasMaterial.congr | |
| (TensorAtom.HasMaterial.adjoint hcard (TensorAtom.HasMaterial.relabel hA e)) | |
| (atom_adjoint_eval hn A) | |
| end TensorExpression | |
| end LogConcaveSampling | |
| end | |
| end | |
| section | |
| noncomputable section | |
| namespace LogConcaveSampling | |
| open scoped Classical BigOperators NNReal | |
| namespace TensorAtom | |
| variable {S : Type} | |
| theorem hasMaterial (A : TensorAtom S) : βB : TensorSum S, | |
| B.weightLE (A.expression.weight+2) β§ A.HasMaterial B := by | |
| obtain β¨B,hB,hβ© := A.expression.hasMaterial | |
| refine β¨B.relabel A.labels,TensorSum.weightLE_relabel hB A.labels,?_β© | |
| exact TensorAtom.HasMaterial.congr (TensorAtom.HasMaterial.relabel h A.labels) (by intros; rfl) | |
| end TensorAtom | |
| namespace TensorSum | |
| variable {S : Type} | |
| def combine {I : Type} [Fintype I] (f : I β TensorSum S) : TensorSum S := | |
| β¨(i : I) Γ (f i).index,inferInstance,fun a => (f a.1).term a.2β© | |
| lemma combine_eval {I : Type} [Fintype I] (f : I β TensorSum S) {d : β} | |
| (F : Point d β β) (x : Point d) (r L : β) (c : S β Fin d) (p : β Γ Point d) : | |
| (combine f).eval F x r L c p=βi,(f i).eval F x r L c p := by | |
| change (βa : (i : I) Γ (f i).index,((f a.1).term a.2).eval F x r L c p)=_ | |
| rw [Fintype.sum_sigma] | |
| rfl | |
| lemma weightLE_combine {I : Type} [Fintype I] {f : I β TensorSum S} {w : β} | |
| (h : βi,(f i).weightLE w) : (combine f).weightLE w := fun a => h a.1 a.2 | |
| def HasMaterial (A 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 HasMaterial.pure {A : TensorAtom S} {B : TensorSum S} (h : A.HasMaterial B) : | |
| (pure A).HasMaterial B := by | |
| intro d F lam hF x r Ο hr hlam hl h0 h1 c y | |
| rw [pure_eval] | |
| exact h hF x hr hlam hl h0 h1 c y | |
| lemma HasMaterial.scale {A B : TensorSum S} (h : A.HasMaterial B) (n : β) (P : Polynomial β) : | |
| (A.scale n P).HasMaterial ((A.scale n P.derivative).add (B.scale n P)) := by | |
| intro d F lam hF x r Ο hr hlam hl h0 h1 c y | |
| have hS := A.timeSmooth hF x hr hlam hl c (Ο,y) (by dsimp; linarith) h1 | |
| have hP := (polynomialTime_smooth (d:=d) P).contDiffAt (x:=(Ο,y)) | |
| have he : (A.scale n P).eval F x r ((lam:β)*r) c=fun p => | |
| (r*((lam:β)*r))^n*(P.eval p.1*A.eval F x r ((lam:β)*r) c p) := by | |
| funext p | |
| rw [scale_eval] | |
| ring | |
| rw [he,JetCalculus.mdir_const_mul_at _ _ _ _ ((hP.mul hS).differentiableAt (by simp)), | |
| JetCalculus.mdir_mul_at _ _ _ _ (hP.differentiableAt (by simp)) (hS.differentiableAt (by simp)), | |
| JetCalculus.mdir_time,h hF x hr hlam hl h0 h1,add_eval,scale_eval,scale_eval] | |
| ring | |
| lemma HasMaterial.combine {I : Type} [Fintype I] {f g : I β TensorSum S} | |
| (h : βi,(f i).HasMaterial (g i)) : (combine f).HasMaterial (combine g) := by | |
| intro d F lam hF x r Ο hr hlam hl h0 h1 c y | |
| have he : (TensorSum.combine f).eval F x r ((lam:β)*r) c=fun p => βi,(f i).eval F x r ((lam:β)*r) c p := | |
| funext (fun p => combine_eval f F x r ((lam:β)*r) c p) | |
| rw [he,JetCalculus.mdir_sum_at Finset.univ _ _ _ _ (fun i _ => | |
| ((f i).timeSmooth hF x hr hlam hl c (Ο,y) (by dsimp; linarith) h1).differentiableAt (by simp)),TensorSum.combine_eval] | |
| apply Finset.sum_congr rfl | |
| intro i _ | |
| exact h i hF x hr hlam hl h0 h1 c y | |
| lemma HasMaterial.congr {A A' B : TensorSum S} (h : A.HasMaterial B) | |
| (he : β{d : β} (F : Point d β β) (x : Point d) (r L : β) (c : S β Fin d), | |
| A'.eval F x r L c=A.eval F x r L c) : A'.HasMaterial B := by | |
| intro d F lam hF x r Ο hr hlam hl h0 h1 c y | |
| rw [he] | |
| exact h hF x hr hlam hl h0 h1 c y | |
| theorem hasMaterial (A : TensorSum S) {w : β} (hw : A.weightLE w) : | |
| βB : TensorSum S,B.weightLE (w+2) β§ A.HasMaterial B := by | |
| have hf (i : A.index) := (A.term i).atom.hasMaterial | |
| choose B hB h using hf | |
| let f : A.index β TensorSum S := fun i => (pure (A.term i).atom).scale (A.term i).power (A.term i).coefficient | |
| let g : A.index β TensorSum S := fun i => | |
| ((pure (A.term i).atom).scale (A.term i).power (A.term i).coefficient.derivative).add | |
| ((B i).scale (A.term i).power (A.term i).coefficient) | |
| refine β¨combine g,?_,?_β© | |
| Β· apply weightLE_combine | |
| intro i | |
| apply weightLE_add | |
| Β· exact weightLE_scale (weightLE_pure _ ((hw i).trans (by omega))) _ _ | |
| Β· exact weightLE_scale (weightLE_mono (hB i) (Nat.add_le_add_right (hw i) 2)) _ _ | |
| Β· have hh : (combine f).HasMaterial (combine g) := HasMaterial.combine (fun i => | |
| HasMaterial.scale (HasMaterial.pure (h i)) _ _) | |
| apply hh.congr | |
| intro d F x r L c | |
| funext p | |
| rw [combine_eval] | |
| change (βi,(A.term i).eval F x r L c p)=βi,(f i).eval F x r L c p | |
| apply Finset.sum_congr rfl | |
| intro i _ | |
| dsimp only [f] | |
| rw [scale_eval,pure_eval] | |
| rfl | |
| end TensorSum | |
| end LogConcaveSampling | |
| end | |
| end | |
| section | |
| noncomputable section | |
| namespace LogConcaveSampling | |
| open Filter | |
| open scoped Topology Classical BigOperators NNReal | |
| namespace JetCalculus | |
| variable {E : Type*} [NormedAddCommGroup E] [NormedSpace β E] | |
| variable {ΞΉ : Type*} [Fintype ΞΉ] | |
| lemma dir_congr_nonneg_time {f g : β Γ E β β} (hf : TimeSmooth f) (hg : TimeSmooth g) | |
| (he : β{t : β},0β€t β t<1 β βz,f (t,z)=g (t,z)) | |
| {Ο : β} (h0 : 0β€Ο) (h1 : Ο<1) (v : β Γ E) (y : E) : dir v f (Ο,y)=dir v g (Ο,y) := by | |
| have hp {t : β} (ht0 : 0<t) (ht1 : t<1) (z : E) : dir v f (t,z)=dir v g (t,z) := by | |
| have hh : f=αΆ [nhds (t,z)]g := by | |
| have ha := (continuousAt_fst (p:=(t,z))).eventually (Ioo_mem_nhds ht0 ht1) | |
| filter_upwards [ha] with p hp | |
| exact he hp.1.le hp.2 p.2 | |
| exact (dir_eventuallyEq hh v).eq_of_nhds | |
| rcases h0.eq_or_lt with hzero | hpos | |
| Β· subst Ο | |
| have hc : ContinuousAt (fun t : β => (t,y)) 0 := continuousAt_id.prodMk continuousAt_const | |
| exact eq_zero_of_continuous_pos (f:=fun t => dir v f (t,y)) (g:=fun t => dir v g (t,y)) | |
| ((smooth_dir_at (hf (0,y) (by norm_num) (by norm_num)) v).continuousAt.comp (f:=fun t : β => (t,y)) hc) | |
| ((smooth_dir_at (hg (0,y) (by norm_num) (by norm_num)) v).continuousAt.comp (f:=fun t : β => (t,y)) hc) | |
| (fun t ht0 ht1 => hp ht0 ht1 y) | |
| Β· exact hp hpos h1 y | |
| lemma mdir_congr_nonneg_time (w : β Γ E) (b : ΞΉ β β Γ E) (r : β) (M : ΞΉ β β Γ E β β) | |
| {f g : β Γ E β β} (hf : TimeSmooth f) (hg : TimeSmooth g) | |
| (he : β{t : β},0β€t β t<1 β βz,f (t,z)=g (t,z)) | |
| {Ο : β} (h0 : 0β€Ο) (h1 : Ο<1) (y : E) : mdir w b r M f (Ο,y)=mdir w b r M g (Ο,y) := by | |
| unfold mdir | |
| rw [dir_congr_nonneg_time hf hg he h0 h1] | |
| congr 2 | |
| apply Finset.sum_congr rfl | |
| intro i _ | |
| rw [dir_congr_nonneg_time hf hg he h0 h1] | |
| def materialIter (w : E) (b : ΞΉ β E) (r : β) (M : ΞΉ β E β β) : β β (E β β) β E β β | |
| | 0,f => f | |
| | n+1,f => mdir w b r M (materialIter w b r M n f) | |
| lemma materialIter_timeSmooth (w : β Γ E) (b : ΞΉ β β Γ E) (r : β) | |
| {M : ΞΉ β β Γ E β β} (hM : βi,TimeSmooth (M i)) {f : β Γ E β β} | |
| (hf : TimeSmooth f) (n : β) : TimeSmooth (materialIter w b r M n f) := by | |
| induction n with | |
| | zero => exact hf | |
| | succ n ih => | |
| intro p h0 h1 | |
| exact smooth_mdir_at w b r (fun i => hM i p h0 h1) (ih p h0 h1) | |
| end JetCalculus | |
| namespace TensorSum | |
| variable {S : Type} | |
| def RepresentsMaterial (A : TensorSum S) (n : β) (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.materialIter (1,0) jointSpace r (jointMean F x r) n | |
| (A.eval F x r ((lam:β)*r) c) (Ο,y)=B.eval F x r ((lam:β)*r) c (Ο,y) | |
| theorem representsMaterial (A : TensorSum S) {w : β} (hA : A.weightLE w) (n : β) : | |
| βB : TensorSum S,B.weightLE (w+2*n) β§ A.RepresentsMaterial n B := by | |
| induction n with | |
| | zero => | |
| refine β¨A,by simpa using hA,?_β© | |
| intro d F lam hF x r Ο hr hlam hl h0 h1 c y | |
| rfl | |
| | succ n ih => | |
| obtain β¨B,hB,heβ© := ih | |
| obtain β¨C,hC,hDβ© := B.hasMaterial hB | |
| refine β¨C,by convert hC using 1,?_β© | |
| intro d F lam hF x r Ο hr hlam hl h0 h1 c y | |
| change JetCalculus.mdir (1,0) jointSpace r (jointMean F x r) | |
| (JetCalculus.materialIter (1,0) jointSpace r (jointMean F x r) n (A.eval F x r ((lam:β)*r) c)) (Ο,y)=_ | |
| rw [JetCalculus.mdir_congr_nonneg_time (1,0) jointSpace r (jointMean F x r) | |
| (JetCalculus.materialIter_timeSmooth _ _ _ (fun i => jointMean_timeSmooth hF x hr.le hl i) | |
| (A.timeSmooth hF x hr hlam hl c) n) (B.timeSmooth hF x hr hlam hl c) | |
| (fun ht0 ht1 z => he hF x hr hlam hl ht0 ht1 c z) h0 h1 y] | |
| exact hD hF x hr hlam hl h0 h1 c y | |
| end TensorSum | |
| end LogConcaveSampling | |
| end | |
| end | |
| section | |
| noncomputable section | |
| namespace LogConcaveSampling | |
| open scoped Classical BigOperators NNReal RealInnerProductSpace | |
| namespace JetCalculus | |
| lemma gadj_add_at {E : Type*} [NormedAddCommGroup E] [NormedSpace β E] | |
| {ΞΉ : Type*} [Fintype ΞΉ] (b : ΞΉ β E) (s : ΞΉ β E β β) {V W : ΞΉ β E β β} {p : E} | |
| (hV : βi,DifferentiableAt β (V i) p) (hW : βi,DifferentiableAt β (W i) p) : | |
| gadj b s (fun i y => V i y+W i y) p=gadj b s V p+gadj b s W p := by | |
| unfold gadj cadj | |
| simp_rw [dir_add_at (hV _) (hW _)] | |
| rw [βFinset.sum_add_distrib] | |
| apply Finset.sum_congr rfl | |
| intro i _ | |
| ring | |
| end JetCalculus | |
| namespace TensorSum | |
| variable {S : Type} [Fintype S] [Nonempty S] | |
| def insertOne (A : TensorSum (S β Unit)) : TensorSum (S β Unit) := | |
| ((pure TensorAtom.one).contract A).relabel (Equiv.sumComm Unit S) | |
| lemma weightLE_insertOne {A : TensorSum (S β Unit)} {w : β} (hw : A.weightLE w) : | |
| A.insertOne.weightLE w := by | |
| unfold insertOne | |
| apply weightLE_relabel | |
| simpa only [zero_add] using weightLE_contract (weightLE_pure TensorAtom.one (by rfl : _β€0)) hw | |
| lemma insertOne_eval {d : β} (A : TensorSum (S β Unit)) (F : Point d β β) | |
| (x : Point d) (r L : β) (c : S β Unit β Fin d) (p : β Γ Point d) : | |
| A.insertOne.eval F x r L c p=βi : Fin d, | |
| (Lβ»ΒΉ*jointU F x r L (fun _ : Unit => JetCalculus.spaceBasis d i) [()] (c (Sum.inr ())) p)* | |
| A.eval F x r L (Sum.elim (fun s => c (Sum.inl s)) (fun _ => i)) p := by | |
| rw [insertOne,relabel_eval,contract_eval] | |
| apply Finset.sum_congr rfl | |
| intro i _ | |
| rw [pure_eval,TensorAtom.one_eval] | |
| rfl | |
| lemma insertOne_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) (h0 : 0β€Ο) (h1 : Ο<1) | |
| (A : TensorSum (S β Unit)) (c : S β Unit β Fin d) (y : Point d) : | |
| βi : Fin d,JetCalculus.dir (jointSpace i) (jointMean F x r (c (Sum.inr ()))) (Ο,y)* | |
| A.eval F x r ((lam:β)*r) (Sum.elim (fun s => c (Sum.inl s)) (fun _ => i)) (Ο,y)= | |
| ((lam:β)*r)*Ο*A.insertOne.eval F x r ((lam:β)*r) c (Ο,y) := by | |
| rw [insertOne_eval,Finset.mul_sum] | |
| apply Finset.sum_congr rfl | |
| intro i _ | |
| rw [jointMean_direction hF x hr hlam hl h0 h1] | |
| have hL : (lam:β)*rβ 0 := ne_of_gt (mul_pos (by exact_mod_cast hlam) hr) | |
| field_simp | |
| def outer {d : β} (A : TensorSum (S β Unit)) (F : Point d β β) (x : Point d) | |
| (r L : β) (c : S β Fin d) : β Γ Point d β β := | |
| JetCalculus.gadj jointSpace (jointScore F x r) | |
| (fun k => A.eval F x r L (Sum.elim c (fun _ => k))) | |
| omit [Fintype S] [Nonempty S] in | |
| lemma outer_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 : TensorSum (S β Unit)) (c : S β Fin d) : | |
| JetCalculus.TimeSmooth (A.outer F x r ((lam:β)*r) c) := by | |
| intro p h0 h1 | |
| exact JetCalculus.smooth_gadj_at _ (fun k => jointScore_timeSmooth hF x hr.le hl k p h0 h1) | |
| (fun k => A.timeSmooth hF x hr hlam hl _ p h0 h1) | |
| omit [Fintype S] [Nonempty S] in | |
| lemma outer_add {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) (h0 : 0β€Ο) (h1 : Ο<1) | |
| (A B : TensorSum (S β Unit)) (c : S β Fin d) (y : Point d) : | |
| (A.add B).outer F x r ((lam:β)*r) c (Ο,y)= | |
| A.outer F x r ((lam:β)*r) c (Ο,y)+B.outer F x r ((lam:β)*r) c (Ο,y) := by | |
| have he : (fun k => (A.add B).eval F x r ((lam:β)*r) (Sum.elim c (fun _ => k)))= | |
| fun k p => A.eval F x r ((lam:β)*r) (Sum.elim c (fun _ => k)) p+ | |
| B.eval F x r ((lam:β)*r) (Sum.elim c (fun _ => k)) p := by | |
| funext k p | |
| exact add_eval A B F x r ((lam:β)*r) _ p | |
| unfold outer | |
| rw [he] | |
| exact JetCalculus.gadj_add_at _ _ (fun k => | |
| (A.timeSmooth hF x hr hlam hl _ (Ο,y) (by dsimp; linarith) h1).differentiableAt (by simp)) | |
| (fun k => (B.timeSmooth hF x hr hlam hl _ (Ο,y) (by dsimp; linarith) h1).differentiableAt (by simp)) | |
| omit [Fintype S] [Nonempty S] in | |
| lemma outer_scale {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) (h0 : 0β€Ο) (h1 : Ο<1) | |
| (A : TensorSum (S β Unit)) (n : β) (P : Polynomial β) (c : S β Fin d) (y : Point d) : | |
| (A.scale n P).outer F x r ((lam:β)*r) c (Ο,y)= | |
| (r*((lam:β)*r))^n*P.eval Ο*A.outer F x r ((lam:β)*r) c (Ο,y) := by | |
| have hA k := A.timeSmooth hF x hr hlam hl (Sum.elim c (fun _ => k)) (Ο,y) (by dsimp; linarith) h1 | |
| have he : (fun k => (A.scale n P).eval F x r ((lam:β)*r) (Sum.elim c (fun _ => k)))= | |
| fun k p => (r*((lam:β)*r))^n*(P.eval p.1*A.eval F x r ((lam:β)*r) (Sum.elim c (fun _ => k)) p) := by | |
| funext k p | |
| rw [scale_eval] | |
| ring | |
| unfold outer | |
| rw [he,JetCalculus.gadj_scalar_at _ _ (fun k => | |
| (((polynomialTime_smooth P).contDiffAt).mul (hA k)).differentiableAt (by simp)), | |
| JetCalculus.gadj_time_at _ _ (fun k => (hA k).differentiableAt (by simp))] | |
| ring | |
| theorem outer_material {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) (h0 : 0β€Ο) (h1 : Ο<1) | |
| {A B : TensorSum (S β Unit)} (hAB : A.HasMaterial B) (c : S β Fin d) (y : Point d) : | |
| JetCalculus.mdir (1,0) jointSpace r (jointMean F x r) (A.outer F x r ((lam:β)*r) c) (Ο,y)= | |
| (B.add (A.insertOne.scale 1 Polynomial.X)).outer F x r ((lam:β)*r) c (Ο,y) := by | |
| 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 => B.eval F x r L (Sum.elim c (fun _ => k)) | |
| have hV (k : Fin d) := A.timeSmooth hF x hr hlam hl (Sum.elim c (fun _ => k)) (Ο,y) (by dsimp; linarith) h1 | |
| have hW (k : Fin d) := B.timeSmooth hF x hr hlam hl (Sum.elim c (fun _ => k)) (Ο,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 hAB 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) := A.insertOne.timeSmooth hF x hr hlam hl (Sum.elim c (fun _ => k)) (Ο,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 | |
| simpa only [Sum.elim_inl,Sum.elim_inr] using | |
| insertOne_mean hF x hr hlam hl h0 h1 A (Sum.elim c (fun _ => k)) z | |
| change JetCalculus.mdir (1,0) jointSpace r (jointMean F x r) | |
| (JetCalculus.gadj jointSpace (jointScore F x r) V) (Ο,y)=_ | |
| rw [physical_material_adjoint_nonneg hF x hr hlam hl h0 h1 hV,hda,hdi, | |
| outer_add hF x hr hlam hl h0 h1,outer_scale hF x hr hlam hl h0 h1] | |
| simp only [pow_one,Polynomial.eval_X] | |
| change B.outer F x r L c (Ο,y)+r*(L*Ο*A.insertOne.outer F x r L c (Ο,y))=_ | |
| dsimp only [L] | |
| ring | |
| end TensorSum | |
| end LogConcaveSampling | |
| end | |
| end | |
| end | |
| end OAI | |