| import Mathlib |
| import OAI.Probability.LogConcave.Dynamics.Truncated |
|
|
| namespace OAI |
|
|
| section |
| section |
| noncomputable section |
| namespace LogConcaveSampling.GlobalODE |
| open Set Function Filter Metric |
| open scoped Topology NNReal |
|
|
| def variationalField {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| (f : E → E) (p : E × (E →L[ℝ] E)) : E × (E →L[ℝ] E) := |
| (f p.1,(fderiv ℝ f p.1).comp p.2) |
|
|
| lemma variationalField_smooth {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| {f : E → E} {n : ℕ} (hf : ContDiff ℝ ((n:WithTop ℕ∞)+1) f) : |
| ContDiff ℝ (n:WithTop ℕ∞) (variationalField f) := |
| ((hf.of_le (by exact_mod_cast Nat.le_succ n)).comp contDiff_fst).prodMk |
| (((hf.fderiv_right le_rfl).comp contDiff_fst).clm_comp contDiff_snd) |
|
|
| lemma truncated_contDiff {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| [FiniteDimensional ℝ E] {f : E → E} {k : ℕ} (hf : ContDiff ℝ (k:WithTop ℕ∞) f) (n : ℕ) : |
| ContDiff ℝ (k:WithTop ℕ∞) (LinearGrowthODE.truncated f n) := |
| (((PoincareCutoff.bump (E:=E)).contDiff).comp (contDiff_id.const_smul _)).smul hf |
|
|
| theorem autonomous_flow_contDiff (n : ℕ) : |
| ∀ {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] [FiniteDimensional ℝ E] |
| {f : E → E} (hf : ContDiff ℝ (n:WithTop ℕ∞) f) {K : ℝ≥0} |
| (hL : LipschitzWith K f) {a b : ℝ} (hab : a≤b) (t : Icc a b), |
| ContDiff ℝ (n:WithTop ℕ∞) (fun x => flow (fun _ _ => hL) |
| (hf.continuous.comp continuous_snd) ⟨a,le_rfl,hab⟩ x t) := by |
| induction n with |
| | zero => |
| intro E _ _ _ f hf K hL a b hab t |
| exact contDiff_zero.mpr (flow_lipschitz (fun _ _ => hL) |
| (hf.continuous.comp continuous_snd) ⟨a,le_rfl,hab⟩ t).continuous |
| | succ n ih => |
| intro E _ _ _ f hf K hL a b hab t |
| have hf1 : ContDiff ℝ 1 f := hf.of_le (by exact_mod_cast Nat.succ_pos n) |
| let hc : Continuous (uncurry (fun (_ : ℝ) => f)) := hf.continuous.comp continuous_snd |
| let hD : Continuous (uncurry (fun (_ : ℝ) => fderiv ℝ f)) := |
| (hf1.continuous_fderiv (by norm_num)).comp continuous_snd |
| let hd : ∀ (u : ℝ) (z : E),HasFDerivAt f (fderiv ℝ f z) z := |
| fun _ z => (hf1.differentiable (by norm_num) z).hasFDerivAt |
| cases n with |
| | zero => |
| exact flow_contDiff_one_left hab hc (fun _ _ => hL) hD hd t |
| | succ m => |
| let J := flowLinearization hab hc (fun _ _ => hL) hD hd |
| let X := fun x => flow (fun _ _ => hL) hc ⟨a,le_rfl,hab⟩ x |
| have hXd (x : E) : HasFDerivAt (fun z => X z t) (J x t) x := |
| flow_hasFDerivAt_left hab hc (fun _ _ => hL) hD hd x t |
| change ContDiff ℝ (((m+1:ℕ):WithTop ℕ∞)+1) (fun x => X x t) |
| apply contDiff_succ_iff_hasFDerivAt.mpr |
| refine ⟨fun x => J x t,?_,hXd⟩ |
| apply contDiff_iff_contDiffAt.mpr |
| intro x₀ |
| let V := variationalField f |
| have hV : ContDiff ℝ ((m+1:ℕ):WithTop ℕ∞) V := variationalField_smooth (by simpa using hf) |
| have hV1 : ContDiff ℝ 1 V := hV.of_le (by exact_mod_cast Nat.succ_pos m) |
| obtain ⟨A,hA⟩ := isCompact_Icc.exists_bound_of_continuousOn |
| (flow_continuous (fun _ _ => hL) hc ⟨a,le_rfl,hab⟩ (0:E)).continuousOn |
| let C := Real.exp ((K:ℝ)*(b-a)) |
| have hC : 0<C := Real.exp_pos _ |
| obtain ⟨N,hN⟩ := exists_nat_gt (max (A+C*(‖x₀‖+1)) C) |
| let W := LinearGrowthODE.truncated V N |
| have hW : ContDiff ℝ ((m+1:ℕ):WithTop ℕ∞) W := truncated_contDiff hV N |
| obtain ⟨L,hWL⟩ := LinearGrowthODE.truncated_lipschitz hV1 N |
| have hWc : Continuous (uncurry (fun (_ : ℝ) => W)) := hW.continuous.comp continuous_snd |
| let Z (p : E × (E →L[ℝ] E)) := flow (fun _ _ => hWL) hWc ⟨a,le_rfl,hab⟩ p t |
| have hZ : ContDiff ℝ ((m+1:ℕ):WithTop ℕ∞) Z := ih hW hWL hab t |
| have hloc : (fun x => J x t) =ᶠ[𝓝 x₀] |
| (fun x => (Z (x,ContinuousLinearMap.id ℝ E)).2) := by |
| filter_upwards [Metric.ball_mem_nhds x₀ zero_lt_one] with x hx |
| have hxn : ‖x‖≤‖x₀‖+1 := by |
| have hh := norm_le_norm_add_norm_sub x₀ x |
| rw [←dist_eq_norm, dist_comm] at hh |
| linarith [Metric.mem_ball.mp hx] |
| have hb (u : Icc a b) : ‖(X x u,J x u)‖≤(N:ℝ)+1 := by |
| have hu : |(u:ℝ)-a|≤b-a := by |
| rw [abs_of_nonneg (sub_nonneg.mpr u.2.1)]; linarith [u.2.2] |
| have hex : Real.exp ((K:ℝ)*|(u:ℝ)-a|)≤C := |
| Real.exp_le_exp.mpr (mul_le_mul_of_nonneg_left hu K.coe_nonneg) |
| have hX : ‖X x u‖≤A+C*(‖x₀‖+1) := by |
| have hs := (flow_lipschitz (fun _ _ => hL) hc ⟨a,le_rfl,hab⟩ u).dist_le_mul x 0 |
| simp only [dist_zero_right] at hs |
| have hn : ‖X x u‖≤‖X 0 u‖+dist (X x u) (X 0 u) := by |
| simpa only [dist_eq_norm, norm_sub_rev] using |
| (norm_le_norm_add_norm_sub (X 0 u) (X x u)) |
| exact hn.trans (add_le_add (hA u u.2) (hs.trans |
| (mul_le_mul hex hxn (norm_nonneg _) hC.le))) |
| have hJ : ‖J x u‖≤C := |
| (fundamental_norm_bound ⟨a,le_rfl,hab⟩ |
| (flowSpatialCoefficient_continuous hab hc (fun _ _ => hL) hD x) |
| (flowSpatialCoefficient_bound hab hc (fun _ _ => hL) hd x) u).trans hex |
| rw [Prod.norm_def] |
| exact (max_le_max hX hJ).trans (by linarith) |
| have he (u : ℝ) (hu : u∈Icc a b) : W (X x u,J x u)=V (X x u,J x u) := |
| LinearGrowthODE.truncated_eq (hb ⟨u,hu⟩) |
| have hcP : Continuous (fun u => (X x u,J x u)) := |
| (flow_continuous (fun _ _ => hL) hc _ x).prodMk |
| (fundamental_continuous ⟨a,le_rfl,hab⟩ |
| (flowSpatialCoefficient_continuous hab hc (fun _ _ => hL) hD x) |
| (flowSpatialCoefficient_bound hab hc (fun _ _ => hL) hd x)) |
| have hdP (u : ℝ) (hu : u∈Icc a b) : |
| HasDerivWithinAt (fun u => (X x u,J x u)) (W (X x u,J x u)) (Icc a b) u := by |
| rw [he u hu] |
| exact (flow_deriv (fun _ _ => hL) hc _ x u hu).prodMk |
| (fundamental_deriv ⟨a,le_rfl,hab⟩ |
| (flowSpatialCoefficient_continuous hab hc (fun _ _ => hL) hD x) |
| (flowSpatialCoefficient_bound hab hc (fun _ _ => hL) hd x) u hu) |
| have hs := trajectory_dist (fun (_ : ℝ) _ => hWL) hcP.continuousOn hdP |
| (flow_continuous (fun _ _ => hWL) hWc ⟨a,le_rfl,hab⟩ (x,ContinuousLinearMap.id ℝ E)).continuousOn |
| (flow_deriv (fun _ _ => hWL) hWc ⟨a,le_rfl,hab⟩ (x,ContinuousLinearMap.id ℝ E)) |
| ⟨a,le_rfl,hab⟩ t |
| have hi : (X x a,J x a)=(x,ContinuousLinearMap.id ℝ E) := by |
| apply Prod.ext |
| · exact flow_initial (fun _ _ => hL) hc ⟨a,le_rfl,hab⟩ x |
| · exact fundamental_initial ⟨a,le_rfl,hab⟩ |
| (flowSpatialCoefficient_continuous hab hc (fun _ _ => hL) hD x) |
| (flowSpatialCoefficient_bound hab hc (fun _ _ => hL) hd x) |
| rw [show (⟨a,le_rfl,hab⟩ : Icc a b).val=a from rfl,hi,flow_initial, |
| dist_self,zero_mul,dist_le_zero] at hs |
| exact congrArg Prod.snd hs |
| exact (hZ.comp (contDiff_id.prodMk contDiff_const)).snd.contDiffAt.congr_of_eventuallyEq hloc |
| end LogConcaveSampling.GlobalODE |
|
|
| end |
|
|
| end |
|
|
| section |
|
|
| noncomputable section |
| namespace LogConcaveSampling.GlobalODE |
| open Set Function Filter Metric |
| open scoped Topology NNReal |
|
|
| theorem smooth_flow_left {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| [FiniteDimensional ℝ E] {n : ℕ} {f : ℝ → E → E} |
| (hf : ContDiff ℝ (n:WithTop ℕ∞) (uncurry f)) {K : ℝ≥0} {a b : ℝ} |
| (hL : ∀t∈Icc a b,LipschitzWith K (f t)) (hab : a≤b) (t : Icc a b) : |
| ContDiff ℝ (n:WithTop ℕ∞) (fun x => flow hL hf.continuous ⟨a,le_rfl,hab⟩ x t) := by |
| cases n with |
| | zero => exact contDiff_zero.mpr (flow_lipschitz hL hf.continuous _ t).continuous |
| | succ n => |
| let V : ℝ × E → ℝ × E := fun p => (1,f p.1 p.2) |
| have hV : ContDiff ℝ ((n+1:ℕ):WithTop ℕ∞) V := contDiff_const.prodMk hf |
| have hV1 : ContDiff ℝ 1 V := hV.of_le (by exact_mod_cast Nat.succ_pos n) |
| let X := fun x => flow hL hf.continuous ⟨a,le_rfl,hab⟩ x |
| apply contDiff_iff_contDiffAt.mpr |
| intro x₀ |
| obtain ⟨A,hA⟩ := isCompact_Icc.exists_bound_of_continuousOn |
| ((flow_continuous hL hf.continuous ⟨a,le_rfl,hab⟩ (0:E)).continuousOn : |
| ContinuousOn (X 0) (Icc a b)) |
| let C := Real.exp ((K:ℝ)*(b-a)) |
| have hC : 0<C := Real.exp_pos _ |
| obtain ⟨N,hN⟩ := exists_nat_gt (max (max |a| |b|) (A+C*(‖x₀‖+1))) |
| let W := LinearGrowthODE.truncated V N |
| have hW : ContDiff ℝ ((n+1:ℕ):WithTop ℕ∞) W := truncated_contDiff hV N |
| obtain ⟨L,hWL⟩ := LinearGrowthODE.truncated_lipschitz hV1 N |
| have hWc : Continuous (uncurry (fun (_ : ℝ) => W)) := hW.continuous.comp continuous_snd |
| let Z (p : ℝ × E) := flow (fun _ _ => hWL) hWc ⟨a,le_rfl,hab⟩ p t |
| have hZ : ContDiff ℝ ((n+1:ℕ):WithTop ℕ∞) Z := autonomous_flow_contDiff _ hW hWL hab t |
| have he : (fun x => X x t) =ᶠ[𝓝 x₀] (fun x => (Z (a,x)).2) := by |
| filter_upwards [ball_mem_nhds x₀ zero_lt_one] with x hx |
| have hxn : ‖x‖≤‖x₀‖+1 := by |
| have hh := norm_le_norm_add_norm_sub x₀ x |
| rw [←dist_eq_norm,dist_comm] at hh |
| linarith [mem_ball.mp hx] |
| have hb (u : Icc a b) : ‖((u:ℝ),X x u)‖≤(N:ℝ)+1 := by |
| have hu : |(u:ℝ)-a|≤b-a := by |
| rw [abs_of_nonneg (sub_nonneg.mpr u.2.1)]; linarith [u.2.2] |
| have hex : Real.exp ((K:ℝ)*|(u:ℝ)-a|)≤C := |
| Real.exp_le_exp.mpr (mul_le_mul_of_nonneg_left hu K.coe_nonneg) |
| have hX : ‖X x u‖≤A+C*(‖x₀‖+1) := by |
| have hs := (flow_lipschitz hL hf.continuous ⟨a,le_rfl,hab⟩ u).dist_le_mul x 0 |
| simp only [dist_zero_right] at hs |
| have hn : ‖X x u‖≤‖X 0 u‖+dist (X x u) (X 0 u) := by |
| simpa only [dist_eq_norm,norm_sub_rev] using (norm_le_norm_add_norm_sub (X 0 u) (X x u)) |
| exact hn.trans (add_le_add (hA u u.2) (hs.trans |
| (mul_le_mul hex hxn (norm_nonneg _) hC.le))) |
| have hau : |(u:ℝ)| ≤ max |a| |b| := by |
| rw [abs_le] |
| exact ⟨by linarith [neg_abs_le a,le_max_left |a| |b|,u.2.1], |
| by linarith [le_abs_self b,le_max_right |a| |b|,u.2.2]⟩ |
| rw [Prod.norm_def,Real.norm_eq_abs] |
| exact (max_le_max hau hX).trans (by linarith) |
| have heW (u : ℝ) (hu : u∈Icc a b) : W (u,X x u)=V (u,X x u) := |
| LinearGrowthODE.truncated_eq (hb ⟨u,hu⟩) |
| have hcP : Continuous (fun u => (u,X x u)) := |
| continuous_id.prodMk (flow_continuous hL hf.continuous _ x) |
| have hdP (u : ℝ) (hu : u∈Icc a b) : |
| HasDerivWithinAt (fun u => (u,X x u)) (W (u,X x u)) (Icc a b) u := by |
| rw [heW u hu] |
| exact (hasDerivWithinAt_id u (Icc a b)).prodMk (flow_deriv hL hf.continuous _ x u hu) |
| have hs := trajectory_dist (fun (_ : ℝ) _ => hWL) hcP.continuousOn hdP |
| (flow_continuous (fun _ _ => hWL) hWc ⟨a,le_rfl,hab⟩ (a,x)).continuousOn |
| (flow_deriv (fun _ _ => hWL) hWc ⟨a,le_rfl,hab⟩ (a,x)) ⟨a,le_rfl,hab⟩ t |
| have hi : (a,X x a)=(a,x) := by rw [show X x a=x from flow_initial hL hf.continuous _ x] |
| rw [show (⟨a,le_rfl,hab⟩ : Icc a b).val=a from rfl,hi,flow_initial, |
| dist_self,zero_mul,dist_le_zero] at hs |
| exact congrArg Prod.snd hs |
| exact (hZ.comp (contDiff_const.prodMk contDiff_id)).snd.contDiffAt.congr_of_eventuallyEq he |
|
|
| lemma flow_congr {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] [CompleteSpace E] |
| {a b : ℝ} {f g : ℝ → E → E} {K L : ℝ≥0} |
| (hf : Continuous (uncurry f)) (hg : Continuous (uncurry g)) |
| (hL : ∀t∈Icc a b,LipschitzWith K (f t)) |
| (hJ : ∀t∈Icc a b,LipschitzWith L (g t)) |
| (he : ∀t∈Icc a b,∀x,f t x=g t x) (s t : Icc a b) (x : E) : |
| flow hL hf s x t=flow hJ hg s x t := by |
| have hd (u : ℝ) (hu : u∈Icc a b) := flow_deriv hJ hg s x u hu |
| have hh := trajectory_dist hL (flow_continuous hL hf s x).continuousOn |
| (flow_deriv hL hf s x) (flow_continuous hJ hg s x).continuousOn |
| (fun u hu => (he u hu _) ▸ flow_deriv hJ hg s x u hu) s t |
| simpa only [flow_initial,dist_self,zero_mul,dist_le_zero] using hh |
| end LogConcaveSampling.GlobalODE |
|
|
| namespace LogConcaveSampling.GlobalODE |
| open Set Function |
| open scoped Topology NNReal |
|
|
| theorem smooth_flow {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| [FiniteDimensional ℝ E] {n : ℕ} {f : ℝ → E → E} |
| (hf : ContDiff ℝ (n:WithTop ℕ∞) (uncurry f)) {K : ℝ≥0} {a b : ℝ} |
| (hL : ∀t∈Icc a b,LipschitzWith K (f t)) (hab : a≤b) (s t : Icc a b) : |
| ContDiff ℝ (n:WithTop ℕ∞) (fun x => flow hL hf.continuous s x t) := by |
| cases n with |
| | zero => exact contDiff_zero.mpr (flow_lipschitz hL hf.continuous s t).continuous |
| | succ n => |
| have hf1 : ContDiff ℝ 1 (uncurry f) := hf.of_le (by exact_mod_cast Nat.succ_pos n) |
| let D : ℝ → E → E →L[ℝ] E := fun u x => |
| (fderiv ℝ (uncurry f) (u,x)).comp (ContinuousLinearMap.inr ℝ ℝ E) |
| have hD : Continuous (uncurry D) := |
| (hf1.continuous_fderiv (by norm_num)).clm_comp continuous_const |
| have hd (u : ℝ) (z : E) : HasFDerivAt (f u) (D u z) z := by |
| exact ((hf1.differentiable (by norm_num) (u,z)).hasFDerivAt).comp z |
| ((hasFDerivAt_const u z).prodMk (hasFDerivAt_id z)) |
| have hi (u : Icc a b) : ContDiff ℝ ((n+1:ℕ):WithTop ℕ∞) |
| (fun x => flow hL hf.continuous u x a) := by |
| let H := flowHomeomorph hL hf.continuous ⟨a,le_rfl,hab⟩ u |
| let J (x : E) := fundamentalEquiv |
| (flowSpatialCoefficient_continuous hab hf.continuous hL hD x) |
| (flowSpatialCoefficient_bound hab hf.continuous hL hd x) ⟨a,le_rfl,hab⟩ u |
| have hJ (x : E) : HasFDerivAt H (J x : E →L[ℝ] E) x := |
| flow_hasFDerivAt_left hab hf.continuous hL hD hd x u |
| exact H.contDiff_symm hJ (smooth_flow_left hf hL hab u) |
| have hh := (smooth_flow_left hf hL hab t).comp (hi s) |
| convert! hh using 1 |
| funext x |
| exact (flow_cocycle hL hf.continuous s ⟨a,le_rfl,hab⟩ t x).symm |
| end LogConcaveSampling.GlobalODE |
|
|
| end |
|
|
| end |
|
|
| end |
|
|
| end OAI |
|
|
