| import Mathlib |
| import OAI.Probability.LogConcave.Dynamics.VariationalField |
|
|
| namespace OAI |
|
|
| section |
| section |
| noncomputable section |
| namespace LogConcaveSampling.GlobalODE |
| open Set Function Filter Metric |
| open scoped Topology NNReal |
|
|
| theorem smooth_flow_joint {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| [FiniteDimensional ℝ E] {f : ℝ → E → E} |
| (hf : ContDiff ℝ (⊤:ℕ∞) (uncurry f)) {K : ℝ≥0} {a b : ℝ} |
| (hL : ∀t∈Icc a b,LipschitzWith K (f t)) (s : Icc a b) |
| (p₀ : ℝ × E) (hp₀ : p₀.1∈Ioo a b) : |
| ContDiffAt ℝ (⊤:ℕ∞) (fun p : ℝ × E => flow hL hf.continuous s p.2 p.1) p₀ := by |
| apply contDiffAt_infty.mpr |
| intro n |
| let V : ℝ × (ℝ × E) → ℝ × (ℝ × E) := fun p => (0,(p.1,p.1 • f p.2.1 p.2.2)) |
| have hV : ContDiff ℝ (⊤:ℕ∞) V := |
| contDiff_const.prodMk (contDiff_fst.prodMk (contDiff_fst.smul (hf.comp contDiff_snd))) |
| let X := fun x => flow hL hf.continuous s x |
| obtain ⟨A,hA⟩ := isCompact_Icc.exists_bound_of_continuousOn |
| ((flow_continuous hL hf.continuous s (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 (b-a) (max (max |a| |b|) (A+C*(‖p₀.2‖+1)))) |
| let W := LinearGrowthODE.truncated V N |
| have hW : ContDiff ℝ (n:WithTop ℕ∞) W := truncated_contDiff (hV.of_le (WithTop.coe_le_coe.mpr le_top)) N |
| obtain ⟨L,hWL⟩ := LinearGrowthODE.truncated_lipschitz (hV.of_le (by norm_num)) N |
| have hWc : Continuous (uncurry (fun (_ : ℝ) => W)) := hW.continuous.comp continuous_snd |
| let Z (p : ℝ × (ℝ × E)) := flow (fun _ _ => hWL) hWc (⟨0,le_rfl,by norm_num⟩ : Icc (0:ℝ) 1) p 1 |
| have hZ : ContDiff ℝ (n:WithTop ℕ∞) Z := autonomous_flow_contDiff _ hW hWL (by norm_num) ⟨1,by norm_num,le_rfl⟩ |
| have he : (fun p : ℝ × E => X p.2 p.1) =ᶠ[𝓝 p₀] |
| (fun p => (Z (p.1-s,((s:ℝ),p.2))).2.2) := by |
| have hn : Ioo a b ×ˢ ball p₀.2 1 ∈ 𝓝 p₀ := |
| (isOpen_Ioo.prod isOpen_ball).mem_nhds ⟨hp₀,mem_ball_self zero_lt_one⟩ |
| filter_upwards [hn] with p hp |
| have hpt : p.1∈Icc a b := ⟨hp.1.1.le,hp.1.2.le⟩ |
| have hxn : ‖p.2‖≤‖p₀.2‖+1 := by |
| have hh := norm_le_norm_add_norm_sub p₀.2 p.2 |
| rw [←dist_eq_norm,dist_comm] at hh |
| linarith [mem_ball.mp hp.2] |
| let q : ℝ → ℝ := fun u => (s:ℝ)+(p.1-s)*u |
| have hq (u : ℝ) (hu : u∈Icc (0:ℝ) 1) : q u∈Icc a b := by |
| have hc := (convex_Icc a b) s.2 hpt (show 0≤1-u by linarith [hu.2]) hu.1 (show 1-u+u=1 by ring) |
| convert! hc using 1 |
| dsimp [q] |
| ring |
| have hqb (u : ℝ) (hu : u∈Icc (0:ℝ) 1) : ‖(p.1-s,(q u,X p.2 (q u)))‖≤(N:ℝ)+1 := by |
| have htime (v : Icc a b) : |(v:ℝ)-s|≤b-a := by |
| rw [abs_le]; constructor <;> linarith [v.2.1,v.2.2,s.2.1,s.2.2] |
| have hex : Real.exp ((K:ℝ)*|q u-s|)≤C := |
| Real.exp_le_exp.mpr (mul_le_mul_of_nonneg_left (htime ⟨q u,hq u hu⟩) K.coe_nonneg) |
| have hX : ‖X p.2 (q u)‖≤A+C*(‖p₀.2‖+1) := by |
| have hs := (flow_lipschitz hL hf.continuous s ⟨q u,hq u hu⟩).dist_le_mul p.2 0 |
| simp only [dist_zero_right] at hs |
| have hh : ‖X p.2 (q u)‖≤‖X 0 (q u)‖+dist (X p.2 (q u)) (X 0 (q u)) := by |
| simpa only [dist_eq_norm,norm_sub_rev] using (norm_le_norm_add_norm_sub (X 0 (q u)) (X p.2 (q u))) |
| exact hh.trans (add_le_add (hA (q u) (hq u hu)) |
| (hs.trans (mul_le_mul hex hxn (norm_nonneg _) hC.le))) |
| have hqt : |q u| ≤ max |a| |b| := by |
| rw [abs_le] |
| constructor <;> linarith [(hq u hu).1,(hq u hu).2, |
| neg_abs_le a,le_abs_self b,le_max_left |a| |b|,le_max_right |a| |b|] |
| simp only [Prod.norm_def,Real.norm_eq_abs] |
| exact (max_le_max (htime ⟨p.1,hpt⟩) (max_le_max hqt hX)).trans (by linarith) |
| let P : ℝ → ℝ × (ℝ × E) := fun u => (p.1-s,(q u,X p.2 (q u))) |
| have hqc : Continuous q := by dsimp [q]; fun_prop |
| have hPc : Continuous P := continuous_const.prodMk |
| (hqc.prodMk ((flow_continuous hL hf.continuous s p.2).comp hqc)) |
| have hPd (u : ℝ) (hu : u∈Icc (0:ℝ) 1) : |
| HasDerivWithinAt P (W (P u)) (Icc (0:ℝ) 1) u := by |
| have heW : W (P u)=V (P u) := LinearGrowthODE.truncated_eq (hqb u hu) |
| rw [heW] |
| have hdq : HasDerivWithinAt q (p.1-s) (Icc (0:ℝ) 1) u := by |
| convert! (hasDerivWithinAt_const u (Icc (0:ℝ) 1) (s:ℝ)).add |
| ((hasDerivWithinAt_id u (Icc (0:ℝ) 1)).const_mul (p.1-s)) using 1 |
| simp |
| have hdX := (flow_deriv hL hf.continuous s p.2 (q u) (hq u hu)).scomp u hdq hq |
| exact (hasDerivWithinAt_const u (Icc (0:ℝ) 1) (p.1-s)).prodMk (hdq.prodMk hdX) |
| have h0 : P 0=(p.1-s,((s:ℝ),p.2)) := by |
| dsimp [P,q] |
| simp only [mul_zero,add_zero] |
| rw [show X p.2 s=p.2 from flow_initial hL hf.continuous s p.2] |
| have h1 : P 1=(p.1-s,(p.1,X p.2 p.1)) := by |
| dsimp [P] |
| rw [show q 1=p.1 by dsimp [q]; ring] |
| have hs := trajectory_dist (fun (_ : ℝ) _ => hWL) hPc.continuousOn hPd |
| (flow_continuous (fun _ _ => hWL) hWc (⟨0,le_rfl,by norm_num⟩ : Icc (0:ℝ) 1) (p.1-s,((s:ℝ),p.2))).continuousOn |
| (flow_deriv (fun _ _ => hWL) hWc (⟨0,le_rfl,by norm_num⟩ : Icc (0:ℝ) 1) (p.1-s,((s:ℝ),p.2))) |
| (⟨0,le_rfl,by norm_num⟩ : Icc (0:ℝ) 1) (⟨1,by norm_num,le_rfl⟩ : Icc (0:ℝ) 1) |
| change dist (P 1) (Z (p.1-s,((s:ℝ),p.2)))≤dist (P 0) _ * _ at hs |
| rw [h0,flow_initial,dist_self,zero_mul,dist_le_zero,h1] at hs |
| exact congrArg (fun z => z.2.2) hs |
| exact ((hZ.comp ((contDiff_fst.sub contDiff_const).prodMk |
| (contDiff_const.prodMk contDiff_snd))).snd.snd).contDiffAt.congr_of_eventuallyEq he |
| end LogConcaveSampling.GlobalODE |
|
|
| end |
|
|
| end |
|
|
| section |
|
|
| noncomputable section |
| namespace LogConcaveSampling.GlobalODE |
| open Set Function Filter |
| open scoped Topology NNReal |
|
|
| variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| [FiniteDimensional ℝ E] {f : ℝ → E → E} |
| (hf : ContDiff ℝ (⊤:ℕ∞) (uncurry f)) {K : ℝ≥0} {a b : ℝ} |
| (hab : a≤b) (hL : ∀t∈Icc a b,LipschitzWith K (f t)) |
|
|
| lemma spaceTimeForward_smooth (p : ℝ × E) (hp : p.1∈Ioo a b) : |
| ContDiffAt ℝ (⊤:ℕ∞) (spaceTimeForward hab hf.continuous hL) p := by |
| have hh := contDiffAt_fst.prodMk (smooth_flow_joint hf hL ⟨a,le_rfl,hab⟩ p hp) |
| apply hh.congr_of_eventuallyEq |
| filter_upwards [continuous_fst.continuousAt.preimage_mem_nhds (Icc_mem_nhds hp.1 hp.2)] with q hq |
| simp only [spaceTimeForward,projIcc_of_mem _ hq] |
|
|
| lemma spaceTimeBackward_smooth (p : ℝ × E) (hp : p.1∈Ioo a b) : |
| ContDiffAt ℝ (⊤:ℕ∞) (spaceTimeBackward hab hf.continuous hL) p := by |
| let D := fun t => fderiv ℝ (f t) |
| have hD : Continuous (uncurry D) := by |
| have hh := hf.continuous_fderiv (by norm_num) |
| have he : uncurry D=fun p : ℝ × E => (fderiv ℝ (uncurry f) p).comp (ContinuousLinearMap.inr ℝ ℝ E) := by |
| funext p |
| have hg : HasFDerivAt (fun z : E => (p.1,z)) (ContinuousLinearMap.inr ℝ ℝ E) p.2 := by |
| convert! (hasFDerivAt_const (𝕜:=ℝ) p.1 p.2).prodMk (hasFDerivAt_id (𝕜:=ℝ) p.2) using 1 |
| exact ((hf.differentiable (by norm_num) p).hasFDerivAt.comp p.2 hg).fderiv |
| rw [he] |
| exact hh.clm_comp continuous_const |
| have hd (t : ℝ) (z : E) : HasFDerivAt (f t) (D t z) z := |
| ((hf.comp (contDiff_const.prodMk contDiff_id)).differentiable (by norm_num) z).hasFDerivAt |
| let H := spaceTimeHomeomorph hab hf.continuous hL |
| have hp' : (H.symm p).1∈Ioo a b := hp |
| exact H.toOpenPartialHomeomorph.contDiffAt_symm (Set.mem_univ p) |
| (spaceTimeForward_hasFDerivAt hab hf.continuous hL hD hd (H.symm p) hp') |
| (spaceTimeForward_smooth hf hab hL (H.symm p) hp') |
| |
| lemma backward_flow_smooth (T : Icc a b) (p : ℝ × E) (hp : p.1∈Ioo a b) : |
| ContDiffAt ℝ (⊤:ℕ∞) |
| (fun p : ℝ × E => flow hL hf.continuous (projIcc a b hab p.1) p.2 T) p := by |
| have hA : ContDiff ℝ (⊤:ℕ∞) |
| (fun y => flow hL hf.continuous ⟨a,le_rfl,hab⟩ y T) := by |
| apply contDiff_infty.mpr |
| intro n |
| exact smooth_flow (hf.of_le (WithTop.coe_le_coe.mpr le_top)) hL hab _ T |
| have hh := hA.contDiffAt.comp p ((spaceTimeBackward_smooth hf hab hL p hp).snd) |
| convert! hh using 1 |
| funext q |
| exact (flow_cocycle hL hf.continuous (projIcc a b hab q.1) ⟨a,le_rfl,hab⟩ T q.2).symm |
| end LogConcaveSampling.GlobalODE |
| |
| end |
| |
| end |
| |
| section |
| |
| noncomputable section |
| namespace LogConcaveSampling.GlobalODE |
| open Set Function |
| open scoped Topology NNReal |
| |
| lemma flow_restrict {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] [CompleteSpace E] |
| {a b c d : ℝ} {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 c d,LipschitzWith L (g t)) (hsub : Icc a b ⊆ Icc c d) |
| (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,hsub s.2⟩ x t := by |
| have hh := trajectory_dist hL (flow_continuous hL hf s x).continuousOn |
| (flow_deriv hL hf s x) (flow_continuous hJ hg ⟨s,hsub s.2⟩ x).continuousOn |
| (fun u hu => (he u hu _) ▸ (flow_deriv hJ hg ⟨s,hsub s.2⟩ x u (hsub hu)).mono hsub) s t |
| simpa only [flow_initial,dist_self,zero_mul,dist_le_zero] using hh |
| end LogConcaveSampling.GlobalODE |
| |
| end |
| end |
| end |
| |
| end OAI |
| |
