lean/OAI/Probability/LogConcave/Dynamics/Truncated.lean

import Mathlib
import OAI.Probability.LogConcave.Dynamics.TriangularEquiv
import OAI.Probability.LogConcave.Sampling.MeasureSmoothLipschitz

namespace OAI

section
section
noncomputable section
namespace LogConcaveSampling.LinearGrowthODE
open Set Function Filter
open scoped Topology NNReal

variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
  [FiniteDimensional ℝ E]

def truncated (f : E → E) (n : ℕ) (x : E) : E := PoincareCutoff.cutoff n x • f x

lemma truncated_smooth {f : E → E} (hf : ContDiff ℝ 1 f) (n : ℕ) :
    ContDiff ℝ 1 (truncated f n) := (PoincareCutoff.cutoff_smooth n).smul hf

lemma truncated_lipschitz {f : E → E} (hf : ContDiff ℝ 1 f) (n : ℕ) :
    ∃ L : ℝ≥0,LipschitzWith L (truncated f n) :=
  ContDiff.lipschitzWith_of_hasCompactSupport
    ((PoincareCutoff.cutoff_compact n).smul_right (f':=f)) (truncated_smooth hf n) (by norm_num)

lemma cutoff_eq_one {n : ℕ} {x : E} (hx : ‖x‖≤(n:ℝ)+1) :
    PoincareCutoff.cutoff n x=1 := by
  apply (PoincareCutoff.bump (E:=E)).one_of_mem_closedBall
  rw [Metric.mem_closedBall,dist_zero_right]
  change ‖((n:ℝ)+1)⁻¹ • x‖≤1
  rw [norm_smul,Real.norm_eq_abs,abs_of_nonneg (by positivity)]
  exact (inv_mul_le_iff₀ (by positivity : 0<(n:ℝ)+1)).mpr (by simpa using hx)

lemma truncated_eq {f : E → E} {n : ℕ} {x : E} (hx : ‖x‖≤(n:ℝ)+1) :
    truncated f n x=f x := by simp [truncated,cutoff_eq_one hx]

lemma truncated_growth {f : E → E} {K B : ℝ}
    (hg : ∀x,‖f x‖≤K*‖x‖+B) (n : ℕ) (x : E) :
    ‖truncated f n x‖≤K*‖x‖+B := by
  rw [truncated,norm_smul,Real.norm_eq_abs,abs_of_nonneg (PoincareCutoff.cutoff_nonneg n x)]
  exact (mul_le_of_le_one_left (norm_nonneg _) (PoincareCutoff.cutoff_le_one n x)).trans (hg x)

theorem exists_curve {f : E → E} (hf : ContDiff ℝ 1 f) {K B a b : ℝ}
    (hK : 0≤K) (hB : 0≤B) (hg : ∀x,‖f x‖≤K*‖x‖+B) (hab : a≤b) (x : E) :
    ∃α : ℝ → E,Continuous α ∧ α a=x ∧
      (∀t∈Icc a b,HasDerivWithinAt α (f (α t)) (Icc a b) t) ∧
      ∀t∈Icc a b,‖α t‖≤gronwallBound ‖x‖ K B (t-a) := by
  obtain ⟨n,hn⟩ := exists_nat_gt (gronwallBound ‖x‖ K B (b-a))
  obtain ⟨L,hL⟩ := truncated_lipschitz hf n
  have hc : Continuous (uncurry (fun (_ : ℝ) => truncated f n)) :=
    (truncated_smooth hf n).continuous.comp continuous_snd
  obtain ⟨α,hα,hα0,hαd⟩ := GlobalODE.exists_curve (f:=fun _ => truncated f n)
    (⟨a,le_rfl,hab⟩ : Icc a b) hc (fun _ _ => hL) x
  have hb : ∀t∈Icc a b,‖α t‖≤gronwallBound ‖x‖ K B (t-a) :=
    norm_le_gronwallBound_of_norm_deriv_right_le hα.continuousOn
      (GlobalODE.right_deriv hαd) (by rw [hα0])
      (fun t _ => truncated_growth hg n (α t))
  have he (t : ℝ) (ht : t∈Icc a b) : truncated f n (α t)=f (α t) := by
    apply truncated_eq
    exact (hb t ht).trans ((gronwallBound_mono (norm_nonneg x) hB hK
      (sub_le_sub_right ht.2 a)).trans (by linarith))
  exact ⟨α,hα,hα0,fun t ht => (he t ht) ▸ hαd t ht,hb⟩

theorem unique {f : E → E} (hf : ContDiff ℝ 1 f) {a b : ℝ} {α β : ℝ → E}
    (hα : ContinuousOn α (Icc a b)) (hβ : ContinuousOn β (Icc a b))
    (hdα : ∀t∈Icc a b,HasDerivWithinAt α (f (α t)) (Icc a b) t)
    (hdβ : ∀t∈Icc a b,HasDerivWithinAt β (f (β t)) (Icc a b) t)
    (h0 : α a=β a) : Set.EqOn α β (Icc a b) := by
  obtain ⟨A,hA⟩ := isCompact_Icc.exists_bound_of_continuousOn hα
  obtain ⟨B,hB⟩ := isCompact_Icc.exists_bound_of_continuousOn hβ
  obtain ⟨L,hL⟩ := hf.contDiffOn.exists_lipschitzOnWith (by norm_num : (1:WithTop ℕ∞)≠0)
    (convex_closedBall (0:E) (max A B)) (isCompact_closedBall (0:E) (max A B))
  intro t ht
  have hh := dist_le_of_trajectories_ODE_of_mem (v:=fun (_ : ℝ) => f)
    (s:=fun _ => Metric.closedBall (0:E) (max A B))
    (fun _ _ => hL) hα (GlobalODE.right_deriv hdα)
    (fun u hu => by simpa only [Metric.mem_closedBall,dist_zero_right] using
      (hA u ⟨hu.1,hu.2.le⟩).trans (le_max_left A B))
    hβ (GlobalODE.right_deriv hdβ)
    (fun u hu => by simpa only [Metric.mem_closedBall,dist_zero_right] using
      (hB u ⟨hu.1,hu.2.le⟩).trans (le_max_right A B)) (show dist (α a) (β a)≤0 by simp [h0]) t ht
  simpa only [h0,dist_self,zero_mul,dist_le_zero] using hh
end LogConcaveSampling.LinearGrowthODE

end

end

section

noncomputable section
namespace LogConcaveSampling.LinearGrowthODE
open Set Function Filter Metric
open scoped Topology NNReal

variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]

lemma growth_from_right {a b K B R : ℝ} {α β : ℝ → E}
    (hc : ContinuousOn α (Icc a b))
    (hd : ∀t∈Icc a b,HasDerivWithinAt α (β t) (Icc a b) t)
    (hb : ‖α b‖≤R) (hg : ∀t∈Icc a b,‖β t‖≤K*‖α t‖+B)
    (t : ℝ) (ht : t∈Icc a b) : ‖α t‖≤gronwallBound R K B (b-t) := by
  let q : ℝ → ℝ := fun u => a+b-u
  have hq (u : ℝ) (hu : u∈Icc a b) : q u∈Icc a b := by
    constructor <;> dsimp [q] <;> linarith [hu.1,hu.2]
  have hqc : Continuous q := by dsimp [q]; fun_prop
  have hαc : ContinuousOn (α ∘ q) (Icc a b) := hc.comp hqc.continuousOn hq
  have hαd (u : ℝ) (hu : u∈Icc a b) :
      HasDerivWithinAt (α ∘ q) (-β (q u)) (Icc a b) u := by
    have hqd : HasDerivWithinAt q (-1) (Icc a b) u := by
      convert! ((hasDerivWithinAt_const u (Icc a b) (a+b)).sub
        (hasDerivWithinAt_id u (Icc a b))) using 1
      simp
    simpa only [neg_one_smul] using (hd (q u) (hq u hu)).scomp u hqd hq
  have h0 : ‖(α ∘ q) a‖≤R := by simpa [q] using hb
  have hβb (u : ℝ) (_hu : u∈Ico a b) :
      ‖-β (q u)‖≤K*‖(α ∘ q) u‖+B := by
    simpa only [norm_neg,comp_apply] using hg (q u) (hq u ⟨_hu.1,_hu.2.le⟩)
  have hh := norm_le_gronwallBound_of_norm_deriv_right_le hαc
    (GlobalODE.right_deriv (f := fun u (_ : E) => -β (q u)) hαd) h0 hβb (q t) (hq t ht)
  simpa only [comp_apply,q,show a+b-(a+b-t)=t by ring,show a+b-t-a=b-t by ring] using hh

lemma gronwallBound_initial_mono {R S K B t : ℝ} (h : R≤S) :
    gronwallBound R K B t≤gronwallBound S K B t := by
  unfold gronwallBound
  split_ifs <;> gcongr

variable [FiniteDimensional ℝ E]

def flow {f : E → E} (hf : ContDiff ℝ 1 f) {K B a b : ℝ}
    (hK : 0≤K) (hB : 0≤B) (hg : ∀x,‖f x‖≤K*‖x‖+B) (hab : a≤b) (x : E) : ℝ → E :=
  (exists_curve hf hK hB hg hab x).choose
lemma flow_continuous {f : E → E} (hf : ContDiff ℝ 1 f) {K B a b : ℝ}
    (hK : 0≤K) (hB : 0≤B) (hg : ∀x,‖f x‖≤K*‖x‖+B) (hab : a≤b) (x : E) :
    Continuous (flow hf hK hB hg hab x) := (exists_curve hf hK hB hg hab x).choose_spec.1
lemma flow_initial {f : E → E} (hf : ContDiff ℝ 1 f) {K B a b : ℝ}
    (hK : 0≤K) (hB : 0≤B) (hg : ∀x,‖f x‖≤K*‖x‖+B) (hab : a≤b) (x : E) :
    flow hf hK hB hg hab x a=x := (exists_curve hf hK hB hg hab x).choose_spec.2.1
lemma flow_deriv {f : E → E} (hf : ContDiff ℝ 1 f) {K B a b : ℝ}
    (hK : 0≤K) (hB : 0≤B) (hg : ∀x,‖f x‖≤K*‖x‖+B) (hab : a≤b) (x : E) :
    ∀t∈Icc a b,HasDerivWithinAt (flow hf hK hB hg hab x)
      (f (flow hf hK hB hg hab x t)) (Icc a b) t :=
  (exists_curve hf hK hB hg hab x).choose_spec.2.2.1
lemma flow_growth {f : E → E} (hf : ContDiff ℝ 1 f) {K B a b : ℝ}
    (hK : 0≤K) (hB : 0≤B) (hg : ∀x,‖f x‖≤K*‖x‖+B) (hab : a≤b) (x : E) :
    ∀t∈Icc a b,‖flow hf hK hB hg hab x t‖≤gronwallBound ‖x‖ K B (t-a) :=
  (exists_curve hf hK hB hg hab x).choose_spec.2.2.2
end LogConcaveSampling.LinearGrowthODE

end

end

section

noncomputable section
namespace LogConcaveSampling.LinearGrowthODE
open Set Function Filter Metric
open scoped Topology NNReal

variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
  [FiniteDimensional ℝ E]

lemma truncated_continuous {f : E → E} (hf : ContDiff ℝ 1 f) (n : ℕ) :
    Continuous (uncurry (fun (_ : ℝ) => truncated f n)) :=
  (truncated_smooth hf n).continuous.comp continuous_snd

lemma truncated_flow_growth {f : E → E} (hf : ContDiff ℝ 1 f) {K B a b : ℝ}
    (hg : ∀x,‖f x‖≤K*‖x‖+B) (hab : a≤b) (n : ℕ)
    {L : ℝ≥0} (hL : LipschitzWith L (truncated f n)) (y : E) :
    ∀t∈Icc a b,‖GlobalODE.flow (fun _ _ => hL)
      (truncated_continuous hf n) ⟨a,le_rfl,hab⟩ y t‖≤
        gronwallBound ‖y‖ K B (t-a) := by
  apply norm_le_gronwallBound_of_norm_deriv_right_le
    (GlobalODE.flow_continuous _ _ _ _).continuousOn
    (GlobalODE.right_deriv (GlobalODE.flow_deriv _ _ _ _))
    (by rw [GlobalODE.flow_initial])
  exact fun _ _ => truncated_growth hg n _

lemma eq_truncated_flow {f : E → E} (hf : ContDiff ℝ 1 f) {K B a b R : ℝ}
    (hK : 0≤K) (hB : 0≤B) (hg : ∀x,‖f x‖≤K*‖x‖+B) (hab : a≤b)
    (n : ℕ) {L : ℝ≥0} (hL : LipschitzWith L (truncated f n))
    (hn : gronwallBound R K B (b-a)≤(n:ℝ)+1) {y : E} (hy : ‖y‖≤R) :
    EqOn (flow hf hK hB hg hab y)
      (GlobalODE.flow (fun _ _ => hL) (truncated_continuous hf n)
        ⟨a,le_rfl,hab⟩ y) (Icc a b) := by
  let α := GlobalODE.flow (fun _ _ => hL)
    (truncated_continuous hf n) (⟨a,le_rfl,hab⟩ : Icc a b) y
  have hd (t : ℝ) (ht : t∈Icc a b) : HasDerivWithinAt α (f (α t)) (Icc a b) t := by
    have hb := truncated_flow_growth hf hg hab n hL y t ht
    have hb' : ‖α t‖≤(n:ℝ)+1 := hb.trans ((gronwallBound_initial_mono hy).trans
      ((gronwallBound_mono ((norm_nonneg y).trans hy) hB hK (sub_le_sub_right ht.2 a)).trans hn))
    have he := truncated_eq (f:=f) hb'
    exact he ▸ GlobalODE.flow_deriv (fun _ _ => hL) _ _ y t ht
  apply unique hf (flow_continuous hf hK hB hg hab y).continuousOn
    (GlobalODE.flow_continuous _ _ _ _).continuousOn (flow_deriv hf hK hB hg hab y) hd
  rw [flow_initial,GlobalODE.flow_initial]

lemma flow_continuous_initial {f : E → E} (hf : ContDiff ℝ 1 f) {K B a b : ℝ}
    (hK : 0≤K) (hB : 0≤B) (hg : ∀x,‖f x‖≤K*‖x‖+B) (hab : a≤b)
    (t : ℝ) (ht : t∈Icc a b) : Continuous (fun y => flow hf hK hB hg hab y t) := by
  apply continuous_iff_continuousAt.mpr
  intro x
  obtain ⟨n,hn⟩ := exists_nat_gt (gronwallBound (‖x‖+1) K B (b-a))
  obtain ⟨L,hL⟩ := truncated_lipschitz hf n
  have hh := (GlobalODE.flow_lipschitz (fun _ _ => hL)
    (truncated_continuous hf n) ⟨a,le_rfl,hab⟩ ⟨t,ht⟩).continuous.continuousAt (x:=x)
  apply hh.congr_of_eventuallyEq
  filter_upwards [Metric.ball_mem_nhds x (by norm_num : (0:ℝ)<1)] with y hy
  apply (eq_truncated_flow hf hK hB hg hab n hL (by linarith) ?_ ht)
  calc ‖y‖≤‖x‖+dist y x := norm_le_norm_add_const_of_dist_le le_rfl
       _≤‖x‖+1 := by gcongr; exact (Metric.mem_ball.mp hy).le

lemma backwardTest_vanish {f : E → E} (hf : ContDiff ℝ 1 f) {K B a b R : ℝ}
    (hK : 0≤K) (hB : 0≤B) (hg : ∀x,‖f x‖≤K*‖x‖+B) (hab : a≤b)
    (hR : 0≤R) {φ : E → ℝ} (hφ : ∀x,R<‖x‖ → φ x=0)
    (n : ℕ) {L : ℝ≥0} (hL : LipschitzWith L (truncated f n)) (t : ℝ) (y : E)
    (hy : gronwallBound R K B (b-a)<‖y‖) :
    GlobalODE.backwardTest (f:=fun (_ : ℝ) => truncated f n) hab
      (truncated_continuous hf n) (fun _ _ => hL)
      ⟨b,hab,le_rfl⟩ φ (t,y)=0 := by
  rw [GlobalODE.backwardTest_eq]
  apply hφ
  by_contra! h
  let s := projIcc a b hab t
  let α := GlobalODE.flow (fun _ _ => hL)
    (truncated_continuous hf n) s y
  have hh := growth_from_right (GlobalODE.flow_continuous _ _ _ _).continuousOn
    (GlobalODE.flow_deriv (fun _ _ => hL) _ s y) h
    (fun u _ => truncated_growth hg n (α u)) s s.2
  rw [GlobalODE.flow_initial] at hh
  have hm := gronwallBound_mono hR hB hK (sub_le_sub_left s.2.1 b)
  exact (not_lt_of_ge (hh.trans hm)) hy
end LogConcaveSampling.LinearGrowthODE

end

end

section

noncomputable section
namespace LogConcaveSampling.GlobalODE
open Set Function Filter MeasureTheory
open scoped Topology NNReal

variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
  [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E]

theorem stationary_integral_of_backward_flux {f : E → E} (hf : ContDiff ℝ 1 f)
    {K : ℝ≥0} (hL : LipschitzWith K f) {μ : Measure E} [IsFiniteMeasure μ]
    (hfi : Integrable (fun x => ‖f x‖) μ)
    {a b : ℝ} (hab : a<b) {φ : E → ℝ} (hφ : ContDiff ℝ 1 φ)
    {L : ℝ≥0} (hφL : LipschitzWith L φ) {B : ℝ} (hφB : ∀x,‖φ x‖≤B)
    (hflux : ∀t : ℝ,(∫y,(fderiv ℝ (fun z =>
      backwardTest (f:=fun (_ : ℝ) => f) hab.le (hf.continuous.comp continuous_snd) (fun _ _ => hL)
        ⟨b,hab.le,le_rfl⟩ φ (t,z)) y) (f y) ∂μ)=0) :
    (∫y,φ (flow (fun _ _ => hL) (hf.continuous.comp continuous_snd)
      ⟨a,le_rfl,hab.le⟩ y b) ∂μ)=∫y,φ y ∂μ := by
  let hc : Continuous (uncurry (fun (_ : ℝ) => f)) := hf.continuous.comp continuous_snd
  let hD : Continuous (uncurry (fun (_ : ℝ) => fderiv ℝ f)) :=
    (hf.continuous_fderiv (by norm_num)).comp continuous_snd
  let hd : ∀ (u : ℝ) (z : E),HasFDerivAt f (fderiv ℝ f z) z :=
    fun _ z => (hf.differentiable (by norm_num) z).hasFDerivAt
  let T : Icc a b := ⟨b,hab.le,le_rfl⟩
  let ψ := backwardTest hab.le hc (fun _ _ => hL) T φ
  let S := fun t => fderiv ℝ (fun y => ψ (t,y))
  let C : ℝ := (L:ℝ)*Real.exp ((K:ℝ)*(b-a))
  have hC : 0≤C := by dsimp [C]; positivity
  have hψ : Continuous ψ := backwardTest_continuous hab.le hc (fun _ _ => hL) T hφ.continuous
  have hψc (t : ℝ) : ContDiff ℝ 1 (fun y => ψ (t,y)) := by
    have he : (fun y => ψ (t,y))=φ ∘ (fun y =>
        flow (fun _ _ => hL) hc (projIcc a b hab.le t) y T) := by
      funext y
      exact backwardTest_eq hab.le hc (fun _ _ => hL) T φ (t,y)
    rw [he]
    exact hφ.comp (flow_contDiff_one hab.le hc (fun _ _ => hL) hD hd _ T)
  have hψL (t : ℝ) := backwardTest_lipschitz hab.le hc (fun _ _ => hL) T hφL t
  have hψB (t : ℝ) (y : E) : ‖ψ (t,y)‖≤B := hφB _
  have hSb (t : ℝ) (y : E) : ‖S t y‖≤C := norm_fderiv_le_of_lipschitz ℝ (hψL t)
  have him (t : ℝ) : Integrable (fun y => ψ (t,y)) μ :=
    (integrable_const B).mono' (hψ.measurable.comp (measurable_const.prodMk measurable_id)).aestronglyMeasurable
      (Eventually.of_forall (hψB t))
  have hdm (t : ℝ) : Measurable (fun y => -(S t y (f y))) :=
    ((continuous_fst.clm_apply continuous_snd).measurable.comp
      ((measurable_fderiv ℝ (fun y => ψ (t,y))).prodMk hf.continuous.measurable)).neg
  have hdb (t : ℝ) (y : E) : ‖-(S t y (f y))‖≤C*‖f y‖ := by
    rw [norm_neg]
    exact (ContinuousLinearMap.le_opNorm _ _).trans (mul_le_mul_of_nonneg_right (hSb t y) (norm_nonneg _))
  have hpd (t : ℝ) (ht : t∈Ioo a b) (y : E) :
      HasDerivAt (fun t => ψ (t,y)) (-(S t y (f y))) t := by
    have hh := backwardTest_chain hab.le hc (fun _ _ => hL) hD hd T
      (hφ.differentiable (by norm_num)) ht (hasDerivAt_const t y)
    simpa only [zero_sub,map_neg] using hh
  have hQd (t : ℝ) (ht : t∈Ioo a b) : HasDerivAt (fun t => ∫y,ψ (t,y) ∂μ) 0 t := by
    have hh := hasDerivAt_integral_of_dominated_loc_of_deriv_le
      (F:=fun t y => ψ (t,y)) (F':=fun t y => -(S t y (f y)))
      (Ioo_mem_nhds ht.1 ht.2)
      (Eventually.of_forall fun _ =>
        (hψ.measurable.comp (measurable_const.prodMk measurable_id)).aestronglyMeasurable)
      (him t) (hdm t).aestronglyMeasurable
      (Eventually.of_forall fun y s _ => hdb s y) (hfi.const_mul C)
      (Eventually.of_forall fun y s hs => hpd s hs y)
    have hz := hflux t
    have he : (∫y,-(S t y (f y)) ∂μ)=0 := by rw [integral_neg]; exact neg_eq_zero.mpr hz
    rw [he] at hh
    exact hh.2
  have hQc : Continuous (fun t => ∫y,ψ (t,y) ∂μ) :=
    continuous_of_dominated
      (fun _ => (hψ.measurable.comp (measurable_const.prodMk measurable_id)).aestronglyMeasurable)
      (fun t => Eventually.of_forall (hψB t)) (integrable_const B)
      (Eventually.of_forall fun y => hψ.comp (continuous_id.prodMk continuous_const))
  obtain ⟨t,ht,he⟩ := exists_deriv_eq_slope (fun t => ∫y,ψ (t,y) ∂μ) hab hQc.continuousOn
    (fun t ht => (hQd t ht).differentiableAt.differentiableWithinAt)
  rw [(hQd t ht).deriv] at he
  have heq : (∫y,ψ (b,y) ∂μ)=(∫y,ψ (a,y) ∂μ) :=
    sub_eq_zero.mp ((div_eq_zero_iff).mp he.symm |>.resolve_right (sub_ne_zero.mpr hab.ne'))
  have ha : (fun y => ψ (a,y))=(fun y => φ (flow (fun _ _ => hL) hc ⟨a,le_rfl,hab.le⟩ y b)) := by
    funext y
    dsimp [ψ]
    rw [backwardTest_eq,projIcc_of_mem _ (show a∈Icc a b from ⟨le_rfl,hab.le⟩)]
  have hb : (fun y => ψ (b,y))=φ := by
    funext y
    dsimp [ψ]
    rw [backwardTest_eq,projIcc_of_mem _ (show b∈Icc a b from ⟨hab.le,le_rfl⟩)]
    exact congrArg φ (flow_initial (fun _ _ => hL) hc T y)
  rw [ha,hb] at heq
  exact heq.symm

end LogConcaveSampling.GlobalODE

end

end

section

noncomputable section
namespace LogConcaveSampling.LinearGrowthODE
open Set Function Filter Metric MeasureTheory
open scoped Topology NNReal

variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
  [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E]

omit [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E] in
lemma fderiv_zero_of_vanish_outside {ψ : E → ℝ} {C : ℝ}
    (hψ : ∀z,C<‖z‖ → ψ z=0) {y : E} (hy : C<‖y‖) : fderiv ℝ ψ y=0 := by
  have he : ψ =ᶠ[𝓝 y] fun _ => (0:ℝ) := by
    filter_upwards [(isOpen_lt continuous_const continuous_norm).mem_nhds hy] with z hz
    exact hψ z hz
  exact ((hasFDerivAt_const (𝕜:=ℝ) (0:ℝ) y).congr_of_eventuallyEq he).fderiv

theorem stationary_integral_compact {f : E → E} (hf : ContDiff ℝ 1 f) {K B a b : ℝ}
    (hK : 0≤K) (hB : 0≤B) (hg : ∀x,‖f x‖≤K*‖x‖+B) (hab : a<b)
    {μ : Measure E} [IsFiniteMeasure μ] (hfi : Integrable (fun x => ‖f x‖) μ)
    (hflux : ∀ψ : E → ℝ,ContDiff ℝ 1 ψ → HasCompactSupport ψ →
      (∫x,(fderiv ℝ ψ x) (f x) ∂μ)=0)
    {φ : E → ℝ} (hφ : ContDiff ℝ 1 φ) (hφc : HasCompactSupport φ) :
    (∫y,φ (flow hf hK hB hg hab.le y b) ∂μ)=∫y,φ y ∂μ := by
  obtain ⟨R,hR,hRb⟩ := hφc.isCompact.isBounded.exists_pos_norm_le
  have hφv (z : E) (hz : R<‖z‖) : φ z=0 := by
    by_contra hh
    exact (not_lt_of_ge (hRb z (subset_tsupport φ hh))) hz
  let C := gronwallBound R K B (b-a)
  obtain ⟨n,hn⟩ := exists_nat_gt (max C (gronwallBound C K B (b-a)))
  have hnC : C≤(n:ℝ)+1 := by have := le_max_left C (gronwallBound C K B (b-a)); linarith
  have hnG : gronwallBound C K B (b-a)≤(n:ℝ)+1 := by
    have := le_max_right C (gronwallBound C K B (b-a)); linarith
  obtain ⟨L,hL⟩ := truncated_lipschitz hf n
  let hc := truncated_continuous hf n
  let T : Icc a b := ⟨b,hab.le,le_rfl⟩
  let ψ := GlobalODE.backwardTest hab.le hc (fun _ _ => hL) T φ
  have hψv (t : ℝ) (z : E) (hz : C<‖z‖) : ψ (t,z)=0 :=
    backwardTest_vanish hf hK hB hg hab.le hR.le hφv n hL t z hz
  have hψc (t : ℝ) : ContDiff ℝ 1 (fun z => ψ (t,z)) := by
    have he : (fun z => ψ (t,z))=φ ∘ (fun z =>
        GlobalODE.flow (fun _ _ => hL) hc (projIcc a b hab.le t) z T) := by
      funext z
      exact GlobalODE.backwardTest_eq hab.le hc (fun _ _ => hL) T φ (t,z)
    rw [he]
    apply hφ.comp
    apply GlobalODE.flow_contDiff_one (D:=fun _ => fderiv ℝ (truncated f n)) hab.le hc (fun _ _ => hL)
      (((truncated_smooth hf n).continuous_fderiv (by norm_num)).comp continuous_snd)
      (fun _ z => ((truncated_smooth hf n).differentiable (by norm_num) z).hasFDerivAt)
  have hψcompact (t : ℝ) : HasCompactSupport (fun z => ψ (t,z)) :=
    HasCompactSupport.intro (isCompact_closedBall (0:E) C) fun z hz =>
      hψv t z (by simpa only [mem_closedBall,dist_zero_right,not_le] using hz)
  have hψflux (t : ℝ) : (∫y,(fderiv ℝ (fun z => ψ (t,z)) y) (truncated f n y) ∂μ)=0 := by
    rw [show (fun y => (fderiv ℝ (fun z => ψ (t,z)) y) (truncated f n y))=
      (fun y => (fderiv ℝ (fun z => ψ (t,z)) y) (f y)) by
        funext y
        by_cases hy : ‖y‖≤C
        · rw [truncated_eq (hy.trans hnC)]
        · rw [fderiv_zero_of_vanish_outside (hψv t) (lt_of_not_ge hy)]
          rfl]
    exact hflux _ (hψc t) (hψcompact t)
  have hni : Integrable (fun x => ‖truncated f n x‖) μ :=
    hfi.mono' (truncated_smooth hf n).continuous.norm.aestronglyMeasurable
      (Eventually.of_forall fun x => by
        rw [norm_norm,truncated,norm_smul,Real.norm_eq_abs,
          abs_of_nonneg (PoincareCutoff.cutoff_nonneg n x)]
        exact mul_le_of_le_one_left (norm_nonneg _) (PoincareCutoff.cutoff_le_one n x))
  obtain ⟨J,hJ⟩ := ContDiff.lipschitzWith_of_hasCompactSupport hφc hφ (by norm_num)
  obtain ⟨D,hD⟩ := hφc.exists_bound_of_continuous hφ.continuous
  have hh := GlobalODE.stationary_integral_of_backward_flux (truncated_smooth hf n) hL hni
    hab hφ hJ hD hψflux
  rw [←hh]
  apply integral_congr_ae
  filter_upwards [] with y
  by_cases hy : ‖y‖≤C
  · exact congrArg φ (eq_truncated_flow hf hK hB hg hab.le n hL hnG hy ⟨hab.le,le_rfl⟩)
  · have hy' : C<‖y‖ := lt_of_not_ge hy
    have hv : φ (flow hf hK hB hg hab.le y b)=0 := by
      apply hφv
      by_contra! h
      have hh := growth_from_right (flow_continuous hf hK hB hg hab.le y).continuousOn
        (flow_deriv hf hK hB hg hab.le y) h (fun _ _ => hg _) a ⟨le_rfl,hab.le⟩
      rw [flow_initial] at hh
      exact (not_lt_of_ge hh) hy'
    rw [hv]
    exact (by
      have hh := hψv a y hy'
      dsimp [ψ] at hh
      rw [GlobalODE.backwardTest_eq,projIcc_of_mem _ (show a∈Icc a b from ⟨le_rfl,hab.le⟩)] at hh
      exact hh.symm)
theorem stationary_law {f : E → E} (hf : ContDiff ℝ 1 f) {K B a b : ℝ}
    (hK : 0≤K) (hB : 0≤B) (hg : ∀x,‖f x‖≤K*‖x‖+B) (hab : a<b)
    {μ : Measure E} [IsFiniteMeasure μ] (hfi : Integrable (fun x => ‖f x‖) μ)
    (hflux : ∀ψ : E → ℝ,ContDiff ℝ 1 ψ → HasCompactSupport ψ →
      (∫x,(fderiv ℝ ψ x) (f x) ∂μ)=0) :
    μ.map (fun y => flow hf hK hB hg hab.le y b)=μ := by
  let T := fun y => flow hf hK hB hg hab.le y b
  have hTc : Continuous T := flow_continuous_initial hf hK hB hg hab.le b ⟨hab.le,le_rfl⟩
  apply measure_eq_of_smooth_lipschitz
  intro φ hφ _hφL hφB
  obtain ⟨D,hD⟩ := hφB
  let u := PoincareCutoff.truncation φ
  have hul (η : Measure E) [IsFiniteMeasure η] :
      Tendsto (fun n => ∫y,u n y ∂η) atTop (𝓝 (∫y,φ y ∂η)) := by
    apply tendsto_integral_of_dominated_convergence (fun _ => D)
      (fun n => (PoincareCutoff.truncation_smooth hφ n).continuous.aestronglyMeasurable)
      (integrable_const D)
    · exact fun n => Eventually.of_forall fun y =>
        (PoincareCutoff.truncation_abs φ n y).trans (hD y)
    · exact Eventually.of_forall (PoincareCutoff.truncation_tendsto φ)
  have he : (fun n => ∫y,u n y ∂μ.map T)=(fun n => ∫y,u n y ∂μ) := by
    funext n
    rw [integral_map hTc.aemeasurable
      (PoincareCutoff.truncation_smooth hφ n).continuous.aestronglyMeasurable]
    exact stationary_integral_compact hf hK hB hg hab hfi hflux
      (PoincareCutoff.truncation_smooth hφ n) (PoincareCutoff.truncation_compact φ n)
  exact tendsto_nhds_unique (hul (μ.map T)) (he ▸ hul μ)
end LogConcaveSampling.LinearGrowthODE

end

end

end

end OAI