| import Mathlib |
| import OAI.Probability.LogConcave.JetEstimates.Slice |
| import OAI.Probability.LogConcave.JetEstimates.SmoothTensorCurve |
| import OAI.Probability.LogConcave.Sampling.NormalizedTensorMajorantScale |
| import OAI.Probability.LogConcave.Sampling.SpatialTransport |
|
|
| namespace OAI |
|
|
| section |
| section |
| noncomputable section |
| namespace LogConcaveSampling |
| open Set Function |
| open scoped NNReal BigOperators |
|
|
| namespace TensorEnergy |
| lemma multilinearTensor_const_smul {d n : ℕ} (a : ℝ) |
| (f : Point d → Point d) (hf : ContDiff ℝ (⊤:ℕ∞) f) (y : Point d) : |
| multilinearTensor (iteratedFDeriv ℝ n (fun z => a • f z) y)= |
| fun c => a*multilinearTensor (iteratedFDeriv ℝ n f y) c := by |
| funext c |
| rw [iteratedFDeriv_const_smul_apply' (hf.contDiffAt.of_le (by exact_mod_cast (le_top : (n:ℕ∞)≤⊤)))] |
| simp [multilinearTensor,real_inner_smul_right] |
| end TensorEnergy |
|
|
| lemma probabilityVelocity_iterated_split {d n : ℕ} {F : Point d → ℝ} {lam : ℝ≥0} |
| (hF : Primitive F lam) (x : Point d) {r ρ R : ℝ} (hr : 0<r) |
| (hlam : 0<lam) (hl : (lam:ℝ)*r^2≤1/2) (hρ0 : 0≤ρ) (hρ1 : ρ<1) |
| (hR : 0<R) (ha : R^2≤1-ρ^2) (y : Point d) : |
| TensorEnergy.AllSplitBound |
| (TensorEnergy.multilinearTensor (iteratedFDeriv ℝ n (probabilityVelocity F x r ρ) y)) |
| (normalizedTensorMajorant (n+1) 1/R^(n-1)) := by |
| have hh := (conditionalMean_iterated_uniform_split hF x hr hlam hl hρ0 hρ1 hR ha y (n:=n)).abs_const_mul (-r) |
| rw [←TensorEnergy.multilinearTensor_const_smul (-r) _ |
| (conditionalFieldMean_smooth hF x hr.le hl hρ0 hρ1)] at hh |
| change TensorEnergy.AllSplitBound _ _ at hh |
| apply hh.mono (mul_nonneg (abs_nonneg _) (div_nonneg (mul_nonneg (by positivity) (normalizedTensorMajorant_nonneg _ _)) (pow_nonneg hR.le _))) |
| rw [abs_neg,abs_of_pos hr] |
| have hC := normalizedTensorMajorant_nonneg (n+1) 1 |
| have he : r*((lam:ℝ)*r*normalizedTensorMajorant (n+1) 1/R^(n-1))= |
| ((lam:ℝ)*r^2)*(normalizedTensorMajorant (n+1) 1/R^(n-1)) := by ring |
| rw [he] |
| exact mul_le_of_le_one_left (by positivity) (by linarith) |
|
|
| theorem probabilityTransport_iterated_split (n : ℕ) : |
| ∃C : ℝ,0≤C ∧ ∀(d : ℕ) (F : Point d → ℝ) (lam : ℝ≥0) |
| (hF : Primitive F lam) (x : Point d) (r R T : ℝ) |
| (hr : 0<r) (_ : 0<lam) (hl : (lam:ℝ)*r^2≤1/2) |
| (_ : 0<R) (_ : R^2≤1-T^2) (hT0 : 0≤T) (hT1 : T<1) |
| (s t : Icc (0:ℝ) T) (y : Point d), |
| TensorEnergy.AllSplitBound |
| (TensorEnergy.multilinearTensor (iteratedFDeriv ℝ n |
| (probabilityTransport hF x hr.le hl hT0 hT1 s t) y)) (C/R^(n-1)) := by |
| obtain ⟨C,hC,hbound⟩ := TensorEnergy.smoothTensorCurve_bounds |
| (fun k => normalizedTensorMajorant (k+1) 1) |
| (fun k => normalizedTensorMajorant_nonneg _ _) n |
| refine ⟨C,hC,?_⟩ |
| intro d F lam hF x r R T hr hlam hl hR hRT hT0 hT1 s t y |
| let a : ℝ := (t:ℝ)-(s:ℝ) |
| let q (u : ℝ) := (s:ℝ)+a*u |
| have hq (u : ℝ) (hu : u∈Icc (0:ℝ) 1) : q u∈Icc 0 T := by |
| dsimp [q,a] |
| constructor |
| · nlinarith [s.2.1,t.2.1,mul_nonneg s.2.1 (sub_nonneg.mpr hu.2),mul_nonneg t.2.1 hu.1] |
| · nlinarith [s.2.2,t.2.2,mul_nonneg (sub_nonneg.mpr s.2.2) (sub_nonneg.mpr hu.2), |
| mul_nonneg (sub_nonneg.mpr t.2.2) hu.1] |
| have ha : |a|≤1 := (abs_le).mpr ⟨by dsimp [a]; linarith [t.2.1,s.2.2],by dsimp [a]; linarith [t.2.2,s.2.1]⟩ |
| let X (p : ℝ × Point d) := spatialTransport hF x hr.le hl hT0 hT1 s (q p.1,p.2) |
| let V (u : ℝ) (z : Point d) := a • probabilityVelocity F x r (q u) z |
| have hVX : TensorEnergy.SmoothTensorCurve d (fun k => normalizedTensorMajorant (k+1) 1) R 1 X V := by |
| constructor |
| · exact (spatialTransport_smooth hF x hr.le hl hT0 hT1 s).comp |
| ((contDiff_const.add (contDiff_const.mul contDiff_fst)).prodMk contDiff_snd) |
| · intro z |
| dsimp [X,q] |
| simp only [mul_zero,add_zero] |
| exact spatialTransport_initial hF x hr.le hl hT0 hT1 s z |
| · intro u hu z |
| have hd := (spatialTransport_deriv hF x hr.le hl hT0 hT1 s (hq u hu) z).scomp u |
| ((hasDerivAt_const u (s:ℝ)).add ((hasDerivAt_const u a).mul (hasDerivAt_id u))) |
| simpa only [zero_mul,one_mul,mul_one,zero_add,X,V,q,Function.comp_def] using hd |
| · intro u hu |
| exact (contDiff_const (c:=a)).smul ((contDiff_const (c:=(-r:ℝ))).smul |
| (conditionalFieldMean_smooth hF x hr.le hl (hq u hu).1 ((hq u hu).2.trans_lt hT1))) |
| · intro k u hu z |
| have huT := hq u hu |
| have hρ : R^2≤1-(q u)^2 := by nlinarith [mul_nonneg (sub_nonneg.mpr huT.2) (add_nonneg hT0 huT.1)] |
| have hh := (probabilityVelocity_iterated_split hF x hr hlam hl huT.1 |
| (huT.2.trans_lt hT1) hR hρ z (n:=k)).abs_const_mul a |
| have hvs : ContDiff ℝ (⊤:ℕ∞) (probabilityVelocity F x r (q u)) := |
| (contDiff_const (c:=(-r:ℝ))).smul (conditionalFieldMean_smooth hF x hr.le hl huT.1 (huT.2.trans_lt hT1)) |
| rw [←TensorEnergy.multilinearTensor_const_smul a (probabilityVelocity F x r (q u)) hvs z] at hh |
| apply hh.mono (mul_nonneg (abs_nonneg _) (div_nonneg (normalizedTensorMajorant_nonneg _ _) (pow_nonneg hR.le _))) |
| exact mul_le_of_le_one_left (div_nonneg (normalizedTensorMajorant_nonneg _ _) (pow_nonneg hR.le _)) ha |
| have hR1 : R≤1 := by nlinarith [sq_nonneg T] |
| have hh := hbound d R 1 X V hR hR1 (by norm_num) le_rfl hVX 1 ⟨by norm_num,le_rfl⟩ y |
| have he : (fun z => X (1,z))=probabilityTransport hF x hr.le hl hT0 hT1 s t := by |
| funext z |
| dsimp [X,q,a] |
| rw [mul_one,add_sub_cancel] |
| exact spatialTransport_eq hF x hr.le hl hT0 hT1 s t z |
| rwa [he] at hh |
| end LogConcaveSampling |
|
|
| end |
|
|
| end |
|
|
| section |
|
|
| noncomputable section |
| namespace LogConcaveSampling.TensorEnergy |
| open scoped Classical BigOperators RealInnerProductSpace |
|
|
| def matrixArray (d : ℕ) : (Point d →L[ℝ] Point d) →L[ℝ] ((Unit ⊕ Unit → Fin d) → ℝ) := |
| ContinuousLinearMap.pi fun c => |
| (innerSL ℝ (EuclideanSpace.basisFun (Fin d) ℝ (c (Sum.inl ())))).comp |
| (ContinuousLinearMap.apply ℝ (Point d) (EuclideanSpace.basisFun (Fin d) ℝ (c (Sum.inr ())))) |
|
|
| lemma matrixArray_apply {d : ℕ} (A : Point d →L[ℝ] Point d) (c : Unit ⊕ Unit → Fin d) : |
| matrixArray d A c=inner ℝ (EuclideanSpace.basisFun (Fin d) ℝ (c (Sum.inl ()))) |
| (A (EuclideanSpace.basisFun (Fin d) ℝ (c (Sum.inr ())))) := rfl |
|
|
| def jacobianSlots (n : ℕ) : (Unit ⊕ Unit) ⊕ Fin n ≃ Unit ⊕ Fin (n+1) where |
| toFun := Sum.elim (Sum.elim Sum.inl (fun _ => Sum.inr (Fin.last n))) |
| (fun i => Sum.inr i.castSucc) |
| invFun := Sum.elim (fun u => Sum.inl (Sum.inl u)) |
| (Fin.lastCases (Sum.inl (Sum.inr ())) Sum.inr) |
| left_inv := by rintro ((u|u)|i) <;> simp |
| right_inv := by |
| rintro (u|i) |
| · rfl |
| · refine Fin.lastCases ?_ (fun i => ?_) i <;> simp |
|
|
| @[simp] lemma jacobianSlots_symm_out (n : ℕ) : |
| (jacobianSlots n).symm (Sum.inl ())=Sum.inl (Sum.inl ()) := rfl |
| @[simp] lemma jacobianSlots_symm_last (n : ℕ) : |
| (jacobianSlots n).symm (Sum.inr (Fin.last n))=Sum.inl (Sum.inr ()) := by simp [jacobianSlots] |
| @[simp] lemma jacobianSlots_symm_init {n : ℕ} (i : Fin n) : |
| (jacobianSlots n).symm (Sum.inr i.castSucc)=Sum.inr i := by simp [jacobianSlots] |
|
|
| lemma arrayTensor_jacobian {d n : ℕ} {f : Point d → Point d} |
| (hf : ContDiff ℝ (⊤:ℕ∞) f) (y : Point d) (c : (Unit ⊕ Unit) ⊕ Fin n → Fin d) : |
| arrayTensor (iteratedFDeriv ℝ n (fun z => matrixArray d (fderiv ℝ f z)) y) c= |
| multilinearTensor (iteratedFDeriv ℝ (n+1) f y) (c ∘ (jacobianSlots n).symm) := by |
| have hd : ContDiff ℝ (⊤:ℕ∞) (fderiv ℝ f) := hf.fderiv_right (by simp) |
| change arrayTensor (iteratedFDeriv ℝ n ((matrixArray d) ∘ fderiv ℝ f) y) c = _ |
| rw [(matrixArray d).iteratedFDeriv_comp_left hd.contDiffAt |
| (by exact_mod_cast (le_top : (n:ℕ∞)≤⊤))] |
| simp only [arrayTensor,ContinuousLinearMap.compContinuousMultilinearMap_coe, |
| Function.comp_apply,matrixArray_apply,multilinearTensor, |
| jacobianSlots_symm_out,iteratedFDeriv_succ_apply_right,jacobianSlots_symm_last] |
| have hv : (Fin.init fun i => EuclideanSpace.basisFun (Fin d) ℝ (c ((jacobianSlots n).symm (Sum.inr i))))= |
| (fun i => EuclideanSpace.basisFun (Fin d) ℝ (c (Sum.inr i))) := by |
| funext i |
| change EuclideanSpace.basisFun (Fin d) ℝ (c ((jacobianSlots n).symm (Sum.inr i.castSucc)))=_ |
| rw [jacobianSlots_symm_init] |
| rw [hv] |
|
|
| lemma AllSplitBound.jacobian {d n : ℕ} {f : Point d → Point d} |
| (hf : ContDiff ℝ (⊤:ℕ∞) f) (y : Point d) {C : ℝ} |
| (h : AllSplitBound (multilinearTensor (iteratedFDeriv ℝ (n+1) f y)) C) : |
| AllSplitBound (arrayTensor (iteratedFDeriv ℝ n (fun z => matrixArray d (fderiv ℝ f z)) y)) C := by |
| have hh := h.reindex (jacobianSlots n).symm |
| convert hh using 1 |
| ext c |
| exact arrayTensor_jacobian hf y c |
| lemma allSplit_jacobian_comp {d n : ℕ} {f g : Point d → Point d} |
| (hf : ContDiff ℝ (⊤:ℕ∞) f) (hg : ContDiff ℝ (⊤:ℕ∞) g) |
| (A B : ℕ → ℝ) (hA : ∀k,0≤A k) (hB : ∀k,0≤B k) |
| (R : ℝ) (hR : 0<R) (y : Point d) |
| (ha : ∀k≤n+1,AllSplitBound (multilinearTensor (iteratedFDeriv ℝ k g (f y))) (A k/R^(k-1))) |
| (hb : ∀k≤n,AllSplitBound (multilinearTensor (iteratedFDeriv ℝ k f y)) (B k/R^(k-1))) : |
| AllSplitBound (arrayTensor (iteratedFDeriv ℝ n |
| ((fun z => matrixArray d (fderiv ℝ g z)) ∘ f) y)) |
| ((∑c : OrderedFinpartition n,A (c.length+1)*∏i,B (c.partSize i))/R^n) := by |
| have hj : ContDiff ℝ (⊤:ℕ∞) (fun z => matrixArray d (fderiv ℝ g z)) := |
| (matrixArray d).contDiff.comp (hg.fderiv_right (by simp)) |
| have hh := array_composition_scale (n:=n) y hf hj (fun k => A (k+1)) B |
| (fun _ => hA _) hB R hR 0 |
| (fun k hk => by |
| have h := AllSplitBound.jacobian (n:=k) hg (f y) (ha (k+1) (by omega)) |
| simpa only [Nat.add_sub_cancel,Nat.add_zero] using h) hb |
| simpa only [Nat.add_zero] using hh |
| end LogConcaveSampling.TensorEnergy |
|
|
| end |
|
|
| end |
|
|
| end |
|
|
| end OAI |
|
|
