diff --git a/LeanPool/Vlasov/ForMathlib/VariationalEquation.lean b/LeanPool/Vlasov/ForMathlib/VariationalEquation.lean
new file mode 100644
index 0000000000..824672bd0d
--- /dev/null
+++ b/LeanPool/Vlasov/ForMathlib/VariationalEquation.lean
@@ -0,0 +1,701 @@
+/-
+Copyright (c) 2026 Joseph K. Miller. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Joseph K. Miller
+-/
+module
+
+public import Mathlib.Analysis.Calculus.ParametricIntegral
+public import Mathlib.Analysis.ODE.Gronwall
+public import Mathlib.Analysis.SpecialFunctions.Integrals.Basic
+
+/-!
+# Generic analysis for the Vlasov variational equation
+
+Picard-series solutions and their parameter dependence, a Grönwall difference-quotient bound,
+and joint differentiability from continuous partial derivatives.  These arguments use only
+Mathlib, so they can compile independently of the characteristic-flow construction.
+-/
+
+@[expose] public section
+
+namespace Vlasov
+
+open MeasureTheory Filter Topology Asymptotics
+
+/-- Picard iterates for the linear IVP `x' = 𝒜(t)x`, `x(0)=x₀` (the V1c engine):
+`I₀ ≡ x₀`, `I_{n+1}(t) = ∫₀ᵗ 𝒜(s)(Iₙ(s)) ds`. -/
+noncomputable def picardIter {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
+    (𝒜 : ℝ → (E →L[ℝ] E)) (x₀ : E) : ℕ → ℝ → E
+  | 0, _ => x₀
+  | (n + 1), t => ∫ s in (0 : ℝ)..t, 𝒜 s (picardIter 𝒜 x₀ n s)
+
+@[simp] lemma picardIter_zero {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
+    (𝒜 : ℝ → (E →L[ℝ] E)) (x₀ : E) (t : ℝ) : picardIter 𝒜 x₀ 0 t = x₀ := rfl
+
+lemma picardIter_succ {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
+    (𝒜 : ℝ → (E →L[ℝ] E)) (x₀ : E) (n : ℕ) (t : ℝ) :
+    picardIter 𝒜 x₀ (n + 1) t = ∫ s in (0 : ℝ)..t, 𝒜 s (picardIter 𝒜 x₀ n s) := rfl
+
+/-- **C3 V1c-engine — the Picard iterates are continuous and satisfy the geometric
+`(Kt)ⁿ/n!`-bound on `[0,T]`.**  Proved by simultaneous induction (continuity feeds
+integrability, which feeds the next bound).  This `Σ (KT)ⁿ/n! = e^{KT}`-summable bound is the
+convergence driver for the V1c fixed point. -/
+lemma picardIter_continuousOn_and_bound {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
+    (𝒜 : ℝ → (E →L[ℝ] E)) (x₀ : E)
+    (T : ℝ) (hT : 0 ≤ T) (K : ℝ) (hK : 0 ≤ K)
+    (hcont𝒜 : ContinuousOn 𝒜 (Set.Icc 0 T))
+    (hbound𝒜 : ∀ t ∈ Set.Icc 0 T, ‖𝒜 t‖ ≤ K) :
+    ∀ n, ContinuousOn (picardIter 𝒜 x₀ n) (Set.Icc 0 T) ∧
+      ∀ t ∈ Set.Icc 0 T, ‖picardIter 𝒜 x₀ n t‖ ≤ (K * t) ^ n / n.factorial * ‖x₀‖ := by
+  intro n
+  induction n with
+  | zero =>
+    refine ⟨continuousOn_const, fun t ht => ?_⟩
+    simp
+  | succ n ih =>
+    obtain ⟨ih_cont, ih_bd⟩ := ih
+    have hg_cont : ContinuousOn (fun s => 𝒜 s (picardIter 𝒜 x₀ n s)) (Set.Icc 0 T) :=
+      hcont𝒜.clm_apply ih_cont
+    have hg_int : IntegrableOn (fun s => 𝒜 s (picardIter 𝒜 x₀ n s)) (Set.Icc 0 T) :=
+      hg_cont.integrableOn_Icc
+    refine ⟨?_, ?_⟩
+    · have hcp := intervalIntegral.continuousOn_primitive_interval (a := 0) (b := T) (μ := volume)
+        (f := fun s => 𝒜 s (picardIter 𝒜 x₀ n s)) (by rw [Set.uIcc_of_le hT]; exact hg_int)
+      rw [Set.uIcc_of_le hT] at hcp
+      exact hcp
+    · intro t ht
+      have ht0 : (0 : ℝ) ≤ t := ht.1
+      have htT : t ≤ T := ht.2
+      have h_ptwise : ∀ s ∈ Set.Icc (0 : ℝ) t,
+          ‖𝒜 s (picardIter 𝒜 x₀ n s)‖ ≤ K * (K * s) ^ n / n.factorial * ‖x₀‖ := by
+        intro s hs
+        have hsT : s ∈ Set.Icc (0 : ℝ) T := ⟨hs.1, le_trans hs.2 htT⟩
+        calc ‖𝒜 s (picardIter 𝒜 x₀ n s)‖
+            ≤ ‖𝒜 s‖ * ‖picardIter 𝒜 x₀ n s‖ := (𝒜 s).le_opNorm _
+          _ ≤ K * ((K * s) ^ n / n.factorial * ‖x₀‖) :=
+              mul_le_mul (hbound𝒜 s hsT) (ih_bd s hsT) (norm_nonneg _) hK
+          _ = K * (K * s) ^ n / n.factorial * ‖x₀‖ := by ring
+      have hRHS_int : IntervalIntegrable
+          (fun s => K * (K * s) ^ n / n.factorial * ‖x₀‖) volume 0 t :=
+        (Continuous.intervalIntegrable (by fun_prop) 0 t)
+      have hLHS_int : IntervalIntegrable
+          (fun s => ‖𝒜 s (picardIter 𝒜 x₀ n s)‖) volume 0 t := by
+        apply ContinuousOn.intervalIntegrable
+        rw [Set.uIcc_of_le ht0]
+        exact (hg_cont.mono (Set.Icc_subset_Icc_right htT)).norm
+      calc ‖picardIter 𝒜 x₀ (n + 1) t‖
+          = ‖∫ s in (0 : ℝ)..t, 𝒜 s (picardIter 𝒜 x₀ n s)‖ := by rw [picardIter_succ]
+        _ ≤ ∫ s in (0 : ℝ)..t, ‖𝒜 s (picardIter 𝒜 x₀ n s)‖ :=
+            intervalIntegral.norm_integral_le_integral_norm ht0
+        _ ≤ ∫ s in (0 : ℝ)..t, K * (K * s) ^ n / n.factorial * ‖x₀‖ :=
+            intervalIntegral.integral_mono_on ht0 hLHS_int hRHS_int h_ptwise
+        _ = (K * t) ^ (n + 1) / (n + 1).factorial * ‖x₀‖ := by
+            have hpow : ∀ s : ℝ, K * (K * s) ^ n / n.factorial * ‖x₀‖
+                = (K ^ (n + 1) * ‖x₀‖ / n.factorial) * s ^ n := by
+              intro s; rw [mul_pow]; ring
+            simp_rw [hpow]
+            rw [intervalIntegral.integral_const_mul, integral_pow]
+            rw [Nat.factorial_succ]
+            push_cast
+            rw [mul_pow]
+            field_simp
+            ring
+
+/-- The Picard majorant can be chosen uniformly over the whole time window. -/
+private lemma picardIter_norm_le_uniform
+    {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
+    (𝒜 : ℝ → (E →L[ℝ] E)) (x₀ : E) (T : ℝ) (hT : 0 ≤ T) (K : ℝ) (hK : 0 ≤ K)
+    (hcont𝒜 : ContinuousOn 𝒜 (Set.Icc 0 T)) (hbound𝒜 : ∀ t ∈ Set.Icc 0 T, ‖𝒜 t‖ ≤ K)
+    (n : ℕ) (t : ℝ) (ht : t ∈ Set.Icc (0 : ℝ) T) :
+    ‖picardIter 𝒜 x₀ n t‖ ≤ (K * T) ^ n / n.factorial * ‖x₀‖ := by
+  refine ((picardIter_continuousOn_and_bound 𝒜 x₀ T hT K hK hcont𝒜 hbound𝒜 n).2 t ht).trans ?_
+  exact mul_le_mul_of_nonneg_right
+    (div_le_div_of_nonneg_right
+      (pow_le_pow_left₀ (mul_nonneg hK ht.1) (mul_le_mul_of_nonneg_left ht.2 hK) n)
+      (Nat.cast_nonneg _)) (norm_nonneg _)
+
+/-- **Step 3 (i) — joint `(z,s)` continuity of the Dyson sum** (global-hypothesis form).
+The Picard iterates are jointly continuous, and their common summable majorant gives continuity
+of the sum on `univ ×ˢ Icc 0 T`.  Fixed-time continuity specializes this result. -/
+lemma picardSum_continuous_param_joint
+    {Z E : Type*} [TopologicalSpace Z] [NormedAddCommGroup E] [NormedSpace ℝ E] [CompleteSpace E]
+    (𝒜 : Z → ℝ → (E →L[ℝ] E)) (x₀ : E) (T : ℝ) (hT : 0 ≤ T) (K : ℝ) (hK : 0 ≤ K)
+    (h𝒜_cont : Continuous (fun p : Z × ℝ => 𝒜 p.1 p.2))
+    (h𝒜_bound : ∀ z, ∀ s ∈ Set.Icc (0 : ℝ) T, ‖𝒜 z s‖ ≤ K) :
+    ContinuousOn (fun p : Z × ℝ => ∑' n, picardIter (𝒜 p.1) x₀ n p.2)
+      (Set.univ ×ˢ Set.Icc (0 : ℝ) T) := by
+  have hiter_cont : ∀ n, Continuous (fun p : Z × ℝ => picardIter (𝒜 p.1) x₀ n p.2) := by
+    intro n
+    induction n with
+    | zero =>
+      simp only [picardIter_zero]
+      exact continuous_const
+    | succ n ih =>
+      have hg : Continuous (Function.uncurry fun z v => 𝒜 z v (picardIter (𝒜 z) x₀ n v)) :=
+        h𝒜_cont.clm_apply ih
+      have hpp := intervalIntegral.continuous_parametric_primitive_of_continuous
+        (μ := volume) (a₀ := (0 : ℝ)) hg
+      simp only [picardIter_succ]
+      exact hpp
+  have h𝒜cont_z : ∀ z, ContinuousOn (𝒜 z) (Set.Icc (0 : ℝ) T) := fun z =>
+    (h𝒜_cont.comp (continuous_const.prodMk continuous_id)).continuousOn
+  have hbd : ∀ (n : ℕ) (p : Z × ℝ), p ∈ Set.univ ×ˢ Set.Icc (0 : ℝ) T →
+      ‖picardIter (𝒜 p.1) x₀ n p.2‖ ≤ (K * T) ^ n / n.factorial * ‖x₀‖ :=
+    fun n p hp => picardIter_norm_le_uniform (𝒜 p.1) x₀ T hT K hK
+      (h𝒜cont_z p.1) (h𝒜_bound p.1) n p.2 hp.2
+  have hsum : Summable (fun n => (K * T) ^ n / n.factorial * ‖x₀‖) :=
+    (Real.summable_pow_div_factorial (K * T)).mul_right ‖x₀‖
+  exact continuousOn_tsum (fun n => (hiter_cont n).continuousOn) hsum hbd
+
+/-- **Step 3 (i) — joint `(z,s)` continuity of the Dyson sum** on a time window.
+Clamp time into `[0,T]` so the global form applies, then transfer back by agreement of the
+iterates on `[0,T]`.  Fixed-time continuity specializes this result. -/
+lemma picardSum_continuous_param_Icc_joint
+    {Z E : Type*} [TopologicalSpace Z] [NormedAddCommGroup E] [NormedSpace ℝ E] [CompleteSpace E]
+    (𝒜 : Z → ℝ → (E →L[ℝ] E)) (x₀ : E) (T : ℝ) (hT : 0 ≤ T) (K : ℝ) (hK : 0 ≤ K)
+    (h𝒜_contOn : ContinuousOn (fun p : Z × ℝ => 𝒜 p.1 p.2) (Set.univ ×ˢ Set.Icc (0 : ℝ) T))
+    (h𝒜_bound : ∀ z, ∀ s ∈ Set.Icc (0 : ℝ) T, ‖𝒜 z s‖ ≤ K) :
+    ContinuousOn (fun p : Z × ℝ => ∑' n, picardIter (𝒜 p.1) x₀ n p.2)
+      (Set.univ ×ˢ Set.Icc (0 : ℝ) T) := by
+  set cl : ℝ → ℝ := fun s => ↑(Set.projIcc 0 T hT s) with hcl
+  have hcl_cont : Continuous cl := continuous_subtype_val.comp continuous_projIcc
+  have hcl_mem : ∀ s, cl s ∈ Set.Icc (0 : ℝ) T := fun s => (Set.projIcc 0 T hT s).2
+  have hcl_eq : ∀ s ∈ Set.Icc (0 : ℝ) T, cl s = s := by
+    intro s hs; change (↑(Set.projIcc 0 T hT s) : ℝ) = s; rw [Set.projIcc_of_mem hT hs]
+  set 𝒜c : Z → ℝ → (E →L[ℝ] E) := fun z s => 𝒜 z (cl s) with h𝒜c
+  have h𝒜c_cont : Continuous (fun p : Z × ℝ => 𝒜c p.1 p.2) := by
+    have hmap : Continuous (fun p : Z × ℝ => ((p.1, cl p.2) : Z × ℝ)) :=
+      continuous_fst.prodMk (hcl_cont.comp continuous_snd)
+    have hmem : ∀ p : Z × ℝ, ((p.1, cl p.2) : Z × ℝ) ∈ Set.univ ×ˢ Set.Icc (0 : ℝ) T :=
+      fun p => ⟨Set.mem_univ _, hcl_mem p.2⟩
+    exact h𝒜_contOn.comp_continuous hmap hmem
+  have h𝒜c_bound : ∀ z, ∀ s ∈ Set.Icc (0 : ℝ) T, ‖𝒜c z s‖ ≤ K :=
+    fun z s _ => h𝒜_bound z (cl s) (hcl_mem s)
+  have hagree : ∀ (n : ℕ) (z : Z), ∀ s ∈ Set.Icc (0 : ℝ) T,
+      picardIter (𝒜c z) x₀ n s = picardIter (𝒜 z) x₀ n s := by
+    intro n
+    induction n with
+    | zero => intro z s _; simp
+    | succ n ih =>
+      intro z s hs
+      simp only [picardIter_succ]
+      refine intervalIntegral.integral_congr (fun u hu => ?_)
+      have huIcc : u ∈ Set.Icc (0 : ℝ) T := by
+        rw [Set.uIcc_of_le hs.1] at hu; exact ⟨hu.1, le_trans hu.2 hs.2⟩
+      have e1 : 𝒜c z u = 𝒜 z u := by simp only [h𝒜c, hcl_eq u huIcc]
+      rw [e1, ih z u huIcc]
+  have key := picardSum_continuous_param_joint 𝒜c x₀ T hT K hK h𝒜c_cont h𝒜c_bound
+  refine key.congr ?_
+  rintro ⟨z, s⟩ ⟨_, hs⟩
+  simp only
+  congr 1; funext n; exact (hagree n z s hs).symm
+
+/-- **C3 V1c-conv — the Dyson sum `M := ∑ₙ Iₙ` is continuous on `[0,T]`.**  Weierstrass M-test:
+the terms are dominated by the summable majorant `(KT)ⁿ/n!·‖x₀‖`, so the series converges
+uniformly; the uniform limit of the continuous partial sums is continuous.  (`M` is the candidate
+solution: `M = x₀ + ∫₀ᵗ 𝒜(s)(M s) ds`, proved next.) -/
+lemma picardSum_continuousOn {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] [CompleteSpace E]
+    (𝒜 : ℝ → (E →L[ℝ] E)) (x₀ : E) (T : ℝ) (hT : 0 ≤ T) (K : ℝ) (hK : 0 ≤ K)
+    (hcont𝒜 : ContinuousOn 𝒜 (Set.Icc 0 T)) (hbound𝒜 : ∀ t ∈ Set.Icc 0 T, ‖𝒜 t‖ ≤ K) :
+    ContinuousOn (fun t => ∑' n, picardIter 𝒜 x₀ n t) (Set.Icc 0 T) := by
+  have hcb := picardIter_continuousOn_and_bound 𝒜 x₀ T hT K hK hcont𝒜 hbound𝒜
+  have hbd : ∀ (n : ℕ) (t : ℝ), t ∈ Set.Icc (0 : ℝ) T →
+      ‖picardIter 𝒜 x₀ n t‖ ≤ (K * T) ^ n / n.factorial * ‖x₀‖ :=
+    picardIter_norm_le_uniform 𝒜 x₀ T hT K hK hcont𝒜 hbound𝒜
+  have hsum : Summable (fun n => (K * T) ^ n / n.factorial * ‖x₀‖) :=
+    (Real.summable_pow_div_factorial (K * T)).mul_right ‖x₀‖
+  exact continuousOn_tsum (fun n => (hcb n).1) hsum hbd
+
+/-- **C3 V2-core — the Dyson sum is continuous in a parameter.**  Restrict joint continuity
+of the Dyson sum to a fixed time in `[0,T]`.  The uniform majorant and convergence argument live
+in `picardSum_continuous_param_joint`, shared by both forms. -/
+lemma picardSum_continuous_param
+    {Z E : Type*} [TopologicalSpace Z] [NormedAddCommGroup E] [NormedSpace ℝ E] [CompleteSpace E]
+    (𝒜 : Z → ℝ → (E →L[ℝ] E)) (x₀ : E) (T : ℝ) (hT : 0 ≤ T) (K : ℝ) (hK : 0 ≤ K)
+    (h𝒜_cont : Continuous (fun p : Z × ℝ => 𝒜 p.1 p.2))
+    (h𝒜_bound : ∀ z, ∀ s ∈ Set.Icc (0 : ℝ) T, ‖𝒜 z s‖ ≤ K)
+    (t : ℝ) (ht : t ∈ Set.Icc (0 : ℝ) T) :
+    Continuous (fun z => ∑' n, picardIter (𝒜 z) x₀ n t) := by
+  exact (picardSum_continuous_param_joint 𝒜 x₀ T hT K hK h𝒜_cont h𝒜_bound).comp_continuous
+    (continuous_id.prodMk continuous_const) (fun z => ⟨Set.mem_univ z, ht⟩)
+
+/-- Window version of `picardSum_continuous_param`: restrict the joint window theorem to a
+fixed time.  The clamping and iterate-agreement argument is shared with the joint form. -/
+lemma picardSum_continuous_param_Icc
+    {Z E : Type*} [TopologicalSpace Z] [NormedAddCommGroup E] [NormedSpace ℝ E] [CompleteSpace E]
+    (𝒜 : Z → ℝ → (E →L[ℝ] E)) (x₀ : E) (T : ℝ) (hT : 0 ≤ T) (K : ℝ) (hK : 0 ≤ K)
+    (h𝒜_contOn : ContinuousOn (fun p : Z × ℝ => 𝒜 p.1 p.2) (Set.univ ×ˢ Set.Icc (0 : ℝ) T))
+    (h𝒜_bound : ∀ z, ∀ s ∈ Set.Icc (0 : ℝ) T, ‖𝒜 z s‖ ≤ K)
+    (t : ℝ) (ht : t ∈ Set.Icc (0 : ℝ) T) :
+    Continuous (fun z => ∑' n, picardIter (𝒜 z) x₀ n t) := by
+  exact (picardSum_continuous_param_Icc_joint 𝒜 x₀ T hT K hK h𝒜_contOn h𝒜_bound).comp_continuous
+    (continuous_id.prodMk continuous_const) (fun z => ⟨Set.mem_univ z, ht⟩)
+
+/-- **C3 V1c-rec — finite Picard recurrence.**  The `(N+1)`-th partial Dyson sum equals
+`x₀ + ∫₀ᵗ 𝒜(s)(Sₙ(s)) ds`, where `Sₙ = ∑_{n<N} Iₙ`.  Only finite-sum swaps
+(`integral_finsetSum`, `map_sum`); no infinite interchange.  Passing `N → ∞` against the
+uniform convergence (`picardSum_continuousOn`'s M-test) yields the integral equation for `M`. -/
+lemma picardSum_finset_recurrence
+    {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
+    (𝒜 : ℝ → (E →L[ℝ] E)) (x₀ : E) (T : ℝ) (hT : 0 ≤ T) (K : ℝ) (hK : 0 ≤ K)
+    (hcont𝒜 : ContinuousOn 𝒜 (Set.Icc 0 T)) (hbound𝒜 : ∀ t ∈ Set.Icc 0 T, ‖𝒜 t‖ ≤ K)
+    (N : ℕ) (t : ℝ) (ht : t ∈ Set.Icc (0 : ℝ) T) :
+    ∑ n ∈ Finset.range (N + 1), picardIter 𝒜 x₀ n t
+      = x₀ + ∫ s in (0 : ℝ)..t, 𝒜 s (∑ n ∈ Finset.range N, picardIter 𝒜 x₀ n s) := by
+  have hcb := picardIter_continuousOn_and_bound 𝒜 x₀ T hT K hK hcont𝒜 hbound𝒜
+  have hint : ∀ n, IntervalIntegrable
+      (fun s => 𝒜 s (picardIter 𝒜 x₀ n s)) volume 0 t := by
+    intro n
+    apply ContinuousOn.intervalIntegrable
+    rw [Set.uIcc_of_le ht.1]
+    exact (hcont𝒜.clm_apply (hcb n).1).mono (Set.Icc_subset_Icc_right ht.2)
+  rw [Finset.sum_range_succ', picardIter_zero]
+  simp only [picardIter_succ]
+  rw [add_comm]
+  congr 1
+  rw [← intervalIntegral.integral_finsetSum (fun i _ => hint i)]
+  refine intervalIntegral.integral_congr (fun s _ => ?_)
+  exact (map_sum (𝒜 s) (fun i => picardIter 𝒜 x₀ i s) (Finset.range N)).symm
+
+/-- **C3 V1c-inteq — the Dyson sum solves the integral equation.**
+`M(t) = x₀ + ∫₀ᵗ 𝒜(s)(M s) ds` on `[0,T]`, where `M = ∑'ₙ Iₙ`.  Pass `N → ∞` in the finite
+recurrence: LHS → `M t` (partial sums of the summable series); RHS via DCT (the terms
+`𝒜(s)(S_N s) → 𝒜(s)(M s)` pointwise, dominated by the constant `K·∑'ₙ (KT)ⁿ/n!·‖x₀‖`). -/
+lemma picardSum_solves_integralEq
+    {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] [CompleteSpace E]
+    (𝒜 : ℝ → (E →L[ℝ] E)) (x₀ : E) (T : ℝ) (hT : 0 ≤ T) (K : ℝ) (hK : 0 ≤ K)
+    (hcont𝒜 : ContinuousOn 𝒜 (Set.Icc 0 T)) (hbound𝒜 : ∀ t ∈ Set.Icc 0 T, ‖𝒜 t‖ ≤ K)
+    (t : ℝ) (ht : t ∈ Set.Icc (0 : ℝ) T) :
+    (∑' n, picardIter 𝒜 x₀ n t)
+      = x₀ + ∫ s in (0 : ℝ)..t, 𝒜 s (∑' n, picardIter 𝒜 x₀ n s) := by
+  have hcb := picardIter_continuousOn_and_bound 𝒜 x₀ T hT K hK hcont𝒜 hbound𝒜
+  have ht0 : (0 : ℝ) ≤ t := ht.1
+  have htT : t ≤ T := ht.2
+  have hmaj : ∀ n, ∀ s ∈ Set.Icc (0 : ℝ) T,
+      ‖picardIter 𝒜 x₀ n s‖ ≤ (K * T) ^ n / n.factorial * ‖x₀‖ :=
+    picardIter_norm_le_uniform 𝒜 x₀ T hT K hK hcont𝒜 hbound𝒜
+  have hmaj_summable : Summable (fun n => (K * T) ^ n / n.factorial * ‖x₀‖) :=
+    (Real.summable_pow_div_factorial (K * T)).mul_right ‖x₀‖
+  have hsummable : ∀ s ∈ Set.Icc (0 : ℝ) T, Summable (fun n => picardIter 𝒜 x₀ n s) := by
+    intro s hs
+    exact (hmaj_summable.of_nonneg_of_le (fun n => norm_nonneg _) (fun n => hmaj n s hs)).of_norm
+  set C : ℝ := ∑' n, (K * T) ^ n / n.factorial * ‖x₀‖ with hC
+  have hSbound : ∀ N, ∀ s ∈ Set.Icc (0 : ℝ) T,
+      ‖∑ n ∈ Finset.range N, picardIter 𝒜 x₀ n s‖ ≤ C := by
+    intro N s hs
+    refine le_trans (norm_sum_le _ _) ?_
+    refine le_trans (Finset.sum_le_sum (fun n _ => hmaj n s hs)) ?_
+    exact hmaj_summable.sum_le_tsum _ (fun n _ => by positivity)
+  set M : ℝ → E := fun u => ∑' n, picardIter 𝒜 x₀ n u with hM
+  have hLHS : Filter.Tendsto (fun N => ∑ n ∈ Finset.range (N + 1), picardIter 𝒜 x₀ n t)
+      Filter.atTop (nhds (M t)) :=
+    ((hsummable t ht).hasSum.tendsto_sum_nat).comp (Filter.tendsto_add_atTop_nat 1)
+  have hRHS_int : Filter.Tendsto
+      (fun N => ∫ s in Set.Ioc (0 : ℝ) t, 𝒜 s (∑ n ∈ Finset.range N, picardIter 𝒜 x₀ n s))
+      Filter.atTop (nhds (∫ s in Set.Ioc (0 : ℝ) t, 𝒜 s (M s))) := by
+    apply MeasureTheory.tendsto_integral_of_dominated_convergence (bound := fun _ => K * C)
+    · intro N
+      apply ContinuousOn.aestronglyMeasurable _ measurableSet_Ioc
+      exact (hcont𝒜.clm_apply (continuousOn_finsetSum _ (fun n _ => (hcb n).1))).mono
+        (Set.Ioc_subset_Icc_self.trans (Set.Icc_subset_Icc_right htT))
+    · exact integrableOn_const (hs := measure_Ioc_lt_top.ne)
+    · intro N
+      refine MeasureTheory.ae_restrict_of_forall_mem measurableSet_Ioc (fun s hs => ?_)
+      have hsT : s ∈ Set.Icc (0 : ℝ) T := ⟨le_of_lt hs.1, le_trans hs.2 htT⟩
+      calc ‖𝒜 s (∑ n ∈ Finset.range N, picardIter 𝒜 x₀ n s)‖
+          ≤ ‖𝒜 s‖ * ‖∑ n ∈ Finset.range N, picardIter 𝒜 x₀ n s‖ := (𝒜 s).le_opNorm _
+        _ ≤ K * C := mul_le_mul (hbound𝒜 s hsT) (hSbound N s hsT) (norm_nonneg _) hK
+    · refine MeasureTheory.ae_restrict_of_forall_mem measurableSet_Ioc (fun s hs => ?_)
+      have hsT : s ∈ Set.Icc (0 : ℝ) T := ⟨le_of_lt hs.1, le_trans hs.2 htT⟩
+      exact ((𝒜 s).continuous.tendsto (M s)).comp ((hsummable s hsT).hasSum.tendsto_sum_nat)
+  rw [intervalIntegral.integral_of_le ht0]
+  have hrec' : ∀ N, ∑ n ∈ Finset.range (N + 1), picardIter 𝒜 x₀ n t
+      = x₀ + ∫ s in Set.Ioc (0 : ℝ) t, 𝒜 s (∑ n ∈ Finset.range N, picardIter 𝒜 x₀ n s) := by
+    intro N
+    rw [picardSum_finset_recurrence 𝒜 x₀ T hT K hK hcont𝒜 hbound𝒜 N t ht,
+      intervalIntegral.integral_of_le ht0]
+  exact tendsto_nhds_unique hLHS ((hRHS_int.const_add x₀).congr (fun N => (hrec' N).symm))
+
+/-- The explicit Picard sum satisfies the linear initial-value problem. -/
+private lemma picardSum_spec
+    {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] [CompleteSpace E]
+    (𝒜 : ℝ → (E →L[ℝ] E)) (T : ℝ) (hT : 0 ≤ T)
+    (h𝒜 : ContinuousOn 𝒜 (Set.Icc 0 T)) (x₀ : E) :
+    (∑' n, picardIter 𝒜 x₀ n 0) = x₀ ∧
+      ContinuousOn (fun t => ∑' n, picardIter 𝒜 x₀ n t) (Set.Icc 0 T) ∧
+      ∀ t ∈ Set.Icc 0 T,
+        HasDerivWithinAt (fun t => ∑' n, picardIter 𝒜 x₀ n t)
+          (𝒜 t (∑' n, picardIter 𝒜 x₀ n t)) (Set.Icc 0 T) t := by
+  obtain ⟨K, hbK⟩ := isCompact_Icc.exists_bound_of_continuousOn h𝒜
+  have hK'0 : 0 ≤ max K 0 := le_max_right _ _
+  have hbound : ∀ t ∈ Set.Icc (0 : ℝ) T, ‖𝒜 t‖ ≤ max K 0 :=
+    fun t ht => le_trans (hbK t ht) (le_max_left _ _)
+  set M : ℝ → E := fun u => ∑' n, picardIter 𝒜 x₀ n u with hM
+  have hMcont : ContinuousOn M (Set.Icc 0 T) :=
+    picardSum_continuousOn 𝒜 x₀ T hT (max K 0) hK'0 h𝒜 hbound
+  have hMeq : ∀ t ∈ Set.Icc (0 : ℝ) T, M t = x₀ + ∫ s in (0 : ℝ)..t, 𝒜 s (M s) :=
+    fun t ht => picardSum_solves_integralEq 𝒜 x₀ T hT (max K 0) hK'0 h𝒜 hbound t ht
+  have hg_cont : ContinuousOn (fun s => 𝒜 s (M s)) (Set.Icc 0 T) := h𝒜.clm_apply hMcont
+  refine ⟨?_, hMcont, fun t ht => ?_⟩
+  · change M 0 = x₀
+    rw [hMeq 0 ⟨le_refl 0, hT⟩, intervalIntegral.integral_same, add_zero]
+  · have : Fact (t ∈ Set.Icc (0 : ℝ) T) := ⟨ht⟩
+    have hg_int : IntervalIntegrable (fun s => 𝒜 s (M s)) volume 0 t := by
+      apply ContinuousOn.intervalIntegrable
+      rw [Set.uIcc_of_le ht.1]
+      exact hg_cont.mono (Set.Icc_subset_Icc_right ht.2)
+    have hg_meas : StronglyMeasurableAtFilter (fun s => 𝒜 s (M s)) (nhdsWithin t (Set.Icc 0 T)) :=
+      ⟨Set.Icc 0 T, self_mem_nhdsWithin, hg_cont.aestronglyMeasurable measurableSet_Icc⟩
+    have hFTC : HasDerivWithinAt (fun u => ∫ s in (0 : ℝ)..u, 𝒜 s (M s)) (𝒜 t (M t))
+        (Set.Icc 0 T) t :=
+      intervalIntegral.integral_hasDerivWithinAt_right hg_int hg_meas (hg_cont t ht)
+    exact (hFTC.const_add x₀).congr (fun y hy => hMeq y hy) (hMeq t ht)
+
+
+/-- Existence for a linear ODE with continuous coefficients on a compact interval.
+The Picard sum gives an explicit solution.  Its summable factorial majorant supplies continuity,
+and its integral equation supplies the derivative through the fundamental theorem of calculus. -/
+theorem exists_linearODE_solution_Icc
+    {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] [CompleteSpace E]
+    (𝒜 : ℝ → (E →L[ℝ] E)) (T : ℝ) (hT : 0 ≤ T)
+    (h𝒜 : ContinuousOn 𝒜 (Set.Icc 0 T)) (x₀ : E) :
+    ∃ M : ℝ → E, M 0 = x₀ ∧ ContinuousOn M (Set.Icc 0 T) ∧
+      ∀ t ∈ Set.Icc 0 T, HasDerivWithinAt M (𝒜 t (M t)) (Set.Icc 0 T) t := by
+  exact ⟨fun t => ∑' n, picardIter 𝒜 x₀ n t, picardSum_spec 𝒜 T hT h𝒜 x₀⟩
+
+/-- **C3 V1c→matrix — the fundamental matrix of a linear ODE.**  Specialising
+`exists_linearODE_solution_Icc` to the operator space `E := F →L[ℝ] F` with `𝒜(s) := A(s) ∘ (·)`
+(left composition) and `x₀ := id` gives the fundamental solution `M' = A(t)∘M`, `M(0) = id`.
+This `M(t)` is the candidate `Dflow t z` of the variational equation (#3), once `A` is the Vlasov
+field Jacobian `A(s) = D_z b(s, Φ_s z)` along the flow (F2). -/
+lemma exists_fundamentalMatrix
+    {F : Type*} [NormedAddCommGroup F] [NormedSpace ℝ F] [CompleteSpace F]
+    (A : ℝ → (F →L[ℝ] F)) (T : ℝ) (hT : 0 ≤ T) (hA : ContinuousOn A (Set.Icc 0 T)) :
+    ∃ M : ℝ → (F →L[ℝ] F), M 0 = ContinuousLinearMap.id ℝ F ∧ ContinuousOn M (Set.Icc 0 T) ∧
+      ∀ t ∈ Set.Icc 0 T, HasDerivWithinAt M ((A t).comp (M t)) (Set.Icc 0 T) t := by
+  obtain ⟨M, hM0, hMcont, hMderiv⟩ := exists_linearODE_solution_Icc
+    (fun s => ContinuousLinearMap.compL ℝ F F F (A s)) T hT
+    ((ContinuousLinearMap.compL ℝ F F F).continuous.comp_continuousOn hA)
+    (ContinuousLinearMap.id ℝ F)
+  refine ⟨M, hM0, hMcont, fun t ht => ?_⟩
+  simpa [ContinuousLinearMap.compL_apply] using hMderiv t ht
+
+/-- **C3 (shared) — Lipschitz-in-parameter + ContinuousOn-in-time ⇒ jointly ContinuousOn.**
+A generic upgrade: if `G z ·` is `ContinuousOn (Icc 0 T)` for each `z` and `z ↦ G z s` is
+`C`-Lipschitz uniformly over `s ∈ [0,T]`, then `(z,s) ↦ G z s` is jointly continuous on
+`univ ×ˢ Icc 0 T`.  Used to derive flow joint continuity `(z,s) ↦ Φ_s z` from
+`charFlow_lipschitzInZ_via_gronwall_Ioo` (Lipschitz-in-`z`) + per-`z` continuity in `s`. -/
+lemma continuousOn_prod_of_lipschitz_continuousOn
+    {Z E : Type*} [PseudoMetricSpace Z] [PseudoMetricSpace E]
+    (G : Z → ℝ → E) (T C : ℝ)
+    (hlip : ∀ s ∈ Set.Icc (0 : ℝ) T, ∀ z₁ z₂, dist (G z₁ s) (G z₂ s) ≤ C * dist z₁ z₂)
+    (hcont : ∀ z, ContinuousOn (fun s => G z s) (Set.Icc (0 : ℝ) T)) :
+    ContinuousOn (fun p : Z × ℝ => G p.1 p.2) (Set.univ ×ˢ Set.Icc (0 : ℝ) T) := by
+  rw [Metric.continuousOn_iff]
+  rintro ⟨z₀, s₀⟩ ⟨_, hs₀⟩ ε hε
+  obtain ⟨δ₁, hδ₁, hcs⟩ :=
+    (Metric.continuousWithinAt_iff).mp (hcont z₀ s₀ hs₀) (ε/2) (by positivity)
+  have hC1 : (0 : ℝ) < |C| + 1 := by positivity
+  refine ⟨min δ₁ (ε / (2 * (|C| + 1))), by positivity, ?_⟩
+  rintro ⟨z, s⟩ ⟨_, hs⟩ hd
+  rw [Prod.dist_eq, max_lt_iff] at hd
+  obtain ⟨hdz, hds⟩ := hd
+  have hterm1 : dist (G z s) (G z₀ s) < ε/2 := by
+    calc dist (G z s) (G z₀ s)
+        ≤ C * dist z z₀ := hlip s hs z z₀
+      _ ≤ (|C| + 1) * dist z z₀ :=
+          mul_le_mul_of_nonneg_right (by linarith [le_abs_self C]) dist_nonneg
+      _ < (|C| + 1) * (ε / (2 * (|C| + 1))) :=
+          mul_lt_mul_of_pos_left (lt_of_lt_of_le hdz (min_le_right _ _)) hC1
+      _ = ε/2 := by field_simp
+  have hterm2 : dist (G z₀ s) (G z₀ s₀) < ε/2 :=
+    hcs hs (lt_of_lt_of_le hds (min_le_left _ _))
+  calc dist (G z s) (G z₀ s₀)
+      ≤ dist (G z s) (G z₀ s) + dist (G z₀ s) (G z₀ s₀) := dist_triangle _ _ _
+    _ < ε/2 + ε/2 := add_lt_add hterm1 hterm2
+    _ = ε := by ring
+
+/-- Generic Grönwall difference-quotient bound (open-interval ODE + `s₀→0⁺` limit).  Two curves
+`uh, mh` that approximately solve the same linear ODE `w' = vlin·w` on `Ioo 0 T` from the same datum
+(`uh 0 = mh 0`), with `mh` exact and `uh`'s defect uniformly `≤ εf`, satisfy
+`dist (uh t) (mh t) ≤ gronwallBound 0 K εf t`.  `vlin` is abstract (kept opaque to avoid unfolding
+the heavy `vlasovFieldJacobian` integral in the Grönwall application). -/
+lemma gronwall_diffQuotient_bound
+    {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
+    (vlin : ℝ → (E →L[ℝ] E)) (K : NNReal) (hvlin_lip : ∀ s, LipschitzWith K (vlin s))
+    (uh mh Fuh : ℝ → E) (εf : ℝ) (T t : ℝ) (ht : t ∈ Set.Ioo (0 : ℝ) T)
+    (huh_cont : ContinuousOn uh (Set.Icc 0 T)) (hmh_cont : ContinuousOn mh (Set.Icc 0 T))
+    (huh_deriv : ∀ s ∈ Set.Ioo (0 : ℝ) T, HasDerivAt uh (Fuh s) s)
+    (hmh_deriv : ∀ s ∈ Set.Ioo (0 : ℝ) T, HasDerivAt mh ((vlin s) (mh s)) s)
+    (hdefect : ∀ s ∈ Set.Ioo (0 : ℝ) T, dist (Fuh s) (vlin s (uh s)) ≤ εf)
+    (h0 : uh 0 = mh 0) :
+    dist (uh t) (mh t) ≤ gronwallBound 0 (K:ℝ) εf t := by
+  have hbound_s0 : ∀ s₀ ∈ Set.Ioo (0 : ℝ) t,
+      dist (uh t) (mh t) ≤ gronwallBound (dist (uh s₀) (mh s₀)) (K:ℝ) εf (t - s₀) := by
+    intro s₀ hs₀
+    have hIco_sub : Set.Ico s₀ t ⊆ Set.Ioo 0 T := fun s hs =>
+      ⟨lt_of_lt_of_le hs₀.1 hs.1, hs.2.trans ht.2⟩
+    have hIcc_sub : Set.Icc s₀ t ⊆ Set.Icc 0 T := fun s hs =>
+      ⟨le_trans hs₀.1.le hs.1, le_trans hs.2 ht.2.le⟩
+    have key := dist_le_of_approx_trajectories_ODE (K := K)
+      (εf := εf) (εg := 0) (δ := dist (uh s₀) (mh s₀))
+      hvlin_lip (huh_cont.mono hIcc_sub)
+      (fun s hs => (huh_deriv s (hIco_sub hs)).hasDerivWithinAt)
+      (fun s hs => hdefect s (hIco_sub hs))
+      (hmh_cont.mono hIcc_sub)
+      (fun s hs => (hmh_deriv s (hIco_sub hs)).hasDerivWithinAt)
+      (fun s _ => le_of_eq (dist_self _)) (le_refl _)
+    have hkey := key t ⟨hs₀.2.le, le_refl t⟩
+    simpa only [add_zero] using hkey
+  have : (𝓝[Set.Ioo 0 t] (0 : ℝ)).NeBot := left_nhdsWithin_Ioo_neBot ht.1
+  have hT0 : (0 : ℝ) ≤ T := le_trans ht.1.le ht.2.le
+  have hsub_Icc : Set.Ioo (0 : ℝ) t ⊆ Set.Icc 0 T := fun s hs => ⟨hs.1.le, le_trans hs.2.le ht.2.le⟩
+  have htend_uh : Tendsto uh (𝓝[Set.Ioo 0 t] 0) (𝓝 (uh 0)) :=
+    (huh_cont 0 ⟨le_refl 0, hT0⟩).tendsto.mono_left (nhdsWithin_mono 0 hsub_Icc)
+  have htend_mh : Tendsto mh (𝓝[Set.Ioo 0 t] 0) (𝓝 (mh 0)) :=
+    (hmh_cont 0 ⟨le_refl 0, hT0⟩).tendsto.mono_left (nhdsWithin_mono 0 hsub_Icc)
+  have htend_δ : Tendsto (fun s₀ => dist (uh s₀) (mh s₀)) (𝓝[Set.Ioo 0 t] 0) (𝓝 0) := by
+    have := htend_uh.dist htend_mh
+    rwa [h0, dist_self] at this
+  have htend_x : Tendsto (fun s₀ : ℝ => t - s₀) (𝓝[Set.Ioo 0 t] 0) (𝓝 t) := by
+    have h0' : Tendsto (fun s₀ : ℝ => t - s₀) (𝓝 0) (𝓝 (t - 0)) :=
+      (continuous_const.sub continuous_id).tendsto 0
+    rw [sub_zero] at h0'; exact h0'.mono_left nhdsWithin_le_nhds
+  have hgb_cont : Continuous (fun p : ℝ × ℝ => gronwallBound p.1 (K:ℝ) εf p.2) := by
+    by_cases hK : (K:ℝ) = 0
+    · simp only [hK, gronwallBound_K0]; fun_prop
+    · have heq : (fun p : ℝ × ℝ => gronwallBound p.1 (K:ℝ) εf p.2)
+          = fun p => p.1 * Real.exp ((K:ℝ) * p.2) + εf / (K:ℝ) * (Real.exp ((K:ℝ) * p.2) - 1) := by
+        funext p; rw [gronwallBound_of_K_ne_0 hK]
+      rw [heq]; fun_prop
+  have htend_gb : Tendsto (fun s₀ => gronwallBound (dist (uh s₀) (mh s₀)) (K:ℝ) εf (t - s₀))
+      (𝓝[Set.Ioo 0 t] 0) (𝓝 (gronwallBound 0 (K:ℝ) εf t)) :=
+    (hgb_cont.tendsto (0, t)).comp (htend_δ.prodMk_nhds htend_x)
+  exact ge_of_tendsto htend_gb (eventually_nhdsWithin_of_forall (fun s₀ hs₀ => hbound_s0 s₀ hs₀))
+
+/-- **Step 3 gating lemma (generic) — joint `C¹` from continuous partial derivatives** on a
+`ℝ × E` domain (Mathlib-absent).  A partial `s`-derivative `Ds p` at every point (`Ds` continuous)
+plus a partial `z`-derivative `Dz₀` at the base point ⇒ `f` is Fréchet-differentiable at `(s₀,z₀)`
+with total derivative `(h,k) ↦ h•Ds(s₀,z₀) + Dz₀ k`.  Proof: split the increment into an
+`s`-part (FTC `∫₀ʰ Ds(s₀+u,z₀+k)du ≈ h•Ds₀` by continuity of `Ds`) and a `z`-part
+(`= Dz₀ k + o(k)`).
+This is the keystone for the joint `(s,w)` regularity of the two-time flow `Φ_{s→t}`: the flow's
+partials are `M_s z` (jointly continuous, V2) in `z` and `b_s(Φ_s z)` in `s`.
+
+**PR-ABLE (Mathlib upstream candidate).**  This is a general real-analysis result with no Vlasov
+content — "a function on `ℝ × E` with a continuous partial derivative in the `ℝ` factor and a
+Fréchet partial derivative in the `E` factor is Fréchet-differentiable" — filling a genuine gap in
+`Mathlib/Analysis/Calculus`.  Generalisation worth doing before a PR: replace the `ℝ` factor by an
+arbitrary first factor with an analogous "integrate the partial along segments" hypothesis, and
+weaken `Continuous Ds` to `ContinuousAt Ds` at the base point (the proof only uses a neighbourhood
+of `(s₀,z₀)`). -/
+theorem hasFDerivAt_of_continuous_partials
+    {E F : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
+    [NormedAddCommGroup F] [NormedSpace ℝ F] [CompleteSpace F]
+    {f : ℝ × E → F} {Ds : ℝ × E → F} {Dz₀ : E →L[ℝ] F} (s₀ : ℝ) (z₀ : E)
+    (hDs : ∀ p : ℝ × E, HasDerivAt (fun s => f (s, p.2)) (Ds p) p.1)
+    (hDs_cont : Continuous Ds)
+    (hDz₀ : HasFDerivAt (fun z => f (s₀, z)) Dz₀ z₀) :
+    HasFDerivAt f
+      ((ContinuousLinearMap.fst ℝ ℝ E).smulRight (Ds (s₀, z₀))
+        + Dz₀.comp (ContinuousLinearMap.snd ℝ ℝ E)) (s₀, z₀) := by
+  set Ds₀ : F := Ds (s₀, z₀) with hDs₀
+  rw [hasFDerivAt_iff_isLittleO_nhds_zero, isLittleO_iff]
+  intro ε hε
+  have hBz : ∀ᶠ k in 𝓝 (0 : E),
+      ‖f (s₀, z₀ + k) - f (s₀, z₀) - Dz₀ k‖ ≤ (ε / 2) * ‖k‖ := by
+    have hz := hDz₀
+    rw [hasFDerivAt_iff_isLittleO_nhds_zero, isLittleO_iff] at hz
+    exact hz (half_pos hε)
+  have hBz' : ∀ᶠ p : ℝ × E in 𝓝 0,
+      ‖f (s₀, z₀ + p.2) - f (s₀, z₀) - Dz₀ p.2‖ ≤ (ε / 2) * ‖p.2‖ :=
+    (continuous_snd.tendsto (0 : ℝ × E)).eventually hBz
+  have hball : ∀ᶠ q in 𝓝 ((s₀, z₀) : ℝ × E), ‖Ds q - Ds₀‖ ≤ ε / 2 := by
+    have hc : Tendsto Ds (𝓝 (s₀, z₀)) (𝓝 Ds₀) := hDs_cont.continuousAt
+    have hsub : Tendsto (fun q => Ds q - Ds₀) (𝓝 (s₀, z₀)) (𝓝 (Ds₀ - Ds₀)) :=
+      hc.sub tendsto_const_nhds
+    rw [sub_self] at hsub
+    have h0 : Tendsto (fun q => ‖Ds q - Ds₀‖) (𝓝 (s₀, z₀)) (𝓝 0) := by
+      simpa using hsub.norm
+    exact h0.eventually (Iic_mem_nhds (half_pos hε))
+  obtain ⟨δ, hδpos, hδ⟩ := Metric.eventually_nhds_iff.mp hball
+  have hAs : ∀ᶠ p : ℝ × E in 𝓝 0,
+      ‖f (s₀ + p.1, z₀ + p.2) - f (s₀, z₀ + p.2) - p.1 • Ds₀‖ ≤ (ε / 2) * ‖p‖ := by
+    filter_upwards [Metric.ball_mem_nhds (0 : ℝ × E) hδpos] with p hp
+    rw [mem_ball_zero_iff] at hp
+    have hcont_u : Continuous (fun u => Ds (u, z₀ + p.2)) :=
+      hDs_cont.comp (continuous_id.prodMk continuous_const)
+    have hg_deriv : ∀ u : ℝ, HasDerivAt (fun s => f (s, z₀ + p.2)) (Ds (u, z₀ + p.2)) u :=
+      fun u => hDs (u, z₀ + p.2)
+    have hftc : ∫ u in s₀..(s₀ + p.1), Ds (u, z₀ + p.2)
+        = f (s₀ + p.1, z₀ + p.2) - f (s₀, z₀ + p.2) := by
+      rw [intervalIntegral.integral_eq_sub_of_hasDerivAt (fun u _ => hg_deriv u)
+        (hcont_u.intervalIntegrable _ _)]
+    have hbound_u : ∀ u ∈ Set.uIoc s₀ (s₀ + p.1), ‖Ds (u, z₀ + p.2) - Ds₀‖ ≤ ε / 2 := by
+      intro u hu
+      refine @hδ (u, z₀ + p.2) ?_
+      have hple : |p.1| ≤ ‖p‖ := by rw [← Real.norm_eq_abs]; exact norm_fst_le p
+      have hp1 : |u - s₀| ≤ ‖p‖ := by
+        rcases Set.mem_uIcc.mp (Set.uIoc_subset_uIcc hu) with ⟨ha, hb⟩ | ⟨ha, hb⟩
+        · rw [abs_of_nonneg (by linarith : (0 : ℝ) ≤ u - s₀)]
+          rw [abs_of_nonneg (by linarith : (0 : ℝ) ≤ p.1)] at hple; linarith
+        · rw [abs_of_nonpos (by linarith : u - s₀ ≤ 0)]
+          rw [abs_of_nonpos (by linarith : p.1 ≤ 0)] at hple; linarith
+      have hp2 : ‖p.2‖ ≤ ‖p‖ := norm_snd_le p
+      rw [Prod.dist_eq]
+      simp only [dist_eq_norm, add_sub_cancel_left, Real.norm_eq_abs]
+      exact lt_of_le_of_lt (max_le hp1 hp2) hp
+    have hA_eq : f (s₀ + p.1, z₀ + p.2) - f (s₀, z₀ + p.2) - p.1 • Ds₀
+        = ∫ u in s₀..(s₀ + p.1), (Ds (u, z₀ + p.2) - Ds₀) := by
+      rw [intervalIntegral.integral_sub (hcont_u.intervalIntegrable _ _)
+          (intervalIntegrable_const), hftc, intervalIntegral.integral_const,
+          add_sub_cancel_left]
+    rw [hA_eq]
+    calc ‖∫ u in s₀..(s₀ + p.1), (Ds (u, z₀ + p.2) - Ds₀)‖
+        ≤ (ε / 2) * |(s₀ + p.1) - s₀| :=
+          intervalIntegral.norm_integral_le_of_norm_le_const hbound_u
+      _ = (ε / 2) * ‖p.1‖ := by rw [add_sub_cancel_left, Real.norm_eq_abs]
+      _ ≤ (ε / 2) * ‖p‖ := mul_le_mul_of_nonneg_left (norm_fst_le p) (by positivity)
+  filter_upwards [hAs, hBz'] with p hAp hBp
+  have hdecomp :
+      f ((s₀, z₀) + p) - f (s₀, z₀)
+        - ((ContinuousLinearMap.fst ℝ ℝ E).smulRight Ds₀
+            + Dz₀.comp (ContinuousLinearMap.snd ℝ ℝ E)) p
+      = (f (s₀ + p.1, z₀ + p.2) - f (s₀, z₀ + p.2) - p.1 • Ds₀)
+        + (f (s₀, z₀ + p.2) - f (s₀, z₀) - Dz₀ p.2) := by
+    rw [show ((s₀, z₀) + p : ℝ × E) = (s₀ + p.1, z₀ + p.2) from rfl]
+    simp only [add_apply, ContinuousLinearMap.smulRight_apply,
+      ContinuousLinearMap.coe_fst', ContinuousLinearMap.comp_apply,
+      ContinuousLinearMap.coe_snd']
+    abel
+  rw [hdecomp]
+  calc ‖(f (s₀ + p.1, z₀ + p.2) - f (s₀, z₀ + p.2) - p.1 • Ds₀)
+          + (f (s₀, z₀ + p.2) - f (s₀, z₀) - Dz₀ p.2)‖
+      ≤ ‖f (s₀ + p.1, z₀ + p.2) - f (s₀, z₀ + p.2) - p.1 • Ds₀‖
+        + ‖f (s₀, z₀ + p.2) - f (s₀, z₀) - Dz₀ p.2‖ := norm_add_le _ _
+    _ ≤ (ε / 2) * ‖p‖ + (ε / 2) * ‖p‖ :=
+        add_le_add hAp (le_trans hBp (mul_le_mul_of_nonneg_left (norm_snd_le p) (by positivity)))
+    _ = ε * ‖p‖ := by ring
+
+/-- **Step 3 gating lemma (LOCAL / open-set form)** — joint `HasFDerivAt` from continuous partial
+derivatives on an open set `U ⊆ ℝ × E`.  The open-set generalisation of
+`hasFDerivAt_of_continuous_partials` (which is the `U := univ` special case) that the PR-note above
+flagged: the `s`-partial is required only on `U`, and `Ds` only `ContinuousOn U`.  This is the form
+the Vlasov flow needs — its partials exist and are continuous only on the open window
+`Ioo 0 T ×ˢ univ`.  Proof = the global proof + ball-in-`U` bookkeeping (`B((s₀,z₀),r) ⊆ U`; the FTC
+segment points `(u, z₀+p.2)`, `u ∈ uIcc s₀ (s₀+p.1)`, lie within `‖p‖ < min δ (r/2)` of `(s₀,z₀)`,
+hence in `U` and within the continuity radius `δ`).
+
+NOTE (consolidation TODO): the global `hasFDerivAt_of_continuous_partials` above is the `univ`
+special case of this; a follow-up cleanup should rewrite it as the one-line corollary
+`hasFDerivAt_of_continuous_partials_open isOpen_univ (Set.mem_univ _) (fun p _ => hDs p)
+hDs_cont.continuousOn hDz₀` to drop the duplicated proof.  **PR-ABLE** (the more
+general statement). -/
+theorem hasFDerivAt_of_continuous_partials_open
+    {E F : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
+    [NormedAddCommGroup F] [NormedSpace ℝ F] [CompleteSpace F]
+    {f : ℝ × E → F} {Ds : ℝ × E → F} {Dz₀ : E →L[ℝ] F}
+    {U : Set (ℝ × E)} (hU : IsOpen U) {s₀ : ℝ} {z₀ : E} (hmem : (s₀, z₀) ∈ U)
+    (hDs : ∀ p ∈ U, HasDerivAt (fun s => f (s, p.2)) (Ds p) p.1)
+    (hDs_cont : ContinuousOn Ds U)
+    (hDz₀ : HasFDerivAt (fun z => f (s₀, z)) Dz₀ z₀) :
+    HasFDerivAt f
+      ((ContinuousLinearMap.fst ℝ ℝ E).smulRight (Ds (s₀, z₀))
+        + Dz₀.comp (ContinuousLinearMap.snd ℝ ℝ E)) (s₀, z₀) := by
+  set Ds₀ : F := Ds (s₀, z₀) with hDs₀
+  obtain ⟨r, hrpos, hrU⟩ := Metric.isOpen_iff.mp hU (s₀, z₀) hmem
+  rw [hasFDerivAt_iff_isLittleO_nhds_zero, isLittleO_iff]
+  intro ε hε
+  have hBz : ∀ᶠ k in 𝓝 (0 : E),
+      ‖f (s₀, z₀ + k) - f (s₀, z₀) - Dz₀ k‖ ≤ (ε / 2) * ‖k‖ := by
+    have hz := hDz₀
+    rw [hasFDerivAt_iff_isLittleO_nhds_zero, isLittleO_iff] at hz
+    exact hz (half_pos hε)
+  have hBz' : ∀ᶠ p : ℝ × E in 𝓝 0,
+      ‖f (s₀, z₀ + p.2) - f (s₀, z₀) - Dz₀ p.2‖ ≤ (ε / 2) * ‖p.2‖ :=
+    (continuous_snd.tendsto (0 : ℝ × E)).eventually hBz
+  have hball : ∀ᶠ q in 𝓝 ((s₀, z₀) : ℝ × E), ‖Ds q - Ds₀‖ ≤ ε / 2 := by
+    have hc : Tendsto Ds (𝓝 (s₀, z₀)) (𝓝 Ds₀) := hDs_cont.continuousAt (hU.mem_nhds hmem)
+    have hsub : Tendsto (fun q => Ds q - Ds₀) (𝓝 (s₀, z₀)) (𝓝 (Ds₀ - Ds₀)) :=
+      hc.sub tendsto_const_nhds
+    rw [sub_self] at hsub
+    have h0 : Tendsto (fun q => ‖Ds q - Ds₀‖) (𝓝 (s₀, z₀)) (𝓝 0) := by
+      simpa using hsub.norm
+    exact h0.eventually (Iic_mem_nhds (half_pos hε))
+  obtain ⟨δ, hδpos, hδ⟩ := Metric.eventually_nhds_iff.mp hball
+  set ρr : ℝ := min δ (r / 2) with hρr
+  have hρrpos : 0 < ρr := lt_min hδpos (by positivity)
+  have hAs : ∀ᶠ p : ℝ × E in 𝓝 0,
+      ‖f (s₀ + p.1, z₀ + p.2) - f (s₀, z₀ + p.2) - p.1 • Ds₀‖ ≤ (ε / 2) * ‖p‖ := by
+    filter_upwards [Metric.ball_mem_nhds (0 : ℝ × E) hρrpos] with p hp
+    rw [mem_ball_zero_iff] at hp
+    have hdist : ∀ u ∈ Set.uIcc s₀ (s₀ + p.1),
+        dist ((u, z₀ + p.2) : ℝ × E) (s₀, z₀) ≤ ‖p‖ := by
+      intro u hu
+      have hple : |p.1| ≤ ‖p‖ := by rw [← Real.norm_eq_abs]; exact norm_fst_le p
+      have hp1 : |u - s₀| ≤ ‖p‖ := by
+        rcases Set.mem_uIcc.mp hu with ⟨ha, hb⟩ | ⟨ha, hb⟩
+        · rw [abs_of_nonneg (by linarith : (0 : ℝ) ≤ u - s₀)]
+          rw [abs_of_nonneg (by linarith : (0 : ℝ) ≤ p.1)] at hple; linarith
+        · rw [abs_of_nonpos (by linarith : u - s₀ ≤ 0)]
+          rw [abs_of_nonpos (by linarith : p.1 ≤ 0)] at hple; linarith
+      have hp2 : ‖p.2‖ ≤ ‖p‖ := norm_snd_le p
+      rw [Prod.dist_eq]
+      refine max_le ?_ ?_
+      · rw [dist_eq_norm]; simpa [Real.norm_eq_abs] using hp1
+      · rw [dist_eq_norm, add_sub_cancel_left]; exact hp2
+    have hmemU : ∀ u ∈ Set.uIcc s₀ (s₀ + p.1), ((u, z₀ + p.2) : ℝ × E) ∈ U := by
+      intro u hu
+      apply hrU
+      rw [Metric.mem_ball]
+      exact lt_of_le_of_lt (hdist u hu)
+        (lt_of_lt_of_le hp (le_trans (min_le_right _ _) (by linarith)))
+    have hcont_u : ContinuousOn (fun u => Ds (u, z₀ + p.2)) (Set.uIcc s₀ (s₀ + p.1)) := by
+      refine hDs_cont.comp (continuous_id.prodMk continuous_const).continuousOn ?_
+      exact fun u hu => hmemU u hu
+    have hg_deriv : ∀ u ∈ Set.uIcc s₀ (s₀ + p.1),
+        HasDerivAt (fun s => f (s, z₀ + p.2)) (Ds (u, z₀ + p.2)) u :=
+      fun u hu => hDs (u, z₀ + p.2) (hmemU u hu)
+    have hftc : ∫ u in s₀..(s₀ + p.1), Ds (u, z₀ + p.2)
+        = f (s₀ + p.1, z₀ + p.2) - f (s₀, z₀ + p.2) := by
+      rw [intervalIntegral.integral_eq_sub_of_hasDerivAt (fun u hu => hg_deriv u hu)
+        (hcont_u.intervalIntegrable)]
+    have hbound_u : ∀ u ∈ Set.uIoc s₀ (s₀ + p.1), ‖Ds (u, z₀ + p.2) - Ds₀‖ ≤ ε / 2 := by
+      intro u hu
+      refine @hδ (u, z₀ + p.2) ?_
+      have hmem' := hdist u (Set.uIoc_subset_uIcc hu)
+      exact lt_of_le_of_lt hmem' (lt_of_lt_of_le hp (min_le_left _ _))
+    have hA_eq : f (s₀ + p.1, z₀ + p.2) - f (s₀, z₀ + p.2) - p.1 • Ds₀
+        = ∫ u in s₀..(s₀ + p.1), (Ds (u, z₀ + p.2) - Ds₀) := by
+      rw [intervalIntegral.integral_sub (hcont_u.intervalIntegrable)
+          (intervalIntegrable_const), hftc, intervalIntegral.integral_const,
+          add_sub_cancel_left]
+    rw [hA_eq]
+    calc ‖∫ u in s₀..(s₀ + p.1), (Ds (u, z₀ + p.2) - Ds₀)‖
+        ≤ (ε / 2) * |(s₀ + p.1) - s₀| :=
+          intervalIntegral.norm_integral_le_of_norm_le_const hbound_u
+      _ = (ε / 2) * ‖p.1‖ := by rw [add_sub_cancel_left, Real.norm_eq_abs]
+      _ ≤ (ε / 2) * ‖p‖ := mul_le_mul_of_nonneg_left (norm_fst_le p) (by positivity)
+  filter_upwards [hAs, hBz'] with p hAp hBp
+  have hdecomp :
+      f ((s₀, z₀) + p) - f (s₀, z₀)
+        - ((ContinuousLinearMap.fst ℝ ℝ E).smulRight Ds₀
+            + Dz₀.comp (ContinuousLinearMap.snd ℝ ℝ E)) p
+      = (f (s₀ + p.1, z₀ + p.2) - f (s₀, z₀ + p.2) - p.1 • Ds₀)
+        + (f (s₀, z₀ + p.2) - f (s₀, z₀) - Dz₀ p.2) := by
+    rw [show ((s₀, z₀) + p : ℝ × E) = (s₀ + p.1, z₀ + p.2) from rfl]
+    simp only [add_apply, ContinuousLinearMap.smulRight_apply,
+      ContinuousLinearMap.coe_fst', ContinuousLinearMap.comp_apply,
+      ContinuousLinearMap.coe_snd']
+    abel
+  rw [hdecomp]
+  calc ‖(f (s₀ + p.1, z₀ + p.2) - f (s₀, z₀ + p.2) - p.1 • Ds₀)
+          + (f (s₀, z₀ + p.2) - f (s₀, z₀) - Dz₀ p.2)‖
+      ≤ ‖f (s₀ + p.1, z₀ + p.2) - f (s₀, z₀ + p.2) - p.1 • Ds₀‖
+        + ‖f (s₀, z₀ + p.2) - f (s₀, z₀) - Dz₀ p.2‖ := norm_add_le _ _
+    _ ≤ (ε / 2) * ‖p‖ + (ε / 2) * ‖p‖ :=
+        add_le_add hAp (le_trans hBp (mul_le_mul_of_nonneg_left (norm_snd_le p) (by positivity)))
+    _ = ε * ‖p‖ := by ring
+
+end Vlasov
diff --git a/LeanPool/Vlasov/Imports.lean b/LeanPool/Vlasov/Imports.lean
index 7395428db4..9e6bab3309 100644
--- a/LeanPool/Vlasov/Imports.lean
+++ b/LeanPool/Vlasov/Imports.lean
@@ -12,9 +12,16 @@ public import LeanPool.Vlasov.Base.Geometry
 public import LeanPool.Vlasov.Basic
 public import LeanPool.Vlasov.ForMathlib
 public import LeanPool.Vlasov.ForMathlib.PicardLindelof
+public import LeanPool.Vlasov.ForMathlib.VariationalEquation
 public import LeanPool.Vlasov.OT
+public import LeanPool.Vlasov.OT.CharacteristicConstruction
 public import LeanPool.Vlasov.OT.CharacteristicFlow
+public import LeanPool.Vlasov.OT.Continuation
 public import LeanPool.Vlasov.OT.Coupling
+public import LeanPool.Vlasov.OT.FlowDifferentiability
+public import LeanPool.Vlasov.OT.FrozenField
+public import LeanPool.Vlasov.OT.LocalWellPosedness
+public import LeanPool.Vlasov.OT.TestApproximation
 public import LeanPool.Vlasov.OT.Wasserstein
 public import LeanPool.Vlasov.OT.WeakToLagrangian
 public import LeanPool.Vlasov.OT.WellPosedness
diff --git a/LeanPool/Vlasov/OT.lean b/LeanPool/Vlasov/OT.lean
index 6bafa90ba2..86ba87f9ca 100644
--- a/LeanPool/Vlasov/OT.lean
+++ b/LeanPool/Vlasov/OT.lean
@@ -10,8 +10,6 @@ public import LeanPool.Vlasov.OT.Coupling
 public import LeanPool.Vlasov.OT.Wasserstein
 public import LeanPool.Vlasov.OT.WeakToLagrangian
 public import LeanPool.Vlasov.OT.WellPosedness
-import Mathlib.Analysis.SpecialFunctions.Trigonometric.Arctan
-import Mathlib.MeasureTheory.Covering.Besicovitch
 
 /-! # Optimal transport, characteristic flow, and the well-posedness ladder. -/
 
diff --git a/LeanPool/Vlasov/OT/CharacteristicConstruction.lean b/LeanPool/Vlasov/OT/CharacteristicConstruction.lean
new file mode 100644
index 0000000000..9fb52770ab
--- /dev/null
+++ b/LeanPool/Vlasov/OT/CharacteristicConstruction.lean
@@ -0,0 +1,2568 @@
+/-
+Copyright (c) 2026 Joseph K. Miller. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Joseph K. Miller
+-/
+module
+
+public import LeanPool.Vlasov.Basic
+public import LeanPool.Vlasov.OT.Coupling
+public import Mathlib.Analysis.ODE.Gronwall
+import LeanPool.Vlasov.ForMathlib.PicardLindelof
+import Mathlib.MeasureTheory.Integral.Prod
+
+/-!
+# Characteristic construction and growth bounds
+
+The phase-space vector field, Grönwall estimates, window predicates and characteristic
+construction compile before the pushforward and fixed-point arguments that use them.
+-/
+
+@[expose] public section
+
+namespace Vlasov
+
+open MeasureTheory ENNReal
+
+/-! ## Vlasov velocity field and its Lipschitz lemma -/
+
+/-- The Vlasov phase-space vector field:
+`b_t(x, v) := (v, −(∇W ∗ ρ_t)(x))`.
+
+Note that the first component is the identity in `v` (the position
+ODE `x' = v`) and the second component is the mean-field force
+`−∇W ∗ ρ_t` evaluated at `x` (the velocity ODE `v' = −(∇W ∗ ρ)(x)`).
+-/
+noncomputable def vlasovVectorField
+    {d : ℕ}
+    (gradW : PhysSpace d → PhysSpace d)
+    (ρ : ℝ → Measure (PhysSpace d))
+    (t : ℝ) (z : PhaseSpace d) : PhaseSpace d :=
+  (z.2, -(convolveFunctionMeasure gradW (ρ t) z.1))
+
+/-- Position-side Lipschitz of the convolution `∇W ∗ ρ`.
+For `gradW` L-Lipschitz and `ρ` a probability measure with finite
+first moment (which guarantees integrability of the kernel), the map
+`x ↦ (∇W ∗ ρ)(x)` is L-Lipschitz.
+
+Proof sketch: by `LipschitzWith.dist_le_mul` applied pointwise to
+`gradW`, then integration over the probability measure `ρ`:
+  ‖∫ y, gradW(x−y) ∂ρ − ∫ y, gradW(x'−y) ∂ρ‖
+    = ‖∫ y, (gradW(x−y) − gradW(x'−y)) ∂ρ‖
+    ≤ ∫ y, ‖gradW(x−y) − gradW(x'−y)‖ ∂ρ
+    ≤ ∫ y, L · ‖x − x'‖ ∂ρ
+    = L · ‖x − x'‖ · ρ(univ)
+    = L · ‖x − x'‖   (probability measure).
+
+The integrability hypotheses on `gradW(x − ·)` for two distinct `x`s
+are needed for `integral_sub` and `norm_integral_le_integral_norm`
+to fire.  At the dobrushin call site these follow from finite first
+moment of `ρ` + Lipschitz growth of `gradW`. -/
+lemma convolveFunctionMeasure_lipschitz_in_x
+    {d : ℕ}
+    (gradW : PhysSpace d → PhysSpace d)
+    (L : NNReal) (hL : LipschitzWith L gradW)
+    (ρ : Measure (PhysSpace d)) [IsProbabilityMeasure ρ]
+    (h_int : ∀ x : PhysSpace d, Integrable (fun y => gradW (x - y)) ρ) :
+    LipschitzWith L (fun x => convolveFunctionMeasure gradW ρ x) := by
+  refine LipschitzWith.of_dist_le_mul (fun x x' => ?_)
+  unfold convolveFunctionMeasure
+  rw [dist_eq_norm, ← integral_sub (h_int x) (h_int x')]
+  -- Pointwise bound: ‖gradW(x − y) − gradW(x' − y)‖ ≤ L · ‖x − x'‖
+  have h_pt : ∀ y, ‖gradW (x - y) - gradW (x' - y)‖ ≤ (L : ℝ) * ‖x - x'‖ :=
+    fun y => by
+    have h_sub : (x - y) - (x' - y) = x - x' := by
+      rw [sub_sub_sub_cancel_right]
+    have := hL.dist_le_mul (x - y) (x' - y)
+    rw [dist_eq_norm, dist_eq_norm, h_sub] at this
+    exact this
+  -- Integrability of the pointwise bound function (a constant).
+  have h_bound_int : Integrable (fun _ : PhysSpace d => (L : ℝ) * ‖x - x'‖) ρ :=
+    integrable_const _
+  -- Integrability of the norm of the difference, via mono'.
+  have h_norm_int : Integrable (fun y => ‖gradW (x - y) - gradW (x' - y)‖) ρ :=
+    Integrable.mono' h_bound_int ((h_int x).sub (h_int x')).norm.aestronglyMeasurable
+      (Filter.Eventually.of_forall fun y => by
+        rw [Real.norm_eq_abs, abs_of_nonneg (norm_nonneg _)]
+        exact h_pt y)
+  calc ‖∫ y, gradW (x - y) - gradW (x' - y) ∂ρ‖
+      ≤ ∫ y, ‖gradW (x - y) - gradW (x' - y)‖ ∂ρ :=
+        norm_integral_le_integral_norm _
+    _ ≤ ∫ _, (L : ℝ) * ‖x - x'‖ ∂ρ :=
+        integral_mono_ae h_norm_int h_bound_int (Filter.Eventually.of_forall h_pt)
+    _ = (L : ℝ) * ‖x - x'‖ := by
+        simp [integral_const, measureReal_def, measure_univ]
+
+/-- A Lipschitz force has an affine convolution bound controlled by the first moment. -/
+lemma norm_convolveFunctionMeasure_le_affine
+    {d : ℕ} (gradW : PhysSpace d → PhysSpace d) (L : NNReal) (hL : LipschitzWith L gradW)
+    (ρ : Measure (PhysSpace d)) [IsProbabilityMeasure ρ]
+    (h_int : ∀ x, Integrable (fun y => gradW (x - y)) ρ)
+    (h_y_int : Integrable (fun y : PhysSpace d => ‖y‖) ρ)
+    (M : ℝ) (hM : ∫ y, ‖y‖ ∂ρ ≤ M) (x : PhysSpace d) :
+    ‖convolveFunctionMeasure gradW ρ x‖ ≤ ‖gradW 0‖ + (L : ℝ) * M + (L : ℝ) * ‖x‖ := by
+  have h_point : ∀ y, ‖gradW (x - y)‖ ≤ ‖gradW 0‖ + (L : ℝ) * (‖x‖ + ‖y‖) := by
+    intro y
+    have h_lipschitz := hL.dist_le_mul (x - y) 0
+    simp only [dist_eq_norm, sub_zero] at h_lipschitz
+    exact (norm_le_norm_add_norm_sub' (gradW (x - y)) (gradW 0)).trans
+      (add_le_add le_rfl (h_lipschitz.trans
+        (mul_le_mul_of_nonneg_left (norm_sub_le x y) L.coe_nonneg)))
+  have h_sum_int : Integrable (fun y : PhysSpace d => ‖x‖ + ‖y‖) ρ :=
+    (integrable_const ‖x‖).add h_y_int
+  have h_bound_int : Integrable (fun y => ‖gradW 0‖ + (L : ℝ) * (‖x‖ + ‖y‖)) ρ :=
+    (integrable_const ‖gradW 0‖).add (h_sum_int.const_mul (L : ℝ))
+  calc
+    ‖convolveFunctionMeasure gradW ρ x‖ ≤ ∫ y, ‖gradW (x - y)‖ ∂ρ :=
+      norm_integral_le_integral_norm _
+    _ ≤ ∫ y, (‖gradW 0‖ + (L : ℝ) * (‖x‖ + ‖y‖)) ∂ρ :=
+      integral_mono (h_int x).norm h_bound_int h_point
+    _ = ‖gradW 0‖ + (L : ℝ) * (‖x‖ + ∫ y, ‖y‖ ∂ρ) := by
+      rw [integral_add (integrable_const _) (h_sum_int.const_mul (L : ℝ)),
+        integral_const_mul, integral_add (integrable_const _) h_y_int]
+      simp only [integral_const, measureReal_def, measure_univ, ENNReal.toReal_one, one_smul]
+    _ ≤ ‖gradW 0‖ + (L : ℝ) * (‖x‖ + M) :=
+      add_le_add le_rfl (mul_le_mul_of_nonneg_left (add_le_add le_rfl hM) L.coe_nonneg)
+    _ = ‖gradW 0‖ + (L : ℝ) * M + (L : ℝ) * ‖x‖ := by ring
+
+/-! ## Flow distance growth bound (Gronwall on the characteristic ODE)
+
+A standalone regularity theorem about `IsCharacteristicFlow`: solutions of
+the characteristic ODE have at most linear growth in their initial condition,
+with a constant depending on `T`, the Lipschitz constant of `gradW`, and a
+uniform first-moment bound on the measure curve `ρ`.
+
+Math content: Gronwall on the position-velocity pair, using
+  `‖(∇W ∗ ρ_t)(x)‖ ≤ ‖gradW 0‖ + L · (‖x‖ + ∫‖y‖dρ_t)`
+as the velocity-field bound. -/
+
+/-- **`IsCharacteristicFlowOn`-flavored variant of `flow_distance_growth_bound`**.
+
+Same Gronwall growth bound, but for a flow specified by **boundary regularity
+hypotheses** (`h_init`, `h_cont_Icc`, `h_deriv_Ico`) instead of the universal-in-`t`
+ODE of `IsCharacteristicFlow`.  This matches what
+`exists_vlasov_characteristicFlow_global_smallT` produces (modulo deriving the
+boundary regularity from `IsCharacteristicFlowOn`'s `Ioo 0 T` ODE clauses), and
+mirrors the hypothesis-passing pattern of `charFlow_measurable_via_gronwall`.
+
+**Used by**: `Phi_step` to derive the per-`z` growth bound
+(`PhiAsVlasovMeasureCurve`'s `h_growth` hypothesis); window uniqueness is a
+natural secondary consumer.
+
+The global `flow_distance_growth_bound` follows by supplying its initial
+condition, continuity and derivative statements as boundary regularity.
+
+**Metric-dependence note**:
+This bound uses the unbounded position difference `‖X^M(t,z) - X^{M'}(t,z)‖`,
+which forces Gronwall and produces exponential-in-`T` constants
+`C_T ≈ exp((1+L)·T)`.  The `Wbar = W_{min(|x-y|,1)}` analog (Dobrushin 1979, §5)
+uses the bounded-and-Lipschitz absorption
+  `|B_μ(x) - B_{μ'}(x)| ≤ max(2‖B‖_∞, C_B) · min(|x₁-x₂|, 1)`
+and produces *linear-in-`T`* constants (Dobrushin 1979, eq. 5.7), changing this
+output shape from `C_T · (‖z‖ + 1)` to a bounded analog. -/
+theorem flow_distance_growth_bound_on
+    {d : ℕ}
+    (gradW : PhysSpace d → PhysSpace d)
+    (L : NNReal) (hL : LipschitzWith L gradW)
+    (ρ : ℝ → Measure (PhysSpace d))
+    [∀ t, IsProbabilityMeasure (ρ t)]
+    (charX charV : ℝ → PhaseSpace d → PhysSpace d)
+    (T : ℝ) (hT : 0 ≤ T)
+    -- Boundary regularity, replacing IsCharacteristicFlow's universal ODE.
+    (h_init : ∀ z : PhaseSpace d, (charX 0 z, charV 0 z) = z)
+    (h_cont_Icc : ∀ z : PhaseSpace d,
+        ContinuousOn (fun s => (charX s z, charV s z)) (Set.Icc (0 : ℝ) T))
+    (h_deriv_Ico : ∀ z : PhaseSpace d, ∀ s ∈ Set.Ico (0 : ℝ) T,
+        HasDerivWithinAt (fun s' => (charX s' z, charV s' z))
+          (vlasovVectorField gradW ρ s (charX s z, charV s z))
+          (Set.Ici s) s)
+    -- ρ regularity, identical to flow_distance_growth_bound's hypotheses.
+    (M_ρ : ℝ) (hM_ρ_nn : 0 ≤ M_ρ)
+    (hM_ρ : ∀ t ∈ Set.Icc 0 T, ∫ y, ‖y‖ ∂(ρ t) ≤ M_ρ)
+    (h_y_int : ∀ t ∈ Set.Icc 0 T, Integrable (fun y : PhysSpace d => ‖y‖) (ρ t))
+    (h_int : ∀ t (x : PhysSpace d), Integrable (fun y => gradW (x - y)) (ρ t)) :
+    ∃ C_T, 0 ≤ C_T ∧
+      ∀ t ∈ Set.Icc 0 T, ∀ z : PhaseSpace d,
+        ‖(charX t z, charV t z)‖ ≤ C_T * (‖z‖ + 1) := by
+  -- Gronwall parameters: K = 1 + L, ε₀ = ‖gradW 0‖ + L * M_ρ.
+  set K := 1 + (L : ℝ) with hK_def
+  set ε₀ := ‖gradW 0‖ + (L : ℝ) * M_ρ with hε₀_def
+  have hK_pos : 0 < K := by positivity
+  have hε₀_nn : 0 ≤ ε₀ := by positivity
+  -- Witness: C_T = gronwallBound 1 K ε₀ T.
+  use gronwallBound 1 K ε₀ T
+  refine ⟨?_, ?_⟩
+  · have hmono := gronwallBound_mono (by norm_num : (0 : ℝ) ≤ 1) hε₀_nn hK_pos.le hT
+    linarith [gronwallBound_x0 1 K ε₀]
+  · intro t ht z
+    -- Convolution bound: ‖(∇W ∗ ρ_t)(x)‖ ≤ ε₀ + L * ‖x‖.
+    have h_conv_bound : ∀ s ∈ Set.Icc 0 T, ∀ x : PhysSpace d,
+        ‖convolveFunctionMeasure gradW (ρ s) x‖ ≤ ε₀ + (L : ℝ) * ‖x‖ := by
+      intro s hs x
+      exact norm_convolveFunctionMeasure_le_affine gradW L hL (ρ s) (h_int s)
+        (h_y_int s hs) M_ρ (hM_ρ s hs) x
+    -- Gronwall step.  Boundary regularity comes from hypotheses, not from
+    -- IsCharacteristicFlow.
+    have h_f_cont : ContinuousOn (fun s => (charX s z, charV s z)) (Set.Icc 0 T) :=
+      h_cont_Icc z
+    have h_deriv : ∀ s ∈ Set.Ico 0 T,
+        HasDerivWithinAt (fun s => (charX s z, charV s z))
+          (charV s z, -convolveFunctionMeasure gradW (ρ s) (charX s z))
+          (Set.Ici s) s := by
+      intro s hs
+      have hderiv := h_deriv_Ico z s hs
+      -- vlasovVectorField gradW ρ s (charX s z, charV s z) = (charV s z, -conv ...)
+      unfold vlasovVectorField at hderiv
+      exact hderiv
+    have h_init_norm : ‖(charX 0 z, charV 0 z)‖ ≤ ‖z‖ := by
+      rw [h_init z]
+    have h_bound : ∀ s ∈ Set.Ico 0 T,
+        ‖(charV s z, -convolveFunctionMeasure gradW (ρ s) (charX s z))‖ ≤
+          K * ‖(charX s z, charV s z)‖ + ε₀ := by
+      intro s hs
+      have hs_mem : s ∈ Set.Icc 0 T := ⟨hs.1, le_of_lt hs.2⟩
+      simp only [Prod.norm_def, norm_neg]
+      have hFsz := le_max_left ‖charX s z‖ ‖charV s z‖
+      have hGsz := le_max_right ‖charX s z‖ ‖charV s z‖
+      have hM_nn : 0 ≤ max ‖charX s z‖ ‖charV s z‖ :=
+        le_max_iff.mpr (Or.inl (norm_nonneg _))
+      have h_v_le : ‖charV s z‖ ≤ K * max ‖charX s z‖ ‖charV s z‖ + ε₀ :=
+        calc ‖charV s z‖ ≤ max ‖charX s z‖ ‖charV s z‖ := hGsz
+          _ ≤ K * max ‖charX s z‖ ‖charV s z‖ :=
+              le_mul_of_one_le_left hM_nn (by linarith [NNReal.coe_nonneg L])
+          _ ≤ K * max ‖charX s z‖ ‖charV s z‖ + ε₀ := le_add_of_nonneg_right hε₀_nn
+      have h_conv_le : ‖convolveFunctionMeasure gradW (ρ s) (charX s z)‖ ≤
+          K * max ‖charX s z‖ ‖charV s z‖ + ε₀ :=
+        calc ‖convolveFunctionMeasure gradW (ρ s) (charX s z)‖
+            ≤ ε₀ + (L : ℝ) * ‖charX s z‖ := h_conv_bound s hs_mem _
+          _ ≤ ε₀ + K * max ‖charX s z‖ ‖charV s z‖ := by
+              have hLK : (L : ℝ) ≤ K := le_add_of_nonneg_left zero_le_one
+              linarith [mul_le_mul_of_nonneg_left hFsz (NNReal.coe_nonneg L),
+                        mul_le_mul_of_nonneg_right hLK hM_nn]
+          _ = K * max ‖charX s z‖ ‖charV s z‖ + ε₀ := by ring
+      exact max_le h_v_le h_conv_le
+    have h_grw := norm_le_gronwallBound_of_norm_deriv_right_le
+      h_f_cont h_deriv h_init_norm h_bound t ht
+    simp only [sub_zero] at h_grw
+    calc ‖(charX t z, charV t z)‖
+        ≤ gronwallBound ‖z‖ K ε₀ t := h_grw
+      _ ≤ gronwallBound ‖z‖ K ε₀ T :=
+          gronwallBound_mono (norm_nonneg _) hε₀_nn hK_pos.le ht.2
+      _ ≤ gronwallBound 1 K ε₀ T * (‖z‖ + 1) := by
+          rw [gronwallBound_of_K_ne_0 hK_pos.ne', gronwallBound_of_K_ne_0 hK_pos.ne']
+          simp only [one_mul]
+          have he1 : 0 ≤ Real.exp (K * T) - 1 :=
+            by linarith [Real.one_le_exp (mul_nonneg hK_pos.le hT)]
+          have hεK := div_nonneg hε₀_nn hK_pos.le
+          nlinarith [norm_nonneg z, Real.exp_nonneg (K * T),
+            mul_nonneg hεK he1, mul_nonneg (norm_nonneg z) (mul_nonneg hεK he1)]
+
+/-- **Flow distance growth bound** (`L`-Lipschitz `gradW`, uniform first moment
+on `ρ`).  Solutions of the characteristic ODE grow at most linearly in their
+initial condition: `‖(charX t z, charV t z)‖ ≤ C_T · (‖z‖ + 1)` for some
+`C_T` depending only on `T`, `L`, `‖gradW 0‖`, and the uniform first-moment
+bound `M_ρ`. -/
+theorem flow_distance_growth_bound
+    {d : ℕ}
+    (gradW : PhysSpace d → PhysSpace d)
+    (L : NNReal) (hL : LipschitzWith L gradW)
+    (ρ : ℝ → Measure (PhysSpace d))
+    [∀ t, IsProbabilityMeasure (ρ t)]
+    (charX charV : ℝ → PhaseSpace d → PhysSpace d)
+    (hflow : IsCharacteristicFlow gradW ρ charX charV)
+    (T : ℝ) (hT : 0 ≤ T)
+    (M_ρ : ℝ) (hM_ρ_nn : 0 ≤ M_ρ)
+    (hM_ρ : ∀ t ∈ Set.Icc 0 T, ∫ y, ‖y‖ ∂(ρ t) ≤ M_ρ)
+    (h_y_int : ∀ t ∈ Set.Icc 0 T, Integrable (fun y : PhysSpace d => ‖y‖) (ρ t))
+    (h_int : ∀ t (x : PhysSpace d), Integrable (fun y => gradW (x - y)) (ρ t)) :
+    ∃ C_T, 0 ≤ C_T ∧
+      ∀ t ∈ Set.Icc 0 T, ∀ z : PhaseSpace d,
+        ‖(charX t z, charV t z)‖ ≤ C_T * (‖z‖ + 1) := by
+  obtain ⟨hflow_init, hflow_x, hflow_v⟩ := hflow
+  refine flow_distance_growth_bound_on gradW L hL ρ charX charV T hT
+    (fun z => Prod.ext (hflow_init z).1 (hflow_init z).2) ?_ ?_
+    M_ρ hM_ρ_nn hM_ρ h_y_int h_int
+  · intro z
+    exact continuousOn_of_forall_continuousAt fun s _ =>
+      (hflow_x s z).continuousAt.prodMk (hflow_v s z).continuousAt
+  · intro z s _
+    exact ((hflow_x s z).prodMk (hflow_v s z)).hasDerivWithinAt
+
+/-- **Two-flow difference Gronwall bound** — the reusable core of the
+integrated Dobrushin coupling bound.  The distance between two trajectories
+`Φ_f · z₁`, `Φ_g · z₂` of flows generated by fields `b_f, b_g` (`b_f`
+`L`-Lipschitz in space) grows by Gronwall: if the field difference *at the
+second trajectory* is bounded by `ε` on `[0, T]` and the initial separation by
+`δ`, then `‖Φ_f t z₁ - Φ_g t z₂‖ ≤ gronwallBound δ L ε t`.
+
+Mirrors `flow_distance_growth_bound`'s Gronwall structure
+(`norm_le_gronwallBound_of_norm_deriv_right_le`) but for the *difference* of two
+flows.  In the integrated-bound application, `z₁ = ω.1`, `z₂ = ω.2` range over a
+coupling `π₀` of `(f 0, g 0)`, `ε = (L : ℝ) * (wasserstein1 (f s) (g s)).toReal`
+(the self-coupling diff-bound, uniform in the trajectory), and integrating this
+pointwise bound over `π₀` against the pushforward bound gives the Dobrushin
+estimate `W₁(f t, g t) ≤ … · W₁(f 0, g 0)`. -/
+theorem flow_difference_growth_bound
+    {α : Type*} [NormedAddCommGroup α] [NormedSpace ℝ α]
+    (b_f b_g : ℝ → α → α) (L : NNReal) (hL_f : ∀ t, LipschitzWith L (b_f t))
+    (Φ_f Φ_g : ℝ → α → α) (z₁ z₂ : α)
+    (T : ℝ)
+    (hcont_f : ContinuousOn (fun s => Φ_f s z₁) (Set.Icc 0 T))
+    (hcont_g : ContinuousOn (fun s => Φ_g s z₂) (Set.Icc 0 T))
+    (hΦ_f : ∀ s ∈ Set.Ico 0 T,
+      HasDerivWithinAt (fun u => Φ_f u z₁) (b_f s (Φ_f s z₁)) (Set.Ici s) s)
+    (hΦ_g : ∀ s ∈ Set.Ico 0 T,
+      HasDerivWithinAt (fun u => Φ_g u z₂) (b_g s (Φ_g s z₂)) (Set.Ici s) s)
+    (δ ε : ℝ) (h_init : ‖Φ_f 0 z₁ - Φ_g 0 z₂‖ ≤ δ)
+    (h_diff : ∀ s ∈ Set.Icc 0 T,
+      ‖b_f s (Φ_g s z₂) - b_g s (Φ_g s z₂)‖ ≤ ε) :
+    ∀ t ∈ Set.Icc 0 T,
+      ‖Φ_f t z₁ - Φ_g t z₂‖ ≤ gronwallBound δ (L : ℝ) ε t := by
+  have hcont : ContinuousOn (fun s => Φ_f s z₁ - Φ_g s z₂) (Set.Icc 0 T) :=
+    hcont_f.sub hcont_g
+  have hderiv : ∀ s ∈ Set.Ico 0 T,
+      HasDerivWithinAt (fun u => Φ_f u z₁ - Φ_g u z₂)
+        (b_f s (Φ_f s z₁) - b_g s (Φ_g s z₂)) (Set.Ici s) s :=
+    fun s hs => (hΦ_f s hs).sub (hΦ_g s hs)
+  have hbound : ∀ s ∈ Set.Ico 0 T,
+      ‖b_f s (Φ_f s z₁) - b_g s (Φ_g s z₂)‖ ≤
+        (L : ℝ) * ‖Φ_f s z₁ - Φ_g s z₂‖ + ε := by
+    intro s hs
+    have hs_icc : s ∈ Set.Icc 0 T := ⟨hs.1, hs.2.le⟩
+    have h_lip : ‖b_f s (Φ_f s z₁) - b_f s (Φ_g s z₂)‖ ≤
+        (L : ℝ) * ‖Φ_f s z₁ - Φ_g s z₂‖ := by
+      have := (hL_f s).dist_le_mul (Φ_f s z₁) (Φ_g s z₂)
+      rwa [dist_eq_norm, dist_eq_norm] at this
+    calc ‖b_f s (Φ_f s z₁) - b_g s (Φ_g s z₂)‖
+        = ‖(b_f s (Φ_f s z₁) - b_f s (Φ_g s z₂)) +
+            (b_f s (Φ_g s z₂) - b_g s (Φ_g s z₂))‖ := by congr 1; abel
+      _ ≤ ‖b_f s (Φ_f s z₁) - b_f s (Φ_g s z₂)‖ +
+            ‖b_f s (Φ_g s z₂) - b_g s (Φ_g s z₂)‖ := norm_add_le _ _
+      _ ≤ (L : ℝ) * ‖Φ_f s z₁ - Φ_g s z₂‖ + ε :=
+            add_le_add h_lip (h_diff s hs_icc)
+  intro t ht
+  have hg := norm_le_gronwallBound_of_norm_deriv_right_le hcont hderiv h_init hbound t ht
+  simpa using hg
+
+/-- **Per-trajectory mild (integral-form) difference bound.**
+Mild-form companion to `flow_difference_growth_bound`:
+the raw integral inequality
+`‖γ_f t − γ_g t‖ ≤ ‖γ_f 0 − γ_g 0‖ + ∫₀ᵗ (L‖γ_f s − γ_g s‖ + ε s) ds`,
+keeping the forcing `ε s` *inside* the integral.  After integrating this over
+the base measure, the self-reference `ε s = L·W₁(f s,g s) ≤ L·Q(s)` is resolved
+by `gronwall_mild_le` — avoiding the constant-`ε` smallness that
+`flow_difference_growth_bound`'s closed form would force (and the blocked
+windowing that smallness needs). -/
+theorem flow_difference_mild_bound
+    {α : Type*} [NormedAddCommGroup α] [NormedSpace ℝ α] [CompleteSpace α]
+    (b_f b_g : ℝ → α → α) (L : NNReal) (hL_f : ∀ t, LipschitzWith L (b_f t))
+    (γ_f γ_g : ℝ → α) (T : ℝ)
+    (hcont_f : ContinuousOn γ_f (Set.Icc 0 T))
+    (hcont_g : ContinuousOn γ_g (Set.Icc 0 T))
+    (hderiv_f : ∀ s ∈ Set.Ioo (0 : ℝ) T,
+      HasDerivWithinAt γ_f (b_f s (γ_f s)) (Set.Ioi s) s)
+    (hderiv_g : ∀ s ∈ Set.Ioo (0 : ℝ) T,
+      HasDerivWithinAt γ_g (b_g s (γ_g s)) (Set.Ioi s) s)
+    (hint : IntervalIntegrable (fun s => b_f s (γ_f s) - b_g s (γ_g s))
+      MeasureTheory.volume 0 T)
+    (ε : ℝ → ℝ) (hε_int : IntervalIntegrable ε MeasureTheory.volume 0 T)
+    (h_diff : ∀ s ∈ Set.Icc (0 : ℝ) T, ‖b_f s (γ_g s) - b_g s (γ_g s)‖ ≤ ε s) :
+    ∀ t ∈ Set.Icc (0 : ℝ) T,
+      ‖γ_f t - γ_g t‖ ≤ ‖γ_f 0 - γ_g 0‖ +
+        ∫ s in (0 : ℝ)..t, ((L : ℝ) * ‖γ_f s - γ_g s‖ + ε s) := by
+  intro t ht
+  have h0t : (0 : ℝ) ≤ t := ht.1
+  have htT : t ≤ T := ht.2
+  have hIcc_sub : Set.Icc (0 : ℝ) t ⊆ Set.Icc 0 T := Set.Icc_subset_Icc_right htT
+  have hcont_diff : ContinuousOn (fun s => γ_f s - γ_g s) (Set.Icc 0 t) :=
+    (hcont_f.mono hIcc_sub).sub (hcont_g.mono hIcc_sub)
+  have hderiv_diff : ∀ s ∈ Set.Ioo (0 : ℝ) t,
+      HasDerivWithinAt (fun s => γ_f s - γ_g s)
+        (b_f s (γ_f s) - b_g s (γ_g s)) (Set.Ioi s) s := by
+    intro s hs
+    have hs' : s ∈ Set.Ioo (0 : ℝ) T := ⟨hs.1, hs.2.trans_le htT⟩
+    exact (hderiv_f s hs').sub (hderiv_g s hs')
+  have hint_t : IntervalIntegrable (fun s => b_f s (γ_f s) - b_g s (γ_g s))
+      MeasureTheory.volume 0 t :=
+    hint.mono_set (by
+      rw [Set.uIcc_of_le h0t, Set.uIcc_of_le (h0t.trans htT)]; exact hIcc_sub)
+  have hftc := intervalIntegral.integral_eq_sub_of_hasDeriv_right_of_le h0t hcont_diff
+    hderiv_diff hint_t
+  have hsplit : ∀ s ∈ Set.Icc (0 : ℝ) t,
+      ‖b_f s (γ_f s) - b_g s (γ_g s)‖ ≤ (L:ℝ) * ‖γ_f s - γ_g s‖ + ε s := by
+    intro s hs
+    have hsT : s ∈ Set.Icc (0 : ℝ) T := hIcc_sub hs
+    have h_lip : ‖b_f s (γ_f s) - b_f s (γ_g s)‖ ≤ (L:ℝ) * ‖γ_f s - γ_g s‖ := by
+      have := (hL_f s).dist_le_mul (γ_f s) (γ_g s)
+      rwa [dist_eq_norm, dist_eq_norm] at this
+    calc ‖b_f s (γ_f s) - b_g s (γ_g s)‖
+        = ‖(b_f s (γ_f s) - b_f s (γ_g s)) + (b_f s (γ_g s) - b_g s (γ_g s))‖ := by
+          congr 1; abel
+      _ ≤ ‖b_f s (γ_f s) - b_f s (γ_g s)‖ + ‖b_f s (γ_g s) - b_g s (γ_g s)‖ :=
+          norm_add_le _ _
+      _ ≤ (L:ℝ) * ‖γ_f s - γ_g s‖ + ε s := add_le_add h_lip (h_diff s hsT)
+  have hci : IntervalIntegrable (fun s => (L:ℝ) * ‖γ_f s - γ_g s‖ + ε s)
+      MeasureTheory.volume 0 t := by
+    refine IntervalIntegrable.add (IntervalIntegrable.const_mul ?_ (L:ℝ))
+      (hε_int.mono_set (by
+        rw [Set.uIcc_of_le h0t, Set.uIcc_of_le (h0t.trans htT)]; exact hIcc_sub))
+    refine ContinuousOn.intervalIntegrable ?_
+    rw [Set.uIcc_of_le h0t]; exact hcont_diff.norm
+  have hnorm_le : ‖∫ s in (0 : ℝ)..t, (b_f s (γ_f s) - b_g s (γ_g s))‖ ≤
+      ∫ s in (0 : ℝ)..t, ((L:ℝ) * ‖γ_f s - γ_g s‖ + ε s) := by
+    calc ‖∫ s in (0 : ℝ)..t, (b_f s (γ_f s) - b_g s (γ_g s))‖
+        ≤ ∫ s in (0 : ℝ)..t, ‖b_f s (γ_f s) - b_g s (γ_g s)‖ :=
+          intervalIntegral.norm_integral_le_integral_norm h0t
+      _ ≤ ∫ s in (0 : ℝ)..t, ((L:ℝ) * ‖γ_f s - γ_g s‖ + ε s) :=
+          intervalIntegral.integral_mono_on h0t hint_t.norm hci hsplit
+  have ha_le : ‖γ_f t - γ_g t‖ ≤ ‖γ_f 0 - γ_g 0‖ +
+      ‖∫ s in (0 : ℝ)..t, (b_f s (γ_f s) - b_g s (γ_g s))‖ := by
+    have heq : (γ_f t - γ_g t) - (γ_f 0 - γ_g 0) =
+        ∫ s in (0 : ℝ)..t, (b_f s (γ_f s) - b_g s (γ_g s)) := hftc.symm
+    calc ‖γ_f t - γ_g t‖
+        = ‖(γ_f 0 - γ_g 0) + ((γ_f t - γ_g t) - (γ_f 0 - γ_g 0))‖ := by congr 1; abel
+      _ ≤ ‖γ_f 0 - γ_g 0‖ + ‖(γ_f t - γ_g t) - (γ_f 0 - γ_g 0)‖ := norm_add_le _ _
+      _ = ‖γ_f 0 - γ_g 0‖ + ‖∫ s in (0 : ℝ)..t, (b_f s (γ_f s) - b_g s (γ_g s))‖ := by
+          rw [heq]
+  linarith [ha_le, hnorm_le]
+
+/-- **Integrate a per-trajectory mild bound over the base measure (Tonelli step).**
+Given a base probability measure `π` on `Ω` and a family `w : ℝ → Ω → α`, if each
+trajectory satisfies the mild bound `‖w t ω‖ ≤ ‖w 0 ω‖ + ∫₀ᵗ (L‖w s ω‖ + ε s) ds`,
+then the integrated quantity `Q t := ∫ ‖w t ω‖ ∂π` satisfies
+`Q t ≤ Q 0 + ∫₀ᵗ (L · Q s + ε s) ds`. The `∫₀ᵗ L‖w s ω‖` term swaps via Tonelli. -/
+theorem integral_mild_bound
+    {Ω α : Type*} [MeasurableSpace Ω] [NormedAddCommGroup α]
+    [MeasurableSpace α] [BorelSpace α]
+    (π : Measure Ω) [IsProbabilityMeasure π]
+    (w : ℝ → Ω → α) (L : ℝ) (hL : 0 ≤ L) (ε : ℝ → ℝ) (T : ℝ) (hT : 0 ≤ T)
+    -- joint-measurability inputs (Carathéodory: continuous-in-time + measurable-in-ω)
+    (hw_cont : ∀ ω, Continuous (fun s => w s ω))
+    (hw_meas : ∀ s, Measurable (w s))
+    -- domination: ‖w s ω‖ ≤ dom ω uniformly on [0,T], dom integrable
+    (dom : Ω → ℝ) (hdom_int : Integrable dom π)
+    (hdom : ∀ s ∈ Set.Icc (0 : ℝ) T, ∀ ω, ‖w s ω‖ ≤ dom ω)
+    (hε_int : IntervalIntegrable ε MeasureTheory.volume 0 T)
+    (hε_nn : ∀ s ∈ Set.Icc (0 : ℝ) T, 0 ≤ ε s)
+    -- the per-trajectory mild bound (e.g. from flow_difference_mild_bound)
+    (hper : ∀ ω, ∀ t ∈ Set.Icc (0 : ℝ) T,
+      ‖w t ω‖ ≤ ‖w 0 ω‖ + ∫ s in (0 : ℝ)..t, (L * ‖w s ω‖ + ε s)) :
+    ∀ t ∈ Set.Icc (0 : ℝ) T,
+      (∫ ω, ‖w t ω‖ ∂π) ≤ (∫ ω, ‖w 0 ω‖ ∂π) +
+        ∫ s in (0 : ℝ)..t, (L * (∫ ω, ‖w s ω‖ ∂π) + ε s) := by
+  -- joint measurability of `(s, ω) ↦ w s ω` and of its norm
+  have hjoint : Measurable (Function.uncurry w) :=
+    measurable_uncurry_of_continuous_of_measurable hw_cont hw_meas
+  have hjoint_norm : Measurable (fun p : ℝ × Ω => ‖w p.1 p.2‖) := hjoint.norm
+  -- abbreviation Q s := ∫ ω, ‖w s ω‖ ∂π
+  set Q : ℝ → ℝ := fun s => ∫ ω, ‖w s ω‖ ∂π with hQ
+  intro t ht
+  have h0t : (0 : ℝ) ≤ t := ht.1
+  have htT : t ≤ T := ht.2
+  have hIcc_sub : Set.Icc (0 : ℝ) t ⊆ Set.Icc 0 T := Set.Icc_subset_Icc_right htT
+  -- `w 0 ·` and `w t ·` are integrable over π (dominated by `dom`)
+  have h0_mem : (0 : ℝ) ∈ Set.Icc (0 : ℝ) T := ⟨le_refl 0, hT⟩
+  have ht_mem : t ∈ Set.Icc (0 : ℝ) T := ht
+  have hint0 : Integrable (fun ω => ‖w 0 ω‖) π := by
+    refine hdom_int.mono' ((hw_meas 0).norm.aestronglyMeasurable) ?_
+    filter_upwards with ω
+    rw [Real.norm_of_nonneg (norm_nonneg _)]
+    exact hdom 0 h0_mem ω
+  have hintt : Integrable (fun ω => ‖w t ω‖) π := by
+    refine hdom_int.mono' ((hw_meas t).norm.aestronglyMeasurable) ?_
+    filter_upwards with ω
+    rw [Real.norm_of_nonneg (norm_nonneg _)]
+    exact hdom t ht_mem ω
+  -- the inner integrand `g s ω := L * ‖w s ω‖ + ε s`
+  set g : ℝ → Ω → ℝ := fun s ω => L * ‖w s ω‖ + ε s with hg
+  -- product measure for the Tonelli swap
+  -- `volume.restrict (Set.uIoc 0 t)` is a finite measure (`uIoc 0 t = Ioc 0 t`)
+  have huIoc : Set.uIoc (0 : ℝ) t = Set.Ioc 0 t := Set.uIoc_of_le h0t
+  have hvol_lt : MeasureTheory.volume (Set.uIoc (0 : ℝ) t) < ⊤ := by
+    rw [huIoc, Real.volume_Ioc]; exact ENNReal.ofReal_lt_top
+  have hfin_restrict : IsFiniteMeasure (MeasureTheory.volume.restrict (Set.uIoc (0 : ℝ) t)) := by
+    refine ⟨?_⟩
+    rw [Measure.restrict_apply_univ]; exact hvol_lt
+  -- `ε` is integrable over `volume.restrict (uIoc 0 t)`
+  have hε_int_t : IntervalIntegrable ε MeasureTheory.volume 0 t :=
+    hε_int.mono_set (by
+      rw [Set.uIcc_of_le h0t, Set.uIcc_of_le hT]; exact Set.Icc_subset_Icc_right htT)
+  have hε_intOn : Integrable ε (MeasureTheory.volume.restrict (Set.uIoc (0 : ℝ) t)) :=
+    hε_int_t.def'
+  -- AEStronglyMeasurability of `uncurry g` over the product measure
+  have hg_aesm : AEStronglyMeasurable (Function.uncurry g)
+      ((MeasureTheory.volume.restrict (Set.uIoc (0 : ℝ) t)).prod π) := by
+    have h1 : AEStronglyMeasurable (fun p : ℝ × Ω => L * ‖w p.1 p.2‖)
+        ((MeasureTheory.volume.restrict (Set.uIoc (0 : ℝ) t)).prod π) :=
+      (measurable_const.mul hjoint_norm).aestronglyMeasurable
+    have h2 : AEStronglyMeasurable (fun p : ℝ × Ω => ε p.1)
+        ((MeasureTheory.volume.restrict (Set.uIoc (0 : ℝ) t)).prod π) :=
+      hε_intOn.aestronglyMeasurable.comp_fst
+    exact h1.add h2
+  -- product integrability of `uncurry g`, via the dominator `L·dom(ω) + ε(s)`
+  have hdom_prod : Integrable (fun p : ℝ × Ω => L * dom p.2 + ε p.1)
+      ((MeasureTheory.volume.restrict (Set.uIoc (0 : ℝ) t)).prod π) :=
+    ((hdom_int.const_mul L).comp_snd
+        (MeasureTheory.volume.restrict (Set.uIoc (0 : ℝ) t))).add (hε_intOn.comp_fst π)
+  have hae_fst : ∀ᵐ p : ℝ × Ω
+      ∂((MeasureTheory.volume.restrict (Set.uIoc (0 : ℝ) t)).prod π), p.1 ∈ Set.uIoc (0 : ℝ) t :=
+    (MeasureTheory.Measure.quasiMeasurePreserving_fst).tendsto_ae.eventually
+      (MeasureTheory.ae_restrict_mem measurableSet_uIoc)
+  have hg_int : Integrable (Function.uncurry g)
+      ((MeasureTheory.volume.restrict (Set.uIoc (0 : ℝ) t)).prod π) := by
+    refine hdom_prod.mono' hg_aesm ?_
+    filter_upwards [hae_fst] with p hp
+    have hp_icc : p.1 ∈ Set.Icc (0 : ℝ) T := by
+      rw [huIoc] at hp; exact ⟨le_of_lt hp.1, hp.2.trans htT⟩
+    have hwle : ‖w p.1 p.2‖ ≤ dom p.2 := hdom p.1 hp_icc p.2
+    have hεnn : 0 ≤ ε p.1 := hε_nn p.1 hp_icc
+    have hg_nn : 0 ≤ L * ‖w p.1 p.2‖ + ε p.1 :=
+      add_nonneg (mul_nonneg hL (norm_nonneg _)) hεnn
+    change ‖L * ‖w p.1 p.2‖ + ε p.1‖ ≤ L * dom p.2 + ε p.1
+    rw [Real.norm_of_nonneg hg_nn]
+    nlinarith [mul_le_mul_of_nonneg_left hwle hL]
+  -- inner intervalIntegral = integral against the restricted measure
+  have hconv : ∀ ω, (∫ s in (0 : ℝ)..t, g s ω)
+      = ∫ s, g s ω ∂(MeasureTheory.volume.restrict (Set.uIoc (0 : ℝ) t)) := by
+    intro ω
+    rw [intervalIntegral.integral_of_le h0t, ← huIoc]
+  -- marginal integrability `ω ↦ ∫ s, g s ω`
+  have hmarg : Integrable
+      (fun ω => ∫ s, g s ω ∂(MeasureTheory.volume.restrict (Set.uIoc (0 : ℝ) t))) π :=
+    hg_int.integral_prod_right
+  have hinner_int : Integrable (fun ω => ∫ s in (0 : ℝ)..t, g s ω) π := by
+    simpa only [hconv] using hmarg
+  -- per-`s` identity  ∫ ω, g s ω ∂π = L · (∫ ω, ‖w s ω‖ ∂π) + ε s
+  have hg_int_s : ∀ s ∈ Set.Icc (0 : ℝ) T, Integrable (fun ω => ‖w s ω‖) π := by
+    intro s hs
+    refine hdom_int.mono' ((hw_meas s).norm.aestronglyMeasurable) ?_
+    filter_upwards with ω
+    rw [Real.norm_of_nonneg (norm_nonneg _)]; exact hdom s hs ω
+  have hQg : ∀ s ∈ Set.Icc (0 : ℝ) T,
+      (∫ ω, g s ω ∂π) = L * (∫ ω, ‖w s ω‖ ∂π) + ε s := by
+    intro s hs
+    simp only [hg]
+    rw [integral_add ((hg_int_s s hs).const_mul L) (integrable_const _), integral_const_mul]
+    congr 1
+    simp [integral_const, measureReal_def, measure_univ]
+  -- the double integral, via Tonelli
+  have hdouble : (∫ ω, (∫ s in (0 : ℝ)..t, g s ω) ∂π)
+      = ∫ s in (0 : ℝ)..t, (L * (∫ ω, ‖w s ω‖ ∂π) + ε s) := by
+    calc (∫ ω, (∫ s in (0 : ℝ)..t, g s ω) ∂π)
+        = ∫ ω, (∫ s, g s ω ∂(MeasureTheory.volume.restrict (Set.uIoc (0 : ℝ) t))) ∂π := by
+          simp only [hconv]
+      _ = ∫ s, (∫ ω, g s ω ∂π) ∂(MeasureTheory.volume.restrict (Set.uIoc (0 : ℝ) t)) :=
+          (MeasureTheory.integral_integral_swap hg_int).symm
+      _ = ∫ s in (0 : ℝ)..t, (∫ ω, g s ω ∂π) := by
+          rw [huIoc, ← intervalIntegral.integral_of_le h0t]
+      _ = ∫ s in (0 : ℝ)..t, (L * (∫ ω, ‖w s ω‖ ∂π) + ε s) := by
+          refine intervalIntegral.integral_congr (fun s hs => ?_)
+          rw [Set.uIcc_of_le h0t] at hs
+          exact hQg s ⟨hs.1, hs.2.trans htT⟩
+  -- assemble
+  calc (∫ ω, ‖w t ω‖ ∂π)
+      ≤ ∫ ω, (‖w 0 ω‖ + ∫ s in (0 : ℝ)..t, g s ω) ∂π :=
+        integral_mono hintt (hint0.add hinner_int) (fun ω => hper ω t ht)
+    _ = (∫ ω, ‖w 0 ω‖ ∂π) + ∫ ω, (∫ s in (0 : ℝ)..t, g s ω) ∂π :=
+        integral_add hint0 hinner_int
+    _ = (∫ ω, ‖w 0 ω‖ ∂π) + ∫ s in (0 : ℝ)..t, (L * (∫ ω, ‖w s ω‖ ∂π) + ε s) := by
+        rw [hdouble]
+
+/-- **Integrated coupling-Gronwall bound** (base-measure generic).
+
+Given a base probability measure `π` on `Ω` and two parameter-families of
+trajectories `X_f, X_g : ℝ → Ω → α` solving ODEs with `L`-Lipschitz vector fields
+`b_f, b_g` on `[0, T]`, with a cross-field bound `‖b_f s y - b_g s y‖ ≤ ε s` whose
+amplitude `ε s` is **self-referentially** controlled by the integrated trajectory
+distance `Q s := ∫ ω, ‖X_f s ω - X_g s ω‖ ∂π` (i.e. `ε s ≤ L · Q s`), the
+integrated distance obeys the closed Gronwall bound
+`Q t ≤ Q 0 · exp (2 L t)` on `[0, T]`.
+
+**Composition** (the collapse pipeline):
+* per-`ω`, `flow_difference_mild_bound` gives the mild integral inequality
+  `‖X_f t ω - X_g t ω‖ ≤ ‖X_f 0 ω - X_g 0 ω‖ + ∫₀ᵗ (L‖X_f s ω - X_g s ω‖ + ε s)`;
+* `integral_mild_bound` integrates this over `π` (Tonelli on a nonnegative
+  integrand), yielding `Q t ≤ Q 0 + ∫₀ᵗ (L·Q s + ε s)`;
+* the self-reference `ε s ≤ L·Q s` collapses the integrand to `2 L · Q s`;
+* `gronwall_mild_le` (scalar mild Gronwall) closes to `Q 0 · exp (2 L t)`.
+
+**Clamp bridge**: `integral_mild_bound` and the DCT continuity of `Q`
+require *global*-in-`s` continuity, but the flow regularity is only on the
+window `[0, T]`.  We work with the clamped flow `s ↦ X_f (clamp s) ω` (globally
+continuous, agreeing with `X_f` on `[0, T]`), apply the window machinery to it,
+and transfer back on `[0, T]` where `clamp = id` via integrand congruence.
+
+**Base-measure genericity**: `π` is abstract, so this serves both the
+uniqueness call site (`π = f 0`, `Q 0 = 0`, Foundation-B-free) and the
+mean-field call site (`π` an optimal coupling, `Q 0 = W₁(f 0, g 0)`). -/
+theorem integrated_coupling_gronwall_bound
+    {Ω α : Type*} [MeasurableSpace Ω]
+    [NormedAddCommGroup α] [NormedSpace ℝ α] [CompleteSpace α]
+    [MeasurableSpace α] [BorelSpace α] [MeasurableSub₂ α]
+    (π : Measure Ω) [IsProbabilityMeasure π]
+    (X_f X_g : ℝ → Ω → α) (b_f b_g : ℝ → α → α) (L : NNReal) (T : ℝ) (hT : 0 ≤ T)
+    (hL_f : ∀ t, LipschitzWith L (b_f t))
+    -- per-`ω` flow regularity (matches `flow_difference_mild_bound`)
+    (hcont_f : ∀ ω, ContinuousOn (fun s => X_f s ω) (Set.Icc 0 T))
+    (hcont_g : ∀ ω, ContinuousOn (fun s => X_g s ω) (Set.Icc 0 T))
+    (hderiv_f : ∀ ω, ∀ s ∈ Set.Ioo (0 : ℝ) T,
+      HasDerivWithinAt (fun s => X_f s ω) (b_f s (X_f s ω)) (Set.Ioi s) s)
+    (hderiv_g : ∀ ω, ∀ s ∈ Set.Ioo (0 : ℝ) T,
+      HasDerivWithinAt (fun s => X_g s ω) (b_g s (X_g s ω)) (Set.Ioi s) s)
+    (hint : ∀ ω, IntervalIntegrable
+      (fun s => b_f s (X_f s ω) - b_g s (X_g s ω)) MeasureTheory.volume 0 T)
+    -- measurability + domination for the Tonelli / DCT
+    (hmeas_f : ∀ s, Measurable (X_f s)) (hmeas_g : ∀ s, Measurable (X_g s))
+    (dom : Ω → ℝ) (hdom_int : Integrable dom π)
+    (hdom : ∀ s ∈ Set.Icc (0 : ℝ) T, ∀ ω, ‖X_f s ω - X_g s ω‖ ≤ dom ω)
+    -- the cross-field bound `ε` and its self-reference to `Q`
+    (ε : ℝ → ℝ) (hε_int : IntervalIntegrable ε MeasureTheory.volume 0 T)
+    (hε_nn : ∀ s ∈ Set.Icc (0 : ℝ) T, 0 ≤ ε s)
+    (h_diff : ∀ ω, ∀ s ∈ Set.Icc (0 : ℝ) T,
+      ‖b_f s (X_g s ω) - b_g s (X_g s ω)‖ ≤ ε s)
+    (h_self : ∀ s ∈ Set.Icc (0 : ℝ) T,
+      ε s ≤ (L : ℝ) * ∫ ω, ‖X_f s ω - X_g s ω‖ ∂π) :
+    ∀ t ∈ Set.Icc (0 : ℝ) T,
+      (∫ ω, ‖X_f t ω - X_g t ω‖ ∂π) ≤
+        (∫ ω, ‖X_f 0 ω - X_g 0 ω‖ ∂π) * Real.exp (2 * (L:ℝ) * t) := by
+  -- clamp into `[0, T]` (opaque; used only through its three properties)
+  obtain ⟨clamp, hclamp_cont, hclamp_mem, hclamp_id⟩ :
+      ∃ clamp : ℝ → ℝ, Continuous clamp ∧ (∀ s, clamp s ∈ Set.Icc (0 : ℝ) T) ∧
+        (∀ s ∈ Set.Icc (0 : ℝ) T, clamp s = s) := by
+    refine ⟨fun s => max 0 (min s T), ?_, ?_, ?_⟩
+    · exact continuous_const.max (continuous_id.min continuous_const)
+    · intro s; exact ⟨le_max_left _ _, max_le hT (min_le_right _ _)⟩
+    · intro s hs; change max 0 (min s T) = s
+      rw [min_eq_left hs.2, max_eq_right hs.1]
+  -- the clamped difference flow `W s ω = X_f (clamp s) ω - X_g (clamp s) ω`
+  set W : ℝ → Ω → α := fun s ω => X_f (clamp s) ω - X_g (clamp s) ω with hW_def
+  have hW_cont : ∀ ω, Continuous (fun s => W s ω) := by
+    intro ω; simp only [hW_def]
+    exact ((hcont_f ω).sub (hcont_g ω)).comp_continuous hclamp_cont hclamp_mem
+  have hW_meas : ∀ s, Measurable (W s) := by
+    intro s; simp only [hW_def]
+    exact (hmeas_f (clamp s)).sub (hmeas_g (clamp s))
+  have hW_dom : ∀ s, ∀ ω, ‖W s ω‖ ≤ dom ω := by
+    intro s ω; simp only [hW_def]; exact hdom (clamp s) (hclamp_mem s) ω
+  -- on `[0, T]`, `W` agrees with the unclamped difference, so the integrals agree
+  have hQW_eq : ∀ s ∈ Set.Icc (0 : ℝ) T,
+      (∫ ω, ‖W s ω‖ ∂π) = ∫ ω, ‖X_f s ω - X_g s ω‖ ∂π := by
+    intro s hs
+    apply integral_congr_ae
+    filter_upwards with ω
+    simp only [hW_def, hclamp_id s hs]
+  -- per-`ω` mild bound (unclamped) via `flow_difference_mild_bound`
+  have hper_w : ∀ ω, ∀ t ∈ Set.Icc (0 : ℝ) T,
+      ‖X_f t ω - X_g t ω‖ ≤ ‖X_f 0 ω - X_g 0 ω‖ +
+        ∫ s in (0 : ℝ)..t, ((L:ℝ) * ‖X_f s ω - X_g s ω‖ + ε s) := fun ω =>
+    flow_difference_mild_bound b_f b_g L hL_f (fun s => X_f s ω) (fun s => X_g s ω) T
+      (hcont_f ω) (hcont_g ω) (hderiv_f ω) (hderiv_g ω) (hint ω) ε hε_int (h_diff ω)
+  -- transfer the mild bound to the clamped flow `W` (needed by `integral_mild_bound`)
+  have hper_W : ∀ ω, ∀ t ∈ Set.Icc (0 : ℝ) T,
+      ‖W t ω‖ ≤ ‖W 0 ω‖ + ∫ s in (0 : ℝ)..t, ((L:ℝ) * ‖W s ω‖ + ε s) := by
+    intro ω t ht
+    have h0t : (0 : ℝ) ≤ t := ht.1
+    have hWt : W t ω = X_f t ω - X_g t ω := by simp only [hW_def, hclamp_id t ht]
+    have hW0 : W 0 ω = X_f 0 ω - X_g 0 ω := by
+      simp only [hW_def, hclamp_id 0 ⟨le_refl 0, hT⟩]
+    have hintegrand : (∫ s in (0 : ℝ)..t, ((L:ℝ) * ‖W s ω‖ + ε s))
+        = ∫ s in (0 : ℝ)..t, ((L:ℝ) * ‖X_f s ω - X_g s ω‖ + ε s) := by
+      refine intervalIntegral.integral_congr (fun s hs => ?_)
+      rw [Set.uIcc_of_le h0t] at hs
+      have hsT : s ∈ Set.Icc (0 : ℝ) T := ⟨hs.1, hs.2.trans ht.2⟩
+      simp only [hW_def, hclamp_id s hsT]
+    rw [hWt, hW0, hintegrand]; exact hper_w ω t ht
+  -- integrate over `π` (Tonelli): `Q t ≤ Q 0 + ∫₀ᵗ (L·Q s + ε s)`
+  have hQW := integral_mild_bound π W (L:ℝ) (NNReal.coe_nonneg L) ε T hT
+    hW_cont hW_meas dom hdom_int (fun s _ ω => hW_dom s ω) hε_int hε_nn hper_W
+  -- `Q` is globally continuous via DCT (clamped flow globally dominated)
+  have hQW_cont : Continuous (fun s => ∫ ω, ‖W s ω‖ ∂π) := by
+    refine continuous_of_dominated
+      (fun s => (hW_meas s).norm.aestronglyMeasurable)
+      (fun s => Filter.Eventually.of_forall (fun ω => ?_)) hdom_int
+      (Filter.Eventually.of_forall (fun ω => (hW_cont ω).norm))
+    rw [Real.norm_of_nonneg (norm_nonneg _)]; exact hW_dom s ω
+  -- collapse the integrand to `2 L · Q s` using the self-reference
+  have hmild_W : ∀ t ∈ Set.Icc (0 : ℝ) T,
+      (∫ ω, ‖W t ω‖ ∂π) ≤ (∫ ω, ‖W 0 ω‖ ∂π)
+        + (2 * (L:ℝ)) * ∫ s in (0 : ℝ)..t, (∫ ω, ‖W s ω‖ ∂π) := by
+    intro t ht
+    have h0t : (0 : ℝ) ≤ t := ht.1
+    have hstep := hQW t ht
+    have hII_lhs : IntervalIntegrable
+        (fun s => (L:ℝ) * (∫ ω, ‖W s ω‖ ∂π) + ε s) MeasureTheory.volume 0 t :=
+      ((hQW_cont.intervalIntegrable 0 t).const_mul (L:ℝ)).add
+        (hε_int.mono_set (by
+          rw [Set.uIcc_of_le h0t, Set.uIcc_of_le hT]
+          exact Set.Icc_subset_Icc_right ht.2))
+    have hII_rhs : IntervalIntegrable
+        (fun s => (2 * (L:ℝ)) * (∫ ω, ‖W s ω‖ ∂π)) MeasureTheory.volume 0 t :=
+      (hQW_cont.intervalIntegrable 0 t).const_mul (2 * (L:ℝ))
+    have hmono : (∫ s in (0 : ℝ)..t, ((L:ℝ) * (∫ ω, ‖W s ω‖ ∂π) + ε s))
+        ≤ ∫ s in (0 : ℝ)..t, (2 * (L:ℝ)) * (∫ ω, ‖W s ω‖ ∂π) := by
+      refine intervalIntegral.integral_mono_on h0t hII_lhs hII_rhs (fun s hs => ?_)
+      have hsT : s ∈ Set.Icc (0 : ℝ) T := ⟨hs.1, hs.2.trans ht.2⟩
+      have hεle : ε s ≤ (L:ℝ) * (∫ ω, ‖W s ω‖ ∂π) := by
+        calc ε s ≤ (L:ℝ) * (∫ ω, ‖X_f s ω - X_g s ω‖ ∂π) := h_self s hsT
+          _ = (L:ℝ) * (∫ ω, ‖W s ω‖ ∂π) := by rw [hQW_eq s hsT]
+      have hring : (2 * (L:ℝ)) * (∫ ω, ‖W s ω‖ ∂π)
+          = (L:ℝ) * (∫ ω, ‖W s ω‖ ∂π) + (L:ℝ) * (∫ ω, ‖W s ω‖ ∂π) := by ring
+      rw [hring]; linarith [hεle]
+    calc (∫ ω, ‖W t ω‖ ∂π)
+        ≤ (∫ ω, ‖W 0 ω‖ ∂π)
+          + ∫ s in (0 : ℝ)..t, ((L:ℝ) * (∫ ω, ‖W s ω‖ ∂π) + ε s) := hstep
+      _ ≤ (∫ ω, ‖W 0 ω‖ ∂π)
+          + ∫ s in (0 : ℝ)..t, (2 * (L:ℝ)) * (∫ ω, ‖W s ω‖ ∂π) := by linarith [hmono]
+      _ = (∫ ω, ‖W 0 ω‖ ∂π)
+          + (2 * (L:ℝ)) * ∫ s in (0 : ℝ)..t, (∫ ω, ‖W s ω‖ ∂π) := by
+            rw [intervalIntegral.integral_const_mul]
+  -- scalar mild Gronwall on `Q`
+  have hgron := gronwall_mild_le (fun s => ∫ ω, ‖W s ω‖ ∂π)
+    (∫ ω, ‖W 0 ω‖ ∂π) (2 * (L:ℝ)) T
+    (by have := NNReal.coe_nonneg L; linarith)
+    (integral_nonneg (fun ω => norm_nonneg _))
+    hQW_cont (fun s => integral_nonneg (fun ω => norm_nonneg _)) hmild_W
+  -- transfer back to the unclamped difference on `[0, T]`
+  intro t ht
+  rw [← hQW_eq t ht, ← hQW_eq 0 ⟨le_refl 0, hT⟩]
+  exact hgron t ht
+
+/-- **Piece A (Option 2): time-dependent moment-envelope growth bound.**
+
+Sharper sibling of `flow_distance_growth_bound_on`.  Instead of a single
+constant moment bound `M_ρ` (which forces the constant-sup growth constant
+`C_T` and, downstream, an `M_f₀`-dependent fixed-point on the curve space),
+this takes a **monotone time-dependent envelope** `m : ℝ → ℝ` bounding the
+spatial-marginal first moment, and concludes the **time-local** Gronwall bound
+
+  `‖(charX t z, charV t z)‖ ≤ gronwallBound ‖z‖ (1+L) (‖gradW 0‖ + L · m t) t`,
+
+with the force constant `ε(t) = ‖gradW 0‖ + L · m t` evaluated at the SAME time
+`t` (not the sup `m T`).  Monotonicity of `m` lets the per-`t` Gronwall on
+`[0, t]` use the endpoint value `ε(t)` while validating the derivative bound at
+every `s ≤ t` (since `ε(s) ≤ ε(t)`).
+
+**Why this is the option-2 foundation**: integrating the conclusion over a
+probability `f₀` gives `M_{Φρ}(t) ≤ A(t) + B(t)·m(t)` with
+`A(t) = M_f₀·e^{(1+L)t} + (‖gradW 0‖/(1+L))(e^{(1+L)t}-1)` and
+`B(t) = (L/(1+L))(e^{(1+L)t}-1)` — crucially an **`M_f₀`-free** coefficient.
+The canonical envelope `m*(t) := A(t)/(1-B(T))` is then Φ-invariant under the
+**data-independent** constraint `B(T) < 1`, dissolving the constant-`M`
+fixed-point without a data-dependent hypothesis.  (Contrast the constant-sup
+bound, which feeds `m(T)` into `ε` and re-derives an `M_f₀`-dependent
+smallness.) -/
+theorem flow_distance_growth_bound_on_timedep
+    {d : ℕ}
+    (gradW : PhysSpace d → PhysSpace d)
+    (L : NNReal) (hL : LipschitzWith L gradW)
+    (ρ : ℝ → Measure (PhysSpace d))
+    [∀ t, IsProbabilityMeasure (ρ t)]
+    (charX charV : ℝ → PhaseSpace d → PhysSpace d)
+    (T : ℝ) (_hT : 0 ≤ T)
+    (h_init : ∀ z : PhaseSpace d, (charX 0 z, charV 0 z) = z)
+    (h_cont_Icc : ∀ z : PhaseSpace d,
+        ContinuousOn (fun s => (charX s z, charV s z)) (Set.Icc (0 : ℝ) T))
+    (h_deriv_Ico : ∀ z : PhaseSpace d, ∀ s ∈ Set.Ico (0 : ℝ) T,
+        HasDerivWithinAt (fun s' => (charX s' z, charV s' z))
+          (vlasovVectorField gradW ρ s (charX s z, charV s z))
+          (Set.Ici s) s)
+    (m : ℝ → ℝ) (hm_mono : MonotoneOn m (Set.Icc 0 T))
+    (hm : ∀ t ∈ Set.Icc 0 T, ∫ y, ‖y‖ ∂(ρ t) ≤ m t)
+    (h_y_int : ∀ t ∈ Set.Icc 0 T, Integrable (fun y : PhysSpace d => ‖y‖) (ρ t))
+    (h_int : ∀ t (x : PhysSpace d), Integrable (fun y => gradW (x - y)) (ρ t)) :
+    ∀ t ∈ Set.Icc 0 T, ∀ z : PhaseSpace d,
+      ‖(charX t z, charV t z)‖ ≤
+        gronwallBound ‖z‖ (1 + (L : ℝ)) (‖gradW 0‖ + (L : ℝ) * m t) t := by
+  intro t ht z
+  set K : ℝ := 1 + (L : ℝ) with hK_def
+  -- m t ≥ 0 (moment of a probability measure is nonneg, bounded by m t).
+  have hmt_nn : 0 ≤ m t :=
+    le_trans (integral_nonneg (fun y => norm_nonneg y)) (hm t ht)
+  set εt : ℝ := ‖gradW 0‖ + (L : ℝ) * m t with hεt_def
+  have hK_pos : 0 < K := by positivity
+  have hεt_nn : 0 ≤ εt := by positivity
+  -- Convolution force bound on [0, t], using m s ≤ m t (monotone).
+  have h_conv_bound : ∀ s ∈ Set.Icc 0 t, ∀ x : PhysSpace d,
+      ‖convolveFunctionMeasure gradW (ρ s) x‖ ≤ εt + (L : ℝ) * ‖x‖ := by
+    intro s hs x
+    have hs_T : s ∈ Set.Icc 0 T := ⟨hs.1, le_trans hs.2 ht.2⟩
+    exact norm_convolveFunctionMeasure_le_affine gradW L hL (ρ s) (h_int s)
+      (h_y_int s hs_T) (m t) ((hm s hs_T).trans (hm_mono hs_T ht hs.2)) x
+  -- Gronwall on [0, t] with the endpoint force constant εt.
+  have ht0 : (0 : ℝ) ≤ t := ht.1
+  have h_f_cont : ContinuousOn (fun s => (charX s z, charV s z)) (Set.Icc 0 t) :=
+    (h_cont_Icc z).mono (Set.Icc_subset_Icc_right ht.2)
+  have h_deriv : ∀ s ∈ Set.Ico 0 t,
+      HasDerivWithinAt (fun s => (charX s z, charV s z))
+        (charV s z, -convolveFunctionMeasure gradW (ρ s) (charX s z))
+        (Set.Ici s) s := by
+    intro s hs
+    have hs_T : s ∈ Set.Ico 0 T := ⟨hs.1, lt_of_lt_of_le hs.2 ht.2⟩
+    have hderiv := h_deriv_Ico z s hs_T
+    unfold vlasovVectorField at hderiv
+    exact hderiv
+  have h_init_norm : ‖(charX 0 z, charV 0 z)‖ ≤ ‖z‖ := by rw [h_init z]
+  have h_bound : ∀ s ∈ Set.Ico 0 t,
+      ‖(charV s z, -convolveFunctionMeasure gradW (ρ s) (charX s z))‖ ≤
+        K * ‖(charX s z, charV s z)‖ + εt := by
+    intro s hs
+    have hs_mem : s ∈ Set.Icc 0 t := ⟨hs.1, le_of_lt hs.2⟩
+    simp only [Prod.norm_def, norm_neg]
+    have hFsz := le_max_left ‖charX s z‖ ‖charV s z‖
+    have hGsz := le_max_right ‖charX s z‖ ‖charV s z‖
+    have hM_nn : 0 ≤ max ‖charX s z‖ ‖charV s z‖ :=
+      le_max_iff.mpr (Or.inl (norm_nonneg _))
+    have h_v_le : ‖charV s z‖ ≤ K * max ‖charX s z‖ ‖charV s z‖ + εt :=
+      calc ‖charV s z‖ ≤ max ‖charX s z‖ ‖charV s z‖ := hGsz
+        _ ≤ K * max ‖charX s z‖ ‖charV s z‖ :=
+            le_mul_of_one_le_left hM_nn (by linarith [NNReal.coe_nonneg L])
+        _ ≤ K * max ‖charX s z‖ ‖charV s z‖ + εt := le_add_of_nonneg_right hεt_nn
+    have h_conv_le : ‖convolveFunctionMeasure gradW (ρ s) (charX s z)‖ ≤
+        K * max ‖charX s z‖ ‖charV s z‖ + εt :=
+      calc ‖convolveFunctionMeasure gradW (ρ s) (charX s z)‖
+          ≤ εt + (L : ℝ) * ‖charX s z‖ := h_conv_bound s hs_mem _
+        _ ≤ εt + K * max ‖charX s z‖ ‖charV s z‖ := by
+            have hLK : (L : ℝ) ≤ K := le_add_of_nonneg_left zero_le_one
+            linarith [mul_le_mul_of_nonneg_left hFsz (NNReal.coe_nonneg L),
+                      mul_le_mul_of_nonneg_right hLK hM_nn]
+        _ = K * max ‖charX s z‖ ‖charV s z‖ + εt := by ring
+    exact max_le h_v_le h_conv_le
+  have h_grw := norm_le_gronwallBound_of_norm_deriv_right_le
+    h_f_cont h_deriv h_init_norm h_bound t (Set.right_mem_Icc.mpr ht0)
+  simpa using h_grw
+
+/-- **Piece A.3 (Option 2): the canonical moment envelope closes (data-free).**
+
+Pure-algebra companion to `flow_distance_growth_bound_on_timedep`.  Under the
+**`M_f₀`-free** smallness `B(T) := (L/(1+L))(e^{(1+L)T}-1) < 1`, the explicit
+envelope `m*(t) := gronwallBound M_f₀ (1+L) g0 t / (1 - B(T))` is a Gronwall
+super-solution:
+
+* monotone on `[0, T]`,
+* dominates the initial moment `M_f₀`,
+* **Φ-invariant** at the moment level:
+  `gronwallBound M_f₀ (1+L) (g0 + L·m* t) t ≤ m* t`.
+
+Composed with Piece A integrated over `f₀` (which gives
+`M_{Φρ}(t) ≤ gronwallBound M_f₀ (1+L) (g0 + L·m(t)) t`, `g0 = ‖gradW 0‖`), this
+shows the Picard iterates stay inside the fixed envelope `m*` with **no**
+data-dependent hypothesis — the faithful dissolution of the constant-`M`
+fixed-point.  This lemma is the measure-free heart of the option-2 escape;
+Pieces B–D thread it through the curve space, `Phi_step`, and #11. -/
+theorem gronwall_envelope_exists
+    (M_f₀ g0 : ℝ) (hM_f₀ : 0 ≤ M_f₀) (hg0 : 0 ≤ g0)
+    (L : NNReal) (T : ℝ) (hT : 0 ≤ T)
+    (hB : (L : ℝ) / (1 + (L : ℝ)) * (Real.exp ((1 + (L : ℝ)) * T) - 1) < 1) :
+    ∃ m : ℝ → ℝ, MonotoneOn m (Set.Icc 0 T) ∧
+      (∀ t ∈ Set.Icc 0 T, M_f₀ ≤ m t) ∧
+      (∀ t ∈ Set.Icc 0 T,
+        gronwallBound M_f₀ (1 + (L : ℝ)) (g0 + (L : ℝ) * m t) t ≤ m t) := by
+  set K : ℝ := 1 + (L : ℝ) with hK_def
+  have hK_pos : 0 < K := by positivity
+  have hK_ne : K ≠ 0 := ne_of_gt hK_pos
+  have hL_nn : (0 : ℝ) ≤ (L : ℝ) := L.coe_nonneg
+  -- B(t) and its monotonicity.
+  set Bf : ℝ → ℝ := fun t => (L : ℝ) / K * (Real.exp (K * t) - 1) with hBf_def
+  have hBT_lt : Bf T < 1 := hB
+  have hD_pos : 0 < 1 - Bf T := by linarith
+  have hD_nn : (0 : ℝ) ≤ 1 - Bf T := hD_pos.le
+  have hD_ne : (1 - Bf T) ≠ 0 := ne_of_gt hD_pos
+  have hLK_nn : 0 ≤ (L : ℝ) / K := div_nonneg hL_nn hK_pos.le
+  have hBf_T_nn : 0 ≤ Bf T := by
+    have he1 : 0 ≤ Real.exp (K * T) - 1 := by
+      have : (1 : ℝ) ≤ Real.exp (K * T) := Real.one_le_exp (by positivity)
+      linarith
+    exact mul_nonneg hLK_nn he1
+  have hBf_le : ∀ t ∈ Set.Icc (0 : ℝ) T, Bf t ≤ Bf T := by
+    intro t ht
+    have hexp : Real.exp (K * t) ≤ Real.exp (K * T) :=
+      Real.exp_le_exp.mpr (by nlinarith [ht.2, hK_pos.le])
+    simp only [hBf_def]
+    nlinarith [hexp, hLK_nn]
+  -- A(t) := gronwallBound M_f₀ K g0 t, expanded + nonneg + monotone.
+  set Af : ℝ → ℝ := fun t => gronwallBound M_f₀ K g0 t with hAf_def
+  have hAf_expand : ∀ t,
+      Af t = M_f₀ * Real.exp (K * t) + g0 / K * (Real.exp (K * t) - 1) := by
+    intro t; simp only [hAf_def]; rw [gronwallBound_of_K_ne_0 hK_ne]
+  have hAf_nn : ∀ t ∈ Set.Icc (0 : ℝ) T, 0 ≤ Af t := by
+    intro t ht
+    rw [hAf_expand t]
+    have he1 : 0 ≤ Real.exp (K * t) - 1 := by
+      have : (1 : ℝ) ≤ Real.exp (K * t) := Real.one_le_exp (by nlinarith [ht.1, hK_pos.le])
+      linarith
+    have hgK_nn : 0 ≤ g0 / K := div_nonneg hg0 hK_pos.le
+    positivity
+  have hAf_mono : MonotoneOn Af (Set.Icc 0 T) := by
+    intro s _ t _ hst
+    simp only [hAf_def]
+    exact gronwallBound_mono hM_f₀ hg0 hK_pos.le hst
+  refine ⟨fun t => Af t / (1 - Bf T), ?_, ?_, ?_⟩
+  · -- monotone: Af increasing, positive constant divisor.
+    intro s hs t ht hst
+    change Af s / (1 - Bf T) ≤ Af t / (1 - Bf T)
+    gcongr
+    exact hAf_mono hs ht hst
+  · -- M_f₀ ≤ m t.
+    intro t ht
+    have h0_mem : (0 : ℝ) ∈ Set.Icc (0 : ℝ) T := ⟨le_refl 0, hT⟩
+    have hAf0 : Af 0 = M_f₀ := by rw [hAf_expand 0]; simp [Real.exp_zero]
+    have h_mono : Af 0 / (1 - Bf T) ≤ Af t / (1 - Bf T) := by
+      gcongr
+      exact hAf_mono h0_mem ht ht.1
+    rw [hAf0] at h_mono
+    have h_self : M_f₀ ≤ M_f₀ / (1 - Bf T) := by
+      rw [le_div_iff₀ hD_pos]; nlinarith [hM_f₀, hBf_T_nn]
+    linarith
+  · -- Φ-invariance.
+    intro t ht
+    change gronwallBound M_f₀ K (g0 + (L : ℝ) * (Af t / (1 - Bf T))) t
+        ≤ Af t / (1 - Bf T)
+    have h_lhs : gronwallBound M_f₀ K (g0 + (L : ℝ) * (Af t / (1 - Bf T))) t
+              = Af t + Bf t * (Af t / (1 - Bf T)) := by
+      rw [gronwallBound_of_K_ne_0 hK_ne, hAf_expand t]
+      simp only [hBf_def]; ring
+    rw [h_lhs]
+    have hkey : 0 ≤ Af t * (Bf T - Bf t) :=
+      mul_nonneg (hAf_nn t ht) (by linarith [hBf_le t ht])
+    have hexpand : Af t / (1 - Bf T) - (Af t + Bf t * (Af t / (1 - Bf T)))
+                 = Af t * (Bf T - Bf t) / (1 - Bf T) := by
+      field_simp
+      ring
+    linarith [div_nonneg hkey hD_pos.le, hexpand]
+
+/-- **Piece A.2 (Option 2): integrate the per-`z` growth bound to a moment bound.**
+
+The measure-level bridge between Piece A and Piece A.3: given the per-`z`
+time-local growth bound (Piece A's conclusion, taken here as the hypothesis
+`h_growth` so this lemma is decoupled from the flow construction), the
+**position pushforward** `Measure.map (charX t ·) f₀` has first moment bounded
+by the same Gronwall functional evaluated at the *initial* moment `∫‖z‖ ∂f₀`:
+
+  `∫ x, ‖x‖ ∂(Measure.map (charX t ·) f₀) ≤ gronwallBound (∫‖z‖ ∂f₀) (1+L) (g0 + L·m t) t`.
+
+Proof: `integral_map` exchanges the pushforward; `‖charX t z‖ ≤ ‖(charX t z, charV t z)‖`
++ `h_growth` bounds the integrand by `gronwallBound ‖z‖ …`, which is affine in `‖z‖`,
+so its `f₀`-integral is `gronwallBound (∫‖z‖) …` (probability measure ⇒ the constant
+term integrates to itself).
+
+Composing with `gronwall_envelope_exists` (Piece A.3): when `m = m*` the canonical
+envelope and `g0 = ‖gradW 0‖`, the RHS is `≤ m* t`, i.e. `Φ` maps the envelope to
+itself at the moment level — the measure-level statement of the data-free escape. -/
+theorem phi_moment_envelope_le {d : ℕ}
+    (L : NNReal) (charX charV : ℝ → PhaseSpace d → PhysSpace d)
+    (g0 : ℝ) (T : ℝ) (m : ℝ → ℝ)
+    (h_growth : ∀ t ∈ Set.Icc (0 : ℝ) T, ∀ z : PhaseSpace d,
+      ‖(charX t z, charV t z)‖ ≤ gronwallBound ‖z‖ (1 + (L : ℝ)) (g0 + (L : ℝ) * m t) t)
+    (f₀ : Measure (PhaseSpace d)) [IsProbabilityMeasure f₀]
+    (hf₀_int : Integrable (fun z : PhaseSpace d => ‖z‖) f₀)
+    (h_meas : ∀ t ∈ Set.Icc (0 : ℝ) T,
+      AEMeasurable (fun z : PhaseSpace d => charX t z) f₀) :
+    ∀ t ∈ Set.Icc (0 : ℝ) T,
+      ∫ x, ‖x‖ ∂(Measure.map (fun z : PhaseSpace d => charX t z) f₀)
+        ≤ gronwallBound (∫ z, ‖z‖ ∂f₀) (1 + (L : ℝ)) (g0 + (L : ℝ) * m t) t := by
+  intro t ht
+  set K : ℝ := 1 + (L : ℝ) with hK_def
+  set εt : ℝ := g0 + (L : ℝ) * m t with hεt_def
+  have hK_ne : K ≠ 0 := by positivity
+  -- gronwallBound is affine in its initial value: gb r = e^{Kt}·r + C.
+  have h_gb : ∀ r : ℝ,
+      gronwallBound r K εt t = Real.exp (K * t) * r + εt / K * (Real.exp (K * t) - 1) := by
+    intro r; rw [gronwallBound_of_K_ne_0 hK_ne]; ring
+  have h_dom_int : Integrable (fun z : PhaseSpace d => gronwallBound ‖z‖ K εt t) f₀ := by
+    simp only [h_gb]
+    exact (hf₀_int.const_mul _).add (integrable_const _)
+  have h_charX_le : ∀ z : PhaseSpace d, ‖charX t z‖ ≤ gronwallBound ‖z‖ K εt t := fun z =>
+    le_trans (norm_fst_le (charX t z, charV t z)) (h_growth t ht z)
+  have h_charX_int : Integrable (fun z : PhaseSpace d => ‖charX t z‖) f₀ :=
+    h_dom_int.mono' ((h_meas t ht).norm.aestronglyMeasurable)
+      (Filter.Eventually.of_forall fun z => by
+        rw [Real.norm_of_nonneg (norm_nonneg _)]; exact h_charX_le z)
+  rw [integral_map (h_meas t ht) continuous_norm.aestronglyMeasurable]
+  calc ∫ z, ‖charX t z‖ ∂f₀
+      ≤ ∫ z, gronwallBound ‖z‖ K εt t ∂f₀ :=
+        integral_mono h_charX_int h_dom_int h_charX_le
+    _ = gronwallBound (∫ z, ‖z‖ ∂f₀) K εt t := by
+        simp only [h_gb]
+        rw [integral_add (hf₀_int.const_mul _) (integrable_const _), integral_const_mul,
+            integral_const]
+        simp [measureReal_def, measure_univ]
+
+/-! ## Characteristic flow existence (Picard-Lindelöf wrapper)
+
+This section wraps the vendored parametric Picard-Lindelöf theorem
+(`LeanPool.Vlasov.ForMathlib.PicardLindelof`) to extract a characteristic flow
+`(charX, charV)` for the Vlasov ODE.
+The four `IsPicardLindelof` hypotheses (Lipschitz-on-ball,
+continuous-in-time, norm bound, contraction) are derived from
+`convolveFunctionMeasure_lipschitz_in_x`, plus narrow-continuity of the
+spatial-marginal curve `ρ`, plus a uniform norm bound from the
+finite-mass assumption.
+
+The contraction condition `L · max(tmax − t₀, t₀ − tmin) ≤ a − r`
+pins down the local time-interval size relative to the ball radius.
+For the dobrushin application we work on a finite interval `[0, T]`;
+the existence theorem is parametrised by `T` and produces a flow
+on `Set.Icc 0 T` (extending the local flow by stitching overlapping
+windows; technically a separate iteration argument, deferred to
+the proof body).
+
+This sub-section first establishes the **global Lipschitz constant**
+for `vlasovVectorField` (a direct composition of
+`convolveFunctionMeasure_lipschitz_in_x` with the 1-Lipschitz
+identity on the velocity coordinate, combined via `LipschitzWith.prodMk`).
+The global Lipschitz immediately restricts to any closed ball,
+giving the first of the four `IsPicardLindelof` fields.
+
+The full `exists_vlasov_characteristicFlow` proof packages the global
+norm bound into a per-window `IsPicardLindelof`, invokes the vendored
+Picard-Lindelöf (`exists_vlasov_extend_one_window`), and stitches
+`N = ⌈T/δ⌉` windows per-`z` via `HasDerivWithinAt.union` under the
+position/velocity inductive invariant.  Downstream callers discharge its
+`hR`/`hbound` hypotheses; the single-ball `hR` discharge in
+`exists_vlasov_trajectory` is what introduces the
+`LocalSmallnessPLBuffer L T := L·T² < 1` constraint — see that
+theorem's docstring for the arbitrary-`L` discussion. -/
+
+/-- Localized variant of `IsCharacteristicFlow` from `Basic.lean`:
+the same initial condition + position/velocity ODEs, but quantified
+over a chosen time set `s_t : Set ℝ` and initial-condition set
+`s_z : Set (PhaseSpace d)`.
+
+The global `IsCharacteristicFlow gradW ρ charX charV` is the
+specialisation `IsCharacteristicFlowOn ... Set.univ Set.univ`
+(modulo the unconditional init clause). -/
+def IsCharacteristicFlowOn
+    {d : ℕ}
+    (gradW : PhysSpace d → PhysSpace d)
+    (ρ : ℝ → Measure (PhysSpace d))
+    (charX charV : ℝ → PhaseSpace d → PhysSpace d)
+    (s_t : Set ℝ) (s_z : Set (PhaseSpace d)) : Prop :=
+  (∀ z ∈ s_z, charX 0 z = z.1 ∧ charV 0 z = z.2) ∧
+  (∀ t ∈ s_t, ∀ z ∈ s_z, HasDerivAt (fun s => charX s z) (charV t z) t) ∧
+  (∀ t ∈ s_t, ∀ z ∈ s_z, HasDerivAt (fun s => charV s z)
+      (-(convolveFunctionMeasure gradW (ρ t) (charX t z))) t)
+
+/-- Monotonicity of `IsCharacteristicFlowOn` in both the time set and the
+initial-condition set.  Used at the end of the global existence theorem
+to restrict a flow produced on `Ioo 0 (N·δ)` (covering all of `[0, T]`)
+down to `Ioo 0 T`. -/
+lemma IsCharacteristicFlowOn.mono
+    {d : ℕ}
+    {gradW : PhysSpace d → PhysSpace d}
+    {ρ : ℝ → Measure (PhysSpace d)}
+    {charX charV : ℝ → PhaseSpace d → PhysSpace d}
+    {s_t s_t' : Set ℝ} {s_z s_z' : Set (PhaseSpace d)}
+    (h : IsCharacteristicFlowOn gradW ρ charX charV s_t s_z)
+    (hs_t : s_t' ⊆ s_t) (hs_z : s_z' ⊆ s_z) :
+    IsCharacteristicFlowOn gradW ρ charX charV s_t' s_z' := by
+  refine ⟨fun z hz => h.1 z (hs_z hz), fun t ht z hz => ?_, fun t ht z hz => ?_⟩
+  · exact h.2.1 t (hs_t ht) z (hs_z hz)
+  · exact h.2.2 t (hs_t ht) z (hs_z hz)
+
+/-- Global Lipschitz constant for the Vlasov phase-space vector field.
+`b_t(x, v) = (v, -(∇W ∗ ρ_t)(x))` is `max(1, L)`-Lipschitz when
+`gradW` is `L`-Lipschitz: the velocity-side projection `(x, v) ↦ v`
+is 1-Lipschitz (`LipschitzWith.prod_snd`), and the force-side map
+`(x, v) ↦ -(∇W ∗ ρ_t)(x)` is `L`-Lipschitz (compose
+`convolveFunctionMeasure_lipschitz_in_x` with `Neg.neg` and
+`Prod.fst`, both 1-Lipschitz).  Combining the two via
+`LipschitzWith.prodMk` yields `max(1, L)` on the product. -/
+lemma vlasovVectorField_lipschitzWith
+    {d : ℕ}
+    (gradW : PhysSpace d → PhysSpace d)
+    (L : NNReal) (hL : LipschitzWith L gradW)
+    (ρ : ℝ → Measure (PhysSpace d)) [∀ t, IsProbabilityMeasure (ρ t)]
+    (h_int : ∀ t (x : PhysSpace d), Integrable (fun y => gradW (x - y)) (ρ t))
+    (t : ℝ) :
+    LipschitzWith (max 1 L) (vlasovVectorField gradW ρ t) := by
+  -- Force-side `x ↦ (∇W ∗ ρ_t)(x)` is `L`-Lipschitz.
+  have h_conv : LipschitzWith L
+      (fun x : PhysSpace d => convolveFunctionMeasure gradW (ρ t) x) :=
+    convolveFunctionMeasure_lipschitz_in_x gradW L hL (ρ t) (h_int t)
+  -- Negate (`Neg.neg` is 1-Lipschitz): `x ↦ -(∇W ∗ ρ_t)(x)` is still `L`-Lipschitz.
+  have h_neg_conv : LipschitzWith L
+      (fun x : PhysSpace d => -convolveFunctionMeasure gradW (ρ t) x) := by
+    simpa [Function.comp_def] using LipschitzWith.id.neg.comp h_conv
+  -- Compose with `Prod.fst` (1-Lipschitz): `z ↦ -(∇W ∗ ρ_t)(z.1)` is `L`-Lipschitz.
+  have h_force : LipschitzWith L
+      (fun z : PhaseSpace d => -convolveFunctionMeasure gradW (ρ t) z.1) := by
+    simpa [Function.comp_def] using h_neg_conv.comp
+      (LipschitzWith.prod_fst (α := PhysSpace d) (β := PhysSpace d))
+  -- Combine velocity-side projection (1-Lipschitz) with force-side (L-Lipschitz).
+  exact (LipschitzWith.prod_snd (α := PhysSpace d) (β := PhysSpace d)).prodMk h_force
+
+/-- Pointwise norm bound for the Vlasov phase-space vector field.
+`‖b_t(x, v)‖ ≤ max(‖v‖, ‖(∇W ∗ ρ_t)(x)‖)` for the product `max`-norm
+on `PhaseSpace d = PhysSpace d × PhysSpace d`.
+
+This is the decomposition used to derive `IsPicardLindelof.norm_le`
+once a uniform bound `M` for `‖(∇W ∗ ρ_t)(x)‖` on a closed ball is
+known (e.g. from finite-first-moment + Lipschitz growth of `gradW`). -/
+lemma vlasovVectorField_norm_le
+    {d : ℕ}
+    (gradW : PhysSpace d → PhysSpace d)
+    (ρ : ℝ → Measure (PhysSpace d)) (t : ℝ) (z : PhaseSpace d) :
+    ‖vlasovVectorField gradW ρ t z‖ ≤
+      max ‖z.2‖ ‖convolveFunctionMeasure gradW (ρ t) z.1‖ := by
+  unfold vlasovVectorField
+  -- Prod norm is the max of component norms; neg preserves norm.
+  simp [Prod.norm_def, norm_neg]
+
+/-- **Local-flow** existence for the Vlasov ODE.
+
+Wraps the vendored parametric Picard-Lindelöf
+(`IsPicardLindelof.exists_forall_mem_closedBall_eq_forall_mem_Icc_hasDerivWithinAt_confined`,
+`LeanPool.Vlasov.ForMathlib.PicardLindelof`)
+into a `HasDerivAt`-on-`Ioo`-shaped characteristic flow.  The result
+holds for initial conditions inside `closedBall z₀ (a/2)` and for
+times in `Ioo 0 δ` where `δ` is a Picard-derived constant.
+
+The new hypothesis `hbound` (uniform norm bound on the convolution
+force on a slightly larger ball, over `[0, 1]`) is the genuine input
+the Picard wrapper needs: the contraction condition + the `norm_le`
+field of `IsPicardLindelof` both require a global bound on `‖b_t‖`.
+
+The global existence form `exists_vlasov_characteristicFlow` (below)
+is the stitched version on `[0, T]`, iterating this local theorem on
+overlapping windows and gluing with `ODE_solution_unique`. -/
+theorem exists_vlasov_characteristicFlow_local
+    {d : ℕ}
+    (W : PhysSpace d → ℝ)
+    (gradW : PhysSpace d → PhysSpace d)
+    (_hgradW : ∀ x, gradW x = gradient W x)
+    (L : NNReal) (hL : LipschitzWith L gradW)
+    (ρ : ℝ → Measure (PhysSpace d))
+    [∀ t, IsProbabilityMeasure (ρ t)]
+    (h_int : ∀ t (x : PhysSpace d), Integrable (fun y => gradW (x - y)) (ρ t))
+    (hρ_cont : ∀ x : PhysSpace d,
+      Continuous (fun t => convolveFunctionMeasure gradW (ρ t) x))
+    -- Local-flow data: the basepoint `z₀`, the ball radius `a`, and a
+    -- uniform force bound `M` on `closedBall z₀.1 (3a/2)` over `[0,1]`.
+    (z₀ : PhaseSpace d) (a : NNReal) (ha : 0 < a)
+    (M : NNReal)
+    (hbound : ∀ t ∈ Set.Icc (0 : ℝ) (1 : ℝ),
+              ∀ x ∈ Metric.closedBall z₀.1 (3 * (a : ℝ) / 2),
+              ‖convolveFunctionMeasure gradW (ρ t) x‖ ≤ M) :
+    ∃ (δ : ℝ) (_ : 0 < δ) (charX charV : ℝ → PhaseSpace d → PhysSpace d),
+      IsCharacteristicFlowOn gradW ρ charX charV
+        (Set.Ioo 0 δ) (Metric.closedBall z₀ ((a : ℝ) / 2)) := by
+  classical
+  -- IsPicardLindelof parameter choices.
+  set K_pl : NNReal := max 1 L with hK_pl_def
+  set r_pl : NNReal := a / 2 with hr_pl_def
+  set L_pl : NNReal := ‖z₀.2‖₊ + a + M with hL_pl_def
+  -- δ chosen to satisfy the contraction L_pl · δ ≤ a − r_pl = a/2.
+  set δ : ℝ := min 1 ((a : ℝ) / 2 / ((L_pl : ℝ) + 1)) with hδ_def
+  have ha_real : (0 : ℝ) < (a : ℝ) := by exact_mod_cast ha
+  have h_denom_pos : (0 : ℝ) < (L_pl : ℝ) + 1 := by positivity
+  have h_ratio_pos : (0 : ℝ) < (a : ℝ) / 2 / ((L_pl : ℝ) + 1) := by positivity
+  have hδ_pos : (0 : ℝ) < δ := lt_min one_pos h_ratio_pos
+  have hδ_le_one : δ ≤ 1 := min_le_left _ _
+  have hδ_le_ratio : δ ≤ (a : ℝ) / 2 / ((L_pl : ℝ) + 1) := min_le_right _ _
+  -- t₀ ∈ Icc 0 δ.
+  let t₀ : Set.Icc (0 : ℝ) δ := ⟨0, Set.mem_Icc.mpr ⟨le_refl 0, le_of_lt hδ_pos⟩⟩
+  -- Assemble IsPicardLindelof.
+  have hpl : IsPicardLindelof (vlasovVectorField gradW ρ) t₀ z₀ a r_pl L_pl K_pl := by
+    refine ⟨?_, ?_, ?_, ?_⟩
+    · -- (a) lipschitzOnWith via vlasovVectorField_lipschitzWith.
+      intro t _
+      exact (vlasovVectorField_lipschitzWith gradW L hL ρ h_int t).lipschitzOnWith
+    · -- (b) continuousOn: velocity component constant in t, force continuous by hρ_cont.
+      intro x _
+      apply Continuous.continuousOn
+      simp only [vlasovVectorField]
+      exact Continuous.prodMk continuous_const (hρ_cont x.1).neg
+    · -- (c) norm_le.
+      intro t ht x hx
+      have h_norm_field := vlasovVectorField_norm_le gradW ρ t x
+      have hdist_le : dist x z₀ ≤ (a : ℝ) := hx
+      have hdist_le_norm : ‖x - z₀‖ ≤ (a : ℝ) := by rwa [dist_eq_norm] at hdist_le
+      have h_x2_proj : ‖x.2 - z₀.2‖ ≤ ‖x - z₀‖ := by
+        rw [Prod.norm_def]; exact le_max_right _ _
+      have h_x2_bound : ‖x.2‖ ≤ ‖z₀.2‖ + (a : ℝ) := by
+        have h1 : ‖x.2‖ = ‖(x.2 - z₀.2) + z₀.2‖ := by rw [sub_add_cancel]
+        have h2 : ‖(x.2 - z₀.2) + z₀.2‖ ≤ ‖x.2 - z₀.2‖ + ‖z₀.2‖ := norm_add_le _ _
+        linarith [h_x2_proj, hdist_le_norm]
+      have h_x1_proj : dist x.1 z₀.1 ≤ dist x z₀ := by
+        simp only [Prod.dist_eq]; exact le_max_left _ _
+      have h_x1_ball : x.1 ∈ Metric.closedBall z₀.1 (3 * (a : ℝ) / 2) := by
+        have hx1d : dist x.1 z₀.1 ≤ (a : ℝ) := le_trans h_x1_proj hdist_le
+        have : dist x.1 z₀.1 ≤ 3 * (a : ℝ) / 2 := by
+          have ha_nn : (0 : ℝ) ≤ (a : ℝ) := le_of_lt ha_real
+          linarith
+        exact this
+      have h_t_Icc : t ∈ Set.Icc (0 : ℝ) 1 :=
+        ⟨ht.1, le_trans ht.2 hδ_le_one⟩
+      have h_force_bound : ‖convolveFunctionMeasure gradW (ρ t) x.1‖ ≤ (M : ℝ) :=
+        hbound t h_t_Icc x.1 h_x1_ball
+      have h_Lpl_eq : (L_pl : ℝ) = ‖z₀.2‖ + (a : ℝ) + (M : ℝ) := by
+        simp [hL_pl_def, NNReal.coe_add, coe_nnnorm]
+      calc ‖vlasovVectorField gradW ρ t x‖
+          ≤ max ‖x.2‖ ‖convolveFunctionMeasure gradW (ρ t) x.1‖ := h_norm_field
+        _ ≤ (L_pl : ℝ) := by
+            rw [h_Lpl_eq]
+            apply max_le
+            · linarith [NNReal.coe_nonneg M]
+            · linarith [norm_nonneg z₀.2, NNReal.coe_nonneg a]
+    · -- (d) mul_max_le: L_pl · max(δ − 0, 0 − 0) = L_pl · δ ≤ a − a/2 = a/2.
+      show (L_pl : ℝ) * max (δ - (t₀ : ℝ)) ((t₀ : ℝ) - 0) ≤ (a : ℝ) - (r_pl : ℝ)
+      have ht₀_eq : (t₀ : ℝ) = 0 := rfl
+      simp only [ht₀_eq, sub_zero, sub_self, max_eq_left (le_of_lt hδ_pos)]
+      have h_a_minus_r : (a : ℝ) - (r_pl : ℝ) = (a : ℝ) / 2 := by
+        simp [hr_pl_def, NNReal.coe_div]
+        ring
+      rw [h_a_minus_r]
+      -- L_pl * δ ≤ a/2 since δ ≤ (a/2)/(L_pl+1) and L_pl ≤ L_pl + 1.
+      have h_Lpl_nn : (0 : ℝ) ≤ (L_pl : ℝ) := L_pl.coe_nonneg
+      have h_a_nn : (0 : ℝ) ≤ (a : ℝ) / 2 := by linarith [ha_real]
+      have h_step : (L_pl : ℝ) * δ ≤ (L_pl : ℝ) *
+          ((a : ℝ) / 2 / ((L_pl : ℝ) + 1)) :=
+        mul_le_mul_of_nonneg_left hδ_le_ratio h_Lpl_nn
+      have h_rewrite : (L_pl : ℝ) * ((a : ℝ) / 2 / ((L_pl : ℝ) + 1))
+          = (L_pl : ℝ) / ((L_pl : ℝ) + 1) * ((a : ℝ) / 2) := by ring
+      have h_frac_le : (L_pl : ℝ) / ((L_pl : ℝ) + 1) ≤ 1 := by
+        rw [div_le_one h_denom_pos]; linarith
+      have h_bound : (L_pl : ℝ) / ((L_pl : ℝ) + 1) * ((a : ℝ) / 2) ≤ (a : ℝ) / 2 := by
+        calc (L_pl : ℝ) / ((L_pl : ℝ) + 1) * ((a : ℝ) / 2)
+            ≤ 1 * ((a : ℝ) / 2) :=
+              mul_le_mul_of_nonneg_right h_frac_le h_a_nn
+          _ = (a : ℝ) / 2 := one_mul _
+      linarith [h_step, h_rewrite ▸ h_step, h_bound]
+  -- Invoke headline Picard-Lindelöf.
+  obtain ⟨α, hα⟩ := hpl.exists_forall_mem_closedBall_eq_forall_mem_Icc_hasDerivWithinAt_confined
+  -- α : PhaseSpace d → ℝ → PhaseSpace d.  Define charX, charV by projection.
+  refine ⟨δ, hδ_pos, fun t z => (α z t).1, fun t z => (α z t).2, ?_, ?_, ?_⟩
+  · -- Initial condition: α z 0 = z gives both component equalities.
+    intro z hz
+    have hz_in_r : z ∈ Metric.closedBall z₀ (r_pl : ℝ) := by
+      have hreq : (r_pl : ℝ) = (a : ℝ) / 2 := by simp [hr_pl_def, NNReal.coe_div]
+      rw [Metric.mem_closedBall] at hz ⊢
+      rw [hreq]; exact hz
+    have h_init : α z (t₀ : ℝ) = z := (hα z hz_in_r).1
+    have ht₀_eq : (t₀ : ℝ) = 0 := rfl
+    rw [ht₀_eq] at h_init
+    refine ⟨?_, ?_⟩
+    · change (α z 0).1 = z.1; rw [h_init]
+    · change (α z 0).2 = z.2; rw [h_init]
+  · -- Position ODE: HasDerivAt (charX · z) (charV t z) t.
+    intro t ht z hz
+    have hz_in_r : z ∈ Metric.closedBall z₀ (r_pl : ℝ) := by
+      have : (r_pl : ℝ) = (a : ℝ) / 2 := by simp [hr_pl_def, NNReal.coe_div]
+      rw [Metric.mem_closedBall] at hz ⊢; rw [this]; exact hz
+    have h_t_Icc : t ∈ Set.Icc (0 : ℝ) δ := ⟨le_of_lt ht.1, le_of_lt ht.2⟩
+    have h_dw := (hα z hz_in_r).2.1 t h_t_Icc
+    have h_icc_nhds : Set.Icc (0 : ℝ) δ ∈ nhds t := Icc_mem_nhds ht.1 ht.2
+    have h_d : HasDerivAt (α z) (vlasovVectorField gradW ρ t (α z t)) t :=
+      h_dw.hasDerivAt h_icc_nhds
+    have h_proj : HasDerivAt (fun s => (α z s).1)
+        (vlasovVectorField gradW ρ t (α z t)).1 t :=
+      (hasFDerivAt_fst (E := PhysSpace d) (F := PhysSpace d)).comp_hasDerivAt t h_d
+    simpa [vlasovVectorField] using h_proj
+  · -- Velocity ODE: HasDerivAt (charV · z) (−(∇W∗ρ)(charX t z)) t.
+    intro t ht z hz
+    have hz_in_r : z ∈ Metric.closedBall z₀ (r_pl : ℝ) := by
+      have : (r_pl : ℝ) = (a : ℝ) / 2 := by simp [hr_pl_def, NNReal.coe_div]
+      rw [Metric.mem_closedBall] at hz ⊢; rw [this]; exact hz
+    have h_t_Icc : t ∈ Set.Icc (0 : ℝ) δ := ⟨le_of_lt ht.1, le_of_lt ht.2⟩
+    have h_dw := (hα z hz_in_r).2.1 t h_t_Icc
+    have h_icc_nhds : Set.Icc (0 : ℝ) δ ∈ nhds t := Icc_mem_nhds ht.1 ht.2
+    have h_d : HasDerivAt (α z) (vlasovVectorField gradW ρ t (α z t)) t :=
+      h_dw.hasDerivAt h_icc_nhds
+    have h_proj : HasDerivAt (fun s => (α z s).2)
+        (vlasovVectorField gradW ρ t (α z t)).2 t :=
+      (hasFDerivAt_snd (E := PhysSpace d) (F := PhysSpace d)).comp_hasDerivAt t h_d
+    simpa [vlasovVectorField] using h_proj
+
+/-- **Per-z, time-shifted single-trajectory Picard with a uniform velocity-bound parameter.**
+
+Given a fixed phase-space point `w`, a starting time `t_start`, an a priori
+velocity bound `V_max ≥ ‖w.2‖`, and a uniform force bound around `w` on the
+time interval `[t_start, t_start + 1]`, this produces a single trajectory
+`β : ℝ → PhaseSpace d` solving the Vlasov ODE on `Ioo t_start (t_start + δ)`
+with `β t_start = w`.
+
+**Why `V_max` as a separate parameter:** the Picard contraction time δ
+depends on the norm-bound `L_pl := V_max + a + M` for the vector field on
+the local ball.  Phrasing this via an explicit `V_max ≥ ‖w.2‖` rather than
+the tight `‖w.2‖` makes δ uniform in `w` for any iteration centered at
+points `w` whose velocity component is bounded by `V_max`.  This is the
+input that lets the N-window iteration in
+`exists_vlasov_characteristicFlow` pick a single δ valid across all
+windows (by combining with the a priori bound
+`‖w_n(z).2‖ ≤ ‖z₀.2‖ + a/2 + M·(T+1)` on a finite `[0, T]`-interval).
+
+Implementation: build an IsPicardLindelof centered at `w` over `[t_start,
+t_start + δ]` with `L_pl := V_max + a + M`.  Invoke the vendored headline
+theorem.  Take the single trajectory `β t := α w t`. -/
+lemma exists_vlasov_extend_one_window
+    {d : ℕ}
+    (gradW : PhysSpace d → PhysSpace d)
+    (L : NNReal) (hL : LipschitzWith L gradW)
+    (ρ : ℝ → Measure (PhysSpace d))
+    [∀ t, IsProbabilityMeasure (ρ t)]
+    (h_int : ∀ t (x : PhysSpace d), Integrable (fun y => gradW (x - y)) (ρ t))
+    (hρ_cont : ∀ x : PhysSpace d,
+      Continuous (fun t => convolveFunctionMeasure gradW (ρ t) x))
+    (w : PhaseSpace d) (a : NNReal) (ha : 0 < a) (M : NNReal)
+    (V_max : NNReal) (hV : ‖w.2‖ ≤ (V_max : ℝ))
+    (t_start : ℝ)
+    (hbound : ∀ t ∈ Set.Icc t_start (t_start + 1),
+              ∀ x ∈ Metric.closedBall w.1 (3 * (a : ℝ) / 2),
+              ‖convolveFunctionMeasure gradW (ρ t) x‖ ≤ M) :
+    ∃ (δ : ℝ) (_ : 0 < δ) (β : ℝ → PhaseSpace d),
+      δ = min 1 ((a : ℝ) / 2 / (((V_max + a + M : NNReal) : ℝ) + 1)) ∧
+      β t_start = w ∧
+      (∀ t ∈ Set.Ioo t_start (t_start + δ),
+        HasDerivAt (fun s => (β s).1) (β t).2 t ∧
+        HasDerivAt (fun s => (β s).2)
+          (-(convolveFunctionMeasure gradW (ρ t) (β t).1)) t) ∧
+      (∀ t ∈ Set.Icc t_start (t_start + δ),
+        HasDerivWithinAt (fun s => (β s).1) (β t).2
+          (Set.Icc t_start (t_start + δ)) t ∧
+        HasDerivWithinAt (fun s => (β s).2)
+          (-(convolveFunctionMeasure gradW (ρ t) (β t).1))
+          (Set.Icc t_start (t_start + δ)) t) ∧
+      (∀ s ∈ Set.Icc t_start (t_start + δ), β s ∈ Metric.closedBall w (a : ℝ)) := by
+  classical
+  set K_pl : NNReal := max 1 L with hK_pl_def
+  set r_pl : NNReal := a / 2 with hr_pl_def
+  set L_pl : NNReal := V_max + a + M with hL_pl_def
+  set δ : ℝ := min 1 ((a : ℝ) / 2 / ((L_pl : ℝ) + 1)) with hδ_def
+  have ha_real : (0 : ℝ) < (a : ℝ) := by exact_mod_cast ha
+  have h_denom_pos : (0 : ℝ) < (L_pl : ℝ) + 1 := by positivity
+  have h_ratio_pos : (0 : ℝ) < (a : ℝ) / 2 / ((L_pl : ℝ) + 1) := by positivity
+  have hδ_pos : (0 : ℝ) < δ := lt_min one_pos h_ratio_pos
+  have hδ_le_one : δ ≤ 1 := min_le_left _ _
+  have hδ_le_ratio : δ ≤ (a : ℝ) / 2 / ((L_pl : ℝ) + 1) := min_le_right _ _
+  let t₀ : Set.Icc t_start (t_start + δ) :=
+    ⟨t_start, Set.mem_Icc.mpr ⟨le_refl _, by linarith⟩⟩
+  have hpl : IsPicardLindelof (vlasovVectorField gradW ρ) t₀ w a r_pl L_pl K_pl := by
+    refine ⟨?_, ?_, ?_, ?_⟩
+    · intro t _
+      exact (vlasovVectorField_lipschitzWith gradW L hL ρ h_int t).lipschitzOnWith
+    · intro x _
+      apply Continuous.continuousOn
+      simp only [vlasovVectorField]
+      exact Continuous.prodMk continuous_const (hρ_cont x.1).neg
+    · intro t ht x hx
+      have h_norm_field := vlasovVectorField_norm_le gradW ρ t x
+      have hdist_le : dist x w ≤ (a : ℝ) := hx
+      have hdist_le_norm : ‖x - w‖ ≤ (a : ℝ) := by rwa [dist_eq_norm] at hdist_le
+      have h_x2_proj : ‖x.2 - w.2‖ ≤ ‖x - w‖ := by
+        rw [Prod.norm_def]; exact le_max_right _ _
+      have h_x2_bound : ‖x.2‖ ≤ ‖w.2‖ + (a : ℝ) := by
+        have h1 : ‖x.2‖ = ‖(x.2 - w.2) + w.2‖ := by rw [sub_add_cancel]
+        have h2 : ‖(x.2 - w.2) + w.2‖ ≤ ‖x.2 - w.2‖ + ‖w.2‖ := norm_add_le _ _
+        linarith [h_x2_proj, hdist_le_norm]
+      have h_x1_proj : dist x.1 w.1 ≤ dist x w := by
+        simp only [Prod.dist_eq]; exact le_max_left _ _
+      have h_x1_ball : x.1 ∈ Metric.closedBall w.1 (3 * (a : ℝ) / 2) := by
+        rw [Metric.mem_closedBall]
+        have hx1d : dist x.1 w.1 ≤ (a : ℝ) := le_trans h_x1_proj hdist_le
+        have ha_nn : (0 : ℝ) ≤ (a : ℝ) := le_of_lt ha_real
+        linarith
+      have h_t_Icc : t ∈ Set.Icc t_start (t_start + 1) :=
+        ⟨ht.1, le_trans ht.2 (by linarith [hδ_le_one])⟩
+      have h_force_bound : ‖convolveFunctionMeasure gradW (ρ t) x.1‖ ≤ (M : ℝ) :=
+        hbound t h_t_Icc x.1 h_x1_ball
+      have h_Lpl_eq : (L_pl : ℝ) = (V_max : ℝ) + (a : ℝ) + (M : ℝ) := by
+        simp [hL_pl_def, NNReal.coe_add]
+      have h_x2_bound' : ‖x.2‖ ≤ (V_max : ℝ) + (a : ℝ) :=
+        le_trans h_x2_bound (by linarith [hV])
+      calc ‖vlasovVectorField gradW ρ t x‖
+          ≤ max ‖x.2‖ ‖convolveFunctionMeasure gradW (ρ t) x.1‖ := h_norm_field
+        _ ≤ (L_pl : ℝ) := by
+            rw [h_Lpl_eq]
+            apply max_le
+            · linarith [NNReal.coe_nonneg M, h_x2_bound']
+            · linarith [norm_nonneg w.2, NNReal.coe_nonneg a, NNReal.coe_nonneg V_max]
+    · show (L_pl : ℝ) * max ((t_start + δ) - (t₀ : ℝ)) ((t₀ : ℝ) - t_start)
+          ≤ (a : ℝ) - (r_pl : ℝ)
+      have ht₀_eq : (t₀ : ℝ) = t_start := rfl
+      simp only [ht₀_eq, add_sub_cancel_left, sub_self, max_eq_left (le_of_lt hδ_pos)]
+      have h_a_minus_r : (a : ℝ) - (r_pl : ℝ) = (a : ℝ) / 2 := by
+        simp [hr_pl_def, NNReal.coe_div]; ring
+      rw [h_a_minus_r]
+      have h_Lpl_nn : (0 : ℝ) ≤ (L_pl : ℝ) := L_pl.coe_nonneg
+      have h_a_nn : (0 : ℝ) ≤ (a : ℝ) / 2 := by linarith [ha_real]
+      have h_step : (L_pl : ℝ) * δ ≤ (L_pl : ℝ) *
+          ((a : ℝ) / 2 / ((L_pl : ℝ) + 1)) :=
+        mul_le_mul_of_nonneg_left hδ_le_ratio h_Lpl_nn
+      have h_rewrite : (L_pl : ℝ) * ((a : ℝ) / 2 / ((L_pl : ℝ) + 1))
+          = (L_pl : ℝ) / ((L_pl : ℝ) + 1) * ((a : ℝ) / 2) := by ring
+      have h_frac_le : (L_pl : ℝ) / ((L_pl : ℝ) + 1) ≤ 1 := by
+        rw [div_le_one h_denom_pos]; linarith
+      have h_bound : (L_pl : ℝ) / ((L_pl : ℝ) + 1) * ((a : ℝ) / 2) ≤ (a : ℝ) / 2 := by
+        calc (L_pl : ℝ) / ((L_pl : ℝ) + 1) * ((a : ℝ) / 2)
+            ≤ 1 * ((a : ℝ) / 2) :=
+              mul_le_mul_of_nonneg_right h_frac_le h_a_nn
+          _ = (a : ℝ) / 2 := one_mul _
+      linarith [h_step, h_rewrite ▸ h_step, h_bound]
+  obtain ⟨α, hα⟩ := hpl.exists_forall_mem_closedBall_eq_forall_mem_Icc_hasDerivWithinAt_confined
+  have hw_in_r : w ∈ Metric.closedBall w ((r_pl : ℝ)) := by
+    rw [Metric.mem_closedBall, dist_self]
+    exact r_pl.coe_nonneg
+  have hα_w := hα w hw_in_r
+  refine ⟨δ, hδ_pos, fun t => α w t, ?_, ?_, ?_, ?_, ?_⟩
+  · rfl
+  · have h_init : α w (t₀ : ℝ) = w := hα_w.1
+    have ht₀_eq : (t₀ : ℝ) = t_start := rfl
+    rw [ht₀_eq] at h_init
+    exact h_init
+  · intro t ht
+    have h_t_Icc : t ∈ Set.Icc t_start (t_start + δ) :=
+      ⟨le_of_lt ht.1, le_of_lt ht.2⟩
+    have h_dw := hα_w.2.1 t h_t_Icc
+    have h_icc_nhds : Set.Icc t_start (t_start + δ) ∈ nhds t := Icc_mem_nhds ht.1 ht.2
+    have h_d : HasDerivAt (α w) (vlasovVectorField gradW ρ t (α w t)) t :=
+      h_dw.hasDerivAt h_icc_nhds
+    refine ⟨?_, ?_⟩
+    · have h_proj : HasDerivAt (fun s => (α w s).1)
+          (vlasovVectorField gradW ρ t (α w t)).1 t :=
+        (hasFDerivAt_fst (E := PhysSpace d) (F := PhysSpace d)).comp_hasDerivAt t h_d
+      simpa [vlasovVectorField] using h_proj
+    · have h_proj : HasDerivAt (fun s => (α w s).2)
+          (vlasovVectorField gradW ρ t (α w t)).2 t :=
+        (hasFDerivAt_snd (E := PhysSpace d) (F := PhysSpace d)).comp_hasDerivAt t h_d
+      simpa [vlasovVectorField] using h_proj
+  · intro t ht
+    have h_dw := hα_w.2.1 t ht
+    refine ⟨?_, ?_⟩
+    · have h_proj : HasDerivWithinAt (fun s => (α w s).1)
+          (vlasovVectorField gradW ρ t (α w t)).1
+          (Set.Icc t_start (t_start + δ)) t :=
+        (hasFDerivAt_fst (E := PhysSpace d) (F := PhysSpace d)).comp_hasDerivWithinAt t h_dw
+      simpa [vlasovVectorField] using h_proj
+    · have h_proj : HasDerivWithinAt (fun s => (α w s).2)
+          (vlasovVectorField gradW ρ t (α w t)).2
+          (Set.Icc t_start (t_start + δ)) t :=
+        (hasFDerivAt_snd (E := PhysSpace d) (F := PhysSpace d)).comp_hasDerivWithinAt t h_dw
+      simpa [vlasovVectorField] using h_proj
+  · -- confinement: β s ∈ closedBall w a (delivered by `_confined` variant)
+    intro s hs
+    exact hα_w.2.2 s hs
+
+/-! ### Per-window helpers for the N-window induction in
+    `exists_vlasov_characteristicFlow`.
+
+    These three top-level lemmas are generic in `(β, ODE, confinement,
+    field bound, IH bound, reference point)` with no mention of the
+    N-window induction context (no `γ_k`, `k`, `N`, `z₀`).  This
+    genericity gives each helper its own elaboration budget AND makes
+    them composable for future call sites — the Lagrangian → Eulerian
+    chain rule, well-posedness's Banach iteration, etc.
+
+    Composition order: Helper 1 (confinement) → Helper 2 (window-wide
+    velocity bound) → Helper 3 (endpoint position bound).
+-/
+
+/-- **Helper 1: Picard window confinement (projection from phase-space ball).**
+
+For a trajectory β satisfying the Vlasov ODE on a Picard window
+`[t_start, t_start + δ]` centered at `w`, the position component
+stays within the local force-bound ball:
+`(β s).1 ∈ closedBall w.1 (3a/2)` for `s` in the window.
+
+**Argument.**  The strengthened Picard-Lindelöf theorem
+`exists_forall_mem_closedBall_eq_forall_mem_Icc_hasDerivWithinAt_confined`
+(`LeanPool.Vlasov.ForMathlib.PicardLindelof`) exposes
+`FunSpace.compProj_mem_closedBall` at the public theorem level,
+delivering `β s ∈ closedBall w a` (phase-space ball of radius `a` —
+the outer Lipschitz radius) as a side product of the existence
+guarantee.  We project this to the position component via
+`Prod.dist_eq` + `le_max_left`, then loosen `a ≤ 3a/2` by arithmetic.
+The result is a 3-5 line projection.
+
+**Hypothesis `hβ_confined`** is supplied by Vlasov-side callers from
+the widened `exists_vlasov_extend_one_window` output.  The other
+hypotheses (ODE, field
+bound, contraction inequality) are retained for genericity / call
+site compatibility; they are not consumed by the projection body but
+remain available for future call sites that want to re-derive the
+confinement directly (e.g. via supremum trick) without invoking
+the vendored Mathlib API. -/
+lemma vlasov_window_confinement
+    {d : ℕ}
+    (gradW : PhysSpace d → PhysSpace d)
+    (L : NNReal) (_hL : LipschitzWith L gradW)
+    (ρ : ℝ → Measure (PhysSpace d))
+    (_h_int : ∀ t (x : PhysSpace d), Integrable (fun y => gradW (x - y)) (ρ t))
+    (_hρ_cont : ∀ x : PhysSpace d,
+      Continuous (fun t => convolveFunctionMeasure gradW (ρ t) x))
+    (w : PhaseSpace d) (a : NNReal) (_ha : 0 < a) (M : NNReal)
+    (V_max : NNReal) (_hV : ‖w.2‖ ≤ (V_max : ℝ))
+    (t_start δ : ℝ) (_hδ_pos : 0 < δ) (_hδ_le_one : δ ≤ 1)
+    (_hδ_contract : δ ≤ (a : ℝ) / 2 / (((V_max + a + M : NNReal) : ℝ) + 1))
+    (_hbound : ∀ t ∈ Set.Icc t_start (t_start + 1),
+              ∀ x ∈ Metric.closedBall w.1 (3 * (a : ℝ) / 2),
+              ‖convolveFunctionMeasure gradW (ρ t) x‖ ≤ M)
+    (β : ℝ → PhaseSpace d) (_hβ_init : β t_start = w)
+    (_hβ_ode_Icc : ∀ t ∈ Set.Icc t_start (t_start + δ),
+      HasDerivWithinAt (fun s => (β s).1) (β t).2
+        (Set.Icc t_start (t_start + δ)) t ∧
+      HasDerivWithinAt (fun s => (β s).2)
+        (-(convolveFunctionMeasure gradW (ρ t) (β t).1))
+        (Set.Icc t_start (t_start + δ)) t)
+    (hβ_confined : ∀ s ∈ Set.Icc t_start (t_start + δ),
+      β s ∈ Metric.closedBall w (a : ℝ)) :
+    ∀ s ∈ Set.Icc t_start (t_start + δ),
+      (β s).1 ∈ Metric.closedBall w.1 (3 * (a : ℝ) / 2) := by
+  intro s hs
+  have h_phase : β s ∈ Metric.closedBall w (a : ℝ) := hβ_confined s hs
+  rw [Metric.mem_closedBall] at h_phase ⊢
+  -- dist (β s).1 w.1 ≤ dist (β s) w ≤ a ≤ 3a/2
+  have h_proj : dist (β s).1 w.1 ≤ dist (β s) w := by
+    rw [Prod.dist_eq]; exact le_max_left _ _
+  have h_a_nn : (0 : ℝ) ≤ (a : ℝ) := a.coe_nonneg
+  linarith
+
+/-- **Helper 2: Window-wide velocity bound.**
+
+For a trajectory β with velocity-component ODE
+`(β · ).2' = -(∇W ∗ ρ_·)((β ·).1)` on `[t_start, t_start + δ]` and
+force bound M (made applicable by `h_β_in_ball`), the velocity at
+every interior `s` is bounded by `h_vel_init + M · (s - t_start)`.
+
+**Math sketch.**  One application of
+`Convex.norm_image_sub_le_of_norm_hasDerivWithin_le` on `(β · ).2`
+over the convex window `Icc t_start (t_start + δ)`, with `y := s`
+universally quantified:
+  `‖(β s).2 - (β t_start).2‖ ≤ M · ‖s - t_start‖ = M · (s - t_start)`.
+Triangle with `‖(β t_start).2‖ = ‖w.2‖ ≤ h_vel_init` (using `hβ_init`)
+gives the conclusion.
+
+The universal quantification over `y` in the mean-value lemma is what
+makes this WINDOW-WIDE from ONE invocation — no per-s re-application. -/
+lemma vlasov_window_velocity_bound
+    {d : ℕ}
+    (gradW : PhysSpace d → PhysSpace d)
+    (ρ : ℝ → Measure (PhysSpace d))
+    (w : PhaseSpace d) (a : NNReal) (M : NNReal)
+    (t_start δ : ℝ) (hδ_pos : 0 < δ) (hδ_le_one : δ ≤ 1)
+    (h_vel_init : ℝ) (hβ_init_vel_bound : ‖w.2‖ ≤ h_vel_init)
+    (β : ℝ → PhaseSpace d) (hβ_init : β t_start = w)
+    (hβ_ode_Icc : ∀ t ∈ Set.Icc t_start (t_start + δ),
+      HasDerivWithinAt (fun s => (β s).2)
+        (-(convolveFunctionMeasure gradW (ρ t) (β t).1))
+        (Set.Icc t_start (t_start + δ)) t)
+    (h_β_in_ball : ∀ s ∈ Set.Icc t_start (t_start + δ),
+      (β s).1 ∈ Metric.closedBall w.1 (3 * (a : ℝ) / 2))
+    (hbound : ∀ t ∈ Set.Icc t_start (t_start + 1),
+              ∀ x ∈ Metric.closedBall w.1 (3 * (a : ℝ) / 2),
+              ‖convolveFunctionMeasure gradW (ρ t) x‖ ≤ M) :
+    ∀ s ∈ Set.Icc t_start (t_start + δ),
+      ‖(β s).2‖ ≤ h_vel_init + (M : ℝ) * (s - t_start) := by
+  intro s hs
+  -- Convexity of the window.
+  have h_convex : Convex ℝ (Set.Icc t_start (t_start + δ)) := convex_Icc _ _
+  have h_t_start_in : t_start ∈ Set.Icc t_start (t_start + δ) :=
+    ⟨le_refl _, by linarith⟩
+  -- Force bound on the window (via h_β_in_ball).
+  have h_force_window : ∀ u ∈ Set.Icc t_start (t_start + δ),
+      ‖-(convolveFunctionMeasure gradW (ρ u) (β u).1)‖ ≤ (M : ℝ) := by
+    intro u hu
+    rw [norm_neg]
+    have hu_time : u ∈ Set.Icc t_start (t_start + 1) :=
+      ⟨hu.1, le_trans hu.2 (by linarith [hδ_le_one])⟩
+    exact hbound u hu_time (β u).1 (h_β_in_ball u hu)
+  -- Velocity ODE on the window.
+  have h_vel_ode : ∀ u ∈ Set.Icc t_start (t_start + δ),
+      HasDerivWithinAt (fun v => (β v).2)
+        (-(convolveFunctionMeasure gradW (ρ u) (β u).1))
+        (Set.Icc t_start (t_start + δ)) u :=
+    fun u hu => hβ_ode_Icc u hu
+  -- Apply Convex.norm_image_sub_le with x := t_start, y := s.
+  have h_mv : ‖(β s).2 - (β t_start).2‖ ≤ (M : ℝ) * ‖s - t_start‖ :=
+    h_convex.norm_image_sub_le_of_norm_hasDerivWithin_le
+      h_vel_ode h_force_window h_t_start_in hs
+  have h_diff_nn : 0 ≤ s - t_start := by linarith [hs.1]
+  rw [Real.norm_of_nonneg h_diff_nn] at h_mv
+  -- β t_start = w, so (β t_start).2 = w.2.
+  have h_β_t_start_vel : (β t_start).2 = w.2 := by rw [hβ_init]
+  -- Triangle: ‖(β s).2‖ ≤ ‖(β s).2 - (β t_start).2‖ + ‖(β t_start).2‖.
+  have h_decomp : (β s).2 = ((β s).2 - (β t_start).2) + (β t_start).2 :=
+    (sub_add_cancel _ _).symm
+  have h_triangle : ‖(β s).2‖
+      ≤ ‖(β s).2 - (β t_start).2‖ + ‖(β t_start).2‖ := by
+    calc ‖(β s).2‖ = ‖((β s).2 - (β t_start).2) + (β t_start).2‖ := by rw [← h_decomp]
+      _ ≤ _ := norm_add_le _ _
+  -- Combine: ‖(β s).2‖ ≤ M·(s - t_start) + ‖w.2‖ ≤ h_vel_init + M·(s - t_start).
+  rw [h_β_t_start_vel] at h_triangle
+  -- h_mv has `(β t_start).2`; rewrite to `w.2` for compatibility.
+  rw [h_β_t_start_vel] at h_mv
+  linarith [h_mv, hβ_init_vel_bound]
+
+/-- **Helper 3: Window endpoint position bound.**
+
+For a trajectory β with position-component ODE
+`(β · ).1' = (β · ).2` on `[t_start, t_start + δ]` and a uniform
+velocity bound `V_bound` (typically Helper 2's output composed with
+a worst-case substitution), the position at `t_start + δ` is bounded
+relative to an explicit reference point `x_ref`:
+  `‖(β (t_start + δ)).1 - x_ref‖ ≤ h_pos_init + V_bound · δ`
+where `h_pos_init ≥ ‖w.1 - x_ref‖`.
+
+**Math sketch.**  One application of
+`Convex.norm_image_sub_le_of_norm_hasDerivWithin_le` on `(β · ).1`
+over the convex window with `x := t_start`, `y := t_start + δ`:
+  `‖(β (t_start + δ)).1 - (β t_start).1‖ ≤ V_bound · δ` (using
+  `hβ_init` for `(β t_start).1 = w.1`).
+Triangle with `‖w.1 - x_ref‖ ≤ h_pos_init` gives the conclusion.
+
+**Genericity.**  `x_ref : PhysSpace d` is an explicit parameter, NOT
+hardcoded to the N-window induction's `z₀.1`.  This makes the helper
+reusable for the Lagrangian → Eulerian chain rule (reference point:
+support of test function φ), well-posedness's Banach iteration
+(reference point: fixed-point candidate), etc. -/
+lemma vlasov_window_position_bound
+    {d : ℕ}
+    (_gradW : PhysSpace d → PhysSpace d)
+    (_ρ : ℝ → Measure (PhysSpace d))
+    (w : PhaseSpace d)
+    (t_start δ : ℝ) (hδ_pos : 0 < δ)
+    (V_bound : ℝ)
+    (x_ref : PhysSpace d)
+    (h_pos_init : ℝ) (hβ_init_pos_bound : ‖w.1 - x_ref‖ ≤ h_pos_init)
+    (β : ℝ → PhaseSpace d) (hβ_init : β t_start = w)
+    (hβ_ode_Icc : ∀ t ∈ Set.Icc t_start (t_start + δ),
+      HasDerivWithinAt (fun s => (β s).1) (β t).2
+        (Set.Icc t_start (t_start + δ)) t)
+    (h_window_vel : ∀ s ∈ Set.Icc t_start (t_start + δ),
+      ‖(β s).2‖ ≤ V_bound) :
+    ‖(β (t_start + δ)).1 - x_ref‖ ≤ h_pos_init + V_bound * δ := by
+  -- Convexity of the window.
+  have h_convex : Convex ℝ (Set.Icc t_start (t_start + δ)) := convex_Icc _ _
+  have h_t_start_in : t_start ∈ Set.Icc t_start (t_start + δ) :=
+    ⟨le_refl _, by linarith⟩
+  have h_t_end_in : t_start + δ ∈ Set.Icc t_start (t_start + δ) :=
+    ⟨by linarith, le_refl _⟩
+  -- Position ODE on the window.
+  have h_pos_ode : ∀ u ∈ Set.Icc t_start (t_start + δ),
+      HasDerivWithinAt (fun v => (β v).1) (β u).2
+        (Set.Icc t_start (t_start + δ)) u :=
+    fun u hu => hβ_ode_Icc u hu
+  -- Apply Convex.norm_image_sub_le with x := t_start, y := t_start + δ.
+  have h_mv : ‖(β (t_start + δ)).1 - (β t_start).1‖
+              ≤ V_bound * ‖(t_start + δ) - t_start‖ :=
+    h_convex.norm_image_sub_le_of_norm_hasDerivWithin_le
+      h_pos_ode h_window_vel h_t_start_in h_t_end_in
+  have h_δ_eq : (t_start + δ) - t_start = δ := by ring
+  rw [h_δ_eq, Real.norm_of_nonneg (le_of_lt hδ_pos)] at h_mv
+  -- β t_start = w, so (β t_start).1 = w.1.
+  have h_β_t_start_pos : (β t_start).1 = w.1 := by rw [hβ_init]
+  rw [h_β_t_start_pos] at h_mv
+  -- Triangle: ‖(β (t_start+δ)).1 - x_ref‖
+  --        ≤ ‖(β (t_start+δ)).1 - w.1‖ + ‖w.1 - x_ref‖
+  --        ≤ V_bound · δ + h_pos_init.
+  have h_decomp : (β (t_start + δ)).1 - x_ref
+                = ((β (t_start + δ)).1 - w.1) + (w.1 - x_ref) := by
+    rw [sub_add_sub_cancel]
+  have h_triangle : ‖(β (t_start + δ)).1 - x_ref‖
+      ≤ ‖(β (t_start + δ)).1 - w.1‖ + ‖w.1 - x_ref‖ := by
+    calc ‖(β (t_start + δ)).1 - x_ref‖
+        = ‖((β (t_start + δ)).1 - w.1) + (w.1 - x_ref)‖ := by rw [← h_decomp]
+      _ ≤ _ := norm_add_le _ _
+  linarith [h_mv, hβ_init_pos_bound]
+
+/-- **Tight per-window Picard with an EXPLICIT step δ and an ADAPTIVE force-window.**
+
+Tight form of `exists_vlasov_extend_one_window`: the force bound is required
+only on `[t_start, t_start + δ]` (the actual step), not the loose unit window
+`[t_start, t_start + 1]`, and `δ` is supplied by the caller (so the N-window
+chain can tile exactly, `N·δ = T`, dissolving the `(T+1)²` → `T²` smallness). -/
+lemma exists_vlasov_extend_one_window_tight
+    {d : ℕ}
+    (gradW : PhysSpace d → PhysSpace d)
+    (L : NNReal) (hL : LipschitzWith L gradW)
+    (ρ : ℝ → Measure (PhysSpace d))
+    [∀ t, IsProbabilityMeasure (ρ t)]
+    (h_int : ∀ t (x : PhysSpace d), Integrable (fun y => gradW (x - y)) (ρ t))
+    (hρ_cont : ∀ x : PhysSpace d,
+      Continuous (fun t => convolveFunctionMeasure gradW (ρ t) x))
+    (w : PhaseSpace d) (a : NNReal) (ha : 0 < a) (M : NNReal)
+    (V_max : NNReal) (hV : ‖w.2‖ ≤ (V_max : ℝ))
+    (t_start : ℝ)
+    (δ : ℝ) (hδ_pos : 0 < δ)
+    (hδ_le : δ ≤ (a : ℝ) / 2 / (((V_max + a + M : NNReal) : ℝ) + 1))
+    (hbound : ∀ t ∈ Set.Icc t_start (t_start + δ),
+              ∀ x ∈ Metric.closedBall w.1 (3 * (a : ℝ) / 2),
+              ‖convolveFunctionMeasure gradW (ρ t) x‖ ≤ M) :
+    ∃ β : ℝ → PhaseSpace d,
+      β t_start = w ∧
+      (∀ t ∈ Set.Ioo t_start (t_start + δ),
+        HasDerivAt (fun s => (β s).1) (β t).2 t ∧
+        HasDerivAt (fun s => (β s).2)
+          (-(convolveFunctionMeasure gradW (ρ t) (β t).1)) t) ∧
+      (∀ t ∈ Set.Icc t_start (t_start + δ),
+        HasDerivWithinAt (fun s => (β s).1) (β t).2
+          (Set.Icc t_start (t_start + δ)) t ∧
+        HasDerivWithinAt (fun s => (β s).2)
+          (-(convolveFunctionMeasure gradW (ρ t) (β t).1))
+          (Set.Icc t_start (t_start + δ)) t) ∧
+      (∀ s ∈ Set.Icc t_start (t_start + δ), β s ∈ Metric.closedBall w (a : ℝ)) := by
+  classical
+  set K_pl : NNReal := max 1 L with hK_pl_def
+  set r_pl : NNReal := a / 2 with hr_pl_def
+  set L_pl : NNReal := V_max + a + M with hL_pl_def
+  have ha_real : (0 : ℝ) < (a : ℝ) := by exact_mod_cast ha
+  have h_denom_pos : (0 : ℝ) < (L_pl : ℝ) + 1 := by positivity
+  have hδ_le_ratio : δ ≤ (a : ℝ) / 2 / ((L_pl : ℝ) + 1) := hδ_le
+  let t₀ : Set.Icc t_start (t_start + δ) :=
+    ⟨t_start, Set.mem_Icc.mpr ⟨le_refl _, by linarith⟩⟩
+  have hpl : IsPicardLindelof (vlasovVectorField gradW ρ) t₀ w a r_pl L_pl K_pl := by
+    refine ⟨?_, ?_, ?_, ?_⟩
+    · intro t _
+      exact (vlasovVectorField_lipschitzWith gradW L hL ρ h_int t).lipschitzOnWith
+    · intro x _
+      apply Continuous.continuousOn
+      simp only [vlasovVectorField]
+      exact Continuous.prodMk continuous_const (hρ_cont x.1).neg
+    · intro t ht x hx
+      have h_norm_field := vlasovVectorField_norm_le gradW ρ t x
+      have hdist_le : dist x w ≤ (a : ℝ) := hx
+      have hdist_le_norm : ‖x - w‖ ≤ (a : ℝ) := by rwa [dist_eq_norm] at hdist_le
+      have h_x2_proj : ‖x.2 - w.2‖ ≤ ‖x - w‖ := by
+        rw [Prod.norm_def]; exact le_max_right _ _
+      have h_x2_bound : ‖x.2‖ ≤ ‖w.2‖ + (a : ℝ) := by
+        have h1 : ‖x.2‖ = ‖(x.2 - w.2) + w.2‖ := by rw [sub_add_cancel]
+        have h2 : ‖(x.2 - w.2) + w.2‖ ≤ ‖x.2 - w.2‖ + ‖w.2‖ := norm_add_le _ _
+        linarith [h_x2_proj, hdist_le_norm]
+      have h_x1_proj : dist x.1 w.1 ≤ dist x w := by
+        simp only [Prod.dist_eq]; exact le_max_left _ _
+      have h_x1_ball : x.1 ∈ Metric.closedBall w.1 (3 * (a : ℝ) / 2) := by
+        rw [Metric.mem_closedBall]
+        have hx1d : dist x.1 w.1 ≤ (a : ℝ) := le_trans h_x1_proj hdist_le
+        have ha_nn : (0 : ℝ) ≤ (a : ℝ) := le_of_lt ha_real
+        linarith
+      have h_force_bound : ‖convolveFunctionMeasure gradW (ρ t) x.1‖ ≤ (M : ℝ) :=
+        hbound t ht x.1 h_x1_ball
+      have h_Lpl_eq : (L_pl : ℝ) = (V_max : ℝ) + (a : ℝ) + (M : ℝ) := by
+        simp [hL_pl_def, NNReal.coe_add]
+      have h_x2_bound' : ‖x.2‖ ≤ (V_max : ℝ) + (a : ℝ) :=
+        le_trans h_x2_bound (by linarith [hV])
+      calc ‖vlasovVectorField gradW ρ t x‖
+          ≤ max ‖x.2‖ ‖convolveFunctionMeasure gradW (ρ t) x.1‖ := h_norm_field
+        _ ≤ (L_pl : ℝ) := by
+            rw [h_Lpl_eq]
+            apply max_le
+            · linarith [NNReal.coe_nonneg M, h_x2_bound']
+            · linarith [norm_nonneg w.2, NNReal.coe_nonneg a, NNReal.coe_nonneg V_max]
+    · show (L_pl : ℝ) * max ((t_start + δ) - (t₀ : ℝ)) ((t₀ : ℝ) - t_start)
+          ≤ (a : ℝ) - (r_pl : ℝ)
+      have ht₀_eq : (t₀ : ℝ) = t_start := rfl
+      simp only [ht₀_eq, add_sub_cancel_left, sub_self, max_eq_left (le_of_lt hδ_pos)]
+      have h_a_minus_r : (a : ℝ) - (r_pl : ℝ) = (a : ℝ) / 2 := by
+        simp [hr_pl_def, NNReal.coe_div]; ring
+      rw [h_a_minus_r]
+      have h_Lpl_nn : (0 : ℝ) ≤ (L_pl : ℝ) := L_pl.coe_nonneg
+      have h_a_nn : (0 : ℝ) ≤ (a : ℝ) / 2 := by linarith [ha_real]
+      have h_step : (L_pl : ℝ) * δ ≤ (L_pl : ℝ) *
+          ((a : ℝ) / 2 / ((L_pl : ℝ) + 1)) :=
+        mul_le_mul_of_nonneg_left hδ_le_ratio h_Lpl_nn
+      have h_rewrite : (L_pl : ℝ) * ((a : ℝ) / 2 / ((L_pl : ℝ) + 1))
+          = (L_pl : ℝ) / ((L_pl : ℝ) + 1) * ((a : ℝ) / 2) := by ring
+      have h_frac_le : (L_pl : ℝ) / ((L_pl : ℝ) + 1) ≤ 1 := by
+        rw [div_le_one h_denom_pos]; linarith
+      have h_bound : (L_pl : ℝ) / ((L_pl : ℝ) + 1) * ((a : ℝ) / 2) ≤ (a : ℝ) / 2 := by
+        calc (L_pl : ℝ) / ((L_pl : ℝ) + 1) * ((a : ℝ) / 2)
+            ≤ 1 * ((a : ℝ) / 2) :=
+              mul_le_mul_of_nonneg_right h_frac_le h_a_nn
+          _ = (a : ℝ) / 2 := one_mul _
+      linarith [h_step, h_rewrite ▸ h_step, h_bound]
+  obtain ⟨α, hα⟩ := hpl.exists_forall_mem_closedBall_eq_forall_mem_Icc_hasDerivWithinAt_confined
+  have hw_in_r : w ∈ Metric.closedBall w ((r_pl : ℝ)) := by
+    rw [Metric.mem_closedBall, dist_self]
+    exact r_pl.coe_nonneg
+  have hα_w := hα w hw_in_r
+  refine ⟨fun t => α w t, ?_, ?_, ?_, ?_⟩
+  · have h_init : α w (t₀ : ℝ) = w := hα_w.1
+    have ht₀_eq : (t₀ : ℝ) = t_start := rfl
+    rw [ht₀_eq] at h_init
+    exact h_init
+  · intro t ht
+    have h_t_Icc : t ∈ Set.Icc t_start (t_start + δ) :=
+      ⟨le_of_lt ht.1, le_of_lt ht.2⟩
+    have h_dw := hα_w.2.1 t h_t_Icc
+    have h_icc_nhds : Set.Icc t_start (t_start + δ) ∈ nhds t := Icc_mem_nhds ht.1 ht.2
+    have h_d : HasDerivAt (α w) (vlasovVectorField gradW ρ t (α w t)) t :=
+      h_dw.hasDerivAt h_icc_nhds
+    refine ⟨?_, ?_⟩
+    · have h_proj : HasDerivAt (fun s => (α w s).1)
+          (vlasovVectorField gradW ρ t (α w t)).1 t :=
+        (hasFDerivAt_fst (E := PhysSpace d) (F := PhysSpace d)).comp_hasDerivAt t h_d
+      simpa [vlasovVectorField] using h_proj
+    · have h_proj : HasDerivAt (fun s => (α w s).2)
+          (vlasovVectorField gradW ρ t (α w t)).2 t :=
+        (hasFDerivAt_snd (E := PhysSpace d) (F := PhysSpace d)).comp_hasDerivAt t h_d
+      simpa [vlasovVectorField] using h_proj
+  · intro t ht
+    have h_dw := hα_w.2.1 t ht
+    refine ⟨?_, ?_⟩
+    · have h_proj : HasDerivWithinAt (fun s => (α w s).1)
+          (vlasovVectorField gradW ρ t (α w t)).1
+          (Set.Icc t_start (t_start + δ)) t :=
+        (hasFDerivAt_fst (E := PhysSpace d) (F := PhysSpace d)).comp_hasDerivWithinAt t h_dw
+      simpa [vlasovVectorField] using h_proj
+    · have h_proj : HasDerivWithinAt (fun s => (α w s).2)
+          (vlasovVectorField gradW ρ t (α w t)).2
+          (Set.Icc t_start (t_start + δ)) t :=
+        (hasFDerivAt_snd (E := PhysSpace d) (F := PhysSpace d)).comp_hasDerivWithinAt t h_dw
+      simpa [vlasovVectorField] using h_proj
+  · intro s hs
+    exact hα_w.2.2 s hs
+
+/-- On the degenerate interval `Icc c c`, every function trivially has every
+within-derivative at `c` (the point is not an accumulation point of the
+singleton).  Serves the `T = 0` branch and the tiling base case of the tight
+flow construction. -/
+private lemma hasDerivWithinAt_Icc_self {E : Type*}
+    [NormedAddCommGroup E] [NormedSpace ℝ E]
+    (f : ℝ → E) (v : E) (c : ℝ) :
+    HasDerivWithinAt f v (Set.Icc c c) c := by
+  have h_notAccPt : ¬ AccPt c (Filter.principal (Set.Icc c c)) := by
+    rw [accPt_iff_clusterPt, Filter.inf_principal]
+    simp [ClusterPt, Set.Icc_self]
+  rw [hasDerivWithinAt_iff_hasFDerivWithinAt]
+  exact HasFDerivWithinAt.of_not_accPt h_notAccPt
+
+/-- Adaptive-window force bound for the tight tiling: on any window
+`[c, c + δ] ⊆ [0, T]` whose entry position `p` satisfies the linear drift
+invariant `‖p - z₀.1‖ ≤ a/2 + V_max·c`, the global `hbound` (radius `R` from
+the tight `hR`) restricts to the moving ball `closedBall p (3a/2)`. -/
+private lemma charFlowTight_window_forceBound
+    {d : ℕ}
+    (gradW : PhysSpace d → PhysSpace d)
+    (ρ : ℝ → Measure (PhysSpace d))
+    (z₀ : PhaseSpace d) (a M V_max R : NNReal) (T : ℝ) (hT : 0 ≤ T)
+    (hV_max_def : V_max = ‖z₀.2‖₊ + a / 2 + M * Real.toNNReal T)
+    (hR : 2 * (a : ℝ) + (‖z₀.2‖ + (a : ℝ) / 2) * T + (M : ℝ) * T ^ 2 ≤ R)
+    (hbound : ∀ t ∈ Set.Icc (0 : ℝ) T,
+              ∀ x ∈ Metric.closedBall z₀.1 (R : ℝ),
+              ‖convolveFunctionMeasure gradW (ρ t) x‖ ≤ M)
+    (c δ : ℝ) (hc_nn : 0 ≤ c) (hc_le_T : c ≤ T) (hcδ_le_T : c + δ ≤ T)
+    (p : PhysSpace d)
+    (hp : ‖p - z₀.1‖ ≤ (a : ℝ) / 2 + (V_max : ℝ) * c) :
+    ∀ t ∈ Set.Icc c (c + δ), ∀ x ∈ Metric.closedBall p (3 * (a : ℝ) / 2),
+      ‖convolveFunctionMeasure gradW (ρ t) x‖ ≤ M := by
+  intro t ht x hx
+  have h_t_in_global : t ∈ Set.Icc (0 : ℝ) T :=
+    ⟨le_trans hc_nn ht.1, le_trans ht.2 hcδ_le_T⟩
+  have h_x_local : dist x p ≤ 3 * (a : ℝ) / 2 := hx
+  have h_pos_chain : dist x z₀.1
+      ≤ 3 * (a : ℝ) / 2 + ((a : ℝ) / 2 + (V_max : ℝ) * c) := by
+    calc dist x z₀.1
+        ≤ dist x p + dist p z₀.1 := dist_triangle _ _ _
+      _ ≤ 3 * (a : ℝ) / 2 + _ := by
+          rw [dist_eq_norm]
+          exact add_le_add h_x_local hp
+  have h_V_max_coe : (V_max : ℝ) = ‖z₀.2‖ + (a : ℝ) / 2 + (M : ℝ) * T := by
+    have h_V_def : (V_max : ℝ) = ‖z₀.2‖ + (a : ℝ) / 2 + (M : ℝ) * (T.toNNReal : ℝ) := by
+      simp [hV_max_def, NNReal.coe_add, coe_nnnorm, NNReal.coe_mul, NNReal.coe_div]
+    rw [h_V_def, Real.coe_toNNReal _ hT]
+  have h_V_max_nn : (0 : ℝ) ≤ (V_max : ℝ) := V_max.coe_nonneg
+  have h_R_expand : 2 * (a : ℝ) + (V_max : ℝ) * T ≤ R := by
+    have h_ring : 2 * (a : ℝ) + (‖z₀.2‖ + (a : ℝ) / 2 + (M : ℝ) * T) * T
+        = 2 * (a : ℝ) + (‖z₀.2‖ + (a : ℝ) / 2) * T + (M : ℝ) * T ^ 2 := by ring
+    rw [h_V_max_coe, h_ring]; exact hR
+  have h_x_in_R : dist x z₀.1 ≤ (R : ℝ) := by
+    have h_pos_worst : (V_max : ℝ) * c ≤ (V_max : ℝ) * T :=
+      mul_le_mul_of_nonneg_left hc_le_T h_V_max_nn
+    linarith [h_pos_chain]
+  exact hbound t h_t_in_global x h_x_in_R
+
+/-- Mean-value velocity carry along one window: if `β` solves the velocity ODE
+on `[c, b]` with force bounded by `Mr`, then `‖(β s).2‖` grows at most linearly
+from its entry value.  Shared by the velocity- and position-invariant steps of
+`charFlowTight_window_step`. -/
+private lemma charFlowTight_window_velocity_carry
+    {d : ℕ}
+    (gradW : PhysSpace d → PhysSpace d)
+    (ρ : ℝ → Measure (PhysSpace d))
+    (β : ℝ → PhaseSpace d) (c b : ℝ) (hcb : c ≤ b) (Mr : ℝ)
+    (h_vel : ∀ s ∈ Set.Icc c b,
+      HasDerivWithinAt (fun u => (β u).2)
+        (-(convolveFunctionMeasure gradW (ρ s) (β s).1)) (Set.Icc c b) s)
+    (h_force : ∀ s ∈ Set.Icc c b,
+      ‖convolveFunctionMeasure gradW (ρ s) (β s).1‖ ≤ Mr) :
+    ∀ s ∈ Set.Icc c b, ‖(β s).2‖ ≤ ‖(β c).2‖ + Mr * (s - c) := by
+  intro s hs
+  have h_convex : Convex ℝ (Set.Icc c b) := convex_Icc _ _
+  have h_c_in : c ∈ Set.Icc c b := ⟨le_refl _, hcb⟩
+  have h_force_neg : ∀ u ∈ Set.Icc c b,
+      ‖-(convolveFunctionMeasure gradW (ρ u) (β u).1)‖ ≤ Mr := by
+    intro u hu; rw [norm_neg]; exact h_force u hu
+  have h_mv : ‖(β s).2 - (β c).2‖ ≤ Mr * ‖s - c‖ :=
+    h_convex.norm_image_sub_le_of_norm_hasDerivWithin_le h_vel h_force_neg h_c_in hs
+  have h_diff_nn : 0 ≤ s - c := by linarith [hs.1]
+  rw [Real.norm_of_nonneg h_diff_nn] at h_mv
+  have h_triangle : ‖(β s).2‖ ≤ ‖(β s).2 - (β c).2‖ + ‖(β c).2‖ := by
+    have h_decomp : (β s).2 = ((β s).2 - (β c).2) + (β c).2 :=
+      (sub_add_cancel _ _).symm
+    calc ‖(β s).2‖ = ‖((β s).2 - (β c).2) + (β c).2‖ := by rw [← h_decomp]
+      _ ≤ _ := norm_add_le _ _
+  linarith
+
+/-- Gluing step for the tight tiling: the `Set.piecewise (Set.Iic c)` splice of
+a left solution on `[0, c]` and a right solution on `[c, b]` (agreeing at the
+join) solves the characteristic ODE system on all of `[0, b]`, via
+`HasDerivWithinAt.union` on `Icc 0 c ∪ Icc c b = Icc 0 b`. -/
+private lemma charFlowTight_piecewise_ode
+    {d : ℕ}
+    (gradW : PhysSpace d → PhysSpace d)
+    (ρ : ℝ → Measure (PhysSpace d))
+    (γL β : ℝ → PhaseSpace d)
+    (c b : ℝ) (hc_nn : 0 ≤ c) (hcb : c ≤ b)
+    (h_join : β c = γL c)
+    (h_ode_L : ∀ t ∈ Set.Icc (0 : ℝ) c,
+      HasDerivWithinAt (fun s => (γL s).1) (γL t).2 (Set.Icc (0 : ℝ) c) t ∧
+      HasDerivWithinAt (fun s => (γL s).2)
+        (-(convolveFunctionMeasure gradW (ρ t) (γL t).1)) (Set.Icc (0 : ℝ) c) t)
+    (h_ode_R : ∀ t ∈ Set.Icc c b,
+      HasDerivWithinAt (fun s => (β s).1) (β t).2 (Set.Icc c b) t ∧
+      HasDerivWithinAt (fun s => (β s).2)
+        (-(convolveFunctionMeasure gradW (ρ t) (β t).1)) (Set.Icc c b) t) :
+    ∀ t ∈ Set.Icc (0 : ℝ) b,
+      HasDerivWithinAt (fun s => (Set.piecewise (Set.Iic c) γL β s).1)
+        (Set.piecewise (Set.Iic c) γL β t).2 (Set.Icc (0 : ℝ) b) t ∧
+      HasDerivWithinAt (fun s => (Set.piecewise (Set.Iic c) γL β s).2)
+        (-(convolveFunctionMeasure gradW (ρ t)
+            (Set.piecewise (Set.Iic c) γL β t).1)) (Set.Icc (0 : ℝ) b) t := by
+  classical
+  intro t ht
+  have h_left : ∀ y ≤ c, Set.piecewise (Set.Iic c) γL β y = γL y := fun y hy =>
+    Set.piecewise_eq_of_mem _ _ _ hy
+  have h_right : ∀ y, c < y → Set.piecewise (Set.Iic c) γL β y = β y := fun y hy =>
+    Set.piecewise_eq_of_notMem _ _ _ (not_le.mpr hy)
+  have h_at_join : Set.piecewise (Set.Iic c) γL β c = γL c := h_left _ (le_refl _)
+  have h_on_right_Icc : ∀ y ∈ Set.Icc c b,
+      Set.piecewise (Set.Iic c) γL β y = β y := by
+    intro y hy
+    rcases eq_or_lt_of_le hy.1 with hy_eq | hy_lt
+    · rw [← hy_eq, h_at_join, h_join]
+    · exact h_right y hy_lt
+  have h_set_union : Set.Icc (0 : ℝ) c ∪ Set.Icc c b = Set.Icc (0 : ℝ) b :=
+    Set.Icc_union_Icc_eq_Icc hc_nn hcb
+  have hA_pos : HasDerivWithinAt (fun s => (Set.piecewise (Set.Iic c) γL β s).1)
+      (Set.piecewise (Set.Iic c) γL β t).2 (Set.Icc (0 : ℝ) c) t := by
+    by_cases ht_left : t ≤ c
+    · have ht_in : t ∈ Set.Icc (0 : ℝ) c := ⟨ht.1, ht_left⟩
+      have h_γL_pos := (h_ode_L t ht_in).1
+      have h_deriv_eq : (Set.piecewise (Set.Iic c) γL β t).2 = (γL t).2 := by
+        rw [h_left t ht_left]
+      rw [h_deriv_eq]
+      refine h_γL_pos.congr (fun y hy => ?_) ?_
+      · rw [h_left y hy.2]
+      · rw [h_left t ht_left]
+    · rw [not_le] at ht_left
+      rw [hasDerivWithinAt_iff_hasFDerivWithinAt]
+      apply HasFDerivWithinAt.of_notMem_closure
+      rw [closure_Icc, Set.mem_Icc]
+      rintro ⟨_, _⟩; linarith
+  have hB_pos : HasDerivWithinAt (fun s => (Set.piecewise (Set.Iic c) γL β s).1)
+      (Set.piecewise (Set.Iic c) γL β t).2 (Set.Icc c b) t := by
+    by_cases ht_right : c ≤ t
+    · have ht_in : t ∈ Set.Icc c b := ⟨ht_right, ht.2⟩
+      have h_β_pos := (h_ode_R t ht_in).1
+      have h_deriv_eq : (Set.piecewise (Set.Iic c) γL β t).2 = (β t).2 := by
+        rw [h_on_right_Icc t ht_in]
+      rw [h_deriv_eq]
+      refine h_β_pos.congr (fun y hy => ?_) ?_
+      · rw [h_on_right_Icc y hy]
+      · rw [h_on_right_Icc t ht_in]
+    · rw [not_le] at ht_right
+      rw [hasDerivWithinAt_iff_hasFDerivWithinAt]
+      apply HasFDerivWithinAt.of_notMem_closure
+      rw [closure_Icc, Set.mem_Icc]
+      rintro ⟨_, _⟩; linarith
+  have hA_vel : HasDerivWithinAt (fun s => (Set.piecewise (Set.Iic c) γL β s).2)
+      (-(convolveFunctionMeasure gradW (ρ t)
+          (Set.piecewise (Set.Iic c) γL β t).1)) (Set.Icc (0 : ℝ) c) t := by
+    by_cases ht_left : t ≤ c
+    · have ht_in : t ∈ Set.Icc (0 : ℝ) c := ⟨ht.1, ht_left⟩
+      have h_γL_vel := (h_ode_L t ht_in).2
+      have h_pos_eq : (Set.piecewise (Set.Iic c) γL β t).1 = (γL t).1 := by
+        rw [h_left t ht_left]
+      rw [h_pos_eq]
+      refine h_γL_vel.congr (fun y hy => ?_) ?_
+      · rw [h_left y hy.2]
+      · rw [h_left t ht_left]
+    · rw [not_le] at ht_left
+      rw [hasDerivWithinAt_iff_hasFDerivWithinAt]
+      apply HasFDerivWithinAt.of_notMem_closure
+      rw [closure_Icc, Set.mem_Icc]
+      rintro ⟨_, _⟩; linarith
+  have hB_vel : HasDerivWithinAt (fun s => (Set.piecewise (Set.Iic c) γL β s).2)
+      (-(convolveFunctionMeasure gradW (ρ t)
+          (Set.piecewise (Set.Iic c) γL β t).1)) (Set.Icc c b) t := by
+    by_cases ht_right : c ≤ t
+    · have ht_in : t ∈ Set.Icc c b := ⟨ht_right, ht.2⟩
+      have h_β_vel := (h_ode_R t ht_in).2
+      have h_pos_eq : (Set.piecewise (Set.Iic c) γL β t).1 = (β t).1 := by
+        rw [h_on_right_Icc t ht_in]
+      rw [h_pos_eq]
+      refine h_β_vel.congr (fun y hy => ?_) ?_
+      · rw [h_on_right_Icc y hy]
+      · rw [h_on_right_Icc t ht_in]
+    · rw [not_le] at ht_right
+      rw [hasDerivWithinAt_iff_hasFDerivWithinAt]
+      apply HasFDerivWithinAt.of_notMem_closure
+      rw [closure_Icc, Set.mem_Icc]
+      rintro ⟨_, _⟩; linarith
+  constructor
+  · have h_union_pos := hA_pos.union hB_pos
+    rw [h_set_union] at h_union_pos
+    exact h_union_pos
+  · have h_union_vel := hA_vel.union hB_vel
+    rw [h_set_union] at h_union_vel
+    exact h_union_vel
+
+/-- One tiling step for the tight flow: extend a trajectory satisfying the
+tight invariants on `[0, c]` to `[0, c + δ']` via
+`exists_vlasov_extend_one_window_tight`, splicing with `Set.piecewise`
+(`charFlowTight_piecewise_ode`) and carrying the linear velocity- and
+position-drift invariants (`charFlowTight_window_velocity_carry` +
+`vlasov_window_position_bound`). -/
+private lemma charFlowTight_window_step
+    {d : ℕ}
+    (gradW : PhysSpace d → PhysSpace d)
+    (L : NNReal) (hL : LipschitzWith L gradW)
+    (ρ : ℝ → Measure (PhysSpace d))
+    [∀ t, IsProbabilityMeasure (ρ t)]
+    (h_int : ∀ t (x : PhysSpace d), Integrable (fun y => gradW (x - y)) (ρ t))
+    (hρ_cont : ∀ x : PhysSpace d,
+      Continuous (fun t => convolveFunctionMeasure gradW (ρ t) x))
+    (z₀ : PhaseSpace d) (a : NNReal) (ha : 0 < a)
+    (M V_max R : NNReal) (T : ℝ) (hT : 0 ≤ T)
+    (hV_max_def : V_max = ‖z₀.2‖₊ + a / 2 + M * Real.toNNReal T)
+    (hR : 2 * (a : ℝ) + (‖z₀.2‖ + (a : ℝ) / 2) * T + (M : ℝ) * T ^ 2 ≤ R)
+    (hbound : ∀ t ∈ Set.Icc (0 : ℝ) T,
+              ∀ x ∈ Metric.closedBall z₀.1 (R : ℝ),
+              ‖convolveFunctionMeasure gradW (ρ t) x‖ ≤ M)
+    (δ' : ℝ) (hδ'_pos : 0 < δ')
+    (hδ'_le_max : δ' ≤ (a : ℝ) / 2 / (((V_max + a + M : NNReal) : ℝ) + 1))
+    (z : PhaseSpace d) (c : ℝ) (hc_nn : 0 ≤ c) (hcδ_le_T : c + δ' ≤ T)
+    (γ_k : ℝ → PhaseSpace d) (h_γ0 : γ_k 0 = z)
+    (h_ode_k : ∀ t ∈ Set.Icc (0 : ℝ) c,
+      HasDerivWithinAt (fun s => (γ_k s).1) (γ_k t).2 (Set.Icc (0 : ℝ) c) t ∧
+      HasDerivWithinAt (fun s => (γ_k s).2)
+        (-(convolveFunctionMeasure gradW (ρ t) (γ_k t).1)) (Set.Icc (0 : ℝ) c) t)
+    (h_vel_k : ‖(γ_k c).2‖ ≤ ‖z₀.2‖ + (a : ℝ) / 2 + (M : ℝ) * c)
+    (h_pos_k : ‖(γ_k c).1 - z₀.1‖ ≤ (a : ℝ) / 2 + (V_max : ℝ) * c) :
+    ∃ γ : ℝ → PhaseSpace d, γ 0 = z ∧
+      (∀ t ∈ Set.Icc (0 : ℝ) (c + δ'),
+        HasDerivWithinAt (fun s => (γ s).1) (γ t).2
+          (Set.Icc (0 : ℝ) (c + δ')) t ∧
+        HasDerivWithinAt (fun s => (γ s).2)
+          (-(convolveFunctionMeasure gradW (ρ t) (γ t).1))
+          (Set.Icc (0 : ℝ) (c + δ')) t) ∧
+      ‖(γ (c + δ')).2‖ ≤ ‖z₀.2‖ + (a : ℝ) / 2 + (M : ℝ) * (c + δ') ∧
+      ‖(γ (c + δ')).1 - z₀.1‖ ≤ (a : ℝ) / 2 + (V_max : ℝ) * (c + δ') := by
+  classical
+  have hc_lt_b : c < c + δ' := by linarith
+  have hc_le_T : c ≤ T := by linarith
+  have hM_nn : (0 : ℝ) ≤ (M : ℝ) := M.coe_nonneg
+  have h_V_max_coe : (V_max : ℝ) = ‖z₀.2‖ + (a : ℝ) / 2 + (M : ℝ) * T := by
+    have h_V_def : (V_max : ℝ) = ‖z₀.2‖ + (a : ℝ) / 2 + (M : ℝ) * (T.toNNReal : ℝ) := by
+      simp [hV_max_def, NNReal.coe_add, coe_nnnorm, NNReal.coe_mul, NNReal.coe_div]
+    rw [h_V_def, Real.coe_toNNReal _ hT]
+  have h_vel_Vmax : ‖(γ_k c).2‖ ≤ (V_max : ℝ) := by
+    rw [h_V_max_coe]
+    calc ‖(γ_k c).2‖
+        ≤ ‖z₀.2‖ + (a : ℝ) / 2 + (M : ℝ) * c := h_vel_k
+      _ ≤ ‖z₀.2‖ + (a : ℝ) / 2 + (M : ℝ) * T := by
+          linarith [mul_le_mul_of_nonneg_left hc_le_T hM_nn]
+  have hbound_local := charFlowTight_window_forceBound gradW ρ z₀ a M V_max R T hT
+    hV_max_def hR hbound c δ' hc_nn hc_le_T hcδ_le_T (γ_k c).1 h_pos_k
+  obtain ⟨β, hβ_init, _hβ_ode_Ioo, hβ_ode_Icc, hβ_confined⟩ :=
+    exists_vlasov_extend_one_window_tight gradW L hL ρ h_int hρ_cont
+      (γ_k c) a ha M V_max h_vel_Vmax c δ' hδ'_pos hδ'_le_max hbound_local
+  have h_β_in_ball : ∀ s ∈ Set.Icc c (c + δ'),
+      (β s).1 ∈ Metric.closedBall (γ_k c).1 (3 * (a : ℝ) / 2) := by
+    intro s hs
+    have h_phase : β s ∈ Metric.closedBall (γ_k c) (a : ℝ) := hβ_confined s hs
+    rw [Metric.mem_closedBall] at h_phase ⊢
+    have h_proj : dist (β s).1 (γ_k c).1 ≤ dist (β s) (γ_k c) := by
+      rw [Prod.dist_eq]; exact le_max_left _ _
+    have h_a_nn : (0 : ℝ) ≤ (a : ℝ) := a.coe_nonneg
+    linarith
+  have h_force_window : ∀ s ∈ Set.Icc c (c + δ'),
+      ‖convolveFunctionMeasure gradW (ρ s) (β s).1‖ ≤ (M : ℝ) := fun s hs =>
+    hbound_local s hs (β s).1 (h_β_in_ball s hs)
+  have h_vel_carry := charFlowTight_window_velocity_carry gradW ρ β c (c + δ')
+    (le_of_lt hc_lt_b) (M : ℝ) (fun s hs => (hβ_ode_Icc s hs).2) h_force_window
+  have h_β_c_vel : (β c).2 = (γ_k c).2 := by rw [hβ_init]
+  have h_ode_pw := charFlowTight_piecewise_ode gradW ρ γ_k β c (c + δ') hc_nn
+    (le_of_lt hc_lt_b) hβ_init h_ode_k hβ_ode_Icc
+  have h_right_end : Set.piecewise (Set.Iic c) γ_k β (c + δ') = β (c + δ') :=
+    Set.piecewise_eq_of_notMem _ _ _ (not_le.mpr hc_lt_b)
+  have h_left0 : Set.piecewise (Set.Iic c) γ_k β 0 = γ_k 0 :=
+    Set.piecewise_eq_of_mem _ _ _ hc_nn
+  refine ⟨Set.piecewise (Set.Iic c) γ_k β, by rw [h_left0, h_γ0], h_ode_pw, ?_, ?_⟩
+  · -- Velocity invariant at the new endpoint, via the mean-value carry.
+    rw [h_right_end]
+    have h_carry_b := h_vel_carry (c + δ') ⟨le_of_lt hc_lt_b, le_refl _⟩
+    rw [h_β_c_vel] at h_carry_b
+    have h_ring : (M : ℝ) * (c + δ' - c) = (M : ℝ) * δ' := by ring
+    rw [h_ring] at h_carry_b
+    calc ‖(β (c + δ')).2‖
+        ≤ ‖(γ_k c).2‖ + (M : ℝ) * δ' := h_carry_b
+      _ ≤ ‖z₀.2‖ + (a : ℝ) / 2 + (M : ℝ) * c + (M : ℝ) * δ' := by linarith [h_vel_k]
+      _ = ‖z₀.2‖ + (a : ℝ) / 2 + (M : ℝ) * (c + δ') := by ring
+  · -- Position invariant at the new endpoint, via the window position bound.
+    rw [h_right_end]
+    have h_window_vel_Vmax : ∀ s ∈ Set.Icc c (c + δ'),
+        ‖(β s).2‖ ≤ (V_max : ℝ) := by
+      intro s hs
+      have h_carry_s := h_vel_carry s hs
+      rw [h_β_c_vel] at h_carry_s
+      have h_s_le_T : s ≤ T := le_trans hs.2 hcδ_le_T
+      have h_M_split : (M : ℝ) * (s - c) + (M : ℝ) * c = (M : ℝ) * s := by ring
+      have h_M_mono : (M : ℝ) * s ≤ (M : ℝ) * T :=
+        mul_le_mul_of_nonneg_left h_s_le_T hM_nn
+      rw [h_V_max_coe]
+      linarith [h_carry_s, h_vel_k]
+    have h_pos_carry :=
+      vlasov_window_position_bound gradW ρ (γ_k c) c δ' hδ'_pos
+        (V_max : ℝ) z₀.1 ((a : ℝ) / 2 + (V_max : ℝ) * c) h_pos_k β hβ_init
+        (fun t ht => (hβ_ode_Icc t ht).1) h_window_vel_Vmax
+    calc ‖(β (c + δ')).1 - z₀.1‖
+        ≤ (a : ℝ) / 2 + (V_max : ℝ) * c + (V_max : ℝ) * δ' := h_pos_carry
+      _ = (a : ℝ) / 2 + (V_max : ℝ) * (c + δ') := by ring
+
+/-- Per-`z` trajectory for the tight flow: `N`-fold exact tiling of
+`[0, N·δ']` by windows of width `δ'`, by induction via
+`charFlowTight_window_step`, carrying the tight velocity/position invariants
+through the induction and discarding them at the end. -/
+private lemma charFlowTight_perZ_trajectory
+    {d : ℕ}
+    (gradW : PhysSpace d → PhysSpace d)
+    (L : NNReal) (hL : LipschitzWith L gradW)
+    (ρ : ℝ → Measure (PhysSpace d))
+    [∀ t, IsProbabilityMeasure (ρ t)]
+    (h_int : ∀ t (x : PhysSpace d), Integrable (fun y => gradW (x - y)) (ρ t))
+    (hρ_cont : ∀ x : PhysSpace d,
+      Continuous (fun t => convolveFunctionMeasure gradW (ρ t) x))
+    (z₀ : PhaseSpace d) (a : NNReal) (ha : 0 < a)
+    (M V_max R : NNReal) (T : ℝ) (hT : 0 ≤ T)
+    (hV_max_def : V_max = ‖z₀.2‖₊ + a / 2 + M * Real.toNNReal T)
+    (hR : 2 * (a : ℝ) + (‖z₀.2‖ + (a : ℝ) / 2) * T + (M : ℝ) * T ^ 2 ≤ R)
+    (hbound : ∀ t ∈ Set.Icc (0 : ℝ) T,
+              ∀ x ∈ Metric.closedBall z₀.1 (R : ℝ),
+              ‖convolveFunctionMeasure gradW (ρ t) x‖ ≤ M)
+    (N : ℕ) (δ' : ℝ) (hδ'_pos : 0 < δ')
+    (hδ'_le_max : δ' ≤ (a : ℝ) / 2 / (((V_max + a + M : NNReal) : ℝ) + 1))
+    (hNδ'_le_T : (N : ℝ) * δ' ≤ T)
+    (z : PhaseSpace d) (hz : z ∈ Metric.closedBall z₀ ((a : ℝ) / 2)) :
+    ∃ γ : ℝ → PhaseSpace d,
+      γ 0 = z ∧
+      ∀ t ∈ Set.Icc (0 : ℝ) ((N : ℝ) * δ'),
+        HasDerivWithinAt (fun s => (γ s).1) (γ t).2
+          (Set.Icc (0 : ℝ) ((N : ℝ) * δ')) t ∧
+        HasDerivWithinAt (fun s => (γ s).2)
+          (-(convolveFunctionMeasure gradW (ρ t) (γ t).1))
+          (Set.Icc (0 : ℝ) ((N : ℝ) * δ')) t := by
+  suffices h_strong : ∀ k : ℕ, k ≤ N → ∃ γ : ℝ → PhaseSpace d,
+      γ 0 = z ∧
+      (∀ t ∈ Set.Icc (0 : ℝ) ((k : ℝ) * δ'),
+        HasDerivWithinAt (fun s => (γ s).1) (γ t).2
+          (Set.Icc (0 : ℝ) ((k : ℝ) * δ')) t ∧
+        HasDerivWithinAt (fun s => (γ s).2)
+          (-(convolveFunctionMeasure gradW (ρ t) (γ t).1))
+          (Set.Icc (0 : ℝ) ((k : ℝ) * δ')) t) ∧
+      ‖(γ ((k : ℝ) * δ')).2‖ ≤
+        ‖z₀.2‖ + (a : ℝ) / 2 + (M : ℝ) * ((k : ℝ) * δ') ∧
+      ‖(γ ((k : ℝ) * δ')).1 - z₀.1‖ ≤
+        (a : ℝ) / 2 + (V_max : ℝ) * ((k : ℝ) * δ') by
+    obtain ⟨γ, hγ0, hode, _, _⟩ := h_strong N (le_refl N)
+    exact ⟨γ, hγ0, hode⟩
+  intro k
+  induction k with
+  | zero =>
+    intro _
+    refine ⟨fun _ => z, rfl, ?_, ?_, ?_⟩
+    · intro t ht
+      have ht_eq : t = 0 := le_antisymm (by simpa using ht.2) ht.1
+      subst ht_eq
+      have h_set_eq : Set.Icc (0 : ℝ) (((0 : ℕ) : ℝ) * δ') = Set.Icc (0 : ℝ) 0 := by
+        norm_num
+      rw [h_set_eq]
+      exact ⟨hasDerivWithinAt_Icc_self _ _ _, hasDerivWithinAt_Icc_self _ _ _⟩
+    · have hdist : ‖z - z₀‖ ≤ (a : ℝ) / 2 := by
+        rw [← dist_eq_norm]; exact hz
+      have h_z2_proj : ‖z.2 - z₀.2‖ ≤ ‖z - z₀‖ := by
+        rw [Prod.norm_def]; exact le_max_right _ _
+      have h_z2_bound : ‖z.2‖ ≤ ‖z₀.2‖ + (a : ℝ) / 2 := by
+        have h1 : ‖z.2‖ = ‖(z.2 - z₀.2) + z₀.2‖ := by rw [sub_add_cancel]
+        have h2 : ‖(z.2 - z₀.2) + z₀.2‖ ≤ ‖z.2 - z₀.2‖ + ‖z₀.2‖ := norm_add_le _ _
+        linarith [h_z2_proj, hdist]
+      change ‖((fun _ => z) (((0 : ℕ) : ℝ) * δ')).2‖ ≤
+        ‖z₀.2‖ + (a : ℝ) / 2 + (M : ℝ) * (((0 : ℕ) : ℝ) * δ')
+      simp only [Nat.cast_zero, zero_mul, mul_zero, add_zero]
+      linarith
+    · have hdist : ‖z - z₀‖ ≤ (a : ℝ) / 2 := by
+        rw [← dist_eq_norm]; exact hz
+      have h_z1_proj : ‖z.1 - z₀.1‖ ≤ ‖z - z₀‖ := by
+        rw [Prod.norm_def]; exact le_max_left _ _
+      change ‖((fun _ => z) (((0 : ℕ) : ℝ) * δ')).1 - z₀.1‖ ≤
+        (a : ℝ) / 2 + (V_max : ℝ) * (((0 : ℕ) : ℝ) * δ')
+      simp only [Nat.cast_zero, zero_mul, mul_zero, add_zero]
+      linarith
+  | succ k ih =>
+    intro hk_succ_le_N
+    obtain ⟨γ_k, h_γ0, h_ode_k, h_vel_k, h_pos_k⟩ :=
+      ih (Nat.le_of_succ_le hk_succ_le_N)
+    have h_kδ_nn : (0 : ℝ) ≤ (k : ℝ) * δ' := by positivity
+    have h_kδ_succ_eq : (k : ℝ) * δ' + δ' = ((k + 1 : ℕ) : ℝ) * δ' := by
+      push_cast; ring
+    have h_succ_kδ_le_T : ((k + 1 : ℕ) : ℝ) * δ' ≤ T := by
+      calc ((k + 1 : ℕ) : ℝ) * δ'
+          ≤ (N : ℝ) * δ' := by
+            have h_cast : ((k + 1 : ℕ) : ℝ) ≤ (N : ℝ) := by
+              exact_mod_cast hk_succ_le_N
+            exact mul_le_mul_of_nonneg_right h_cast (le_of_lt hδ'_pos)
+        _ ≤ T := hNδ'_le_T
+    obtain ⟨γ, hγ0, h_ode, h_vel, h_pos⟩ :=
+      charFlowTight_window_step gradW L hL ρ h_int hρ_cont z₀ a ha M V_max R T hT
+        hV_max_def hR hbound δ' hδ'_pos hδ'_le_max z ((k : ℝ) * δ') h_kδ_nn
+        (by rw [h_kδ_succ_eq]; exact h_succ_kδ_le_T) γ_k h_γ0 h_ode_k h_vel_k h_pos_k
+    rw [← h_kδ_succ_eq]
+    exact ⟨γ, hγ0, h_ode, h_vel, h_pos⟩
+
+/-- **Tight global per-ball flow: `[0,T]` force-window, `T²` smallness (no `+1`).**
+
+Tight form of `exists_vlasov_characteristicFlow`.  By tiling `[0,T]`
+EXACTLY (`N = ⌈T/δ_max⌉` windows of width `δ' = T/N ≤ δ_max`, so `N·δ' = T`) and
+calling `exists_vlasov_extend_one_window_tight` with the adaptive force-window
+`[k·δ', (k+1)·δ']`, the global force-bound is required only on `[0,T]` and the
+position drift is `M·T²` (not `M·(T+1)²`).  Consumers' R-selection then needs only
+`L·T² < 1`, satisfiable for any `L` (threshold `T < 1/√L`), dissolving the `L<1`
+restriction. -/
+theorem exists_vlasov_characteristicFlow_tight
+    {d : ℕ}
+    (W : PhysSpace d → ℝ)
+    (gradW : PhysSpace d → PhysSpace d)
+    (_hgradW : ∀ x, gradW x = gradient W x)
+    (L : NNReal) (hL : LipschitzWith L gradW)
+    (ρ : ℝ → Measure (PhysSpace d))
+    [∀ t, IsProbabilityMeasure (ρ t)]
+    (h_int : ∀ t (x : PhysSpace d), Integrable (fun y => gradW (x - y)) (ρ t))
+    (hρ_cont : ∀ x : PhysSpace d,
+      Continuous (fun t => convolveFunctionMeasure gradW (ρ t) x))
+    (z₀ : PhaseSpace d) (a : NNReal) (ha : 0 < a)
+    (M : NNReal) (T : ℝ) (hT : 0 ≤ T)
+    (R : NNReal)
+    (hR : 2 * (a : ℝ) + (‖z₀.2‖ + (a : ℝ) / 2) * T + (M : ℝ) * T ^ 2 ≤ R)
+    (hbound : ∀ t ∈ Set.Icc (0 : ℝ) T,
+              ∀ x ∈ Metric.closedBall z₀.1 (R : ℝ),
+              ‖convolveFunctionMeasure gradW (ρ t) x‖ ≤ M) :
+    ∃ (charX charV : ℝ → PhaseSpace d → PhysSpace d),
+      IsCharacteristicFlowOn gradW ρ charX charV
+        (Set.Ioo 0 T) (Metric.closedBall z₀ ((a : ℝ) / 2)) ∧
+      (∀ z ∈ Metric.closedBall z₀ ((a : ℝ) / 2),
+        ∀ t ∈ Set.Icc (0 : ℝ) T,
+          HasDerivWithinAt (fun s => charX s z) (charV t z)
+            (Set.Icc (0 : ℝ) T) t ∧
+          HasDerivWithinAt (fun s => charV s z)
+            (-(convolveFunctionMeasure gradW (ρ t) (charX t z)))
+            (Set.Icc (0 : ℝ) T) t) := by
+  classical
+  -- ============================================================
+  -- Parameter setup (uniform across all windows and initial z).
+  -- TIGHT: V_max uses `T` (not `T+1`); EXACT tiling N·δ' = T.
+  -- ============================================================
+  set V_max : NNReal :=
+    ‖z₀.2‖₊ + a / 2 + M * Real.toNNReal T with hV_max_def
+  have ha_real : (0 : ℝ) < (a : ℝ) := by exact_mod_cast ha
+  have h_denom_pos : (0 : ℝ) < (((V_max + a + M : NNReal) : ℝ) + 1) := by positivity
+  set δ_max : ℝ := (a : ℝ) / 2 / (((V_max + a + M : NNReal) : ℝ) + 1) with hδ_max_def
+  have hδ_max_pos : (0 : ℝ) < δ_max := by rw [hδ_max_def]; positivity
+  -- T = 0 edge case: the conclusion's intervals collapse.
+  rcases eq_or_lt_of_le hT with hT_eq | hT_pos
+  · -- T = 0: Ioo 0 0 = ∅, Icc 0 0 = {0}.  Build the trivial flow γ_func z s = z.
+    subst hT_eq
+    -- charX/charV constant in time, equal to z (resp. its components).
+    refine ⟨fun _ z => z.1, fun _ z => z.2, ⟨?_, ?_, ?_⟩, ?_⟩
+    · intro z hz; exact ⟨rfl, rfl⟩
+    · intro t ht z hz; exact absurd (lt_trans ht.1 ht.2) (lt_irrefl 0)
+    · intro t ht z hz; exact absurd (lt_trans ht.1 ht.2) (lt_irrefl 0)
+    · intro z hz t ht
+      have ht_eq : t = 0 := le_antisymm ht.2 ht.1
+      subst ht_eq
+      exact ⟨hasDerivWithinAt_Icc_self _ _ _, hasDerivWithinAt_Icc_self _ _ _⟩
+  · -- T > 0: EXACT tiling.
+    -- N := ⌈T/δ_max⌉₊ windows of width δ' = T/N ≤ δ_max, so N·δ' = T.
+    set N : ℕ := ⌈T / δ_max⌉₊ with hN_def
+    have hN_pos : 0 < N := by
+      rw [hN_def, Nat.ceil_pos]
+      positivity
+    have hN_real_pos : (0 : ℝ) < (N : ℝ) := by exact_mod_cast hN_pos
+    set δ' : ℝ := T / (N : ℝ) with hδ'_def
+    have hδ'_pos : (0 : ℝ) < δ' := by rw [hδ'_def]; positivity
+    have hNδ'_eq : (N : ℝ) * δ' = T := by
+      rw [hδ'_def]; field_simp
+    -- δ' ≤ δ_max because N ≥ T/δ_max.
+    have hδ'_le_max : δ' ≤ δ_max := by
+      have h_ceil : T / δ_max ≤ (N : ℝ) := Nat.le_ceil _
+      rw [hδ'_def, div_le_iff₀ hN_real_pos]
+      calc T = (T / δ_max) * δ_max := by field_simp
+        _ ≤ (N : ℝ) * δ_max :=
+            mul_le_mul_of_nonneg_right h_ceil (le_of_lt hδ_max_pos)
+        _ = δ_max * (N : ℝ) := by ring
+    -- ============================================================
+    -- Per-z induction: a curve solving the ODE on [0, N·δ'] = [0, T].
+    -- ============================================================
+    have h_perZ : ∀ z ∈ Metric.closedBall z₀ ((a : ℝ) / 2),
+        ∃ γ : ℝ → PhaseSpace d,
+          γ 0 = z ∧
+          ∀ t ∈ Set.Icc (0 : ℝ) ((N : ℝ) * δ'),
+            HasDerivWithinAt (fun s => (γ s).1) (γ t).2
+              (Set.Icc (0 : ℝ) ((N : ℝ) * δ')) t ∧
+            HasDerivWithinAt (fun s => (γ s).2)
+              (-(convolveFunctionMeasure gradW (ρ t) (γ t).1))
+              (Set.Icc (0 : ℝ) ((N : ℝ) * δ')) t :=
+      fun z hz =>
+        charFlowTight_perZ_trajectory gradW L hL ρ h_int hρ_cont z₀ a ha M V_max R
+          T hT hV_max_def hR hbound N δ' hδ'_pos
+          (by rw [← hδ_max_def]; exact hδ'_le_max) (le_of_eq hNδ'_eq) z hz
+    -- ============================================================
+    -- Bundle per-z curves into a joint flow via Classical.choose.
+    -- ============================================================
+    let γ_func : PhaseSpace d → ℝ → PhaseSpace d := fun z =>
+      if hz : z ∈ Metric.closedBall z₀ ((a : ℝ) / 2)
+      then Classical.choose (h_perZ z hz)
+      else (fun _ => z)
+    have h_Icc_T_sub : Set.Icc (0 : ℝ) T ⊆ Set.Icc (0 : ℝ) ((N : ℝ) * δ') :=
+      fun t ht => ⟨ht.1, le_trans ht.2 (le_of_eq hNδ'_eq.symm)⟩
+    have h_dw_on_big :
+        ∀ z ∈ Metric.closedBall z₀ ((a : ℝ) / 2),
+          ∀ t ∈ Set.Icc (0 : ℝ) ((N : ℝ) * δ'),
+            HasDerivWithinAt (fun s => (γ_func z s).1) (γ_func z t).2
+              (Set.Icc (0 : ℝ) ((N : ℝ) * δ')) t ∧
+            HasDerivWithinAt (fun s => (γ_func z s).2)
+              (-(convolveFunctionMeasure gradW (ρ t) (γ_func z t).1))
+              (Set.Icc (0 : ℝ) ((N : ℝ) * δ')) t := by
+      intro z hz t ht
+      have h_func_eq : γ_func z = Classical.choose (h_perZ z hz) := by
+        simp only [γ_func, dite_eq_left hz]
+      have h_ode := (Classical.choose_spec (h_perZ z hz)).2
+      have h_pos_dw := (h_ode t ht).1
+      have h_vel_dw := (h_ode t ht).2
+      have h_eq_fun_pos : (fun s => (γ_func z s).1)
+          = (fun s => ((Classical.choose (h_perZ z hz)) s).1) := by
+        funext s; rw [h_func_eq]
+      have h_eq_fun_vel : (fun s => (γ_func z s).2)
+          = (fun s => ((Classical.choose (h_perZ z hz)) s).2) := by
+        funext s; rw [h_func_eq]
+      have h_eq_pt_vel : (γ_func z t).2 = (Classical.choose (h_perZ z hz) t).2 := by
+        rw [h_func_eq]
+      have h_eq_pt_pos : (γ_func z t).1 = (Classical.choose (h_perZ z hz) t).1 := by
+        rw [h_func_eq]
+      refine ⟨?_, ?_⟩
+      · rw [h_eq_fun_pos, h_eq_pt_vel]; exact h_pos_dw
+      · rw [h_eq_fun_vel, h_eq_pt_pos]; exact h_vel_dw
+    refine ⟨fun t z => (γ_func z t).1, fun t z => (γ_func z t).2,
+           ⟨?_, ?_, ?_⟩, ?_⟩
+    · intro z hz
+      have h_init : Classical.choose (h_perZ z hz) 0 = z :=
+        (Classical.choose_spec (h_perZ z hz)).1
+      have h_func_eq : γ_func z = Classical.choose (h_perZ z hz) := by
+        simp only [γ_func, dite_eq_left hz]
+      refine ⟨?_, ?_⟩
+      · change (γ_func z 0).1 = z.1
+        rw [h_func_eq, h_init]
+      · change (γ_func z 0).2 = z.2
+        rw [h_func_eq, h_init]
+    · intro t ht z hz
+      have h_t_in : t ∈ Set.Icc (0 : ℝ) ((N : ℝ) * δ') := by
+        refine ⟨le_of_lt ht.1, le_trans (le_of_lt ht.2) (le_of_eq hNδ'_eq.symm)⟩
+      have hT_lt_N : t < (N : ℝ) * δ' := lt_of_lt_of_le ht.2 (le_of_eq hNδ'_eq.symm)
+      have h_icc_nhds : Set.Icc (0 : ℝ) ((N : ℝ) * δ') ∈ nhds t :=
+        Icc_mem_nhds ht.1 hT_lt_N
+      exact ((h_dw_on_big z hz t h_t_in).1).hasDerivAt h_icc_nhds
+    · intro t ht z hz
+      have h_t_in : t ∈ Set.Icc (0 : ℝ) ((N : ℝ) * δ') := by
+        refine ⟨le_of_lt ht.1, le_trans (le_of_lt ht.2) (le_of_eq hNδ'_eq.symm)⟩
+      have hT_lt_N : t < (N : ℝ) * δ' := lt_of_lt_of_le ht.2 (le_of_eq hNδ'_eq.symm)
+      have h_icc_nhds : Set.Icc (0 : ℝ) ((N : ℝ) * δ') ∈ nhds t :=
+        Icc_mem_nhds ht.1 hT_lt_N
+      exact ((h_dw_on_big z hz t h_t_in).2).hasDerivAt h_icc_nhds
+    · intro z hz t ht
+      have h_t_in_big : t ∈ Set.Icc (0 : ℝ) ((N : ℝ) * δ') :=
+        h_Icc_T_sub ht
+      obtain ⟨h_pos_big, h_vel_big⟩ := h_dw_on_big z hz t h_t_in_big
+      exact ⟨h_pos_big.mono h_Icc_T_sub, h_vel_big.mono h_Icc_T_sub⟩
+
+/-- **Two-window** characteristic-flow existence.
+
+A flow on `Ioo 0 (2δ)` for some `δ > 0` and initial conditions in
+`closedBall z₀ (a/2)`.  Produces a strictly longer window than
+`exists_vlasov_characteristicFlow_local` (which gave `Ioo 0 δ` with
+the larger `δ := (a/2)/(L_pl + 1)`); here we tighten the contraction
+constraint to `L_pl · (2δ) ≤ a/2`, yielding the smaller
+`δ := (a/2)/(2·(L_pl + 1))` but covering a `2δ`-long interval.
+
+**Implementation note.**  This is a single Picard call (the vendored
+`_confined` wrapper) with
+`tmax = 2δ`, not a literal "two-window stitch" via uniqueness on
+overlapping windows.  Mathematically the two are equivalent: a
+single Picard with an extended `tmax` and tightened `δ` recovers the
+same set of solutions that a two-window stitch would produce.  The
+genuine two-window stitch (per-z second Picard at varying centers
+glued via `ODE_solution_unique`) becomes essential only when the
+single-Picard contraction cannot be satisfied — i.e., when the total
+time window needed exceeds the asymptotic threshold `≈ 1/2` regardless
+of `a`.  For the upcoming N-window induction follow-up, this single-
+Picard extension is iterated, with each iteration using a per-z
+center from the previous window's endpoint. -/
+theorem exists_vlasov_characteristicFlow_twoWindow
+    {d : ℕ}
+    (W : PhysSpace d → ℝ)
+    (gradW : PhysSpace d → PhysSpace d)
+    (_hgradW : ∀ x, gradW x = gradient W x)
+    (L : NNReal) (hL : LipschitzWith L gradW)
+    (ρ : ℝ → Measure (PhysSpace d))
+    [∀ t, IsProbabilityMeasure (ρ t)]
+    (h_int : ∀ t (x : PhysSpace d), Integrable (fun y => gradW (x - y)) (ρ t))
+    (hρ_cont : ∀ x : PhysSpace d,
+      Continuous (fun t => convolveFunctionMeasure gradW (ρ t) x))
+    (z₀ : PhaseSpace d) (a : NNReal) (ha : 0 < a)
+    (M : NNReal)
+    (hbound : ∀ t ∈ Set.Icc (0 : ℝ) (1 : ℝ),
+              ∀ x ∈ Metric.closedBall z₀.1 (3 * (a : ℝ) / 2),
+              ‖convolveFunctionMeasure gradW (ρ t) x‖ ≤ M) :
+    ∃ (δ : ℝ) (_ : 0 < δ) (charX charV : ℝ → PhaseSpace d → PhysSpace d),
+      IsCharacteristicFlowOn gradW ρ charX charV
+        (Set.Ioo 0 (2 * δ)) (Metric.closedBall z₀ ((a : ℝ) / 2)) := by
+  classical
+  -- IsPicardLindelof parameter choices.  Same K_pl, r_pl, L_pl as `_local`;
+  -- only the time-step δ is halved to fit the 2δ contraction.
+  set K_pl : NNReal := max 1 L with hK_pl_def
+  set r_pl : NNReal := a / 2 with hr_pl_def
+  set L_pl : NNReal := ‖z₀.2‖₊ + a + M with hL_pl_def
+  -- δ chosen so the doubled window 2δ still satisfies L_pl · (2δ) ≤ a/2.
+  set δ : ℝ := min (1 / 2) ((a : ℝ) / 2 / (2 * ((L_pl : ℝ) + 1))) with hδ_def
+  have ha_real : (0 : ℝ) < (a : ℝ) := by exact_mod_cast ha
+  have h_denom_pos : (0 : ℝ) < 2 * ((L_pl : ℝ) + 1) := by positivity
+  have h_ratio_pos : (0 : ℝ) < (a : ℝ) / 2 / (2 * ((L_pl : ℝ) + 1)) := by positivity
+  have hδ_pos : (0 : ℝ) < δ := lt_min (by norm_num) h_ratio_pos
+  have hδ_le_half : δ ≤ 1 / 2 := min_le_left _ _
+  have hδ_le_ratio : δ ≤ (a : ℝ) / 2 / (2 * ((L_pl : ℝ) + 1)) := min_le_right _ _
+  have h_2δ_pos : (0 : ℝ) < 2 * δ := by linarith
+  have h_2δ_le_one : 2 * δ ≤ 1 := by linarith
+  -- t₀ ∈ Icc 0 (2δ).
+  let t₀ : Set.Icc (0 : ℝ) (2 * δ) :=
+    ⟨0, Set.mem_Icc.mpr ⟨le_refl 0, le_of_lt h_2δ_pos⟩⟩
+  -- Assemble IsPicardLindelof on time window [0, 2δ].
+  have hpl : IsPicardLindelof (vlasovVectorField gradW ρ) t₀ z₀ a r_pl L_pl K_pl := by
+    refine ⟨?_, ?_, ?_, ?_⟩
+    · intro t _
+      exact (vlasovVectorField_lipschitzWith gradW L hL ρ h_int t).lipschitzOnWith
+    · intro x _
+      apply Continuous.continuousOn
+      simp only [vlasovVectorField]
+      exact Continuous.prodMk continuous_const (hρ_cont x.1).neg
+    · -- norm_le — verbatim from `_local` (uses hbound on Icc 0 1, ball 3a/2).
+      intro t ht x hx
+      have h_norm_field := vlasovVectorField_norm_le gradW ρ t x
+      have hdist_le : dist x z₀ ≤ (a : ℝ) := hx
+      have hdist_le_norm : ‖x - z₀‖ ≤ (a : ℝ) := by rwa [dist_eq_norm] at hdist_le
+      have h_x2_proj : ‖x.2 - z₀.2‖ ≤ ‖x - z₀‖ := by
+        rw [Prod.norm_def]; exact le_max_right _ _
+      have h_x2_bound : ‖x.2‖ ≤ ‖z₀.2‖ + (a : ℝ) := by
+        have h1 : ‖x.2‖ = ‖(x.2 - z₀.2) + z₀.2‖ := by rw [sub_add_cancel]
+        have h2 : ‖(x.2 - z₀.2) + z₀.2‖ ≤ ‖x.2 - z₀.2‖ + ‖z₀.2‖ := norm_add_le _ _
+        linarith [h_x2_proj, hdist_le_norm]
+      have h_x1_proj : dist x.1 z₀.1 ≤ dist x z₀ := by
+        simp only [Prod.dist_eq]; exact le_max_left _ _
+      have h_x1_ball : x.1 ∈ Metric.closedBall z₀.1 (3 * (a : ℝ) / 2) := by
+        have hx1d : dist x.1 z₀.1 ≤ (a : ℝ) := le_trans h_x1_proj hdist_le
+        have : dist x.1 z₀.1 ≤ 3 * (a : ℝ) / 2 := by
+          have ha_nn : (0 : ℝ) ≤ (a : ℝ) := le_of_lt ha_real
+          linarith
+        exact this
+      have h_t_Icc : t ∈ Set.Icc (0 : ℝ) 1 :=
+        ⟨ht.1, le_trans ht.2 h_2δ_le_one⟩
+      have h_force_bound : ‖convolveFunctionMeasure gradW (ρ t) x.1‖ ≤ (M : ℝ) :=
+        hbound t h_t_Icc x.1 h_x1_ball
+      have h_Lpl_eq : (L_pl : ℝ) = ‖z₀.2‖ + (a : ℝ) + (M : ℝ) := by
+        simp [hL_pl_def, NNReal.coe_add, coe_nnnorm]
+      calc ‖vlasovVectorField gradW ρ t x‖
+          ≤ max ‖x.2‖ ‖convolveFunctionMeasure gradW (ρ t) x.1‖ := h_norm_field
+        _ ≤ (L_pl : ℝ) := by
+            rw [h_Lpl_eq]
+            apply max_le
+            · linarith [NNReal.coe_nonneg M]
+            · linarith [norm_nonneg z₀.2, NNReal.coe_nonneg a]
+    · -- mul_max_le: L_pl · (2δ) ≤ a − a/2 = a/2.  Tighter constraint than `_local`.
+      show (L_pl : ℝ) * max (2 * δ - (t₀ : ℝ)) ((t₀ : ℝ) - 0) ≤ (a : ℝ) - (r_pl : ℝ)
+      have ht₀_eq : (t₀ : ℝ) = 0 := rfl
+      simp only [ht₀_eq, sub_zero, sub_self, max_eq_left (le_of_lt h_2δ_pos)]
+      have h_a_minus_r : (a : ℝ) - (r_pl : ℝ) = (a : ℝ) / 2 := by
+        simp [hr_pl_def, NNReal.coe_div]; ring
+      rw [h_a_minus_r]
+      have h_Lpl_nn : (0 : ℝ) ≤ (L_pl : ℝ) := L_pl.coe_nonneg
+      have h_a_nn : (0 : ℝ) ≤ (a : ℝ) / 2 := by linarith [ha_real]
+      have h_step : (L_pl : ℝ) * (2 * δ) ≤ (L_pl : ℝ) *
+          (2 * ((a : ℝ) / 2 / (2 * ((L_pl : ℝ) + 1)))) := by
+        apply mul_le_mul_of_nonneg_left _ h_Lpl_nn
+        linarith [hδ_le_ratio]
+      have h_simp : (L_pl : ℝ) *
+          (2 * ((a : ℝ) / 2 / (2 * ((L_pl : ℝ) + 1))))
+          = (L_pl : ℝ) / ((L_pl : ℝ) + 1) * ((a : ℝ) / 2) := by
+        field_simp
+      have h_frac_le : (L_pl : ℝ) / ((L_pl : ℝ) + 1) ≤ 1 := by
+        have h_pos : (0 : ℝ) < (L_pl : ℝ) + 1 := by linarith
+        rw [div_le_one h_pos]; linarith
+      have h_bound : (L_pl : ℝ) / ((L_pl : ℝ) + 1) * ((a : ℝ) / 2) ≤ (a : ℝ) / 2 := by
+        calc (L_pl : ℝ) / ((L_pl : ℝ) + 1) * ((a : ℝ) / 2)
+            ≤ 1 * ((a : ℝ) / 2) :=
+              mul_le_mul_of_nonneg_right h_frac_le h_a_nn
+          _ = (a : ℝ) / 2 := one_mul _
+      linarith [h_step, h_simp ▸ h_step, h_bound]
+  -- Invoke headline Picard-Lindelöf on the doubled window.
+  obtain ⟨α, hα⟩ := hpl.exists_forall_mem_closedBall_eq_forall_mem_Icc_hasDerivWithinAt_confined
+  -- Define charX, charV by projection.
+  refine ⟨δ, hδ_pos, fun t z => (α z t).1, fun t z => (α z t).2, ?_, ?_, ?_⟩
+  · -- Initial condition.
+    intro z hz
+    have hz_in_r : z ∈ Metric.closedBall z₀ (r_pl : ℝ) := by
+      have hreq : (r_pl : ℝ) = (a : ℝ) / 2 := by simp [hr_pl_def, NNReal.coe_div]
+      rw [Metric.mem_closedBall] at hz ⊢
+      rw [hreq]; exact hz
+    have h_init : α z (t₀ : ℝ) = z := (hα z hz_in_r).1
+    have ht₀_eq : (t₀ : ℝ) = 0 := rfl
+    rw [ht₀_eq] at h_init
+    refine ⟨?_, ?_⟩
+    · change (α z 0).1 = z.1; rw [h_init]
+    · change (α z 0).2 = z.2; rw [h_init]
+  · -- Position ODE on Ioo 0 (2δ).
+    intro t ht z hz
+    have hz_in_r : z ∈ Metric.closedBall z₀ (r_pl : ℝ) := by
+      have hreq : (r_pl : ℝ) = (a : ℝ) / 2 := by simp [hr_pl_def, NNReal.coe_div]
+      rw [Metric.mem_closedBall] at hz ⊢; rw [hreq]; exact hz
+    have h_t_Icc : t ∈ Set.Icc (0 : ℝ) (2 * δ) := ⟨le_of_lt ht.1, le_of_lt ht.2⟩
+    have h_dw := (hα z hz_in_r).2.1 t h_t_Icc
+    have h_icc_nhds : Set.Icc (0 : ℝ) (2 * δ) ∈ nhds t := Icc_mem_nhds ht.1 ht.2
+    have h_d : HasDerivAt (α z) (vlasovVectorField gradW ρ t (α z t)) t :=
+      h_dw.hasDerivAt h_icc_nhds
+    have h_proj : HasDerivAt (fun s => (α z s).1)
+        (vlasovVectorField gradW ρ t (α z t)).1 t :=
+      (hasFDerivAt_fst (E := PhysSpace d) (F := PhysSpace d)).comp_hasDerivAt t h_d
+    simpa [vlasovVectorField] using h_proj
+  · -- Velocity ODE on Ioo 0 (2δ).
+    intro t ht z hz
+    have hz_in_r : z ∈ Metric.closedBall z₀ (r_pl : ℝ) := by
+      have hreq : (r_pl : ℝ) = (a : ℝ) / 2 := by simp [hr_pl_def, NNReal.coe_div]
+      rw [Metric.mem_closedBall] at hz ⊢; rw [hreq]; exact hz
+    have h_t_Icc : t ∈ Set.Icc (0 : ℝ) (2 * δ) := ⟨le_of_lt ht.1, le_of_lt ht.2⟩
+    have h_dw := (hα z hz_in_r).2.1 t h_t_Icc
+    have h_icc_nhds : Set.Icc (0 : ℝ) (2 * δ) ∈ nhds t := Icc_mem_nhds ht.1 ht.2
+    have h_d : HasDerivAt (α z) (vlasovVectorField gradW ρ t (α z t)) t :=
+      h_dw.hasDerivAt h_icc_nhds
+    have h_proj : HasDerivAt (fun s => (α z s).2)
+        (vlasovVectorField gradW ρ t (α z t)).2 t :=
+      (hasFDerivAt_snd (E := PhysSpace d) (F := PhysSpace d)).comp_hasDerivAt t h_d
+    simpa [vlasovVectorField] using h_proj
+
+
+end Vlasov
diff --git a/LeanPool/Vlasov/OT/CharacteristicFlow.lean b/LeanPool/Vlasov/OT/CharacteristicFlow.lean
index ade83358bb..7d23bb5f4a 100644
--- a/LeanPool/Vlasov/OT/CharacteristicFlow.lean
+++ b/LeanPool/Vlasov/OT/CharacteristicFlow.lean
@@ -5,13 +5,10 @@ Authors: Joseph K. Miller
 -/
 module
 
-public import LeanPool.Vlasov.Basic
-public import LeanPool.Vlasov.OT.Coupling
-public import Mathlib.Analysis.ODE.Gronwall
-import LeanPool.Vlasov.ForMathlib.PicardLindelof
+public import LeanPool.Vlasov.OT.CharacteristicConstruction
+import all LeanPool.Vlasov.OT.CharacteristicConstruction
 import Mathlib.Algebra.Order.Field.GeomSum
 import Mathlib.Analysis.Calculus.ParametricIntegral
-import Mathlib.MeasureTheory.Integral.Prod
 
 /-!
 # Characteristic flow for the Vlasov ODE + Lagrangian-Eulerian equivalence
@@ -53,1082 +50,24 @@ namespace Vlasov
 
 open MeasureTheory ENNReal
 
-/-! ## Vlasov velocity field and its Lipschitz lemma -/
+-- Preserve existing private names when moving their proofs.
+private alias charFlowTight_perZ_trajectory :=
+  _root_.Vlasov.charFlowTight_perZ_trajectory
 
-/-- The Vlasov phase-space vector field:
-`b_t(x, v) := (v, −(∇W ∗ ρ_t)(x))`.
+private alias charFlowTight_piecewise_ode :=
+  _root_.Vlasov.charFlowTight_piecewise_ode
 
-Note that the first component is the identity in `v` (the position
-ODE `x' = v`) and the second component is the mean-field force
-`−∇W ∗ ρ_t` evaluated at `x` (the velocity ODE `v' = −(∇W ∗ ρ)(x)`).
--/
-noncomputable def vlasovVectorField
-    {d : ℕ}
-    (gradW : PhysSpace d → PhysSpace d)
-    (ρ : ℝ → Measure (PhysSpace d))
-    (t : ℝ) (z : PhaseSpace d) : PhaseSpace d :=
-  (z.2, -(convolveFunctionMeasure gradW (ρ t) z.1))
-
-/-- Position-side Lipschitz of the convolution `∇W ∗ ρ`.
-For `gradW` L-Lipschitz and `ρ` a probability measure with finite
-first moment (which guarantees integrability of the kernel), the map
-`x ↦ (∇W ∗ ρ)(x)` is L-Lipschitz.
-
-Proof sketch: by `LipschitzWith.dist_le_mul` applied pointwise to
-`gradW`, then integration over the probability measure `ρ`:
-  ‖∫ y, gradW(x−y) ∂ρ − ∫ y, gradW(x'−y) ∂ρ‖
-    = ‖∫ y, (gradW(x−y) − gradW(x'−y)) ∂ρ‖
-    ≤ ∫ y, ‖gradW(x−y) − gradW(x'−y)‖ ∂ρ
-    ≤ ∫ y, L · ‖x − x'‖ ∂ρ
-    = L · ‖x − x'‖ · ρ(univ)
-    = L · ‖x − x'‖   (probability measure).
-
-The integrability hypotheses on `gradW(x − ·)` for two distinct `x`s
-are needed for `integral_sub` and `norm_integral_le_integral_norm`
-to fire.  At the dobrushin call site these follow from finite first
-moment of `ρ` + Lipschitz growth of `gradW`. -/
-lemma convolveFunctionMeasure_lipschitz_in_x
-    {d : ℕ}
-    (gradW : PhysSpace d → PhysSpace d)
-    (L : NNReal) (hL : LipschitzWith L gradW)
-    (ρ : Measure (PhysSpace d)) [IsProbabilityMeasure ρ]
-    (h_int : ∀ x : PhysSpace d, Integrable (fun y => gradW (x - y)) ρ) :
-    LipschitzWith L (fun x => convolveFunctionMeasure gradW ρ x) := by
-  refine LipschitzWith.of_dist_le_mul (fun x x' => ?_)
-  unfold convolveFunctionMeasure
-  rw [dist_eq_norm, ← integral_sub (h_int x) (h_int x')]
-  -- Pointwise bound: ‖gradW(x − y) − gradW(x' − y)‖ ≤ L · ‖x − x'‖
-  have h_pt : ∀ y, ‖gradW (x - y) - gradW (x' - y)‖ ≤ (L : ℝ) * ‖x - x'‖ :=
-    fun y => by
-    have h_sub : (x - y) - (x' - y) = x - x' := by
-      rw [sub_sub_sub_cancel_right]
-    have := hL.dist_le_mul (x - y) (x' - y)
-    rw [dist_eq_norm, dist_eq_norm, h_sub] at this
-    exact this
-  -- Integrability of the pointwise bound function (a constant).
-  have h_bound_int : Integrable (fun _ : PhysSpace d => (L : ℝ) * ‖x - x'‖) ρ :=
-    integrable_const _
-  -- Integrability of the norm of the difference, via mono'.
-  have h_norm_int : Integrable (fun y => ‖gradW (x - y) - gradW (x' - y)‖) ρ :=
-    Integrable.mono' h_bound_int ((h_int x).sub (h_int x')).norm.aestronglyMeasurable
-      (Filter.Eventually.of_forall fun y => by
-        rw [Real.norm_eq_abs, abs_of_nonneg (norm_nonneg _)]
-        exact h_pt y)
-  calc ‖∫ y, gradW (x - y) - gradW (x' - y) ∂ρ‖
-      ≤ ∫ y, ‖gradW (x - y) - gradW (x' - y)‖ ∂ρ :=
-        norm_integral_le_integral_norm _
-    _ ≤ ∫ _, (L : ℝ) * ‖x - x'‖ ∂ρ :=
-        integral_mono_ae h_norm_int h_bound_int (Filter.Eventually.of_forall h_pt)
-    _ = (L : ℝ) * ‖x - x'‖ := by
-        simp [integral_const, measureReal_def, measure_univ]
+private alias charFlowTight_window_forceBound :=
+  _root_.Vlasov.charFlowTight_window_forceBound
 
-/-! ## Flow distance growth bound (Gronwall on the characteristic ODE)
+private alias charFlowTight_window_step :=
+  _root_.Vlasov.charFlowTight_window_step
 
-A standalone regularity theorem about `IsCharacteristicFlow`: solutions of
-the characteristic ODE have at most linear growth in their initial condition,
-with a constant depending on `T`, the Lipschitz constant of `gradW`, and a
-uniform first-moment bound on the measure curve `ρ`.
+private alias charFlowTight_window_velocity_carry :=
+  _root_.Vlasov.charFlowTight_window_velocity_carry
 
-Math content: Gronwall on the position-velocity pair, using
-  `‖(∇W ∗ ρ_t)(x)‖ ≤ ‖gradW 0‖ + L · (‖x‖ + ∫‖y‖dρ_t)`
-as the velocity-field bound. -/
-
-/-- **`IsCharacteristicFlowOn`-flavored variant of `flow_distance_growth_bound`**.
-
-Same Gronwall growth bound, but for a flow specified by **boundary regularity
-hypotheses** (`h_init`, `h_cont_Icc`, `h_deriv_Ico`) instead of the universal-in-`t`
-ODE of `IsCharacteristicFlow`.  This matches what
-`exists_vlasov_characteristicFlow_global_smallT` produces (modulo deriving the
-boundary regularity from `IsCharacteristicFlowOn`'s `Ioo 0 T` ODE clauses), and
-mirrors the hypothesis-passing pattern of `charFlow_measurable_via_gronwall`.
-
-**Used by**: `Phi_step` to derive the per-`z` growth bound
-(`PhiAsVlasovMeasureCurve`'s `h_growth` hypothesis); window uniqueness is a
-natural secondary consumer.
-
-The global `flow_distance_growth_bound` follows by supplying its initial
-condition, continuity and derivative statements as boundary regularity.
-
-**Metric-dependence note**:
-This bound uses the unbounded position difference `‖X^M(t,z) - X^{M'}(t,z)‖`,
-which forces Gronwall and produces exponential-in-`T` constants
-`C_T ≈ exp((1+L)·T)`.  The `Wbar = W_{min(|x-y|,1)}` analog (Dobrushin 1979, §5)
-uses the bounded-and-Lipschitz absorption
-  `|B_μ(x) - B_{μ'}(x)| ≤ max(2‖B‖_∞, C_B) · min(|x₁-x₂|, 1)`
-and produces *linear-in-`T`* constants (Dobrushin 1979, eq. 5.7), changing this
-output shape from `C_T · (‖z‖ + 1)` to a bounded analog. -/
-theorem flow_distance_growth_bound_on
-    {d : ℕ}
-    (gradW : PhysSpace d → PhysSpace d)
-    (L : NNReal) (hL : LipschitzWith L gradW)
-    (ρ : ℝ → Measure (PhysSpace d))
-    [∀ t, IsProbabilityMeasure (ρ t)]
-    (charX charV : ℝ → PhaseSpace d → PhysSpace d)
-    (T : ℝ) (hT : 0 ≤ T)
-    -- Boundary regularity, replacing IsCharacteristicFlow's universal ODE.
-    (h_init : ∀ z : PhaseSpace d, (charX 0 z, charV 0 z) = z)
-    (h_cont_Icc : ∀ z : PhaseSpace d,
-        ContinuousOn (fun s => (charX s z, charV s z)) (Set.Icc (0 : ℝ) T))
-    (h_deriv_Ico : ∀ z : PhaseSpace d, ∀ s ∈ Set.Ico (0 : ℝ) T,
-        HasDerivWithinAt (fun s' => (charX s' z, charV s' z))
-          (vlasovVectorField gradW ρ s (charX s z, charV s z))
-          (Set.Ici s) s)
-    -- ρ regularity, identical to flow_distance_growth_bound's hypotheses.
-    (M_ρ : ℝ) (hM_ρ_nn : 0 ≤ M_ρ)
-    (hM_ρ : ∀ t ∈ Set.Icc 0 T, ∫ y, ‖y‖ ∂(ρ t) ≤ M_ρ)
-    (h_y_int : ∀ t ∈ Set.Icc 0 T, Integrable (fun y : PhysSpace d => ‖y‖) (ρ t))
-    (h_int : ∀ t (x : PhysSpace d), Integrable (fun y => gradW (x - y)) (ρ t)) :
-    ∃ C_T, 0 ≤ C_T ∧
-      ∀ t ∈ Set.Icc 0 T, ∀ z : PhaseSpace d,
-        ‖(charX t z, charV t z)‖ ≤ C_T * (‖z‖ + 1) := by
-  -- Gronwall parameters: K = 1 + L, ε₀ = ‖gradW 0‖ + L * M_ρ.
-  set K := 1 + (L : ℝ) with hK_def
-  set ε₀ := ‖gradW 0‖ + (L : ℝ) * M_ρ with hε₀_def
-  have hK_pos : 0 < K := by positivity
-  have hε₀_nn : 0 ≤ ε₀ := by positivity
-  -- Witness: C_T = gronwallBound 1 K ε₀ T.
-  use gronwallBound 1 K ε₀ T
-  refine ⟨?_, ?_⟩
-  · have hmono := gronwallBound_mono (by norm_num : (0 : ℝ) ≤ 1) hε₀_nn hK_pos.le hT
-    linarith [gronwallBound_x0 1 K ε₀]
-  · intro t ht z
-    -- Convolution bound: ‖(∇W ∗ ρ_t)(x)‖ ≤ ε₀ + L * ‖x‖.
-    have h_conv_bound : ∀ s ∈ Set.Icc 0 T, ∀ x : PhysSpace d,
-        ‖convolveFunctionMeasure gradW (ρ s) x‖ ≤ ε₀ + (L : ℝ) * ‖x‖ := by
-      intro s hs x
-      unfold convolveFunctionMeasure
-      have h_sub_int : Integrable (fun y => ‖x - y‖) (ρ s) :=
-        Integrable.mono' ((integrable_const ‖x‖).add (h_y_int s hs))
-          ((aestronglyMeasurable_const (b := x)).sub aestronglyMeasurable_id |>.norm)
-          (Filter.Eventually.of_forall fun y => by
-            simp only [Real.norm_of_nonneg (norm_nonneg _)]
-            exact norm_sub_le x y)
-      have h_bnd_int : Integrable (fun y => ‖gradW 0‖ + (L : ℝ) * ‖x - y‖) (ρ s) :=
-        (integrable_const _).add (h_sub_int.const_mul _)
-      have h_pt : ∀ y : PhysSpace d,
-          ‖gradW (x - y)‖ ≤ ‖gradW 0‖ + (L : ℝ) * ‖x - y‖ := by
-        intro y
-        have hd := hL.dist_le_mul (x - y) 0
-        simp only [dist_eq_norm, sub_zero] at hd
-        have h_tri : ‖gradW (x - y)‖ ≤ ‖gradW 0‖ + ‖gradW (x - y) - gradW 0‖ := by
-          have := norm_add_le (gradW (x - y) - gradW 0) (gradW 0)
-          simp only [sub_add_cancel] at this
-          linarith
-        linarith
-      calc ‖∫ y, gradW (x - y) ∂(ρ s)‖
-          ≤ ∫ y, ‖gradW (x - y)‖ ∂(ρ s) := norm_integral_le_integral_norm _
-        _ ≤ ∫ y, (‖gradW 0‖ + (L : ℝ) * ‖x - y‖) ∂(ρ s) :=
-            integral_mono (h_int s x).norm h_bnd_int h_pt
-        _ = ‖gradW 0‖ + (L : ℝ) * ∫ y, ‖x - y‖ ∂(ρ s) := by
-            rw [integral_add (integrable_const _) (h_sub_int.const_mul _)]
-            simp [integral_const, measureReal_def, measure_univ, integral_const_mul]
-        _ ≤ ‖gradW 0‖ + (L : ℝ) * (‖x‖ + M_ρ) := by
-            have hint_bd : ∫ y, ‖x - y‖ ∂(ρ s) ≤ ‖x‖ + M_ρ := by
-              calc ∫ y, ‖x - y‖ ∂(ρ s)
-                  ≤ ∫ y, (‖x‖ + ‖y‖) ∂(ρ s) :=
-                    integral_mono h_sub_int
-                      ((integrable_const _).add (h_y_int s hs))
-                      (fun y => norm_sub_le x y)
-                _ = ‖x‖ + ∫ y, ‖y‖ ∂(ρ s) := by
-                    rw [integral_add (integrable_const _) (h_y_int s hs)]
-                    simp [integral_const, measureReal_def, measure_univ]
-                _ ≤ ‖x‖ + M_ρ := by linarith [hM_ρ s hs]
-            have := mul_le_mul_of_nonneg_left hint_bd L.coe_nonneg
-            linarith
-        _ = ε₀ + (L : ℝ) * ‖x‖ := by
-            simp only [hε₀_def]; ring
-    -- Gronwall step.  Boundary regularity comes from hypotheses, not from
-    -- IsCharacteristicFlow.
-    have h_f_cont : ContinuousOn (fun s => (charX s z, charV s z)) (Set.Icc 0 T) :=
-      h_cont_Icc z
-    have h_deriv : ∀ s ∈ Set.Ico 0 T,
-        HasDerivWithinAt (fun s => (charX s z, charV s z))
-          (charV s z, -convolveFunctionMeasure gradW (ρ s) (charX s z))
-          (Set.Ici s) s := by
-      intro s hs
-      have hderiv := h_deriv_Ico z s hs
-      -- vlasovVectorField gradW ρ s (charX s z, charV s z) = (charV s z, -conv ...)
-      unfold vlasovVectorField at hderiv
-      exact hderiv
-    have h_init_norm : ‖(charX 0 z, charV 0 z)‖ ≤ ‖z‖ := by
-      rw [h_init z]
-    have h_bound : ∀ s ∈ Set.Ico 0 T,
-        ‖(charV s z, -convolveFunctionMeasure gradW (ρ s) (charX s z))‖ ≤
-          K * ‖(charX s z, charV s z)‖ + ε₀ := by
-      intro s hs
-      have hs_mem : s ∈ Set.Icc 0 T := ⟨hs.1, le_of_lt hs.2⟩
-      simp only [Prod.norm_def, norm_neg]
-      have hFsz := le_max_left ‖charX s z‖ ‖charV s z‖
-      have hGsz := le_max_right ‖charX s z‖ ‖charV s z‖
-      have hM_nn : 0 ≤ max ‖charX s z‖ ‖charV s z‖ :=
-        le_max_iff.mpr (Or.inl (norm_nonneg _))
-      have h_v_le : ‖charV s z‖ ≤ K * max ‖charX s z‖ ‖charV s z‖ + ε₀ :=
-        calc ‖charV s z‖ ≤ max ‖charX s z‖ ‖charV s z‖ := hGsz
-          _ ≤ K * max ‖charX s z‖ ‖charV s z‖ :=
-              le_mul_of_one_le_left hM_nn (by linarith [NNReal.coe_nonneg L])
-          _ ≤ K * max ‖charX s z‖ ‖charV s z‖ + ε₀ := le_add_of_nonneg_right hε₀_nn
-      have h_conv_le : ‖convolveFunctionMeasure gradW (ρ s) (charX s z)‖ ≤
-          K * max ‖charX s z‖ ‖charV s z‖ + ε₀ :=
-        calc ‖convolveFunctionMeasure gradW (ρ s) (charX s z)‖
-            ≤ ε₀ + (L : ℝ) * ‖charX s z‖ := h_conv_bound s hs_mem _
-          _ ≤ ε₀ + K * max ‖charX s z‖ ‖charV s z‖ := by
-              have hLK : (L : ℝ) ≤ K := le_add_of_nonneg_left zero_le_one
-              linarith [mul_le_mul_of_nonneg_left hFsz (NNReal.coe_nonneg L),
-                        mul_le_mul_of_nonneg_right hLK hM_nn]
-          _ = K * max ‖charX s z‖ ‖charV s z‖ + ε₀ := by ring
-      exact max_le h_v_le h_conv_le
-    have h_grw := norm_le_gronwallBound_of_norm_deriv_right_le
-      h_f_cont h_deriv h_init_norm h_bound t ht
-    simp only [sub_zero] at h_grw
-    calc ‖(charX t z, charV t z)‖
-        ≤ gronwallBound ‖z‖ K ε₀ t := h_grw
-      _ ≤ gronwallBound ‖z‖ K ε₀ T :=
-          gronwallBound_mono (norm_nonneg _) hε₀_nn hK_pos.le ht.2
-      _ ≤ gronwallBound 1 K ε₀ T * (‖z‖ + 1) := by
-          rw [gronwallBound_of_K_ne_0 hK_pos.ne', gronwallBound_of_K_ne_0 hK_pos.ne']
-          simp only [one_mul]
-          have he1 : 0 ≤ Real.exp (K * T) - 1 :=
-            by linarith [Real.one_le_exp (mul_nonneg hK_pos.le hT)]
-          have hεK := div_nonneg hε₀_nn hK_pos.le
-          nlinarith [norm_nonneg z, Real.exp_nonneg (K * T),
-            mul_nonneg hεK he1, mul_nonneg (norm_nonneg z) (mul_nonneg hεK he1)]
-
-/-- **Flow distance growth bound** (`L`-Lipschitz `gradW`, uniform first moment
-on `ρ`).  Solutions of the characteristic ODE grow at most linearly in their
-initial condition: `‖(charX t z, charV t z)‖ ≤ C_T · (‖z‖ + 1)` for some
-`C_T` depending only on `T`, `L`, `‖gradW 0‖`, and the uniform first-moment
-bound `M_ρ`. -/
-theorem flow_distance_growth_bound
-    {d : ℕ}
-    (gradW : PhysSpace d → PhysSpace d)
-    (L : NNReal) (hL : LipschitzWith L gradW)
-    (ρ : ℝ → Measure (PhysSpace d))
-    [∀ t, IsProbabilityMeasure (ρ t)]
-    (charX charV : ℝ → PhaseSpace d → PhysSpace d)
-    (hflow : IsCharacteristicFlow gradW ρ charX charV)
-    (T : ℝ) (hT : 0 ≤ T)
-    (M_ρ : ℝ) (hM_ρ_nn : 0 ≤ M_ρ)
-    (hM_ρ : ∀ t ∈ Set.Icc 0 T, ∫ y, ‖y‖ ∂(ρ t) ≤ M_ρ)
-    (h_y_int : ∀ t ∈ Set.Icc 0 T, Integrable (fun y : PhysSpace d => ‖y‖) (ρ t))
-    (h_int : ∀ t (x : PhysSpace d), Integrable (fun y => gradW (x - y)) (ρ t)) :
-    ∃ C_T, 0 ≤ C_T ∧
-      ∀ t ∈ Set.Icc 0 T, ∀ z : PhaseSpace d,
-        ‖(charX t z, charV t z)‖ ≤ C_T * (‖z‖ + 1) := by
-  obtain ⟨hflow_init, hflow_x, hflow_v⟩ := hflow
-  refine flow_distance_growth_bound_on gradW L hL ρ charX charV T hT
-    (fun z => Prod.ext (hflow_init z).1 (hflow_init z).2) ?_ ?_
-    M_ρ hM_ρ_nn hM_ρ h_y_int h_int
-  · intro z
-    exact continuousOn_of_forall_continuousAt fun s _ =>
-      (hflow_x s z).continuousAt.prodMk (hflow_v s z).continuousAt
-  · intro z s _
-    exact ((hflow_x s z).prodMk (hflow_v s z)).hasDerivWithinAt
-
-/-- **Two-flow difference Gronwall bound** — the reusable core of the
-integrated Dobrushin coupling bound.  The distance between two trajectories
-`Φ_f · z₁`, `Φ_g · z₂` of flows generated by fields `b_f, b_g` (`b_f`
-`L`-Lipschitz in space) grows by Gronwall: if the field difference *at the
-second trajectory* is bounded by `ε` on `[0, T]` and the initial separation by
-`δ`, then `‖Φ_f t z₁ - Φ_g t z₂‖ ≤ gronwallBound δ L ε t`.
-
-Mirrors `flow_distance_growth_bound`'s Gronwall structure
-(`norm_le_gronwallBound_of_norm_deriv_right_le`) but for the *difference* of two
-flows.  In the integrated-bound application, `z₁ = ω.1`, `z₂ = ω.2` range over a
-coupling `π₀` of `(f 0, g 0)`, `ε = (L : ℝ) * (wasserstein1 (f s) (g s)).toReal`
-(the self-coupling diff-bound, uniform in the trajectory), and integrating this
-pointwise bound over `π₀` against the pushforward bound gives the Dobrushin
-estimate `W₁(f t, g t) ≤ … · W₁(f 0, g 0)`. -/
-theorem flow_difference_growth_bound
-    {α : Type*} [NormedAddCommGroup α] [NormedSpace ℝ α]
-    (b_f b_g : ℝ → α → α) (L : NNReal) (hL_f : ∀ t, LipschitzWith L (b_f t))
-    (Φ_f Φ_g : ℝ → α → α) (z₁ z₂ : α)
-    (T : ℝ)
-    (hcont_f : ContinuousOn (fun s => Φ_f s z₁) (Set.Icc 0 T))
-    (hcont_g : ContinuousOn (fun s => Φ_g s z₂) (Set.Icc 0 T))
-    (hΦ_f : ∀ s ∈ Set.Ico 0 T,
-      HasDerivWithinAt (fun u => Φ_f u z₁) (b_f s (Φ_f s z₁)) (Set.Ici s) s)
-    (hΦ_g : ∀ s ∈ Set.Ico 0 T,
-      HasDerivWithinAt (fun u => Φ_g u z₂) (b_g s (Φ_g s z₂)) (Set.Ici s) s)
-    (δ ε : ℝ) (h_init : ‖Φ_f 0 z₁ - Φ_g 0 z₂‖ ≤ δ)
-    (h_diff : ∀ s ∈ Set.Icc 0 T,
-      ‖b_f s (Φ_g s z₂) - b_g s (Φ_g s z₂)‖ ≤ ε) :
-    ∀ t ∈ Set.Icc 0 T,
-      ‖Φ_f t z₁ - Φ_g t z₂‖ ≤ gronwallBound δ (L : ℝ) ε t := by
-  have hcont : ContinuousOn (fun s => Φ_f s z₁ - Φ_g s z₂) (Set.Icc 0 T) :=
-    hcont_f.sub hcont_g
-  have hderiv : ∀ s ∈ Set.Ico 0 T,
-      HasDerivWithinAt (fun u => Φ_f u z₁ - Φ_g u z₂)
-        (b_f s (Φ_f s z₁) - b_g s (Φ_g s z₂)) (Set.Ici s) s :=
-    fun s hs => (hΦ_f s hs).sub (hΦ_g s hs)
-  have hbound : ∀ s ∈ Set.Ico 0 T,
-      ‖b_f s (Φ_f s z₁) - b_g s (Φ_g s z₂)‖ ≤
-        (L : ℝ) * ‖Φ_f s z₁ - Φ_g s z₂‖ + ε := by
-    intro s hs
-    have hs_icc : s ∈ Set.Icc 0 T := ⟨hs.1, hs.2.le⟩
-    have h_lip : ‖b_f s (Φ_f s z₁) - b_f s (Φ_g s z₂)‖ ≤
-        (L : ℝ) * ‖Φ_f s z₁ - Φ_g s z₂‖ := by
-      have := (hL_f s).dist_le_mul (Φ_f s z₁) (Φ_g s z₂)
-      rwa [dist_eq_norm, dist_eq_norm] at this
-    calc ‖b_f s (Φ_f s z₁) - b_g s (Φ_g s z₂)‖
-        = ‖(b_f s (Φ_f s z₁) - b_f s (Φ_g s z₂)) +
-            (b_f s (Φ_g s z₂) - b_g s (Φ_g s z₂))‖ := by congr 1; abel
-      _ ≤ ‖b_f s (Φ_f s z₁) - b_f s (Φ_g s z₂)‖ +
-            ‖b_f s (Φ_g s z₂) - b_g s (Φ_g s z₂)‖ := norm_add_le _ _
-      _ ≤ (L : ℝ) * ‖Φ_f s z₁ - Φ_g s z₂‖ + ε :=
-            add_le_add h_lip (h_diff s hs_icc)
-  intro t ht
-  have hg := norm_le_gronwallBound_of_norm_deriv_right_le hcont hderiv h_init hbound t ht
-  simpa using hg
-
-/-- **Per-trajectory mild (integral-form) difference bound.**
-Mild-form companion to `flow_difference_growth_bound`:
-the raw integral inequality
-`‖γ_f t − γ_g t‖ ≤ ‖γ_f 0 − γ_g 0‖ + ∫₀ᵗ (L‖γ_f s − γ_g s‖ + ε s) ds`,
-keeping the forcing `ε s` *inside* the integral.  After integrating this over
-the base measure, the self-reference `ε s = L·W₁(f s,g s) ≤ L·Q(s)` is resolved
-by `gronwall_mild_le` — avoiding the constant-`ε` smallness that
-`flow_difference_growth_bound`'s closed form would force (and the blocked
-windowing that smallness needs). -/
-theorem flow_difference_mild_bound
-    {α : Type*} [NormedAddCommGroup α] [NormedSpace ℝ α] [CompleteSpace α]
-    (b_f b_g : ℝ → α → α) (L : NNReal) (hL_f : ∀ t, LipschitzWith L (b_f t))
-    (γ_f γ_g : ℝ → α) (T : ℝ)
-    (hcont_f : ContinuousOn γ_f (Set.Icc 0 T))
-    (hcont_g : ContinuousOn γ_g (Set.Icc 0 T))
-    (hderiv_f : ∀ s ∈ Set.Ioo (0 : ℝ) T,
-      HasDerivWithinAt γ_f (b_f s (γ_f s)) (Set.Ioi s) s)
-    (hderiv_g : ∀ s ∈ Set.Ioo (0 : ℝ) T,
-      HasDerivWithinAt γ_g (b_g s (γ_g s)) (Set.Ioi s) s)
-    (hint : IntervalIntegrable (fun s => b_f s (γ_f s) - b_g s (γ_g s))
-      MeasureTheory.volume 0 T)
-    (ε : ℝ → ℝ) (hε_int : IntervalIntegrable ε MeasureTheory.volume 0 T)
-    (h_diff : ∀ s ∈ Set.Icc (0 : ℝ) T, ‖b_f s (γ_g s) - b_g s (γ_g s)‖ ≤ ε s) :
-    ∀ t ∈ Set.Icc (0 : ℝ) T,
-      ‖γ_f t - γ_g t‖ ≤ ‖γ_f 0 - γ_g 0‖ +
-        ∫ s in (0 : ℝ)..t, ((L : ℝ) * ‖γ_f s - γ_g s‖ + ε s) := by
-  intro t ht
-  have h0t : (0 : ℝ) ≤ t := ht.1
-  have htT : t ≤ T := ht.2
-  have hIcc_sub : Set.Icc (0 : ℝ) t ⊆ Set.Icc 0 T := Set.Icc_subset_Icc_right htT
-  have hcont_diff : ContinuousOn (fun s => γ_f s - γ_g s) (Set.Icc 0 t) :=
-    (hcont_f.mono hIcc_sub).sub (hcont_g.mono hIcc_sub)
-  have hderiv_diff : ∀ s ∈ Set.Ioo (0 : ℝ) t,
-      HasDerivWithinAt (fun s => γ_f s - γ_g s)
-        (b_f s (γ_f s) - b_g s (γ_g s)) (Set.Ioi s) s := by
-    intro s hs
-    have hs' : s ∈ Set.Ioo (0 : ℝ) T := ⟨hs.1, hs.2.trans_le htT⟩
-    exact (hderiv_f s hs').sub (hderiv_g s hs')
-  have hint_t : IntervalIntegrable (fun s => b_f s (γ_f s) - b_g s (γ_g s))
-      MeasureTheory.volume 0 t :=
-    hint.mono_set (by
-      rw [Set.uIcc_of_le h0t, Set.uIcc_of_le (h0t.trans htT)]; exact hIcc_sub)
-  have hftc := intervalIntegral.integral_eq_sub_of_hasDeriv_right_of_le h0t hcont_diff
-    hderiv_diff hint_t
-  have hsplit : ∀ s ∈ Set.Icc (0 : ℝ) t,
-      ‖b_f s (γ_f s) - b_g s (γ_g s)‖ ≤ (L:ℝ) * ‖γ_f s - γ_g s‖ + ε s := by
-    intro s hs
-    have hsT : s ∈ Set.Icc (0 : ℝ) T := hIcc_sub hs
-    have h_lip : ‖b_f s (γ_f s) - b_f s (γ_g s)‖ ≤ (L:ℝ) * ‖γ_f s - γ_g s‖ := by
-      have := (hL_f s).dist_le_mul (γ_f s) (γ_g s)
-      rwa [dist_eq_norm, dist_eq_norm] at this
-    calc ‖b_f s (γ_f s) - b_g s (γ_g s)‖
-        = ‖(b_f s (γ_f s) - b_f s (γ_g s)) + (b_f s (γ_g s) - b_g s (γ_g s))‖ := by
-          congr 1; abel
-      _ ≤ ‖b_f s (γ_f s) - b_f s (γ_g s)‖ + ‖b_f s (γ_g s) - b_g s (γ_g s)‖ :=
-          norm_add_le _ _
-      _ ≤ (L:ℝ) * ‖γ_f s - γ_g s‖ + ε s := add_le_add h_lip (h_diff s hsT)
-  have hci : IntervalIntegrable (fun s => (L:ℝ) * ‖γ_f s - γ_g s‖ + ε s)
-      MeasureTheory.volume 0 t := by
-    refine IntervalIntegrable.add (IntervalIntegrable.const_mul ?_ (L:ℝ))
-      (hε_int.mono_set (by
-        rw [Set.uIcc_of_le h0t, Set.uIcc_of_le (h0t.trans htT)]; exact hIcc_sub))
-    refine ContinuousOn.intervalIntegrable ?_
-    rw [Set.uIcc_of_le h0t]; exact hcont_diff.norm
-  have hnorm_le : ‖∫ s in (0 : ℝ)..t, (b_f s (γ_f s) - b_g s (γ_g s))‖ ≤
-      ∫ s in (0 : ℝ)..t, ((L:ℝ) * ‖γ_f s - γ_g s‖ + ε s) := by
-    calc ‖∫ s in (0 : ℝ)..t, (b_f s (γ_f s) - b_g s (γ_g s))‖
-        ≤ ∫ s in (0 : ℝ)..t, ‖b_f s (γ_f s) - b_g s (γ_g s)‖ :=
-          intervalIntegral.norm_integral_le_integral_norm h0t
-      _ ≤ ∫ s in (0 : ℝ)..t, ((L:ℝ) * ‖γ_f s - γ_g s‖ + ε s) :=
-          intervalIntegral.integral_mono_on h0t hint_t.norm hci hsplit
-  have ha_le : ‖γ_f t - γ_g t‖ ≤ ‖γ_f 0 - γ_g 0‖ +
-      ‖∫ s in (0 : ℝ)..t, (b_f s (γ_f s) - b_g s (γ_g s))‖ := by
-    have heq : (γ_f t - γ_g t) - (γ_f 0 - γ_g 0) =
-        ∫ s in (0 : ℝ)..t, (b_f s (γ_f s) - b_g s (γ_g s)) := hftc.symm
-    calc ‖γ_f t - γ_g t‖
-        = ‖(γ_f 0 - γ_g 0) + ((γ_f t - γ_g t) - (γ_f 0 - γ_g 0))‖ := by congr 1; abel
-      _ ≤ ‖γ_f 0 - γ_g 0‖ + ‖(γ_f t - γ_g t) - (γ_f 0 - γ_g 0)‖ := norm_add_le _ _
-      _ = ‖γ_f 0 - γ_g 0‖ + ‖∫ s in (0 : ℝ)..t, (b_f s (γ_f s) - b_g s (γ_g s))‖ := by
-          rw [heq]
-  linarith [ha_le, hnorm_le]
-
-/-- **Integrate a per-trajectory mild bound over the base measure (Tonelli step).**
-Given a base probability measure `π` on `Ω` and a family `w : ℝ → Ω → α`, if each
-trajectory satisfies the mild bound `‖w t ω‖ ≤ ‖w 0 ω‖ + ∫₀ᵗ (L‖w s ω‖ + ε s) ds`,
-then the integrated quantity `Q t := ∫ ‖w t ω‖ ∂π` satisfies
-`Q t ≤ Q 0 + ∫₀ᵗ (L · Q s + ε s) ds`. The `∫₀ᵗ L‖w s ω‖` term swaps via Tonelli. -/
-theorem integral_mild_bound
-    {Ω α : Type*} [MeasurableSpace Ω] [NormedAddCommGroup α]
-    [MeasurableSpace α] [BorelSpace α]
-    (π : Measure Ω) [IsProbabilityMeasure π]
-    (w : ℝ → Ω → α) (L : ℝ) (hL : 0 ≤ L) (ε : ℝ → ℝ) (T : ℝ) (hT : 0 ≤ T)
-    -- joint-measurability inputs (Carathéodory: continuous-in-time + measurable-in-ω)
-    (hw_cont : ∀ ω, Continuous (fun s => w s ω))
-    (hw_meas : ∀ s, Measurable (w s))
-    -- domination: ‖w s ω‖ ≤ dom ω uniformly on [0,T], dom integrable
-    (dom : Ω → ℝ) (hdom_int : Integrable dom π)
-    (hdom : ∀ s ∈ Set.Icc (0 : ℝ) T, ∀ ω, ‖w s ω‖ ≤ dom ω)
-    (hε_int : IntervalIntegrable ε MeasureTheory.volume 0 T)
-    (hε_nn : ∀ s ∈ Set.Icc (0 : ℝ) T, 0 ≤ ε s)
-    -- the per-trajectory mild bound (e.g. from flow_difference_mild_bound)
-    (hper : ∀ ω, ∀ t ∈ Set.Icc (0 : ℝ) T,
-      ‖w t ω‖ ≤ ‖w 0 ω‖ + ∫ s in (0 : ℝ)..t, (L * ‖w s ω‖ + ε s)) :
-    ∀ t ∈ Set.Icc (0 : ℝ) T,
-      (∫ ω, ‖w t ω‖ ∂π) ≤ (∫ ω, ‖w 0 ω‖ ∂π) +
-        ∫ s in (0 : ℝ)..t, (L * (∫ ω, ‖w s ω‖ ∂π) + ε s) := by
-  -- joint measurability of `(s, ω) ↦ w s ω` and of its norm
-  have hjoint : Measurable (Function.uncurry w) :=
-    measurable_uncurry_of_continuous_of_measurable hw_cont hw_meas
-  have hjoint_norm : Measurable (fun p : ℝ × Ω => ‖w p.1 p.2‖) := hjoint.norm
-  -- abbreviation Q s := ∫ ω, ‖w s ω‖ ∂π
-  set Q : ℝ → ℝ := fun s => ∫ ω, ‖w s ω‖ ∂π with hQ
-  intro t ht
-  have h0t : (0 : ℝ) ≤ t := ht.1
-  have htT : t ≤ T := ht.2
-  have hIcc_sub : Set.Icc (0 : ℝ) t ⊆ Set.Icc 0 T := Set.Icc_subset_Icc_right htT
-  -- `w 0 ·` and `w t ·` are integrable over π (dominated by `dom`)
-  have h0_mem : (0 : ℝ) ∈ Set.Icc (0 : ℝ) T := ⟨le_refl 0, hT⟩
-  have ht_mem : t ∈ Set.Icc (0 : ℝ) T := ht
-  have hint0 : Integrable (fun ω => ‖w 0 ω‖) π := by
-    refine hdom_int.mono' ((hw_meas 0).norm.aestronglyMeasurable) ?_
-    filter_upwards with ω
-    rw [Real.norm_of_nonneg (norm_nonneg _)]
-    exact hdom 0 h0_mem ω
-  have hintt : Integrable (fun ω => ‖w t ω‖) π := by
-    refine hdom_int.mono' ((hw_meas t).norm.aestronglyMeasurable) ?_
-    filter_upwards with ω
-    rw [Real.norm_of_nonneg (norm_nonneg _)]
-    exact hdom t ht_mem ω
-  -- the inner integrand `g s ω := L * ‖w s ω‖ + ε s`
-  set g : ℝ → Ω → ℝ := fun s ω => L * ‖w s ω‖ + ε s with hg
-  -- product measure for the Tonelli swap
-  -- `volume.restrict (Set.uIoc 0 t)` is a finite measure (`uIoc 0 t = Ioc 0 t`)
-  have huIoc : Set.uIoc (0 : ℝ) t = Set.Ioc 0 t := Set.uIoc_of_le h0t
-  have hvol_lt : MeasureTheory.volume (Set.uIoc (0 : ℝ) t) < ⊤ := by
-    rw [huIoc, Real.volume_Ioc]; exact ENNReal.ofReal_lt_top
-  have hfin_restrict : IsFiniteMeasure (MeasureTheory.volume.restrict (Set.uIoc (0 : ℝ) t)) := by
-    refine ⟨?_⟩
-    rw [Measure.restrict_apply_univ]; exact hvol_lt
-  -- `ε` is integrable over `volume.restrict (uIoc 0 t)`
-  have hε_int_t : IntervalIntegrable ε MeasureTheory.volume 0 t :=
-    hε_int.mono_set (by
-      rw [Set.uIcc_of_le h0t, Set.uIcc_of_le hT]; exact Set.Icc_subset_Icc_right htT)
-  have hε_intOn : Integrable ε (MeasureTheory.volume.restrict (Set.uIoc (0 : ℝ) t)) :=
-    hε_int_t.def'
-  -- AEStronglyMeasurability of `uncurry g` over the product measure
-  have hg_aesm : AEStronglyMeasurable (Function.uncurry g)
-      ((MeasureTheory.volume.restrict (Set.uIoc (0 : ℝ) t)).prod π) := by
-    have h1 : AEStronglyMeasurable (fun p : ℝ × Ω => L * ‖w p.1 p.2‖)
-        ((MeasureTheory.volume.restrict (Set.uIoc (0 : ℝ) t)).prod π) :=
-      (measurable_const.mul hjoint_norm).aestronglyMeasurable
-    have h2 : AEStronglyMeasurable (fun p : ℝ × Ω => ε p.1)
-        ((MeasureTheory.volume.restrict (Set.uIoc (0 : ℝ) t)).prod π) :=
-      hε_intOn.aestronglyMeasurable.comp_fst
-    exact h1.add h2
-  -- product integrability of `uncurry g`, via the dominator `L·dom(ω) + ε(s)`
-  have hdom_prod : Integrable (fun p : ℝ × Ω => L * dom p.2 + ε p.1)
-      ((MeasureTheory.volume.restrict (Set.uIoc (0 : ℝ) t)).prod π) :=
-    ((hdom_int.const_mul L).comp_snd
-        (MeasureTheory.volume.restrict (Set.uIoc (0 : ℝ) t))).add (hε_intOn.comp_fst π)
-  have hae_fst : ∀ᵐ p : ℝ × Ω
-      ∂((MeasureTheory.volume.restrict (Set.uIoc (0 : ℝ) t)).prod π), p.1 ∈ Set.uIoc (0 : ℝ) t :=
-    (MeasureTheory.Measure.quasiMeasurePreserving_fst).tendsto_ae.eventually
-      (MeasureTheory.ae_restrict_mem measurableSet_uIoc)
-  have hg_int : Integrable (Function.uncurry g)
-      ((MeasureTheory.volume.restrict (Set.uIoc (0 : ℝ) t)).prod π) := by
-    refine hdom_prod.mono' hg_aesm ?_
-    filter_upwards [hae_fst] with p hp
-    have hp_icc : p.1 ∈ Set.Icc (0 : ℝ) T := by
-      rw [huIoc] at hp; exact ⟨le_of_lt hp.1, hp.2.trans htT⟩
-    have hwle : ‖w p.1 p.2‖ ≤ dom p.2 := hdom p.1 hp_icc p.2
-    have hεnn : 0 ≤ ε p.1 := hε_nn p.1 hp_icc
-    have hg_nn : 0 ≤ L * ‖w p.1 p.2‖ + ε p.1 :=
-      add_nonneg (mul_nonneg hL (norm_nonneg _)) hεnn
-    change ‖L * ‖w p.1 p.2‖ + ε p.1‖ ≤ L * dom p.2 + ε p.1
-    rw [Real.norm_of_nonneg hg_nn]
-    nlinarith [mul_le_mul_of_nonneg_left hwle hL]
-  -- inner intervalIntegral = integral against the restricted measure
-  have hconv : ∀ ω, (∫ s in (0 : ℝ)..t, g s ω)
-      = ∫ s, g s ω ∂(MeasureTheory.volume.restrict (Set.uIoc (0 : ℝ) t)) := by
-    intro ω
-    rw [intervalIntegral.integral_of_le h0t, ← huIoc]
-  -- marginal integrability `ω ↦ ∫ s, g s ω`
-  have hmarg : Integrable
-      (fun ω => ∫ s, g s ω ∂(MeasureTheory.volume.restrict (Set.uIoc (0 : ℝ) t))) π :=
-    hg_int.integral_prod_right
-  have hinner_int : Integrable (fun ω => ∫ s in (0 : ℝ)..t, g s ω) π := by
-    simpa only [hconv] using hmarg
-  -- per-`s` identity  ∫ ω, g s ω ∂π = L · (∫ ω, ‖w s ω‖ ∂π) + ε s
-  have hg_int_s : ∀ s ∈ Set.Icc (0 : ℝ) T, Integrable (fun ω => ‖w s ω‖) π := by
-    intro s hs
-    refine hdom_int.mono' ((hw_meas s).norm.aestronglyMeasurable) ?_
-    filter_upwards with ω
-    rw [Real.norm_of_nonneg (norm_nonneg _)]; exact hdom s hs ω
-  have hQg : ∀ s ∈ Set.Icc (0 : ℝ) T,
-      (∫ ω, g s ω ∂π) = L * (∫ ω, ‖w s ω‖ ∂π) + ε s := by
-    intro s hs
-    simp only [hg]
-    rw [integral_add ((hg_int_s s hs).const_mul L) (integrable_const _), integral_const_mul]
-    congr 1
-    simp [integral_const, measureReal_def, measure_univ]
-  -- the double integral, via Tonelli
-  have hdouble : (∫ ω, (∫ s in (0 : ℝ)..t, g s ω) ∂π)
-      = ∫ s in (0 : ℝ)..t, (L * (∫ ω, ‖w s ω‖ ∂π) + ε s) := by
-    calc (∫ ω, (∫ s in (0 : ℝ)..t, g s ω) ∂π)
-        = ∫ ω, (∫ s, g s ω ∂(MeasureTheory.volume.restrict (Set.uIoc (0 : ℝ) t))) ∂π := by
-          simp only [hconv]
-      _ = ∫ s, (∫ ω, g s ω ∂π) ∂(MeasureTheory.volume.restrict (Set.uIoc (0 : ℝ) t)) :=
-          (MeasureTheory.integral_integral_swap hg_int).symm
-      _ = ∫ s in (0 : ℝ)..t, (∫ ω, g s ω ∂π) := by
-          rw [huIoc, ← intervalIntegral.integral_of_le h0t]
-      _ = ∫ s in (0 : ℝ)..t, (L * (∫ ω, ‖w s ω‖ ∂π) + ε s) := by
-          refine intervalIntegral.integral_congr (fun s hs => ?_)
-          rw [Set.uIcc_of_le h0t] at hs
-          exact hQg s ⟨hs.1, hs.2.trans htT⟩
-  -- assemble
-  calc (∫ ω, ‖w t ω‖ ∂π)
-      ≤ ∫ ω, (‖w 0 ω‖ + ∫ s in (0 : ℝ)..t, g s ω) ∂π :=
-        integral_mono hintt (hint0.add hinner_int) (fun ω => hper ω t ht)
-    _ = (∫ ω, ‖w 0 ω‖ ∂π) + ∫ ω, (∫ s in (0 : ℝ)..t, g s ω) ∂π :=
-        integral_add hint0 hinner_int
-    _ = (∫ ω, ‖w 0 ω‖ ∂π) + ∫ s in (0 : ℝ)..t, (L * (∫ ω, ‖w s ω‖ ∂π) + ε s) := by
-        rw [hdouble]
-
-/-- **Integrated coupling-Gronwall bound** (base-measure generic).
-
-Given a base probability measure `π` on `Ω` and two parameter-families of
-trajectories `X_f, X_g : ℝ → Ω → α` solving ODEs with `L`-Lipschitz vector fields
-`b_f, b_g` on `[0, T]`, with a cross-field bound `‖b_f s y - b_g s y‖ ≤ ε s` whose
-amplitude `ε s` is **self-referentially** controlled by the integrated trajectory
-distance `Q s := ∫ ω, ‖X_f s ω - X_g s ω‖ ∂π` (i.e. `ε s ≤ L · Q s`), the
-integrated distance obeys the closed Gronwall bound
-`Q t ≤ Q 0 · exp (2 L t)` on `[0, T]`.
-
-**Composition** (the collapse pipeline):
-* per-`ω`, `flow_difference_mild_bound` gives the mild integral inequality
-  `‖X_f t ω - X_g t ω‖ ≤ ‖X_f 0 ω - X_g 0 ω‖ + ∫₀ᵗ (L‖X_f s ω - X_g s ω‖ + ε s)`;
-* `integral_mild_bound` integrates this over `π` (Tonelli on a nonnegative
-  integrand), yielding `Q t ≤ Q 0 + ∫₀ᵗ (L·Q s + ε s)`;
-* the self-reference `ε s ≤ L·Q s` collapses the integrand to `2 L · Q s`;
-* `gronwall_mild_le` (scalar mild Gronwall) closes to `Q 0 · exp (2 L t)`.
-
-**Clamp bridge**: `integral_mild_bound` and the DCT continuity of `Q`
-require *global*-in-`s` continuity, but the flow regularity is only on the
-window `[0, T]`.  We work with the clamped flow `s ↦ X_f (clamp s) ω` (globally
-continuous, agreeing with `X_f` on `[0, T]`), apply the window machinery to it,
-and transfer back on `[0, T]` where `clamp = id` via integrand congruence.
-
-**Base-measure genericity**: `π` is abstract, so this serves both the
-uniqueness call site (`π = f 0`, `Q 0 = 0`, Foundation-B-free) and the
-mean-field call site (`π` an optimal coupling, `Q 0 = W₁(f 0, g 0)`). -/
-theorem integrated_coupling_gronwall_bound
-    {Ω α : Type*} [MeasurableSpace Ω]
-    [NormedAddCommGroup α] [NormedSpace ℝ α] [CompleteSpace α]
-    [MeasurableSpace α] [BorelSpace α] [MeasurableSub₂ α]
-    (π : Measure Ω) [IsProbabilityMeasure π]
-    (X_f X_g : ℝ → Ω → α) (b_f b_g : ℝ → α → α) (L : NNReal) (T : ℝ) (hT : 0 ≤ T)
-    (hL_f : ∀ t, LipschitzWith L (b_f t))
-    -- per-`ω` flow regularity (matches `flow_difference_mild_bound`)
-    (hcont_f : ∀ ω, ContinuousOn (fun s => X_f s ω) (Set.Icc 0 T))
-    (hcont_g : ∀ ω, ContinuousOn (fun s => X_g s ω) (Set.Icc 0 T))
-    (hderiv_f : ∀ ω, ∀ s ∈ Set.Ioo (0 : ℝ) T,
-      HasDerivWithinAt (fun s => X_f s ω) (b_f s (X_f s ω)) (Set.Ioi s) s)
-    (hderiv_g : ∀ ω, ∀ s ∈ Set.Ioo (0 : ℝ) T,
-      HasDerivWithinAt (fun s => X_g s ω) (b_g s (X_g s ω)) (Set.Ioi s) s)
-    (hint : ∀ ω, IntervalIntegrable
-      (fun s => b_f s (X_f s ω) - b_g s (X_g s ω)) MeasureTheory.volume 0 T)
-    -- measurability + domination for the Tonelli / DCT
-    (hmeas_f : ∀ s, Measurable (X_f s)) (hmeas_g : ∀ s, Measurable (X_g s))
-    (dom : Ω → ℝ) (hdom_int : Integrable dom π)
-    (hdom : ∀ s ∈ Set.Icc (0 : ℝ) T, ∀ ω, ‖X_f s ω - X_g s ω‖ ≤ dom ω)
-    -- the cross-field bound `ε` and its self-reference to `Q`
-    (ε : ℝ → ℝ) (hε_int : IntervalIntegrable ε MeasureTheory.volume 0 T)
-    (hε_nn : ∀ s ∈ Set.Icc (0 : ℝ) T, 0 ≤ ε s)
-    (h_diff : ∀ ω, ∀ s ∈ Set.Icc (0 : ℝ) T,
-      ‖b_f s (X_g s ω) - b_g s (X_g s ω)‖ ≤ ε s)
-    (h_self : ∀ s ∈ Set.Icc (0 : ℝ) T,
-      ε s ≤ (L : ℝ) * ∫ ω, ‖X_f s ω - X_g s ω‖ ∂π) :
-    ∀ t ∈ Set.Icc (0 : ℝ) T,
-      (∫ ω, ‖X_f t ω - X_g t ω‖ ∂π) ≤
-        (∫ ω, ‖X_f 0 ω - X_g 0 ω‖ ∂π) * Real.exp (2 * (L:ℝ) * t) := by
-  -- clamp into `[0, T]` (opaque; used only through its three properties)
-  obtain ⟨clamp, hclamp_cont, hclamp_mem, hclamp_id⟩ :
-      ∃ clamp : ℝ → ℝ, Continuous clamp ∧ (∀ s, clamp s ∈ Set.Icc (0 : ℝ) T) ∧
-        (∀ s ∈ Set.Icc (0 : ℝ) T, clamp s = s) := by
-    refine ⟨fun s => max 0 (min s T), ?_, ?_, ?_⟩
-    · exact continuous_const.max (continuous_id.min continuous_const)
-    · intro s; exact ⟨le_max_left _ _, max_le hT (min_le_right _ _)⟩
-    · intro s hs; change max 0 (min s T) = s
-      rw [min_eq_left hs.2, max_eq_right hs.1]
-  -- the clamped difference flow `W s ω = X_f (clamp s) ω - X_g (clamp s) ω`
-  set W : ℝ → Ω → α := fun s ω => X_f (clamp s) ω - X_g (clamp s) ω with hW_def
-  have hW_cont : ∀ ω, Continuous (fun s => W s ω) := by
-    intro ω; simp only [hW_def]
-    exact ((hcont_f ω).sub (hcont_g ω)).comp_continuous hclamp_cont hclamp_mem
-  have hW_meas : ∀ s, Measurable (W s) := by
-    intro s; simp only [hW_def]
-    exact (hmeas_f (clamp s)).sub (hmeas_g (clamp s))
-  have hW_dom : ∀ s, ∀ ω, ‖W s ω‖ ≤ dom ω := by
-    intro s ω; simp only [hW_def]; exact hdom (clamp s) (hclamp_mem s) ω
-  -- on `[0, T]`, `W` agrees with the unclamped difference, so the integrals agree
-  have hQW_eq : ∀ s ∈ Set.Icc (0 : ℝ) T,
-      (∫ ω, ‖W s ω‖ ∂π) = ∫ ω, ‖X_f s ω - X_g s ω‖ ∂π := by
-    intro s hs
-    apply integral_congr_ae
-    filter_upwards with ω
-    simp only [hW_def, hclamp_id s hs]
-  -- per-`ω` mild bound (unclamped) via `flow_difference_mild_bound`
-  have hper_w : ∀ ω, ∀ t ∈ Set.Icc (0 : ℝ) T,
-      ‖X_f t ω - X_g t ω‖ ≤ ‖X_f 0 ω - X_g 0 ω‖ +
-        ∫ s in (0 : ℝ)..t, ((L:ℝ) * ‖X_f s ω - X_g s ω‖ + ε s) := fun ω =>
-    flow_difference_mild_bound b_f b_g L hL_f (fun s => X_f s ω) (fun s => X_g s ω) T
-      (hcont_f ω) (hcont_g ω) (hderiv_f ω) (hderiv_g ω) (hint ω) ε hε_int (h_diff ω)
-  -- transfer the mild bound to the clamped flow `W` (needed by `integral_mild_bound`)
-  have hper_W : ∀ ω, ∀ t ∈ Set.Icc (0 : ℝ) T,
-      ‖W t ω‖ ≤ ‖W 0 ω‖ + ∫ s in (0 : ℝ)..t, ((L:ℝ) * ‖W s ω‖ + ε s) := by
-    intro ω t ht
-    have h0t : (0 : ℝ) ≤ t := ht.1
-    have hWt : W t ω = X_f t ω - X_g t ω := by simp only [hW_def, hclamp_id t ht]
-    have hW0 : W 0 ω = X_f 0 ω - X_g 0 ω := by
-      simp only [hW_def, hclamp_id 0 ⟨le_refl 0, hT⟩]
-    have hintegrand : (∫ s in (0 : ℝ)..t, ((L:ℝ) * ‖W s ω‖ + ε s))
-        = ∫ s in (0 : ℝ)..t, ((L:ℝ) * ‖X_f s ω - X_g s ω‖ + ε s) := by
-      refine intervalIntegral.integral_congr (fun s hs => ?_)
-      rw [Set.uIcc_of_le h0t] at hs
-      have hsT : s ∈ Set.Icc (0 : ℝ) T := ⟨hs.1, hs.2.trans ht.2⟩
-      simp only [hW_def, hclamp_id s hsT]
-    rw [hWt, hW0, hintegrand]; exact hper_w ω t ht
-  -- integrate over `π` (Tonelli): `Q t ≤ Q 0 + ∫₀ᵗ (L·Q s + ε s)`
-  have hQW := integral_mild_bound π W (L:ℝ) (NNReal.coe_nonneg L) ε T hT
-    hW_cont hW_meas dom hdom_int (fun s _ ω => hW_dom s ω) hε_int hε_nn hper_W
-  -- `Q` is globally continuous via DCT (clamped flow globally dominated)
-  have hQW_cont : Continuous (fun s => ∫ ω, ‖W s ω‖ ∂π) := by
-    refine continuous_of_dominated
-      (fun s => (hW_meas s).norm.aestronglyMeasurable)
-      (fun s => Filter.Eventually.of_forall (fun ω => ?_)) hdom_int
-      (Filter.Eventually.of_forall (fun ω => (hW_cont ω).norm))
-    rw [Real.norm_of_nonneg (norm_nonneg _)]; exact hW_dom s ω
-  -- collapse the integrand to `2 L · Q s` using the self-reference
-  have hmild_W : ∀ t ∈ Set.Icc (0 : ℝ) T,
-      (∫ ω, ‖W t ω‖ ∂π) ≤ (∫ ω, ‖W 0 ω‖ ∂π)
-        + (2 * (L:ℝ)) * ∫ s in (0 : ℝ)..t, (∫ ω, ‖W s ω‖ ∂π) := by
-    intro t ht
-    have h0t : (0 : ℝ) ≤ t := ht.1
-    have hstep := hQW t ht
-    have hII_lhs : IntervalIntegrable
-        (fun s => (L:ℝ) * (∫ ω, ‖W s ω‖ ∂π) + ε s) MeasureTheory.volume 0 t :=
-      ((hQW_cont.intervalIntegrable 0 t).const_mul (L:ℝ)).add
-        (hε_int.mono_set (by
-          rw [Set.uIcc_of_le h0t, Set.uIcc_of_le hT]
-          exact Set.Icc_subset_Icc_right ht.2))
-    have hII_rhs : IntervalIntegrable
-        (fun s => (2 * (L:ℝ)) * (∫ ω, ‖W s ω‖ ∂π)) MeasureTheory.volume 0 t :=
-      (hQW_cont.intervalIntegrable 0 t).const_mul (2 * (L:ℝ))
-    have hmono : (∫ s in (0 : ℝ)..t, ((L:ℝ) * (∫ ω, ‖W s ω‖ ∂π) + ε s))
-        ≤ ∫ s in (0 : ℝ)..t, (2 * (L:ℝ)) * (∫ ω, ‖W s ω‖ ∂π) := by
-      refine intervalIntegral.integral_mono_on h0t hII_lhs hII_rhs (fun s hs => ?_)
-      have hsT : s ∈ Set.Icc (0 : ℝ) T := ⟨hs.1, hs.2.trans ht.2⟩
-      have hεle : ε s ≤ (L:ℝ) * (∫ ω, ‖W s ω‖ ∂π) := by
-        calc ε s ≤ (L:ℝ) * (∫ ω, ‖X_f s ω - X_g s ω‖ ∂π) := h_self s hsT
-          _ = (L:ℝ) * (∫ ω, ‖W s ω‖ ∂π) := by rw [hQW_eq s hsT]
-      have hring : (2 * (L:ℝ)) * (∫ ω, ‖W s ω‖ ∂π)
-          = (L:ℝ) * (∫ ω, ‖W s ω‖ ∂π) + (L:ℝ) * (∫ ω, ‖W s ω‖ ∂π) := by ring
-      rw [hring]; linarith [hεle]
-    calc (∫ ω, ‖W t ω‖ ∂π)
-        ≤ (∫ ω, ‖W 0 ω‖ ∂π)
-          + ∫ s in (0 : ℝ)..t, ((L:ℝ) * (∫ ω, ‖W s ω‖ ∂π) + ε s) := hstep
-      _ ≤ (∫ ω, ‖W 0 ω‖ ∂π)
-          + ∫ s in (0 : ℝ)..t, (2 * (L:ℝ)) * (∫ ω, ‖W s ω‖ ∂π) := by linarith [hmono]
-      _ = (∫ ω, ‖W 0 ω‖ ∂π)
-          + (2 * (L:ℝ)) * ∫ s in (0 : ℝ)..t, (∫ ω, ‖W s ω‖ ∂π) := by
-            rw [intervalIntegral.integral_const_mul]
-  -- scalar mild Gronwall on `Q`
-  have hgron := gronwall_mild_le (fun s => ∫ ω, ‖W s ω‖ ∂π)
-    (∫ ω, ‖W 0 ω‖ ∂π) (2 * (L:ℝ)) T
-    (by have := NNReal.coe_nonneg L; linarith)
-    (integral_nonneg (fun ω => norm_nonneg _))
-    hQW_cont (fun s => integral_nonneg (fun ω => norm_nonneg _)) hmild_W
-  -- transfer back to the unclamped difference on `[0, T]`
-  intro t ht
-  rw [← hQW_eq t ht, ← hQW_eq 0 ⟨le_refl 0, hT⟩]
-  exact hgron t ht
-
-/-- **Piece A (Option 2): time-dependent moment-envelope growth bound.**
-
-Sharper sibling of `flow_distance_growth_bound_on`.  Instead of a single
-constant moment bound `M_ρ` (which forces the constant-sup growth constant
-`C_T` and, downstream, an `M_f₀`-dependent fixed-point on the curve space),
-this takes a **monotone time-dependent envelope** `m : ℝ → ℝ` bounding the
-spatial-marginal first moment, and concludes the **time-local** Gronwall bound
-
-  `‖(charX t z, charV t z)‖ ≤ gronwallBound ‖z‖ (1+L) (‖gradW 0‖ + L · m t) t`,
-
-with the force constant `ε(t) = ‖gradW 0‖ + L · m t` evaluated at the SAME time
-`t` (not the sup `m T`).  Monotonicity of `m` lets the per-`t` Gronwall on
-`[0, t]` use the endpoint value `ε(t)` while validating the derivative bound at
-every `s ≤ t` (since `ε(s) ≤ ε(t)`).
-
-**Why this is the option-2 foundation**: integrating the conclusion over a
-probability `f₀` gives `M_{Φρ}(t) ≤ A(t) + B(t)·m(t)` with
-`A(t) = M_f₀·e^{(1+L)t} + (‖gradW 0‖/(1+L))(e^{(1+L)t}-1)` and
-`B(t) = (L/(1+L))(e^{(1+L)t}-1)` — crucially an **`M_f₀`-free** coefficient.
-The canonical envelope `m*(t) := A(t)/(1-B(T))` is then Φ-invariant under the
-**data-independent** constraint `B(T) < 1`, dissolving the constant-`M`
-fixed-point without a data-dependent hypothesis.  (Contrast the constant-sup
-bound, which feeds `m(T)` into `ε` and re-derives an `M_f₀`-dependent
-smallness.) -/
-theorem flow_distance_growth_bound_on_timedep
-    {d : ℕ}
-    (gradW : PhysSpace d → PhysSpace d)
-    (L : NNReal) (hL : LipschitzWith L gradW)
-    (ρ : ℝ → Measure (PhysSpace d))
-    [∀ t, IsProbabilityMeasure (ρ t)]
-    (charX charV : ℝ → PhaseSpace d → PhysSpace d)
-    (T : ℝ) (_hT : 0 ≤ T)
-    (h_init : ∀ z : PhaseSpace d, (charX 0 z, charV 0 z) = z)
-    (h_cont_Icc : ∀ z : PhaseSpace d,
-        ContinuousOn (fun s => (charX s z, charV s z)) (Set.Icc (0 : ℝ) T))
-    (h_deriv_Ico : ∀ z : PhaseSpace d, ∀ s ∈ Set.Ico (0 : ℝ) T,
-        HasDerivWithinAt (fun s' => (charX s' z, charV s' z))
-          (vlasovVectorField gradW ρ s (charX s z, charV s z))
-          (Set.Ici s) s)
-    (m : ℝ → ℝ) (hm_mono : MonotoneOn m (Set.Icc 0 T))
-    (hm : ∀ t ∈ Set.Icc 0 T, ∫ y, ‖y‖ ∂(ρ t) ≤ m t)
-    (h_y_int : ∀ t ∈ Set.Icc 0 T, Integrable (fun y : PhysSpace d => ‖y‖) (ρ t))
-    (h_int : ∀ t (x : PhysSpace d), Integrable (fun y => gradW (x - y)) (ρ t)) :
-    ∀ t ∈ Set.Icc 0 T, ∀ z : PhaseSpace d,
-      ‖(charX t z, charV t z)‖ ≤
-        gronwallBound ‖z‖ (1 + (L : ℝ)) (‖gradW 0‖ + (L : ℝ) * m t) t := by
-  intro t ht z
-  set K : ℝ := 1 + (L : ℝ) with hK_def
-  -- m t ≥ 0 (moment of a probability measure is nonneg, bounded by m t).
-  have hmt_nn : 0 ≤ m t :=
-    le_trans (integral_nonneg (fun y => norm_nonneg y)) (hm t ht)
-  set εt : ℝ := ‖gradW 0‖ + (L : ℝ) * m t with hεt_def
-  have hK_pos : 0 < K := by positivity
-  have hεt_nn : 0 ≤ εt := by positivity
-  -- Convolution force bound on [0, t], using m s ≤ m t (monotone).
-  have h_conv_bound : ∀ s ∈ Set.Icc 0 t, ∀ x : PhysSpace d,
-      ‖convolveFunctionMeasure gradW (ρ s) x‖ ≤ εt + (L : ℝ) * ‖x‖ := by
-    intro s hs x
-    have hs_T : s ∈ Set.Icc 0 T := ⟨hs.1, le_trans hs.2 ht.2⟩
-    have hms_le_mt : m s ≤ m t := hm_mono hs_T ht hs.2
-    unfold convolveFunctionMeasure
-    have h_sub_int : Integrable (fun y => ‖x - y‖) (ρ s) :=
-      Integrable.mono' ((integrable_const ‖x‖).add (h_y_int s hs_T))
-        ((aestronglyMeasurable_const (b := x)).sub aestronglyMeasurable_id |>.norm)
-        (Filter.Eventually.of_forall fun y => by
-          simp only [Real.norm_of_nonneg (norm_nonneg _)]; exact norm_sub_le x y)
-    have h_bnd_int : Integrable (fun y => ‖gradW 0‖ + (L : ℝ) * ‖x - y‖) (ρ s) :=
-      (integrable_const _).add (h_sub_int.const_mul _)
-    have h_pt : ∀ y : PhysSpace d,
-        ‖gradW (x - y)‖ ≤ ‖gradW 0‖ + (L : ℝ) * ‖x - y‖ := by
-      intro y
-      have hd := hL.dist_le_mul (x - y) 0
-      simp only [dist_eq_norm, sub_zero] at hd
-      have h_tri : ‖gradW (x - y)‖ ≤ ‖gradW 0‖ + ‖gradW (x - y) - gradW 0‖ := by
-        have := norm_add_le (gradW (x - y) - gradW 0) (gradW 0)
-        simp only [sub_add_cancel] at this; linarith
-      linarith
-    calc ‖∫ y, gradW (x - y) ∂(ρ s)‖
-        ≤ ∫ y, ‖gradW (x - y)‖ ∂(ρ s) := norm_integral_le_integral_norm _
-      _ ≤ ∫ y, (‖gradW 0‖ + (L : ℝ) * ‖x - y‖) ∂(ρ s) :=
-          integral_mono (h_int s x).norm h_bnd_int h_pt
-      _ = ‖gradW 0‖ + (L : ℝ) * ∫ y, ‖x - y‖ ∂(ρ s) := by
-          rw [integral_add (integrable_const _) (h_sub_int.const_mul _)]
-          simp [integral_const, measureReal_def, measure_univ, integral_const_mul]
-      _ ≤ εt + (L : ℝ) * ‖x‖ := by
-          have h_int_le : ∫ y, ‖x - y‖ ∂(ρ s) ≤ ‖x‖ + m t := by
-            calc ∫ y, ‖x - y‖ ∂(ρ s)
-                ≤ ∫ y, (‖x‖ + ‖y‖) ∂(ρ s) :=
-                  integral_mono h_sub_int ((integrable_const _).add (h_y_int s hs_T))
-                    (fun y => norm_sub_le x y)
-              _ = ‖x‖ + ∫ y, ‖y‖ ∂(ρ s) := by
-                  rw [integral_add (integrable_const _) (h_y_int s hs_T)]
-                  simp [integral_const, measureReal_def, measure_univ]
-              _ ≤ ‖x‖ + m t := by linarith [hm s hs_T, hms_le_mt]
-          simp only [hεt_def]
-          nlinarith [mul_le_mul_of_nonneg_left h_int_le (NNReal.coe_nonneg L)]
-  -- Gronwall on [0, t] with the endpoint force constant εt.
-  have ht0 : (0 : ℝ) ≤ t := ht.1
-  have h_f_cont : ContinuousOn (fun s => (charX s z, charV s z)) (Set.Icc 0 t) :=
-    (h_cont_Icc z).mono (Set.Icc_subset_Icc_right ht.2)
-  have h_deriv : ∀ s ∈ Set.Ico 0 t,
-      HasDerivWithinAt (fun s => (charX s z, charV s z))
-        (charV s z, -convolveFunctionMeasure gradW (ρ s) (charX s z))
-        (Set.Ici s) s := by
-    intro s hs
-    have hs_T : s ∈ Set.Ico 0 T := ⟨hs.1, lt_of_lt_of_le hs.2 ht.2⟩
-    have hderiv := h_deriv_Ico z s hs_T
-    unfold vlasovVectorField at hderiv
-    exact hderiv
-  have h_init_norm : ‖(charX 0 z, charV 0 z)‖ ≤ ‖z‖ := by rw [h_init z]
-  have h_bound : ∀ s ∈ Set.Ico 0 t,
-      ‖(charV s z, -convolveFunctionMeasure gradW (ρ s) (charX s z))‖ ≤
-        K * ‖(charX s z, charV s z)‖ + εt := by
-    intro s hs
-    have hs_mem : s ∈ Set.Icc 0 t := ⟨hs.1, le_of_lt hs.2⟩
-    simp only [Prod.norm_def, norm_neg]
-    have hFsz := le_max_left ‖charX s z‖ ‖charV s z‖
-    have hGsz := le_max_right ‖charX s z‖ ‖charV s z‖
-    have hM_nn : 0 ≤ max ‖charX s z‖ ‖charV s z‖ :=
-      le_max_iff.mpr (Or.inl (norm_nonneg _))
-    have h_v_le : ‖charV s z‖ ≤ K * max ‖charX s z‖ ‖charV s z‖ + εt :=
-      calc ‖charV s z‖ ≤ max ‖charX s z‖ ‖charV s z‖ := hGsz
-        _ ≤ K * max ‖charX s z‖ ‖charV s z‖ :=
-            le_mul_of_one_le_left hM_nn (by linarith [NNReal.coe_nonneg L])
-        _ ≤ K * max ‖charX s z‖ ‖charV s z‖ + εt := le_add_of_nonneg_right hεt_nn
-    have h_conv_le : ‖convolveFunctionMeasure gradW (ρ s) (charX s z)‖ ≤
-        K * max ‖charX s z‖ ‖charV s z‖ + εt :=
-      calc ‖convolveFunctionMeasure gradW (ρ s) (charX s z)‖
-          ≤ εt + (L : ℝ) * ‖charX s z‖ := h_conv_bound s hs_mem _
-        _ ≤ εt + K * max ‖charX s z‖ ‖charV s z‖ := by
-            have hLK : (L : ℝ) ≤ K := le_add_of_nonneg_left zero_le_one
-            linarith [mul_le_mul_of_nonneg_left hFsz (NNReal.coe_nonneg L),
-                      mul_le_mul_of_nonneg_right hLK hM_nn]
-        _ = K * max ‖charX s z‖ ‖charV s z‖ + εt := by ring
-    exact max_le h_v_le h_conv_le
-  have h_grw := norm_le_gronwallBound_of_norm_deriv_right_le
-    h_f_cont h_deriv h_init_norm h_bound t (Set.right_mem_Icc.mpr ht0)
-  simpa using h_grw
-
-/-- **Piece A.3 (Option 2): the canonical moment envelope closes (data-free).**
-
-Pure-algebra companion to `flow_distance_growth_bound_on_timedep`.  Under the
-**`M_f₀`-free** smallness `B(T) := (L/(1+L))(e^{(1+L)T}-1) < 1`, the explicit
-envelope `m*(t) := gronwallBound M_f₀ (1+L) g0 t / (1 - B(T))` is a Gronwall
-super-solution:
-
-* monotone on `[0, T]`,
-* dominates the initial moment `M_f₀`,
-* **Φ-invariant** at the moment level:
-  `gronwallBound M_f₀ (1+L) (g0 + L·m* t) t ≤ m* t`.
-
-Composed with Piece A integrated over `f₀` (which gives
-`M_{Φρ}(t) ≤ gronwallBound M_f₀ (1+L) (g0 + L·m(t)) t`, `g0 = ‖gradW 0‖`), this
-shows the Picard iterates stay inside the fixed envelope `m*` with **no**
-data-dependent hypothesis — the faithful dissolution of the constant-`M`
-fixed-point.  This lemma is the measure-free heart of the option-2 escape;
-Pieces B–D thread it through the curve space, `Phi_step`, and #11. -/
-theorem gronwall_envelope_exists
-    (M_f₀ g0 : ℝ) (hM_f₀ : 0 ≤ M_f₀) (hg0 : 0 ≤ g0)
-    (L : NNReal) (T : ℝ) (hT : 0 ≤ T)
-    (hB : (L : ℝ) / (1 + (L : ℝ)) * (Real.exp ((1 + (L : ℝ)) * T) - 1) < 1) :
-    ∃ m : ℝ → ℝ, MonotoneOn m (Set.Icc 0 T) ∧
-      (∀ t ∈ Set.Icc 0 T, M_f₀ ≤ m t) ∧
-      (∀ t ∈ Set.Icc 0 T,
-        gronwallBound M_f₀ (1 + (L : ℝ)) (g0 + (L : ℝ) * m t) t ≤ m t) := by
-  set K : ℝ := 1 + (L : ℝ) with hK_def
-  have hK_pos : 0 < K := by positivity
-  have hK_ne : K ≠ 0 := ne_of_gt hK_pos
-  have hL_nn : (0 : ℝ) ≤ (L : ℝ) := L.coe_nonneg
-  -- B(t) and its monotonicity.
-  set Bf : ℝ → ℝ := fun t => (L : ℝ) / K * (Real.exp (K * t) - 1) with hBf_def
-  have hBT_lt : Bf T < 1 := hB
-  have hD_pos : 0 < 1 - Bf T := by linarith
-  have hD_nn : (0 : ℝ) ≤ 1 - Bf T := hD_pos.le
-  have hD_ne : (1 - Bf T) ≠ 0 := ne_of_gt hD_pos
-  have hLK_nn : 0 ≤ (L : ℝ) / K := div_nonneg hL_nn hK_pos.le
-  have hBf_T_nn : 0 ≤ Bf T := by
-    have he1 : 0 ≤ Real.exp (K * T) - 1 := by
-      have : (1 : ℝ) ≤ Real.exp (K * T) := Real.one_le_exp (by positivity)
-      linarith
-    exact mul_nonneg hLK_nn he1
-  have hBf_le : ∀ t ∈ Set.Icc (0 : ℝ) T, Bf t ≤ Bf T := by
-    intro t ht
-    have hexp : Real.exp (K * t) ≤ Real.exp (K * T) :=
-      Real.exp_le_exp.mpr (by nlinarith [ht.2, hK_pos.le])
-    simp only [hBf_def]
-    nlinarith [hexp, hLK_nn]
-  -- A(t) := gronwallBound M_f₀ K g0 t, expanded + nonneg + monotone.
-  set Af : ℝ → ℝ := fun t => gronwallBound M_f₀ K g0 t with hAf_def
-  have hAf_expand : ∀ t,
-      Af t = M_f₀ * Real.exp (K * t) + g0 / K * (Real.exp (K * t) - 1) := by
-    intro t; simp only [hAf_def]; rw [gronwallBound_of_K_ne_0 hK_ne]
-  have hAf_nn : ∀ t ∈ Set.Icc (0 : ℝ) T, 0 ≤ Af t := by
-    intro t ht
-    rw [hAf_expand t]
-    have he1 : 0 ≤ Real.exp (K * t) - 1 := by
-      have : (1 : ℝ) ≤ Real.exp (K * t) := Real.one_le_exp (by nlinarith [ht.1, hK_pos.le])
-      linarith
-    have hgK_nn : 0 ≤ g0 / K := div_nonneg hg0 hK_pos.le
-    positivity
-  have hAf_mono : MonotoneOn Af (Set.Icc 0 T) := by
-    intro s _ t _ hst
-    simp only [hAf_def]
-    exact gronwallBound_mono hM_f₀ hg0 hK_pos.le hst
-  refine ⟨fun t => Af t / (1 - Bf T), ?_, ?_, ?_⟩
-  · -- monotone: Af increasing, positive constant divisor.
-    intro s hs t ht hst
-    change Af s / (1 - Bf T) ≤ Af t / (1 - Bf T)
-    gcongr
-    exact hAf_mono hs ht hst
-  · -- M_f₀ ≤ m t.
-    intro t ht
-    have h0_mem : (0 : ℝ) ∈ Set.Icc (0 : ℝ) T := ⟨le_refl 0, hT⟩
-    have hAf0 : Af 0 = M_f₀ := by rw [hAf_expand 0]; simp [Real.exp_zero]
-    have h_mono : Af 0 / (1 - Bf T) ≤ Af t / (1 - Bf T) := by
-      gcongr
-      exact hAf_mono h0_mem ht ht.1
-    rw [hAf0] at h_mono
-    have h_self : M_f₀ ≤ M_f₀ / (1 - Bf T) := by
-      rw [le_div_iff₀ hD_pos]; nlinarith [hM_f₀, hBf_T_nn]
-    linarith
-  · -- Φ-invariance.
-    intro t ht
-    change gronwallBound M_f₀ K (g0 + (L : ℝ) * (Af t / (1 - Bf T))) t
-        ≤ Af t / (1 - Bf T)
-    have h_lhs : gronwallBound M_f₀ K (g0 + (L : ℝ) * (Af t / (1 - Bf T))) t
-              = Af t + Bf t * (Af t / (1 - Bf T)) := by
-      rw [gronwallBound_of_K_ne_0 hK_ne, hAf_expand t]
-      simp only [hBf_def]; ring
-    rw [h_lhs]
-    have hkey : 0 ≤ Af t * (Bf T - Bf t) :=
-      mul_nonneg (hAf_nn t ht) (by linarith [hBf_le t ht])
-    have hexpand : Af t / (1 - Bf T) - (Af t + Bf t * (Af t / (1 - Bf T)))
-                 = Af t * (Bf T - Bf t) / (1 - Bf T) := by
-      field_simp
-      ring
-    linarith [div_nonneg hkey hD_pos.le, hexpand]
-
-/-- **Piece A.2 (Option 2): integrate the per-`z` growth bound to a moment bound.**
-
-The measure-level bridge between Piece A and Piece A.3: given the per-`z`
-time-local growth bound (Piece A's conclusion, taken here as the hypothesis
-`h_growth` so this lemma is decoupled from the flow construction), the
-**position pushforward** `Measure.map (charX t ·) f₀` has first moment bounded
-by the same Gronwall functional evaluated at the *initial* moment `∫‖z‖ ∂f₀`:
-
-  `∫ x, ‖x‖ ∂(Measure.map (charX t ·) f₀) ≤ gronwallBound (∫‖z‖ ∂f₀) (1+L) (g0 + L·m t) t`.
-
-Proof: `integral_map` exchanges the pushforward; `‖charX t z‖ ≤ ‖(charX t z, charV t z)‖`
-+ `h_growth` bounds the integrand by `gronwallBound ‖z‖ …`, which is affine in `‖z‖`,
-so its `f₀`-integral is `gronwallBound (∫‖z‖) …` (probability measure ⇒ the constant
-term integrates to itself).
-
-Composing with `gronwall_envelope_exists` (Piece A.3): when `m = m*` the canonical
-envelope and `g0 = ‖gradW 0‖`, the RHS is `≤ m* t`, i.e. `Φ` maps the envelope to
-itself at the moment level — the measure-level statement of the data-free escape. -/
-theorem phi_moment_envelope_le {d : ℕ}
-    (L : NNReal) (charX charV : ℝ → PhaseSpace d → PhysSpace d)
-    (g0 : ℝ) (T : ℝ) (m : ℝ → ℝ)
-    (h_growth : ∀ t ∈ Set.Icc (0 : ℝ) T, ∀ z : PhaseSpace d,
-      ‖(charX t z, charV t z)‖ ≤ gronwallBound ‖z‖ (1 + (L : ℝ)) (g0 + (L : ℝ) * m t) t)
-    (f₀ : Measure (PhaseSpace d)) [IsProbabilityMeasure f₀]
-    (hf₀_int : Integrable (fun z : PhaseSpace d => ‖z‖) f₀)
-    (h_meas : ∀ t ∈ Set.Icc (0 : ℝ) T,
-      AEMeasurable (fun z : PhaseSpace d => charX t z) f₀) :
-    ∀ t ∈ Set.Icc (0 : ℝ) T,
-      ∫ x, ‖x‖ ∂(Measure.map (fun z : PhaseSpace d => charX t z) f₀)
-        ≤ gronwallBound (∫ z, ‖z‖ ∂f₀) (1 + (L : ℝ)) (g0 + (L : ℝ) * m t) t := by
-  intro t ht
-  set K : ℝ := 1 + (L : ℝ) with hK_def
-  set εt : ℝ := g0 + (L : ℝ) * m t with hεt_def
-  have hK_ne : K ≠ 0 := by positivity
-  -- gronwallBound is affine in its initial value: gb r = e^{Kt}·r + C.
-  have h_gb : ∀ r : ℝ,
-      gronwallBound r K εt t = Real.exp (K * t) * r + εt / K * (Real.exp (K * t) - 1) := by
-    intro r; rw [gronwallBound_of_K_ne_0 hK_ne]; ring
-  have h_dom_int : Integrable (fun z : PhaseSpace d => gronwallBound ‖z‖ K εt t) f₀ := by
-    simp only [h_gb]
-    exact (hf₀_int.const_mul _).add (integrable_const _)
-  have h_charX_le : ∀ z : PhaseSpace d, ‖charX t z‖ ≤ gronwallBound ‖z‖ K εt t := fun z =>
-    le_trans (norm_fst_le (charX t z, charV t z)) (h_growth t ht z)
-  have h_charX_int : Integrable (fun z : PhaseSpace d => ‖charX t z‖) f₀ :=
-    h_dom_int.mono' ((h_meas t ht).norm.aestronglyMeasurable)
-      (Filter.Eventually.of_forall fun z => by
-        rw [Real.norm_of_nonneg (norm_nonneg _)]; exact h_charX_le z)
-  rw [integral_map (h_meas t ht) continuous_norm.aestronglyMeasurable]
-  calc ∫ z, ‖charX t z‖ ∂f₀
-      ≤ ∫ z, gronwallBound ‖z‖ K εt t ∂f₀ :=
-        integral_mono h_charX_int h_dom_int h_charX_le
-    _ = gronwallBound (∫ z, ‖z‖ ∂f₀) K εt t := by
-        simp only [h_gb]
-        rw [integral_add (hf₀_int.const_mul _) (integrable_const _), integral_const_mul,
-            integral_const]
-        simp [measureReal_def, measure_univ]
-
-/-! ## Characteristic flow existence (Picard-Lindelöf wrapper)
-
-This section wraps the vendored parametric Picard-Lindelöf theorem
-(`LeanPool.Vlasov.ForMathlib.PicardLindelof`) to extract a characteristic flow
-`(charX, charV)` for the Vlasov ODE.
-The four `IsPicardLindelof` hypotheses (Lipschitz-on-ball,
-continuous-in-time, norm bound, contraction) are derived from
-`convolveFunctionMeasure_lipschitz_in_x`, plus narrow-continuity of the
-spatial-marginal curve `ρ`, plus a uniform norm bound from the
-finite-mass assumption.
-
-The contraction condition `L · max(tmax − t₀, t₀ − tmin) ≤ a − r`
-pins down the local time-interval size relative to the ball radius.
-For the dobrushin application we work on a finite interval `[0, T]`;
-the existence theorem is parametrised by `T` and produces a flow
-on `Set.Icc 0 T` (extending the local flow by stitching overlapping
-windows; technically a separate iteration argument, deferred to
-the proof body).
-
-This sub-section first establishes the **global Lipschitz constant**
-for `vlasovVectorField` (a direct composition of
-`convolveFunctionMeasure_lipschitz_in_x` with the 1-Lipschitz
-identity on the velocity coordinate, combined via `LipschitzWith.prodMk`).
-The global Lipschitz immediately restricts to any closed ball,
-giving the first of the four `IsPicardLindelof` fields.
-
-The full `exists_vlasov_characteristicFlow` proof packages the global
-norm bound into a per-window `IsPicardLindelof`, invokes the vendored
-Picard-Lindelöf (`exists_vlasov_extend_one_window`), and stitches
-`N = ⌈T/δ⌉` windows per-`z` via `HasDerivWithinAt.union` under the
-position/velocity inductive invariant.  Downstream callers discharge its
-`hR`/`hbound` hypotheses; the single-ball `hR` discharge in
-`exists_vlasov_trajectory` is what introduces the
-`LocalSmallnessPLBuffer L T := L·T² < 1` constraint — see that
-theorem's docstring for the arbitrary-`L` discussion. -/
-
-/-- Localized variant of `IsCharacteristicFlow` from `Basic.lean`:
-the same initial condition + position/velocity ODEs, but quantified
-over a chosen time set `s_t : Set ℝ` and initial-condition set
-`s_z : Set (PhaseSpace d)`.
-
-The global `IsCharacteristicFlow gradW ρ charX charV` is the
-specialisation `IsCharacteristicFlowOn ... Set.univ Set.univ`
-(modulo the unconditional init clause). -/
-def IsCharacteristicFlowOn
-    {d : ℕ}
-    (gradW : PhysSpace d → PhysSpace d)
-    (ρ : ℝ → Measure (PhysSpace d))
-    (charX charV : ℝ → PhaseSpace d → PhysSpace d)
-    (s_t : Set ℝ) (s_z : Set (PhaseSpace d)) : Prop :=
-  (∀ z ∈ s_z, charX 0 z = z.1 ∧ charV 0 z = z.2) ∧
-  (∀ t ∈ s_t, ∀ z ∈ s_z, HasDerivAt (fun s => charX s z) (charV t z) t) ∧
-  (∀ t ∈ s_t, ∀ z ∈ s_z, HasDerivAt (fun s => charV s z)
-      (-(convolveFunctionMeasure gradW (ρ t) (charX t z))) t)
-
-/-- Monotonicity of `IsCharacteristicFlowOn` in both the time set and the
-initial-condition set.  Used at the end of the global existence theorem
-to restrict a flow produced on `Ioo 0 (N·δ)` (covering all of `[0, T]`)
-down to `Ioo 0 T`. -/
-lemma IsCharacteristicFlowOn.mono
-    {d : ℕ}
-    {gradW : PhysSpace d → PhysSpace d}
-    {ρ : ℝ → Measure (PhysSpace d)}
-    {charX charV : ℝ → PhaseSpace d → PhysSpace d}
-    {s_t s_t' : Set ℝ} {s_z s_z' : Set (PhaseSpace d)}
-    (h : IsCharacteristicFlowOn gradW ρ charX charV s_t s_z)
-    (hs_t : s_t' ⊆ s_t) (hs_z : s_z' ⊆ s_z) :
-    IsCharacteristicFlowOn gradW ρ charX charV s_t' s_z' := by
-  refine ⟨fun z hz => h.1 z (hs_z hz), fun t ht z hz => ?_, fun t ht z hz => ?_⟩
-  · exact h.2.1 t (hs_t ht) z (hs_z hz)
-  · exact h.2.2 t (hs_t ht) z (hs_z hz)
+private alias hasDerivWithinAt_Icc_self :=
+  _root_.Vlasov.hasDerivWithinAt_Icc_self
 
 /-! ### Localized Vlasov-solution predicates on `[0, T]`
 
@@ -1264,1512 +203,6 @@ lemma IsLagrangianVlasovSolution.toOn {d : ℕ}
       continuous_iff_continuousAt.mpr (fun t => (h_flow.2.2 t z).continuousAt)
     exact (hX.prodMk hV).continuousOn
 
-/-- Global Lipschitz constant for the Vlasov phase-space vector field.
-`b_t(x, v) = (v, -(∇W ∗ ρ_t)(x))` is `max(1, L)`-Lipschitz when
-`gradW` is `L`-Lipschitz: the velocity-side projection `(x, v) ↦ v`
-is 1-Lipschitz (`LipschitzWith.prod_snd`), and the force-side map
-`(x, v) ↦ -(∇W ∗ ρ_t)(x)` is `L`-Lipschitz (compose
-`convolveFunctionMeasure_lipschitz_in_x` with `Neg.neg` and
-`Prod.fst`, both 1-Lipschitz).  Combining the two via
-`LipschitzWith.prodMk` yields `max(1, L)` on the product. -/
-lemma vlasovVectorField_lipschitzWith
-    {d : ℕ}
-    (gradW : PhysSpace d → PhysSpace d)
-    (L : NNReal) (hL : LipschitzWith L gradW)
-    (ρ : ℝ → Measure (PhysSpace d)) [∀ t, IsProbabilityMeasure (ρ t)]
-    (h_int : ∀ t (x : PhysSpace d), Integrable (fun y => gradW (x - y)) (ρ t))
-    (t : ℝ) :
-    LipschitzWith (max 1 L) (vlasovVectorField gradW ρ t) := by
-  -- Force-side `x ↦ (∇W ∗ ρ_t)(x)` is `L`-Lipschitz.
-  have h_conv : LipschitzWith L
-      (fun x : PhysSpace d => convolveFunctionMeasure gradW (ρ t) x) :=
-    convolveFunctionMeasure_lipschitz_in_x gradW L hL (ρ t) (h_int t)
-  -- Negate (`Neg.neg` is 1-Lipschitz): `x ↦ -(∇W ∗ ρ_t)(x)` is still `L`-Lipschitz.
-  have h_neg_conv : LipschitzWith L
-      (fun x : PhysSpace d => -convolveFunctionMeasure gradW (ρ t) x) := by
-    simpa [Function.comp_def] using LipschitzWith.id.neg.comp h_conv
-  -- Compose with `Prod.fst` (1-Lipschitz): `z ↦ -(∇W ∗ ρ_t)(z.1)` is `L`-Lipschitz.
-  have h_force : LipschitzWith L
-      (fun z : PhaseSpace d => -convolveFunctionMeasure gradW (ρ t) z.1) := by
-    simpa [Function.comp_def] using h_neg_conv.comp
-      (LipschitzWith.prod_fst (α := PhysSpace d) (β := PhysSpace d))
-  -- Combine velocity-side projection (1-Lipschitz) with force-side (L-Lipschitz).
-  exact (LipschitzWith.prod_snd (α := PhysSpace d) (β := PhysSpace d)).prodMk h_force
-
-/-- Pointwise norm bound for the Vlasov phase-space vector field.
-`‖b_t(x, v)‖ ≤ max(‖v‖, ‖(∇W ∗ ρ_t)(x)‖)` for the product `max`-norm
-on `PhaseSpace d = PhysSpace d × PhysSpace d`.
-
-This is the decomposition used to derive `IsPicardLindelof.norm_le`
-once a uniform bound `M` for `‖(∇W ∗ ρ_t)(x)‖` on a closed ball is
-known (e.g. from finite-first-moment + Lipschitz growth of `gradW`). -/
-lemma vlasovVectorField_norm_le
-    {d : ℕ}
-    (gradW : PhysSpace d → PhysSpace d)
-    (ρ : ℝ → Measure (PhysSpace d)) (t : ℝ) (z : PhaseSpace d) :
-    ‖vlasovVectorField gradW ρ t z‖ ≤
-      max ‖z.2‖ ‖convolveFunctionMeasure gradW (ρ t) z.1‖ := by
-  unfold vlasovVectorField
-  -- Prod norm is the max of component norms; neg preserves norm.
-  simp [Prod.norm_def, norm_neg]
-
-/-- **Local-flow** existence for the Vlasov ODE.
-
-Wraps the vendored parametric Picard-Lindelöf
-(`IsPicardLindelof.exists_forall_mem_closedBall_eq_forall_mem_Icc_hasDerivWithinAt_confined`,
-`LeanPool.Vlasov.ForMathlib.PicardLindelof`)
-into a `HasDerivAt`-on-`Ioo`-shaped characteristic flow.  The result
-holds for initial conditions inside `closedBall z₀ (a/2)` and for
-times in `Ioo 0 δ` where `δ` is a Picard-derived constant.
-
-The new hypothesis `hbound` (uniform norm bound on the convolution
-force on a slightly larger ball, over `[0, 1]`) is the genuine input
-the Picard wrapper needs: the contraction condition + the `norm_le`
-field of `IsPicardLindelof` both require a global bound on `‖b_t‖`.
-
-The global existence form `exists_vlasov_characteristicFlow` (below)
-is the stitched version on `[0, T]`, iterating this local theorem on
-overlapping windows and gluing with `ODE_solution_unique`. -/
-theorem exists_vlasov_characteristicFlow_local
-    {d : ℕ}
-    (W : PhysSpace d → ℝ)
-    (gradW : PhysSpace d → PhysSpace d)
-    (_hgradW : ∀ x, gradW x = gradient W x)
-    (L : NNReal) (hL : LipschitzWith L gradW)
-    (ρ : ℝ → Measure (PhysSpace d))
-    [∀ t, IsProbabilityMeasure (ρ t)]
-    (h_int : ∀ t (x : PhysSpace d), Integrable (fun y => gradW (x - y)) (ρ t))
-    (hρ_cont : ∀ x : PhysSpace d,
-      Continuous (fun t => convolveFunctionMeasure gradW (ρ t) x))
-    -- Local-flow data: the basepoint `z₀`, the ball radius `a`, and a
-    -- uniform force bound `M` on `closedBall z₀.1 (3a/2)` over `[0,1]`.
-    (z₀ : PhaseSpace d) (a : NNReal) (ha : 0 < a)
-    (M : NNReal)
-    (hbound : ∀ t ∈ Set.Icc (0 : ℝ) (1 : ℝ),
-              ∀ x ∈ Metric.closedBall z₀.1 (3 * (a : ℝ) / 2),
-              ‖convolveFunctionMeasure gradW (ρ t) x‖ ≤ M) :
-    ∃ (δ : ℝ) (_ : 0 < δ) (charX charV : ℝ → PhaseSpace d → PhysSpace d),
-      IsCharacteristicFlowOn gradW ρ charX charV
-        (Set.Ioo 0 δ) (Metric.closedBall z₀ ((a : ℝ) / 2)) := by
-  classical
-  -- IsPicardLindelof parameter choices.
-  set K_pl : NNReal := max 1 L with hK_pl_def
-  set r_pl : NNReal := a / 2 with hr_pl_def
-  set L_pl : NNReal := ‖z₀.2‖₊ + a + M with hL_pl_def
-  -- δ chosen to satisfy the contraction L_pl · δ ≤ a − r_pl = a/2.
-  set δ : ℝ := min 1 ((a : ℝ) / 2 / ((L_pl : ℝ) + 1)) with hδ_def
-  have ha_real : (0 : ℝ) < (a : ℝ) := by exact_mod_cast ha
-  have h_denom_pos : (0 : ℝ) < (L_pl : ℝ) + 1 := by positivity
-  have h_ratio_pos : (0 : ℝ) < (a : ℝ) / 2 / ((L_pl : ℝ) + 1) := by positivity
-  have hδ_pos : (0 : ℝ) < δ := lt_min one_pos h_ratio_pos
-  have hδ_le_one : δ ≤ 1 := min_le_left _ _
-  have hδ_le_ratio : δ ≤ (a : ℝ) / 2 / ((L_pl : ℝ) + 1) := min_le_right _ _
-  -- t₀ ∈ Icc 0 δ.
-  let t₀ : Set.Icc (0 : ℝ) δ := ⟨0, Set.mem_Icc.mpr ⟨le_refl 0, le_of_lt hδ_pos⟩⟩
-  -- Assemble IsPicardLindelof.
-  have hpl : IsPicardLindelof (vlasovVectorField gradW ρ) t₀ z₀ a r_pl L_pl K_pl := by
-    refine ⟨?_, ?_, ?_, ?_⟩
-    · -- (a) lipschitzOnWith via vlasovVectorField_lipschitzWith.
-      intro t _
-      exact (vlasovVectorField_lipschitzWith gradW L hL ρ h_int t).lipschitzOnWith
-    · -- (b) continuousOn: velocity component constant in t, force continuous by hρ_cont.
-      intro x _
-      apply Continuous.continuousOn
-      simp only [vlasovVectorField]
-      exact Continuous.prodMk continuous_const (hρ_cont x.1).neg
-    · -- (c) norm_le.
-      intro t ht x hx
-      have h_norm_field := vlasovVectorField_norm_le gradW ρ t x
-      have hdist_le : dist x z₀ ≤ (a : ℝ) := hx
-      have hdist_le_norm : ‖x - z₀‖ ≤ (a : ℝ) := by rwa [dist_eq_norm] at hdist_le
-      have h_x2_proj : ‖x.2 - z₀.2‖ ≤ ‖x - z₀‖ := by
-        rw [Prod.norm_def]; exact le_max_right _ _
-      have h_x2_bound : ‖x.2‖ ≤ ‖z₀.2‖ + (a : ℝ) := by
-        have h1 : ‖x.2‖ = ‖(x.2 - z₀.2) + z₀.2‖ := by rw [sub_add_cancel]
-        have h2 : ‖(x.2 - z₀.2) + z₀.2‖ ≤ ‖x.2 - z₀.2‖ + ‖z₀.2‖ := norm_add_le _ _
-        linarith [h_x2_proj, hdist_le_norm]
-      have h_x1_proj : dist x.1 z₀.1 ≤ dist x z₀ := by
-        simp only [Prod.dist_eq]; exact le_max_left _ _
-      have h_x1_ball : x.1 ∈ Metric.closedBall z₀.1 (3 * (a : ℝ) / 2) := by
-        have hx1d : dist x.1 z₀.1 ≤ (a : ℝ) := le_trans h_x1_proj hdist_le
-        have : dist x.1 z₀.1 ≤ 3 * (a : ℝ) / 2 := by
-          have ha_nn : (0 : ℝ) ≤ (a : ℝ) := le_of_lt ha_real
-          linarith
-        exact this
-      have h_t_Icc : t ∈ Set.Icc (0 : ℝ) 1 :=
-        ⟨ht.1, le_trans ht.2 hδ_le_one⟩
-      have h_force_bound : ‖convolveFunctionMeasure gradW (ρ t) x.1‖ ≤ (M : ℝ) :=
-        hbound t h_t_Icc x.1 h_x1_ball
-      have h_Lpl_eq : (L_pl : ℝ) = ‖z₀.2‖ + (a : ℝ) + (M : ℝ) := by
-        simp [hL_pl_def, NNReal.coe_add, coe_nnnorm]
-      calc ‖vlasovVectorField gradW ρ t x‖
-          ≤ max ‖x.2‖ ‖convolveFunctionMeasure gradW (ρ t) x.1‖ := h_norm_field
-        _ ≤ (L_pl : ℝ) := by
-            rw [h_Lpl_eq]
-            apply max_le
-            · linarith [NNReal.coe_nonneg M]
-            · linarith [norm_nonneg z₀.2, NNReal.coe_nonneg a]
-    · -- (d) mul_max_le: L_pl · max(δ − 0, 0 − 0) = L_pl · δ ≤ a − a/2 = a/2.
-      show (L_pl : ℝ) * max (δ - (t₀ : ℝ)) ((t₀ : ℝ) - 0) ≤ (a : ℝ) - (r_pl : ℝ)
-      have ht₀_eq : (t₀ : ℝ) = 0 := rfl
-      simp only [ht₀_eq, sub_zero, sub_self, max_eq_left (le_of_lt hδ_pos)]
-      have h_a_minus_r : (a : ℝ) - (r_pl : ℝ) = (a : ℝ) / 2 := by
-        simp [hr_pl_def, NNReal.coe_div]
-        ring
-      rw [h_a_minus_r]
-      -- L_pl * δ ≤ a/2 since δ ≤ (a/2)/(L_pl+1) and L_pl ≤ L_pl + 1.
-      have h_Lpl_nn : (0 : ℝ) ≤ (L_pl : ℝ) := L_pl.coe_nonneg
-      have h_a_nn : (0 : ℝ) ≤ (a : ℝ) / 2 := by linarith [ha_real]
-      have h_step : (L_pl : ℝ) * δ ≤ (L_pl : ℝ) *
-          ((a : ℝ) / 2 / ((L_pl : ℝ) + 1)) :=
-        mul_le_mul_of_nonneg_left hδ_le_ratio h_Lpl_nn
-      have h_rewrite : (L_pl : ℝ) * ((a : ℝ) / 2 / ((L_pl : ℝ) + 1))
-          = (L_pl : ℝ) / ((L_pl : ℝ) + 1) * ((a : ℝ) / 2) := by ring
-      have h_frac_le : (L_pl : ℝ) / ((L_pl : ℝ) + 1) ≤ 1 := by
-        rw [div_le_one h_denom_pos]; linarith
-      have h_bound : (L_pl : ℝ) / ((L_pl : ℝ) + 1) * ((a : ℝ) / 2) ≤ (a : ℝ) / 2 := by
-        calc (L_pl : ℝ) / ((L_pl : ℝ) + 1) * ((a : ℝ) / 2)
-            ≤ 1 * ((a : ℝ) / 2) :=
-              mul_le_mul_of_nonneg_right h_frac_le h_a_nn
-          _ = (a : ℝ) / 2 := one_mul _
-      linarith [h_step, h_rewrite ▸ h_step, h_bound]
-  -- Invoke headline Picard-Lindelöf.
-  obtain ⟨α, hα⟩ := hpl.exists_forall_mem_closedBall_eq_forall_mem_Icc_hasDerivWithinAt_confined
-  -- α : PhaseSpace d → ℝ → PhaseSpace d.  Define charX, charV by projection.
-  refine ⟨δ, hδ_pos, fun t z => (α z t).1, fun t z => (α z t).2, ?_, ?_, ?_⟩
-  · -- Initial condition: α z 0 = z gives both component equalities.
-    intro z hz
-    have hz_in_r : z ∈ Metric.closedBall z₀ (r_pl : ℝ) := by
-      have hreq : (r_pl : ℝ) = (a : ℝ) / 2 := by simp [hr_pl_def, NNReal.coe_div]
-      rw [Metric.mem_closedBall] at hz ⊢
-      rw [hreq]; exact hz
-    have h_init : α z (t₀ : ℝ) = z := (hα z hz_in_r).1
-    have ht₀_eq : (t₀ : ℝ) = 0 := rfl
-    rw [ht₀_eq] at h_init
-    refine ⟨?_, ?_⟩
-    · change (α z 0).1 = z.1; rw [h_init]
-    · change (α z 0).2 = z.2; rw [h_init]
-  · -- Position ODE: HasDerivAt (charX · z) (charV t z) t.
-    intro t ht z hz
-    have hz_in_r : z ∈ Metric.closedBall z₀ (r_pl : ℝ) := by
-      have : (r_pl : ℝ) = (a : ℝ) / 2 := by simp [hr_pl_def, NNReal.coe_div]
-      rw [Metric.mem_closedBall] at hz ⊢; rw [this]; exact hz
-    have h_t_Icc : t ∈ Set.Icc (0 : ℝ) δ := ⟨le_of_lt ht.1, le_of_lt ht.2⟩
-    have h_dw := (hα z hz_in_r).2.1 t h_t_Icc
-    have h_icc_nhds : Set.Icc (0 : ℝ) δ ∈ nhds t := Icc_mem_nhds ht.1 ht.2
-    have h_d : HasDerivAt (α z) (vlasovVectorField gradW ρ t (α z t)) t :=
-      h_dw.hasDerivAt h_icc_nhds
-    have h_proj : HasDerivAt (fun s => (α z s).1)
-        (vlasovVectorField gradW ρ t (α z t)).1 t :=
-      (hasFDerivAt_fst (E := PhysSpace d) (F := PhysSpace d)).comp_hasDerivAt t h_d
-    simpa [vlasovVectorField] using h_proj
-  · -- Velocity ODE: HasDerivAt (charV · z) (−(∇W∗ρ)(charX t z)) t.
-    intro t ht z hz
-    have hz_in_r : z ∈ Metric.closedBall z₀ (r_pl : ℝ) := by
-      have : (r_pl : ℝ) = (a : ℝ) / 2 := by simp [hr_pl_def, NNReal.coe_div]
-      rw [Metric.mem_closedBall] at hz ⊢; rw [this]; exact hz
-    have h_t_Icc : t ∈ Set.Icc (0 : ℝ) δ := ⟨le_of_lt ht.1, le_of_lt ht.2⟩
-    have h_dw := (hα z hz_in_r).2.1 t h_t_Icc
-    have h_icc_nhds : Set.Icc (0 : ℝ) δ ∈ nhds t := Icc_mem_nhds ht.1 ht.2
-    have h_d : HasDerivAt (α z) (vlasovVectorField gradW ρ t (α z t)) t :=
-      h_dw.hasDerivAt h_icc_nhds
-    have h_proj : HasDerivAt (fun s => (α z s).2)
-        (vlasovVectorField gradW ρ t (α z t)).2 t :=
-      (hasFDerivAt_snd (E := PhysSpace d) (F := PhysSpace d)).comp_hasDerivAt t h_d
-    simpa [vlasovVectorField] using h_proj
-
-/-- **Per-z, time-shifted single-trajectory Picard with a uniform velocity-bound parameter.**
-
-Given a fixed phase-space point `w`, a starting time `t_start`, an a priori
-velocity bound `V_max ≥ ‖w.2‖`, and a uniform force bound around `w` on the
-time interval `[t_start, t_start + 1]`, this produces a single trajectory
-`β : ℝ → PhaseSpace d` solving the Vlasov ODE on `Ioo t_start (t_start + δ)`
-with `β t_start = w`.
-
-**Why `V_max` as a separate parameter:** the Picard contraction time δ
-depends on the norm-bound `L_pl := V_max + a + M` for the vector field on
-the local ball.  Phrasing this via an explicit `V_max ≥ ‖w.2‖` rather than
-the tight `‖w.2‖` makes δ uniform in `w` for any iteration centered at
-points `w` whose velocity component is bounded by `V_max`.  This is the
-input that lets the N-window iteration in
-`exists_vlasov_characteristicFlow` pick a single δ valid across all
-windows (by combining with the a priori bound
-`‖w_n(z).2‖ ≤ ‖z₀.2‖ + a/2 + M·(T+1)` on a finite `[0, T]`-interval).
-
-Implementation: build an IsPicardLindelof centered at `w` over `[t_start,
-t_start + δ]` with `L_pl := V_max + a + M`.  Invoke the vendored headline
-theorem.  Take the single trajectory `β t := α w t`. -/
-lemma exists_vlasov_extend_one_window
-    {d : ℕ}
-    (gradW : PhysSpace d → PhysSpace d)
-    (L : NNReal) (hL : LipschitzWith L gradW)
-    (ρ : ℝ → Measure (PhysSpace d))
-    [∀ t, IsProbabilityMeasure (ρ t)]
-    (h_int : ∀ t (x : PhysSpace d), Integrable (fun y => gradW (x - y)) (ρ t))
-    (hρ_cont : ∀ x : PhysSpace d,
-      Continuous (fun t => convolveFunctionMeasure gradW (ρ t) x))
-    (w : PhaseSpace d) (a : NNReal) (ha : 0 < a) (M : NNReal)
-    (V_max : NNReal) (hV : ‖w.2‖ ≤ (V_max : ℝ))
-    (t_start : ℝ)
-    (hbound : ∀ t ∈ Set.Icc t_start (t_start + 1),
-              ∀ x ∈ Metric.closedBall w.1 (3 * (a : ℝ) / 2),
-              ‖convolveFunctionMeasure gradW (ρ t) x‖ ≤ M) :
-    ∃ (δ : ℝ) (_ : 0 < δ) (β : ℝ → PhaseSpace d),
-      δ = min 1 ((a : ℝ) / 2 / (((V_max + a + M : NNReal) : ℝ) + 1)) ∧
-      β t_start = w ∧
-      (∀ t ∈ Set.Ioo t_start (t_start + δ),
-        HasDerivAt (fun s => (β s).1) (β t).2 t ∧
-        HasDerivAt (fun s => (β s).2)
-          (-(convolveFunctionMeasure gradW (ρ t) (β t).1)) t) ∧
-      (∀ t ∈ Set.Icc t_start (t_start + δ),
-        HasDerivWithinAt (fun s => (β s).1) (β t).2
-          (Set.Icc t_start (t_start + δ)) t ∧
-        HasDerivWithinAt (fun s => (β s).2)
-          (-(convolveFunctionMeasure gradW (ρ t) (β t).1))
-          (Set.Icc t_start (t_start + δ)) t) ∧
-      (∀ s ∈ Set.Icc t_start (t_start + δ), β s ∈ Metric.closedBall w (a : ℝ)) := by
-  classical
-  set K_pl : NNReal := max 1 L with hK_pl_def
-  set r_pl : NNReal := a / 2 with hr_pl_def
-  set L_pl : NNReal := V_max + a + M with hL_pl_def
-  set δ : ℝ := min 1 ((a : ℝ) / 2 / ((L_pl : ℝ) + 1)) with hδ_def
-  have ha_real : (0 : ℝ) < (a : ℝ) := by exact_mod_cast ha
-  have h_denom_pos : (0 : ℝ) < (L_pl : ℝ) + 1 := by positivity
-  have h_ratio_pos : (0 : ℝ) < (a : ℝ) / 2 / ((L_pl : ℝ) + 1) := by positivity
-  have hδ_pos : (0 : ℝ) < δ := lt_min one_pos h_ratio_pos
-  have hδ_le_one : δ ≤ 1 := min_le_left _ _
-  have hδ_le_ratio : δ ≤ (a : ℝ) / 2 / ((L_pl : ℝ) + 1) := min_le_right _ _
-  let t₀ : Set.Icc t_start (t_start + δ) :=
-    ⟨t_start, Set.mem_Icc.mpr ⟨le_refl _, by linarith⟩⟩
-  have hpl : IsPicardLindelof (vlasovVectorField gradW ρ) t₀ w a r_pl L_pl K_pl := by
-    refine ⟨?_, ?_, ?_, ?_⟩
-    · intro t _
-      exact (vlasovVectorField_lipschitzWith gradW L hL ρ h_int t).lipschitzOnWith
-    · intro x _
-      apply Continuous.continuousOn
-      simp only [vlasovVectorField]
-      exact Continuous.prodMk continuous_const (hρ_cont x.1).neg
-    · intro t ht x hx
-      have h_norm_field := vlasovVectorField_norm_le gradW ρ t x
-      have hdist_le : dist x w ≤ (a : ℝ) := hx
-      have hdist_le_norm : ‖x - w‖ ≤ (a : ℝ) := by rwa [dist_eq_norm] at hdist_le
-      have h_x2_proj : ‖x.2 - w.2‖ ≤ ‖x - w‖ := by
-        rw [Prod.norm_def]; exact le_max_right _ _
-      have h_x2_bound : ‖x.2‖ ≤ ‖w.2‖ + (a : ℝ) := by
-        have h1 : ‖x.2‖ = ‖(x.2 - w.2) + w.2‖ := by rw [sub_add_cancel]
-        have h2 : ‖(x.2 - w.2) + w.2‖ ≤ ‖x.2 - w.2‖ + ‖w.2‖ := norm_add_le _ _
-        linarith [h_x2_proj, hdist_le_norm]
-      have h_x1_proj : dist x.1 w.1 ≤ dist x w := by
-        simp only [Prod.dist_eq]; exact le_max_left _ _
-      have h_x1_ball : x.1 ∈ Metric.closedBall w.1 (3 * (a : ℝ) / 2) := by
-        rw [Metric.mem_closedBall]
-        have hx1d : dist x.1 w.1 ≤ (a : ℝ) := le_trans h_x1_proj hdist_le
-        have ha_nn : (0 : ℝ) ≤ (a : ℝ) := le_of_lt ha_real
-        linarith
-      have h_t_Icc : t ∈ Set.Icc t_start (t_start + 1) :=
-        ⟨ht.1, le_trans ht.2 (by linarith [hδ_le_one])⟩
-      have h_force_bound : ‖convolveFunctionMeasure gradW (ρ t) x.1‖ ≤ (M : ℝ) :=
-        hbound t h_t_Icc x.1 h_x1_ball
-      have h_Lpl_eq : (L_pl : ℝ) = (V_max : ℝ) + (a : ℝ) + (M : ℝ) := by
-        simp [hL_pl_def, NNReal.coe_add]
-      have h_x2_bound' : ‖x.2‖ ≤ (V_max : ℝ) + (a : ℝ) :=
-        le_trans h_x2_bound (by linarith [hV])
-      calc ‖vlasovVectorField gradW ρ t x‖
-          ≤ max ‖x.2‖ ‖convolveFunctionMeasure gradW (ρ t) x.1‖ := h_norm_field
-        _ ≤ (L_pl : ℝ) := by
-            rw [h_Lpl_eq]
-            apply max_le
-            · linarith [NNReal.coe_nonneg M, h_x2_bound']
-            · linarith [norm_nonneg w.2, NNReal.coe_nonneg a, NNReal.coe_nonneg V_max]
-    · show (L_pl : ℝ) * max ((t_start + δ) - (t₀ : ℝ)) ((t₀ : ℝ) - t_start)
-          ≤ (a : ℝ) - (r_pl : ℝ)
-      have ht₀_eq : (t₀ : ℝ) = t_start := rfl
-      simp only [ht₀_eq, add_sub_cancel_left, sub_self, max_eq_left (le_of_lt hδ_pos)]
-      have h_a_minus_r : (a : ℝ) - (r_pl : ℝ) = (a : ℝ) / 2 := by
-        simp [hr_pl_def, NNReal.coe_div]; ring
-      rw [h_a_minus_r]
-      have h_Lpl_nn : (0 : ℝ) ≤ (L_pl : ℝ) := L_pl.coe_nonneg
-      have h_a_nn : (0 : ℝ) ≤ (a : ℝ) / 2 := by linarith [ha_real]
-      have h_step : (L_pl : ℝ) * δ ≤ (L_pl : ℝ) *
-          ((a : ℝ) / 2 / ((L_pl : ℝ) + 1)) :=
-        mul_le_mul_of_nonneg_left hδ_le_ratio h_Lpl_nn
-      have h_rewrite : (L_pl : ℝ) * ((a : ℝ) / 2 / ((L_pl : ℝ) + 1))
-          = (L_pl : ℝ) / ((L_pl : ℝ) + 1) * ((a : ℝ) / 2) := by ring
-      have h_frac_le : (L_pl : ℝ) / ((L_pl : ℝ) + 1) ≤ 1 := by
-        rw [div_le_one h_denom_pos]; linarith
-      have h_bound : (L_pl : ℝ) / ((L_pl : ℝ) + 1) * ((a : ℝ) / 2) ≤ (a : ℝ) / 2 := by
-        calc (L_pl : ℝ) / ((L_pl : ℝ) + 1) * ((a : ℝ) / 2)
-            ≤ 1 * ((a : ℝ) / 2) :=
-              mul_le_mul_of_nonneg_right h_frac_le h_a_nn
-          _ = (a : ℝ) / 2 := one_mul _
-      linarith [h_step, h_rewrite ▸ h_step, h_bound]
-  obtain ⟨α, hα⟩ := hpl.exists_forall_mem_closedBall_eq_forall_mem_Icc_hasDerivWithinAt_confined
-  have hw_in_r : w ∈ Metric.closedBall w ((r_pl : ℝ)) := by
-    rw [Metric.mem_closedBall, dist_self]
-    exact r_pl.coe_nonneg
-  have hα_w := hα w hw_in_r
-  refine ⟨δ, hδ_pos, fun t => α w t, ?_, ?_, ?_, ?_, ?_⟩
-  · rfl
-  · have h_init : α w (t₀ : ℝ) = w := hα_w.1
-    have ht₀_eq : (t₀ : ℝ) = t_start := rfl
-    rw [ht₀_eq] at h_init
-    exact h_init
-  · intro t ht
-    have h_t_Icc : t ∈ Set.Icc t_start (t_start + δ) :=
-      ⟨le_of_lt ht.1, le_of_lt ht.2⟩
-    have h_dw := hα_w.2.1 t h_t_Icc
-    have h_icc_nhds : Set.Icc t_start (t_start + δ) ∈ nhds t := Icc_mem_nhds ht.1 ht.2
-    have h_d : HasDerivAt (α w) (vlasovVectorField gradW ρ t (α w t)) t :=
-      h_dw.hasDerivAt h_icc_nhds
-    refine ⟨?_, ?_⟩
-    · have h_proj : HasDerivAt (fun s => (α w s).1)
-          (vlasovVectorField gradW ρ t (α w t)).1 t :=
-        (hasFDerivAt_fst (E := PhysSpace d) (F := PhysSpace d)).comp_hasDerivAt t h_d
-      simpa [vlasovVectorField] using h_proj
-    · have h_proj : HasDerivAt (fun s => (α w s).2)
-          (vlasovVectorField gradW ρ t (α w t)).2 t :=
-        (hasFDerivAt_snd (E := PhysSpace d) (F := PhysSpace d)).comp_hasDerivAt t h_d
-      simpa [vlasovVectorField] using h_proj
-  · intro t ht
-    have h_dw := hα_w.2.1 t ht
-    refine ⟨?_, ?_⟩
-    · have h_proj : HasDerivWithinAt (fun s => (α w s).1)
-          (vlasovVectorField gradW ρ t (α w t)).1
-          (Set.Icc t_start (t_start + δ)) t :=
-        (hasFDerivAt_fst (E := PhysSpace d) (F := PhysSpace d)).comp_hasDerivWithinAt t h_dw
-      simpa [vlasovVectorField] using h_proj
-    · have h_proj : HasDerivWithinAt (fun s => (α w s).2)
-          (vlasovVectorField gradW ρ t (α w t)).2
-          (Set.Icc t_start (t_start + δ)) t :=
-        (hasFDerivAt_snd (E := PhysSpace d) (F := PhysSpace d)).comp_hasDerivWithinAt t h_dw
-      simpa [vlasovVectorField] using h_proj
-  · -- confinement: β s ∈ closedBall w a (delivered by `_confined` variant)
-    intro s hs
-    exact hα_w.2.2 s hs
-
-/-! ### Per-window helpers for the N-window induction in
-    `exists_vlasov_characteristicFlow`.
-
-    These three top-level lemmas are generic in `(β, ODE, confinement,
-    field bound, IH bound, reference point)` with no mention of the
-    N-window induction context (no `γ_k`, `k`, `N`, `z₀`).  This
-    genericity gives each helper its own elaboration budget AND makes
-    them composable for future call sites — the Lagrangian → Eulerian
-    chain rule, well-posedness's Banach iteration, etc.
-
-    Composition order: Helper 1 (confinement) → Helper 2 (window-wide
-    velocity bound) → Helper 3 (endpoint position bound).
--/
-
-/-- **Helper 1: Picard window confinement (projection from phase-space ball).**
-
-For a trajectory β satisfying the Vlasov ODE on a Picard window
-`[t_start, t_start + δ]` centered at `w`, the position component
-stays within the local force-bound ball:
-`(β s).1 ∈ closedBall w.1 (3a/2)` for `s` in the window.
-
-**Argument.**  The strengthened Picard-Lindelöf theorem
-`exists_forall_mem_closedBall_eq_forall_mem_Icc_hasDerivWithinAt_confined`
-(`LeanPool.Vlasov.ForMathlib.PicardLindelof`) exposes
-`FunSpace.compProj_mem_closedBall` at the public theorem level,
-delivering `β s ∈ closedBall w a` (phase-space ball of radius `a` —
-the outer Lipschitz radius) as a side product of the existence
-guarantee.  We project this to the position component via
-`Prod.dist_eq` + `le_max_left`, then loosen `a ≤ 3a/2` by arithmetic.
-The result is a 3-5 line projection.
-
-**Hypothesis `hβ_confined`** is supplied by Vlasov-side callers from
-the widened `exists_vlasov_extend_one_window` output.  The other
-hypotheses (ODE, field
-bound, contraction inequality) are retained for genericity / call
-site compatibility; they are not consumed by the projection body but
-remain available for future call sites that want to re-derive the
-confinement directly (e.g. via supremum trick) without invoking
-the vendored Mathlib API. -/
-lemma vlasov_window_confinement
-    {d : ℕ}
-    (gradW : PhysSpace d → PhysSpace d)
-    (L : NNReal) (_hL : LipschitzWith L gradW)
-    (ρ : ℝ → Measure (PhysSpace d))
-    (_h_int : ∀ t (x : PhysSpace d), Integrable (fun y => gradW (x - y)) (ρ t))
-    (_hρ_cont : ∀ x : PhysSpace d,
-      Continuous (fun t => convolveFunctionMeasure gradW (ρ t) x))
-    (w : PhaseSpace d) (a : NNReal) (_ha : 0 < a) (M : NNReal)
-    (V_max : NNReal) (_hV : ‖w.2‖ ≤ (V_max : ℝ))
-    (t_start δ : ℝ) (_hδ_pos : 0 < δ) (_hδ_le_one : δ ≤ 1)
-    (_hδ_contract : δ ≤ (a : ℝ) / 2 / (((V_max + a + M : NNReal) : ℝ) + 1))
-    (_hbound : ∀ t ∈ Set.Icc t_start (t_start + 1),
-              ∀ x ∈ Metric.closedBall w.1 (3 * (a : ℝ) / 2),
-              ‖convolveFunctionMeasure gradW (ρ t) x‖ ≤ M)
-    (β : ℝ → PhaseSpace d) (_hβ_init : β t_start = w)
-    (_hβ_ode_Icc : ∀ t ∈ Set.Icc t_start (t_start + δ),
-      HasDerivWithinAt (fun s => (β s).1) (β t).2
-        (Set.Icc t_start (t_start + δ)) t ∧
-      HasDerivWithinAt (fun s => (β s).2)
-        (-(convolveFunctionMeasure gradW (ρ t) (β t).1))
-        (Set.Icc t_start (t_start + δ)) t)
-    (hβ_confined : ∀ s ∈ Set.Icc t_start (t_start + δ),
-      β s ∈ Metric.closedBall w (a : ℝ)) :
-    ∀ s ∈ Set.Icc t_start (t_start + δ),
-      (β s).1 ∈ Metric.closedBall w.1 (3 * (a : ℝ) / 2) := by
-  intro s hs
-  have h_phase : β s ∈ Metric.closedBall w (a : ℝ) := hβ_confined s hs
-  rw [Metric.mem_closedBall] at h_phase ⊢
-  -- dist (β s).1 w.1 ≤ dist (β s) w ≤ a ≤ 3a/2
-  have h_proj : dist (β s).1 w.1 ≤ dist (β s) w := by
-    rw [Prod.dist_eq]; exact le_max_left _ _
-  have h_a_nn : (0 : ℝ) ≤ (a : ℝ) := a.coe_nonneg
-  linarith
-
-/-- **Helper 2: Window-wide velocity bound.**
-
-For a trajectory β with velocity-component ODE
-`(β · ).2' = -(∇W ∗ ρ_·)((β ·).1)` on `[t_start, t_start + δ]` and
-force bound M (made applicable by `h_β_in_ball`), the velocity at
-every interior `s` is bounded by `h_vel_init + M · (s - t_start)`.
-
-**Math sketch.**  One application of
-`Convex.norm_image_sub_le_of_norm_hasDerivWithin_le` on `(β · ).2`
-over the convex window `Icc t_start (t_start + δ)`, with `y := s`
-universally quantified:
-  `‖(β s).2 - (β t_start).2‖ ≤ M · ‖s - t_start‖ = M · (s - t_start)`.
-Triangle with `‖(β t_start).2‖ = ‖w.2‖ ≤ h_vel_init` (using `hβ_init`)
-gives the conclusion.
-
-The universal quantification over `y` in the mean-value lemma is what
-makes this WINDOW-WIDE from ONE invocation — no per-s re-application. -/
-lemma vlasov_window_velocity_bound
-    {d : ℕ}
-    (gradW : PhysSpace d → PhysSpace d)
-    (ρ : ℝ → Measure (PhysSpace d))
-    (w : PhaseSpace d) (a : NNReal) (M : NNReal)
-    (t_start δ : ℝ) (hδ_pos : 0 < δ) (hδ_le_one : δ ≤ 1)
-    (h_vel_init : ℝ) (hβ_init_vel_bound : ‖w.2‖ ≤ h_vel_init)
-    (β : ℝ → PhaseSpace d) (hβ_init : β t_start = w)
-    (hβ_ode_Icc : ∀ t ∈ Set.Icc t_start (t_start + δ),
-      HasDerivWithinAt (fun s => (β s).2)
-        (-(convolveFunctionMeasure gradW (ρ t) (β t).1))
-        (Set.Icc t_start (t_start + δ)) t)
-    (h_β_in_ball : ∀ s ∈ Set.Icc t_start (t_start + δ),
-      (β s).1 ∈ Metric.closedBall w.1 (3 * (a : ℝ) / 2))
-    (hbound : ∀ t ∈ Set.Icc t_start (t_start + 1),
-              ∀ x ∈ Metric.closedBall w.1 (3 * (a : ℝ) / 2),
-              ‖convolveFunctionMeasure gradW (ρ t) x‖ ≤ M) :
-    ∀ s ∈ Set.Icc t_start (t_start + δ),
-      ‖(β s).2‖ ≤ h_vel_init + (M : ℝ) * (s - t_start) := by
-  intro s hs
-  -- Convexity of the window.
-  have h_convex : Convex ℝ (Set.Icc t_start (t_start + δ)) := convex_Icc _ _
-  have h_t_start_in : t_start ∈ Set.Icc t_start (t_start + δ) :=
-    ⟨le_refl _, by linarith⟩
-  -- Force bound on the window (via h_β_in_ball).
-  have h_force_window : ∀ u ∈ Set.Icc t_start (t_start + δ),
-      ‖-(convolveFunctionMeasure gradW (ρ u) (β u).1)‖ ≤ (M : ℝ) := by
-    intro u hu
-    rw [norm_neg]
-    have hu_time : u ∈ Set.Icc t_start (t_start + 1) :=
-      ⟨hu.1, le_trans hu.2 (by linarith [hδ_le_one])⟩
-    exact hbound u hu_time (β u).1 (h_β_in_ball u hu)
-  -- Velocity ODE on the window.
-  have h_vel_ode : ∀ u ∈ Set.Icc t_start (t_start + δ),
-      HasDerivWithinAt (fun v => (β v).2)
-        (-(convolveFunctionMeasure gradW (ρ u) (β u).1))
-        (Set.Icc t_start (t_start + δ)) u :=
-    fun u hu => hβ_ode_Icc u hu
-  -- Apply Convex.norm_image_sub_le with x := t_start, y := s.
-  have h_mv : ‖(β s).2 - (β t_start).2‖ ≤ (M : ℝ) * ‖s - t_start‖ :=
-    h_convex.norm_image_sub_le_of_norm_hasDerivWithin_le
-      h_vel_ode h_force_window h_t_start_in hs
-  have h_diff_nn : 0 ≤ s - t_start := by linarith [hs.1]
-  rw [Real.norm_of_nonneg h_diff_nn] at h_mv
-  -- β t_start = w, so (β t_start).2 = w.2.
-  have h_β_t_start_vel : (β t_start).2 = w.2 := by rw [hβ_init]
-  -- Triangle: ‖(β s).2‖ ≤ ‖(β s).2 - (β t_start).2‖ + ‖(β t_start).2‖.
-  have h_decomp : (β s).2 = ((β s).2 - (β t_start).2) + (β t_start).2 :=
-    (sub_add_cancel _ _).symm
-  have h_triangle : ‖(β s).2‖
-      ≤ ‖(β s).2 - (β t_start).2‖ + ‖(β t_start).2‖ := by
-    calc ‖(β s).2‖ = ‖((β s).2 - (β t_start).2) + (β t_start).2‖ := by rw [← h_decomp]
-      _ ≤ _ := norm_add_le _ _
-  -- Combine: ‖(β s).2‖ ≤ M·(s - t_start) + ‖w.2‖ ≤ h_vel_init + M·(s - t_start).
-  rw [h_β_t_start_vel] at h_triangle
-  -- h_mv has `(β t_start).2`; rewrite to `w.2` for compatibility.
-  rw [h_β_t_start_vel] at h_mv
-  linarith [h_mv, hβ_init_vel_bound]
-
-/-- **Helper 3: Window endpoint position bound.**
-
-For a trajectory β with position-component ODE
-`(β · ).1' = (β · ).2` on `[t_start, t_start + δ]` and a uniform
-velocity bound `V_bound` (typically Helper 2's output composed with
-a worst-case substitution), the position at `t_start + δ` is bounded
-relative to an explicit reference point `x_ref`:
-  `‖(β (t_start + δ)).1 - x_ref‖ ≤ h_pos_init + V_bound · δ`
-where `h_pos_init ≥ ‖w.1 - x_ref‖`.
-
-**Math sketch.**  One application of
-`Convex.norm_image_sub_le_of_norm_hasDerivWithin_le` on `(β · ).1`
-over the convex window with `x := t_start`, `y := t_start + δ`:
-  `‖(β (t_start + δ)).1 - (β t_start).1‖ ≤ V_bound · δ` (using
-  `hβ_init` for `(β t_start).1 = w.1`).
-Triangle with `‖w.1 - x_ref‖ ≤ h_pos_init` gives the conclusion.
-
-**Genericity.**  `x_ref : PhysSpace d` is an explicit parameter, NOT
-hardcoded to the N-window induction's `z₀.1`.  This makes the helper
-reusable for the Lagrangian → Eulerian chain rule (reference point:
-support of test function φ), well-posedness's Banach iteration
-(reference point: fixed-point candidate), etc. -/
-lemma vlasov_window_position_bound
-    {d : ℕ}
-    (_gradW : PhysSpace d → PhysSpace d)
-    (_ρ : ℝ → Measure (PhysSpace d))
-    (w : PhaseSpace d)
-    (t_start δ : ℝ) (hδ_pos : 0 < δ)
-    (V_bound : ℝ)
-    (x_ref : PhysSpace d)
-    (h_pos_init : ℝ) (hβ_init_pos_bound : ‖w.1 - x_ref‖ ≤ h_pos_init)
-    (β : ℝ → PhaseSpace d) (hβ_init : β t_start = w)
-    (hβ_ode_Icc : ∀ t ∈ Set.Icc t_start (t_start + δ),
-      HasDerivWithinAt (fun s => (β s).1) (β t).2
-        (Set.Icc t_start (t_start + δ)) t)
-    (h_window_vel : ∀ s ∈ Set.Icc t_start (t_start + δ),
-      ‖(β s).2‖ ≤ V_bound) :
-    ‖(β (t_start + δ)).1 - x_ref‖ ≤ h_pos_init + V_bound * δ := by
-  -- Convexity of the window.
-  have h_convex : Convex ℝ (Set.Icc t_start (t_start + δ)) := convex_Icc _ _
-  have h_t_start_in : t_start ∈ Set.Icc t_start (t_start + δ) :=
-    ⟨le_refl _, by linarith⟩
-  have h_t_end_in : t_start + δ ∈ Set.Icc t_start (t_start + δ) :=
-    ⟨by linarith, le_refl _⟩
-  -- Position ODE on the window.
-  have h_pos_ode : ∀ u ∈ Set.Icc t_start (t_start + δ),
-      HasDerivWithinAt (fun v => (β v).1) (β u).2
-        (Set.Icc t_start (t_start + δ)) u :=
-    fun u hu => hβ_ode_Icc u hu
-  -- Apply Convex.norm_image_sub_le with x := t_start, y := t_start + δ.
-  have h_mv : ‖(β (t_start + δ)).1 - (β t_start).1‖
-              ≤ V_bound * ‖(t_start + δ) - t_start‖ :=
-    h_convex.norm_image_sub_le_of_norm_hasDerivWithin_le
-      h_pos_ode h_window_vel h_t_start_in h_t_end_in
-  have h_δ_eq : (t_start + δ) - t_start = δ := by ring
-  rw [h_δ_eq, Real.norm_of_nonneg (le_of_lt hδ_pos)] at h_mv
-  -- β t_start = w, so (β t_start).1 = w.1.
-  have h_β_t_start_pos : (β t_start).1 = w.1 := by rw [hβ_init]
-  rw [h_β_t_start_pos] at h_mv
-  -- Triangle: ‖(β (t_start+δ)).1 - x_ref‖
-  --        ≤ ‖(β (t_start+δ)).1 - w.1‖ + ‖w.1 - x_ref‖
-  --        ≤ V_bound · δ + h_pos_init.
-  have h_decomp : (β (t_start + δ)).1 - x_ref
-                = ((β (t_start + δ)).1 - w.1) + (w.1 - x_ref) := by
-    rw [sub_add_sub_cancel]
-  have h_triangle : ‖(β (t_start + δ)).1 - x_ref‖
-      ≤ ‖(β (t_start + δ)).1 - w.1‖ + ‖w.1 - x_ref‖ := by
-    calc ‖(β (t_start + δ)).1 - x_ref‖
-        = ‖((β (t_start + δ)).1 - w.1) + (w.1 - x_ref)‖ := by rw [← h_decomp]
-      _ ≤ _ := norm_add_le _ _
-  linarith [h_mv, hβ_init_pos_bound]
-
-/-- **Tight per-window Picard with an EXPLICIT step δ and an ADAPTIVE force-window.**
-
-Tight form of `exists_vlasov_extend_one_window`: the force bound is required
-only on `[t_start, t_start + δ]` (the actual step), not the loose unit window
-`[t_start, t_start + 1]`, and `δ` is supplied by the caller (so the N-window
-chain can tile exactly, `N·δ = T`, dissolving the `(T+1)²` → `T²` smallness). -/
-lemma exists_vlasov_extend_one_window_tight
-    {d : ℕ}
-    (gradW : PhysSpace d → PhysSpace d)
-    (L : NNReal) (hL : LipschitzWith L gradW)
-    (ρ : ℝ → Measure (PhysSpace d))
-    [∀ t, IsProbabilityMeasure (ρ t)]
-    (h_int : ∀ t (x : PhysSpace d), Integrable (fun y => gradW (x - y)) (ρ t))
-    (hρ_cont : ∀ x : PhysSpace d,
-      Continuous (fun t => convolveFunctionMeasure gradW (ρ t) x))
-    (w : PhaseSpace d) (a : NNReal) (ha : 0 < a) (M : NNReal)
-    (V_max : NNReal) (hV : ‖w.2‖ ≤ (V_max : ℝ))
-    (t_start : ℝ)
-    (δ : ℝ) (hδ_pos : 0 < δ)
-    (hδ_le : δ ≤ (a : ℝ) / 2 / (((V_max + a + M : NNReal) : ℝ) + 1))
-    (hbound : ∀ t ∈ Set.Icc t_start (t_start + δ),
-              ∀ x ∈ Metric.closedBall w.1 (3 * (a : ℝ) / 2),
-              ‖convolveFunctionMeasure gradW (ρ t) x‖ ≤ M) :
-    ∃ β : ℝ → PhaseSpace d,
-      β t_start = w ∧
-      (∀ t ∈ Set.Ioo t_start (t_start + δ),
-        HasDerivAt (fun s => (β s).1) (β t).2 t ∧
-        HasDerivAt (fun s => (β s).2)
-          (-(convolveFunctionMeasure gradW (ρ t) (β t).1)) t) ∧
-      (∀ t ∈ Set.Icc t_start (t_start + δ),
-        HasDerivWithinAt (fun s => (β s).1) (β t).2
-          (Set.Icc t_start (t_start + δ)) t ∧
-        HasDerivWithinAt (fun s => (β s).2)
-          (-(convolveFunctionMeasure gradW (ρ t) (β t).1))
-          (Set.Icc t_start (t_start + δ)) t) ∧
-      (∀ s ∈ Set.Icc t_start (t_start + δ), β s ∈ Metric.closedBall w (a : ℝ)) := by
-  classical
-  set K_pl : NNReal := max 1 L with hK_pl_def
-  set r_pl : NNReal := a / 2 with hr_pl_def
-  set L_pl : NNReal := V_max + a + M with hL_pl_def
-  have ha_real : (0 : ℝ) < (a : ℝ) := by exact_mod_cast ha
-  have h_denom_pos : (0 : ℝ) < (L_pl : ℝ) + 1 := by positivity
-  have hδ_le_ratio : δ ≤ (a : ℝ) / 2 / ((L_pl : ℝ) + 1) := hδ_le
-  let t₀ : Set.Icc t_start (t_start + δ) :=
-    ⟨t_start, Set.mem_Icc.mpr ⟨le_refl _, by linarith⟩⟩
-  have hpl : IsPicardLindelof (vlasovVectorField gradW ρ) t₀ w a r_pl L_pl K_pl := by
-    refine ⟨?_, ?_, ?_, ?_⟩
-    · intro t _
-      exact (vlasovVectorField_lipschitzWith gradW L hL ρ h_int t).lipschitzOnWith
-    · intro x _
-      apply Continuous.continuousOn
-      simp only [vlasovVectorField]
-      exact Continuous.prodMk continuous_const (hρ_cont x.1).neg
-    · intro t ht x hx
-      have h_norm_field := vlasovVectorField_norm_le gradW ρ t x
-      have hdist_le : dist x w ≤ (a : ℝ) := hx
-      have hdist_le_norm : ‖x - w‖ ≤ (a : ℝ) := by rwa [dist_eq_norm] at hdist_le
-      have h_x2_proj : ‖x.2 - w.2‖ ≤ ‖x - w‖ := by
-        rw [Prod.norm_def]; exact le_max_right _ _
-      have h_x2_bound : ‖x.2‖ ≤ ‖w.2‖ + (a : ℝ) := by
-        have h1 : ‖x.2‖ = ‖(x.2 - w.2) + w.2‖ := by rw [sub_add_cancel]
-        have h2 : ‖(x.2 - w.2) + w.2‖ ≤ ‖x.2 - w.2‖ + ‖w.2‖ := norm_add_le _ _
-        linarith [h_x2_proj, hdist_le_norm]
-      have h_x1_proj : dist x.1 w.1 ≤ dist x w := by
-        simp only [Prod.dist_eq]; exact le_max_left _ _
-      have h_x1_ball : x.1 ∈ Metric.closedBall w.1 (3 * (a : ℝ) / 2) := by
-        rw [Metric.mem_closedBall]
-        have hx1d : dist x.1 w.1 ≤ (a : ℝ) := le_trans h_x1_proj hdist_le
-        have ha_nn : (0 : ℝ) ≤ (a : ℝ) := le_of_lt ha_real
-        linarith
-      have h_force_bound : ‖convolveFunctionMeasure gradW (ρ t) x.1‖ ≤ (M : ℝ) :=
-        hbound t ht x.1 h_x1_ball
-      have h_Lpl_eq : (L_pl : ℝ) = (V_max : ℝ) + (a : ℝ) + (M : ℝ) := by
-        simp [hL_pl_def, NNReal.coe_add]
-      have h_x2_bound' : ‖x.2‖ ≤ (V_max : ℝ) + (a : ℝ) :=
-        le_trans h_x2_bound (by linarith [hV])
-      calc ‖vlasovVectorField gradW ρ t x‖
-          ≤ max ‖x.2‖ ‖convolveFunctionMeasure gradW (ρ t) x.1‖ := h_norm_field
-        _ ≤ (L_pl : ℝ) := by
-            rw [h_Lpl_eq]
-            apply max_le
-            · linarith [NNReal.coe_nonneg M, h_x2_bound']
-            · linarith [norm_nonneg w.2, NNReal.coe_nonneg a, NNReal.coe_nonneg V_max]
-    · show (L_pl : ℝ) * max ((t_start + δ) - (t₀ : ℝ)) ((t₀ : ℝ) - t_start)
-          ≤ (a : ℝ) - (r_pl : ℝ)
-      have ht₀_eq : (t₀ : ℝ) = t_start := rfl
-      simp only [ht₀_eq, add_sub_cancel_left, sub_self, max_eq_left (le_of_lt hδ_pos)]
-      have h_a_minus_r : (a : ℝ) - (r_pl : ℝ) = (a : ℝ) / 2 := by
-        simp [hr_pl_def, NNReal.coe_div]; ring
-      rw [h_a_minus_r]
-      have h_Lpl_nn : (0 : ℝ) ≤ (L_pl : ℝ) := L_pl.coe_nonneg
-      have h_a_nn : (0 : ℝ) ≤ (a : ℝ) / 2 := by linarith [ha_real]
-      have h_step : (L_pl : ℝ) * δ ≤ (L_pl : ℝ) *
-          ((a : ℝ) / 2 / ((L_pl : ℝ) + 1)) :=
-        mul_le_mul_of_nonneg_left hδ_le_ratio h_Lpl_nn
-      have h_rewrite : (L_pl : ℝ) * ((a : ℝ) / 2 / ((L_pl : ℝ) + 1))
-          = (L_pl : ℝ) / ((L_pl : ℝ) + 1) * ((a : ℝ) / 2) := by ring
-      have h_frac_le : (L_pl : ℝ) / ((L_pl : ℝ) + 1) ≤ 1 := by
-        rw [div_le_one h_denom_pos]; linarith
-      have h_bound : (L_pl : ℝ) / ((L_pl : ℝ) + 1) * ((a : ℝ) / 2) ≤ (a : ℝ) / 2 := by
-        calc (L_pl : ℝ) / ((L_pl : ℝ) + 1) * ((a : ℝ) / 2)
-            ≤ 1 * ((a : ℝ) / 2) :=
-              mul_le_mul_of_nonneg_right h_frac_le h_a_nn
-          _ = (a : ℝ) / 2 := one_mul _
-      linarith [h_step, h_rewrite ▸ h_step, h_bound]
-  obtain ⟨α, hα⟩ := hpl.exists_forall_mem_closedBall_eq_forall_mem_Icc_hasDerivWithinAt_confined
-  have hw_in_r : w ∈ Metric.closedBall w ((r_pl : ℝ)) := by
-    rw [Metric.mem_closedBall, dist_self]
-    exact r_pl.coe_nonneg
-  have hα_w := hα w hw_in_r
-  refine ⟨fun t => α w t, ?_, ?_, ?_, ?_⟩
-  · have h_init : α w (t₀ : ℝ) = w := hα_w.1
-    have ht₀_eq : (t₀ : ℝ) = t_start := rfl
-    rw [ht₀_eq] at h_init
-    exact h_init
-  · intro t ht
-    have h_t_Icc : t ∈ Set.Icc t_start (t_start + δ) :=
-      ⟨le_of_lt ht.1, le_of_lt ht.2⟩
-    have h_dw := hα_w.2.1 t h_t_Icc
-    have h_icc_nhds : Set.Icc t_start (t_start + δ) ∈ nhds t := Icc_mem_nhds ht.1 ht.2
-    have h_d : HasDerivAt (α w) (vlasovVectorField gradW ρ t (α w t)) t :=
-      h_dw.hasDerivAt h_icc_nhds
-    refine ⟨?_, ?_⟩
-    · have h_proj : HasDerivAt (fun s => (α w s).1)
-          (vlasovVectorField gradW ρ t (α w t)).1 t :=
-        (hasFDerivAt_fst (E := PhysSpace d) (F := PhysSpace d)).comp_hasDerivAt t h_d
-      simpa [vlasovVectorField] using h_proj
-    · have h_proj : HasDerivAt (fun s => (α w s).2)
-          (vlasovVectorField gradW ρ t (α w t)).2 t :=
-        (hasFDerivAt_snd (E := PhysSpace d) (F := PhysSpace d)).comp_hasDerivAt t h_d
-      simpa [vlasovVectorField] using h_proj
-  · intro t ht
-    have h_dw := hα_w.2.1 t ht
-    refine ⟨?_, ?_⟩
-    · have h_proj : HasDerivWithinAt (fun s => (α w s).1)
-          (vlasovVectorField gradW ρ t (α w t)).1
-          (Set.Icc t_start (t_start + δ)) t :=
-        (hasFDerivAt_fst (E := PhysSpace d) (F := PhysSpace d)).comp_hasDerivWithinAt t h_dw
-      simpa [vlasovVectorField] using h_proj
-    · have h_proj : HasDerivWithinAt (fun s => (α w s).2)
-          (vlasovVectorField gradW ρ t (α w t)).2
-          (Set.Icc t_start (t_start + δ)) t :=
-        (hasFDerivAt_snd (E := PhysSpace d) (F := PhysSpace d)).comp_hasDerivWithinAt t h_dw
-      simpa [vlasovVectorField] using h_proj
-  · intro s hs
-    exact hα_w.2.2 s hs
-
-/-- On the degenerate interval `Icc c c`, every function trivially has every
-within-derivative at `c` (the point is not an accumulation point of the
-singleton).  Serves the `T = 0` branch and the tiling base case of the tight
-flow construction. -/
-private lemma hasDerivWithinAt_Icc_self {E : Type*}
-    [NormedAddCommGroup E] [NormedSpace ℝ E]
-    (f : ℝ → E) (v : E) (c : ℝ) :
-    HasDerivWithinAt f v (Set.Icc c c) c := by
-  have h_notAccPt : ¬ AccPt c (Filter.principal (Set.Icc c c)) := by
-    rw [accPt_iff_clusterPt, Filter.inf_principal]
-    simp [ClusterPt, Set.Icc_self]
-  rw [hasDerivWithinAt_iff_hasFDerivWithinAt]
-  exact HasFDerivWithinAt.of_not_accPt h_notAccPt
-
-/-- Adaptive-window force bound for the tight tiling: on any window
-`[c, c + δ] ⊆ [0, T]` whose entry position `p` satisfies the linear drift
-invariant `‖p - z₀.1‖ ≤ a/2 + V_max·c`, the global `hbound` (radius `R` from
-the tight `hR`) restricts to the moving ball `closedBall p (3a/2)`. -/
-private lemma charFlowTight_window_forceBound
-    {d : ℕ}
-    (gradW : PhysSpace d → PhysSpace d)
-    (ρ : ℝ → Measure (PhysSpace d))
-    (z₀ : PhaseSpace d) (a M V_max R : NNReal) (T : ℝ) (hT : 0 ≤ T)
-    (hV_max_def : V_max = ‖z₀.2‖₊ + a / 2 + M * Real.toNNReal T)
-    (hR : 2 * (a : ℝ) + (‖z₀.2‖ + (a : ℝ) / 2) * T + (M : ℝ) * T ^ 2 ≤ R)
-    (hbound : ∀ t ∈ Set.Icc (0 : ℝ) T,
-              ∀ x ∈ Metric.closedBall z₀.1 (R : ℝ),
-              ‖convolveFunctionMeasure gradW (ρ t) x‖ ≤ M)
-    (c δ : ℝ) (hc_nn : 0 ≤ c) (hc_le_T : c ≤ T) (hcδ_le_T : c + δ ≤ T)
-    (p : PhysSpace d)
-    (hp : ‖p - z₀.1‖ ≤ (a : ℝ) / 2 + (V_max : ℝ) * c) :
-    ∀ t ∈ Set.Icc c (c + δ), ∀ x ∈ Metric.closedBall p (3 * (a : ℝ) / 2),
-      ‖convolveFunctionMeasure gradW (ρ t) x‖ ≤ M := by
-  intro t ht x hx
-  have h_t_in_global : t ∈ Set.Icc (0 : ℝ) T :=
-    ⟨le_trans hc_nn ht.1, le_trans ht.2 hcδ_le_T⟩
-  have h_x_local : dist x p ≤ 3 * (a : ℝ) / 2 := hx
-  have h_pos_chain : dist x z₀.1
-      ≤ 3 * (a : ℝ) / 2 + ((a : ℝ) / 2 + (V_max : ℝ) * c) := by
-    calc dist x z₀.1
-        ≤ dist x p + dist p z₀.1 := dist_triangle _ _ _
-      _ ≤ 3 * (a : ℝ) / 2 + _ := by
-          rw [dist_eq_norm]
-          exact add_le_add h_x_local hp
-  have h_V_max_coe : (V_max : ℝ) = ‖z₀.2‖ + (a : ℝ) / 2 + (M : ℝ) * T := by
-    have h_V_def : (V_max : ℝ) = ‖z₀.2‖ + (a : ℝ) / 2 + (M : ℝ) * (T.toNNReal : ℝ) := by
-      simp [hV_max_def, NNReal.coe_add, coe_nnnorm, NNReal.coe_mul, NNReal.coe_div]
-    rw [h_V_def, Real.coe_toNNReal _ hT]
-  have h_V_max_nn : (0 : ℝ) ≤ (V_max : ℝ) := V_max.coe_nonneg
-  have h_R_expand : 2 * (a : ℝ) + (V_max : ℝ) * T ≤ R := by
-    have h_ring : 2 * (a : ℝ) + (‖z₀.2‖ + (a : ℝ) / 2 + (M : ℝ) * T) * T
-        = 2 * (a : ℝ) + (‖z₀.2‖ + (a : ℝ) / 2) * T + (M : ℝ) * T ^ 2 := by ring
-    rw [h_V_max_coe, h_ring]; exact hR
-  have h_x_in_R : dist x z₀.1 ≤ (R : ℝ) := by
-    have h_pos_worst : (V_max : ℝ) * c ≤ (V_max : ℝ) * T :=
-      mul_le_mul_of_nonneg_left hc_le_T h_V_max_nn
-    linarith [h_pos_chain]
-  exact hbound t h_t_in_global x h_x_in_R
-
-/-- Mean-value velocity carry along one window: if `β` solves the velocity ODE
-on `[c, b]` with force bounded by `Mr`, then `‖(β s).2‖` grows at most linearly
-from its entry value.  Shared by the velocity- and position-invariant steps of
-`charFlowTight_window_step`. -/
-private lemma charFlowTight_window_velocity_carry
-    {d : ℕ}
-    (gradW : PhysSpace d → PhysSpace d)
-    (ρ : ℝ → Measure (PhysSpace d))
-    (β : ℝ → PhaseSpace d) (c b : ℝ) (hcb : c ≤ b) (Mr : ℝ)
-    (h_vel : ∀ s ∈ Set.Icc c b,
-      HasDerivWithinAt (fun u => (β u).2)
-        (-(convolveFunctionMeasure gradW (ρ s) (β s).1)) (Set.Icc c b) s)
-    (h_force : ∀ s ∈ Set.Icc c b,
-      ‖convolveFunctionMeasure gradW (ρ s) (β s).1‖ ≤ Mr) :
-    ∀ s ∈ Set.Icc c b, ‖(β s).2‖ ≤ ‖(β c).2‖ + Mr * (s - c) := by
-  intro s hs
-  have h_convex : Convex ℝ (Set.Icc c b) := convex_Icc _ _
-  have h_c_in : c ∈ Set.Icc c b := ⟨le_refl _, hcb⟩
-  have h_force_neg : ∀ u ∈ Set.Icc c b,
-      ‖-(convolveFunctionMeasure gradW (ρ u) (β u).1)‖ ≤ Mr := by
-    intro u hu; rw [norm_neg]; exact h_force u hu
-  have h_mv : ‖(β s).2 - (β c).2‖ ≤ Mr * ‖s - c‖ :=
-    h_convex.norm_image_sub_le_of_norm_hasDerivWithin_le h_vel h_force_neg h_c_in hs
-  have h_diff_nn : 0 ≤ s - c := by linarith [hs.1]
-  rw [Real.norm_of_nonneg h_diff_nn] at h_mv
-  have h_triangle : ‖(β s).2‖ ≤ ‖(β s).2 - (β c).2‖ + ‖(β c).2‖ := by
-    have h_decomp : (β s).2 = ((β s).2 - (β c).2) + (β c).2 :=
-      (sub_add_cancel _ _).symm
-    calc ‖(β s).2‖ = ‖((β s).2 - (β c).2) + (β c).2‖ := by rw [← h_decomp]
-      _ ≤ _ := norm_add_le _ _
-  linarith
-
-/-- Gluing step for the tight tiling: the `Set.piecewise (Set.Iic c)` splice of
-a left solution on `[0, c]` and a right solution on `[c, b]` (agreeing at the
-join) solves the characteristic ODE system on all of `[0, b]`, via
-`HasDerivWithinAt.union` on `Icc 0 c ∪ Icc c b = Icc 0 b`. -/
-private lemma charFlowTight_piecewise_ode
-    {d : ℕ}
-    (gradW : PhysSpace d → PhysSpace d)
-    (ρ : ℝ → Measure (PhysSpace d))
-    (γL β : ℝ → PhaseSpace d)
-    (c b : ℝ) (hc_nn : 0 ≤ c) (hcb : c ≤ b)
-    (h_join : β c = γL c)
-    (h_ode_L : ∀ t ∈ Set.Icc (0 : ℝ) c,
-      HasDerivWithinAt (fun s => (γL s).1) (γL t).2 (Set.Icc (0 : ℝ) c) t ∧
-      HasDerivWithinAt (fun s => (γL s).2)
-        (-(convolveFunctionMeasure gradW (ρ t) (γL t).1)) (Set.Icc (0 : ℝ) c) t)
-    (h_ode_R : ∀ t ∈ Set.Icc c b,
-      HasDerivWithinAt (fun s => (β s).1) (β t).2 (Set.Icc c b) t ∧
-      HasDerivWithinAt (fun s => (β s).2)
-        (-(convolveFunctionMeasure gradW (ρ t) (β t).1)) (Set.Icc c b) t) :
-    ∀ t ∈ Set.Icc (0 : ℝ) b,
-      HasDerivWithinAt (fun s => (Set.piecewise (Set.Iic c) γL β s).1)
-        (Set.piecewise (Set.Iic c) γL β t).2 (Set.Icc (0 : ℝ) b) t ∧
-      HasDerivWithinAt (fun s => (Set.piecewise (Set.Iic c) γL β s).2)
-        (-(convolveFunctionMeasure gradW (ρ t)
-            (Set.piecewise (Set.Iic c) γL β t).1)) (Set.Icc (0 : ℝ) b) t := by
-  classical
-  intro t ht
-  have h_left : ∀ y ≤ c, Set.piecewise (Set.Iic c) γL β y = γL y := fun y hy =>
-    Set.piecewise_eq_of_mem _ _ _ hy
-  have h_right : ∀ y, c < y → Set.piecewise (Set.Iic c) γL β y = β y := fun y hy =>
-    Set.piecewise_eq_of_notMem _ _ _ (not_le.mpr hy)
-  have h_at_join : Set.piecewise (Set.Iic c) γL β c = γL c := h_left _ (le_refl _)
-  have h_on_right_Icc : ∀ y ∈ Set.Icc c b,
-      Set.piecewise (Set.Iic c) γL β y = β y := by
-    intro y hy
-    rcases eq_or_lt_of_le hy.1 with hy_eq | hy_lt
-    · rw [← hy_eq, h_at_join, h_join]
-    · exact h_right y hy_lt
-  have h_set_union : Set.Icc (0 : ℝ) c ∪ Set.Icc c b = Set.Icc (0 : ℝ) b :=
-    Set.Icc_union_Icc_eq_Icc hc_nn hcb
-  have hA_pos : HasDerivWithinAt (fun s => (Set.piecewise (Set.Iic c) γL β s).1)
-      (Set.piecewise (Set.Iic c) γL β t).2 (Set.Icc (0 : ℝ) c) t := by
-    by_cases ht_left : t ≤ c
-    · have ht_in : t ∈ Set.Icc (0 : ℝ) c := ⟨ht.1, ht_left⟩
-      have h_γL_pos := (h_ode_L t ht_in).1
-      have h_deriv_eq : (Set.piecewise (Set.Iic c) γL β t).2 = (γL t).2 := by
-        rw [h_left t ht_left]
-      rw [h_deriv_eq]
-      refine h_γL_pos.congr (fun y hy => ?_) ?_
-      · rw [h_left y hy.2]
-      · rw [h_left t ht_left]
-    · rw [not_le] at ht_left
-      rw [hasDerivWithinAt_iff_hasFDerivWithinAt]
-      apply HasFDerivWithinAt.of_notMem_closure
-      rw [closure_Icc, Set.mem_Icc]
-      rintro ⟨_, _⟩; linarith
-  have hB_pos : HasDerivWithinAt (fun s => (Set.piecewise (Set.Iic c) γL β s).1)
-      (Set.piecewise (Set.Iic c) γL β t).2 (Set.Icc c b) t := by
-    by_cases ht_right : c ≤ t
-    · have ht_in : t ∈ Set.Icc c b := ⟨ht_right, ht.2⟩
-      have h_β_pos := (h_ode_R t ht_in).1
-      have h_deriv_eq : (Set.piecewise (Set.Iic c) γL β t).2 = (β t).2 := by
-        rw [h_on_right_Icc t ht_in]
-      rw [h_deriv_eq]
-      refine h_β_pos.congr (fun y hy => ?_) ?_
-      · rw [h_on_right_Icc y hy]
-      · rw [h_on_right_Icc t ht_in]
-    · rw [not_le] at ht_right
-      rw [hasDerivWithinAt_iff_hasFDerivWithinAt]
-      apply HasFDerivWithinAt.of_notMem_closure
-      rw [closure_Icc, Set.mem_Icc]
-      rintro ⟨_, _⟩; linarith
-  have hA_vel : HasDerivWithinAt (fun s => (Set.piecewise (Set.Iic c) γL β s).2)
-      (-(convolveFunctionMeasure gradW (ρ t)
-          (Set.piecewise (Set.Iic c) γL β t).1)) (Set.Icc (0 : ℝ) c) t := by
-    by_cases ht_left : t ≤ c
-    · have ht_in : t ∈ Set.Icc (0 : ℝ) c := ⟨ht.1, ht_left⟩
-      have h_γL_vel := (h_ode_L t ht_in).2
-      have h_pos_eq : (Set.piecewise (Set.Iic c) γL β t).1 = (γL t).1 := by
-        rw [h_left t ht_left]
-      rw [h_pos_eq]
-      refine h_γL_vel.congr (fun y hy => ?_) ?_
-      · rw [h_left y hy.2]
-      · rw [h_left t ht_left]
-    · rw [not_le] at ht_left
-      rw [hasDerivWithinAt_iff_hasFDerivWithinAt]
-      apply HasFDerivWithinAt.of_notMem_closure
-      rw [closure_Icc, Set.mem_Icc]
-      rintro ⟨_, _⟩; linarith
-  have hB_vel : HasDerivWithinAt (fun s => (Set.piecewise (Set.Iic c) γL β s).2)
-      (-(convolveFunctionMeasure gradW (ρ t)
-          (Set.piecewise (Set.Iic c) γL β t).1)) (Set.Icc c b) t := by
-    by_cases ht_right : c ≤ t
-    · have ht_in : t ∈ Set.Icc c b := ⟨ht_right, ht.2⟩
-      have h_β_vel := (h_ode_R t ht_in).2
-      have h_pos_eq : (Set.piecewise (Set.Iic c) γL β t).1 = (β t).1 := by
-        rw [h_on_right_Icc t ht_in]
-      rw [h_pos_eq]
-      refine h_β_vel.congr (fun y hy => ?_) ?_
-      · rw [h_on_right_Icc y hy]
-      · rw [h_on_right_Icc t ht_in]
-    · rw [not_le] at ht_right
-      rw [hasDerivWithinAt_iff_hasFDerivWithinAt]
-      apply HasFDerivWithinAt.of_notMem_closure
-      rw [closure_Icc, Set.mem_Icc]
-      rintro ⟨_, _⟩; linarith
-  constructor
-  · have h_union_pos := hA_pos.union hB_pos
-    rw [h_set_union] at h_union_pos
-    exact h_union_pos
-  · have h_union_vel := hA_vel.union hB_vel
-    rw [h_set_union] at h_union_vel
-    exact h_union_vel
-
-/-- One tiling step for the tight flow: extend a trajectory satisfying the
-tight invariants on `[0, c]` to `[0, c + δ']` via
-`exists_vlasov_extend_one_window_tight`, splicing with `Set.piecewise`
-(`charFlowTight_piecewise_ode`) and carrying the linear velocity- and
-position-drift invariants (`charFlowTight_window_velocity_carry` +
-`vlasov_window_position_bound`). -/
-private lemma charFlowTight_window_step
-    {d : ℕ}
-    (gradW : PhysSpace d → PhysSpace d)
-    (L : NNReal) (hL : LipschitzWith L gradW)
-    (ρ : ℝ → Measure (PhysSpace d))
-    [∀ t, IsProbabilityMeasure (ρ t)]
-    (h_int : ∀ t (x : PhysSpace d), Integrable (fun y => gradW (x - y)) (ρ t))
-    (hρ_cont : ∀ x : PhysSpace d,
-      Continuous (fun t => convolveFunctionMeasure gradW (ρ t) x))
-    (z₀ : PhaseSpace d) (a : NNReal) (ha : 0 < a)
-    (M V_max R : NNReal) (T : ℝ) (hT : 0 ≤ T)
-    (hV_max_def : V_max = ‖z₀.2‖₊ + a / 2 + M * Real.toNNReal T)
-    (hR : 2 * (a : ℝ) + (‖z₀.2‖ + (a : ℝ) / 2) * T + (M : ℝ) * T ^ 2 ≤ R)
-    (hbound : ∀ t ∈ Set.Icc (0 : ℝ) T,
-              ∀ x ∈ Metric.closedBall z₀.1 (R : ℝ),
-              ‖convolveFunctionMeasure gradW (ρ t) x‖ ≤ M)
-    (δ' : ℝ) (hδ'_pos : 0 < δ')
-    (hδ'_le_max : δ' ≤ (a : ℝ) / 2 / (((V_max + a + M : NNReal) : ℝ) + 1))
-    (z : PhaseSpace d) (c : ℝ) (hc_nn : 0 ≤ c) (hcδ_le_T : c + δ' ≤ T)
-    (γ_k : ℝ → PhaseSpace d) (h_γ0 : γ_k 0 = z)
-    (h_ode_k : ∀ t ∈ Set.Icc (0 : ℝ) c,
-      HasDerivWithinAt (fun s => (γ_k s).1) (γ_k t).2 (Set.Icc (0 : ℝ) c) t ∧
-      HasDerivWithinAt (fun s => (γ_k s).2)
-        (-(convolveFunctionMeasure gradW (ρ t) (γ_k t).1)) (Set.Icc (0 : ℝ) c) t)
-    (h_vel_k : ‖(γ_k c).2‖ ≤ ‖z₀.2‖ + (a : ℝ) / 2 + (M : ℝ) * c)
-    (h_pos_k : ‖(γ_k c).1 - z₀.1‖ ≤ (a : ℝ) / 2 + (V_max : ℝ) * c) :
-    ∃ γ : ℝ → PhaseSpace d, γ 0 = z ∧
-      (∀ t ∈ Set.Icc (0 : ℝ) (c + δ'),
-        HasDerivWithinAt (fun s => (γ s).1) (γ t).2
-          (Set.Icc (0 : ℝ) (c + δ')) t ∧
-        HasDerivWithinAt (fun s => (γ s).2)
-          (-(convolveFunctionMeasure gradW (ρ t) (γ t).1))
-          (Set.Icc (0 : ℝ) (c + δ')) t) ∧
-      ‖(γ (c + δ')).2‖ ≤ ‖z₀.2‖ + (a : ℝ) / 2 + (M : ℝ) * (c + δ') ∧
-      ‖(γ (c + δ')).1 - z₀.1‖ ≤ (a : ℝ) / 2 + (V_max : ℝ) * (c + δ') := by
-  classical
-  have hc_lt_b : c < c + δ' := by linarith
-  have hc_le_T : c ≤ T := by linarith
-  have hM_nn : (0 : ℝ) ≤ (M : ℝ) := M.coe_nonneg
-  have h_V_max_coe : (V_max : ℝ) = ‖z₀.2‖ + (a : ℝ) / 2 + (M : ℝ) * T := by
-    have h_V_def : (V_max : ℝ) = ‖z₀.2‖ + (a : ℝ) / 2 + (M : ℝ) * (T.toNNReal : ℝ) := by
-      simp [hV_max_def, NNReal.coe_add, coe_nnnorm, NNReal.coe_mul, NNReal.coe_div]
-    rw [h_V_def, Real.coe_toNNReal _ hT]
-  have h_vel_Vmax : ‖(γ_k c).2‖ ≤ (V_max : ℝ) := by
-    rw [h_V_max_coe]
-    calc ‖(γ_k c).2‖
-        ≤ ‖z₀.2‖ + (a : ℝ) / 2 + (M : ℝ) * c := h_vel_k
-      _ ≤ ‖z₀.2‖ + (a : ℝ) / 2 + (M : ℝ) * T := by
-          linarith [mul_le_mul_of_nonneg_left hc_le_T hM_nn]
-  have hbound_local := charFlowTight_window_forceBound gradW ρ z₀ a M V_max R T hT
-    hV_max_def hR hbound c δ' hc_nn hc_le_T hcδ_le_T (γ_k c).1 h_pos_k
-  obtain ⟨β, hβ_init, _hβ_ode_Ioo, hβ_ode_Icc, hβ_confined⟩ :=
-    exists_vlasov_extend_one_window_tight gradW L hL ρ h_int hρ_cont
-      (γ_k c) a ha M V_max h_vel_Vmax c δ' hδ'_pos hδ'_le_max hbound_local
-  have h_β_in_ball : ∀ s ∈ Set.Icc c (c + δ'),
-      (β s).1 ∈ Metric.closedBall (γ_k c).1 (3 * (a : ℝ) / 2) := by
-    intro s hs
-    have h_phase : β s ∈ Metric.closedBall (γ_k c) (a : ℝ) := hβ_confined s hs
-    rw [Metric.mem_closedBall] at h_phase ⊢
-    have h_proj : dist (β s).1 (γ_k c).1 ≤ dist (β s) (γ_k c) := by
-      rw [Prod.dist_eq]; exact le_max_left _ _
-    have h_a_nn : (0 : ℝ) ≤ (a : ℝ) := a.coe_nonneg
-    linarith
-  have h_force_window : ∀ s ∈ Set.Icc c (c + δ'),
-      ‖convolveFunctionMeasure gradW (ρ s) (β s).1‖ ≤ (M : ℝ) := fun s hs =>
-    hbound_local s hs (β s).1 (h_β_in_ball s hs)
-  have h_vel_carry := charFlowTight_window_velocity_carry gradW ρ β c (c + δ')
-    (le_of_lt hc_lt_b) (M : ℝ) (fun s hs => (hβ_ode_Icc s hs).2) h_force_window
-  have h_β_c_vel : (β c).2 = (γ_k c).2 := by rw [hβ_init]
-  have h_ode_pw := charFlowTight_piecewise_ode gradW ρ γ_k β c (c + δ') hc_nn
-    (le_of_lt hc_lt_b) hβ_init h_ode_k hβ_ode_Icc
-  have h_right_end : Set.piecewise (Set.Iic c) γ_k β (c + δ') = β (c + δ') :=
-    Set.piecewise_eq_of_notMem _ _ _ (not_le.mpr hc_lt_b)
-  have h_left0 : Set.piecewise (Set.Iic c) γ_k β 0 = γ_k 0 :=
-    Set.piecewise_eq_of_mem _ _ _ hc_nn
-  refine ⟨Set.piecewise (Set.Iic c) γ_k β, by rw [h_left0, h_γ0], h_ode_pw, ?_, ?_⟩
-  · -- Velocity invariant at the new endpoint, via the mean-value carry.
-    rw [h_right_end]
-    have h_carry_b := h_vel_carry (c + δ') ⟨le_of_lt hc_lt_b, le_refl _⟩
-    rw [h_β_c_vel] at h_carry_b
-    have h_ring : (M : ℝ) * (c + δ' - c) = (M : ℝ) * δ' := by ring
-    rw [h_ring] at h_carry_b
-    calc ‖(β (c + δ')).2‖
-        ≤ ‖(γ_k c).2‖ + (M : ℝ) * δ' := h_carry_b
-      _ ≤ ‖z₀.2‖ + (a : ℝ) / 2 + (M : ℝ) * c + (M : ℝ) * δ' := by linarith [h_vel_k]
-      _ = ‖z₀.2‖ + (a : ℝ) / 2 + (M : ℝ) * (c + δ') := by ring
-  · -- Position invariant at the new endpoint, via the window position bound.
-    rw [h_right_end]
-    have h_window_vel_Vmax : ∀ s ∈ Set.Icc c (c + δ'),
-        ‖(β s).2‖ ≤ (V_max : ℝ) := by
-      intro s hs
-      have h_carry_s := h_vel_carry s hs
-      rw [h_β_c_vel] at h_carry_s
-      have h_s_le_T : s ≤ T := le_trans hs.2 hcδ_le_T
-      have h_M_split : (M : ℝ) * (s - c) + (M : ℝ) * c = (M : ℝ) * s := by ring
-      have h_M_mono : (M : ℝ) * s ≤ (M : ℝ) * T :=
-        mul_le_mul_of_nonneg_left h_s_le_T hM_nn
-      rw [h_V_max_coe]
-      linarith [h_carry_s, h_vel_k]
-    have h_pos_carry :=
-      vlasov_window_position_bound gradW ρ (γ_k c) c δ' hδ'_pos
-        (V_max : ℝ) z₀.1 ((a : ℝ) / 2 + (V_max : ℝ) * c) h_pos_k β hβ_init
-        (fun t ht => (hβ_ode_Icc t ht).1) h_window_vel_Vmax
-    calc ‖(β (c + δ')).1 - z₀.1‖
-        ≤ (a : ℝ) / 2 + (V_max : ℝ) * c + (V_max : ℝ) * δ' := h_pos_carry
-      _ = (a : ℝ) / 2 + (V_max : ℝ) * (c + δ') := by ring
-
-/-- Per-`z` trajectory for the tight flow: `N`-fold exact tiling of
-`[0, N·δ']` by windows of width `δ'`, by induction via
-`charFlowTight_window_step`, carrying the tight velocity/position invariants
-through the induction and discarding them at the end. -/
-private lemma charFlowTight_perZ_trajectory
-    {d : ℕ}
-    (gradW : PhysSpace d → PhysSpace d)
-    (L : NNReal) (hL : LipschitzWith L gradW)
-    (ρ : ℝ → Measure (PhysSpace d))
-    [∀ t, IsProbabilityMeasure (ρ t)]
-    (h_int : ∀ t (x : PhysSpace d), Integrable (fun y => gradW (x - y)) (ρ t))
-    (hρ_cont : ∀ x : PhysSpace d,
-      Continuous (fun t => convolveFunctionMeasure gradW (ρ t) x))
-    (z₀ : PhaseSpace d) (a : NNReal) (ha : 0 < a)
-    (M V_max R : NNReal) (T : ℝ) (hT : 0 ≤ T)
-    (hV_max_def : V_max = ‖z₀.2‖₊ + a / 2 + M * Real.toNNReal T)
-    (hR : 2 * (a : ℝ) + (‖z₀.2‖ + (a : ℝ) / 2) * T + (M : ℝ) * T ^ 2 ≤ R)
-    (hbound : ∀ t ∈ Set.Icc (0 : ℝ) T,
-              ∀ x ∈ Metric.closedBall z₀.1 (R : ℝ),
-              ‖convolveFunctionMeasure gradW (ρ t) x‖ ≤ M)
-    (N : ℕ) (δ' : ℝ) (hδ'_pos : 0 < δ')
-    (hδ'_le_max : δ' ≤ (a : ℝ) / 2 / (((V_max + a + M : NNReal) : ℝ) + 1))
-    (hNδ'_le_T : (N : ℝ) * δ' ≤ T)
-    (z : PhaseSpace d) (hz : z ∈ Metric.closedBall z₀ ((a : ℝ) / 2)) :
-    ∃ γ : ℝ → PhaseSpace d,
-      γ 0 = z ∧
-      ∀ t ∈ Set.Icc (0 : ℝ) ((N : ℝ) * δ'),
-        HasDerivWithinAt (fun s => (γ s).1) (γ t).2
-          (Set.Icc (0 : ℝ) ((N : ℝ) * δ')) t ∧
-        HasDerivWithinAt (fun s => (γ s).2)
-          (-(convolveFunctionMeasure gradW (ρ t) (γ t).1))
-          (Set.Icc (0 : ℝ) ((N : ℝ) * δ')) t := by
-  suffices h_strong : ∀ k : ℕ, k ≤ N → ∃ γ : ℝ → PhaseSpace d,
-      γ 0 = z ∧
-      (∀ t ∈ Set.Icc (0 : ℝ) ((k : ℝ) * δ'),
-        HasDerivWithinAt (fun s => (γ s).1) (γ t).2
-          (Set.Icc (0 : ℝ) ((k : ℝ) * δ')) t ∧
-        HasDerivWithinAt (fun s => (γ s).2)
-          (-(convolveFunctionMeasure gradW (ρ t) (γ t).1))
-          (Set.Icc (0 : ℝ) ((k : ℝ) * δ')) t) ∧
-      ‖(γ ((k : ℝ) * δ')).2‖ ≤
-        ‖z₀.2‖ + (a : ℝ) / 2 + (M : ℝ) * ((k : ℝ) * δ') ∧
-      ‖(γ ((k : ℝ) * δ')).1 - z₀.1‖ ≤
-        (a : ℝ) / 2 + (V_max : ℝ) * ((k : ℝ) * δ') by
-    obtain ⟨γ, hγ0, hode, _, _⟩ := h_strong N (le_refl N)
-    exact ⟨γ, hγ0, hode⟩
-  intro k
-  induction k with
-  | zero =>
-    intro _
-    refine ⟨fun _ => z, rfl, ?_, ?_, ?_⟩
-    · intro t ht
-      have ht_eq : t = 0 := le_antisymm (by simpa using ht.2) ht.1
-      subst ht_eq
-      have h_set_eq : Set.Icc (0 : ℝ) (((0 : ℕ) : ℝ) * δ') = Set.Icc (0 : ℝ) 0 := by
-        norm_num
-      rw [h_set_eq]
-      exact ⟨hasDerivWithinAt_Icc_self _ _ _, hasDerivWithinAt_Icc_self _ _ _⟩
-    · have hdist : ‖z - z₀‖ ≤ (a : ℝ) / 2 := by
-        rw [← dist_eq_norm]; exact hz
-      have h_z2_proj : ‖z.2 - z₀.2‖ ≤ ‖z - z₀‖ := by
-        rw [Prod.norm_def]; exact le_max_right _ _
-      have h_z2_bound : ‖z.2‖ ≤ ‖z₀.2‖ + (a : ℝ) / 2 := by
-        have h1 : ‖z.2‖ = ‖(z.2 - z₀.2) + z₀.2‖ := by rw [sub_add_cancel]
-        have h2 : ‖(z.2 - z₀.2) + z₀.2‖ ≤ ‖z.2 - z₀.2‖ + ‖z₀.2‖ := norm_add_le _ _
-        linarith [h_z2_proj, hdist]
-      change ‖((fun _ => z) (((0 : ℕ) : ℝ) * δ')).2‖ ≤
-        ‖z₀.2‖ + (a : ℝ) / 2 + (M : ℝ) * (((0 : ℕ) : ℝ) * δ')
-      simp only [Nat.cast_zero, zero_mul, mul_zero, add_zero]
-      linarith
-    · have hdist : ‖z - z₀‖ ≤ (a : ℝ) / 2 := by
-        rw [← dist_eq_norm]; exact hz
-      have h_z1_proj : ‖z.1 - z₀.1‖ ≤ ‖z - z₀‖ := by
-        rw [Prod.norm_def]; exact le_max_left _ _
-      change ‖((fun _ => z) (((0 : ℕ) : ℝ) * δ')).1 - z₀.1‖ ≤
-        (a : ℝ) / 2 + (V_max : ℝ) * (((0 : ℕ) : ℝ) * δ')
-      simp only [Nat.cast_zero, zero_mul, mul_zero, add_zero]
-      linarith
-  | succ k ih =>
-    intro hk_succ_le_N
-    obtain ⟨γ_k, h_γ0, h_ode_k, h_vel_k, h_pos_k⟩ :=
-      ih (Nat.le_of_succ_le hk_succ_le_N)
-    have h_kδ_nn : (0 : ℝ) ≤ (k : ℝ) * δ' := by positivity
-    have h_kδ_succ_eq : (k : ℝ) * δ' + δ' = ((k + 1 : ℕ) : ℝ) * δ' := by
-      push_cast; ring
-    have h_succ_kδ_le_T : ((k + 1 : ℕ) : ℝ) * δ' ≤ T := by
-      calc ((k + 1 : ℕ) : ℝ) * δ'
-          ≤ (N : ℝ) * δ' := by
-            have h_cast : ((k + 1 : ℕ) : ℝ) ≤ (N : ℝ) := by
-              exact_mod_cast hk_succ_le_N
-            exact mul_le_mul_of_nonneg_right h_cast (le_of_lt hδ'_pos)
-        _ ≤ T := hNδ'_le_T
-    obtain ⟨γ, hγ0, h_ode, h_vel, h_pos⟩ :=
-      charFlowTight_window_step gradW L hL ρ h_int hρ_cont z₀ a ha M V_max R T hT
-        hV_max_def hR hbound δ' hδ'_pos hδ'_le_max z ((k : ℝ) * δ') h_kδ_nn
-        (by rw [h_kδ_succ_eq]; exact h_succ_kδ_le_T) γ_k h_γ0 h_ode_k h_vel_k h_pos_k
-    rw [← h_kδ_succ_eq]
-    exact ⟨γ, hγ0, h_ode, h_vel, h_pos⟩
-
-/-- **Tight global per-ball flow: `[0,T]` force-window, `T²` smallness (no `+1`).**
-
-Tight form of `exists_vlasov_characteristicFlow`.  By tiling `[0,T]`
-EXACTLY (`N = ⌈T/δ_max⌉` windows of width `δ' = T/N ≤ δ_max`, so `N·δ' = T`) and
-calling `exists_vlasov_extend_one_window_tight` with the adaptive force-window
-`[k·δ', (k+1)·δ']`, the global force-bound is required only on `[0,T]` and the
-position drift is `M·T²` (not `M·(T+1)²`).  Consumers' R-selection then needs only
-`L·T² < 1`, satisfiable for any `L` (threshold `T < 1/√L`), dissolving the `L<1`
-restriction. -/
-theorem exists_vlasov_characteristicFlow_tight
-    {d : ℕ}
-    (W : PhysSpace d → ℝ)
-    (gradW : PhysSpace d → PhysSpace d)
-    (_hgradW : ∀ x, gradW x = gradient W x)
-    (L : NNReal) (hL : LipschitzWith L gradW)
-    (ρ : ℝ → Measure (PhysSpace d))
-    [∀ t, IsProbabilityMeasure (ρ t)]
-    (h_int : ∀ t (x : PhysSpace d), Integrable (fun y => gradW (x - y)) (ρ t))
-    (hρ_cont : ∀ x : PhysSpace d,
-      Continuous (fun t => convolveFunctionMeasure gradW (ρ t) x))
-    (z₀ : PhaseSpace d) (a : NNReal) (ha : 0 < a)
-    (M : NNReal) (T : ℝ) (hT : 0 ≤ T)
-    (R : NNReal)
-    (hR : 2 * (a : ℝ) + (‖z₀.2‖ + (a : ℝ) / 2) * T + (M : ℝ) * T ^ 2 ≤ R)
-    (hbound : ∀ t ∈ Set.Icc (0 : ℝ) T,
-              ∀ x ∈ Metric.closedBall z₀.1 (R : ℝ),
-              ‖convolveFunctionMeasure gradW (ρ t) x‖ ≤ M) :
-    ∃ (charX charV : ℝ → PhaseSpace d → PhysSpace d),
-      IsCharacteristicFlowOn gradW ρ charX charV
-        (Set.Ioo 0 T) (Metric.closedBall z₀ ((a : ℝ) / 2)) ∧
-      (∀ z ∈ Metric.closedBall z₀ ((a : ℝ) / 2),
-        ∀ t ∈ Set.Icc (0 : ℝ) T,
-          HasDerivWithinAt (fun s => charX s z) (charV t z)
-            (Set.Icc (0 : ℝ) T) t ∧
-          HasDerivWithinAt (fun s => charV s z)
-            (-(convolveFunctionMeasure gradW (ρ t) (charX t z)))
-            (Set.Icc (0 : ℝ) T) t) := by
-  classical
-  -- ============================================================
-  -- Parameter setup (uniform across all windows and initial z).
-  -- TIGHT: V_max uses `T` (not `T+1`); EXACT tiling N·δ' = T.
-  -- ============================================================
-  set V_max : NNReal :=
-    ‖z₀.2‖₊ + a / 2 + M * Real.toNNReal T with hV_max_def
-  have ha_real : (0 : ℝ) < (a : ℝ) := by exact_mod_cast ha
-  have h_denom_pos : (0 : ℝ) < (((V_max + a + M : NNReal) : ℝ) + 1) := by positivity
-  set δ_max : ℝ := (a : ℝ) / 2 / (((V_max + a + M : NNReal) : ℝ) + 1) with hδ_max_def
-  have hδ_max_pos : (0 : ℝ) < δ_max := by rw [hδ_max_def]; positivity
-  -- T = 0 edge case: the conclusion's intervals collapse.
-  rcases eq_or_lt_of_le hT with hT_eq | hT_pos
-  · -- T = 0: Ioo 0 0 = ∅, Icc 0 0 = {0}.  Build the trivial flow γ_func z s = z.
-    subst hT_eq
-    -- charX/charV constant in time, equal to z (resp. its components).
-    refine ⟨fun _ z => z.1, fun _ z => z.2, ⟨?_, ?_, ?_⟩, ?_⟩
-    · intro z hz; exact ⟨rfl, rfl⟩
-    · intro t ht z hz; exact absurd (lt_trans ht.1 ht.2) (lt_irrefl 0)
-    · intro t ht z hz; exact absurd (lt_trans ht.1 ht.2) (lt_irrefl 0)
-    · intro z hz t ht
-      have ht_eq : t = 0 := le_antisymm ht.2 ht.1
-      subst ht_eq
-      exact ⟨hasDerivWithinAt_Icc_self _ _ _, hasDerivWithinAt_Icc_self _ _ _⟩
-  · -- T > 0: EXACT tiling.
-    -- N := ⌈T/δ_max⌉₊ windows of width δ' = T/N ≤ δ_max, so N·δ' = T.
-    set N : ℕ := ⌈T / δ_max⌉₊ with hN_def
-    have hN_pos : 0 < N := by
-      rw [hN_def, Nat.ceil_pos]
-      positivity
-    have hN_real_pos : (0 : ℝ) < (N : ℝ) := by exact_mod_cast hN_pos
-    set δ' : ℝ := T / (N : ℝ) with hδ'_def
-    have hδ'_pos : (0 : ℝ) < δ' := by rw [hδ'_def]; positivity
-    have hNδ'_eq : (N : ℝ) * δ' = T := by
-      rw [hδ'_def]; field_simp
-    -- δ' ≤ δ_max because N ≥ T/δ_max.
-    have hδ'_le_max : δ' ≤ δ_max := by
-      have h_ceil : T / δ_max ≤ (N : ℝ) := Nat.le_ceil _
-      rw [hδ'_def, div_le_iff₀ hN_real_pos]
-      calc T = (T / δ_max) * δ_max := by field_simp
-        _ ≤ (N : ℝ) * δ_max :=
-            mul_le_mul_of_nonneg_right h_ceil (le_of_lt hδ_max_pos)
-        _ = δ_max * (N : ℝ) := by ring
-    -- ============================================================
-    -- Per-z induction: a curve solving the ODE on [0, N·δ'] = [0, T].
-    -- ============================================================
-    have h_perZ : ∀ z ∈ Metric.closedBall z₀ ((a : ℝ) / 2),
-        ∃ γ : ℝ → PhaseSpace d,
-          γ 0 = z ∧
-          ∀ t ∈ Set.Icc (0 : ℝ) ((N : ℝ) * δ'),
-            HasDerivWithinAt (fun s => (γ s).1) (γ t).2
-              (Set.Icc (0 : ℝ) ((N : ℝ) * δ')) t ∧
-            HasDerivWithinAt (fun s => (γ s).2)
-              (-(convolveFunctionMeasure gradW (ρ t) (γ t).1))
-              (Set.Icc (0 : ℝ) ((N : ℝ) * δ')) t :=
-      fun z hz =>
-        charFlowTight_perZ_trajectory gradW L hL ρ h_int hρ_cont z₀ a ha M V_max R
-          T hT hV_max_def hR hbound N δ' hδ'_pos
-          (by rw [← hδ_max_def]; exact hδ'_le_max) (le_of_eq hNδ'_eq) z hz
-    -- ============================================================
-    -- Bundle per-z curves into a joint flow via Classical.choose.
-    -- ============================================================
-    let γ_func : PhaseSpace d → ℝ → PhaseSpace d := fun z =>
-      if hz : z ∈ Metric.closedBall z₀ ((a : ℝ) / 2)
-      then Classical.choose (h_perZ z hz)
-      else (fun _ => z)
-    have h_Icc_T_sub : Set.Icc (0 : ℝ) T ⊆ Set.Icc (0 : ℝ) ((N : ℝ) * δ') :=
-      fun t ht => ⟨ht.1, le_trans ht.2 (le_of_eq hNδ'_eq.symm)⟩
-    have h_dw_on_big :
-        ∀ z ∈ Metric.closedBall z₀ ((a : ℝ) / 2),
-          ∀ t ∈ Set.Icc (0 : ℝ) ((N : ℝ) * δ'),
-            HasDerivWithinAt (fun s => (γ_func z s).1) (γ_func z t).2
-              (Set.Icc (0 : ℝ) ((N : ℝ) * δ')) t ∧
-            HasDerivWithinAt (fun s => (γ_func z s).2)
-              (-(convolveFunctionMeasure gradW (ρ t) (γ_func z t).1))
-              (Set.Icc (0 : ℝ) ((N : ℝ) * δ')) t := by
-      intro z hz t ht
-      have h_func_eq : γ_func z = Classical.choose (h_perZ z hz) := by
-        simp only [γ_func, dite_eq_left hz]
-      have h_ode := (Classical.choose_spec (h_perZ z hz)).2
-      have h_pos_dw := (h_ode t ht).1
-      have h_vel_dw := (h_ode t ht).2
-      have h_eq_fun_pos : (fun s => (γ_func z s).1)
-          = (fun s => ((Classical.choose (h_perZ z hz)) s).1) := by
-        funext s; rw [h_func_eq]
-      have h_eq_fun_vel : (fun s => (γ_func z s).2)
-          = (fun s => ((Classical.choose (h_perZ z hz)) s).2) := by
-        funext s; rw [h_func_eq]
-      have h_eq_pt_vel : (γ_func z t).2 = (Classical.choose (h_perZ z hz) t).2 := by
-        rw [h_func_eq]
-      have h_eq_pt_pos : (γ_func z t).1 = (Classical.choose (h_perZ z hz) t).1 := by
-        rw [h_func_eq]
-      refine ⟨?_, ?_⟩
-      · rw [h_eq_fun_pos, h_eq_pt_vel]; exact h_pos_dw
-      · rw [h_eq_fun_vel, h_eq_pt_pos]; exact h_vel_dw
-    refine ⟨fun t z => (γ_func z t).1, fun t z => (γ_func z t).2,
-           ⟨?_, ?_, ?_⟩, ?_⟩
-    · intro z hz
-      have h_init : Classical.choose (h_perZ z hz) 0 = z :=
-        (Classical.choose_spec (h_perZ z hz)).1
-      have h_func_eq : γ_func z = Classical.choose (h_perZ z hz) := by
-        simp only [γ_func, dite_eq_left hz]
-      refine ⟨?_, ?_⟩
-      · change (γ_func z 0).1 = z.1
-        rw [h_func_eq, h_init]
-      · change (γ_func z 0).2 = z.2
-        rw [h_func_eq, h_init]
-    · intro t ht z hz
-      have h_t_in : t ∈ Set.Icc (0 : ℝ) ((N : ℝ) * δ') := by
-        refine ⟨le_of_lt ht.1, le_trans (le_of_lt ht.2) (le_of_eq hNδ'_eq.symm)⟩
-      have hT_lt_N : t < (N : ℝ) * δ' := lt_of_lt_of_le ht.2 (le_of_eq hNδ'_eq.symm)
-      have h_icc_nhds : Set.Icc (0 : ℝ) ((N : ℝ) * δ') ∈ nhds t :=
-        Icc_mem_nhds ht.1 hT_lt_N
-      exact ((h_dw_on_big z hz t h_t_in).1).hasDerivAt h_icc_nhds
-    · intro t ht z hz
-      have h_t_in : t ∈ Set.Icc (0 : ℝ) ((N : ℝ) * δ') := by
-        refine ⟨le_of_lt ht.1, le_trans (le_of_lt ht.2) (le_of_eq hNδ'_eq.symm)⟩
-      have hT_lt_N : t < (N : ℝ) * δ' := lt_of_lt_of_le ht.2 (le_of_eq hNδ'_eq.symm)
-      have h_icc_nhds : Set.Icc (0 : ℝ) ((N : ℝ) * δ') ∈ nhds t :=
-        Icc_mem_nhds ht.1 hT_lt_N
-      exact ((h_dw_on_big z hz t h_t_in).2).hasDerivAt h_icc_nhds
-    · intro z hz t ht
-      have h_t_in_big : t ∈ Set.Icc (0 : ℝ) ((N : ℝ) * δ') :=
-        h_Icc_T_sub ht
-      obtain ⟨h_pos_big, h_vel_big⟩ := h_dw_on_big z hz t h_t_in_big
-      exact ⟨h_pos_big.mono h_Icc_T_sub, h_vel_big.mono h_Icc_T_sub⟩
-
-/-- **Two-window** characteristic-flow existence.
-
-A flow on `Ioo 0 (2δ)` for some `δ > 0` and initial conditions in
-`closedBall z₀ (a/2)`.  Produces a strictly longer window than
-`exists_vlasov_characteristicFlow_local` (which gave `Ioo 0 δ` with
-the larger `δ := (a/2)/(L_pl + 1)`); here we tighten the contraction
-constraint to `L_pl · (2δ) ≤ a/2`, yielding the smaller
-`δ := (a/2)/(2·(L_pl + 1))` but covering a `2δ`-long interval.
-
-**Implementation note.**  This is a single Picard call (the vendored
-`_confined` wrapper) with
-`tmax = 2δ`, not a literal "two-window stitch" via uniqueness on
-overlapping windows.  Mathematically the two are equivalent: a
-single Picard with an extended `tmax` and tightened `δ` recovers the
-same set of solutions that a two-window stitch would produce.  The
-genuine two-window stitch (per-z second Picard at varying centers
-glued via `ODE_solution_unique`) becomes essential only when the
-single-Picard contraction cannot be satisfied — i.e., when the total
-time window needed exceeds the asymptotic threshold `≈ 1/2` regardless
-of `a`.  For the upcoming N-window induction follow-up, this single-
-Picard extension is iterated, with each iteration using a per-z
-center from the previous window's endpoint. -/
-theorem exists_vlasov_characteristicFlow_twoWindow
-    {d : ℕ}
-    (W : PhysSpace d → ℝ)
-    (gradW : PhysSpace d → PhysSpace d)
-    (_hgradW : ∀ x, gradW x = gradient W x)
-    (L : NNReal) (hL : LipschitzWith L gradW)
-    (ρ : ℝ → Measure (PhysSpace d))
-    [∀ t, IsProbabilityMeasure (ρ t)]
-    (h_int : ∀ t (x : PhysSpace d), Integrable (fun y => gradW (x - y)) (ρ t))
-    (hρ_cont : ∀ x : PhysSpace d,
-      Continuous (fun t => convolveFunctionMeasure gradW (ρ t) x))
-    (z₀ : PhaseSpace d) (a : NNReal) (ha : 0 < a)
-    (M : NNReal)
-    (hbound : ∀ t ∈ Set.Icc (0 : ℝ) (1 : ℝ),
-              ∀ x ∈ Metric.closedBall z₀.1 (3 * (a : ℝ) / 2),
-              ‖convolveFunctionMeasure gradW (ρ t) x‖ ≤ M) :
-    ∃ (δ : ℝ) (_ : 0 < δ) (charX charV : ℝ → PhaseSpace d → PhysSpace d),
-      IsCharacteristicFlowOn gradW ρ charX charV
-        (Set.Ioo 0 (2 * δ)) (Metric.closedBall z₀ ((a : ℝ) / 2)) := by
-  classical
-  -- IsPicardLindelof parameter choices.  Same K_pl, r_pl, L_pl as `_local`;
-  -- only the time-step δ is halved to fit the 2δ contraction.
-  set K_pl : NNReal := max 1 L with hK_pl_def
-  set r_pl : NNReal := a / 2 with hr_pl_def
-  set L_pl : NNReal := ‖z₀.2‖₊ + a + M with hL_pl_def
-  -- δ chosen so the doubled window 2δ still satisfies L_pl · (2δ) ≤ a/2.
-  set δ : ℝ := min (1 / 2) ((a : ℝ) / 2 / (2 * ((L_pl : ℝ) + 1))) with hδ_def
-  have ha_real : (0 : ℝ) < (a : ℝ) := by exact_mod_cast ha
-  have h_denom_pos : (0 : ℝ) < 2 * ((L_pl : ℝ) + 1) := by positivity
-  have h_ratio_pos : (0 : ℝ) < (a : ℝ) / 2 / (2 * ((L_pl : ℝ) + 1)) := by positivity
-  have hδ_pos : (0 : ℝ) < δ := lt_min (by norm_num) h_ratio_pos
-  have hδ_le_half : δ ≤ 1 / 2 := min_le_left _ _
-  have hδ_le_ratio : δ ≤ (a : ℝ) / 2 / (2 * ((L_pl : ℝ) + 1)) := min_le_right _ _
-  have h_2δ_pos : (0 : ℝ) < 2 * δ := by linarith
-  have h_2δ_le_one : 2 * δ ≤ 1 := by linarith
-  -- t₀ ∈ Icc 0 (2δ).
-  let t₀ : Set.Icc (0 : ℝ) (2 * δ) :=
-    ⟨0, Set.mem_Icc.mpr ⟨le_refl 0, le_of_lt h_2δ_pos⟩⟩
-  -- Assemble IsPicardLindelof on time window [0, 2δ].
-  have hpl : IsPicardLindelof (vlasovVectorField gradW ρ) t₀ z₀ a r_pl L_pl K_pl := by
-    refine ⟨?_, ?_, ?_, ?_⟩
-    · intro t _
-      exact (vlasovVectorField_lipschitzWith gradW L hL ρ h_int t).lipschitzOnWith
-    · intro x _
-      apply Continuous.continuousOn
-      simp only [vlasovVectorField]
-      exact Continuous.prodMk continuous_const (hρ_cont x.1).neg
-    · -- norm_le — verbatim from `_local` (uses hbound on Icc 0 1, ball 3a/2).
-      intro t ht x hx
-      have h_norm_field := vlasovVectorField_norm_le gradW ρ t x
-      have hdist_le : dist x z₀ ≤ (a : ℝ) := hx
-      have hdist_le_norm : ‖x - z₀‖ ≤ (a : ℝ) := by rwa [dist_eq_norm] at hdist_le
-      have h_x2_proj : ‖x.2 - z₀.2‖ ≤ ‖x - z₀‖ := by
-        rw [Prod.norm_def]; exact le_max_right _ _
-      have h_x2_bound : ‖x.2‖ ≤ ‖z₀.2‖ + (a : ℝ) := by
-        have h1 : ‖x.2‖ = ‖(x.2 - z₀.2) + z₀.2‖ := by rw [sub_add_cancel]
-        have h2 : ‖(x.2 - z₀.2) + z₀.2‖ ≤ ‖x.2 - z₀.2‖ + ‖z₀.2‖ := norm_add_le _ _
-        linarith [h_x2_proj, hdist_le_norm]
-      have h_x1_proj : dist x.1 z₀.1 ≤ dist x z₀ := by
-        simp only [Prod.dist_eq]; exact le_max_left _ _
-      have h_x1_ball : x.1 ∈ Metric.closedBall z₀.1 (3 * (a : ℝ) / 2) := by
-        have hx1d : dist x.1 z₀.1 ≤ (a : ℝ) := le_trans h_x1_proj hdist_le
-        have : dist x.1 z₀.1 ≤ 3 * (a : ℝ) / 2 := by
-          have ha_nn : (0 : ℝ) ≤ (a : ℝ) := le_of_lt ha_real
-          linarith
-        exact this
-      have h_t_Icc : t ∈ Set.Icc (0 : ℝ) 1 :=
-        ⟨ht.1, le_trans ht.2 h_2δ_le_one⟩
-      have h_force_bound : ‖convolveFunctionMeasure gradW (ρ t) x.1‖ ≤ (M : ℝ) :=
-        hbound t h_t_Icc x.1 h_x1_ball
-      have h_Lpl_eq : (L_pl : ℝ) = ‖z₀.2‖ + (a : ℝ) + (M : ℝ) := by
-        simp [hL_pl_def, NNReal.coe_add, coe_nnnorm]
-      calc ‖vlasovVectorField gradW ρ t x‖
-          ≤ max ‖x.2‖ ‖convolveFunctionMeasure gradW (ρ t) x.1‖ := h_norm_field
-        _ ≤ (L_pl : ℝ) := by
-            rw [h_Lpl_eq]
-            apply max_le
-            · linarith [NNReal.coe_nonneg M]
-            · linarith [norm_nonneg z₀.2, NNReal.coe_nonneg a]
-    · -- mul_max_le: L_pl · (2δ) ≤ a − a/2 = a/2.  Tighter constraint than `_local`.
-      show (L_pl : ℝ) * max (2 * δ - (t₀ : ℝ)) ((t₀ : ℝ) - 0) ≤ (a : ℝ) - (r_pl : ℝ)
-      have ht₀_eq : (t₀ : ℝ) = 0 := rfl
-      simp only [ht₀_eq, sub_zero, sub_self, max_eq_left (le_of_lt h_2δ_pos)]
-      have h_a_minus_r : (a : ℝ) - (r_pl : ℝ) = (a : ℝ) / 2 := by
-        simp [hr_pl_def, NNReal.coe_div]; ring
-      rw [h_a_minus_r]
-      have h_Lpl_nn : (0 : ℝ) ≤ (L_pl : ℝ) := L_pl.coe_nonneg
-      have h_a_nn : (0 : ℝ) ≤ (a : ℝ) / 2 := by linarith [ha_real]
-      have h_step : (L_pl : ℝ) * (2 * δ) ≤ (L_pl : ℝ) *
-          (2 * ((a : ℝ) / 2 / (2 * ((L_pl : ℝ) + 1)))) := by
-        apply mul_le_mul_of_nonneg_left _ h_Lpl_nn
-        linarith [hδ_le_ratio]
-      have h_simp : (L_pl : ℝ) *
-          (2 * ((a : ℝ) / 2 / (2 * ((L_pl : ℝ) + 1))))
-          = (L_pl : ℝ) / ((L_pl : ℝ) + 1) * ((a : ℝ) / 2) := by
-        field_simp
-      have h_frac_le : (L_pl : ℝ) / ((L_pl : ℝ) + 1) ≤ 1 := by
-        have h_pos : (0 : ℝ) < (L_pl : ℝ) + 1 := by linarith
-        rw [div_le_one h_pos]; linarith
-      have h_bound : (L_pl : ℝ) / ((L_pl : ℝ) + 1) * ((a : ℝ) / 2) ≤ (a : ℝ) / 2 := by
-        calc (L_pl : ℝ) / ((L_pl : ℝ) + 1) * ((a : ℝ) / 2)
-            ≤ 1 * ((a : ℝ) / 2) :=
-              mul_le_mul_of_nonneg_right h_frac_le h_a_nn
-          _ = (a : ℝ) / 2 := one_mul _
-      linarith [h_step, h_simp ▸ h_step, h_bound]
-  -- Invoke headline Picard-Lindelöf on the doubled window.
-  obtain ⟨α, hα⟩ := hpl.exists_forall_mem_closedBall_eq_forall_mem_Icc_hasDerivWithinAt_confined
-  -- Define charX, charV by projection.
-  refine ⟨δ, hδ_pos, fun t z => (α z t).1, fun t z => (α z t).2, ?_, ?_, ?_⟩
-  · -- Initial condition.
-    intro z hz
-    have hz_in_r : z ∈ Metric.closedBall z₀ (r_pl : ℝ) := by
-      have hreq : (r_pl : ℝ) = (a : ℝ) / 2 := by simp [hr_pl_def, NNReal.coe_div]
-      rw [Metric.mem_closedBall] at hz ⊢
-      rw [hreq]; exact hz
-    have h_init : α z (t₀ : ℝ) = z := (hα z hz_in_r).1
-    have ht₀_eq : (t₀ : ℝ) = 0 := rfl
-    rw [ht₀_eq] at h_init
-    refine ⟨?_, ?_⟩
-    · change (α z 0).1 = z.1; rw [h_init]
-    · change (α z 0).2 = z.2; rw [h_init]
-  · -- Position ODE on Ioo 0 (2δ).
-    intro t ht z hz
-    have hz_in_r : z ∈ Metric.closedBall z₀ (r_pl : ℝ) := by
-      have hreq : (r_pl : ℝ) = (a : ℝ) / 2 := by simp [hr_pl_def, NNReal.coe_div]
-      rw [Metric.mem_closedBall] at hz ⊢; rw [hreq]; exact hz
-    have h_t_Icc : t ∈ Set.Icc (0 : ℝ) (2 * δ) := ⟨le_of_lt ht.1, le_of_lt ht.2⟩
-    have h_dw := (hα z hz_in_r).2.1 t h_t_Icc
-    have h_icc_nhds : Set.Icc (0 : ℝ) (2 * δ) ∈ nhds t := Icc_mem_nhds ht.1 ht.2
-    have h_d : HasDerivAt (α z) (vlasovVectorField gradW ρ t (α z t)) t :=
-      h_dw.hasDerivAt h_icc_nhds
-    have h_proj : HasDerivAt (fun s => (α z s).1)
-        (vlasovVectorField gradW ρ t (α z t)).1 t :=
-      (hasFDerivAt_fst (E := PhysSpace d) (F := PhysSpace d)).comp_hasDerivAt t h_d
-    simpa [vlasovVectorField] using h_proj
-  · -- Velocity ODE on Ioo 0 (2δ).
-    intro t ht z hz
-    have hz_in_r : z ∈ Metric.closedBall z₀ (r_pl : ℝ) := by
-      have hreq : (r_pl : ℝ) = (a : ℝ) / 2 := by simp [hr_pl_def, NNReal.coe_div]
-      rw [Metric.mem_closedBall] at hz ⊢; rw [hreq]; exact hz
-    have h_t_Icc : t ∈ Set.Icc (0 : ℝ) (2 * δ) := ⟨le_of_lt ht.1, le_of_lt ht.2⟩
-    have h_dw := (hα z hz_in_r).2.1 t h_t_Icc
-    have h_icc_nhds : Set.Icc (0 : ℝ) (2 * δ) ∈ nhds t := Icc_mem_nhds ht.1 ht.2
-    have h_d : HasDerivAt (α z) (vlasovVectorField gradW ρ t (α z t)) t :=
-      h_dw.hasDerivAt h_icc_nhds
-    have h_proj : HasDerivAt (fun s => (α z s).2)
-        (vlasovVectorField gradW ρ t (α z t)).2 t :=
-      (hasFDerivAt_snd (E := PhysSpace d) (F := PhysSpace d)).comp_hasDerivAt t h_d
-    simpa [vlasovVectorField] using h_proj
-
-
 /-! ## Lagrangian → Eulerian: pushforward solves weak Vlasov
 
 The pushforward `vlasovSolutionViaPushforward charX charV f₀` satisfies
@@ -3347,41 +780,8 @@ lemma vlasov_trajectory_lipschitz_bound_on
   have h_conv_bound : ∀ s ∈ Set.Icc 0 T, ∀ x : PhysSpace d,
       ‖convolveFunctionMeasure gradW (ρ s) x‖ ≤ ε₀ + (L : ℝ) * ‖x‖ := by
     intro s hs x
-    unfold convolveFunctionMeasure
-    have h_sub_int : Integrable (fun y => ‖x - y‖) (ρ s) :=
-      Integrable.mono' ((integrable_const ‖x‖).add (h_y_int s hs))
-        ((aestronglyMeasurable_const (b := x)).sub aestronglyMeasurable_id |>.norm)
-        (Filter.Eventually.of_forall fun y => by
-          simp only [Real.norm_of_nonneg (norm_nonneg _)]; exact norm_sub_le x y)
-    have h_pt : ∀ y : PhysSpace d,
-        ‖gradW (x - y)‖ ≤ ‖gradW 0‖ + (L : ℝ) * ‖x - y‖ := by
-      intro y
-      have hd := hL.dist_le_mul (x - y) 0
-      simp only [dist_eq_norm, sub_zero] at hd
-      have h_tri : ‖gradW (x - y)‖ ≤ ‖gradW 0‖ + ‖gradW (x - y) - gradW 0‖ := by
-        have := norm_add_le (gradW (x - y) - gradW 0) (gradW 0)
-        simp only [sub_add_cancel] at this; linarith
-      linarith
-    have h_bnd_int : Integrable (fun y => ‖gradW 0‖ + (L : ℝ) * ‖x - y‖) (ρ s) :=
-      (integrable_const _).add (h_sub_int.const_mul _)
-    calc ‖∫ y, gradW (x - y) ∂(ρ s)‖
-        ≤ ∫ y, ‖gradW (x - y)‖ ∂(ρ s) := norm_integral_le_integral_norm _
-      _ ≤ ∫ y, (‖gradW 0‖ + (L : ℝ) * ‖x - y‖) ∂(ρ s) :=
-          integral_mono (h_int s x).norm h_bnd_int (fun y => h_pt y)
-      _ = ‖gradW 0‖ + (L : ℝ) * ∫ y, ‖x - y‖ ∂(ρ s) := by
-          rw [integral_add (integrable_const _) (h_sub_int.const_mul _)]
-          simp [integral_const, measureReal_def, measure_univ, integral_const_mul]
-      _ ≤ ε₀ + (L : ℝ) * ‖x‖ := by
-          have h_int_le : ∫ y, ‖x - y‖ ∂(ρ s) ≤ ‖x‖ + M_ρ := by
-            calc ∫ y, ‖x - y‖ ∂(ρ s)
-                ≤ ∫ y, (‖x‖ + ‖y‖) ∂(ρ s) :=
-                  integral_mono h_sub_int ((integrable_const _).add (h_y_int s hs))
-                    (fun y => norm_sub_le x y)
-              _ = ‖x‖ + ∫ y, ‖y‖ ∂(ρ s) := by
-                  rw [integral_add (integrable_const _) (h_y_int s hs)]
-                  simp [integral_const, measureReal_def, measure_univ]
-              _ ≤ ‖x‖ + M_ρ := by linarith [hM_ρ s hs]
-          simp only [ε₀]; linarith [mul_le_mul_of_nonneg_left h_int_le (NNReal.coe_nonneg L)]
+    exact norm_convolveFunctionMeasure_le_affine gradW L hL (ρ s) (h_int s)
+      (h_y_int s hs) M_ρ (hM_ρ s hs) x
   -- Step 3: Choose nhd = Ioo (t/2) ((t+T)/2) ⊆ Ioo 0 T.  t/2 < t (since t>0) and
   -- t < (t+T)/2 (since t < T), so t ∈ nhd; further nhd ⊆ Icc 0 T for bounding.
   refine ⟨Set.Ioo (t / 2) ((t + T) / 2),
diff --git a/LeanPool/Vlasov/OT/Continuation.lean b/LeanPool/Vlasov/OT/Continuation.lean
new file mode 100644
index 0000000000..a2b16afa29
--- /dev/null
+++ b/LeanPool/Vlasov/OT/Continuation.lean
@@ -0,0 +1,2912 @@
+/-
+Copyright (c) 2026 Joseph K. Miller. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Joseph K. Miller
+-/
+module
+
+public import LeanPool.Vlasov.OT.LocalWellPosedness
+import Mathlib.Analysis.Calculus.FDeriv.Extend
+
+/-!
+# Continuation of local Vlasov solutions
+
+Boundary gluing and iteration extend a local Lagrangian solution to any finite
+horizon. Stability and the global theorem use this continuation independently.
+-/
+
+@[expose] public section
+
+namespace Vlasov
+
+open MeasureTheory ENNReal
+
+/-! ## Banked infrastructure: localized `hasDerivAt_of_hasDerivAt_of_ne` -/
+-- Generic real-analysis helper banked for `vlasovWellPosedness_glue` case (a)'s substantive
+-- close.  Mathlib's `hasDerivAt_of_hasDerivAt_of_ne`
+-- (Mathlib/Analysis/Calculus/FDeriv/Extend.lean) requires a UNIVERSAL
+-- `∀ y ≠ x, HasDerivAt f (g y) y` hypothesis; the `vlasovWellPosedness_glue` setting only
+-- gives HasDerivAt on a bounded interval `Ioo 0 (T + T_0)`.  This helper
+-- localizes the Mathlib pattern to a neighborhood-eventually hypothesis,
+-- enabling case (a)'s close via union of one-sided extension lemmas.
+
+section HasDerivAtPunctured
+open scoped Topology
+open Filter
+
+/-- Local version of `hasDerivAt_of_hasDerivAt_of_ne` (Mathlib/Analysis/Calculus/
+FDeriv/Extend.lean): if `f : ℝ → ℝ` has HasDerivAt with derivative `g(y)` at
+every `y ≠ x₀` in some neighborhood of `x₀`, and both `f` and `g` are continuous
+at `x₀`, then `f` has HasDerivAt with derivative `g(x₀)` at `x₀`.
+
+The proof composes `hasDerivWithinAt_Iic_of_tendsto_deriv` (left side) +
+`hasDerivWithinAt_Ici_of_tendsto_deriv` (right side) + `HasDerivWithinAt.union`,
+following the Mathlib lemma's proof structure but with locally-quantified
+hypothesis (enabling use when the punctured-HasDerivAt holds only on a bounded
+interval, not all of ℝ). -/
+theorem hasDerivAt_of_hasDerivAt_of_ne_in_nhds
+    {f g : ℝ → ℝ} {x₀ : ℝ}
+    (h_diff_ne : ∀ᶠ y in 𝓝 x₀, y ≠ x₀ → HasDerivAt f (g y) y)
+    (hf : ContinuousAt f x₀) (hg : ContinuousAt g x₀) :
+    HasDerivAt f (g x₀) x₀ := by
+  -- Extract an open ball around x₀ on which the punctured HasDerivAt holds.
+  obtain ⟨U, hU_sub, hU_open, hx₀_U⟩ := mem_nhds_iff.mp h_diff_ne
+  obtain ⟨ε, ε_pos, hε⟩ := Metric.isOpen_iff.mp hU_open x₀ hx₀_U
+  -- Right side: HasDerivWithinAt on Ici x₀ via hasDerivWithinAt_Ici_of_tendsto_deriv.
+  have h_right : HasDerivWithinAt f (g x₀) (Set.Ici x₀) x₀ := by
+    have hs_right : Set.Ioo x₀ (x₀ + ε) ∈ 𝓝[>] x₀ :=
+      Ioo_mem_nhdsGT (by linarith : x₀ < x₀ + ε)
+    have h_diff_right : DifferentiableOn ℝ f (Set.Ioo x₀ (x₀ + ε)) := by
+      intro y hy
+      have hy_U : y ∈ U := hε (by
+        rw [Metric.mem_ball, Real.dist_eq, abs_lt]
+        exact ⟨by linarith [hy.1, hy.2], by linarith [hy.1, hy.2]⟩)
+      exact (hU_sub hy_U (ne_of_gt hy.1)).differentiableAt.differentiableWithinAt
+    apply hasDerivWithinAt_Ici_of_tendsto_deriv h_diff_right hf.continuousWithinAt hs_right
+    have h_g_tendsto : Tendsto g (𝓝[>] x₀) (𝓝 (g x₀)) := tendsto_inf_left hg
+    apply h_g_tendsto.congr'
+    apply mem_of_superset hs_right
+    intro y hy
+    have hy_U : y ∈ U := hε (by
+      rw [Metric.mem_ball, Real.dist_eq, abs_lt]
+      exact ⟨by linarith [hy.1, hy.2], by linarith [hy.1, hy.2]⟩)
+    exact (hU_sub hy_U (ne_of_gt hy.1)).deriv.symm
+  -- Left side: symmetric.
+  have h_left : HasDerivWithinAt f (g x₀) (Set.Iic x₀) x₀ := by
+    have hs_left : Set.Ioo (x₀ - ε) x₀ ∈ 𝓝[<] x₀ :=
+      Ioo_mem_nhdsLT (by linarith : x₀ - ε < x₀)
+    have h_diff_left : DifferentiableOn ℝ f (Set.Ioo (x₀ - ε) x₀) := by
+      intro y hy
+      have hy_U : y ∈ U := hε (by
+        rw [Metric.mem_ball, Real.dist_eq, abs_lt]
+        exact ⟨by linarith [hy.1, hy.2], by linarith [hy.1, hy.2]⟩)
+      exact (hU_sub hy_U (ne_of_lt hy.2)).differentiableAt.differentiableWithinAt
+    apply hasDerivWithinAt_Iic_of_tendsto_deriv h_diff_left hf.continuousWithinAt hs_left
+    have h_g_tendsto : Tendsto g (𝓝[<] x₀) (𝓝 (g x₀)) := tendsto_inf_left hg
+    apply h_g_tendsto.congr'
+    apply mem_of_superset hs_left
+    intro y hy
+    have hy_U : y ∈ U := hε (by
+      rw [Metric.mem_ball, Real.dist_eq, abs_lt]
+      exact ⟨by linarith [hy.1, hy.2], by linarith [hy.1, hy.2]⟩)
+    exact (hU_sub hy_U (ne_of_lt hy.2)).deriv.symm
+  -- Union via Set.Iic_union_Ici = Set.univ → HasDerivAt at x₀.
+  simpa using h_left.union h_right
+
+end HasDerivAtPunctured
+
+/-! ## Variable-`T_target` continuation via fixed-`T_0` iteration -/
+-- Composes `vlasovWellPosedness_local` against itself to extend the local
+-- solution from `[0, T_0]` to `[0, T_target]` for any `T_target > 0`.  The
+-- contraction time `T_0` is *fixed* (depends only on `L`, not on iteration-
+-- accumulated moment bounds) — see the docstring on `vlasovWellPosedness_local`
+-- (above) for why fixed-`T_0` is the correct iteration shape (the
+-- `Phi_supW1_contraction` factor `q` depends only on `L` and `T`).
+--
+-- Two sub-theorems:
+-- * `vlasovWellPosedness_glue`: extend a solution on `[0, T]` by one
+--   window of length `T_0`, gluing at `t = T`.
+-- * `vlasovWellPosedness_forward`: `Nat.rec` iteration of `vlasovWellPosedness_glue`
+--   to reach any `T_target`.
+--
+-- The universal-in-`t` bridge (below) then goes from
+-- `IsLagrangianVlasovSolutionOn` (any `T_target`) to
+-- `IsLagrangianVlasovSolution` (universal-in-`t`), and uniqueness follows.
+
+/-- The `t = T` seam of the glue: both one-sided derivatives of the spliced
+flow at the junction agree (`g`'s flow starts at the identity on
+`f_prev T`'s data), so `HasDerivWithinAt.union` on `Iic T ∪ Ici T = univ`
+gives the two-sided derivative, restricted back to `Icc 0 (T + T_0)`. -/
+private lemma vlasovWellPosedness_glue_boundary_seam {d : ℕ}
+    (gradW : PhysSpace d → PhysSpace d)
+    {T T_0 : ℝ} (hT_pos : 0 < T) (hT_0_pos : 0 < T_0)
+    (f_prev g f_next : ℝ → Measure (PhaseSpace d))
+    (charX_prev charV_prev charX_g charV_g : ℝ → PhaseSpace d → PhysSpace d)
+    (hdef_f : f_next = fun t => if t ≤ T then f_prev t else g (t - T))
+    (h_prev_boundary : ∀ (z : PhaseSpace d) (t : ℝ), t ∈ Set.Icc (0 : ℝ) T →
+        HasDerivWithinAt (fun s => charX_prev s z) (charV_prev t z) (Set.Icc 0 T) t ∧
+        HasDerivWithinAt (fun s => charV_prev s z)
+          (-(convolveFunctionMeasure gradW (spatialMarginal (f_prev t)) (charX_prev t z)))
+          (Set.Icc 0 T) t)
+    (hg_boundary : ∀ (w : PhaseSpace d) (t : ℝ), t ∈ Set.Icc (0 : ℝ) T_0 →
+        HasDerivWithinAt (fun s => charX_g s w) (charV_g t w) (Set.Icc 0 T_0) t ∧
+        HasDerivWithinAt (fun s => charV_g s w)
+          (-(convolveFunctionMeasure gradW (spatialMarginal (g t)) (charX_g t w)))
+          (Set.Icc 0 T_0) t)
+    (hg_init : g 0 = f_prev T)
+    (hg_init_cond : ∀ (w : PhaseSpace d), charX_g 0 w = w.1 ∧ charV_g 0 w = w.2)
+    (z : PhaseSpace d) :
+    HasDerivWithinAt
+      (fun s => if s ≤ T then charX_prev s z
+        else charX_g (s - T) (charX_prev T z, charV_prev T z))
+      (charV_prev T z) (Set.Icc 0 (T + T_0)) T ∧
+    HasDerivWithinAt
+      (fun s => if s ≤ T then charV_prev s z
+        else charV_g (s - T) (charX_prev T z, charV_prev T z))
+      (-(convolveFunctionMeasure gradW (spatialMarginal (f_next T)) (charX_prev T z)))
+      (Set.Icc 0 (T + T_0)) T := by
+  have hT_in : T ∈ Set.Icc (0 : ℝ) T := ⟨hT_pos.le, le_refl T⟩
+  have h_bX := (h_prev_boundary z T hT_in).1
+  have h_bV := (h_prev_boundary z T hT_in).2
+  have h0_T0_in : (0 : ℝ) ∈ Set.Icc (0 : ℝ) T_0 := ⟨le_refl 0, hT_0_pos.le⟩
+  have h_g_bX := (hg_boundary (charX_prev T z, charV_prev T z) 0 h0_T0_in).1
+  have h_g_bV := (hg_boundary (charX_prev T z, charV_prev T z) 0 h0_T0_in).2
+  have h_nhd_L : Set.Icc 0 T ∈ nhdsWithin T (Set.Iic T) := Icc_mem_nhdsLE hT_pos
+  have h_nhd_R : Set.Icc 0 T_0 ∈ nhdsWithin (0 : ℝ) (Set.Ici 0) := Icc_mem_nhdsGE hT_0_pos
+  -- charX: left one-sided
+  have hX_Lic := h_bX.mono_of_mem_nhdsWithin h_nhd_L
+  have hX_left : HasDerivWithinAt
+      (fun s => if s ≤ T then charX_prev s z
+        else charX_g (s - T) (charX_prev T z, charV_prev T z))
+      (charV_prev T z) (Set.Iic T) T :=
+    hX_Lic.congr_of_mem (fun s hs => by simp [Set.mem_Iic.mp hs]) Set.self_mem_Iic
+  -- charX: right one-sided via chain rule on g's boundary
+  have hX_Ici0 := h_g_bX.mono_of_mem_nhdsWithin h_nhd_R
+  have h_sub_R : HasDerivWithinAt (· - T) 1 (Set.Ici T) T :=
+    ((hasDerivAt_id' T).sub_const T).hasDerivWithinAt
+  have h_mapR : Set.MapsTo (· - T) (Set.Ici T) (Set.Ici 0) :=
+    fun s hs => Set.mem_Ici.mpr (by linarith [Set.mem_Ici.mp hs])
+  have h_chainX : HasDerivWithinAt
+      (fun s => charX_g (s - T) (charX_prev T z, charV_prev T z))
+      (charV_g 0 (charX_prev T z, charV_prev T z)) (Set.Ici T) T := by
+    have := HasDerivWithinAt.scomp_of_eq T hX_Ici0 h_sub_R h_mapR (sub_self T).symm
+    simpa [Function.comp_def, one_smul] using this
+  have hVg0_eq : charV_g 0 (charX_prev T z, charV_prev T z) = charV_prev T z :=
+    (hg_init_cond (charX_prev T z, charV_prev T z)).2
+  rw [hVg0_eq] at h_chainX
+  have hX_right : HasDerivWithinAt
+      (fun s => if s ≤ T then charX_prev s z
+        else charX_g (s - T) (charX_prev T z, charV_prev T z))
+      (charV_prev T z) (Set.Ici T) T :=
+    h_chainX.congr_of_mem
+      (fun s hs => by
+        by_cases hle : s ≤ T
+        · have heq : s = T := le_antisymm hle (Set.mem_Ici.mp hs)
+          simp [heq, sub_self,
+            (hg_init_cond (charX_prev T z, charV_prev T z)).1]
+        · simp [hle])
+      Set.self_mem_Ici
+  have hX_union := hX_left.union hX_right
+  rw [Set.Iic_union_Ici] at hX_union
+  -- charV: analogously
+  have hV_Lic := h_bV.mono_of_mem_nhdsWithin h_nhd_L
+  have hV_left : HasDerivWithinAt
+      (fun s => if s ≤ T then charV_prev s z
+        else charV_g (s - T) (charX_prev T z, charV_prev T z))
+      (-(convolveFunctionMeasure gradW (spatialMarginal (f_next T)) (charX_prev T z)))
+      (Set.Iic T) T := by
+    simp only [hdef_f, ite_eq_left (le_refl T)]
+    exact hV_Lic.congr_of_mem (fun s hs => by simp [Set.mem_Iic.mp hs]) Set.self_mem_Iic
+  have hV_Ici0 := h_g_bV.mono_of_mem_nhdsWithin h_nhd_R
+  have h_chainV : HasDerivWithinAt
+      (fun s => charV_g (s - T) (charX_prev T z, charV_prev T z))
+      (-(convolveFunctionMeasure gradW
+        (spatialMarginal (g 0))
+        (charX_g 0 (charX_prev T z, charV_prev T z))))
+      (Set.Ici T) T := by
+    have := HasDerivWithinAt.scomp_of_eq T hV_Ici0 h_sub_R h_mapR (sub_self T).symm
+    simpa [Function.comp_def, one_smul] using this
+  have hXg0_eq : charX_g 0 (charX_prev T z, charV_prev T z) = charX_prev T z :=
+    (hg_init_cond (charX_prev T z, charV_prev T z)).1
+  have hg0_spat : spatialMarginal (g 0) = spatialMarginal (f_prev T) :=
+    congrArg spatialMarginal hg_init
+  have hfnextT : spatialMarginal (f_next T) = spatialMarginal (f_prev T) :=
+    congrArg spatialMarginal (by rw [hdef_f]; simp only [ite_eq_left (le_refl T)])
+  rw [hXg0_eq, hg0_spat, ← hfnextT] at h_chainV
+  have hV_right : HasDerivWithinAt
+      (fun s => if s ≤ T then charV_prev s z
+        else charV_g (s - T) (charX_prev T z, charV_prev T z))
+      (-(convolveFunctionMeasure gradW (spatialMarginal (f_next T)) (charX_prev T z)))
+      (Set.Ici T) T :=
+    h_chainV.congr_of_mem
+      (fun s hs => by
+        by_cases hle : s ≤ T
+        · have heq : s = T := le_antisymm hle (Set.mem_Ici.mp hs)
+          simp [heq, sub_self,
+            (hg_init_cond (charX_prev T z, charV_prev T z)).2]
+        · simp [hle])
+      Set.self_mem_Ici
+  have hV_union := hV_left.union hV_right
+  rw [Set.Iic_union_Ici] at hV_union
+  exact ⟨hX_union.hasDerivAt Filter.univ_mem |>.hasDerivWithinAt,
+    hV_union.hasDerivAt Filter.univ_mem |>.hasDerivWithinAt⟩
+
+private lemma vlasovWellPosedness_glue_boundary {d : ℕ}
+    (gradW : PhysSpace d → PhysSpace d)
+    {T T_0 : ℝ} (hT_pos : 0 < T) (hT_0_pos : 0 < T_0)
+    (f_prev g f_next : ℝ → Measure (PhaseSpace d))
+    (charX_prev charV_prev charX_g charV_g charX_next charV_next :
+        ℝ → PhaseSpace d → PhysSpace d)
+    (hdef_X : charX_next = fun t z =>
+        if t ≤ T then charX_prev t z else charX_g (t - T) (charX_prev T z, charV_prev T z))
+    (hdef_V : charV_next = fun t z =>
+        if t ≤ T then charV_prev t z else charV_g (t - T) (charX_prev T z, charV_prev T z))
+    (hdef_f : f_next = fun t => if t ≤ T then f_prev t else g (t - T))
+    (h_prev_boundary : ∀ (z : PhaseSpace d) (t : ℝ), t ∈ Set.Icc (0 : ℝ) T →
+        HasDerivWithinAt (fun s => charX_prev s z) (charV_prev t z) (Set.Icc 0 T) t ∧
+        HasDerivWithinAt (fun s => charV_prev s z)
+          (-(convolveFunctionMeasure gradW (spatialMarginal (f_prev t)) (charX_prev t z)))
+          (Set.Icc 0 T) t)
+    (hg_boundary : ∀ (w : PhaseSpace d) (t : ℝ), t ∈ Set.Icc (0 : ℝ) T_0 →
+        HasDerivWithinAt (fun s => charX_g s w) (charV_g t w) (Set.Icc 0 T_0) t ∧
+        HasDerivWithinAt (fun s => charV_g s w)
+          (-(convolveFunctionMeasure gradW (spatialMarginal (g t)) (charX_g t w)))
+          (Set.Icc 0 T_0) t)
+    (hg_init : g 0 = f_prev T)
+    (hg_init_cond : ∀ (w : PhaseSpace d), charX_g 0 w = w.1 ∧ charV_g 0 w = w.2) :
+    ∀ (z : PhaseSpace d) (t : ℝ), t ∈ Set.Icc (0 : ℝ) (T + T_0) →
+      HasDerivWithinAt (fun s => charX_next s z) (charV_next t z) (Set.Icc 0 (T + T_0)) t ∧
+      HasDerivWithinAt (fun s => charV_next s z)
+        (-(convolveFunctionMeasure gradW (spatialMarginal (f_next t)) (charX_next t z)))
+        (Set.Icc 0 (T + T_0)) t := by
+  subst hdef_X hdef_V
+  intro z t ht
+  simp only []
+  -- Abbreviate the initial phase-space point for g
+  have hz₀_def : (charX_prev T z, charV_prev T z) = (charX_prev T z, charV_prev T z) := rfl
+  by_cases ht_le : t ≤ T
+  · -- t ≤ T: use h_prev_boundary + upgrade to Icc 0 (T + T_0)
+    simp only [ite_eq_left ht_le]
+    have ht_in : t ∈ Set.Icc (0 : ℝ) T := ⟨ht.1, ht_le⟩
+    have h_bX := (h_prev_boundary z t ht_in).1
+    have h_bV := (h_prev_boundary z t ht_in).2
+    by_cases ht_eqT : t = T
+    · -- t = T: the seam case, extracted as `_glue_boundary_seam`.
+      rw [ht_eqT]
+      exact vlasovWellPosedness_glue_boundary_seam gradW hT_pos hT_0_pos f_prev g f_next
+        charX_prev charV_prev charX_g charV_g hdef_f h_prev_boundary hg_boundary
+        hg_init hg_init_cond z
+    · -- t < T: use mono_of_mem_nhdsWithin to extend to Icc 0 (T + T_0)
+      have ht_ltT : t < T := lt_of_le_of_ne ht_le ht_eqT
+      -- Get Icc 0 T ∈ nhdsWithin t (Icc 0 (T + T_0))
+      have h_mem : Set.Icc (0 : ℝ) T ∈ nhdsWithin t (Set.Icc 0 (T + T_0)) := by
+        rcases eq_or_lt_of_le ht.1 with rfl | ht_pos
+        · exact (nhdsWithin_mono 0 Set.Icc_subset_Ici_self) (Icc_mem_nhdsGE hT_pos)
+        · exact mem_nhdsWithin_of_mem_nhds (Icc_mem_nhds ht_pos ht_ltT)
+      -- Upgrade HasDerivWithinAt from Icc 0 T to Icc 0 (T + T_0)
+      have hX_big := h_bX.mono_of_mem_nhdsWithin h_mem
+      have hV_big := h_bV.mono_of_mem_nhdsWithin h_mem
+      -- Congr: charX_next = charX_prev on Icc 0 T (within Icc 0 (T+T_0))
+      have hX_ev : (fun s => if s ≤ T then charX_prev s z
+            else charX_g (s - T) (charX_prev T z, charV_prev T z))
+          =ᶠ[nhdsWithin t (Set.Icc 0 (T + T_0))] (charX_prev · z) :=
+        Filter.Eventually.mono h_mem (fun s hs => by simp [hs.2])
+      have hV_ev : (fun s => if s ≤ T then charV_prev s z
+            else charV_g (s - T) (charX_prev T z, charV_prev T z))
+          =ᶠ[nhdsWithin t (Set.Icc 0 (T + T_0))] (charV_prev · z) :=
+        Filter.Eventually.mono h_mem (fun s hs => by simp [hs.2])
+      -- f_next t = f_prev t, so marginals match
+      have hfnext : f_next t = f_prev t := by rw [hdef_f]; simp only [ite_eq_left ht_le]
+      have hfnext_spat : spatialMarginal (f_next t) = spatialMarginal (f_prev t) :=
+        congrArg spatialMarginal hfnext
+      rw [← hfnext_spat] at hV_big
+      constructor
+      · exact hX_big.congr_of_eventuallyEq_of_mem hX_ev ht
+      · exact hV_big.congr_of_eventuallyEq_of_mem hV_ev ht
+  · -- T < t: use hg_boundary + chain rule
+    push Not at ht_le
+    simp only [ite_eq_right (not_le.mpr ht_le)]
+    have htT_mem : t - T ∈ Set.Icc (0 : ℝ) T_0 := ⟨by linarith, by linarith [ht.2]⟩
+    have h_bdry_gX := (hg_boundary (charX_prev T z, charV_prev T z) (t - T) htT_mem).1
+    have h_bdry_gV := (hg_boundary (charX_prev T z, charV_prev T z) (t - T) htT_mem).2
+    by_cases ht_ltTT0 : t < T + T_0
+    · -- t ∈ Ioo T (T + T_0): interior case, use HasDerivAt + congr
+      have htT_Ioo : t - T ∈ Set.Ioo (0 : ℝ) T_0 := ⟨by linarith, by linarith⟩
+      have hX_da := h_bdry_gX.hasDerivAt (Icc_mem_nhds htT_Ioo.1 htT_Ioo.2)
+      have hV_da := h_bdry_gV.hasDerivAt (Icc_mem_nhds htT_Ioo.1 htT_Ioo.2)
+      have h_sub : HasDerivAt (· - T) 1 t := (hasDerivAt_id' t).sub_const T
+      have h_chainX : HasDerivAt (fun s => charX_g (s - T) (charX_prev T z, charV_prev T z))
+          (charV_g (t - T) (charX_prev T z, charV_prev T z)) t := by
+        have := HasDerivAt.scomp_of_eq t hX_da h_sub rfl
+        simpa [Function.comp_def, one_smul] using this
+      have h_chainV : HasDerivAt (fun s => charV_g (s - T) (charX_prev T z, charV_prev T z))
+          (-(convolveFunctionMeasure gradW
+            (spatialMarginal (g (t - T)))
+            (charX_g (t - T) (charX_prev T z, charV_prev T z)))) t := by
+        have := HasDerivAt.scomp_of_eq t hV_da h_sub rfl
+        simpa [Function.comp_def, one_smul] using this
+      -- f_next t = g (t - T), so marginals match
+      have h_fnext_t : f_next t = g (t - T) := by
+        rw [hdef_f]; simp only [ite_eq_right (not_le.mpr ht_le)]
+      rw [← congrArg spatialMarginal h_fnext_t] at h_chainV
+      -- piecewise = charX_g (· - T) (charX_prev T z, charV_prev T z) near t (since T < t)
+      have h_ev_gt : ∀ᶠ s in nhds t, T < s := eventually_gt_nhds ht_le
+      have hX_ev : (fun s => if s ≤ T then charX_prev s z
+            else charX_g (s - T) (charX_prev T z, charV_prev T z))
+          =ᶠ[nhds t] (fun s => charX_g (s - T) (charX_prev T z, charV_prev T z)) :=
+        Filter.Eventually.mono h_ev_gt (fun s hs => by simp [not_le.mpr hs])
+      have hV_ev : (fun s => if s ≤ T then charV_prev s z
+            else charV_g (s - T) (charX_prev T z, charV_prev T z))
+          =ᶠ[nhds t] (fun s => charV_g (s - T) (charX_prev T z, charV_prev T z)) :=
+        Filter.Eventually.mono h_ev_gt (fun s hs => by simp [not_le.mpr hs])
+      exact ⟨(h_chainX.congr_of_eventuallyEq hX_ev).hasDerivWithinAt,
+             (h_chainV.congr_of_eventuallyEq hV_ev).hasDerivWithinAt⟩
+    · -- t = T + T_0: endpoint, use mono_of_mem_nhdsWithin + chain rule + mono
+      push Not at ht_ltTT0
+      have htT0 : t = T + T_0 := le_antisymm ht.2 ht_ltTT0
+      rw [show t - T = T_0 from by linarith] at h_bdry_gX h_bdry_gV
+      -- Upgrade to Iic T_0 via Icc_mem_nhdsLE
+      have h_nhd_LE : Set.Icc 0 T_0 ∈ nhdsWithin T_0 (Set.Iic T_0) := Icc_mem_nhdsLE hT_0_pos
+      have hX_Lic := h_bdry_gX.mono_of_mem_nhdsWithin h_nhd_LE
+      have hV_Lic := h_bdry_gV.mono_of_mem_nhdsWithin h_nhd_LE
+      -- Chain rule: (· - T) maps Iic (T + T_0) to Iic T_0
+      have h_sub_LE : HasDerivWithinAt (· - T) 1 (Set.Iic (T + T_0)) (T + T_0) :=
+        ((hasDerivAt_id' (T + T_0)).sub_const T).hasDerivWithinAt.mono
+          (fun _ _ => Set.mem_univ _)
+      have h_mapLE : Set.MapsTo (· - T) (Set.Iic (T + T_0)) (Set.Iic T_0) :=
+        fun s hs => Set.mem_Iic.mpr (by linarith [Set.mem_Iic.mp hs])
+      have h_chainX : HasDerivWithinAt
+          (fun s => charX_g (s - T) (charX_prev T z, charV_prev T z))
+          (charV_g T_0 (charX_prev T z, charV_prev T z)) (Set.Iic (T + T_0)) (T + T_0) := by
+        have := HasDerivWithinAt.scomp_of_eq (T + T_0) hX_Lic h_sub_LE h_mapLE
+          (show T_0 = (T + T_0) - T by ring)
+        simpa [Function.comp_def, one_smul] using this
+      have h_chainV : HasDerivWithinAt
+          (fun s => charV_g (s - T) (charX_prev T z, charV_prev T z))
+          (-(convolveFunctionMeasure gradW
+            (spatialMarginal (g T_0))
+            (charX_g T_0 (charX_prev T z, charV_prev T z))))
+          (Set.Iic (T + T_0)) (T + T_0) := by
+        have := HasDerivWithinAt.scomp_of_eq (T + T_0) hV_Lic h_sub_LE h_mapLE
+          (show T_0 = (T + T_0) - T by ring)
+        simpa [Function.comp_def, one_smul] using this
+      -- Congr: near T+T_0 within Iic (T+T_0), points > T eventually
+      have h_ev_gt2 : ∀ᶠ s in nhdsWithin (T + T_0) (Set.Iic (T + T_0)), T < s :=
+        (eventually_gt_nhds (show T < T + T_0 by linarith)).filter_mono nhdsWithin_le_nhds
+      have hX_ev2 : (fun s => if s ≤ T then charX_prev s z
+            else charX_g (s - T) (charX_prev T z, charV_prev T z))
+          =ᶠ[nhdsWithin (T + T_0) (Set.Iic (T + T_0))]
+          (fun s => charX_g (s - T) (charX_prev T z, charV_prev T z)) :=
+        Filter.Eventually.mono h_ev_gt2 (fun s hs => by simp [not_le.mpr hs])
+      have hV_ev2 : (fun s => if s ≤ T then charV_prev s z
+            else charV_g (s - T) (charX_prev T z, charV_prev T z))
+          =ᶠ[nhdsWithin (T + T_0) (Set.Iic (T + T_0))]
+          (fun s => charV_g (s - T) (charX_prev T z, charV_prev T z)) :=
+        Filter.Eventually.mono h_ev_gt2 (fun s hs => by simp [not_le.mpr hs])
+      have h_Iic_sub : Set.Icc 0 (T + T_0) ⊆ Set.Iic (T + T_0) := Set.Icc_subset_Iic_self
+      have h_TT0_Iic : (T + T_0) ∈ Set.Iic (T + T_0) := Set.mem_Iic.mpr (le_refl _)
+      -- f_next (T + T_0) = g T_0
+      have h_fnext_TT0 : f_next (T + T_0) = g T_0 := by
+        simp [hdef_f, not_le.mpr (show T < T + T_0 by linarith)]
+      constructor
+      · have h_cX : HasDerivWithinAt
+            (fun s => if s ≤ T then charX_prev s z
+              else charX_g (s - T) (charX_prev T z, charV_prev T z))
+            (charV_g T_0 (charX_prev T z, charV_prev T z))
+            (Set.Icc 0 (T + T_0)) (T + T_0) :=
+          (h_chainX.congr_of_eventuallyEq_of_mem hX_ev2 h_TT0_Iic).mono h_Iic_sub
+        rw [htT0]
+        rw [show T + T_0 - T = T_0 from by ring]
+        exact h_cX
+      · have h_cV : HasDerivWithinAt
+            (fun s => if s ≤ T then charV_prev s z
+              else charV_g (s - T) (charX_prev T z, charV_prev T z))
+            (-(convolveFunctionMeasure gradW
+              (spatialMarginal (g T_0))
+              (charX_g T_0 (charX_prev T z, charV_prev T z))))
+            (Set.Icc 0 (T + T_0)) (T + T_0) :=
+          (h_chainV.congr_of_eventuallyEq_of_mem hV_ev2 h_TT0_Iic).mono h_Iic_sub
+        rw [htT0]
+        rw [h_fnext_TT0]
+        rw [show T + T_0 - T = T_0 from by ring]
+        exact h_cV
+
+
+/-- **Route 2 inner kernel for `glue_step` `h_cont_g`** (LEFT / `Iic T`): continuity
+at the seam `T` of `s ↦ (∇W ∗ μ_s)(charX s z)`, where the window measure curve `μ` is
+the flow-pushforward of `f₀`.
+
+Proven from PROVEN tools only (no deferred OT).  The pushforward rewrite
+`(∇W ∗ μ_s)(x) = ∫ z', gradW (x − charX s z') ∂f₀` (`integral_map`) turns the
+moving-measure convolution into a fixed-`f₀` integral with moving integrand, closed by
+dominated convergence: convergence from the flow's seam continuity `h_charX_cont`,
+domination from the Gronwall growth bound `hC_T` (Piece A) against `f₀`'s finite first
+moment.  This is the structural reason `h_cont_g` does NOT need the general narrow→W₁
+kernel — its consumer carries a pushforward representation. -/
+lemma flowConv_continuousWithinAt_Iic_seam
+    {d : ℕ}
+    (gradW : PhysSpace d → PhysSpace d)
+    (L : NNReal) (hL : LipschitzWith L gradW)
+    (charX : ℝ → PhaseSpace d → PhysSpace d)
+    (f₀ : Measure (PhaseSpace d)) [IsProbabilityMeasure f₀]
+    (hf₀_int : Integrable (fun z : PhaseSpace d => ‖z‖) f₀)
+    {T : ℝ} (hT : 0 < T)
+    (μ : ℝ → Measure (PhysSpace d))
+    (h_push : ∀ s ∈ Set.Icc (0 : ℝ) T,
+        μ s = Measure.map (fun z : PhaseSpace d => charX s z) f₀)
+    (h_aemeas : ∀ s ∈ Set.Icc (0 : ℝ) T,
+        AEMeasurable (fun z : PhaseSpace d => charX s z) f₀)
+    (h_charX_cont : ∀ z : PhaseSpace d,
+        ContinuousWithinAt (fun s => charX s z) (Set.Icc (0 : ℝ) T) T)
+    (C_T : ℝ) (_hC_T_nn : 0 ≤ C_T)
+    (hC_T : ∀ s ∈ Set.Icc (0 : ℝ) T, ∀ z : PhaseSpace d, ‖charX s z‖ ≤ C_T * (‖z‖ + 1))
+    (z : PhaseSpace d) :
+    ContinuousWithinAt (fun s => convolveFunctionMeasure gradW (μ s) (charX s z))
+      (Set.Iic T) T := by
+  have h_nhd_L : Set.Icc (0 : ℝ) T ∈ nhdsWithin T (Set.Iic T) := Icc_mem_nhdsLE hT
+  have hgradW_cont : Continuous gradW := hL.continuous
+  have hL_nn : (0 : ℝ) ≤ (L : ℝ) := L.coe_nonneg
+  -- Pushforward rewrite of the convolution, eventually in s (on the window).
+  have h_eq : (fun s => convolveFunctionMeasure gradW (μ s) (charX s z))
+      =ᶠ[nhdsWithin T (Set.Iic T)]
+      (fun s => ∫ z', gradW (charX s z - charX s z') ∂f₀) := by
+    apply Filter.Eventually.mono h_nhd_L
+    intro s hs
+    change ∫ y, gradW (charX s z - y) ∂(μ s)
+        = ∫ z', gradW (charX s z - charX s z') ∂f₀
+    rw [h_push s hs]
+    exact integral_map (h_aemeas s hs)
+      (hgradW_cont.comp (continuous_const.sub continuous_id)).aestronglyMeasurable
+  -- The rewritten f₀-integral is continuous at T by dominated convergence.
+  have h_cont_rhs : ContinuousWithinAt
+      (fun s => ∫ z', gradW (charX s z - charX s z') ∂f₀) (Set.Iic T) T := by
+    apply continuousWithinAt_of_dominated
+      (bound := fun z' => ‖gradW 0‖ + (L : ℝ) * (C_T * (‖z‖ + 1))
+        + (L : ℝ) * (C_T * (‖z'‖ + 1)))
+    · -- AEStronglyMeasurable in z', eventually in s
+      apply Filter.Eventually.mono h_nhd_L
+      intro s hs
+      exact (hgradW_cont.measurable.comp_aemeasurable
+        (aemeasurable_const.sub (h_aemeas s hs))).aestronglyMeasurable
+    · -- pointwise dominator bound, eventually in s
+      apply Filter.Eventually.mono h_nhd_L
+      intro s hs
+      apply Filter.Eventually.of_forall
+      intro z'
+      have h1 : ‖gradW (charX s z - charX s z')‖
+          ≤ ‖gradW 0‖ + (L : ℝ) * ‖charX s z - charX s z'‖ := by
+        have hd := hL.dist_le_mul (charX s z - charX s z') 0
+        simp only [dist_eq_norm, sub_zero] at hd
+        have htri : ‖gradW (charX s z - charX s z')‖
+            ≤ ‖gradW 0‖ + ‖gradW (charX s z - charX s z') - gradW 0‖ := by
+          have := norm_add_le (gradW (charX s z - charX s z') - gradW 0) (gradW 0)
+          simp only [sub_add_cancel] at this; linarith
+        linarith
+      have h2 : ‖charX s z - charX s z'‖ ≤ ‖charX s z‖ + ‖charX s z'‖ := norm_sub_le _ _
+      have h3 : ‖charX s z‖ ≤ C_T * (‖z‖ + 1) := hC_T s hs z
+      have h4 : ‖charX s z'‖ ≤ C_T * (‖z'‖ + 1) := hC_T s hs z'
+      nlinarith [mul_le_mul_of_nonneg_left (h2.trans (add_le_add h3 h4)) hL_nn]
+    · -- integrability of the dominator
+      apply Integrable.add (integrable_const _)
+      exact ((hf₀_int.add (integrable_const (1 : ℝ))).const_mul C_T).const_mul (L : ℝ)
+    · -- pointwise continuity in s, a.e. z'
+      apply Filter.Eventually.of_forall
+      intro z'
+      have hcz : ContinuousWithinAt (fun s => charX s z) (Set.Iic T) T :=
+        (h_charX_cont z).mono_of_mem_nhdsWithin h_nhd_L
+      have hcz' : ContinuousWithinAt (fun s => charX s z') (Set.Iic T) T :=
+        (h_charX_cont z').mono_of_mem_nhdsWithin h_nhd_L
+      exact hgradW_cont.continuousAt.comp_continuousWithinAt (hcz.sub hcz')
+  -- Bridge value at T and conclude.
+  have h_val_T : convolveFunctionMeasure gradW (μ T) (charX T z)
+      = ∫ z', gradW (charX T z - charX T z') ∂f₀ := by
+    have hT_mem : T ∈ Set.Icc (0 : ℝ) T := ⟨hT.le, le_refl T⟩
+    change ∫ y, gradW (charX T z - y) ∂(μ T)
+        = ∫ z', gradW (charX T z - charX T z') ∂f₀
+    rw [h_push T hT_mem]
+    exact integral_map (h_aemeas T hT_mem)
+      (hgradW_cont.comp (continuous_const.sub continuous_id)).aestronglyMeasurable
+  exact h_cont_rhs.congr_of_eventuallyEq h_eq h_val_T
+
+/-- **Route 2 inner kernel for `glue_step` `h_cont_g`** (RIGHT / `Ici a`): the
+exact mirror of `flowConv_continuousWithinAt_Iic_seam`, but on `Set.Ici a` over a
+generic window `[a, b]` with the seam at the lower endpoint `a`.  Same proof shape;
+the only set-dependent swaps are `Iic T → Ici a`, `Icc_mem_nhdsLE → Icc_mem_nhdsGE`,
+and the window `[0, T] → [a, b]`.  Used for the RIGHT side of the seam at `T` where
+`charX` is the composed position flow `Z_s z = charX_g (s-T) (charX_prev T z, …)` and
+`μ s = spatialMarginal (g (s-T))` is its pushforward of `f₀`. -/
+lemma flowConv_continuousWithinAt_Ici_seam
+    {d : ℕ}
+    (gradW : PhysSpace d → PhysSpace d)
+    (L : NNReal) (hL : LipschitzWith L gradW)
+    (charX : ℝ → PhaseSpace d → PhysSpace d)
+    (f₀ : Measure (PhaseSpace d)) [IsProbabilityMeasure f₀]
+    (hf₀_int : Integrable (fun z : PhaseSpace d => ‖z‖) f₀)
+    {a b : ℝ} (hab : a < b)
+    (μ : ℝ → Measure (PhysSpace d))
+    (h_push : ∀ s ∈ Set.Icc a b,
+        μ s = Measure.map (fun z : PhaseSpace d => charX s z) f₀)
+    (h_aemeas : ∀ s ∈ Set.Icc a b,
+        AEMeasurable (fun z : PhaseSpace d => charX s z) f₀)
+    (h_charX_cont : ∀ z : PhaseSpace d,
+        ContinuousWithinAt (fun s => charX s z) (Set.Ici a) a)
+    (C_T : ℝ) (_hC_T_nn : 0 ≤ C_T)
+    (hC_T : ∀ s ∈ Set.Icc a b, ∀ z : PhaseSpace d, ‖charX s z‖ ≤ C_T * (‖z‖ + 1))
+    (z : PhaseSpace d) :
+    ContinuousWithinAt (fun s => convolveFunctionMeasure gradW (μ s) (charX s z))
+      (Set.Ici a) a := by
+  have h_nhd_R : Set.Icc a b ∈ nhdsWithin a (Set.Ici a) := Icc_mem_nhdsGE hab
+  have hgradW_cont : Continuous gradW := hL.continuous
+  have hL_nn : (0 : ℝ) ≤ (L : ℝ) := L.coe_nonneg
+  -- Pushforward rewrite of the convolution, eventually in s (on the window).
+  have h_eq : (fun s => convolveFunctionMeasure gradW (μ s) (charX s z))
+      =ᶠ[nhdsWithin a (Set.Ici a)]
+      (fun s => ∫ z', gradW (charX s z - charX s z') ∂f₀) := by
+    apply Filter.Eventually.mono h_nhd_R
+    intro s hs
+    change ∫ y, gradW (charX s z - y) ∂(μ s)
+        = ∫ z', gradW (charX s z - charX s z') ∂f₀
+    rw [h_push s hs]
+    exact integral_map (h_aemeas s hs)
+      (hgradW_cont.comp (continuous_const.sub continuous_id)).aestronglyMeasurable
+  -- The rewritten f₀-integral is continuous at a by dominated convergence.
+  have h_cont_rhs : ContinuousWithinAt
+      (fun s => ∫ z', gradW (charX s z - charX s z') ∂f₀) (Set.Ici a) a := by
+    apply continuousWithinAt_of_dominated
+      (bound := fun z' => ‖gradW 0‖ + (L : ℝ) * (C_T * (‖z‖ + 1))
+        + (L : ℝ) * (C_T * (‖z'‖ + 1)))
+    · -- AEStronglyMeasurable in z', eventually in s
+      apply Filter.Eventually.mono h_nhd_R
+      intro s hs
+      exact (hgradW_cont.measurable.comp_aemeasurable
+        (aemeasurable_const.sub (h_aemeas s hs))).aestronglyMeasurable
+    · -- pointwise dominator bound, eventually in s
+      apply Filter.Eventually.mono h_nhd_R
+      intro s hs
+      apply Filter.Eventually.of_forall
+      intro z'
+      have h1 : ‖gradW (charX s z - charX s z')‖
+          ≤ ‖gradW 0‖ + (L : ℝ) * ‖charX s z - charX s z'‖ := by
+        have hd := hL.dist_le_mul (charX s z - charX s z') 0
+        simp only [dist_eq_norm, sub_zero] at hd
+        have htri : ‖gradW (charX s z - charX s z')‖
+            ≤ ‖gradW 0‖ + ‖gradW (charX s z - charX s z') - gradW 0‖ := by
+          have := norm_add_le (gradW (charX s z - charX s z') - gradW 0) (gradW 0)
+          simp only [sub_add_cancel] at this; linarith
+        linarith
+      have h2 : ‖charX s z - charX s z'‖ ≤ ‖charX s z‖ + ‖charX s z'‖ := norm_sub_le _ _
+      have h3 : ‖charX s z‖ ≤ C_T * (‖z‖ + 1) := hC_T s hs z
+      have h4 : ‖charX s z'‖ ≤ C_T * (‖z'‖ + 1) := hC_T s hs z'
+      nlinarith [mul_le_mul_of_nonneg_left (h2.trans (add_le_add h3 h4)) hL_nn]
+    · -- integrability of the dominator
+      apply Integrable.add (integrable_const _)
+      exact ((hf₀_int.add (integrable_const (1 : ℝ))).const_mul C_T).const_mul (L : ℝ)
+    · -- pointwise continuity in s, a.e. z'
+      apply Filter.Eventually.of_forall
+      intro z'
+      have hcz : ContinuousWithinAt (fun s => charX s z) (Set.Ici a) a := h_charX_cont z
+      have hcz' : ContinuousWithinAt (fun s => charX s z') (Set.Ici a) a := h_charX_cont z'
+      exact hgradW_cont.continuousAt.comp_continuousWithinAt (hcz.sub hcz')
+  -- Bridge value at a and conclude.
+  have h_val_a : convolveFunctionMeasure gradW (μ a) (charX a z)
+      = ∫ z', gradW (charX a z - charX a z') ∂f₀ := by
+    have ha_mem : a ∈ Set.Icc a b := ⟨le_refl a, hab.le⟩
+    change ∫ y, gradW (charX a z - y) ∂(μ a)
+        = ∫ z', gradW (charX a z - charX a z') ∂f₀
+    rw [h_push a ha_mem]
+    exact integral_map (h_aemeas a ha_mem)
+      (hgradW_cont.comp (continuous_const.sub continuous_id)).aestronglyMeasurable
+  exact h_cont_rhs.congr_of_eventuallyEq h_eq h_val_a
+
+/-- gradW-kernel integrability on the spatial marginals of a finite-first-moment
+curve (window-generic over the curve `μ`).  The first-moment transfer to the
+marginal feeds `integrable_gradW_shift`. -/
+private lemma dobrushinFlow_marginal_gradW_integrable
+    {d : ℕ}
+    (gradW : PhysSpace d → PhysSpace d)
+    (L : NNReal) (hL : LipschitzWith L gradW)
+    (T : ℝ) (μ : ℝ → Measure (PhaseSpace d))
+    (hμ_mom : ∀ t ∈ Set.Icc (0 : ℝ) T, HasFiniteFirstMoment (μ t)) :
+    ∀ t ∈ Set.Icc (0 : ℝ) T, ∀ (x_pt : PhysSpace d),
+      Integrable (fun y => gradW (x_pt - y)) (spatialMarginal (μ t)) := by
+  intro t ht x_pt
+  have : IsProbabilityMeasure (μ t) := (hμ_mom t ht).1
+  have : IsProbabilityMeasure (spatialMarginal (μ t)) :=
+    (Measure.isProbabilityMeasure_map_iff measurable_fst.aemeasurable).mpr inferInstance
+  have h_y_int : Integrable (fun y : PhysSpace d => ‖y‖) (spatialMarginal (μ t)) := by
+    unfold spatialMarginal
+    rw [integrable_map_measure
+      (by exact (continuous_norm.measurable).aestronglyMeasurable)
+      measurable_fst.aemeasurable]
+    refine Integrable.mono' (hμ_mom t ht).2
+      ((continuous_norm.comp continuous_fst).aestronglyMeasurable)
+      (Filter.Eventually.of_forall fun z => ?_)
+    change |‖z.1‖| ≤ ‖z‖
+    rw [abs_of_nonneg (norm_nonneg _)]; exact norm_fst_le z
+  exact integrable_gradW_shift gradW L hL (spatialMarginal (μ t)) h_y_int x_pt
+
+/-- First-moment integrability transfers to the spatial marginal:
+`∫ ‖z‖ ∂μ < ∞` gives `∫ ‖y‖ ∂(spatialMarginal μ) < ∞`. -/
+private lemma vlasovGlue_marginal_norm_integrable
+    {d : ℕ}
+    (μ : Measure (PhaseSpace d)) (hμ : HasFiniteFirstMoment μ) :
+    Integrable (fun y : PhysSpace d => ‖y‖) (spatialMarginal μ) := by
+  have : IsProbabilityMeasure μ := hμ.1
+  unfold spatialMarginal
+  rw [integrable_map_measure
+    (by exact (continuous_norm.measurable).aestronglyMeasurable)
+    measurable_fst.aemeasurable]
+  refine Integrable.mono' hμ.2
+    ((continuous_norm.comp continuous_fst).aestronglyMeasurable)
+    (Filter.Eventually.of_forall fun z => ?_)
+  change |‖z.1‖| ≤ ‖z‖
+  rw [abs_of_nonneg (norm_nonneg _)]; exact norm_fst_le z
+
+/-- Continuity of the spatial-gradient component `gradXφ` of a smooth test
+function `φ` on phase space. -/
+private lemma vlasovGlue_gradXφ_continuous
+    {d : ℕ}
+    (φ : PhaseSpace d → ℝ) (hφ_smooth : ContDiff ℝ (⊤ : ℕ∞) φ)
+    (gradXφ : PhaseSpace d → PhysSpace d)
+    (hgradXφ : ∀ z : PhaseSpace d, gradXφ z = gradient (fun x => φ (x, z.2)) z.1) :
+    Continuous gradXφ := by
+  have hfderiv_X : ∀ z : PhaseSpace d,
+      fderiv ℝ (fun x => φ (x, z.2)) z.1 =
+      (fderiv ℝ φ z).comp (ContinuousLinearMap.inl ℝ (PhysSpace d) (PhysSpace d)) :=
+    fun z => by
+      have h1 : HasFDerivAt φ (fderiv ℝ φ z) z :=
+        (hφ_smooth.differentiable (by simp) z).hasFDerivAt
+      have h2 : HasFDerivAt (fun x : PhysSpace d => (x, z.2))
+          (ContinuousLinearMap.inl ℝ (PhysSpace d) (PhysSpace d)) z.1 :=
+        hasFDerivAt_prodMk_left z.1 z.2
+      exact (h1.comp z.1 h2).fderiv
+  have heqX : gradXφ = fun z => gradient (fun x => φ (x, z.2)) z.1 :=
+    funext hgradXφ
+  rw [heqX]
+  simp_rw [gradient, hfderiv_X]
+  exact (InnerProductSpace.toDual ℝ (PhysSpace d)).symm.continuous.comp
+    ((ContinuousLinearMap.isBoundedLinearMap_comp_right
+      (ContinuousLinearMap.inl ℝ (PhysSpace d) (PhysSpace d))).continuous.comp
+      (hφ_smooth.continuous_fderiv (by simp)))
+
+/-- Continuity of the velocity-gradient component `gradVφ` of a smooth test
+function `φ` on phase space. -/
+private lemma vlasovGlue_gradVφ_continuous
+    {d : ℕ}
+    (φ : PhaseSpace d → ℝ) (hφ_smooth : ContDiff ℝ (⊤ : ℕ∞) φ)
+    (gradVφ : PhaseSpace d → PhysSpace d)
+    (hgradVφ : ∀ z : PhaseSpace d, gradVφ z = gradient (fun v => φ (z.1, v)) z.2) :
+    Continuous gradVφ := by
+  have hfderiv_V : ∀ z : PhaseSpace d,
+      fderiv ℝ (fun v => φ (z.1, v)) z.2 =
+      (fderiv ℝ φ z).comp (ContinuousLinearMap.inr ℝ (PhysSpace d) (PhysSpace d)) :=
+    fun z => by
+      have h1 : HasFDerivAt φ (fderiv ℝ φ z) z :=
+        (hφ_smooth.differentiable (by simp) z).hasFDerivAt
+      have h2 : HasFDerivAt (fun v : PhysSpace d => (z.1, v))
+          (ContinuousLinearMap.inr ℝ (PhysSpace d) (PhysSpace d)) z.2 :=
+        hasFDerivAt_prodMk_right z.1 z.2
+      exact (h1.comp z.2 h2).fderiv
+  have heqV : gradVφ = fun z => gradient (fun v => φ (z.1, v)) z.2 :=
+    funext hgradVφ
+  rw [heqV]
+  simp_rw [gradient, hfderiv_V]
+  exact (InnerProductSpace.toDual ℝ (PhysSpace d)).symm.continuous.comp
+    ((ContinuousLinearMap.isBoundedLinearMap_comp_right
+      (ContinuousLinearMap.inr ℝ (PhysSpace d) (PhysSpace d))).continuous.comp
+      (hφ_smooth.continuous_fderiv (by simp)))
+
+/-- Uniform sup-bound on both gradient components of a compactly supported
+smooth test function: `‖∇_x φ‖, ‖∇_v φ‖ ≤ M_φ := sup ‖fderiv φ‖`. -/
+private lemma vlasovGlue_gradφ_bound
+    {d : ℕ}
+    (φ : PhaseSpace d → ℝ) (hφ_smooth : ContDiff ℝ (⊤ : ℕ∞) φ)
+    (hφ_compact : HasCompactSupport φ)
+    (gradXφ gradVφ : PhaseSpace d → PhysSpace d)
+    (hgradXφ : ∀ z : PhaseSpace d, gradXφ z = gradient (fun x => φ (x, z.2)) z.1)
+    (hgradVφ : ∀ z : PhaseSpace d, gradVφ z = gradient (fun v => φ (z.1, v)) z.2) :
+    ∃ M_φ : ℝ, (∀ z : PhaseSpace d, ‖gradXφ z‖ ≤ M_φ) ∧
+      (∀ z : PhaseSpace d, ‖gradVφ z‖ ≤ M_φ) := by
+  have hfderiv_cont : Continuous (fderiv ℝ φ) :=
+    hφ_smooth.continuous_fderiv (by norm_num)
+  have hfderiv_compact : HasCompactSupport (fderiv ℝ φ) :=
+    HasCompactSupport.fderiv (𝕜 := ℝ) hφ_compact
+  obtain ⟨M_φ, hM_φ⟩ := hfderiv_cont.bounded_above_of_compact_support hfderiv_compact
+  refine ⟨M_φ, fun z => ?_, fun z => ?_⟩
+  · have hfd : fderiv ℝ (fun x => φ (x, z.2)) z.1 =
+        (fderiv ℝ φ z).comp
+          (ContinuousLinearMap.inl ℝ (PhysSpace d) (PhysSpace d)) := by
+      have h1 : HasFDerivAt φ (fderiv ℝ φ z) z :=
+        (hφ_smooth.differentiable (by simp) z).hasFDerivAt
+      have h2 : HasFDerivAt (fun x : PhysSpace d => (x, z.2))
+          (ContinuousLinearMap.inl ℝ (PhysSpace d) (PhysSpace d)) z.1 :=
+        hasFDerivAt_prodMk_left z.1 z.2
+      exact (h1.comp z.1 h2).fderiv
+    rw [hgradXφ z, gradient, hfd,
+      (InnerProductSpace.toDual ℝ (PhysSpace d)).symm.norm_map]
+    refine le_trans (ContinuousLinearMap.opNorm_comp_le _ _) ?_
+    refine le_trans (mul_le_mul_of_nonneg_left
+      (ContinuousLinearMap.norm_inl_le_one (𝕜 := ℝ)
+        (E := PhysSpace d) (F := PhysSpace d)) (norm_nonneg _)) ?_
+    rw [mul_one]; exact hM_φ z
+  · have hfd : fderiv ℝ (fun v => φ (z.1, v)) z.2 =
+        (fderiv ℝ φ z).comp
+          (ContinuousLinearMap.inr ℝ (PhysSpace d) (PhysSpace d)) := by
+      have h1 : HasFDerivAt φ (fderiv ℝ φ z) z :=
+        (hφ_smooth.differentiable (by simp) z).hasFDerivAt
+      have h2 : HasFDerivAt (fun v : PhysSpace d => (z.1, v))
+          (ContinuousLinearMap.inr ℝ (PhysSpace d) (PhysSpace d)) z.2 :=
+        hasFDerivAt_prodMk_right z.1 z.2
+      exact (h1.comp z.2 h2).fderiv
+    rw [hgradVφ z, gradient, hfd,
+      (InnerProductSpace.toDual ℝ (PhysSpace d)).symm.norm_map]
+    refine le_trans (ContinuousLinearMap.opNorm_comp_le _ _) ?_
+    refine le_trans (mul_le_mul_of_nonneg_left
+      (ContinuousLinearMap.norm_inr_le_one (𝕜 := ℝ)
+        (E := PhysSpace d) (F := PhysSpace d)) (norm_nonneg _)) ?_
+    rw [mul_one]; exact hM_φ z
+
+/-- Convolution force bound from a first-moment envelope:
+`‖(gradW ⋆ ρ) x‖ ≤ ‖gradW 0‖ + L·‖x‖ + L·M` for a probability measure `ρ`
+with `∫ ‖y‖ ∂ρ ≤ M`. -/
+private lemma vlasovGlue_conv_force_bound
+    {d : ℕ}
+    (gradW : PhysSpace d → PhysSpace d)
+    (L : NNReal) (hL : LipschitzWith L gradW)
+    (ρ : Measure (PhysSpace d)) [IsProbabilityMeasure ρ]
+    (M : ℝ) (hM : ∫ y, ‖y‖ ∂ρ ≤ M)
+    (h_y_int : Integrable (fun y : PhysSpace d => ‖y‖) ρ)
+    (h_int : ∀ x : PhysSpace d, Integrable (fun y => gradW (x - y)) ρ)
+    (x : PhysSpace d) :
+    ‖convolveFunctionMeasure gradW ρ x‖
+      ≤ ‖gradW 0‖ + (L : ℝ) * ‖x‖ + (L : ℝ) * M := by
+  unfold convolveFunctionMeasure
+  have h_sub_int : Integrable (fun y => ‖x - y‖) ρ :=
+    Integrable.mono' ((integrable_const ‖x‖).add h_y_int)
+      ((aestronglyMeasurable_const (b := x)).sub aestronglyMeasurable_id |>.norm)
+      (Filter.Eventually.of_forall fun y => by
+        simp only [Real.norm_of_nonneg (norm_nonneg _)]; exact norm_sub_le x y)
+  have h_pt : ∀ y : PhysSpace d,
+      ‖gradW (x - y)‖ ≤ ‖gradW 0‖ + (L : ℝ) * ‖x - y‖ := by
+    intro y
+    have hd := hL.dist_le_mul (x - y) 0
+    simp only [dist_eq_norm, sub_zero] at hd
+    have h_tri : ‖gradW (x - y)‖ ≤ ‖gradW 0‖ + ‖gradW (x - y) - gradW 0‖ := by
+      have := norm_add_le (gradW (x - y) - gradW 0) (gradW 0)
+      simp only [sub_add_cancel] at this; linarith
+    linarith
+  have h_bnd_int :
+      Integrable (fun y => ‖gradW 0‖ + (L : ℝ) * ‖x - y‖) ρ :=
+    (integrable_const _).add (h_sub_int.const_mul _)
+  calc ‖∫ y, gradW (x - y) ∂ρ‖
+      ≤ ∫ y, ‖gradW (x - y)‖ ∂ρ :=
+        norm_integral_le_integral_norm _
+    _ ≤ ∫ y, (‖gradW 0‖ + (L : ℝ) * ‖x - y‖) ∂ρ :=
+        integral_mono (h_int x).norm h_bnd_int h_pt
+    _ = ‖gradW 0‖ + (L : ℝ) * ∫ y, ‖x - y‖ ∂ρ := by
+        rw [integral_add (integrable_const _) (h_sub_int.const_mul _)]
+        simp [integral_const, measureReal_def, measure_univ, integral_const_mul]
+    _ ≤ ‖gradW 0‖ + (L : ℝ) * ‖x‖ + (L : ℝ) * M := by
+        have h_int_le : ∫ y, ‖x - y‖ ∂ρ ≤ ‖x‖ + M := by
+          calc ∫ y, ‖x - y‖ ∂ρ
+              ≤ ∫ y, (‖x‖ + ‖y‖) ∂ρ :=
+                integral_mono h_sub_int ((integrable_const _).add h_y_int)
+                  (fun y => norm_sub_le x y)
+            _ = ‖x‖ + ∫ y, ‖y‖ ∂ρ := by
+                rw [integral_add (integrable_const _) h_y_int]
+                simp [integral_const, measureReal_def, measure_univ]
+            _ ≤ ‖x‖ + M := by linarith
+        nlinarith [mul_le_mul_of_nonneg_left h_int_le L.coe_nonneg]
+
+/-- Window growth bound for a characteristic flow given boundary regularity:
+clamps the marginal curve into `[0, T]` (for the universal probability
+instance), derives the interior `IsCharacteristicFlowOn` from the boundary
+bundle, and applies `characteristicFlow_boundary_regularity` +
+`flow_distance_growth_bound_on`.  Returns the linear growth constant `C`
+together with per-`z` window continuity of the joint flow curve. -/
+private lemma vlasovGlue_flow_growthBound
+    {d : ℕ}
+    (gradW : PhysSpace d → PhysSpace d)
+    (L : NNReal) (hL : LipschitzWith L gradW)
+    (μ : ℝ → Measure (PhaseSpace d))
+    (charX charV : ℝ → PhaseSpace d → PhysSpace d)
+    (T : ℝ) (hT_pos : 0 < T)
+    (hμ_mom : ∀ t ∈ Set.Icc (0 : ℝ) T, HasFiniteFirstMoment (μ t))
+    (hM : ∃ M : ℝ, 0 ≤ M ∧
+        ∀ t ∈ Set.Icc (0 : ℝ) T, ∫ y, ‖y‖ ∂(spatialMarginal (μ t)) ≤ M)
+    (h_ic : ∀ z : PhaseSpace d, charX 0 z = z.1 ∧ charV 0 z = z.2)
+    (h_boundary : ∀ (z : PhaseSpace d) (t : ℝ), t ∈ Set.Icc (0 : ℝ) T →
+        HasDerivWithinAt (fun s => charX s z) (charV t z) (Set.Icc 0 T) t ∧
+        HasDerivWithinAt (fun s => charV s z)
+          (-(convolveFunctionMeasure gradW (spatialMarginal (μ t)) (charX t z)))
+          (Set.Icc 0 T) t) :
+    ∃ C : ℝ, 0 ≤ C ∧
+      (∀ s ∈ Set.Icc (0 : ℝ) T, ∀ z : PhaseSpace d,
+        ‖(charX s z, charV s z)‖ ≤ C * (‖z‖ + 1)) ∧
+      (∀ z : PhaseSpace d,
+        ContinuousOn (fun s => (charX s z, charV s z)) (Set.Icc (0 : ℝ) T)) := by
+  obtain ⟨M, hM_nn, hM_bd⟩ := hM
+  set clampT : ℝ → ℝ := fun t => max 0 (min t T) with hclampT_def
+  have hclampT_mem : ∀ t, clampT t ∈ Set.Icc (0 : ℝ) T := by
+    intro t
+    simp only [hclampT_def, Set.mem_Icc]
+    exact ⟨le_max_left _ _, max_le hT_pos.le (min_le_right _ _)⟩
+  have hclampT_id : ∀ t ∈ Set.Icc (0 : ℝ) T, clampT t = t := by
+    intro t ht
+    simp only [hclampT_def, min_eq_left ht.2, max_eq_right ht.1]
+  set ρc : ℝ → Measure (PhysSpace d) :=
+    fun t => spatialMarginal (μ (clampT t)) with hρc_def
+  have hρc_isProb : ∀ t, IsProbabilityMeasure (ρc t) := by
+    intro t
+    have : IsProbabilityMeasure (μ (clampT t)) :=
+      (hμ_mom (clampT t) (hclampT_mem t)).1
+    exact (Measure.isProbabilityMeasure_map_iff measurable_fst.aemeasurable).mpr inferInstance
+  have hM_ρ : ∀ t ∈ Set.Icc (0 : ℝ) T, ∫ y, ‖y‖ ∂(ρc t) ≤ M := by
+    intro t _ht
+    rw [hρc_def]
+    exact hM_bd (clampT t) (hclampT_mem t)
+  have h_y_int_ρc : ∀ t ∈ Set.Icc (0 : ℝ) T,
+      Integrable (fun y : PhysSpace d => ‖y‖) (ρc t) := by
+    intro t ht
+    have h_eq : ρc t = spatialMarginal (μ t) := by
+      simp only [hρc_def, hclampT_id t ht]
+    rw [h_eq]
+    exact vlasovGlue_marginal_norm_integrable (μ t) (hμ_mom t ht)
+  have h_int_ρc : ∀ t (x : PhysSpace d),
+      Integrable (fun y => gradW (x - y)) (ρc t) :=
+    fun t x => by
+      have := dobrushinFlow_marginal_gradW_integrable gradW L hL T μ hμ_mom
+        (clampT t) (hclampT_mem t) x
+      simpa only [hρc_def] using this
+  have h_bdry_ρc : ∀ z : PhaseSpace d, ∀ t ∈ Set.Icc (0 : ℝ) T,
+      HasDerivWithinAt (fun s => charX s z) (charV t z) (Set.Icc 0 T) t ∧
+      HasDerivWithinAt (fun s => charV s z)
+        (-(convolveFunctionMeasure gradW (ρc t) (charX t z)))
+        (Set.Icc 0 T) t := by
+    intro z t ht
+    have h_eq : ρc t = spatialMarginal (μ t) := by
+      simp only [hρc_def, hclampT_id t ht]
+    rw [h_eq]
+    exact h_boundary z t ht
+  have h_flow_ρc : IsCharacteristicFlowOn gradW ρc charX charV
+      (Set.Ioo 0 T) Set.univ := by
+    refine ⟨fun z _ => h_ic z, fun t ht z _ => ?_, fun t ht z _ => ?_⟩
+    · have ht_Icc : t ∈ Set.Icc (0 : ℝ) T := ⟨ht.1.le, ht.2.le⟩
+      exact ((h_bdry_ρc z t ht_Icc).1).hasDerivAt (Icc_mem_nhds ht.1 ht.2)
+    · have ht_Icc : t ∈ Set.Icc (0 : ℝ) T := ⟨ht.1.le, ht.2.le⟩
+      exact ((h_bdry_ρc z t ht_Icc).2).hasDerivAt (Icc_mem_nhds ht.1 ht.2)
+  obtain ⟨h_init_ρc, h_cont_Icc_ρc, h_deriv_Ico_ρc⟩ :=
+    characteristicFlow_boundary_regularity gradW ρc charX charV T hT_pos.le
+      h_flow_ρc h_bdry_ρc
+  obtain ⟨C, hC_nn, hC_pair⟩ :=
+    flow_distance_growth_bound_on gradW L hL ρc charX charV T hT_pos.le
+      h_init_ρc h_cont_Icc_ρc h_deriv_Ico_ρc M hM_nn hM_ρ h_y_int_ρc h_int_ρc
+  exact ⟨C, hC_nn, hC_pair, h_cont_Icc_ρc⟩
+
+/-- Generic seam continuity of the force-integral functional
+`s ↦ ∫ ⟪V s z, ∇ₓφ(Φ s z)⟫ − ⟪(gradW ⋆ ρ s)(X s z), ∇ᵥφ(Φ s z)⟫ ∂f₀`
+at a window endpoint, by dominated convergence.  `S` is the one-sided
+neighborhood filter set (`Iic T` or `Ici T`), `W` the compact window
+(`Icc 0 T` or `Icc T (T+T₀)`) carrying the uniform data: a linear growth
+bound `C` on the flow, a moment envelope `M` on the marginal curve `ρ`, and
+kernel integrability.  Instantiated on the LEFT by `f_prev`'s window flow and
+on the RIGHT by the composed flow off `g`. -/
+private lemma vlasovGlue_seam_forceIntegral_cont
+    {d : ℕ}
+    (gradW : PhysSpace d → PhysSpace d)
+    (L : NNReal) (hL : LipschitzWith L gradW)
+    (f₀ : Measure (PhaseSpace d)) [IsProbabilityMeasure f₀]
+    (hf₀_int : Integrable (fun z : PhaseSpace d => ‖z‖) f₀)
+    (gradXφ gradVφ : PhaseSpace d → PhysSpace d)
+    (hgradXφ_cont : Continuous gradXφ) (hgradVφ_cont : Continuous gradVφ)
+    (M_φ : ℝ)
+    (hgradXφ_bd : ∀ z : PhaseSpace d, ‖gradXφ z‖ ≤ M_φ)
+    (hgradVφ_bd : ∀ z : PhaseSpace d, ‖gradVφ z‖ ≤ M_φ)
+    (ρ : ℝ → Measure (PhysSpace d))
+    (X V : ℝ → PhaseSpace d → PhysSpace d)
+    (T₀ : ℝ) (S : Set ℝ) (W : Set ℝ)
+    (hW_nhd : W ∈ nhdsWithin T₀ S)
+    (hρ_prob : ∀ s ∈ W, IsProbabilityMeasure (ρ s))
+    (M : ℝ) (hM : ∀ s ∈ W, ∫ y, ‖y‖ ∂(ρ s) ≤ M)
+    (h_y_int : ∀ s ∈ W, Integrable (fun y : PhysSpace d => ‖y‖) (ρ s))
+    (h_int : ∀ s ∈ W, ∀ x : PhysSpace d, Integrable (fun y => gradW (x - y)) (ρ s))
+    (C : ℝ)
+    (hC_pair : ∀ s ∈ W, ∀ z : PhaseSpace d, ‖(X s z, V s z)‖ ≤ C * (‖z‖ + 1))
+    (h_aemeas : ∀ s ∈ W, AEMeasurable (fun z : PhaseSpace d => (X s z, V s z)) f₀)
+    (h_X_cont : ∀ z : PhaseSpace d, ContinuousWithinAt (fun s => X s z) S T₀)
+    (h_V_cont : ∀ z : PhaseSpace d, ContinuousWithinAt (fun s => V s z) S T₀)
+    (h_conv_cwn : ∀ z : PhaseSpace d, ContinuousWithinAt
+        (fun s => convolveFunctionMeasure gradW (ρ s) (X s z)) S T₀) :
+    ContinuousWithinAt
+      (fun s => ∫ z, (@inner ℝ (PhysSpace d) _ (V s z) (gradXφ (X s z, V s z)) -
+          @inner ℝ (PhysSpace d) _
+            (convolveFunctionMeasure gradW (ρ s) (X s z))
+            (gradVφ (X s z, V s z))) ∂f₀) S T₀ := by
+  set bound_fn : PhaseSpace d → ℝ := fun z =>
+    M_φ * (C * (‖z‖ + 1))
+    + (‖gradW 0‖ + (L : ℝ) * (C * (‖z‖ + 1)) + (L : ℝ) * M) * M_φ
+    with hbound_def
+  have hbound_int : Integrable bound_fn f₀ := by
+    have ha : Integrable
+        (fun z : PhaseSpace d =>
+          (M_φ * C + L * M_φ * C) * ‖z‖
+          + (M_φ * C + (‖gradW 0‖ + L * C + L * M) * M_φ)) f₀ :=
+      (hf₀_int.const_mul _).add (integrable_const _)
+    refine ha.congr (Filter.Eventually.of_forall fun z => ?_)
+    simp only [hbound_def]; ring
+  have h_conv_force : ∀ s ∈ W, ∀ x : PhysSpace d,
+      ‖convolveFunctionMeasure gradW (ρ s) x‖
+        ≤ ‖gradW 0‖ + (L : ℝ) * ‖x‖ + (L : ℝ) * M := by
+    intro s hs x
+    have := hρ_prob s hs
+    exact vlasovGlue_conv_force_bound gradW L hL (ρ s) M (hM s hs)
+      (h_y_int s hs) (h_int s hs) x
+  have hB : ∀ s ∈ W, ∀ z : PhaseSpace d,
+      ‖@inner ℝ (PhysSpace d) _ (V s z) (gradXφ (X s z, V s z)) -
+          @inner ℝ (PhysSpace d) _
+            (convolveFunctionMeasure gradW (ρ s) (X s z))
+            (gradVφ (X s z, V s z))‖ ≤ bound_fn z := by
+    intro s hs z
+    have hV : ‖V s z‖ ≤ C * (‖z‖ + 1) :=
+      le_trans (norm_snd_le (X s z, V s z)) (hC_pair s hs z)
+    have hX : ‖X s z‖ ≤ C * (‖z‖ + 1) :=
+      le_trans (norm_fst_le (X s z, V s z)) (hC_pair s hs z)
+    have ht1 : ‖@inner ℝ (PhysSpace d) _ (V s z) (gradXφ (X s z, V s z))‖
+        ≤ M_φ * (C * (‖z‖ + 1)) := by
+      refine le_trans (norm_inner_le_norm _ _) ?_
+      have := mul_le_mul hV (hgradXφ_bd (X s z, V s z))
+        (norm_nonneg _) (le_trans (norm_nonneg _) hV)
+      calc ‖V s z‖ * ‖gradXφ (X s z, V s z)‖
+          ≤ (C * (‖z‖ + 1)) * M_φ := this
+        _ = M_φ * (C * (‖z‖ + 1)) := by ring
+    have ht2 : ‖@inner ℝ (PhysSpace d) _
+          (convolveFunctionMeasure gradW (ρ s) (X s z))
+          (gradVφ (X s z, V s z))‖
+        ≤ (‖gradW 0‖ + (L : ℝ) * (C * (‖z‖ + 1)) + (L : ℝ) * M) * M_φ := by
+      refine le_trans (norm_inner_le_norm _ _) ?_
+      have hc : ‖convolveFunctionMeasure gradW (ρ s) (X s z)‖
+          ≤ ‖gradW 0‖ + (L : ℝ) * (C * (‖z‖ + 1)) + (L : ℝ) * M := by
+        refine le_trans (h_conv_force s hs (X s z)) ?_
+        have := mul_le_mul_of_nonneg_left hX L.coe_nonneg
+        linarith
+      have hcnn : 0 ≤ ‖gradW 0‖ + (L : ℝ) * (C * (‖z‖ + 1)) + (L : ℝ) * M :=
+        le_trans (norm_nonneg _) hc
+      exact mul_le_mul hc (hgradVφ_bd (X s z, V s z)) (norm_nonneg _) hcnn
+    calc ‖_ - _‖
+        ≤ ‖@inner ℝ (PhysSpace d) _ (V s z) (gradXφ (X s z, V s z))‖
+          + ‖@inner ℝ (PhysSpace d) _
+              (convolveFunctionMeasure gradW (ρ s) (X s z))
+              (gradVφ (X s z, V s z))‖ := norm_sub_le _ _
+      _ ≤ bound_fn z := by simp only [hbound_def]; linarith
+  apply continuousWithinAt_of_dominated (bound := bound_fn)
+  · -- AEStronglyMeasurable in z, eventually in s
+    apply Filter.Eventually.mono hW_nhd
+    intro s hs
+    have h_aem_pair := h_aemeas s hs
+    have h_aem_X : AEMeasurable (fun z : PhaseSpace d => X s z) f₀ :=
+      measurable_fst.comp_aemeasurable h_aem_pair
+    have h_aem_V : AEMeasurable (fun z : PhaseSpace d => V s z) f₀ :=
+      measurable_snd.comp_aemeasurable h_aem_pair
+    have h1 : AEStronglyMeasurable
+        (fun z : PhaseSpace d => @inner ℝ (PhysSpace d) _ (V s z)
+          (gradXφ (X s z, V s z))) f₀ := by
+      have hg : AEMeasurable (fun z : PhaseSpace d => gradXφ (X s z, V s z)) f₀ :=
+        hgradXφ_cont.measurable.comp_aemeasurable (h_aem_X.prodMk h_aem_V)
+      exact (continuous_inner.measurable.comp_aemeasurable
+        (h_aem_V.prodMk hg)).aestronglyMeasurable
+    have h2 : AEStronglyMeasurable
+        (fun z : PhaseSpace d => @inner ℝ (PhysSpace d) _
+          (convolveFunctionMeasure gradW (ρ s) (X s z))
+          (gradVφ (X s z, V s z))) f₀ := by
+      have hconv_aem : AEMeasurable
+          (fun z : PhaseSpace d => convolveFunctionMeasure gradW (ρ s) (X s z)) f₀ := by
+        have hconv_cont' : Continuous (fun x : PhysSpace d =>
+            convolveFunctionMeasure gradW (ρ s) x) := by
+          have := hρ_prob s hs
+          exact (convolveFunctionMeasure_lipschitz_in_x gradW L hL
+            (ρ s) (h_int s hs)).continuous
+        exact hconv_cont'.measurable.comp_aemeasurable h_aem_X
+      have hg : AEMeasurable (fun z : PhaseSpace d => gradVφ (X s z, V s z)) f₀ :=
+        hgradVφ_cont.measurable.comp_aemeasurable (h_aem_X.prodMk h_aem_V)
+      exact (continuous_inner.measurable.comp_aemeasurable
+        (hconv_aem.prodMk hg)).aestronglyMeasurable
+    exact h1.sub h2
+  · -- dominator bound, eventually in s
+    apply Filter.Eventually.mono hW_nhd
+    intro s hs
+    exact Filter.Eventually.of_forall fun z => hB s hs z
+  · exact hbound_int
+  · -- pointwise continuity in s, for every z
+    apply Filter.Eventually.of_forall
+    intro z
+    have h_pair_cwn : ContinuousWithinAt (fun s => (X s z, V s z)) S T₀ :=
+      (h_X_cont z).prodMk (h_V_cont z)
+    have h_gX_cwn : ContinuousWithinAt
+        (fun s => gradXφ (X s z, V s z)) S T₀ :=
+      hgradXφ_cont.continuousAt.comp_continuousWithinAt h_pair_cwn
+    have h_gV_cwn : ContinuousWithinAt
+        (fun s => gradVφ (X s z, V s z)) S T₀ :=
+      hgradVφ_cont.continuousAt.comp_continuousWithinAt h_pair_cwn
+    have h_term1 : ContinuousWithinAt
+        (fun s => @inner ℝ (PhysSpace d) _ (V s z)
+          (gradXφ (X s z, V s z))) S T₀ :=
+      (h_V_cont z).inner h_gX_cwn
+    have h_term2 : ContinuousWithinAt
+        (fun s => @inner ℝ (PhysSpace d) _
+          (convolveFunctionMeasure gradW (ρ s) (X s z))
+          (gradVφ (X s z, V s z))) S T₀ :=
+      (h_conv_cwn z).inner h_gV_cwn
+    exact h_term1.sub h_term2
+
+/-- LEFT seam continuity of the force-integral functional at `T`: on `Iic T`
+the glued solution agrees with `f_prev` (via `hf_next_le`), whose window
+pushforward representation reduces the claim to the generic seam DCT lemma
+`vlasovGlue_seam_forceIntegral_cont` on `f_prev`'s window flow. -/
+private lemma vlasovGlue_seam_contLeft
+    {d : ℕ}
+    (gradW : PhysSpace d → PhysSpace d)
+    (L : NNReal) (hL : LipschitzWith L gradW)
+    (f₀ : Measure (PhaseSpace d)) [IsProbabilityMeasure f₀]
+    (hf₀_int : Integrable (fun z : PhaseSpace d => ‖z‖) f₀)
+    {T : ℝ} (hT_pos : 0 < T)
+    (f_prev : ℝ → Measure (PhaseSpace d))
+    (h_prev_init : f_prev 0 = f₀)
+    (h_prev_mom : ∀ t ∈ Set.Icc (0 : ℝ) T, HasFiniteFirstMoment (f_prev t))
+    (hM_prev : ∃ M : ℝ, 0 ≤ M ∧
+        ∀ t ∈ Set.Icc (0 : ℝ) T, ∫ y, ‖y‖ ∂(spatialMarginal (f_prev t)) ≤ M)
+    (charX_prev charV_prev : ℝ → PhaseSpace d → PhysSpace d)
+    (h_prev_push : ∀ t ∈ Set.Icc (0 : ℝ) T,
+        f_prev t =
+          Measure.map (fun z : PhaseSpace d => (charX_prev t z, charV_prev t z)) (f_prev 0))
+    (h_prev_aemeas : ∀ s ∈ Set.Icc (0 : ℝ) T,
+        AEMeasurable (fun z : PhaseSpace d => (charX_prev s z, charV_prev s z)) (f_prev 0))
+    (h_prev_boundary : ∀ (z : PhaseSpace d) (t : ℝ), t ∈ Set.Icc (0 : ℝ) T →
+        HasDerivWithinAt (fun s => charX_prev s z) (charV_prev t z) (Set.Icc 0 T) t ∧
+        HasDerivWithinAt (fun s => charV_prev s z)
+          (-(convolveFunctionMeasure gradW (spatialMarginal (f_prev t)) (charX_prev t z)))
+          (Set.Icc 0 T) t)
+    (h_prev_ic : ∀ z : PhaseSpace d, charX_prev 0 z = z.1 ∧ charV_prev 0 z = z.2)
+    (f_next : ℝ → Measure (PhaseSpace d))
+    (hf_next_le : ∀ s, s ≤ T → f_next s = f_prev s)
+    (φ : PhaseSpace d → ℝ)
+    (hφ_smooth : ContDiff ℝ (⊤ : ℕ∞) φ) (hφ_compact : HasCompactSupport φ)
+    (gradXφ gradVφ : PhaseSpace d → PhysSpace d)
+    (hgradXφ : ∀ z : PhaseSpace d, gradXφ z = gradient (fun x => φ (x, z.2)) z.1)
+    (hgradVφ : ∀ z : PhaseSpace d, gradVφ z = gradient (fun v => φ (z.1, v)) z.2) :
+    ContinuousWithinAt
+      (fun s => ∫ z, (@inner ℝ (PhysSpace d) _ z.2 (gradXφ z) -
+              @inner ℝ (PhysSpace d) _
+                (convolveFunctionMeasure gradW (spatialMarginal (f_next s)) z.1)
+                (gradVφ z)) ∂(f_next s)) (Set.Iic T) T := by
+  have h_nhd_L : Set.Icc (0 : ℝ) T ∈ nhdsWithin T (Set.Iic T) :=
+    Icc_mem_nhdsLE hT_pos
+  have hgradXφ_cont : Continuous gradXφ :=
+    vlasovGlue_gradXφ_continuous φ hφ_smooth gradXφ hgradXφ
+  have hgradVφ_cont : Continuous gradVφ :=
+    vlasovGlue_gradVφ_continuous φ hφ_smooth gradVφ hgradVφ
+  have h_int_marg := dobrushinFlow_marginal_gradW_integrable gradW L hL T
+    f_prev h_prev_mom
+  have h_push_marg : ∀ s ∈ Set.Icc (0 : ℝ) T,
+      spatialMarginal (f_prev s)
+        = Measure.map (fun z : PhaseSpace d => charX_prev s z) f₀ := by
+    intro s hs
+    have h_pair_aem : AEMeasurable
+        (fun z : PhaseSpace d => (charX_prev s z, charV_prev s z)) f₀ :=
+      h_prev_init ▸ h_prev_aemeas s hs
+    unfold spatialMarginal
+    rw [h_prev_push s hs, h_prev_init,
+        AEMeasurable.map_map_of_aemeasurable measurable_fst.aemeasurable h_pair_aem]
+    rfl
+  have h_aemeas_marg : ∀ s ∈ Set.Icc (0 : ℝ) T,
+      AEMeasurable (fun z : PhaseSpace d => charX_prev s z) f₀ := by
+    intro s hs
+    have h_pair_aem : AEMeasurable
+        (fun z : PhaseSpace d => (charX_prev s z, charV_prev s z)) f₀ :=
+      h_prev_init ▸ h_prev_aemeas s hs
+    exact measurable_fst.comp_aemeasurable h_pair_aem
+  obtain ⟨M_ρ, hM_ρ_nn, hM_ρ⟩ := hM_prev
+  have h_y_int_marg : ∀ t ∈ Set.Icc (0 : ℝ) T,
+      Integrable (fun y : PhysSpace d => ‖y‖) (spatialMarginal (f_prev t)) :=
+    fun t ht => vlasovGlue_marginal_norm_integrable (f_prev t) (h_prev_mom t ht)
+  obtain ⟨C_T, hC_T_nn, hC_T_pair, h_cont_Icc_prev⟩ :=
+    vlasovGlue_flow_growthBound gradW L hL f_prev charX_prev charV_prev
+      T hT_pos h_prev_mom ⟨M_ρ, hM_ρ_nn, hM_ρ⟩ h_prev_ic h_prev_boundary
+  have hC_T : ∀ s ∈ Set.Icc (0 : ℝ) T, ∀ z : PhaseSpace d,
+      ‖charX_prev s z‖ ≤ C_T * (‖z‖ + 1) := by
+    intro s hs z
+    exact le_trans (norm_fst_le (charX_prev s z, charV_prev s z))
+      (hC_T_pair s hs z)
+  have h_conv_z_cont : ∀ s ∈ Set.Icc (0 : ℝ) T,
+      Continuous (fun z : PhaseSpace d =>
+        convolveFunctionMeasure gradW (spatialMarginal (f_prev s)) z.1) := by
+    intro s hs
+    have : IsProbabilityMeasure (f_prev s) := (h_prev_mom s hs).1
+    have : IsProbabilityMeasure (spatialMarginal (f_prev s)) :=
+      (Measure.isProbabilityMeasure_map_iff measurable_fst.aemeasurable).mpr inferInstance
+    exact (convolveFunctionMeasure_lipschitz_in_x gradW L hL
+      (spatialMarginal (f_prev s)) (h_int_marg s hs)).continuous.comp continuous_fst
+  have h_integrand_cont : ∀ s ∈ Set.Icc (0 : ℝ) T,
+      Continuous (fun z : PhaseSpace d =>
+        @inner ℝ (PhysSpace d) _ z.2 (gradXφ z) -
+        @inner ℝ (PhysSpace d) _
+          (convolveFunctionMeasure gradW (spatialMarginal (f_prev s)) z.1)
+          (gradVφ z)) := by
+    intro s hs
+    exact (continuous_snd.inner hgradXφ_cont).sub
+      ((h_conv_z_cont s hs).inner hgradVφ_cont)
+  have h_eq_L : (fun s => ∫ z, (@inner ℝ (PhysSpace d) _ z.2 (gradXφ z) -
+          @inner ℝ (PhysSpace d) _
+            (convolveFunctionMeasure gradW (spatialMarginal (f_next s)) z.1)
+            (gradVφ z)) ∂(f_next s))
+      =ᶠ[nhdsWithin T (Set.Iic T)]
+      (fun s => ∫ z, (@inner ℝ (PhysSpace d) _ (charV_prev s z)
+            (gradXφ (charX_prev s z, charV_prev s z)) -
+          @inner ℝ (PhysSpace d) _
+            (convolveFunctionMeasure gradW (spatialMarginal (f_prev s))
+              (charX_prev s z))
+            (gradVφ (charX_prev s z, charV_prev s z))) ∂f₀) := by
+    apply Filter.Eventually.mono h_nhd_L
+    intro s hs
+    have h_fnext : f_next s = f_prev s := hf_next_le s hs.2
+    have h_marg : spatialMarginal (f_next s) = spatialMarginal (f_prev s) :=
+      congrArg spatialMarginal h_fnext
+    have h_aemeas_f₀ : AEMeasurable
+        (fun z : PhaseSpace d => (charX_prev s z, charV_prev s z)) f₀ :=
+      h_prev_init ▸ h_prev_aemeas s hs
+    change (∫ z, (@inner ℝ (PhysSpace d) _ z.2 (gradXφ z) -
+            @inner ℝ (PhysSpace d) _
+              (convolveFunctionMeasure gradW (spatialMarginal (f_next s)) z.1)
+              (gradVφ z)) ∂(f_next s))
+        = ∫ z, (@inner ℝ (PhysSpace d) _ (charV_prev s z)
+              (gradXφ (charX_prev s z, charV_prev s z)) -
+            @inner ℝ (PhysSpace d) _
+              (convolveFunctionMeasure gradW (spatialMarginal (f_prev s))
+                (charX_prev s z))
+              (gradVφ (charX_prev s z, charV_prev s z))) ∂f₀
+    have h_meq : f_next s
+        = Measure.map
+            (fun z : PhaseSpace d => (charX_prev s z, charV_prev s z)) f₀ := by
+      rw [h_fnext, h_prev_push s hs, h_prev_init]
+    rw [h_marg, h_meq,
+        integral_map h_aemeas_f₀
+          (h_integrand_cont s hs).aestronglyMeasurable]
+  obtain ⟨M_φ, hgradXφ_bd, hgradVφ_bd⟩ :=
+    vlasovGlue_gradφ_bound φ hφ_smooth hφ_compact gradXφ gradVφ hgradXφ hgradVφ
+  have h_X_cont : ∀ z : PhaseSpace d,
+      ContinuousWithinAt (fun s => charX_prev s z) (Set.Iic T) T := fun z =>
+    ((h_prev_boundary z T
+        ⟨hT_pos.le, le_refl T⟩).1.continuousWithinAt).mono_of_mem_nhdsWithin h_nhd_L
+  have h_V_cont : ∀ z : PhaseSpace d,
+      ContinuousWithinAt (fun s => charV_prev s z) (Set.Iic T) T := fun z =>
+    ((h_prev_boundary z T
+        ⟨hT_pos.le, le_refl T⟩).2.continuousWithinAt).mono_of_mem_nhdsWithin h_nhd_L
+  have h_conv_cwn : ∀ z : PhaseSpace d, ContinuousWithinAt
+      (fun s => convolveFunctionMeasure gradW (spatialMarginal (f_prev s))
+        (charX_prev s z)) (Set.Iic T) T := fun z =>
+    flowConv_continuousWithinAt_Iic_seam gradW L hL charX_prev f₀
+      hf₀_int hT_pos (fun s => spatialMarginal (f_prev s))
+      h_push_marg h_aemeas_marg
+      (fun z' => (h_cont_Icc_prev z').continuousWithinAt
+        (Set.right_mem_Icc.mpr hT_pos.le) |>.fst) C_T hC_T_nn hC_T z
+  have h_cont_pf : ContinuousWithinAt
+      (fun s => ∫ z, (@inner ℝ (PhysSpace d) _ (charV_prev s z)
+            (gradXφ (charX_prev s z, charV_prev s z)) -
+          @inner ℝ (PhysSpace d) _
+            (convolveFunctionMeasure gradW (spatialMarginal (f_prev s))
+              (charX_prev s z))
+            (gradVφ (charX_prev s z, charV_prev s z))) ∂f₀)
+      (Set.Iic T) T :=
+    vlasovGlue_seam_forceIntegral_cont gradW L hL f₀ hf₀_int gradXφ gradVφ
+      hgradXφ_cont hgradVφ_cont M_φ hgradXφ_bd hgradVφ_bd
+      (fun s => spatialMarginal (f_prev s)) charX_prev charV_prev
+      T (Set.Iic T) (Set.Icc 0 T) h_nhd_L
+      (fun s hs => by
+        have : IsProbabilityMeasure (f_prev s) := (h_prev_mom s hs).1
+        exact (Measure.isProbabilityMeasure_map_iff measurable_fst.aemeasurable).mpr inferInstance)
+      M_ρ hM_ρ h_y_int_marg h_int_marg C_T hC_T_pair
+      (fun s hs => h_prev_init ▸ h_prev_aemeas s hs)
+      h_X_cont h_V_cont h_conv_cwn
+  have h_val_T : (∫ z, (@inner ℝ (PhysSpace d) _ z.2 (gradXφ z) -
+          @inner ℝ (PhysSpace d) _
+            (convolveFunctionMeasure gradW (spatialMarginal (f_next T)) z.1)
+            (gradVφ z)) ∂(f_next T))
+      = ∫ z, (@inner ℝ (PhysSpace d) _ (charV_prev T z)
+            (gradXφ (charX_prev T z, charV_prev T z)) -
+          @inner ℝ (PhysSpace d) _
+            (convolveFunctionMeasure gradW (spatialMarginal (f_prev T))
+              (charX_prev T z))
+            (gradVφ (charX_prev T z, charV_prev T z))) ∂f₀ := by
+    have hT_Icc : T ∈ Set.Icc (0 : ℝ) T := ⟨hT_pos.le, le_refl T⟩
+    have h_fnext_T : f_next T = f_prev T := hf_next_le T (le_refl T)
+    have h_marg : spatialMarginal (f_next T) = spatialMarginal (f_prev T) :=
+      congrArg spatialMarginal h_fnext_T
+    have h_aemeas_f₀_T : AEMeasurable
+        (fun z : PhaseSpace d => (charX_prev T z, charV_prev T z)) f₀ :=
+      h_prev_init ▸ h_prev_aemeas T hT_Icc
+    have h_meq : f_next T
+        = Measure.map
+            (fun z : PhaseSpace d => (charX_prev T z, charV_prev T z)) f₀ := by
+      rw [h_fnext_T, h_prev_push T hT_Icc, h_prev_init]
+    rw [h_marg, h_meq,
+        integral_map h_aemeas_f₀_T (h_integrand_cont T hT_Icc).aestronglyMeasurable]
+  exact h_cont_pf.congr_of_eventuallyEq h_eq_L h_val_T
+
+/-- A shifted flow curve `s ↦ Φ (s − T) w` is continuous within `Ici T` at `T`
+when the unshifted curve has a one-sided derivative at `0` on `[0, T_0]`. -/
+private lemma vlasovGlue_shifted_flow_contWithin
+    {d : ℕ}
+    (charW : ℝ → PhaseSpace d → PhysSpace d) (w : PhaseSpace d) {v₀ : PhysSpace d}
+    (T : ℝ) {T_0 : ℝ} (hT_0_pos : 0 < T_0)
+    (hb : HasDerivWithinAt (fun s => charW s w) v₀ (Set.Icc 0 T_0) 0) :
+    ContinuousWithinAt (fun s => charW (s - T) w) (Set.Ici T) T := by
+  have h_nhdsW_0 : Set.Icc (0 : ℝ) T_0 ∈ nhdsWithin 0 (Set.Ici 0) :=
+    Icc_mem_nhdsGE hT_0_pos
+  have h_cont : ContinuousWithinAt (fun s => charW s w) (Set.Ici 0) 0 :=
+    hb.continuousWithinAt.mono_of_mem_nhdsWithin h_nhdsW_0
+  have h_sub_cont : ContinuousWithinAt (fun s : ℝ => s - T) (Set.Ici T) T :=
+    ((continuous_id.sub continuous_const).continuousAt).continuousWithinAt
+  have h_sub_maps : Set.MapsTo (fun s : ℝ => s - T) (Set.Ici T) (Set.Ici 0) :=
+    fun s hs => Set.mem_Ici.mpr (by linarith [Set.mem_Ici.mp hs])
+  exact ContinuousWithinAt.comp_of_eq h_cont h_sub_cont h_sub_maps (sub_self T)
+
+/-- Composed-pushforward infrastructure on the glued window `[T, T+T_0]`:
+`g (s−T)` is the pushforward of `f₀` by the composed phase-space flow
+(`g`'s window flow after the outer time-`T` map `(XT, VT)`), its spatial
+marginal is the pushforward by the composed position map, and both composed
+maps are a.e.-measurable. -/
+private lemma vlasovGlue_composed_pushforward
+    {d : ℕ}
+    (f₀ : Measure (PhaseSpace d))
+    (g : ℝ → Measure (PhaseSpace d))
+    (f_prevT : Measure (PhaseSpace d))
+    (charX_g charV_g : ℝ → PhaseSpace d → PhysSpace d)
+    (XT VT : PhaseSpace d → PhysSpace d)
+    {T T_0 : ℝ}
+    (h_outer_aemeas : AEMeasurable (fun z : PhaseSpace d => (XT z, VT z)) f₀)
+    (h_prevT_push : f_prevT = Measure.map (fun z : PhaseSpace d => (XT z, VT z)) f₀)
+    (hg_init : g 0 = f_prevT)
+    (hg_push_ex : ∀ t ∈ Set.Icc (0 : ℝ) T_0,
+        g t = Measure.map (fun z : PhaseSpace d => (charX_g t z, charV_g t z)) (g 0))
+    (hg_aemeas_ex : ∀ s ∈ Set.Icc (0 : ℝ) T_0,
+        AEMeasurable (fun z : PhaseSpace d => (charX_g s z, charV_g s z)) (g 0)) :
+    (∀ τ ∈ Set.Icc (0 : ℝ) T_0,
+        AEMeasurable (fun z : PhaseSpace d =>
+          (charX_g τ (XT z, VT z), charV_g τ (XT z, VT z))) f₀) ∧
+    (∀ s ∈ Set.Icc T (T + T_0),
+        g (s - T) = Measure.map (fun z : PhaseSpace d =>
+          (charX_g (s - T) (XT z, VT z), charV_g (s - T) (XT z, VT z))) f₀) ∧
+    (∀ s ∈ Set.Icc T (T + T_0),
+        spatialMarginal (g (s - T)) = Measure.map (fun z : PhaseSpace d =>
+          charX_g (s - T) (XT z, VT z)) f₀) ∧
+    (∀ s ∈ Set.Icc T (T + T_0),
+        AEMeasurable (fun z : PhaseSpace d => charX_g (s - T) (XT z, VT z)) f₀) := by
+  have h_g_at_aemeas : ∀ τ ∈ Set.Icc (0 : ℝ) T_0,
+      AEMeasurable (fun z : PhaseSpace d => (charX_g τ z, charV_g τ z))
+        (Measure.map (fun z : PhaseSpace d => (XT z, VT z)) f₀) := by
+    intro τ hτ
+    have := hg_aemeas_ex τ hτ
+    rw [hg_init, h_prevT_push] at this
+    exact this
+  have h_comp_aemeas : ∀ τ ∈ Set.Icc (0 : ℝ) T_0,
+      AEMeasurable (fun z : PhaseSpace d =>
+        (charX_g τ (XT z, VT z), charV_g τ (XT z, VT z))) f₀ := by
+    intro τ hτ
+    exact (h_g_at_aemeas τ hτ).comp_aemeasurable h_outer_aemeas
+  have h_push_comp : ∀ s ∈ Set.Icc T (T + T_0),
+      g (s - T) = Measure.map (fun z : PhaseSpace d =>
+        (charX_g (s - T) (XT z, VT z), charV_g (s - T) (XT z, VT z))) f₀ := by
+    intro s hs
+    have hsT_Icc : s - T ∈ Set.Icc (0 : ℝ) T_0 :=
+      ⟨by linarith [hs.1], by linarith [hs.2]⟩
+    rw [hg_push_ex (s - T) hsT_Icc, hg_init, h_prevT_push,
+        AEMeasurable.map_map_of_aemeasurable
+          (h_g_at_aemeas (s - T) hsT_Icc) h_outer_aemeas]
+    rfl
+  refine ⟨h_comp_aemeas, h_push_comp, fun s hs => ?_, fun s hs => ?_⟩
+  · have hsT_Icc : s - T ∈ Set.Icc (0 : ℝ) T_0 :=
+      ⟨by linarith [hs.1], by linarith [hs.2]⟩
+    unfold spatialMarginal
+    rw [h_push_comp s hs,
+        AEMeasurable.map_map_of_aemeasurable measurable_fst.aemeasurable
+          (h_comp_aemeas (s - T) hsT_Icc)]
+    rfl
+  · have hsT_Icc : s - T ∈ Set.Icc (0 : ℝ) T_0 :=
+      ⟨by linarith [hs.1], by linarith [hs.2]⟩
+    exact measurable_fst.comp_aemeasurable (h_comp_aemeas (s - T) hsT_Icc)
+
+/-- Pointwise composed-pushforward rewrite of the force integral on the glued
+window: for `s ∈ [T, T+T_0]` the integral of the force integrand against
+`f_next s` equals the integral of the flow-composed integrand against `f₀`.
+Serves both the eventually-equal rewrite and the value-at-`T` bridge of the
+RIGHT seam close. -/
+private lemma vlasovGlue_composed_integral_eq
+    {d : ℕ}
+    (gradW : PhysSpace d → PhysSpace d)
+    (f₀ : Measure (PhaseSpace d))
+    {T T_0 : ℝ} (hT_pos : 0 < T)
+    (f_prev g : ℝ → Measure (PhaseSpace d))
+    (h_prev_init : f_prev 0 = f₀)
+    (charX_prev charV_prev charX_g charV_g : ℝ → PhaseSpace d → PhysSpace d)
+    (h_prev_push : ∀ t ∈ Set.Icc (0 : ℝ) T,
+        f_prev t =
+          Measure.map (fun z : PhaseSpace d => (charX_prev t z, charV_prev t z)) (f_prev 0))
+    (hg_init : g 0 = f_prev T)
+    (hg_init_cond : ∀ z : PhaseSpace d, charX_g 0 z = z.1 ∧ charV_g 0 z = z.2)
+    (f_next : ℝ → Measure (PhaseSpace d))
+    (hf_next_T : f_next T = f_prev T)
+    (hf_next_gt : ∀ s, T < s → f_next s = g (s - T))
+    (gradXφ gradVφ : PhaseSpace d → PhysSpace d)
+    (h_comp_aemeas : ∀ τ ∈ Set.Icc (0 : ℝ) T_0,
+        AEMeasurable (fun z : PhaseSpace d =>
+          (charX_g τ (charX_prev T z, charV_prev T z),
+           charV_g τ (charX_prev T z, charV_prev T z))) f₀)
+    (h_g_push_comp : ∀ s ∈ Set.Icc T (T + T_0),
+        g (s - T) = Measure.map (fun z : PhaseSpace d =>
+          (charX_g (s - T) (charX_prev T z, charV_prev T z),
+           charV_g (s - T) (charX_prev T z, charV_prev T z))) f₀)
+    (h_integrand_cont : ∀ τ ∈ Set.Icc (0 : ℝ) T_0,
+        Continuous (fun z : PhaseSpace d =>
+          @inner ℝ (PhysSpace d) _ z.2 (gradXφ z) -
+          @inner ℝ (PhysSpace d) _
+            (convolveFunctionMeasure gradW (spatialMarginal (g τ)) z.1)
+            (gradVφ z)))
+    (s : ℝ) (hs : s ∈ Set.Icc T (T + T_0)) :
+    (∫ z, (@inner ℝ (PhysSpace d) _ z.2 (gradXφ z) -
+        @inner ℝ (PhysSpace d) _
+          (convolveFunctionMeasure gradW (spatialMarginal (f_next s)) z.1)
+          (gradVφ z)) ∂(f_next s))
+      = ∫ z, (@inner ℝ (PhysSpace d) _
+            (charV_g (s - T) (charX_prev T z, charV_prev T z))
+            (gradXφ (charX_g (s - T) (charX_prev T z, charV_prev T z),
+                     charV_g (s - T) (charX_prev T z, charV_prev T z))) -
+          @inner ℝ (PhysSpace d) _
+            (convolveFunctionMeasure gradW (spatialMarginal (g (s - T)))
+              (charX_g (s - T) (charX_prev T z, charV_prev T z)))
+            (gradVφ (charX_g (s - T) (charX_prev T z, charV_prev T z),
+                     charV_g (s - T) (charX_prev T z, charV_prev T z)))) ∂f₀ := by
+  have hT_Icc : T ∈ Set.Icc (0 : ℝ) T := ⟨hT_pos.le, le_refl T⟩
+  have hsT_Icc : s - T ∈ Set.Icc (0 : ℝ) T_0 :=
+    ⟨by linarith [hs.1], by linarith [hs.2]⟩
+  by_cases hs_eq : s = T
+  · -- s = T: f_next T = f_prev T = composed pushforward (collapse g at 0 = id)
+    have hs_T_zero : s - T = 0 := by rw [hs_eq]; exact sub_self T
+    have h_fnext_s : f_next s = f_prev T := by
+      rw [hs_eq]; exact hf_next_T
+    have h_marg_eq : spatialMarginal (f_next s) = spatialMarginal (g (s - T)) := by
+      rw [h_fnext_s, hs_T_zero, hg_init]
+    have h_meq : f_next s = Measure.map
+        (fun z : PhaseSpace d =>
+          (charX_g (s - T) (charX_prev T z, charV_prev T z),
+           charV_g (s - T) (charX_prev T z, charV_prev T z))) f₀ := by
+      rw [h_fnext_s, h_prev_push T hT_Icc, h_prev_init]
+      apply Measure.map_congr
+      apply Filter.Eventually.of_forall
+      intro z
+      simp only [hs_T_zero, (hg_init_cond _).1, (hg_init_cond _).2]
+    rw [h_marg_eq, h_meq,
+        integral_map (h_comp_aemeas (s - T) hsT_Icc)
+          (h_integrand_cont (s - T) hsT_Icc).aestronglyMeasurable]
+  · -- s > T: f_next s = g (s − T) = composed pushforward
+    have hs_gt : T < s := lt_of_le_of_ne hs.1 (Ne.symm hs_eq)
+    have h_fnext_s : f_next s = g (s - T) := hf_next_gt s hs_gt
+    have h_marg_eq : spatialMarginal (f_next s) = spatialMarginal (g (s - T)) :=
+      congrArg spatialMarginal h_fnext_s
+    have h_meq : f_next s = Measure.map
+        (fun z : PhaseSpace d =>
+          (charX_g (s - T) (charX_prev T z, charV_prev T z),
+           charV_g (s - T) (charX_prev T z, charV_prev T z))) f₀ := by
+      rw [h_fnext_s]; exact h_g_push_comp s hs
+    rw [h_marg_eq, h_meq,
+        integral_map (h_comp_aemeas (s - T) hsT_Icc)
+          (h_integrand_cont (s - T) hsT_Icc).aestronglyMeasurable]
+
+/-- RIGHT seam continuity of the force-integral functional at `T`: on `Ici T`
+the glued solution is `g (·−T)` (via `hf_next_T`/`hf_next_gt`), represented as
+the composed pushforward of `f₀` by `g`'s window flow after `f_prev`'s time-`T`
+flow; the claim reduces to the generic seam DCT lemma
+`vlasovGlue_seam_forceIntegral_cont` on the composed flow. -/
+private lemma vlasovGlue_seam_contRight
+    {d : ℕ}
+    (gradW : PhysSpace d → PhysSpace d)
+    (L : NNReal) (hL : LipschitzWith L gradW)
+    (f₀ : Measure (PhaseSpace d)) [IsProbabilityMeasure f₀]
+    (hf₀_int : Integrable (fun z : PhaseSpace d => ‖z‖) f₀)
+    {T : ℝ} (hT_pos : 0 < T) {T_0 : ℝ} (hT_0_pos : 0 < T_0)
+    (f_prev : ℝ → Measure (PhaseSpace d))
+    (h_prev_init : f_prev 0 = f₀)
+    (h_prev_mom : ∀ t ∈ Set.Icc (0 : ℝ) T, HasFiniteFirstMoment (f_prev t))
+    (hM_prev : ∃ M : ℝ, 0 ≤ M ∧
+        ∀ t ∈ Set.Icc (0 : ℝ) T, ∫ y, ‖y‖ ∂(spatialMarginal (f_prev t)) ≤ M)
+    (charX_prev charV_prev : ℝ → PhaseSpace d → PhysSpace d)
+    (h_prev_push : ∀ t ∈ Set.Icc (0 : ℝ) T,
+        f_prev t =
+          Measure.map (fun z : PhaseSpace d => (charX_prev t z, charV_prev t z)) (f_prev 0))
+    (h_prev_aemeas : ∀ s ∈ Set.Icc (0 : ℝ) T,
+        AEMeasurable (fun z : PhaseSpace d => (charX_prev s z, charV_prev s z)) (f_prev 0))
+    (h_prev_boundary : ∀ (z : PhaseSpace d) (t : ℝ), t ∈ Set.Icc (0 : ℝ) T →
+        HasDerivWithinAt (fun s => charX_prev s z) (charV_prev t z) (Set.Icc 0 T) t ∧
+        HasDerivWithinAt (fun s => charV_prev s z)
+          (-(convolveFunctionMeasure gradW (spatialMarginal (f_prev t)) (charX_prev t z)))
+          (Set.Icc 0 T) t)
+    (h_prev_ic : ∀ z : PhaseSpace d, charX_prev 0 z = z.1 ∧ charV_prev 0 z = z.2)
+    (g : ℝ → Measure (PhaseSpace d))
+    (charX_g charV_g : ℝ → PhaseSpace d → PhysSpace d)
+    (hg_init : g 0 = f_prev T)
+    (hg_mom : ∀ t ∈ Set.Icc (0 : ℝ) T_0, HasFiniteFirstMoment (g t))
+    (hg_mom_unif : ∃ M : ℝ, 0 ≤ M ∧
+        ∀ t ∈ Set.Icc (0 : ℝ) T_0, ∫ y, ‖y‖ ∂(spatialMarginal (g t)) ≤ M)
+    (hg_push_ex : ∀ t ∈ Set.Icc (0 : ℝ) T_0,
+        g t = Measure.map (fun z : PhaseSpace d => (charX_g t z, charV_g t z)) (g 0))
+    (hg_aemeas_ex : ∀ s ∈ Set.Icc (0 : ℝ) T_0,
+        AEMeasurable (fun z : PhaseSpace d => (charX_g s z, charV_g s z)) (g 0))
+    (hg_boundary : ∀ z : PhaseSpace d, ∀ t ∈ Set.Icc (0 : ℝ) T_0,
+        HasDerivWithinAt (fun s => charX_g s z) (charV_g t z) (Set.Icc 0 T_0) t ∧
+        HasDerivWithinAt (fun s => charV_g s z)
+          (-(convolveFunctionMeasure gradW (spatialMarginal (g t)) (charX_g t z)))
+          (Set.Icc 0 T_0) t)
+    (hg_init_cond : ∀ z : PhaseSpace d, charX_g 0 z = z.1 ∧ charV_g 0 z = z.2)
+    (f_next : ℝ → Measure (PhaseSpace d))
+    (hf_next_T : f_next T = f_prev T)
+    (hf_next_gt : ∀ s, T < s → f_next s = g (s - T))
+    (φ : PhaseSpace d → ℝ)
+    (hφ_smooth : ContDiff ℝ (⊤ : ℕ∞) φ) (hφ_compact : HasCompactSupport φ)
+    (gradXφ gradVφ : PhaseSpace d → PhysSpace d)
+    (hgradXφ : ∀ z : PhaseSpace d, gradXφ z = gradient (fun x => φ (x, z.2)) z.1)
+    (hgradVφ : ∀ z : PhaseSpace d, gradVφ z = gradient (fun v => φ (z.1, v)) z.2) :
+    ContinuousWithinAt
+      (fun s => ∫ z, (@inner ℝ (PhysSpace d) _ z.2 (gradXφ z) -
+              @inner ℝ (PhysSpace d) _
+                (convolveFunctionMeasure gradW (spatialMarginal (f_next s)) z.1)
+                (gradVφ z)) ∂(f_next s)) (Set.Ici T) T := by
+  have hT_Icc : T ∈ Set.Icc (0 : ℝ) T := ⟨hT_pos.le, le_refl T⟩
+  have h_nhd_R : Set.Icc T (T + T_0) ∈ nhdsWithin T (Set.Ici T) :=
+    Icc_mem_nhdsGE (by linarith : T < T + T_0)
+  have h_outer_aemeas : AEMeasurable
+      (fun z : PhaseSpace d => (charX_prev T z, charV_prev T z)) f₀ :=
+    h_prev_init ▸ h_prev_aemeas T hT_Icc
+  set Zpos : ℝ → PhaseSpace d → PhysSpace d :=
+    fun s z => charX_g (s - T) (charX_prev T z, charV_prev T z) with hZpos_def
+  set Zvel : ℝ → PhaseSpace d → PhysSpace d :=
+    fun s z => charV_g (s - T) (charX_prev T z, charV_prev T z) with hZvel_def
+  have hgradXφ_cont : Continuous gradXφ :=
+    vlasovGlue_gradXφ_continuous φ hφ_smooth gradXφ hgradXφ
+  have hgradVφ_cont : Continuous gradVφ :=
+    vlasovGlue_gradVφ_continuous φ hφ_smooth gradVφ hgradVφ
+  have h_int_marg_g := dobrushinFlow_marginal_gradW_integrable gradW L hL T_0
+    g hg_mom
+  -- Composed pushforward of g's spatial marginal (hoisted helper), bridged to
+  -- the Zpos/Zvel forms.
+  have h_prevT_push : f_prev T
+      = Measure.map (fun z : PhaseSpace d => (charX_prev T z, charV_prev T z)) f₀ := by
+    rw [h_prev_push T hT_Icc, h_prev_init]
+  obtain ⟨h_comp_aemeas, h_g_push_comp', h_push_marg', h_aemeas_marg'⟩ :=
+    vlasovGlue_composed_pushforward f₀ g (f_prev T) charX_g charV_g
+      (charX_prev T) (charV_prev T) h_outer_aemeas h_prevT_push hg_init
+      hg_push_ex hg_aemeas_ex
+  have h_g_push_comp : ∀ s ∈ Set.Icc T (T + T_0),
+      g (s - T) = Measure.map
+        (fun z : PhaseSpace d => (Zpos s z, Zvel s z)) f₀ := by
+    intro s hs
+    simpa only [hZpos_def, hZvel_def] using h_g_push_comp' s hs
+  have h_push_marg : ∀ s ∈ Set.Icc T (T + T_0),
+      spatialMarginal (g (s - T))
+        = Measure.map (fun z : PhaseSpace d => Zpos s z) f₀ := by
+    intro s hs
+    simpa only [hZpos_def] using h_push_marg' s hs
+  have h_aemeas_marg : ∀ s ∈ Set.Icc T (T + T_0),
+      AEMeasurable (fun z : PhaseSpace d => Zpos s z) f₀ := by
+    intro s hs
+    simpa only [hZpos_def] using h_aemeas_marg' s hs
+  -- Composed growth bound: Piece A on g over [0,T_0] composed with Piece A on
+  -- prev at T (both via the hoisted clamp construction).
+  obtain ⟨C_prev, hC_prev_nn, hC_prev_pair, _h_cont_Icc_prev⟩ :=
+    vlasovGlue_flow_growthBound gradW L hL f_prev charX_prev charV_prev
+      T hT_pos h_prev_mom hM_prev h_prev_ic h_prev_boundary
+  obtain ⟨C_g, hC_g_nn, hC_g_pair, _h_cont_Icc_g⟩ :=
+    vlasovGlue_flow_growthBound gradW L hL g charX_g charV_g
+      T_0 hT_0_pos hg_mom hg_mom_unif hg_init_cond hg_boundary
+  obtain ⟨M_g, _hM_g_nn, hM_g_bd⟩ := hg_mom_unif
+  have h_y_int_marg_g : ∀ τ ∈ Set.Icc (0 : ℝ) T_0,
+      Integrable (fun y : PhysSpace d => ‖y‖) (spatialMarginal (g τ)) :=
+    fun τ hτ => vlasovGlue_marginal_norm_integrable (g τ) (hg_mom τ hτ)
+  set C_comp : ℝ := C_g * C_prev + C_g with hC_comp_def
+  have hC_comp_nn : 0 ≤ C_comp := by positivity
+  have hC_comp_pair : ∀ s ∈ Set.Icc T (T + T_0), ∀ z : PhaseSpace d,
+      ‖(Zpos s z, Zvel s z)‖ ≤ C_comp * (‖z‖ + 1) := by
+    intro s hs z
+    have hsT_Icc : s - T ∈ Set.Icc (0 : ℝ) T_0 :=
+      ⟨by linarith [hs.1], by linarith [hs.2]⟩
+    have h_prev : ‖(charX_prev T z, charV_prev T z)‖ ≤ C_prev * (‖z‖ + 1) :=
+      hC_prev_pair T hT_Icc z
+    have h_g : ‖(charX_g (s - T) (charX_prev T z, charV_prev T z),
+                 charV_g (s - T) (charX_prev T z, charV_prev T z))‖
+        ≤ C_g * (‖(charX_prev T z, charV_prev T z)‖ + 1) :=
+      hC_g_pair (s - T) hsT_Icc (charX_prev T z, charV_prev T z)
+    have hz1 : (0 : ℝ) ≤ ‖z‖ + 1 := by positivity
+    calc ‖(Zpos s z, Zvel s z)‖
+        = ‖(charX_g (s - T) (charX_prev T z, charV_prev T z),
+            charV_g (s - T) (charX_prev T z, charV_prev T z))‖ := by
+          simp only [hZpos_def, hZvel_def]
+      _ ≤ C_g * (‖(charX_prev T z, charV_prev T z)‖ + 1) := h_g
+      _ ≤ C_g * (C_prev * (‖z‖ + 1) + 1) := by
+          apply mul_le_mul_of_nonneg_left _ hC_g_nn; linarith
+      _ ≤ C_comp * (‖z‖ + 1) := by
+          simp only [hC_comp_def]
+          nlinarith [mul_nonneg hC_g_nn (norm_nonneg z),
+            mul_nonneg (mul_nonneg hC_g_nn hC_prev_nn) hz1]
+  have hC_comp_X : ∀ s ∈ Set.Icc T (T + T_0), ∀ z : PhaseSpace d,
+      ‖Zpos s z‖ ≤ C_comp * (‖z‖ + 1) := by
+    intro s hs z
+    exact le_trans (norm_fst_le (Zpos s z, Zvel s z)) (hC_comp_pair s hs z)
+  -- Seam continuity of the composed flow at T (hoisted shift helper).
+  have h_Zpos_cont : ∀ z : PhaseSpace d,
+      ContinuousWithinAt (fun s => Zpos s z) (Set.Ici T) T := by
+    intro z
+    have := vlasovGlue_shifted_flow_contWithin charX_g
+      (charX_prev T z, charV_prev T z) T hT_0_pos
+      (hg_boundary (charX_prev T z, charV_prev T z) 0 ⟨le_refl 0, hT_0_pos.le⟩).1
+    simpa only [hZpos_def] using this
+  have h_Zvel_cont : ∀ z : PhaseSpace d,
+      ContinuousWithinAt (fun s => Zvel s z) (Set.Ici T) T := by
+    intro z
+    have := vlasovGlue_shifted_flow_contWithin charV_g
+      (charX_prev T z, charV_prev T z) T hT_0_pos
+      (hg_boundary (charX_prev T z, charV_prev T z) 0 ⟨le_refl 0, hT_0_pos.le⟩).2
+    simpa only [hZvel_def] using this
+  -- Continuity of the un-pushed integrand in z (for integral_map's
+  -- AEStronglyMeasurable side).
+  have h_conv_z_cont : ∀ τ ∈ Set.Icc (0 : ℝ) T_0,
+      Continuous (fun z : PhaseSpace d =>
+        convolveFunctionMeasure gradW (spatialMarginal (g τ)) z.1) := by
+    intro τ hτ
+    have : IsProbabilityMeasure (g τ) := (hg_mom τ hτ).1
+    have : IsProbabilityMeasure (spatialMarginal (g τ)) :=
+      (Measure.isProbabilityMeasure_map_iff measurable_fst.aemeasurable).mpr inferInstance
+    exact (convolveFunctionMeasure_lipschitz_in_x gradW L hL
+      (spatialMarginal (g τ)) (h_int_marg_g τ hτ)).continuous.comp continuous_fst
+  have h_integrand_cont : ∀ τ ∈ Set.Icc (0 : ℝ) T_0,
+      Continuous (fun z : PhaseSpace d =>
+        @inner ℝ (PhysSpace d) _ z.2 (gradXφ z) -
+        @inner ℝ (PhysSpace d) _
+          (convolveFunctionMeasure gradW (spatialMarginal (g τ)) z.1)
+          (gradVφ z)) := by
+    intro τ hτ
+    exact (continuous_snd.inner hgradXφ_cont).sub
+      ((h_conv_z_cont τ hτ).inner hgradVφ_cont)
+  -- Eventually-equal rewrite to the composed-pushforward form (pointwise helper).
+  have h_intg_eq := vlasovGlue_composed_integral_eq gradW f₀ hT_pos f_prev g
+    h_prev_init charX_prev charV_prev charX_g charV_g h_prev_push hg_init
+    hg_init_cond f_next hf_next_T hf_next_gt gradXφ gradVφ h_comp_aemeas
+    h_g_push_comp' h_integrand_cont
+  have h_eq_R : (fun s => ∫ z, (@inner ℝ (PhysSpace d) _ z.2 (gradXφ z) -
+          @inner ℝ (PhysSpace d) _
+            (convolveFunctionMeasure gradW (spatialMarginal (f_next s)) z.1)
+            (gradVφ z)) ∂(f_next s))
+      =ᶠ[nhdsWithin T (Set.Ici T)]
+      (fun s => ∫ z, (@inner ℝ (PhysSpace d) _ (Zvel s z)
+            (gradXφ (Zpos s z, Zvel s z)) -
+          @inner ℝ (PhysSpace d) _
+            (convolveFunctionMeasure gradW (spatialMarginal (g (s - T)))
+              (Zpos s z))
+            (gradVφ (Zpos s z, Zvel s z))) ∂f₀) := by
+    apply Filter.Eventually.mono h_nhd_R
+    intro s hs
+    simpa only [hZpos_def, hZvel_def] using h_intg_eq s hs
+  obtain ⟨M_φ, hgradXφ_bd, hgradVφ_bd⟩ :=
+    vlasovGlue_gradφ_bound φ hφ_smooth hφ_compact gradXφ gradVφ hgradXφ hgradVφ
+  -- DCT via the generic seam lemma on the composed flow.
+  have h_conv_cwn : ∀ z : PhaseSpace d, ContinuousWithinAt
+      (fun s => convolveFunctionMeasure gradW (spatialMarginal (g (s - T)))
+        (Zpos s z)) (Set.Ici T) T := fun z =>
+    flowConv_continuousWithinAt_Ici_seam gradW L hL Zpos f₀
+      hf₀_int (by linarith : T < T + T_0)
+      (fun s => spatialMarginal (g (s - T)))
+      h_push_marg h_aemeas_marg h_Zpos_cont C_comp hC_comp_nn hC_comp_X z
+  have h_aemeas_W : ∀ s ∈ Set.Icc T (T + T_0),
+      AEMeasurable (fun z : PhaseSpace d => (Zpos s z, Zvel s z)) f₀ := by
+    intro s hs
+    have hsT_Icc : s - T ∈ Set.Icc (0 : ℝ) T_0 :=
+      ⟨by linarith [hs.1], by linarith [hs.2]⟩
+    simpa only [hZpos_def, hZvel_def] using h_comp_aemeas (s - T) hsT_Icc
+  have h_cont_pf : ContinuousWithinAt
+      (fun s => ∫ z, (@inner ℝ (PhysSpace d) _ (Zvel s z)
+            (gradXφ (Zpos s z, Zvel s z)) -
+          @inner ℝ (PhysSpace d) _
+            (convolveFunctionMeasure gradW (spatialMarginal (g (s - T)))
+              (Zpos s z))
+            (gradVφ (Zpos s z, Zvel s z))) ∂f₀)
+      (Set.Ici T) T :=
+    vlasovGlue_seam_forceIntegral_cont gradW L hL f₀ hf₀_int gradXφ gradVφ
+      hgradXφ_cont hgradVφ_cont M_φ hgradXφ_bd hgradVφ_bd
+      (fun s => spatialMarginal (g (s - T))) Zpos Zvel
+      T (Set.Ici T) (Set.Icc T (T + T_0)) h_nhd_R
+      (fun s hs => by
+        have hsT_Icc : s - T ∈ Set.Icc (0 : ℝ) T_0 :=
+          ⟨by linarith [hs.1], by linarith [hs.2]⟩
+        have : IsProbabilityMeasure (g (s - T)) := (hg_mom (s - T) hsT_Icc).1
+        exact (Measure.isProbabilityMeasure_map_iff measurable_fst.aemeasurable).mpr inferInstance)
+      M_g
+      (fun s hs => hM_g_bd (s - T) ⟨by linarith [hs.1], by linarith [hs.2]⟩)
+      (fun s hs => h_y_int_marg_g (s - T) ⟨by linarith [hs.1], by linarith [hs.2]⟩)
+      (fun s hs => h_int_marg_g (s - T) ⟨by linarith [hs.1], by linarith [hs.2]⟩)
+      C_comp hC_comp_pair h_aemeas_W h_Zpos_cont h_Zvel_cont h_conv_cwn
+  -- Value at T bridge (pointwise helper at s = T).
+  have h_val_T : (∫ z, (@inner ℝ (PhysSpace d) _ z.2 (gradXφ z) -
+          @inner ℝ (PhysSpace d) _
+            (convolveFunctionMeasure gradW (spatialMarginal (f_next T)) z.1)
+            (gradVφ z)) ∂(f_next T))
+      = ∫ z, (@inner ℝ (PhysSpace d) _ (Zvel T z)
+            (gradXφ (Zpos T z, Zvel T z)) -
+          @inner ℝ (PhysSpace d) _
+            (convolveFunctionMeasure gradW (spatialMarginal (g (T - T)))
+              (Zpos T z))
+            (gradVφ (Zpos T z, Zvel T z))) ∂f₀ := by
+    simpa only [hZpos_def, hZvel_def] using
+      h_intg_eq T ⟨le_refl T, by linarith⟩
+  exact h_cont_pf.congr_of_eventuallyEq h_eq_R h_val_T
+
+/-- `HasDerivAt` of the glued position flow at interior times of the extended
+window: piecewise from `f_prev`'s flow (`t < T`), the two-sided union of the
+boundary bundles (`t = T`), and `g`'s shifted flow (`t > T`).  Pure ODE gluing —
+takes only the position projections of the flow hypotheses. -/
+private lemma vlasovGlue_flowX_hasDerivAt
+    {d : ℕ}
+    (charX_prev charV_prev charX_g charV_g : ℝ → PhaseSpace d → PhysSpace d)
+    {T T_0 : ℝ} (hT_pos : 0 < T) (hT_0_pos : 0 < T_0)
+    (h_prev_flowX : ∀ t ∈ Set.Ioo (0 : ℝ) T, ∀ z : PhaseSpace d,
+        HasDerivAt (fun s => charX_prev s z) (charV_prev t z) t)
+    (h_prev_boundaryX : ∀ (z : PhaseSpace d) (t : ℝ), t ∈ Set.Icc (0 : ℝ) T →
+        HasDerivWithinAt (fun s => charX_prev s z) (charV_prev t z) (Set.Icc 0 T) t)
+    (hg_boundaryX : ∀ z : PhaseSpace d, ∀ t ∈ Set.Icc (0 : ℝ) T_0,
+        HasDerivWithinAt (fun s => charX_g s z) (charV_g t z) (Set.Icc 0 T_0) t)
+    (hg_init_cond : ∀ z : PhaseSpace d, charX_g 0 z = z.1 ∧ charV_g 0 z = z.2)
+    (t : ℝ) (ht : t ∈ Set.Ioo (0 : ℝ) (T + T_0)) (z : PhaseSpace d) :
+    HasDerivAt (fun s => if s ≤ T then charX_prev s z
+        else charX_g (s - T) (charX_prev T z, charV_prev T z))
+      (if t ≤ T then charV_prev t z
+        else charV_g (t - T) (charX_prev T z, charV_prev T z)) t := by
+  by_cases ht_le : t ≤ T
+  · simp only [ite_eq_left ht_le]
+    -- Sub-case: t < T (strict interior) vs t = T (boundary)
+    by_cases ht_lt : t < T
+    · -- t < T strict: piecewise function = charX_prev · z near t
+      have h_ev : (fun s => if s ≤ T then charX_prev s z
+          else charX_g (s - T) (charX_prev T z, charV_prev T z)) =ᶠ[nhds t]
+          (fun s => charX_prev s z) := by
+        apply Filter.Eventually.mono (eventually_lt_nhds ht_lt)
+        intro s hs; simp [le_of_lt hs]
+      exact ((h_prev_flowX t ⟨ht.1, ht_lt⟩ z).congr_of_eventuallyEq h_ev)
+    · -- t = T: boundary HasDerivAt via HasDerivWithinAt.union (Iic T ∪ Ici T = univ)
+      push Not at ht_lt
+      have h_t_eq : t = T := le_antisymm ht_le ht_lt
+      have hT_in : T ∈ Set.Icc (0 : ℝ) T := ⟨hT_pos.le, le_refl T⟩
+      have h_bX := h_prev_boundaryX z T hT_in
+      have h0_T0_in : (0 : ℝ) ∈ Set.Icc (0 : ℝ) T_0 := ⟨le_refl 0, hT_0_pos.le⟩
+      have h_g_bX := hg_boundaryX (charX_prev T z, charV_prev T z) 0 h0_T0_in
+      have h_nhd_L : Set.Icc 0 T ∈ nhdsWithin T (Set.Iic T) := Icc_mem_nhdsLE hT_pos
+      have h_nhd_R : Set.Icc 0 T_0 ∈ nhdsWithin (0 : ℝ) (Set.Ici 0) :=
+        Icc_mem_nhdsGE hT_0_pos
+      -- LEFT: HasDerivWithinAt charX_prev on Iic T at T
+      have hX_Lic := h_bX.mono_of_mem_nhdsWithin h_nhd_L
+      have hX_left : HasDerivWithinAt
+          (fun s => if s ≤ T then charX_prev s z
+            else charX_g (s - T) (charX_prev T z, charV_prev T z))
+          (charV_prev T z) (Set.Iic T) T :=
+        hX_Lic.congr_of_mem (fun s hs => by simp [Set.mem_Iic.mp hs]) Set.self_mem_Iic
+      -- RIGHT: chain rule from g's boundary at 0
+      have hX_Ici0 := h_g_bX.mono_of_mem_nhdsWithin h_nhd_R
+      have h_sub_R : HasDerivWithinAt (· - T) 1 (Set.Ici T) T :=
+        ((hasDerivAt_id' T).sub_const T).hasDerivWithinAt
+      have h_mapR : Set.MapsTo (· - T) (Set.Ici T) (Set.Ici 0) :=
+        fun s hs => Set.mem_Ici.mpr (by linarith [Set.mem_Ici.mp hs])
+      have h_chainX : HasDerivWithinAt
+          (fun s => charX_g (s - T) (charX_prev T z, charV_prev T z))
+          (charV_g 0 (charX_prev T z, charV_prev T z)) (Set.Ici T) T := by
+        have := HasDerivWithinAt.scomp_of_eq T hX_Ici0 h_sub_R h_mapR (sub_self T).symm
+        simpa [Function.comp_def, one_smul] using this
+      have hVg0_eq : charV_g 0 (charX_prev T z, charV_prev T z) = charV_prev T z :=
+        (hg_init_cond (charX_prev T z, charV_prev T z)).2
+      rw [hVg0_eq] at h_chainX
+      have hX_right : HasDerivWithinAt
+          (fun s => if s ≤ T then charX_prev s z
+            else charX_g (s - T) (charX_prev T z, charV_prev T z))
+          (charV_prev T z) (Set.Ici T) T :=
+        h_chainX.congr_of_mem
+          (fun s hs => by
+            by_cases hle : s ≤ T
+            · have heq : s = T := le_antisymm hle (Set.mem_Ici.mp hs)
+              simp [heq, sub_self,
+                (hg_init_cond (charX_prev T z, charV_prev T z)).1]
+            · simp [hle])
+          Set.self_mem_Ici
+      have hX_union := hX_left.union hX_right
+      rw [Set.Iic_union_Ici] at hX_union
+      rw [h_t_eq]
+      exact hX_union.hasDerivAt Filter.univ_mem
+  · simp only [ite_eq_right ht_le]
+    push Not at ht_le
+    -- t > T: use hg_boundaryX at (t - T) with chain rule for (s ↦ s - T)
+    have htT_mem : t - T ∈ Set.Ioo (0 : ℝ) T_0 := ⟨by linarith, by linarith [ht.2]⟩
+    have h_g_deriv : HasDerivAt (fun s => charX_g s (charX_prev T z, charV_prev T z))
+        (charV_g (t - T) (charX_prev T z, charV_prev T z)) (t - T) :=
+      (hg_boundaryX (charX_prev T z, charV_prev T z) (t - T)
+          (Set.Ioo_subset_Icc_self htT_mem)).hasDerivAt
+        (Icc_mem_nhds htT_mem.1 htT_mem.2)
+    have h_sub : HasDerivAt (· - T) 1 t := (hasDerivAt_id' t).sub_const T
+    have h_chain : HasDerivAt (fun s => charX_g (s - T) (charX_prev T z, charV_prev T z))
+        (charV_g (t - T) (charX_prev T z, charV_prev T z)) t := by
+      have := HasDerivAt.scomp_of_eq t h_g_deriv h_sub rfl
+      simpa [Function.comp_def, one_smul] using this
+    have h_ev : (fun s => if s ≤ T then charX_prev s z
+        else charX_g (s - T) (charX_prev T z, charV_prev T z)) =ᶠ[nhds t]
+        (fun s => charX_g (s - T) (charX_prev T z, charV_prev T z)) := by
+      apply Filter.Eventually.mono (eventually_gt_nhds ht_le)
+      intro s hs; simp [not_le.mpr hs]
+    exact h_chain.congr_of_eventuallyEq h_ev
+
+/-- `HasDerivAt` of the glued velocity flow at interior times of the extended
+window, with the force term against the glued measure `f_next` (consumed only
+through its value hypotheses).  Mirrors `vlasovGlue_flowX_hasDerivAt` with the
+velocity projections and the marginal bridges. -/
+private lemma vlasovGlue_flowV_hasDerivAt
+    {d : ℕ}
+    (gradW : PhysSpace d → PhysSpace d)
+    (f_prev g : ℝ → Measure (PhaseSpace d))
+    (charX_prev charV_prev charX_g charV_g : ℝ → PhaseSpace d → PhysSpace d)
+    {T T_0 : ℝ} (hT_pos : 0 < T) (hT_0_pos : 0 < T_0)
+    (h_prev_flowV : ∀ t ∈ Set.Ioo (0 : ℝ) T, ∀ z : PhaseSpace d,
+        HasDerivAt (fun s => charV_prev s z)
+          (-(convolveFunctionMeasure gradW (spatialMarginal (f_prev t))
+              (charX_prev t z))) t)
+    (h_prev_boundaryV : ∀ (z : PhaseSpace d) (t : ℝ), t ∈ Set.Icc (0 : ℝ) T →
+        HasDerivWithinAt (fun s => charV_prev s z)
+          (-(convolveFunctionMeasure gradW (spatialMarginal (f_prev t)) (charX_prev t z)))
+          (Set.Icc 0 T) t)
+    (hg_boundaryV : ∀ z : PhaseSpace d, ∀ t ∈ Set.Icc (0 : ℝ) T_0,
+        HasDerivWithinAt (fun s => charV_g s z)
+          (-(convolveFunctionMeasure gradW (spatialMarginal (g t)) (charX_g t z)))
+          (Set.Icc 0 T_0) t)
+    (hg_init : g 0 = f_prev T)
+    (hg_init_cond : ∀ z : PhaseSpace d, charX_g 0 z = z.1 ∧ charV_g 0 z = z.2)
+    (f_next : ℝ → Measure (PhaseSpace d))
+    (hf_next_le : ∀ s, s ≤ T → f_next s = f_prev s)
+    (hf_next_gt : ∀ s, T < s → f_next s = g (s - T))
+    (t : ℝ) (ht : t ∈ Set.Ioo (0 : ℝ) (T + T_0)) (z : PhaseSpace d) :
+    HasDerivAt (fun s => if s ≤ T then charV_prev s z
+        else charV_g (s - T) (charX_prev T z, charV_prev T z))
+      (-(convolveFunctionMeasure gradW (spatialMarginal (f_next t))
+          (if t ≤ T then charX_prev t z
+            else charX_g (t - T) (charX_prev T z, charV_prev T z)))) t := by
+  by_cases ht_le : t ≤ T
+  · simp only [ite_eq_left ht_le]
+    -- Sub-case: t < T (strict interior) vs t = T (boundary)
+    by_cases ht_lt : t < T
+    · -- t < T strict: piecewise function = charV_prev · z near t
+      have h_ev : (fun s => if s ≤ T then charV_prev s z
+          else charV_g (s - T) (charX_prev T z, charV_prev T z)) =ᶠ[nhds t]
+          (fun s => charV_prev s z) := by
+        apply Filter.Eventually.mono (eventually_lt_nhds ht_lt)
+        intro s hs; simp [le_of_lt hs]
+      have h_fnext_t : f_next t = f_prev t := hf_next_le t ht_le
+      have h_prev_deriv := h_prev_flowV t ⟨ht.1, ht_lt⟩ z
+      have h_eq_marg : spatialMarginal (f_prev t) = spatialMarginal (f_next t) :=
+        congrArg spatialMarginal h_fnext_t.symm
+      simp only [h_eq_marg] at h_prev_deriv
+      exact h_prev_deriv.congr_of_eventuallyEq h_ev
+    · -- t = T: boundary HasDerivAt via HasDerivWithinAt.union (same as charX case)
+      push Not at ht_lt
+      have h_t_eq : t = T := le_antisymm ht_le ht_lt
+      have hT_in : T ∈ Set.Icc (0 : ℝ) T := ⟨hT_pos.le, le_refl T⟩
+      have h_bV := h_prev_boundaryV z T hT_in
+      have h0_T0_in : (0 : ℝ) ∈ Set.Icc (0 : ℝ) T_0 := ⟨le_refl 0, hT_0_pos.le⟩
+      have h_g_bV := hg_boundaryV (charX_prev T z, charV_prev T z) 0 h0_T0_in
+      have h_nhd_L : Set.Icc 0 T ∈ nhdsWithin T (Set.Iic T) := Icc_mem_nhdsLE hT_pos
+      have h_nhd_R : Set.Icc 0 T_0 ∈ nhdsWithin (0 : ℝ) (Set.Ici 0) :=
+        Icc_mem_nhdsGE hT_0_pos
+      -- Bridge f_prev T ↔ f_next T (for spatial marginal in goal vs h_bV)
+      have hfnextT : f_next T = f_prev T := hf_next_le T (le_refl T)
+      have hfnextT_spat : spatialMarginal (f_next T) = spatialMarginal (f_prev T) :=
+        congrArg spatialMarginal hfnextT
+      -- LEFT: HasDerivWithinAt charV_prev on Iic T at T
+      have hV_Lic := h_bV.mono_of_mem_nhdsWithin h_nhd_L
+      have hV_left : HasDerivWithinAt
+          (fun s => if s ≤ T then charV_prev s z
+            else charV_g (s - T) (charX_prev T z, charV_prev T z))
+          (-(convolveFunctionMeasure gradW (spatialMarginal (f_next T))
+              (charX_prev T z)))
+          (Set.Iic T) T := by
+        rw [hfnextT_spat]
+        exact hV_Lic.congr_of_mem (fun s hs => by simp [Set.mem_Iic.mp hs])
+          Set.self_mem_Iic
+      -- RIGHT: chain rule from g's boundary at 0
+      have hV_Ici0 := h_g_bV.mono_of_mem_nhdsWithin h_nhd_R
+      have h_sub_R : HasDerivWithinAt (· - T) 1 (Set.Ici T) T :=
+        ((hasDerivAt_id' T).sub_const T).hasDerivWithinAt
+      have h_mapR : Set.MapsTo (· - T) (Set.Ici T) (Set.Ici 0) :=
+        fun s hs => Set.mem_Ici.mpr (by linarith [Set.mem_Ici.mp hs])
+      have h_chainV : HasDerivWithinAt
+          (fun s => charV_g (s - T) (charX_prev T z, charV_prev T z))
+          (-(convolveFunctionMeasure gradW
+            (spatialMarginal (g 0))
+            (charX_g 0 (charX_prev T z, charV_prev T z))))
+          (Set.Ici T) T := by
+        have := HasDerivWithinAt.scomp_of_eq T hV_Ici0 h_sub_R h_mapR (sub_self T).symm
+        simpa [Function.comp_def, one_smul] using this
+      have hXg0_eq : charX_g 0 (charX_prev T z, charV_prev T z) = charX_prev T z :=
+        (hg_init_cond (charX_prev T z, charV_prev T z)).1
+      have hg0_spat : spatialMarginal (g 0) = spatialMarginal (f_prev T) :=
+        congrArg spatialMarginal hg_init
+      rw [hXg0_eq, hg0_spat, ← hfnextT_spat] at h_chainV
+      have hV_right : HasDerivWithinAt
+          (fun s => if s ≤ T then charV_prev s z
+            else charV_g (s - T) (charX_prev T z, charV_prev T z))
+          (-(convolveFunctionMeasure gradW (spatialMarginal (f_next T))
+              (charX_prev T z)))
+          (Set.Ici T) T :=
+        h_chainV.congr_of_mem
+          (fun s hs => by
+            by_cases hle : s ≤ T
+            · have heq : s = T := le_antisymm hle (Set.mem_Ici.mp hs)
+              simp [heq, sub_self,
+                (hg_init_cond (charX_prev T z, charV_prev T z)).2]
+            · simp [hle])
+          Set.self_mem_Ici
+      have hV_union := hV_left.union hV_right
+      rw [Set.Iic_union_Ici] at hV_union
+      rw [h_t_eq]
+      exact hV_union.hasDerivAt Filter.univ_mem
+  · simp only [ite_eq_right ht_le]
+    push Not at ht_le
+    -- t > T: use hg_boundaryV at (t - T)
+    have htT_mem : t - T ∈ Set.Ioo (0 : ℝ) T_0 := ⟨by linarith, by linarith [ht.2]⟩
+    have h_g_deriv : HasDerivAt (fun s => charV_g s (charX_prev T z, charV_prev T z))
+        (-(convolveFunctionMeasure gradW (spatialMarginal (g (t - T)))
+            (charX_g (t - T) (charX_prev T z, charV_prev T z)))) (t - T) :=
+      (hg_boundaryV (charX_prev T z, charV_prev T z) (t - T)
+          (Set.Ioo_subset_Icc_self htT_mem)).hasDerivAt
+        (Icc_mem_nhds htT_mem.1 htT_mem.2)
+    have h_sub : HasDerivAt (· - T) 1 t := (hasDerivAt_id' t).sub_const T
+    have h_chain : HasDerivAt (fun s => charV_g (s - T) (charX_prev T z, charV_prev T z))
+        (-(convolveFunctionMeasure gradW (spatialMarginal (g (t - T)))
+            (charX_g (t - T) (charX_prev T z, charV_prev T z)))) t := by
+      have := HasDerivAt.scomp_of_eq t h_g_deriv h_sub rfl
+      simpa [Function.comp_def, one_smul] using this
+    -- f_next t = g (t - T) when t > T
+    have h_fnext_t : f_next t = g (t - T) := hf_next_gt t ht_le
+    -- Rewrite derivative value: g (t-T) → f_next t
+    rw [← congrArg spatialMarginal h_fnext_t] at h_chain
+    have h_ev : (fun s => if s ≤ T then charV_prev s z
+        else charV_g (s - T) (charX_prev T z, charV_prev T z)) =ᶠ[nhds t]
+        (fun s => charV_g (s - T) (charX_prev T z, charV_prev T z)) := by
+      apply Filter.Eventually.mono (eventually_gt_nhds ht_le)
+      intro s hs; simp [not_le.mpr hs]
+    exact h_chain.congr_of_eventuallyEq h_ev
+
+/-- The weak PDE holds at every time `t' ≠ T` near the seam: to the left the
+glued solution is `f_prev` (use its weak PDE), to the right it is `g (·−T)`
+(use `g`'s weak PDE with the shift chain rule). -/
+private lemma vlasovGlue_diff_ne
+    {d : ℕ}
+    (gradW : PhysSpace d → PhysSpace d)
+    (f_prev g : ℝ → Measure (PhaseSpace d))
+    {T T_0 : ℝ}
+    (h_prev_vlasov : IsVlasovSolutionOn gradW f_prev T)
+    (h_g_vlasov : IsVlasovSolutionOn gradW g T_0)
+    (f_next : ℝ → Measure (PhaseSpace d))
+    (hf_next_le : ∀ s, s ≤ T → f_next s = f_prev s)
+    (hf_next_gt : ∀ s, T < s → f_next s = g (s - T))
+    (φ : PhaseSpace d → ℝ)
+    (hφ_smooth : ContDiff ℝ (⊤ : ℕ∞) φ) (hφ_compact : HasCompactSupport φ)
+    (gradXφ gradVφ : PhaseSpace d → PhysSpace d)
+    (hgradXφ : ∀ z : PhaseSpace d, gradXφ z = gradient (fun x => φ (x, z.2)) z.1)
+    (hgradVφ : ∀ z : PhaseSpace d, gradVφ z = gradient (fun v => φ (z.1, v)) z.2) :
+    ∀ t' ∈ Set.Ioo (0 : ℝ) (T + T_0), t' ≠ T → HasDerivAt
+      (fun s => ∫ z, φ z ∂f_next s)
+      ((∫ z, (@inner ℝ (PhysSpace d) _ z.2 (gradXφ z) -
+              @inner ℝ (PhysSpace d) _
+                (convolveFunctionMeasure gradW (spatialMarginal (f_next t')) z.1)
+                (gradVφ z)) ∂(f_next t')) + 0) t' := by
+  intro t' ht' ht'_ne
+  rcases lt_or_gt_of_ne ht'_ne with ht'_lt | ht'_gt
+  · -- t' < T: use h_prev_vlasov + bridge f_next = f_prev on left of T
+    have ht'_prev : t' ∈ Set.Ioo (0 : ℝ) T := ⟨ht'.1, ht'_lt⟩
+    have h_ev : (fun s => ∫ z, φ z ∂f_next s) =ᶠ[nhds t']
+        (fun s => ∫ z, φ z ∂f_prev s) := by
+      apply Filter.Eventually.mono (eventually_lt_nhds ht'_lt)
+      intro s hs; simp [hf_next_le s (le_of_lt hs)]
+    have h_fnext_t' : f_next t' = f_prev t' := hf_next_le t' (le_of_lt ht'_lt)
+    have h_deriv := h_prev_vlasov φ hφ_smooth hφ_compact gradXφ gradVφ
+        hgradXφ hgradVφ t' ht'_prev
+    rw [show (fun _ => (0 : ℝ)) t' = 0 from rfl, add_zero] at h_deriv
+    have h_marg : spatialMarginal (f_next t') = spatialMarginal (f_prev t') :=
+      congrArg spatialMarginal h_fnext_t'
+    rw [add_zero, h_marg, h_fnext_t']
+    exact h_deriv.congr_of_eventuallyEq h_ev
+  · -- t' > T: use h_g_vlasov + chain rule + bridge f_next = g (·-T)
+    have ht'_g : t' - T ∈ Set.Ioo (0 : ℝ) T_0 := ⟨by linarith, by linarith [ht'.2]⟩
+    have h_ev : (fun s => ∫ z, φ z ∂f_next s) =ᶠ[nhds t']
+        (fun s => ∫ z, φ z ∂g (s - T)) := by
+      apply Filter.Eventually.mono (eventually_gt_nhds ht'_gt)
+      intro s hs; simp [hf_next_gt s hs]
+    have h_fnext_t' : f_next t' = g (t' - T) := hf_next_gt t' ht'_gt
+    have h_g_deriv := h_g_vlasov φ hφ_smooth hφ_compact gradXφ gradVφ
+        hgradXφ hgradVφ (t' - T) ht'_g
+    rw [show (fun _ => (0 : ℝ)) (t' - T) = 0 from rfl, add_zero] at h_g_deriv
+    have h_sub : HasDerivAt (· - T) 1 t' := (hasDerivAt_id' t').sub_const T
+    have h_chain : HasDerivAt (fun s => ∫ z, φ z ∂g (s - T))
+        (∫ z, (@inner ℝ (PhysSpace d) _ z.2 (gradXφ z) -
+          @inner ℝ (PhysSpace d) _
+            (convolveFunctionMeasure gradW (spatialMarginal (g (t' - T))) z.1)
+            (gradVφ z)) ∂g (t' - T)) t' := by
+      have := HasDerivAt.comp_of_eq t' h_g_deriv h_sub rfl
+      simpa [Function.comp_def, mul_one] using this
+    have h_marg : spatialMarginal (f_next t') = spatialMarginal (g (t' - T)) :=
+      congrArg spatialMarginal h_fnext_t'
+    rw [add_zero, h_marg, h_fnext_t']
+    exact h_chain.congr_of_eventuallyEq h_ev
+
+/-- LEFT seam continuity of the plain test-function integral at `T`: on `Iic T`
+the glued solution agrees with `f_prev`; DCT with the constant dominator `Cφ`
+against the window pushforward. -/
+private lemma vlasovGlue_intCont_left
+    {d : ℕ}
+    (gradW : PhysSpace d → PhysSpace d)
+    (f₀ : Measure (PhaseSpace d)) [IsProbabilityMeasure f₀]
+    {T : ℝ} (hT_pos : 0 < T)
+    (f_prev : ℝ → Measure (PhaseSpace d))
+    (h_prev_init : f_prev 0 = f₀)
+    (charX_prev charV_prev : ℝ → PhaseSpace d → PhysSpace d)
+    (h_prev_push : ∀ t ∈ Set.Icc (0 : ℝ) T,
+        f_prev t =
+          Measure.map (fun z : PhaseSpace d => (charX_prev t z, charV_prev t z)) (f_prev 0))
+    (h_prev_aemeas : ∀ s ∈ Set.Icc (0 : ℝ) T,
+        AEMeasurable (fun z : PhaseSpace d => (charX_prev s z, charV_prev s z)) (f_prev 0))
+    (h_prev_boundary : ∀ (z : PhaseSpace d) (t : ℝ), t ∈ Set.Icc (0 : ℝ) T →
+        HasDerivWithinAt (fun s => charX_prev s z) (charV_prev t z) (Set.Icc 0 T) t ∧
+        HasDerivWithinAt (fun s => charV_prev s z)
+          (-(convolveFunctionMeasure gradW (spatialMarginal (f_prev t)) (charX_prev t z)))
+          (Set.Icc 0 T) t)
+    (f_next : ℝ → Measure (PhaseSpace d))
+    (hf_next_le : ∀ s, s ≤ T → f_next s = f_prev s)
+    (φ : PhaseSpace d → ℝ) (hφ_cont : Continuous φ)
+    (Cφ : ℝ) (hCφ : ∀ z : PhaseSpace d, ‖φ z‖ ≤ Cφ) :
+    ContinuousWithinAt (fun s => ∫ z, φ z ∂f_next s) (Set.Iic T) T := by
+  have h_nhd_L : Set.Icc (0 : ℝ) T ∈ nhdsWithin T (Set.Iic T) :=
+    Icc_mem_nhdsLE hT_pos
+  -- Equation: f_next = f_prev = pushforward of f₀ on Icc 0 T
+  have h_eq_L : (fun s => ∫ z, φ z ∂f_next s) =ᶠ[nhdsWithin T (Set.Iic T)]
+      (fun s => ∫ z, φ (charX_prev s z, charV_prev s z) ∂f₀) := by
+    apply Filter.Eventually.mono h_nhd_L
+    intro s hs
+    change ∫ z, φ z ∂f_next s = ∫ z, φ (charX_prev s z, charV_prev s z) ∂f₀
+    have h_fnext : f_next s = f_prev s := hf_next_le s hs.2
+    have h_aemeas_f₀ : AEMeasurable
+        (fun z : PhaseSpace d => (charX_prev s z, charV_prev s z)) f₀ :=
+      h_prev_init ▸ h_prev_aemeas s hs
+    rw [h_fnext, h_prev_push s hs, h_prev_init]
+    exact integral_map h_aemeas_f₀ hφ_cont.aestronglyMeasurable
+  -- DCT for the pushforward-composed form
+  have h_cont_pf : ContinuousWithinAt
+      (fun s => ∫ z, φ (charX_prev s z, charV_prev s z) ∂f₀) (Set.Iic T) T := by
+    apply continuousWithinAt_of_dominated (bound := fun _ => Cφ)
+    · apply Filter.Eventually.mono h_nhd_L
+      intro s hs
+      have h_pair_aem : AEMeasurable
+          (fun z : PhaseSpace d => (charX_prev s z, charV_prev s z)) f₀ :=
+        h_prev_init ▸ h_prev_aemeas s hs
+      exact (hφ_cont.measurable.comp_aemeasurable h_pair_aem).aestronglyMeasurable
+    · apply Filter.Eventually.mono h_nhd_L
+      intro s _
+      exact Filter.Eventually.of_forall fun z => hCφ _
+    · exact integrable_const _
+    · apply Filter.Eventually.of_forall
+      intro z
+      have hT_Icc : T ∈ Set.Icc (0 : ℝ) T := ⟨hT_pos.le, le_refl T⟩
+      have h_bX := (h_prev_boundary z T hT_Icc).1
+      have h_bV := (h_prev_boundary z T hT_Icc).2
+      have h_pair_Icc : ContinuousWithinAt
+          (fun s => (charX_prev s z, charV_prev s z)) (Set.Icc 0 T) T :=
+        h_bX.continuousWithinAt.prodMk h_bV.continuousWithinAt
+      have h_pair_Iic : ContinuousWithinAt
+          (fun s => (charX_prev s z, charV_prev s z)) (Set.Iic T) T :=
+        h_pair_Icc.mono_of_mem_nhdsWithin h_nhd_L
+      exact hφ_cont.continuousAt.comp_continuousWithinAt h_pair_Iic
+  -- Value at T: bridge via the pushforward formula
+  have h_val_T : (∫ z, φ z ∂f_next T)
+      = ∫ z, φ (charX_prev T z, charV_prev T z) ∂f₀ := by
+    have hT_Icc : T ∈ Set.Icc (0 : ℝ) T := ⟨hT_pos.le, le_refl T⟩
+    have h_fnext_T : f_next T = f_prev T := hf_next_le T (le_refl T)
+    have h_aemeas_f₀_T : AEMeasurable
+        (fun z : PhaseSpace d => (charX_prev T z, charV_prev T z)) f₀ :=
+      h_prev_init ▸ h_prev_aemeas T hT_Icc
+    rw [h_fnext_T, h_prev_push T hT_Icc, h_prev_init]
+    exact integral_map h_aemeas_f₀_T hφ_cont.aestronglyMeasurable
+  exact h_cont_pf.congr_of_eventuallyEq h_eq_L h_val_T
+
+/-- RIGHT seam continuity of the plain test-function integral at `T`: on
+`Ici T` the glued solution is the composed pushforward off `g`; DCT with the
+constant dominator `Cφ`. -/
+private lemma vlasovGlue_intCont_right
+    {d : ℕ}
+    (gradW : PhysSpace d → PhysSpace d)
+    (f₀ : Measure (PhaseSpace d)) [IsProbabilityMeasure f₀]
+    {T : ℝ} (hT_pos : 0 < T) {T_0 : ℝ} (hT_0_pos : 0 < T_0)
+    (f_prev : ℝ → Measure (PhaseSpace d))
+    (h_prev_init : f_prev 0 = f₀)
+    (charX_prev charV_prev : ℝ → PhaseSpace d → PhysSpace d)
+    (h_prev_push : ∀ t ∈ Set.Icc (0 : ℝ) T,
+        f_prev t =
+          Measure.map (fun z : PhaseSpace d => (charX_prev t z, charV_prev t z)) (f_prev 0))
+    (h_prev_aemeas : ∀ s ∈ Set.Icc (0 : ℝ) T,
+        AEMeasurable (fun z : PhaseSpace d => (charX_prev s z, charV_prev s z)) (f_prev 0))
+    (g : ℝ → Measure (PhaseSpace d))
+    (charX_g charV_g : ℝ → PhaseSpace d → PhysSpace d)
+    (hg_init : g 0 = f_prev T)
+    (hg_push_ex : ∀ t ∈ Set.Icc (0 : ℝ) T_0,
+        g t = Measure.map (fun z : PhaseSpace d => (charX_g t z, charV_g t z)) (g 0))
+    (hg_aemeas_ex : ∀ s ∈ Set.Icc (0 : ℝ) T_0,
+        AEMeasurable (fun z : PhaseSpace d => (charX_g s z, charV_g s z)) (g 0))
+    (hg_boundary : ∀ z : PhaseSpace d, ∀ t ∈ Set.Icc (0 : ℝ) T_0,
+        HasDerivWithinAt (fun s => charX_g s z) (charV_g t z) (Set.Icc 0 T_0) t ∧
+        HasDerivWithinAt (fun s => charV_g s z)
+          (-(convolveFunctionMeasure gradW (spatialMarginal (g t)) (charX_g t z)))
+          (Set.Icc 0 T_0) t)
+    (hg_init_cond : ∀ z : PhaseSpace d, charX_g 0 z = z.1 ∧ charV_g 0 z = z.2)
+    (f_next : ℝ → Measure (PhaseSpace d))
+    (hf_next_T : f_next T = f_prev T)
+    (hf_next_gt : ∀ s, T < s → f_next s = g (s - T))
+    (φ : PhaseSpace d → ℝ) (hφ_cont : Continuous φ)
+    (Cφ : ℝ) (hCφ : ∀ z : PhaseSpace d, ‖φ z‖ ≤ Cφ) :
+    ContinuousWithinAt (fun s => ∫ z, φ z ∂f_next s) (Set.Ici T) T := by
+  have h_nhd_R : Set.Icc T (T + T_0) ∈ nhdsWithin T (Set.Ici T) :=
+    Icc_mem_nhdsGE (by linarith : T < T + T_0)
+  have hT_Icc : T ∈ Set.Icc (0 : ℝ) T := ⟨hT_pos.le, le_refl T⟩
+  have h_outer_aemeas : AEMeasurable
+      (fun z : PhaseSpace d => (charX_prev T z, charV_prev T z)) f₀ :=
+    h_prev_init ▸ h_prev_aemeas T hT_Icc
+  -- Eventually-equal: f_next s = composed pushforward on Icc T (T+T_0)
+  have h_eq_R : (fun s => ∫ z, φ z ∂f_next s) =ᶠ[nhdsWithin T (Set.Ici T)]
+      (fun s => ∫ z, φ
+        (charX_g (s - T) (charX_prev T z, charV_prev T z),
+         charV_g (s - T) (charX_prev T z, charV_prev T z)) ∂f₀) := by
+    apply Filter.Eventually.mono h_nhd_R
+    intro s hs
+    change ∫ z, φ z ∂f_next s = ∫ z, φ
+        (charX_g (s - T) (charX_prev T z, charV_prev T z),
+         charV_g (s - T) (charX_prev T z, charV_prev T z)) ∂f₀
+    have hs_T : T ≤ s := hs.1
+    have hsT_Icc : s - T ∈ Set.Icc (0 : ℝ) T_0 :=
+      ⟨by linarith, by linarith [hs.2]⟩
+    by_cases hs_eq : s = T
+    · -- s = T: f_next s = f_next T = f_prev T = (charX_prev T, charV_prev T)#f₀
+      --   RHS at s = T uses hg_init_cond to collapse (charX_g 0, charV_g 0) = id
+      have hs_T_zero : s - T = 0 := by rw [hs_eq]; exact sub_self T
+      have h_fnext_s : f_next s = f_prev T := by
+        rw [hs_eq]; exact hf_next_T
+      rw [h_fnext_s, h_prev_push T hT_Icc, h_prev_init,
+          integral_map h_outer_aemeas hφ_cont.aestronglyMeasurable]
+      congr 1
+      funext z
+      rw [hs_T_zero, (hg_init_cond _).1, (hg_init_cond _).2]
+    · -- s > T: f_next s = g (s - T) = composed pushforward
+      have hs_gt : T < s := lt_of_le_of_ne hs_T (Ne.symm hs_eq)
+      have h_fnext_s : f_next s = g (s - T) := hf_next_gt s hs_gt
+      rw [h_fnext_s, hg_push_ex (s - T) hsT_Icc, hg_init,
+          h_prev_push T hT_Icc, h_prev_init]
+      have h_g_at_sT : AEMeasurable
+          (fun z : PhaseSpace d => (charX_g (s - T) z, charV_g (s - T) z))
+          (Measure.map (fun z : PhaseSpace d =>
+            (charX_prev T z, charV_prev T z)) f₀) := by
+        have := hg_aemeas_ex (s - T) hsT_Icc
+        rw [hg_init, h_prev_push T hT_Icc, h_prev_init] at this
+        exact this
+      have h_comp_aem : AEMeasurable
+          (fun z : PhaseSpace d =>
+            (charX_g (s - T) (charX_prev T z, charV_prev T z),
+             charV_g (s - T) (charX_prev T z, charV_prev T z))) f₀ :=
+        h_g_at_sT.comp_aemeasurable h_outer_aemeas
+      rw [AEMeasurable.map_map_of_aemeasurable h_g_at_sT h_outer_aemeas]
+      exact integral_map h_comp_aem hφ_cont.aestronglyMeasurable
+  -- DCT for the composed-pushforward form
+  have h_cont_pf : ContinuousWithinAt
+      (fun s => ∫ z, φ
+        (charX_g (s - T) (charX_prev T z, charV_prev T z),
+         charV_g (s - T) (charX_prev T z, charV_prev T z)) ∂f₀)
+      (Set.Ici T) T := by
+    apply continuousWithinAt_of_dominated (bound := fun _ => Cφ)
+    · apply Filter.Eventually.mono h_nhd_R
+      intro s hs
+      have hsT_Icc : s - T ∈ Set.Icc (0 : ℝ) T_0 :=
+        ⟨by linarith [hs.1], by linarith [hs.2]⟩
+      have h_g_at_sT : AEMeasurable
+          (fun z : PhaseSpace d => (charX_g (s - T) z, charV_g (s - T) z))
+          (Measure.map (fun z : PhaseSpace d =>
+            (charX_prev T z, charV_prev T z)) f₀) := by
+        have := hg_aemeas_ex (s - T) hsT_Icc
+        rw [hg_init, h_prev_push T hT_Icc, h_prev_init] at this
+        exact this
+      have h_comp_aem : AEMeasurable
+          (fun z : PhaseSpace d =>
+            (charX_g (s - T) (charX_prev T z, charV_prev T z),
+             charV_g (s - T) (charX_prev T z, charV_prev T z))) f₀ :=
+        h_g_at_sT.comp_aemeasurable h_outer_aemeas
+      exact (hφ_cont.measurable.comp_aemeasurable h_comp_aem).aestronglyMeasurable
+    · apply Filter.Eventually.mono h_nhd_R
+      intro s _
+      exact Filter.Eventually.of_forall fun z => hCφ _
+    · exact integrable_const _
+    · -- Pointwise continuity: chain rule for (· - T) at T with charX_g/charV_g at 0
+      apply Filter.Eventually.of_forall
+      intro z
+      have h0_Icc : (0 : ℝ) ∈ Set.Icc (0 : ℝ) T_0 := ⟨le_refl 0, hT_0_pos.le⟩
+      have h_g_bX := (hg_boundary (charX_prev T z, charV_prev T z) 0 h0_Icc).1
+      have h_g_bV := (hg_boundary (charX_prev T z, charV_prev T z) 0 h0_Icc).2
+      have h_nhdsW_0 : Set.Icc (0 : ℝ) T_0 ∈ nhdsWithin 0 (Set.Ici 0) :=
+        Icc_mem_nhdsGE hT_0_pos
+      have h_g_bX_cont : ContinuousWithinAt
+          (fun s' => charX_g s' (charX_prev T z, charV_prev T z))
+          (Set.Ici 0) 0 :=
+        h_g_bX.continuousWithinAt.mono_of_mem_nhdsWithin h_nhdsW_0
+      have h_g_bV_cont : ContinuousWithinAt
+          (fun s' => charV_g s' (charX_prev T z, charV_prev T z))
+          (Set.Ici 0) 0 :=
+        h_g_bV.continuousWithinAt.mono_of_mem_nhdsWithin h_nhdsW_0
+      have h_sub_cont : ContinuousWithinAt (fun s : ℝ => s - T) (Set.Ici T) T :=
+        ((continuous_id.sub continuous_const).continuousAt).continuousWithinAt
+      have h_sub_maps : Set.MapsTo (fun s : ℝ => s - T) (Set.Ici T) (Set.Ici 0) :=
+        fun s hs => Set.mem_Ici.mpr (by linarith [Set.mem_Ici.mp hs])
+      have h_chainX : ContinuousWithinAt
+          (fun s => charX_g (s - T) (charX_prev T z, charV_prev T z))
+          (Set.Ici T) T :=
+        ContinuousWithinAt.comp_of_eq h_g_bX_cont h_sub_cont h_sub_maps (sub_self T)
+      have h_chainV : ContinuousWithinAt
+          (fun s => charV_g (s - T) (charX_prev T z, charV_prev T z))
+          (Set.Ici T) T :=
+        ContinuousWithinAt.comp_of_eq h_g_bV_cont h_sub_cont h_sub_maps (sub_self T)
+      have h_pair : ContinuousWithinAt
+          (fun s => (charX_g (s - T) (charX_prev T z, charV_prev T z),
+                     charV_g (s - T) (charX_prev T z, charV_prev T z)))
+          (Set.Ici T) T :=
+        h_chainX.prodMk h_chainV
+      exact hφ_cont.continuousAt.comp_continuousWithinAt h_pair
+  -- Value at T: integrate the s = T case
+  have h_val_T : (∫ z, φ z ∂f_next T) = ∫ z, φ
+      (charX_g (T - T) (charX_prev T z, charV_prev T z),
+       charV_g (T - T) (charX_prev T z, charV_prev T z)) ∂f₀ := by
+    rw [hf_next_T, h_prev_push T hT_Icc, h_prev_init,
+        integral_map h_outer_aemeas hφ_cont.aestronglyMeasurable]
+    congr 1; funext z
+    rw [show T - T = (0 : ℝ) from sub_self T,
+        (hg_init_cond _).1, (hg_init_cond _).2]
+  exact h_cont_pf.congr_of_eventuallyEq h_eq_R h_val_T
+
+/-- Pushforward equation for the glued solution against the glued piecewise
+flow, on the extended window.  Serves both `IsLagrangianVlasovSolutionOn`'s
+pushforward conjunct and the explicit conjunct (v). -/
+private lemma vlasovGlue_pushforward_eq
+    {d : ℕ}
+    (f_prev g : ℝ → Measure (PhaseSpace d))
+    (charX_prev charV_prev charX_g charV_g : ℝ → PhaseSpace d → PhysSpace d)
+    {T T_0 : ℝ} (hT_pos : 0 < T)
+    (h_prev_push : ∀ t ∈ Set.Icc (0 : ℝ) T,
+        f_prev t =
+          Measure.map (fun z : PhaseSpace d => (charX_prev t z, charV_prev t z)) (f_prev 0))
+    (h_prev_aemeas : ∀ s ∈ Set.Icc (0 : ℝ) T,
+        AEMeasurable (fun z : PhaseSpace d => (charX_prev s z, charV_prev s z)) (f_prev 0))
+    (hg_init : g 0 = f_prev T)
+    (hg_push_ex : ∀ t ∈ Set.Icc (0 : ℝ) T_0,
+        g t = Measure.map (fun z : PhaseSpace d => (charX_g t z, charV_g t z)) (g 0))
+    (hg_aemeas_ex : ∀ s ∈ Set.Icc (0 : ℝ) T_0,
+        AEMeasurable (fun z : PhaseSpace d => (charX_g s z, charV_g s z)) (g 0))
+    (f_next : ℝ → Measure (PhaseSpace d))
+    (hf_next_le : ∀ s, s ≤ T → f_next s = f_prev s)
+    (hf_next_gt : ∀ s, T < s → f_next s = g (s - T))
+    (t : ℝ) (ht : t ∈ Set.Icc (0 : ℝ) (T + T_0)) :
+    f_next t = Measure.map (fun z : PhaseSpace d =>
+      ((if t ≤ T then charX_prev t z
+         else charX_g (t - T) (charX_prev T z, charV_prev T z)),
+       (if t ≤ T then charV_prev t z
+         else charV_g (t - T) (charX_prev T z, charV_prev T z)))) (f_next 0) := by
+  rw [hf_next_le 0 hT_pos.le]
+  by_cases ht_le : t ≤ T
+  · simp only [ite_eq_left ht_le]
+    rw [hf_next_le t ht_le]
+    exact h_prev_push t ⟨ht.1, ht_le⟩
+  · simp only [ite_eq_right ht_le]
+    push Not at ht_le
+    rw [hf_next_gt t ht_le]
+    have hT_mem : T ∈ Set.Icc (0 : ℝ) T := ⟨hT_pos.le, le_refl T⟩
+    have htT_mem : t - T ∈ Set.Icc (0 : ℝ) T_0 := ⟨by linarith, by linarith [ht.2]⟩
+    rw [hg_push_ex (t - T) htT_mem, hg_init, h_prev_push T hT_mem]
+    have h_prev_T_aemeas := h_prev_aemeas T hT_mem
+    have h_g_at_tT := hg_aemeas_ex (t - T) htT_mem
+    rw [hg_init, h_prev_push T hT_mem] at h_g_at_tT
+    rw [AEMeasurable.map_map_of_aemeasurable h_g_at_tT h_prev_T_aemeas]
+    rfl
+
+/-- AEMeasurability of the glued piecewise flow against `f_next 0` on the
+extended window.  Serves both `IsLagrangianVlasovSolutionOn`'s conjunct and
+the explicit conjunct (vi). -/
+private lemma vlasovGlue_flow_aemeasurable
+    {d : ℕ}
+    (f_prev g : ℝ → Measure (PhaseSpace d))
+    (charX_prev charV_prev charX_g charV_g : ℝ → PhaseSpace d → PhysSpace d)
+    {T T_0 : ℝ} (hT_pos : 0 < T)
+    (h_prev_push : ∀ t ∈ Set.Icc (0 : ℝ) T,
+        f_prev t =
+          Measure.map (fun z : PhaseSpace d => (charX_prev t z, charV_prev t z)) (f_prev 0))
+    (h_prev_aemeas : ∀ s ∈ Set.Icc (0 : ℝ) T,
+        AEMeasurable (fun z : PhaseSpace d => (charX_prev s z, charV_prev s z)) (f_prev 0))
+    (hg_init : g 0 = f_prev T)
+    (hg_aemeas_ex : ∀ s ∈ Set.Icc (0 : ℝ) T_0,
+        AEMeasurable (fun z : PhaseSpace d => (charX_g s z, charV_g s z)) (g 0))
+    (f_next : ℝ → Measure (PhaseSpace d))
+    (hf_next_le : ∀ s, s ≤ T → f_next s = f_prev s)
+    (s : ℝ) (hs : s ∈ Set.Icc (0 : ℝ) (T + T_0)) :
+    AEMeasurable (fun z : PhaseSpace d =>
+      ((if s ≤ T then charX_prev s z
+         else charX_g (s - T) (charX_prev T z, charV_prev T z)),
+       (if s ≤ T then charV_prev s z
+         else charV_g (s - T) (charX_prev T z, charV_prev T z)))) (f_next 0) := by
+  rw [hf_next_le 0 hT_pos.le]
+  by_cases hs_le : s ≤ T
+  · simp only [ite_eq_left hs_le]
+    exact h_prev_aemeas s ⟨hs.1, hs_le⟩
+  · simp only [ite_eq_right hs_le]
+    push Not at hs_le
+    have hT_mem : T ∈ Set.Icc (0 : ℝ) T := ⟨hT_pos.le, le_refl T⟩
+    have hsT_mem : s - T ∈ Set.Icc (0 : ℝ) T_0 := ⟨by linarith, by linarith [hs.2]⟩
+    have h_g_at_sT := hg_aemeas_ex (s - T) hsT_mem
+    rw [hg_init, h_prev_push T hT_mem] at h_g_at_sT
+    exact h_g_at_sT.comp_aemeasurable (h_prev_aemeas T hT_mem)
+
+/-- Finite first moment of the glued solution on the extended window,
+piecewise from the two window moment hypotheses. -/
+private lemma vlasovGlue_moment
+    {d : ℕ}
+    (f_prev g : ℝ → Measure (PhaseSpace d))
+    {T T_0 : ℝ}
+    (h_prev_mom : ∀ t ∈ Set.Icc (0 : ℝ) T, HasFiniteFirstMoment (f_prev t))
+    (hg_mom : ∀ t ∈ Set.Icc (0 : ℝ) T_0, HasFiniteFirstMoment (g t))
+    (f_next : ℝ → Measure (PhaseSpace d))
+    (hf_next_le : ∀ s, s ≤ T → f_next s = f_prev s)
+    (hf_next_gt : ∀ s, T < s → f_next s = g (s - T)) :
+    ∀ t ∈ Set.Icc (0 : ℝ) (T + T_0), HasFiniteFirstMoment (f_next t) := by
+  intro t ht
+  by_cases ht_le : t ≤ T
+  · rw [hf_next_le t ht_le]
+    exact h_prev_mom t ⟨ht.1, ht_le⟩
+  · push Not at ht_le
+    rw [hf_next_gt t ht_le]
+    exact hg_mom (t - T) ⟨by linarith, by linarith [ht.2]⟩
+
+/-- FLAT uniform first-moment bound on the glued solution's spatial marginal:
+`max` of the two window envelopes, no cross-term. -/
+private lemma vlasovGlue_moment_flat
+    {d : ℕ}
+    (f_prev g : ℝ → Measure (PhaseSpace d))
+    {T T_0 : ℝ}
+    (hM_prev : ∃ M : ℝ, 0 ≤ M ∧
+        ∀ t ∈ Set.Icc (0 : ℝ) T, ∫ y, ‖y‖ ∂(spatialMarginal (f_prev t)) ≤ M)
+    (hg_mom_unif : ∃ M : ℝ, 0 ≤ M ∧
+        ∀ t ∈ Set.Icc (0 : ℝ) T_0, ∫ y, ‖y‖ ∂(spatialMarginal (g t)) ≤ M)
+    (f_next : ℝ → Measure (PhaseSpace d))
+    (hf_next_le : ∀ s, s ≤ T → f_next s = f_prev s)
+    (hf_next_gt : ∀ s, T < s → f_next s = g (s - T)) :
+    ∃ M : ℝ, 0 ≤ M ∧
+      ∀ t ∈ Set.Icc (0 : ℝ) (T + T_0),
+        ∫ y, ‖y‖ ∂(spatialMarginal (f_next t)) ≤ M := by
+  obtain ⟨M_prev, hM_prev_nn, hM_prev_bd⟩ := hM_prev
+  obtain ⟨M_g, _hM_g_nn, hM_g_bd⟩ := hg_mom_unif
+  refine ⟨max M_prev M_g, le_trans hM_prev_nn (le_max_left _ _), fun t ht => ?_⟩
+  by_cases ht_le : t ≤ T
+  · rw [hf_next_le t ht_le]
+    exact le_trans (hM_prev_bd t ⟨ht.1, ht_le⟩) (le_max_left _ _)
+  · push Not at ht_le
+    rw [hf_next_gt t ht_le]
+    exact le_trans (hM_g_bd (t - T) ⟨by linarith, by linarith [ht.2]⟩) (le_max_right _ _)
+
+/-- **One-window glue step.**
+
+Given a solution `f_prev : ℝ → Measure (PhaseSpace d)` on `[0, T]`
+satisfying the local-existence conjuncts (initial condition + finite first
+moment + `IsLagrangianVlasovSolutionOn`), and a window length `T_0`
+satisfying the smallness constraints `LocalSmallnessPLBuffer L T_0` +
+`LocalSmallnessContraction L T_0`, produces a glued solution
+`f_next : ℝ → Measure (PhaseSpace d)` on `[0, T + T_0]` that agrees with
+`f_prev` on `[0, T]`.
+
+**Proof strategy**:
+
+1. Shift the initial condition: apply `vlasovWellPosedness_local` to
+   `f_prev T` (which has finite first moment by `h_prev_mom T`) with
+   window length `T_0`.  Gives a solution `g : ℝ → Measure (PhaseSpace d)`
+   on `[0, T_0]` with `g 0 = f_prev T`.
+
+2. Glue: define `f_next t := if t ≤ T then f_prev t else g (t - T)`.
+   Agreement at `t = T` is by `g 0 = f_prev T`.
+
+3. Verify the four output conjuncts:
+   - Initial: `f_next 0 = f_prev 0 = f₀`.
+   - Moment: piecewise from `h_prev_mom` and `g`'s moment bound.
+   - `IsLagrangianVlasovSolutionOn` on `[0, T + T_0]`:
+     * `IsVlasovSolutionOn`: weak PDE on `Ioo 0 (T + T_0)` — split at `T`,
+       use `h_prev_lag.1` for `Ioo 0 T` part and `g`'s for `Ioo T (T+T_0)`,
+       continuity at `T` from the integral being continuous.
+     * Flow: glue the per-window flows via standard ODE composition
+       (charX_next(t, z) := if t ≤ T then charX_prev(t, z) else
+       charX_g(t - T, (charX_prev(T, z), charV_prev(T, z)))).
+     * Pushforward equation: holds piecewise.
+     * AEMeasurable witness: composition of AEMeasurable maps. -/
+theorem vlasovWellPosedness_glue
+    {d : ℕ} [NeZero d]
+    (W : PhysSpace d → ℝ)
+    (gradW : PhysSpace d → PhysSpace d)
+    (hgradW : ∀ x, gradW x = gradient W x)
+    (L : NNReal) (hL : LipschitzWith L gradW)
+    (f₀ : Measure (PhaseSpace d))
+    (hf₀ : HasFiniteFirstMoment f₀)
+    {T : ℝ} (hT_pos : 0 < T)
+    (f_prev : ℝ → Measure (PhaseSpace d))
+    (h_prev_init : f_prev 0 = f₀)
+    (h_prev_mom : ∀ t ∈ Set.Icc (0 : ℝ) T, HasFiniteFirstMoment (f_prev t))
+    -- FLAT (window-constant) uniform first-moment bound on f_prev's spatial marginal.
+    (hM_prev : ∃ M : ℝ, 0 ≤ M ∧
+        ∀ t ∈ Set.Icc (0 : ℝ) T, ∫ y, ‖y‖ ∂(spatialMarginal (f_prev t)) ≤ M)
+    -- Explicit flow witnesses for f_prev (avoids witness-identity issues with
+    -- IsLagrangianVlasovSolutionOn)
+    (charX_prev charV_prev : ℝ → PhaseSpace d → PhysSpace d)
+    (h_prev_vlasov : IsVlasovSolutionOn gradW f_prev T)
+    (h_prev_flow : IsCharacteristicFlowOn gradW (fun t => spatialMarginal (f_prev t))
+        charX_prev charV_prev (Set.Ioo 0 T) Set.univ)
+    (h_prev_push : ∀ t ∈ Set.Icc (0 : ℝ) T,
+        f_prev t =
+          Measure.map (fun z : PhaseSpace d => (charX_prev t z, charV_prev t z)) (f_prev 0))
+    (h_prev_aemeas : ∀ s ∈ Set.Icc (0 : ℝ) T,
+        AEMeasurable (fun z : PhaseSpace d => (charX_prev s z, charV_prev s z)) (f_prev 0))
+    (h_prev_boundary : ∀ (z : PhaseSpace d) (t : ℝ), t ∈ Set.Icc (0 : ℝ) T →
+        HasDerivWithinAt (fun s => charX_prev s z) (charV_prev t z) (Set.Icc 0 T) t ∧
+        HasDerivWithinAt (fun s => charV_prev s z)
+          (-(convolveFunctionMeasure gradW (spatialMarginal (f_prev t)) (charX_prev t z)))
+          (Set.Icc 0 T) t)
+    (h_prev_ic : ∀ z : PhaseSpace d, charX_prev 0 z = z.1 ∧ charV_prev 0 z = z.2)
+    {T_0 : ℝ} (hT_0_pos : 0 < T_0)
+    (hT_0_small_PL : LocalSmallnessPLBuffer L T_0)
+    (hT_0_small_con : LocalSmallnessContraction L T_0)
+    (hT_0_small_B : (L : ℝ) / (1 + (L : ℝ)) * (Real.exp ((1 + (L : ℝ)) * T_0) - 1) < 1) :
+    ∃ (f_next : ℝ → Measure (PhaseSpace d))
+      (charX_next charV_next : ℝ → PhaseSpace d → PhysSpace d),
+      (∀ t ∈ Set.Icc (0 : ℝ) T, f_next t = f_prev t) ∧
+      f_next 0 = f₀ ∧
+      (∀ t ∈ Set.Icc (0 : ℝ) (T + T_0), HasFiniteFirstMoment (f_next t)) ∧
+      -- FLAT (window-constant) uniform first-moment bound on the spatial marginal.
+      (∃ M : ℝ, 0 ≤ M ∧
+        ∀ t ∈ Set.Icc (0 : ℝ) (T + T_0), ∫ y, ‖y‖ ∂(spatialMarginal (f_next t)) ≤ M) ∧
+      IsLagrangianVlasovSolutionOn gradW f_next (T + T_0) ∧
+      (∀ t ∈ Set.Icc (0 : ℝ) (T + T_0),
+          f_next t =
+            Measure.map (fun z : PhaseSpace d => (charX_next t z, charV_next t z)) (f_next 0)) ∧
+      (∀ s ∈ Set.Icc (0 : ℝ) (T + T_0),
+          AEMeasurable (fun z : PhaseSpace d => (charX_next s z, charV_next s z)) (f_next 0)) ∧
+      (∀ (z : PhaseSpace d) (t : ℝ), t ∈ Set.Icc (0 : ℝ) (T + T_0) →
+          HasDerivWithinAt (fun s => charX_next s z) (charV_next t z) (Set.Icc 0 (T + T_0)) t ∧
+          HasDerivWithinAt (fun s => charV_next s z)
+            (-(convolveFunctionMeasure gradW (spatialMarginal (f_next t)) (charX_next t z)))
+            (Set.Icc 0 (T + T_0)) t) ∧
+      (∀ z : PhaseSpace d, charX_next 0 z = z.1 ∧ charV_next 0 z = z.2) := by
+  -- The gluing closes the boundary at `t = T` by combining the boundary
+  -- regularity bundles from both windows: HasDerivWithinAt at T from the
+  -- LEFT (via f_prev's boundary bundle at endpoint T) and HasDerivWithinAt
+  -- at 0 from the RIGHT (via g's boundary bundle at endpoint 0), giving
+  -- HasDerivAt at t = T in `f_next`'s frame.
+  --
+  -- Step 1: invoke vlasovWellPosedness_local on f_prev T to get g on [0, T_0]
+  have h_prev_T_mom : HasFiniteFirstMoment (f_prev T) :=
+    h_prev_mom T (Set.right_mem_Icc.mpr hT_pos.le)
+  obtain ⟨g, charX_g, charV_g, hg_init, hg_mom, hg_mom_unif, hg_lag, hg_push_ex, hg_aemeas_ex,
+          hg_boundary, hg_init_cond⟩ :=
+    vlasovWellPosedness_local W gradW hgradW L hL
+      (f_prev T) h_prev_T_mom hT_0_pos hT_0_small_PL hT_0_small_con hT_0_small_B
+  -- Step 2: define the glued solution piecewise
+  let f_next : ℝ → Measure (PhaseSpace d) :=
+    fun t => if t ≤ T then f_prev t else g (t - T)
+  -- Step 3: verify the output conjuncts
+  -- Piecewise flow: for t ≤ T use charX_prev, for t > T compose with charX_g shifted
+  let charX_next : ℝ → PhaseSpace d → PhysSpace d := fun t z =>
+    if t ≤ T then charX_prev t z else charX_g (t - T) (charX_prev T z, charV_prev T z)
+  let charV_next : ℝ → PhaseSpace d → PhysSpace d := fun t z =>
+    if t ≤ T then charV_prev t z else charV_g (t - T) (charX_prev T z, charV_prev T z)
+  have h_g_vlasov : IsVlasovSolutionOn gradW g T_0 := hg_lag.1
+  refine ⟨f_next, charX_next, charV_next, ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_⟩
+  · -- Conjunct (i): agreement on [0, T]
+    intro t ht
+    simp only [f_next]
+    have ht_le : t ≤ T := ht.2
+    simp [ht_le]
+  · -- Conjunct (ii): initial condition f_next 0 = f₀
+    simp only [f_next]
+    have h0_le : (0 : ℝ) ≤ T := hT_pos.le
+    simp [h0_le, h_prev_init]
+  · -- Conjunct (iii): HasFiniteFirstMoment on [0, T + T_0] (hoisted helper)
+    exact vlasovGlue_moment f_prev g h_prev_mom hg_mom f_next
+      (fun s hs => ite_eq_left hs) (fun s hs => ite_eq_right (not_le.mpr hs))
+  · -- Conjunct (iii′): FLAT uniform first-moment bound (hoisted helper)
+    exact vlasovGlue_moment_flat f_prev g hM_prev hg_mom_unif f_next
+      (fun s hs => ite_eq_left hs) (fun s hs => ite_eq_right (not_le.mpr hs))
+  · -- Conjunct (iv): IsLagrangianVlasovSolutionOn gradW f_next (T + T_0)
+    refine ⟨?_, charX_next, charV_next, ?_, ?_, ?_⟩
+    · -- IsVlasovSolutionOn gradW f_next (T + T_0)
+      -- Sub-sorry: PDE gluing — on Ioo 0 (T + T_0), piecewise from h_prev_vlasov and h_g_vlasov
+      -- Sub-sorry (a): IsVlasovSolutionOn for the glued solution.
+      -- Strategy: for t ∈ Ioo 0 T use h_prev_vlasov (with f_next = f_prev near t);
+      -- for t ∈ Ioo T (T+T_0) use h_g_vlasov shifted (f_next t = g (t-T));
+      -- at t = T use continuity of t ↦ ∫ φ ∂f_next t from both sides.
+      have h_vlasov_glue : IsVlasovSolutionOn gradW f_next (T + T_0) := by
+        intro φ hφ_smooth hφ_compact gradXφ gradVφ hgradXφ hgradVφ t ht
+        -- Off-seam weak PDE at every t' ≠ T (hoisted helper); the two strict
+        -- branches consume it directly, the seam derives its eventual form.
+        have h_diff_ne := vlasovGlue_diff_ne gradW f_prev g
+          h_prev_vlasov h_g_vlasov f_next (fun s hs => ite_eq_left hs)
+          (fun s hs => ite_eq_right (not_le.mpr hs)) φ hφ_smooth hφ_compact
+          gradXφ gradVφ hgradXφ hgradVφ
+        by_cases ht_lt : t < T
+        · -- t ∈ Ioo 0 T: off-seam weak PDE
+          rw [show (fun _ => (0 : ℝ)) t = 0 from rfl]
+          exact h_diff_ne t ht (ne_of_lt ht_lt)
+        · by_cases ht_gt : T < t
+          · -- t ∈ Ioo T (T + T_0): off-seam weak PDE
+            rw [show (fun _ => (0 : ℝ)) t = 0 from rfl]
+            exact h_diff_ne t ht (ne_of_gt ht_gt)
+          · -- t = T: boundary case via `hasDerivAt_of_hasDerivAt_of_ne_in_nhds`.
+            -- Three sub-arguments: (1) HasDerivAt at every nearby t' ≠ T from the
+            -- off-seam helper; (2) ContinuousAt of the integral function at T;
+            -- (3) ContinuousAt of the derivative function at T.
+            push Not at ht_gt
+            have h_t_eq : t = T := le_antisymm ht_gt (not_lt.mp ht_lt)
+            -- Step 1: HasDerivAt at every nearby t' ≠ T, in eventual form.
+            have h_diff_ne_ev : ∀ᶠ t' in nhds T, t' ≠ T → HasDerivAt
+                (fun s => ∫ z, φ z ∂f_next s)
+                ((∫ z, (@inner ℝ (PhysSpace d) _ z.2 (gradXφ z) -
+                        @inner ℝ (PhysSpace d) _
+                          (convolveFunctionMeasure gradW (spatialMarginal (f_next t')) z.1)
+                          (gradVφ z)) ∂(f_next t')) + 0) t' := by
+              have hU_mem : Set.Ioo (0 : ℝ) (T + T_0) ∈ nhds T :=
+                Ioo_mem_nhds hT_pos (by linarith)
+              exact Filter.Eventually.mono hU_mem (fun t' ht' => h_diff_ne t' ht')
+            -- Step 2: ContinuousAt of integral function at T.
+            -- Decomposed into LEFT (Iic T) + RIGHT (Ici T) closes, joined via
+            -- `Iic_union_Ici = univ`.
+            have hφ_cont : Continuous φ := hφ_smooth.continuous
+            obtain ⟨Cφ, hCφ⟩ := hφ_cont.bounded_above_of_compact_support hφ_compact
+            obtain ⟨hf₀_prob, hf₀_int⟩ := hf₀
+            have : IsProbabilityMeasure f₀ := hf₀_prob
+            -- LEFT side: substantive close via DCT on f_prev's pushforward.
+            have h_cont_f_left : ContinuousWithinAt (fun s => ∫ z, φ z ∂f_next s)
+                (Set.Iic T) T :=
+              vlasovGlue_intCont_left gradW f₀ hT_pos f_prev h_prev_init
+                charX_prev charV_prev h_prev_push h_prev_aemeas h_prev_boundary
+                f_next (fun s hs => ite_eq_left hs) φ hφ_cont Cφ hCφ
+            -- RIGHT side: substantive close via DCT on the composed pushforward
+            -- (charX_g (s-T), charV_g (s-T)) ∘ (charX_prev T, charV_prev T).
+            -- At s = T, hg_init_cond bridges (charX_g 0, charV_g 0) = id, matching f_prev T.
+            have h_cont_f_right : ContinuousWithinAt (fun s => ∫ z, φ z ∂f_next s)
+                (Set.Ici T) T :=
+              vlasovGlue_intCont_right gradW f₀ hT_pos hT_0_pos f_prev h_prev_init
+                charX_prev charV_prev h_prev_push h_prev_aemeas g charX_g charV_g
+                hg_init hg_push_ex hg_aemeas_ex hg_boundary hg_init_cond
+                f_next (ite_eq_left (le_refl T)) (fun s hs => ite_eq_right (not_le.mpr hs))
+                φ hφ_cont Cφ hCφ
+            -- Combine via union
+            have h_cont_f : ContinuousAt (fun s => ∫ z, φ z ∂f_next s) T := by
+              have h_union := h_cont_f_left.union h_cont_f_right
+              rw [Set.Iic_union_Ici] at h_union
+              exact h_union.continuousAt Filter.univ_mem
+            -- Step 3: ContinuousAt of the derivative functional at the seam T.
+            -- Mirror `h_cont_f`'s one-sided-union structure (Iic/Ici +
+            -- `Set.Iic_union_Ici`).  Each side discharges by push-to-f₀ +
+            -- DCT; the integrand's force term carries
+            -- `convolveFunctionMeasure gradW (spatialMarginal (f_next ·)) z.1`, whose
+            -- seam continuity closes from PROVEN TOOLS via the pushforward
+            -- representation: `f_prev`/`g` are flow-pushforwards of `f₀`, so the
+            -- convolution rewrites by `integral_map` to a fixed-`f₀` integral, closed
+            -- by the inner kernels `flowConv_continuousWithinAt_{Iic,Ici}_seam`
+            -- (Piece-A-dominated DCT).  LEFT uses `spatialMarginal (f_prev ·)`,
+            -- RIGHT the composed flow off `g`.
+            have h_cont_g : ContinuousAt (fun t' =>
+                (∫ z, (@inner ℝ (PhysSpace d) _ z.2 (gradXφ z) -
+                        @inner ℝ (PhysSpace d) _
+                          (convolveFunctionMeasure gradW (spatialMarginal (f_next t')) z.1)
+                          (gradVφ z)) ∂(f_next t')) + 0) T := by
+              simp only [add_zero]
+              -- LEFT side (s ≤ T): f_next = f_prev = pushforward of f₀; force term
+              -- uses `spatialMarginal (f_prev ·)`.  Discharge: push-to-f₀ + DCT.
+              have h_left : ContinuousWithinAt
+                  (fun s => ∫ z, (@inner ℝ (PhysSpace d) _ z.2 (gradXφ z) -
+                          @inner ℝ (PhysSpace d) _
+                            (convolveFunctionMeasure gradW (spatialMarginal (f_next s)) z.1)
+                            (gradVφ z)) ∂(f_next s)) (Set.Iic T) T :=
+                vlasovGlue_seam_contLeft gradW L hL f₀ hf₀_int hT_pos f_prev h_prev_init
+                  h_prev_mom hM_prev charX_prev charV_prev h_prev_push h_prev_aemeas
+                  h_prev_boundary h_prev_ic f_next (fun s hs => ite_eq_left hs)
+                  φ hφ_smooth hφ_compact gradXφ gradVφ hgradXφ hgradVφ
+              -- RIGHT side (s ≥ T): f_next = g (·−T) = composed pushforward; symmetric
+              -- to `h_left`.  The flow is the COMPOSED phase-space flow
+              -- `Φ_s z = (charX_g (s−T) (charX_prev T z, charV_prev T z),
+              --           charV_g (s−T) (charX_prev T z, charV_prev T z))`, and the
+              -- position part `Z_s z = charX_g (s−T) (charX_prev T z, charV_prev T z)`
+              -- is what the force-term convolution sees.  Pushforward, AEMeasurability,
+              -- and seam continuity are copied/adapted from the PROVEN
+              -- `h_cont_f_right` (composed-pushforward machinery); the growth bound is
+              -- the composed Piece A (g over [0,T_0] ∘ prev at T); the force-term seam
+              -- continuity uses the `Ici` sibling kernel `flowConv_continuousWithinAt_Ici_seam`.
+              have h_right : ContinuousWithinAt
+                  (fun s => ∫ z, (@inner ℝ (PhysSpace d) _ z.2 (gradXφ z) -
+                          @inner ℝ (PhysSpace d) _
+                            (convolveFunctionMeasure gradW (spatialMarginal (f_next s)) z.1)
+                            (gradVφ z)) ∂(f_next s)) (Set.Ici T) T :=
+                vlasovGlue_seam_contRight gradW L hL f₀ hf₀_int hT_pos hT_0_pos
+                  f_prev h_prev_init h_prev_mom hM_prev charX_prev charV_prev
+                  h_prev_push h_prev_aemeas h_prev_boundary h_prev_ic
+                  g charX_g charV_g hg_init hg_mom hg_mom_unif hg_push_ex
+                  hg_aemeas_ex hg_boundary hg_init_cond f_next
+                  (ite_eq_left (le_refl T)) (fun s hs => ite_eq_right (not_le.mpr hs))
+                  φ hφ_smooth hφ_compact gradXφ gradVφ hgradXφ hgradVφ
+              have h_union := h_left.union h_right
+              rw [Set.Iic_union_Ici] at h_union
+              exact h_union.continuousAt Filter.univ_mem
+            -- Step 4: Apply the localized helper.
+            rw [h_t_eq]
+            exact hasDerivAt_of_hasDerivAt_of_ne_in_nhds h_diff_ne_ev h_cont_f h_cont_g
+      exact h_vlasov_glue
+    · -- IsCharacteristicFlowOn for the glued flow
+      -- Sub-sorry: flow initial condition + HasDerivAt for piecewise flow
+      have h_flow_glue : IsCharacteristicFlowOn gradW
+          (fun t => spatialMarginal (f_next t)) charX_next charV_next
+          (Set.Ioo 0 (T + T_0)) Set.univ := by
+        refine ⟨?_, ?_, ?_⟩
+        · -- Initial condition: charX_next 0 z = z.1 ∧ charV_next 0 z = z.2
+          intro z _
+          simp only [charX_next, charV_next, ite_eq_left hT_pos.le]
+          exact h_prev_flow.1 z (Set.mem_univ z)
+        · -- HasDerivAt charX_next at t for t ∈ Ioo 0 (T + T_0) (hoisted helper)
+          intro t ht z _
+          simp only [charX_next, charV_next]
+          exact vlasovGlue_flowX_hasDerivAt charX_prev charV_prev charX_g charV_g
+            hT_pos hT_0_pos
+            (fun t' ht' z' => h_prev_flow.2.1 t' ht' z' (Set.mem_univ z'))
+            (fun z' t' ht' => (h_prev_boundary z' t' ht').1)
+            (fun z' t' ht' => (hg_boundary z' t' ht').1)
+            hg_init_cond t ht z
+        · -- HasDerivAt charV_next at t for t ∈ Ioo 0 (T + T_0) (hoisted helper)
+          intro t ht z _
+          simp only [charX_next, charV_next]
+          exact vlasovGlue_flowV_hasDerivAt gradW f_prev g charX_prev charV_prev
+            charX_g charV_g hT_pos hT_0_pos
+            (fun t' ht' z' => h_prev_flow.2.2 t' ht' z' (Set.mem_univ z'))
+            (fun z' t' ht' => (h_prev_boundary z' t' ht').2)
+            (fun z' t' ht' => (hg_boundary z' t' ht').2)
+            hg_init hg_init_cond f_next (fun s hs => ite_eq_left hs)
+            (fun s hs => ite_eq_right (not_le.mpr hs)) t ht z
+      exact h_flow_glue
+    · -- Pushforward equation for f_next on Icc 0 (T + T_0) (hoisted helper)
+      intro t ht
+      simp only [charX_next, charV_next]
+      exact vlasovGlue_pushforward_eq f_prev g charX_prev charV_prev charX_g charV_g
+        hT_pos h_prev_push h_prev_aemeas hg_init hg_push_ex hg_aemeas_ex f_next
+        (fun s hs => ite_eq_left hs) (fun s hs => ite_eq_right (not_le.mpr hs)) t ht
+    · -- AEMeasurability ∧ boundary ContinuousOn on Icc 0 (T + T_0).
+      refine ⟨?_, ?_⟩
+      · -- AEMeasurability of the glued flow (hoisted helper).
+        intro s hs
+        simp only [charX_next, charV_next]
+        exact vlasovGlue_flow_aemeasurable f_prev g charX_prev charV_prev
+          charX_g charV_g hT_pos h_prev_push h_prev_aemeas hg_init hg_aemeas_ex
+          f_next (fun s' hs' => ite_eq_left hs') s hs
+      · -- Boundary ContinuousOn on Icc 0 (T + T_0): project the boundary bundle.
+        intro z s hs
+        exact ((vlasovWellPosedness_glue_boundary gradW hT_pos hT_0_pos f_prev g f_next
+          charX_prev charV_prev charX_g charV_g charX_next charV_next rfl rfl rfl
+          h_prev_boundary hg_boundary hg_init hg_init_cond z s hs).1.continuousWithinAt.prodMk
+          (vlasovWellPosedness_glue_boundary gradW hT_pos hT_0_pos f_prev g f_next
+            charX_prev charV_prev charX_g charV_g charX_next charV_next rfl rfl rfl
+            h_prev_boundary hg_boundary hg_init hg_init_cond z s hs).2.continuousWithinAt)
+  · -- Conjunct (v): explicit pushforward for charX_next charV_next (hoisted helper)
+    intro t ht
+    simp only [charX_next, charV_next]
+    exact vlasovGlue_pushforward_eq f_prev g charX_prev charV_prev charX_g charV_g
+      hT_pos h_prev_push h_prev_aemeas hg_init hg_push_ex hg_aemeas_ex f_next
+      (fun s hs => ite_eq_left hs) (fun s hs => ite_eq_right (not_le.mpr hs)) t ht
+  · -- Conjunct (vi): AEMeasurable for charX_next charV_next (hoisted helper)
+    intro s hs
+    simp only [charX_next, charV_next]
+    exact vlasovGlue_flow_aemeasurable f_prev g charX_prev charV_prev
+      charX_g charV_g hT_pos h_prev_push h_prev_aemeas hg_init hg_aemeas_ex
+      f_next (fun s' hs' => ite_eq_left hs') s hs
+  · -- Conjunct (vii): boundary bundle for charX_next charV_next on Icc 0 (T + T_0)
+    exact vlasovWellPosedness_glue_boundary gradW hT_pos hT_0_pos f_prev g f_next
+      charX_prev charV_prev charX_g charV_g charX_next charV_next rfl rfl rfl
+      h_prev_boundary hg_boundary hg_init hg_init_cond
+  · -- Conjunct (viii): initial condition for charX_next charV_next
+    intro z
+    simp only [charX_next, charV_next, ite_eq_left hT_pos.le]
+    exact h_prev_ic z
+
+/-- For every positive Lipschitz constant there is a window length satisfying all
+three per-window smallness constraints — the PL buffer, the contraction, and the
+envelope closure.  Pure threshold arithmetic: `T_0 := min(1/√L, T_0_con, T_0_env)/2`
+with each threshold positive for every `L > 0` (no `L < 1` restriction). -/
+lemma exists_localSmallness_window (L : NNReal) (hL_pos : (0 : ℝ) < L) :
+    ∃ T_0 : ℝ, 0 < T_0 ∧ LocalSmallnessPLBuffer L T_0 ∧ LocalSmallnessContraction L T_0 ∧
+      (L : ℝ) / (1 + (L : ℝ)) * (Real.exp ((1 + (L : ℝ)) * T_0) - 1) < 1 := by
+  let T_0_PL : ℝ := 1 / Real.sqrt L
+  let T_0_con : ℝ := Real.log (max 1 (L : ℝ) / (L : ℝ) + 1) / max 1 (L : ℝ)
+  let T_0_env : ℝ := Real.log (1 + (1 + (L : ℝ)) / (L : ℝ)) / (1 + (L : ℝ))
+  let T_0 : ℝ := min (min T_0_PL T_0_con) T_0_env / 2
+  have hL_nn : (0 : ℝ) ≤ L := NNReal.coe_nonneg L
+  have hL_ne : (L : ℝ) ≠ 0 := ne_of_gt hL_pos
+  have hsqrtL_pos : 0 < Real.sqrt (L : ℝ) := Real.sqrt_pos.mpr hL_pos
+  have hs_eq : (Real.sqrt (L : ℝ)) ^ 2 = (L : ℝ) := Real.sq_sqrt hL_nn
+  have hK_pos : (0 : ℝ) < max 1 (L : ℝ) := lt_of_lt_of_le one_pos (le_max_left _ _)
+  have hT_0_PL_pos : 0 < T_0_PL := by
+    change 0 < 1 / Real.sqrt (L : ℝ); positivity
+  have hKL_gt1 : 1 < max 1 (L : ℝ) / (L : ℝ) + 1 := by
+    have : 0 < max 1 (L : ℝ) / (L : ℝ) := div_pos hK_pos hL_pos
+    linarith
+  have hT_0_con_pos : 0 < T_0_con :=
+    div_pos (Real.log_pos hKL_gt1) hK_pos
+  have h_1L_pos : (0 : ℝ) < 1 + (L : ℝ) := by linarith [hL_pos]
+  have hT_0_env_pos : 0 < T_0_env := by
+    change 0 < Real.log (1 + (1 + (L : ℝ)) / (L : ℝ)) / (1 + (L : ℝ))
+    have h_arg_gt1 : 1 < 1 + (1 + (L : ℝ)) / (L : ℝ) := by
+      have : 0 < (1 + (L : ℝ)) / (L : ℝ) := by positivity
+      linarith
+    exact div_pos (Real.log_pos h_arg_gt1) h_1L_pos
+  have hT_0_min_pos : 0 < min (min T_0_PL T_0_con) T_0_env :=
+    lt_min (lt_min hT_0_PL_pos hT_0_con_pos) hT_0_env_pos
+  have hT0_pos : 0 < T_0 := by
+    change 0 < min (min T_0_PL T_0_con) T_0_env / 2; linarith
+  have hTL_T0_PL : LocalSmallnessPLBuffer L T_0 := by
+    change (L : ℝ) * T_0 ^ 2 < 1
+    have h_T_0_le : T_0 ≤ 1 / (2 * Real.sqrt (L : ℝ)) := by
+      change min (min T_0_PL T_0_con) T_0_env / 2 ≤ 1 / (2 * Real.sqrt (L : ℝ))
+      have h_min_le : min (min T_0_PL T_0_con) T_0_env ≤ T_0_PL :=
+        le_trans (min_le_left _ _) (min_le_left _ _)
+      have hrw : (1 : ℝ) / (2 * Real.sqrt (L : ℝ)) = (1 / Real.sqrt (L : ℝ)) / 2 := by
+        rw [div_div, mul_comm (2 : ℝ) (Real.sqrt (L : ℝ))]
+      rw [hrw]
+      have hTPL : T_0_PL = 1 / Real.sqrt (L : ℝ) := rfl
+      rw [hTPL] at h_min_le; linarith
+    have h_T_0_nn : 0 ≤ T_0 := le_of_lt hT0_pos
+    have h_sq_le : T_0 ^ 2 ≤ (1 / (2 * Real.sqrt (L : ℝ))) ^ 2 :=
+      pow_le_pow_left₀ h_T_0_nn h_T_0_le 2
+    have h_mul_le : (L : ℝ) * T_0 ^ 2 ≤ (L : ℝ) * (1 / (2 * Real.sqrt (L : ℝ))) ^ 2 :=
+      mul_le_mul_of_nonneg_left h_sq_le hL_nn
+    have h_eq : (L : ℝ) * (1 / (2 * Real.sqrt (L : ℝ))) ^ 2 = 1 / 4 := by
+      rw [div_pow, one_pow, mul_pow, hs_eq]; field_simp; ring
+    rw [h_eq] at h_mul_le; linarith
+  have hTL_T0_con : LocalSmallnessContraction L T_0 := by
+    change (L : ℝ) * (Real.exp ((max 1 (L : ℝ)) * T_0) - 1) / (max 1 (L : ℝ)) < 1
+    set K : ℝ := max 1 (L : ℝ) with hK_def
+    have h_T_0_lt : T_0 < T_0_con := by
+      change min (min T_0_PL T_0_con) T_0_env / 2 < T_0_con
+      have h_min_le : min (min T_0_PL T_0_con) T_0_env ≤ T_0_con :=
+        le_trans (min_le_left _ _) (min_le_right _ _)
+      linarith
+    have hKL1_pos : (0 : ℝ) < K / (L : ℝ) + 1 := by
+      have : 0 < K / (L : ℝ) := div_pos hK_pos hL_pos
+      linarith
+    have h_KT0_lt : K * T_0 < Real.log (K / (L : ℝ) + 1) := by
+      have hTcon : T_0_con = Real.log (K / (L : ℝ) + 1) / K := rfl
+      rw [hTcon] at h_T_0_lt
+      have hh := (lt_div_iff₀ hK_pos).mp h_T_0_lt
+      nlinarith [hh]
+    have h_exp_lt : Real.exp (K * T_0) < K / (L : ℝ) + 1 := by
+      have := Real.exp_lt_exp.mpr h_KT0_lt
+      rwa [Real.exp_log hKL1_pos] at this
+    have h_sub_lt : Real.exp (K * T_0) - 1 < K / (L : ℝ) := by linarith
+    have h_num_lt : (L : ℝ) * (Real.exp (K * T_0) - 1) < K := by
+      have := mul_lt_mul_of_pos_left h_sub_lt hL_pos
+      rwa [mul_div_cancel₀ _ hL_ne] at this
+    rw [div_lt_one hK_pos]
+    exact h_num_lt
+  have hTL_T0_B :
+      (L : ℝ) / (1 + (L : ℝ)) * (Real.exp ((1 + (L : ℝ)) * T_0) - 1) < 1 := by
+    have hL_ne : (L : ℝ) ≠ 0 := ne_of_gt hL_pos
+    have h_1L_ne : (1 + (L : ℝ)) ≠ 0 := ne_of_gt h_1L_pos
+    have h_ratio_pos : (0 : ℝ) < (1 + (L : ℝ)) / (L : ℝ) := div_pos h_1L_pos hL_pos
+    have h_arg_pos : (0 : ℝ) < 1 + (1 + (L : ℝ)) / (L : ℝ) := by linarith
+    have h_T_0_lt_env : T_0 < T_0_env := by
+      change min (min T_0_PL T_0_con) T_0_env / 2 < T_0_env
+      have h_min_le : min (min T_0_PL T_0_con) T_0_env ≤ T_0_env := min_le_right _ _
+      linarith
+    have h_lin_lt : (1 + (L : ℝ)) * T_0
+        < Real.log (1 + (1 + (L : ℝ)) / (L : ℝ)) := by
+      have h_env_eq : (1 + (L : ℝ)) * T_0_env
+          = Real.log (1 + (1 + (L : ℝ)) / (L : ℝ)) := by
+        change (1 + (L : ℝ)) *
+            (Real.log (1 + (1 + (L : ℝ)) / (L : ℝ)) / (1 + (L : ℝ)))
+          = Real.log (1 + (1 + (L : ℝ)) / (L : ℝ))
+        field_simp
+      calc (1 + (L : ℝ)) * T_0
+          < (1 + (L : ℝ)) * T_0_env := mul_lt_mul_of_pos_left h_T_0_lt_env h_1L_pos
+        _ = Real.log (1 + (1 + (L : ℝ)) / (L : ℝ)) := h_env_eq
+    have h_exp_lt : Real.exp ((1 + (L : ℝ)) * T_0)
+        < 1 + (1 + (L : ℝ)) / (L : ℝ) := by
+      calc Real.exp ((1 + (L : ℝ)) * T_0)
+          < Real.exp (Real.log (1 + (1 + (L : ℝ)) / (L : ℝ))) :=
+            Real.exp_lt_exp.mpr h_lin_lt
+        _ = 1 + (1 + (L : ℝ)) / (L : ℝ) := Real.exp_log h_arg_pos
+    have h_diff_lt : Real.exp ((1 + (L : ℝ)) * T_0) - 1 < (1 + (L : ℝ)) / (L : ℝ) := by
+      linarith
+    have hcoef_pos : (0 : ℝ) < (L : ℝ) / (1 + (L : ℝ)) := div_pos hL_pos h_1L_pos
+    calc (L : ℝ) / (1 + (L : ℝ)) * (Real.exp ((1 + (L : ℝ)) * T_0) - 1)
+        < (L : ℝ) / (1 + (L : ℝ)) * ((1 + (L : ℝ)) / (L : ℝ)) :=
+          mul_lt_mul_of_pos_left h_diff_lt hcoef_pos
+      _ = 1 := by field_simp
+  exact ⟨T_0, hT0_pos, hTL_T0_PL, hTL_T0_con, hTL_T0_B⟩
+
+/-- **Forward iteration to arbitrary `T_target`.**
+
+Extends the local-existence theorem from its small-`T` smallness window
+to any `T_target > 0`, by iterating the local theorem with shifted initial
+data at a fixed step `T_0` depending only on `L` (no `L < 1` hypothesis).
+
+**Proof strategy**:
+
+1. Pick `T_0 := min(T_0_PL, T_0_con, T_0_env) / 2`, with `T_0_PL := 1/√L`
+   (the PL-buffer threshold for `L · T_0² < 1`), `T_0_con`/`T_0_env` the
+   contraction/envelope thresholds.  Each is positive for every `L > 0`, so
+   `T_0 > 0` and all three smallness constraints hold.
+
+2. Pick `N := ⌈T_target / T_0⌉₊` so that `N · T_0 ≥ T_target`.
+
+3. `Nat.rec` construction: a solution holding the conjuncts at `T = n·T_0`.
+   - Base case: apply `vlasovWellPosedness_local` directly.
+   - Step case (`n → n+1`): apply `vlasovWellPosedness_glue` to extend.
+
+4. Take `f := f_N` and verify the conjuncts for `T_target ≤ N · T_0` via
+   `IsLagrangianVlasovSolutionOn`'s monotonicity in `T` (project down). -/
+theorem vlasovWellPosedness_forward
+    {d : ℕ} [NeZero d]
+    (W : PhysSpace d → ℝ)
+    (gradW : PhysSpace d → PhysSpace d)
+    (hgradW : ∀ x, gradW x = gradient W x)
+    (L : NNReal) (hL : LipschitzWith L gradW)
+    (hL_pos : (0 : ℝ) < L)
+    (f₀ : Measure (PhaseSpace d))
+    (hf₀ : HasFiniteFirstMoment f₀)
+    {T_target : ℝ} (hT_target : 0 < T_target) :
+    ∃ f : ℝ → Measure (PhaseSpace d),
+      f 0 = f₀ ∧
+      (∀ t ∈ Set.Icc (0 : ℝ) T_target, HasFiniteFirstMoment (f t)) ∧
+      IsLagrangianVlasovSolutionOn gradW f T_target := by
+  -- T_0 must satisfy the PL-buffer, contraction, and envelope constraints —
+  -- all supplied by the pure-arithmetic `exists_localSmallness_window`.
+  obtain ⟨T_0, hT0_pos, hTL_T0_PL, hTL_T0_con, hTL_T0_B⟩ :=
+    exists_localSmallness_window L hL_pos
+  -- Step 2: N = ⌈T_target / T_0⌉₊ windows of size T_0 cover T_target.
+  let N : ℕ := ⌈T_target / T_0⌉₊
+  have hN_pos : 0 < N := by
+    change 0 < ⌈T_target / T_0⌉₊
+    rw [Nat.ceil_pos]
+    exact div_pos hT_target hT0_pos
+  have hN_covers : T_target ≤ (N : ℝ) * T_0 := by
+    have hle := Nat.le_ceil (T_target / T_0)
+    have hT0_pos' := hT0_pos
+    calc T_target = T_target / T_0 * T_0 := by field_simp
+         _ ≤ (⌈T_target / T_0⌉₊ : ℝ) * T_0 :=
+              mul_le_mul_of_nonneg_right hle (le_of_lt hT0_pos)
+  -- Step 3: Induction on n : ℕ — solution exists on [0, (n+1)·T_0].
+  -- The induction carries explicit flow witnesses (charX, charV) and the full
+  -- 7-component bundle to enable vlasovWellPosedness_glue calls without witness-identity issues.
+  let T_n := fun n : ℕ => ((n + 1 : ℕ) : ℝ) * T_0
+  have h_ind : ∀ n : ℕ,
+      ∃ (f : ℝ → Measure (PhaseSpace d))
+        (charX charV : ℝ → PhaseSpace d → PhysSpace d),
+        f 0 = f₀ ∧
+        (∀ t ∈ Set.Icc (0 : ℝ) (T_n n), HasFiniteFirstMoment (f t)) ∧
+        -- FLAT (window-constant) uniform first-moment bound on the spatial marginal.
+        (∃ M : ℝ, 0 ≤ M ∧
+          ∀ t ∈ Set.Icc (0 : ℝ) (T_n n), ∫ y, ‖y‖ ∂(spatialMarginal (f t)) ≤ M) ∧
+        IsVlasovSolutionOn gradW f (T_n n) ∧
+        (∀ t ∈ Set.Icc (0 : ℝ) (T_n n),
+            f t = Measure.map (fun z : PhaseSpace d => (charX t z, charV t z)) (f 0)) ∧
+        (∀ s ∈ Set.Icc (0 : ℝ) (T_n n),
+            AEMeasurable (fun z : PhaseSpace d => (charX s z, charV s z)) (f 0)) ∧
+        (∀ (z : PhaseSpace d) (t : ℝ), t ∈ Set.Icc (0 : ℝ) (T_n n) →
+            HasDerivWithinAt (fun s => charX s z) (charV t z) (Set.Icc 0 (T_n n)) t ∧
+            HasDerivWithinAt (fun s => charV s z)
+              (-(convolveFunctionMeasure gradW (spatialMarginal (f t)) (charX t z)))
+              (Set.Icc 0 (T_n n)) t) ∧
+        (∀ z : PhaseSpace d, charX 0 z = z.1 ∧ charV 0 z = z.2) := by
+    intro n
+    induction n with
+    | zero =>
+      -- Base: n = 0, need solution on [0, 1·T_0] = [0, T_0].
+      simp only [T_n, zero_add, Nat.cast_one, one_mul]
+      obtain ⟨f, charX, charV, hf_init, hf_mom, hf_mom_unif, hf_lag, hf_push, hf_aemeas,
+        hf_boundary, hf_ic⟩ :=
+        vlasovWellPosedness_local W gradW hgradW L hL f₀ hf₀ hT0_pos hTL_T0_PL hTL_T0_con hTL_T0_B
+      exact ⟨f, charX, charV, hf_init, hf_mom, hf_mom_unif, hf_lag.1, hf_push, hf_aemeas,
+        hf_boundary, hf_ic⟩
+    | succ n ih =>
+      -- Step: n+1 → (n+2)·T_0.  Use vlasovWellPosedness_glue with T = (n+1)·T_0 > 0.
+      obtain ⟨f_n, charX_n, charV_n, hfn_init, hfn_mom, hfn_mom_unif, hfn_vlasov,
+              hfn_push, hfn_aemeas, hfn_boundary, hfn_ic⟩ := ih
+      simp only [T_n] at hfn_mom hfn_mom_unif hfn_vlasov hfn_push hfn_aemeas hfn_boundary
+      have hT_n_pos : (0 : ℝ) < ((n + 1 : ℕ) : ℝ) * T_0 :=
+        mul_pos (by exact_mod_cast Nat.succ_pos n) hT0_pos
+      -- Derive IsCharacteristicFlowOn from h_prev_boundary + hasDerivAt
+      -- (interior points t ∈ Ioo 0 T_n have Icc 0 T_n ∈ 𝓝 t, so HasDerivWithinAt → HasDerivAt)
+      have hfn_flow : IsCharacteristicFlowOn gradW (fun t => spatialMarginal (f_n t))
+          charX_n charV_n (Set.Ioo 0 (((n + 1 : ℕ) : ℝ) * T_0)) Set.univ := by
+        refine ⟨fun z _ => hfn_ic z, ?_, ?_⟩
+        · intro t ht z _
+          exact ((hfn_boundary z t (Set.Ioo_subset_Icc_self ht)).1).hasDerivAt
+            (Icc_mem_nhds ht.1 ht.2)
+        · intro t ht z _
+          exact ((hfn_boundary z t (Set.Ioo_subset_Icc_self ht)).2).hasDerivAt
+            (Icc_mem_nhds ht.1 ht.2)
+      obtain ⟨f_next, charX_next, charV_next, _h_agree, h_init, h_mom, h_mom_unif, h_lag,
+              h_push, h_aemeas, h_boundary, h_ic⟩ :=
+        vlasovWellPosedness_glue W gradW hgradW L hL f₀ hf₀ hT_n_pos
+          f_n hfn_init hfn_mom hfn_mom_unif
+          charX_n charV_n hfn_vlasov hfn_flow
+          hfn_push hfn_aemeas hfn_boundary hfn_ic
+          hT0_pos hTL_T0_PL hTL_T0_con hTL_T0_B
+      -- Need: T_n (n+1) = T_n n + T_0
+      have h_T_eq : T_n (n + 1) = T_n n + T_0 := by
+        simp only [T_n]; push_cast; ring
+      refine ⟨f_next, charX_next, charV_next, h_init, ?_, ?_, ?_, ?_, ?_, ?_, ?_⟩
+      · rw [h_T_eq]; exact h_mom
+      · rw [h_T_eq]; exact h_mom_unif
+      · rw [h_T_eq]; exact h_lag.1
+      · rw [h_T_eq]; exact h_push
+      · rw [h_T_eq]; exact h_aemeas
+      · rw [h_T_eq]; exact h_boundary
+      · exact h_ic
+  -- Step 4: Apply h_ind at n = N - 1 (since N ≥ 1).
+  have hN_pred : N - 1 + 1 = N := Nat.succ_pred_eq_of_pos hN_pos
+  obtain ⟨f, charX_f, charV_f, hf_init, hf_mom, _hf_mom_unif, hf_vlasov,
+          hf_push, hf_aemeas, hf_boundary, hf_ic⟩ := h_ind (N - 1)
+  simp only [T_n] at hf_mom hf_vlasov hf_push hf_aemeas hf_boundary
+  rw [hN_pred] at hf_mom hf_vlasov hf_push hf_aemeas hf_boundary
+  -- Step 5: Restrict from [0, N·T_0] down to [0, T_target].
+  refine ⟨f, hf_init, ?_, ?_⟩
+  · -- Moment bound on [0, T_target] ⊆ [0, N·T_0].
+    intro t ht
+    exact hf_mom t ⟨ht.1, le_trans ht.2 hN_covers⟩
+  · -- IsLagrangianVlasovSolutionOn on [0, T_target] ≤ [0, N·T_0].
+    -- Derive IsCharacteristicFlowOn for T_target from hf_boundary (restrict to Ioo 0 T_target).
+    have hf_flow : IsCharacteristicFlowOn gradW (fun t => spatialMarginal (f t))
+        charX_f charV_f (Set.Ioo 0 T_target) Set.univ := by
+      refine ⟨fun z _ => hf_ic z, ?_, ?_⟩
+      · intro t ht z _
+        have ht_lt_NT0 : t < (N : ℝ) * T_0 := lt_of_lt_of_le ht.2 hN_covers
+        exact ((hf_boundary z t ⟨le_of_lt ht.1, le_of_lt ht_lt_NT0⟩).1).hasDerivAt
+          (Icc_mem_nhds ht.1 ht_lt_NT0)
+      · intro t ht z _
+        have ht_lt_NT0 : t < (N : ℝ) * T_0 := lt_of_lt_of_le ht.2 hN_covers
+        exact ((hf_boundary z t ⟨le_of_lt ht.1, le_of_lt ht_lt_NT0⟩).2).hasDerivAt
+          (Icc_mem_nhds ht.1 ht_lt_NT0)
+    refine ⟨?_, charX_f, charV_f, ?_, ?_, ?_⟩
+    · -- IsVlasovSolutionOn: restrict Ioo 0 T_target ⊆ Ioo 0 (N·T_0)
+      intro φ hφ_smooth hφ_compact gradXφ gradVφ hgradXφ hgradVφ t ht
+      exact hf_vlasov φ hφ_smooth hφ_compact gradXφ gradVφ hgradXφ hgradVφ t
+        ⟨ht.1, lt_of_lt_of_le ht.2 hN_covers⟩
+    · exact hf_flow
+    · -- pushforward eq: restrict Icc 0 T_target ⊆ Icc 0 (N·T_0)
+      intro t ht
+      exact hf_push t ⟨ht.1, le_trans ht.2 hN_covers⟩
+    · -- AEMeasurable ∧ boundary ContinuousOn, restricted to Icc 0 T_target.
+      refine ⟨?_, ?_⟩
+      · intro s hs
+        exact hf_aemeas s ⟨hs.1, le_trans hs.2 hN_covers⟩
+      · intro z
+        have h_big : ContinuousOn (fun s => (charX_f s z, charV_f s z))
+            (Set.Icc 0 ((N : ℝ) * T_0)) := fun t ht =>
+          ((hf_boundary z t ht).1.continuousWithinAt).prodMk
+            ((hf_boundary z t ht).2.continuousWithinAt)
+        exact h_big.mono (fun t ht => ⟨ht.1, le_trans ht.2 hN_covers⟩)
+
+end Vlasov
diff --git a/LeanPool/Vlasov/OT/FlowDifferentiability.lean b/LeanPool/Vlasov/OT/FlowDifferentiability.lean
new file mode 100644
index 0000000000..d826d877d3
--- /dev/null
+++ b/LeanPool/Vlasov/OT/FlowDifferentiability.lean
@@ -0,0 +1,1400 @@
+/-
+Copyright (c) 2026 Joseph K. Miller. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Joseph K. Miller
+-/
+module
+
+public import LeanPool.Vlasov.OT.FrozenField
+public import LeanPool.Vlasov.ForMathlib.VariationalEquation
+import all LeanPool.Vlasov.ForMathlib.VariationalEquation
+import Mathlib.Algebra.Order.Ring.Star
+import Mathlib.Analysis.Calculus.InverseFunctionTheorem.ContDiff
+
+/-!
+# Differentiability and inversion of the frozen Vlasov flow
+
+The variational equation gives the spatial and joint derivatives of the flow and
+its inverse. The Jacobian and explicit fundamental matrix remain together so
+their generated proof declarations are shared as before.
+-/
+
+@[expose] public section
+
+namespace Vlasov
+
+open MeasureTheory
+
+variable {d : ℕ} [NeZero d]
+
+/-- **C3 D1 (Jacobian).**  The phase-space Jacobian `A(s, p) = D_w b(s, p)` of the frozen Vlasov
+field at the base point `p`: the block continuous-linear map `δ ↦ (δ.2, −(D_x conv ρ_s)(p.1)·δ.1)`,
+where `D_x conv ρ_s (p.1) = ∫ y, fderiv ℝ gradW (p.1 − y) ∂ρ_s` (F1).  This is the coefficient of
+the linear variational ODE `M' = A(s, Φ_s z)·M`; `vlasovVectorField_hasFDerivAt_in_z` (F2) says it
+is the Fréchet derivative of `vlasovVectorField gradW ρ s` at `p.2`. -/
+noncomputable def vlasovFieldJacobian (gradW : PhysSpace d → PhysSpace d)
+    (ρ : ℝ → Measure (PhysSpace d)) (p : ℝ × PhaseSpace d) : PhaseSpace d →L[ℝ] PhaseSpace d :=
+  (ContinuousLinearMap.snd ℝ (PhysSpace d) (PhysSpace d)).prod
+    (-((∫ y, fderiv ℝ gradW (p.2.1 - y) ∂(ρ p.1)).comp
+        (ContinuousLinearMap.fst ℝ (PhysSpace d) (PhysSpace d))))
+
+omit [NeZero d] in
+/-- Joint continuity of the Jacobian on `Icc 0 T ×ˢ univ`.
+Express the block map as a sum of continuous compositions of the convolution derivative. -/
+lemma vlasovFieldJacobian_continuousOn
+    (gradW : PhysSpace d → PhysSpace d) (ρ : ℝ → Measure (PhysSpace d)) (T : ℝ)
+    (hρD_cont : ContinuousOn
+      (fun p : ℝ × PhysSpace d => ∫ y, fderiv ℝ gradW (p.2 - y) ∂(ρ p.1))
+      (Set.Icc 0 T ×ˢ (Set.univ : Set (PhysSpace d)))) :
+    ContinuousOn (fun p : ℝ × PhaseSpace d => vlasovFieldJacobian gradW ρ p)
+      (Set.Icc 0 T ×ˢ (Set.univ : Set (PhaseSpace d))) := by
+  have hg_cont : Continuous (fun p : ℝ × PhaseSpace d => ((p.1, p.2.1) : ℝ × PhysSpace d)) :=
+    continuous_fst.prodMk (continuous_fst.comp continuous_snd)
+  have hmaps : Set.MapsTo (fun p : ℝ × PhaseSpace d => ((p.1, p.2.1) : ℝ × PhysSpace d))
+      (Set.Icc 0 T ×ˢ (Set.univ : Set (PhaseSpace d)))
+      (Set.Icc 0 T ×ˢ (Set.univ : Set (PhysSpace d))) :=
+    fun p hp => ⟨hp.1, Set.mem_univ _⟩
+  have hD2 : ContinuousOn
+      (fun p : ℝ × PhaseSpace d => ∫ y, fderiv ℝ gradW (p.2.1 - y) ∂(ρ p.1))
+      (Set.Icc 0 T ×ˢ Set.univ) :=
+    hρD_cont.comp hg_cont.continuousOn hmaps
+  have hDcomp : ContinuousOn
+      (fun p : ℝ × PhaseSpace d => -((∫ y, fderiv ℝ gradW (p.2.1 - y) ∂(ρ p.1)).comp
+        (ContinuousLinearMap.fst ℝ (PhysSpace d) (PhysSpace d)))) (Set.Icc 0 T ×ˢ Set.univ) :=
+    (hD2.clm_comp continuousOn_const).neg
+  have heq : (fun p : ℝ × PhaseSpace d => vlasovFieldJacobian gradW ρ p) = fun p =>
+        (ContinuousLinearMap.inl ℝ (PhysSpace d) (PhysSpace d)).comp
+          (ContinuousLinearMap.snd ℝ (PhysSpace d) (PhysSpace d))
+        + (ContinuousLinearMap.inr ℝ (PhysSpace d) (PhysSpace d)).comp
+          (-((∫ y, fderiv ℝ gradW (p.2.1 - y) ∂(ρ p.1)).comp
+              (ContinuousLinearMap.fst ℝ (PhysSpace d) (PhysSpace d)))) := by
+    funext p; ext x <;> simp [vlasovFieldJacobian]
+  rw [heq]; exact continuousOn_const.add (continuousOn_const.clm_comp hDcomp)
+
+omit [NeZero d] in
+/-- **C3 D1a — the uniform-over-compact first-order Taylor remainder of the Vlasov field.**
+
+For a fixed initial point `z`, the first-order remainder of the frozen field `b(s,·)` at the moving
+base point `Φ_s z := (charX s z, charV s z)`,
+`R(s,w) = b(s,w) − b(s,Φ_s z) − A(s,Φ_s z)·(w − Φ_s z)`, is `o(‖w − Φ_s z‖)` **uniformly in
+`s ∈ [0,T]`**: for every `η > 0` there is a single `δ > 0` (independent of `s`) with
+`‖R(s,w)‖ ≤ η·‖w − Φ_s z‖` whenever `‖w − Φ_s z‖ ≤ δ`.
+
+This uniformity is the load-bearing analytic core of D1 (the variational-equation difference
+quotient): it is what lets Grönwall bound `Φ_t(z+h) − Φ_t(z) − M_t(z)·h` by `o(‖h‖)` *uniformly
+along the trajectory*.  Proof: the flow image `{Φ_s z : s ∈ [0,T]}` is compact (continuous image of
+`[0,T]`), `A = D_w b` is jointly `(s,w)`-continuous (from `hρD_cont`), so `A` is **uniformly**
+continuous on the compact tube `Γ = {(s, Φ_s z + e) : s ∈ [0,T], ‖e‖ ≤ 1}` (Heine–Cantor); the
+mean-value inequality on `closedBall (Φ_s z) δ` then converts the modulus into the remainder
+bound. -/
+lemma vlasovField_taylorRemainder_uniform
+    (gradW : PhysSpace d → PhysSpace d) (hgradW_C1 : ContDiff ℝ 1 gradW)
+    (L : NNReal) (hL : LipschitzWith L gradW)
+    (ρ : ℝ → Measure (PhysSpace d)) [∀ s, IsProbabilityMeasure (ρ s)]
+    (h_int : ∀ s (x : PhysSpace d), Integrable (fun y => gradW (x - y)) (ρ s))
+    (charX charV : ℝ → PhaseSpace d → PhysSpace d) (T : ℝ) (z : PhaseSpace d)
+    (hcontIcc : ContinuousOn (fun s => (charX s z, charV s z)) (Set.Icc (0 : ℝ) T))
+    (hρD_cont : ContinuousOn
+      (fun p : ℝ × PhysSpace d => ∫ y, fderiv ℝ gradW (p.2 - y) ∂(ρ p.1))
+      (Set.Icc 0 T ×ˢ (Set.univ : Set (PhysSpace d)))) :
+    ∀ η : ℝ, 0 < η → ∃ δ : ℝ, 0 < δ ∧ ∀ s ∈ Set.Icc (0 : ℝ) T, ∀ w : PhaseSpace d,
+      ‖w - (charX s z, charV s z)‖ ≤ δ →
+      ‖vlasovVectorField gradW ρ s w - vlasovVectorField gradW ρ s (charX s z, charV s z)
+        - (vlasovFieldJacobian gradW ρ (s, (charX s z, charV s z))) (w - (charX s z, charV s z))‖
+        ≤ η * ‖w - (charX s z, charV s z)‖ := by
+  set Φ : ℝ → PhaseSpace d := fun s => (charX s z, charV s z) with hΦ
+  -- F2: the field is differentiable in the phase variable with derivative `vlasovFieldJacobian`.
+  have hF2 : ∀ s (w : PhaseSpace d),
+      HasFDerivAt (vlasovVectorField gradW ρ s) (vlasovFieldJacobian gradW ρ (s, w)) w :=
+    fun s w => vlasovVectorField_hasFDerivAt_in_z gradW hgradW_C1 L hL ρ h_int s w
+  -- Joint continuity of the Jacobian on `Icc 0 T ×ˢ Set.univ` (from `hρD_cont`).
+  have hg_cont : Continuous (fun p : ℝ × PhaseSpace d => ((p.1, p.2.1) : ℝ × PhysSpace d)) :=
+    continuous_fst.prodMk (continuous_fst.comp continuous_snd)
+  have hmaps : Set.MapsTo (fun p : ℝ × PhaseSpace d => ((p.1, p.2.1) : ℝ × PhysSpace d))
+      (Set.Icc 0 T ×ˢ (Set.univ : Set (PhaseSpace d)))
+      (Set.Icc 0 T ×ˢ (Set.univ : Set (PhysSpace d))) :=
+    fun p hp => ⟨hp.1, Set.mem_univ _⟩
+  have hD2 : ContinuousOn
+      (fun p : ℝ × PhaseSpace d => ∫ y, fderiv ℝ gradW (p.2.1 - y) ∂(ρ p.1))
+      (Set.Icc 0 T ×ˢ Set.univ) :=
+    hρD_cont.comp hg_cont.continuousOn hmaps
+  have hDcomp : ContinuousOn
+      (fun p : ℝ × PhaseSpace d => -((∫ y, fderiv ℝ gradW (p.2.1 - y) ∂(ρ p.1)).comp
+        (ContinuousLinearMap.fst ℝ (PhysSpace d) (PhysSpace d)))) (Set.Icc 0 T ×ˢ Set.univ) :=
+    (hD2.clm_comp continuousOn_const).neg
+  have heq : (fun p : ℝ × PhaseSpace d => vlasovFieldJacobian gradW ρ p) = fun p =>
+        (ContinuousLinearMap.inl ℝ (PhysSpace d) (PhysSpace d)).comp
+          (ContinuousLinearMap.snd ℝ (PhysSpace d) (PhysSpace d))
+        + (ContinuousLinearMap.inr ℝ (PhysSpace d) (PhysSpace d)).comp
+          (-((∫ y, fderiv ℝ gradW (p.2.1 - y) ∂(ρ p.1)).comp
+              (ContinuousLinearMap.fst ℝ (PhysSpace d) (PhysSpace d)))) := by
+    funext p; ext x <;> simp [vlasovFieldJacobian]
+  have hAj_cont : ContinuousOn (fun p : ℝ × PhaseSpace d => vlasovFieldJacobian gradW ρ p)
+      (Set.Icc 0 T ×ˢ Set.univ) := by
+    rw [heq]; exact continuousOn_const.add (continuousOn_const.clm_comp hDcomp)
+  -- The compact tube `Γ = {(s, Φ s + e) : s ∈ [0,T], ‖e‖ ≤ 1}`.
+  set ball1 : Set (PhaseSpace d) := Metric.closedBall 0 1 with hball1
+  have hmap : ContinuousOn (fun q : ℝ × PhaseSpace d => ((q.1, Φ q.1 + q.2) : ℝ × PhaseSpace d))
+      (Set.Icc 0 T ×ˢ ball1) :=
+    continuousOn_fst.prodMk
+      ((hcontIcc.comp continuousOn_fst (fun q hq => hq.1)).add continuousOn_snd)
+  set Γ : Set (ℝ × PhaseSpace d) :=
+    (fun q : ℝ × PhaseSpace d => ((q.1, Φ q.1 + q.2) : ℝ × PhaseSpace d)) '' (Set.Icc 0 T ×ˢ ball1)
+    with hΓ
+  have hΓcompact : IsCompact Γ :=
+    (isCompact_Icc.prod (isCompact_closedBall 0 1)).image_of_continuousOn hmap
+  have hΓsub : Γ ⊆ Set.Icc 0 T ×ˢ Set.univ := by
+    rintro _ ⟨q, hq, rfl⟩; exact ⟨hq.1, Set.mem_univ _⟩
+  have hUC : UniformContinuousOn (fun p => vlasovFieldJacobian gradW ρ p) Γ :=
+    hΓcompact.uniformContinuousOn_of_continuous (hAj_cont.mono hΓsub)
+  have hmemΓ : ∀ s ∈ Set.Icc (0 : ℝ) T, ∀ e : PhaseSpace d, ‖e‖ ≤ 1 →
+      ((s, Φ s + e) : ℝ × PhaseSpace d) ∈ Γ := by
+    intro s hs e he
+    exact ⟨(s, e), ⟨hs, by simpa [hball1, Metric.mem_closedBall, dist_eq_norm] using he⟩, rfl⟩
+  -- Extract the uniform-continuity modulus.
+  intro η hη
+  obtain ⟨δ₀, hδ₀, H⟩ := Metric.uniformContinuousOn_iff_le.mp hUC η hη
+  refine ⟨min δ₀ 1, lt_min hδ₀ one_pos, ?_⟩
+  intro s hs w hw
+  -- Mean value on the convex ball `C = closedBall (Φ s) (min δ₀ 1)`.
+  set C : Set (PhaseSpace d) := Metric.closedBall (Φ s) (min δ₀ 1) with hC
+  have hΦmem : Φ s ∈ C := Metric.mem_closedBall_self (le_min hδ₀.le zero_le_one)
+  have hwmem : w ∈ C := by
+    rw [hC, Metric.mem_closedBall, dist_eq_norm]; exact hw
+  -- The fderiv bound on `C` from uniform continuity.
+  have hbound : ∀ w' ∈ C,
+      ‖vlasovFieldJacobian gradW ρ (s, w') - vlasovFieldJacobian gradW ρ (s, Φ s)‖ ≤ η := by
+    intro w' hw'
+    have hw'norm : ‖w' - Φ s‖ ≤ min δ₀ 1 := by
+      rw [← dist_eq_norm]; rw [hC, Metric.mem_closedBall] at hw'; exact hw'
+    have hw'le1 : ‖w' - Φ s‖ ≤ 1 := hw'norm.trans (min_le_right _ _)
+    have hmem1 : ((s, w') : ℝ × PhaseSpace d) ∈ Γ := by
+      have := hmemΓ s hs (w' - Φ s) hw'le1
+      rwa [add_sub_cancel] at this
+    have hmem2 : ((s, Φ s) : ℝ × PhaseSpace d) ∈ Γ := by
+      have := hmemΓ s hs 0 (by simp)
+      rwa [add_zero] at this
+    have hdist : dist ((s, w') : ℝ × PhaseSpace d) (s, Φ s) ≤ δ₀ := by
+      rw [Prod.dist_eq]
+      simp only [dist_self, max_le_iff]
+      refine ⟨hδ₀.le, ?_⟩
+      rw [dist_eq_norm]; exact hw'norm.trans (min_le_left _ _)
+    have := H _ hmem1 _ hmem2 hdist
+    rwa [dist_eq_norm] at this
+  -- Apply the mean value inequality to `g u = b(s,u) − A(s,Φ s)·u`.
+  have hg : ∀ w' ∈ C, HasFDerivWithinAt
+      (fun u => vlasovVectorField gradW ρ s u - vlasovFieldJacobian gradW ρ (s, Φ s) u)
+      (vlasovFieldJacobian gradW ρ (s, w') - vlasovFieldJacobian gradW ρ (s, Φ s)) C w' := by
+    intro w' _
+    have h1 := hF2 s w'
+    have h2 : HasFDerivAt (fun u => vlasovFieldJacobian gradW ρ (s, Φ s) u)
+        (vlasovFieldJacobian gradW ρ (s, Φ s)) w' :=
+      (vlasovFieldJacobian gradW ρ (s, Φ s)).hasFDerivAt
+    exact (h1.sub h2).hasFDerivWithinAt
+  have hmv := (convex_closedBall (Φ s) (min δ₀ 1)).norm_image_sub_le_of_norm_hasFDerivWithin_le
+    hg hbound hΦmem hwmem
+  -- Rewrite `g w − g (Φ s)` as the remainder.
+  have hReq : (vlasovVectorField gradW ρ s w - vlasovFieldJacobian gradW ρ (s, Φ s) w)
+        - (vlasovVectorField gradW ρ s (Φ s) - vlasovFieldJacobian gradW ρ (s, Φ s) (Φ s))
+      = vlasovVectorField gradW ρ s w - vlasovVectorField gradW ρ s (Φ s)
+        - vlasovFieldJacobian gradW ρ (s, Φ s) (w - Φ s) := by
+    rw [map_sub]; abel
+  simpa only [hReq] using hmv
+
+/-- **C3 V2 — the explicit fundamental matrix** (Route A, lesson L14): the canonical Dyson-series
+solution of `M' = A(t)·M`, `M 0 = id`, as a *function* (not a `choose`-d witness), so its
+parameter-regularity is accessible. -/
+noncomputable def fundamentalMatrix {F : Type*} [NormedAddCommGroup F] [NormedSpace ℝ F]
+    (A : ℝ → (F →L[ℝ] F)) : ℝ → (F →L[ℝ] F) :=
+  fun t => ∑' n, picardIter (fun s => ContinuousLinearMap.compL ℝ F F F (A s))
+    (ContinuousLinearMap.id ℝ F) n t
+
+/-- `fundamentalMatrix A` solves the fundamental-matrix IVP on `[0,T]` (the non-existential form of
+`exists_fundamentalMatrix`; same proof through the picardSum lemmas). -/
+lemma fundamentalMatrix_spec {F : Type*} [NormedAddCommGroup F] [NormedSpace ℝ F] [CompleteSpace F]
+    (A : ℝ → (F →L[ℝ] F)) (T : ℝ) (hT : 0 ≤ T) (hA : ContinuousOn A (Set.Icc 0 T)) :
+    fundamentalMatrix A 0 = ContinuousLinearMap.id ℝ F ∧
+      ContinuousOn (fundamentalMatrix A) (Set.Icc 0 T) ∧
+      ∀ t ∈ Set.Icc 0 T, HasDerivWithinAt (fundamentalMatrix A)
+        ((A t).comp (fundamentalMatrix A t)) (Set.Icc 0 T) t := by
+  unfold fundamentalMatrix
+  simpa only [ContinuousLinearMap.compL_apply] using
+    picardSum_spec (fun s => ContinuousLinearMap.compL ℝ F F F (A s)) T hT
+      ((ContinuousLinearMap.compL ℝ F F F).continuous.comp_continuousOn hA)
+      (ContinuousLinearMap.id ℝ F)
+
+/-- **C3 V2 — the fundamental matrix is continuous in a PARAMETER** (closes V2 via Route A).
+Specialises `picardSum_continuous_param_Icc` to `𝒜 := compL∘A`, `x₀ := id`; the `compL` factor is
+`1`-bounded so the `K`-bound transfers from `A`. -/
+lemma fundamentalMatrix_continuous_param
+    {Z F : Type*} [TopologicalSpace Z] [NormedAddCommGroup F] [NormedSpace ℝ F] [CompleteSpace F]
+    (A : Z → ℝ → (F →L[ℝ] F)) (T : ℝ) (hT : 0 ≤ T) (K : ℝ) (hK : 0 ≤ K)
+    (hA_contOn : ContinuousOn (fun p : Z × ℝ => A p.1 p.2) (Set.univ ×ˢ Set.Icc (0 : ℝ) T))
+    (hA_bound : ∀ z, ∀ s ∈ Set.Icc (0 : ℝ) T, ‖A z s‖ ≤ K)
+    (t : ℝ) (ht : t ∈ Set.Icc (0 : ℝ) T) :
+    Continuous (fun z => fundamentalMatrix (A z) t) := by
+  have h𝒜_contOn : ContinuousOn
+      (fun p : Z × ℝ => ContinuousLinearMap.compL ℝ F F F (A p.1 p.2))
+      (Set.univ ×ˢ Set.Icc (0 : ℝ) T) :=
+    (ContinuousLinearMap.compL ℝ F F F).continuous.comp_continuousOn hA_contOn
+  have h𝒜_bound : ∀ z, ∀ s ∈ Set.Icc (0 : ℝ) T,
+      ‖ContinuousLinearMap.compL ℝ F F F (A z s)‖ ≤ K := by
+    intro z s hs
+    refine le_trans ?_ (hA_bound z s hs)
+    refine ContinuousLinearMap.opNorm_le_bound _ (norm_nonneg _) (fun g => ?_)
+    rw [ContinuousLinearMap.compL_apply]
+    exact (A z s).opNorm_comp_le g
+  exact picardSum_continuous_param_Icc (fun z s => ContinuousLinearMap.compL ℝ F F F (A z s))
+    (ContinuousLinearMap.id ℝ F) T hT K hK h𝒜_contOn h𝒜_bound t ht
+
+/-- **Step 3 (i) — the fundamental matrix is jointly `(z,s)`-continuous.**  Joint companion of
+`fundamentalMatrix_continuous_param`; specialises `picardSum_continuous_param_Icc_joint` to
+`𝒜 := compL∘A`, `x₀ := id`.  This is the partial-`z`-derivative continuity input to the joint
+`C¹`-ness of the forward flow `(s,z) ↦ Φ_s z` (Step 3 (iii)). -/
+lemma fundamentalMatrix_continuous_param_joint
+    {Z F : Type*} [TopologicalSpace Z] [NormedAddCommGroup F] [NormedSpace ℝ F] [CompleteSpace F]
+    (A : Z → ℝ → (F →L[ℝ] F)) (T : ℝ) (hT : 0 ≤ T) (K : ℝ) (hK : 0 ≤ K)
+    (hA_contOn : ContinuousOn (fun p : Z × ℝ => A p.1 p.2) (Set.univ ×ˢ Set.Icc (0 : ℝ) T))
+    (hA_bound : ∀ z, ∀ s ∈ Set.Icc (0 : ℝ) T, ‖A z s‖ ≤ K) :
+    ContinuousOn (fun p : Z × ℝ => fundamentalMatrix (A p.1) p.2)
+      (Set.univ ×ˢ Set.Icc (0 : ℝ) T) := by
+  have h𝒜_contOn : ContinuousOn
+      (fun p : Z × ℝ => ContinuousLinearMap.compL ℝ F F F (A p.1 p.2))
+      (Set.univ ×ˢ Set.Icc (0 : ℝ) T) :=
+    (ContinuousLinearMap.compL ℝ F F F).continuous.comp_continuousOn hA_contOn
+  have h𝒜_bound : ∀ z, ∀ s ∈ Set.Icc (0 : ℝ) T,
+      ‖ContinuousLinearMap.compL ℝ F F F (A z s)‖ ≤ K := by
+    intro z s hs
+    refine le_trans ?_ (hA_bound z s hs)
+    refine ContinuousLinearMap.opNorm_le_bound _ (norm_nonneg _) (fun g => ?_)
+    rw [ContinuousLinearMap.compL_apply]
+    exact (A z s).opNorm_comp_le g
+  exact picardSum_continuous_param_Icc_joint
+    (fun z s => ContinuousLinearMap.compL ℝ F F F (A z s))
+    (ContinuousLinearMap.id ℝ F) T hT K hK h𝒜_contOn h𝒜_bound
+
+section CharFlowDeriv
+open Filter Topology
+
+omit [NeZero d] in
+/-- **C3 D1 — the difference-quotient heart of the variational equation.**
+
+Given the fundamental matrix `Mz` of the linear variational ODE `M' = A(s, Φ_s z)·M`, `M 0 = id`
+(coefficient `A = vlasovFieldJacobian`), the time-`t` flow map `w ↦ (charX t w, charV t w)` is
+Fréchet-differentiable **at the fixed point `z`** with derivative exactly `Mz t`.
+
+This is the load-bearing difference-quotient estimate `Φ_t(z+h) − Φ_t(z) − Mz t·h = o(‖h‖)`.
+The matrix is threaded as an explicit hypothesis (rather than `choose`-d) so the proof can use its
+ODE/continuity data directly.
+
+**Proof plan (route b — Grönwall on the linearisation remainder).**  Reduce via
+`hasFDerivAt_iff_isLittleO_nhds_zero` + `Asymptotics.isLittleO_iff` to: `∀ c>0, ∀ᶠ h, ‖Φ_t(z+h) −
+Φ_t(z) − Mz t·h‖ ≤ c‖h‖`.  For fixed small `h`, the two curves `u_h(s) := Φ_s(z+h) − Φ_s(z)`
+(approximate) and `m_h(s) := Mz s·h` (exact) both solve `w' = A(s, Φ_s z)·w` from the same datum
+`h` (`Φ_0 = id`, `Mz 0 = id`):
+* `m_h` is exact — its defect is `0` (its derivative `(A·Mz)(s)·h = A(s)·m_h(s)` by `hMzderiv` +
+  `HasDerivWithinAt.clm_apply`).
+* `u_h`'s defect is the Taylor remainder `R(s, Φ_s(z+h))`, bounded by `η·‖u_h(s)‖` (D1a,
+  `vlasovField_taylorRemainder_uniform`) once `‖u_h(s)‖ ≤ δ(η)`, which holds with
+  `‖u_h(s)‖ ≤ exp(K T)·‖h‖` (flow Lipschitz-in-`z`, `charFlow_lipschitzInZ_via_gronwall_Ioo`) for
+  `‖h‖` small.  So `εf = η·exp(K T)·‖h‖`, uniform in `s`.
+The frozen field's two-sided ODE holds only on `Ioo 0 T`, so apply
+`dist_le_of_approx_trajectories_ODE` on `[s₀, t]` (`s₀ ∈ Ioo 0 t`) and take `s₀ → 0⁺` (the initial
+defect `dist(u_h s₀, m_h s₀) → 0` by continuity), giving `‖u_h t − m_h t‖ ≤ gronwallBound 0 K εf t =
+εf·(exp(K t)−1)/K`.  Since `η` is arbitrary this is `o(‖h‖)`.  `K := max 1 L` is the uniform field
+Lipschitz constant; `‖A(s,·)‖ ≤ K` via `norm_fderiv_le_of_lipschitz`.  (`hcontIcc` is universal in
+the initial point because the `s₀→0⁺` limit needs continuity of `Φ_·(z+h)`, M2.) -/
+theorem charFlow_hasFDerivAt_of_fundamentalMatrix
+    (gradW : PhysSpace d → PhysSpace d) (hgradW_C1 : ContDiff ℝ 1 gradW)
+    (L : NNReal) (hL : LipschitzWith L gradW)
+    (ρ : ℝ → Measure (PhysSpace d)) [∀ s, IsProbabilityMeasure (ρ s)]
+    (charX charV : ℝ → PhaseSpace d → PhysSpace d)
+    (T : ℝ) (hT : 0 < T)
+    (hflow : IsCharacteristicFlowOn gradW ρ charX charV (Set.Ioo 0 T) Set.univ)
+    (h_int : ∀ s (x : PhysSpace d), Integrable (fun y => gradW (x - y)) (ρ s))
+    (hρD_cont : ContinuousOn
+      (fun p : ℝ × PhysSpace d => ∫ y, fderiv ℝ gradW (p.2 - y) ∂(ρ p.1))
+      (Set.Icc 0 T ×ˢ (Set.univ : Set (PhysSpace d))))
+    (z : PhaseSpace d)
+    (hcontIcc : ∀ z' : PhaseSpace d,
+      ContinuousOn (fun s => (charX s z', charV s z')) (Set.Icc (0 : ℝ) T))
+    (Mz : ℝ → (PhaseSpace d →L[ℝ] PhaseSpace d))
+    (hMz0 : Mz 0 = ContinuousLinearMap.id ℝ (PhaseSpace d))
+    (hMzcont : ContinuousOn Mz (Set.Icc 0 T))
+    (hMzderiv : ∀ s ∈ Set.Icc (0 : ℝ) T,
+      HasDerivWithinAt Mz
+        ((vlasovFieldJacobian gradW ρ (s, (charX s z, charV s z))).comp (Mz s))
+        (Set.Icc 0 T) s) :
+    ∀ t ∈ Set.Ioo (0 : ℝ) T, HasFDerivAt (fun w => (charX t w, charV t w)) (Mz t) z := by
+  intro t ht
+  set Kr : ℝ := ((max 1 L : NNReal) : ℝ) with hKr
+  have hKr1 : (1:ℝ) ≤ Kr := by rw [hKr]; exact_mod_cast le_max_left 1 L
+  have hKrpos : (0 : ℝ) < Kr := lt_of_lt_of_le one_pos hKr1
+  set Φ : ℝ → PhaseSpace d := fun s => (charX s z, charV s z) with hΦ
+  have hF2 : ∀ s (w : PhaseSpace d),
+      HasFDerivAt (vlasovVectorField gradW ρ s) (vlasovFieldJacobian gradW ρ (s, w)) w :=
+    fun s w => vlasovVectorField_hasFDerivAt_in_z gradW hgradW_C1 L hL ρ h_int s w
+  have hVF_lip : ∀ s, LipschitzWith (max 1 L) (vlasovVectorField gradW ρ s) := fun s =>
+    vlasovVectorField_lipschitzWith gradW L hL ρ h_int s
+  set vlin : ℝ → (PhaseSpace d →L[ℝ] PhaseSpace d) := fun s => vlasovFieldJacobian gradW ρ (s, Φ s)
+    with hvlin
+  have hvlin_norm : ∀ s, ‖vlin s‖ ≤ Kr := by
+    intro s
+    change ‖vlasovFieldJacobian gradW ρ (s, Φ s)‖ ≤ Kr
+    rw [← (hF2 s (Φ s)).fderiv]
+    exact norm_fderiv_le_of_lipschitz ℝ (hVF_lip s)
+  have hvlin_lip : ∀ s, LipschitzWith (max 1 L) (vlin s) := by
+    intro s
+    refine LipschitzWith.of_dist_le_mul (fun x y => ?_)
+    rw [dist_eq_norm, dist_eq_norm, ← map_sub]
+    calc ‖vlin s (x - y)‖ ≤ ‖vlin s‖ * ‖x - y‖ := (vlin s).le_opNorm _
+      _ ≤ Kr * ‖x - y‖ := mul_le_mul_of_nonneg_right (hvlin_norm s) (norm_nonneg _)
+  clear_value vlin
+  have h_init : ∀ z' : PhaseSpace d, (charX 0 z', charV 0 z') = z' := fun z' =>
+    Prod.ext_iff.mpr ⟨(hflow.1 z' (Set.mem_univ z')).1, (hflow.1 z' (Set.mem_univ z')).2⟩
+  have h_derivAt : ∀ z', ∀ s ∈ Set.Ioo (0 : ℝ) T,
+      HasDerivAt (fun s => (charX s z', charV s z'))
+        (vlasovVectorField gradW ρ s (charX s z', charV s z')) s := fun z' s hs =>
+    HasDerivAt.prodMk (hflow.2.1 s hs z' (Set.mem_univ z')) (hflow.2.2 s hs z' (Set.mem_univ z'))
+  have hgron := charFlow_lipschitzInZ_via_gronwall_Ioo gradW L hL ρ h_int charX charV T hT.le
+    h_init hcontIcc (fun z' s hs => (h_derivAt z' s hs).hasDerivWithinAt)
+  rw [hasFDerivAt_iff_isLittleO_nhds_zero, Asymptotics.isLittleO_iff]
+  intro c hc
+  set Cexp : ℝ := Real.exp (Kr * T) with hCexp
+  have hCexp_pos : 0 < Cexp := Real.exp_pos _
+  set Cgron : ℝ := (Real.exp (Kr * t) - 1) / Kr with hCgron
+  have hCgron_nonneg : 0 ≤ Cgron := by
+    rw [hCgron]; apply div_nonneg _ hKrpos.le
+    simp only [sub_nonneg]; exact Real.one_le_exp (mul_nonneg hKrpos.le ht.1.le)
+  set G : ℝ := Cexp * Cgron with hG
+  have hG_nonneg : 0 ≤ G := mul_nonneg hCexp_pos.le hCgron_nonneg
+  set η : ℝ := c / (G + 1) with hη
+  have hη_pos : 0 < η := by rw [hη]; positivity
+  obtain ⟨δη, hδη_pos, hδη⟩ := vlasovField_taylorRemainder_uniform gradW hgradW_C1 L hL ρ h_int
+    charX charV T z (hcontIcc z) hρD_cont η hη_pos
+  refine Metric.eventually_nhds_iff.mpr
+    ⟨δη / (Cexp + 1), div_pos hδη_pos (by linarith [hCexp_pos]), ?_⟩
+  intro h hh
+  rw [dist_zero_right] at hh
+  have hCexph : Cexp * ‖h‖ ≤ δη := by
+    have hle : ‖h‖ * (Cexp + 1) ≤ δη := by rw [← le_div_iff₀ (by linarith [hCexp_pos])]; exact hh.le
+    nlinarith [norm_nonneg h, hCexp_pos, hle]
+  set uh : ℝ → PhaseSpace d := fun s => (charX s (z + h), charV s (z + h)) - (charX s z, charV s z)
+    with huh
+  set mh : ℝ → PhaseSpace d := fun s => (Mz s) h with hmh
+  set εf : ℝ := η * Cexp * ‖h‖ with hεf
+  have huh_cont : ContinuousOn uh (Set.Icc 0 T) := (hcontIcc (z + h)).sub (hcontIcc z)
+  have hmh_cont : ContinuousOn mh (Set.Icc 0 T) := hMzcont.clm_apply continuousOn_const
+  have huh_bound : ∀ s ∈ Set.Icc (0 : ℝ) T, ‖uh s‖ ≤ Cexp * ‖h‖ := by
+    intro s hs
+    change ‖(charX s (z + h), charV s (z + h)) - (charX s z, charV s z)‖ ≤ Cexp * ‖h‖
+    rw [← dist_eq_norm]
+    calc dist ((charX s (z + h), charV s (z + h)) : PhaseSpace d) (charX s z, charV s z)
+        ≤ dist (z + h) z * Real.exp (Kr * (s - 0)) := hgron s hs (z + h) z
+      _ = ‖h‖ * Real.exp (Kr * s) := by rw [dist_eq_norm, add_sub_cancel_left, sub_zero]
+      _ ≤ ‖h‖ * Cexp := by
+          refine mul_le_mul_of_nonneg_left ?_ (norm_nonneg h)
+          rw [hCexp]; exact Real.exp_le_exp.mpr (mul_le_mul_of_nonneg_left hs.2 hKrpos.le)
+      _ = Cexp * ‖h‖ := mul_comm _ _
+  have huh_derivAt : ∀ s ∈ Set.Ioo (0 : ℝ) T, HasDerivAt uh
+      (vlasovVectorField gradW ρ s (charX s (z + h), charV s (z + h))
+        - vlasovVectorField gradW ρ s (charX s z, charV s z)) s := fun s hs =>
+    (h_derivAt (z + h) s hs).sub (h_derivAt z s hs)
+  have hmh_derivAt : ∀ s ∈ Set.Ioo (0 : ℝ) T, HasDerivAt mh ((vlin s) (mh s)) s := by
+    intro s hs
+    have hMz_at : HasDerivAt Mz ((vlin s).comp (Mz s)) s := by
+      simp only [hvlin]
+      exact (hMzderiv s (Set.Ioo_subset_Icc_self hs)).hasDerivAt (Icc_mem_nhds hs.1 hs.2)
+    have hck := hMz_at.clm_apply (hasDerivAt_const s h)
+    simpa only [ContinuousLinearMap.comp_apply, map_zero, add_zero] using hck
+  have hdefect : ∀ s ∈ Set.Ioo (0 : ℝ) T,
+      dist (vlasovVectorField gradW ρ s (charX s (z + h), charV s (z + h))
+        - vlasovVectorField gradW ρ s (charX s z, charV s z)) (vlin s (uh s)) ≤ εf := by
+    intro s hs
+    have hsIcc : s ∈ Set.Icc (0 : ℝ) T := Set.Ioo_subset_Icc_self hs
+    have huhs_le : ‖uh s‖ ≤ δη := le_trans (huh_bound s hsIcc) hCexph
+    have hR := hδη s hsIcc (charX s (z + h), charV s (z + h)) huhs_le
+    rw [dist_eq_norm]; simp only [hvlin]
+    calc ‖vlasovVectorField gradW ρ s (charX s (z + h), charV s (z + h))
+            - vlasovVectorField gradW ρ s (charX s z, charV s z)
+            - vlasovFieldJacobian gradW ρ (s, Φ s) (uh s)‖
+        ≤ η * ‖uh s‖ := hR
+      _ ≤ η * (Cexp * ‖h‖) := mul_le_mul_of_nonneg_left (huh_bound s hsIcc) hη_pos.le
+      _ = εf := by rw [hεf]; ring
+  have huh0 : uh 0 = h := by
+    change (charX 0 (z + h), charV 0 (z + h)) - (charX 0 z, charV 0 z) = h
+    rw [h_init (z + h), h_init z, add_sub_cancel_left]
+  have hmh0 : mh 0 = h := by change (Mz 0) h = h; rw [hMz0]; rfl
+  have hlim : dist (uh t) (mh t) ≤ gronwallBound 0 Kr εf t := by
+    have := gronwall_diffQuotient_bound vlin (max 1 L) hvlin_lip uh mh
+      (fun s => vlasovVectorField gradW ρ s (charX s (z + h), charV s (z + h))
+        - vlasovVectorField gradW ρ s (charX s z, charV s z)) εf T t ht
+      huh_cont hmh_cont huh_derivAt hmh_derivAt hdefect (huh0.trans hmh0.symm)
+    rwa [← hKr] at this
+  have hgb_val : gronwallBound 0 Kr εf t = εf * Cgron := by
+    rw [gronwallBound_of_K_ne_0 hKrpos.ne']; simp only [zero_mul, zero_add]; rw [hCgron]; ring
+  have hηG : η * G ≤ c := by
+    rw [hη]; rw [div_mul_eq_mul_div, div_le_iff₀ (by linarith [hG_nonneg] : (0 : ℝ) < G + 1)]
+    nlinarith [hG_nonneg, hc.le]
+  change ‖(charX t (z + h), charV t (z + h)) - (charX t z, charV t z) - (Mz t) h‖ ≤ c * ‖h‖
+  rw [show (charX t (z + h), charV t (z + h)) - (charX t z, charV t z) - (Mz t) h
+      = uh t - mh t from rfl, ← dist_eq_norm]
+  calc dist (uh t) (mh t)
+      ≤ gronwallBound 0 Kr εf t := hlim
+    _ = εf * Cgron := hgb_val
+    _ = η * G * ‖h‖ := by rw [hεf, hG]; ring
+    _ ≤ c * ‖h‖ := mul_le_mul_of_nonneg_right hηG (norm_nonneg h)
+
+end CharFlowDeriv
+
+omit [NeZero d] in
+/-- **C3 #3 — the variational equation (`HasFDerivAt` of the flow in its initial point).**
+
+For the frozen field `b(t,·) = vlasovVectorField gradW ρ t` with `gradW ∈ C¹` (supplied by the
+consumer via `assW2_contDiff_gradW`), the time-`t` characteristic map
+`z ↦ (charX t z, charV t z)` is Fréchet-differentiable in the initial point `z`, with a derivative
+`Dflow t z` that is continuous in `z` (so the flow map is `C¹` in `z`).  The derivative solves the
+linear matrix variational ODE `M' = (D_z b(t, Φ_t z)) · M`, `M_0 = id`.
+
+**This was the load-bearing research gap** — Mathlib has no C¹-dependence-of-an-ODE-flow-on-its-
+initial-condition lemma — now proven (axiom-clean) via route (b)
+(`charFlow_lipschitzInZ_via_gronwall_Ioo`, `CharacteristicFlow.lean`, is the Lipschitz-in-`z`
+scaffold; Mathlib Gronwall + the vendored `IsPicardLindelof` confinement are the analytic inputs):
+3.1 existence/uniqueness of the continuous matrix solution `M_t(z)` of the variational ODE
+(`fundamentalMatrix`); 3.2 joint `(t,z)` continuity of `M` (`fundamentalMatrix_continuous_param`);
+3.3 the difference-quotient estimate `Φ_t(z+h) − Φ_t(z) − M_t(z)·h = o(‖h‖)` uniformly on compacts
+(Gronwall on the linearization remainder, using `gradW ∈ C¹`,
+`charFlow_hasFDerivAt_of_fundamentalMatrix`); 3.4 assembled into `HasFDerivAt`.
+
+The `HasFDerivAt`/continuity *conclusion* is route-independent, so this interface is stable; the
+universal-`t` probability instance + force-integrability `h_int` are the field-regularity inputs
+the proof consumes (the window-only application clamps, L11, at the grind).
+
+**`hρD_cont` (joint continuity of the convolution-derivative field).**  This is the regularity that
+makes the variational coefficient `A(s,z) = D_z b(s, Φ_s z)` continuous in `s` — its only non-flow
+varying part is `D_x conv(ρ_s)(x) = ∫ fderiv gradW (x − y) ∂ρ_s`, evaluated at the *moving* point
+`Φ_s z`, so per-`x` continuity is not enough; joint `(s,x)`-continuity is needed.  Note the
+asymmetry with the *field*: `∫ gradW(x−y) dρ_s` gets joint continuity for free (per-`x` continuity
++ uniform Lipschitz-in-`x`, `convolveFunctionMeasure_lipschitz_in_x`), but the *derivative* field is
+NOT uniformly Lipschitz in `x` (that needs `W ∈ C³`; `AssW2` gives only `C²`), so its joint
+continuity must be supplied.
+
+**Option-B note (running — eventual extension).**  `hρD_cont` is, in the complete theory, NOT a new
+assumption: it is *derivable* from **narrow continuity of `s ↦ ρ_s`** (since `fderiv gradW` is
+bounded continuous, `‖·‖ ≤ L`), which is in turn derivable from `IsVlasovSolutionOn` + tightness
+(the uniform moment bound) via the standard **"`C_c^∞`-continuity + tight ⟹ narrow-continuity"**
+upgrade — a self-contained measure-theory lemma not yet in the codebase.  We thread it as a
+hypothesis (Option A) to unblock the variational-equation grind; folding it into a derived fact
+(so the bridge assumes only the weak solution + moments) is the **Option-B extension**, tracked as
+a follow-up. -/
+theorem charFlow_hasFDerivAt_in_initialPoint
+    (gradW : PhysSpace d → PhysSpace d) (hgradW_C1 : ContDiff ℝ 1 gradW)
+    (L : NNReal) (hL : LipschitzWith L gradW)
+    (ρ : ℝ → Measure (PhysSpace d)) [∀ s, IsProbabilityMeasure (ρ s)]
+    (charX charV : ℝ → PhaseSpace d → PhysSpace d)
+    (T : ℝ) (hT : 0 < T)
+    (hflow : IsCharacteristicFlowOn gradW ρ charX charV (Set.Ioo 0 T) Set.univ)
+    (h_int : ∀ s (x : PhysSpace d), Integrable (fun y => gradW (x - y)) (ρ s))
+    (hρD_cont : ContinuousOn
+      (fun p : ℝ × PhysSpace d => ∫ y, fderiv ℝ gradW (p.2 - y) ∂(ρ p.1))
+      (Set.Icc 0 T ×ˢ (Set.univ : Set (PhysSpace d))))
+    (hcontIcc : ∀ z : PhaseSpace d,
+      ContinuousOn (fun s => (charX s z, charV s z)) (Set.Icc (0 : ℝ) T)) :
+    ∃ Dflow : ℝ → PhaseSpace d → (PhaseSpace d →L[ℝ] PhaseSpace d),
+      (∀ t ∈ Set.Ioo (0 : ℝ) T, ∀ z : PhaseSpace d,
+        HasFDerivAt (fun w => (charX t w, charV t w)) (Dflow t z) z) ∧
+      (∀ t ∈ Set.Ioo (0 : ℝ) T, Continuous (Dflow t)) := by
+  -- **Reduction (Route A — explicit fundamental matrix, lesson L14).**  `M z := fundamentalMatrix
+  -- (A z)` with `A z s := vlasovFieldJacobian gradW ρ (s, Φ_s z)`; its ODE/continuity
+  -- data come from
+  -- `fundamentalMatrix_spec` (feeds D1), and `z ↦ M z t` continuity (V2) from
+  -- `fundamentalMatrix_continuous_param` — the parameter-regularity an existential
+  -- `choose` could not
+  -- supply.  `Dflow t z := fundamentalMatrix (A z) t`.
+  set A : PhaseSpace d → ℝ → (PhaseSpace d →L[ℝ] PhaseSpace d) :=
+    fun z s => vlasovFieldJacobian gradW ρ (s, (charX s z, charV s z)) with hA_def
+  have hAcont : ∀ z : PhaseSpace d, ContinuousOn (A z) (Set.Icc 0 T) := fun z =>
+    vlasovVariationalCoeff_continuousOn gradW ρ charX charV T z (hcontIcc z) hρD_cont
+  refine ⟨fun t z => fundamentalMatrix (A z) t, ?_, ?_⟩
+  · -- **D1** — `charFlow_hasFDerivAt_of_fundamentalMatrix` fed by `fundamentalMatrix_spec`.
+    intro t ht z
+    obtain ⟨h0, hcont, hderiv⟩ := fundamentalMatrix_spec (A z) T hT.le (hAcont z)
+    exact charFlow_hasFDerivAt_of_fundamentalMatrix gradW hgradW_C1 L hL ρ charX charV T hT hflow
+      h_int hρD_cont z hcontIcc (fundamentalMatrix (A z)) h0 hcont hderiv t ht
+  · -- **V2** — `fundamentalMatrix_continuous_param`: flow joint continuity ⇒ `A` jointly continuous
+    -- ⇒ `z ↦ M z t` continuous.
+    intro t ht
+    -- Flow joint continuity `(z,s) ↦ Φ_s z` on `univ ×ˢ Icc 0 T` (Grönwall Lipschitz-in-`z` from
+    -- `hflow` + per-`z` continuity in `s`).
+    have h_init : ∀ z : PhaseSpace d, (charX 0 z, charV 0 z) = z := fun z =>
+      Prod.ext_iff.mpr ⟨(hflow.1 z (Set.mem_univ z)).1, (hflow.1 z (Set.mem_univ z)).2⟩
+    have h_deriv : ∀ z, ∀ s ∈ Set.Ioo (0 : ℝ) T,
+        HasDerivWithinAt (fun s => (charX s z, charV s z))
+          (vlasovVectorField gradW ρ s (charX s z, charV s z)) (Set.Ici s) s := fun z s hs =>
+      (HasDerivAt.prodMk (hflow.2.1 s hs z (Set.mem_univ z))
+        (hflow.2.2 s hs z (Set.mem_univ z))).hasDerivWithinAt
+    have hgron := charFlow_lipschitzInZ_via_gronwall_Ioo gradW L hL ρ h_int charX charV T hT.le
+      h_init hcontIcc h_deriv
+    have hflowjoint : ContinuousOn
+        (fun p : PhaseSpace d × ℝ => (charX p.2 p.1, charV p.2 p.1)) (Set.univ ×ˢ Set.Icc 0 T) := by
+      refine continuousOn_prod_of_lipschitz_continuousOn (fun z s => (charX s z, charV s z)) T
+        (Real.exp (((max 1 L : NNReal) : ℝ) * T)) (fun s hs z₁ z₂ => ?_) hcontIcc
+      calc dist ((charX s z₁, charV s z₁) : PhaseSpace d) (charX s z₂, charV s z₂)
+          ≤ dist z₁ z₂ * Real.exp (((max 1 L : NNReal) : ℝ) * (s - 0)) := hgron s hs z₁ z₂
+        _ = Real.exp (((max 1 L : NNReal) : ℝ) * (s - 0)) * dist z₁ z₂ := by ring
+        _ ≤ Real.exp (((max 1 L : NNReal) : ℝ) * T) * dist z₁ z₂ := by
+            refine mul_le_mul_of_nonneg_right (Real.exp_le_exp.mpr ?_) dist_nonneg
+            have hsT : s - 0 ≤ T := by simp only [sub_zero]; exact hs.2
+            exact mul_le_mul_of_nonneg_left hsT (by positivity)
+    -- `A` jointly continuous (Jacobian along the flow) and uniformly bounded by `max 1 L`.
+    have hg : ContinuousOn
+        (fun p : PhaseSpace d × ℝ => ((p.2, (charX p.2 p.1, charV p.2 p.1)) : ℝ × PhaseSpace d))
+        (Set.univ ×ˢ Set.Icc 0 T) := continuousOn_snd.prodMk hflowjoint
+    have hmapsg : Set.MapsTo
+        (fun p : PhaseSpace d × ℝ => ((p.2, (charX p.2 p.1, charV p.2 p.1)) : ℝ × PhaseSpace d))
+        (Set.univ ×ˢ Set.Icc 0 T) (Set.Icc 0 T ×ˢ Set.univ) := fun p hp => ⟨hp.2, Set.mem_univ _⟩
+    have hA_contOn : ContinuousOn (fun p : PhaseSpace d × ℝ => A p.1 p.2)
+        (Set.univ ×ˢ Set.Icc 0 T) :=
+      (vlasovFieldJacobian_continuousOn gradW ρ T hρD_cont).comp hg hmapsg
+    have hA_bound : ∀ z, ∀ s ∈ Set.Icc (0 : ℝ) T, ‖A z s‖ ≤ ((max 1 L : NNReal) : ℝ) := by
+      intro z s _
+      have heq : A z s = fderiv ℝ (vlasovVectorField gradW ρ s) (charX s z, charV s z) := by
+        simp only [hA_def]
+        exact (vlasovVectorField_hasFDerivAt_in_z gradW hgradW_C1 L hL ρ h_int s
+          (charX s z, charV s z)).fderiv.symm
+      rw [heq]
+      exact norm_fderiv_le_of_lipschitz ℝ (vlasovVectorField_lipschitzWith gradW L hL ρ h_int s)
+    exact fundamentalMatrix_continuous_param A T hT.le ((max 1 L : NNReal) : ℝ) (by positivity)
+      hA_contOn hA_bound t (Set.Ioo_subset_Icc_self ht)
+
+open Filter Topology in
+omit [NeZero d] in
+/-- **Step 1 (dual core) — lower Grönwall / anti-Lipschitz bound on the characteristic flow.**
+For `t ∈ (0,T)`, the flow `Φ_t : z ↦ (charX t z, charV t z)` satisfies
+`dist z₁ z₂ ≤ dist (Φ_t z₁) (Φ_t z₂) · exp(K t)` (K = max 1 L), i.e. `Φ_t` is `AntilipschitzWith`.
+This is the keystone of the two-time-flow inverse construction (Step 2): bi-Lipschitz makes `Φ_t`
+injective with closed range and `M_t = DΦ_t` invertible (no Liouville needed).
+
+Proof: time-reverse the two trajectories on each `[s₀,t] ⊆ (0,T)` (so they solve
+`w' = −b_{s₀+t−r}(w)`, still K-Lipschitz) and apply the existing forward
+`dist_le_of_trajectories_ODE`; take `s₀→0⁺`.  `h_deriv2` is the two-sided `HasDerivAt` on the open
+interval, supplied by `IsCharacteristicFlowOn`. -/
+theorem charFlow_antilipschitzInZ_via_gronwall_Ioo
+    (gradW : PhysSpace d → PhysSpace d)
+    (L : NNReal) (hL : LipschitzWith L gradW)
+    (ρ : ℝ → Measure (PhysSpace d))
+    [∀ t, IsProbabilityMeasure (ρ t)]
+    (h_int : ∀ t (x : PhysSpace d), Integrable (fun y => gradW (x - y)) (ρ t))
+    (charX charV : ℝ → PhaseSpace d → PhysSpace d)
+    (T : ℝ)
+    (h_init : ∀ z : PhaseSpace d, (charX 0 z, charV 0 z) = z)
+    (h_cont_Icc : ∀ z, ContinuousOn (fun s => (charX s z, charV s z)) (Set.Icc (0 : ℝ) T))
+    (h_deriv2 : ∀ z, ∀ s ∈ Set.Ioo (0 : ℝ) T,
+      HasDerivAt (fun s' => (charX s' z, charV s' z))
+        (vlasovVectorField gradW ρ s (charX s z, charV s z)) s) :
+    ∀ t ∈ Set.Ioo (0 : ℝ) T, ∀ z₁ z₂ : PhaseSpace d,
+      dist z₁ z₂ ≤
+        dist ((charX t z₁, charV t z₁) : PhaseSpace d) (charX t z₂, charV t z₂)
+          * Real.exp (((max 1 L : NNReal) : ℝ) * (t - 0)) := by
+  intro t ht z₁ z₂
+  set K : NNReal := max 1 L with hK_def
+  have h_vf_lip : ∀ s, LipschitzWith K (vlasovVectorField gradW ρ s) := fun s =>
+    vlasovVectorField_lipschitzWith gradW L hL ρ h_int s
+  set F : ℝ → PhaseSpace d := fun s => (charX s z₁, charV s z₁) with hF_def
+  set G : ℝ → PhaseSpace d := fun s => (charX s z₂, charV s z₂) with hG_def
+  -- Per-`s₀` antilipschitz bound on `[s₀, t]`.
+  have h_perS0 : ∀ s₀ ∈ Set.Ioo (0 : ℝ) t,
+      dist (F s₀) (G s₀) ≤ dist (F t) (G t) * Real.exp ((K : ℝ) * (t - s₀)) := by
+    intro s₀ hs₀
+    have hsub_Ioo : Set.Icc s₀ t ⊆ Set.Ioo (0 : ℝ) T := fun r hr =>
+      ⟨lt_of_lt_of_le hs₀.1 hr.1, lt_of_le_of_lt hr.2 ht.2⟩
+    have hsub_Icc : Set.Icc s₀ t ⊆ Set.Icc (0 : ℝ) T := fun r hr =>
+      ⟨le_of_lt (lt_of_lt_of_le hs₀.1 hr.1), le_of_lt (lt_of_le_of_lt hr.2 ht.2)⟩
+    have hrefl_mem : ∀ r ∈ Set.Icc s₀ t, s₀ + t - r ∈ Set.Icc s₀ t := by
+      intro r hr; exact ⟨by linarith [hr.2], by linarith [hr.1]⟩
+    have hrefl_cont : ContinuousOn (fun r : ℝ => s₀ + t - r) (Set.Icc s₀ t) :=
+      (continuous_const.sub continuous_id).continuousOn
+    set vr : ℝ → PhaseSpace d → PhaseSpace d :=
+      fun r w => -(vlasovVectorField gradW ρ (s₀ + t - r) w) with hvr_def
+    have hvr_lip : ∀ r, LipschitzWith K (vr r) := fun r => (h_vf_lip (s₀ + t - r)).neg
+    have hFr_cont : ContinuousOn (fun r => F (s₀ + t - r)) (Set.Icc s₀ t) :=
+      (h_cont_Icc z₁).comp hrefl_cont (fun r hr => hsub_Icc (hrefl_mem r hr))
+    have hGr_cont : ContinuousOn (fun r => G (s₀ + t - r)) (Set.Icc s₀ t) :=
+      (h_cont_Icc z₂).comp hrefl_cont (fun r hr => hsub_Icc (hrefl_mem r hr))
+    have hFr' : ∀ r ∈ Set.Ico s₀ t,
+        HasDerivWithinAt (fun r => F (s₀ + t - r)) (vr r (F (s₀ + t - r))) (Set.Ici r) r := by
+      intro r hr
+      have hrIoo : s₀ + t - r ∈ Set.Ioo (0 : ℝ) T :=
+        hsub_Ioo ⟨by linarith [hr.2], by linarith [hr.1]⟩
+      have hlin : HasDerivAt (fun r : ℝ => s₀ + t - r) (-1) r := by
+        simpa using (hasDerivAt_id r).const_sub (s₀ + t)
+      have key : HasDerivAt (fun r => F (s₀ + t - r))
+          ((-1 : ℝ) • vlasovVectorField gradW ρ (s₀ + t - r) (F (s₀ + t - r))) r :=
+        HasDerivAt.scomp_of_eq r (h_deriv2 z₁ (s₀ + t - r) hrIoo) hlin rfl
+      simp only [neg_one_smul] at key
+      exact key.hasDerivWithinAt
+    have hGr' : ∀ r ∈ Set.Ico s₀ t,
+        HasDerivWithinAt (fun r => G (s₀ + t - r)) (vr r (G (s₀ + t - r))) (Set.Ici r) r := by
+      intro r hr
+      have hrIoo : s₀ + t - r ∈ Set.Ioo (0 : ℝ) T :=
+        hsub_Ioo ⟨by linarith [hr.2], by linarith [hr.1]⟩
+      have hlin : HasDerivAt (fun r : ℝ => s₀ + t - r) (-1) r := by
+        simpa using (hasDerivAt_id r).const_sub (s₀ + t)
+      have key : HasDerivAt (fun r => G (s₀ + t - r))
+          ((-1 : ℝ) • vlasovVectorField gradW ρ (s₀ + t - r) (G (s₀ + t - r))) r :=
+        HasDerivAt.scomp_of_eq r (h_deriv2 z₂ (s₀ + t - r) hrIoo) hlin rfl
+      simp only [neg_one_smul] at key
+      exact key.hasDerivWithinAt
+    have hgron := dist_le_of_trajectories_ODE hvr_lip hFr_cont hFr' hGr_cont hGr'
+      (le_refl (dist (F (s₀ + t - s₀)) (G (s₀ + t - s₀)))) t ⟨hs₀.2.le, le_refl t⟩
+    simp only [show s₀ + t - t = s₀ from by ring, show s₀ + t - s₀ = t from by ring] at hgron
+    exact hgron
+  -- `s₀ → 0⁺` limit.
+  have hfilt : (nhdsWithin (0 : ℝ) (Set.Ioo 0 t)).NeBot := left_nhdsWithin_Ioo_neBot ht.1
+  have hIoo_sub_Icc : Set.Ioo (0 : ℝ) t ⊆ Set.Icc (0 : ℝ) T := fun s hs =>
+    ⟨hs.1.le, le_of_lt (lt_trans hs.2 ht.2)⟩
+  have h_tendsto_F : Tendsto F (nhdsWithin (0 : ℝ) (Set.Ioo 0 t)) (nhds z₁) := by
+    have hcw : ContinuousWithinAt F (Set.Icc (0 : ℝ) T) 0 :=
+      (h_cont_Icc z₁) 0 ⟨le_refl 0, le_of_lt (lt_trans ht.1 ht.2)⟩
+    have h0 : Tendsto F (nhdsWithin (0 : ℝ) (Set.Icc 0 T)) (nhds (F 0)) := hcw
+    rw [show F 0 = z₁ from h_init z₁] at h0
+    exact h0.mono_left (nhdsWithin_mono 0 hIoo_sub_Icc)
+  have h_tendsto_G : Tendsto G (nhdsWithin (0 : ℝ) (Set.Ioo 0 t)) (nhds z₂) := by
+    have hcw : ContinuousWithinAt G (Set.Icc (0 : ℝ) T) 0 :=
+      (h_cont_Icc z₂) 0 ⟨le_refl 0, le_of_lt (lt_trans ht.1 ht.2)⟩
+    have h0 : Tendsto G (nhdsWithin (0 : ℝ) (Set.Icc 0 T)) (nhds (G 0)) := hcw
+    rw [show G 0 = z₂ from h_init z₂] at h0
+    exact h0.mono_left (nhdsWithin_mono 0 hIoo_sub_Icc)
+  have h_tendsto_lhs : Tendsto (fun s₀ => dist (F s₀) (G s₀))
+      (nhdsWithin (0 : ℝ) (Set.Ioo 0 t)) (nhds (dist z₁ z₂)) :=
+    h_tendsto_F.dist h_tendsto_G
+  have h_tendsto_rhs : Tendsto (fun s₀ => dist (F t) (G t) * Real.exp ((K : ℝ) * (t - s₀)))
+      (nhdsWithin (0 : ℝ) (Set.Ioo 0 t))
+      (nhds (dist (F t) (G t) * Real.exp ((K : ℝ) * (t - 0)))) := by
+    have hcont : Continuous (fun s₀ : ℝ => dist (F t) (G t) * Real.exp ((K : ℝ) * (t - s₀))) := by
+      fun_prop
+    exact (hcont.tendsto 0).mono_left nhdsWithin_le_nhds
+  exact le_of_tendsto_of_tendsto h_tendsto_lhs h_tendsto_rhs
+    (eventually_nhdsWithin_of_forall h_perS0)
+
+section Step2Inverse
+open Filter Topology
+
+/-- **Step 2a (dual core, generic) — antilipschitz map ⇒ antilipschitz derivative.**
+If `f` is antilipschitz and Fréchet-differentiable at `x`, its derivative `f'` is antilipschitz
+(hence injective) with the same constant.  `f' u` is the limit of slopes `n•(f(x+n⁻¹•u)−f x)`, each
+of norm `≥ ‖u‖/C` by antilipschitz; pass to the limit.  (Mathlib lacks this producer.) -/
+theorem antilipschitzWith_fderiv_of_antilipschitz
+    {E F : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
+    [NormedAddCommGroup F] [NormedSpace ℝ F]
+    {f : E → F} {f' : E →L[ℝ] F} {x : E} {C : NNReal}
+    (hf : AntilipschitzWith C f) (hf' : HasFDerivAt f f' x) :
+    AntilipschitzWith C f' := by
+  refine AntilipschitzWith.of_le_mul_dist (fun v w => ?_)
+  rw [dist_eq_norm, dist_eq_norm, ← map_sub]
+  set u := v - w with hu
+  have hc : Tendsto (fun n : ℕ => ‖((n : ℝ))‖) atTop atTop := by
+    simpa [Real.norm_natCast] using tendsto_natCast_atTop_atTop (R := ℝ)
+  have hlim := hf'.lim u hc
+  have hbd : ∀ᶠ n : ℕ in atTop,
+      ‖u‖ ≤ (C : ℝ) * ‖(n : ℝ) • (f (x + ((n : ℝ))⁻¹ • u) - f x)‖ := by
+    filter_upwards [eventually_gt_atTop 0] with n hn
+    have hn0 : (0 : ℝ) < (n : ℝ) := by exact_mod_cast hn
+    have hd := hf.le_mul_dist (x + ((n : ℝ))⁻¹ • u) x
+    rw [dist_eq_norm, dist_eq_norm, add_sub_cancel_left, norm_smul, norm_inv,
+      Real.norm_natCast] at hd
+    rw [norm_smul, Real.norm_natCast]
+    calc ‖u‖ = (n : ℝ) * ((n : ℝ)⁻¹ * ‖u‖) := by
+              rw [← mul_assoc, mul_inv_cancel₀ (ne_of_gt hn0), one_mul]
+      _ ≤ (n : ℝ) * ((C : ℝ) * ‖f (x + ((n : ℝ))⁻¹ • u) - f x‖) :=
+              mul_le_mul_of_nonneg_left hd (le_of_lt hn0)
+      _ = (C : ℝ) * ((n : ℝ) * ‖f (x + ((n : ℝ))⁻¹ • u) - f x‖) := by ring
+  have hlim2 : Tendsto (fun n : ℕ => (C : ℝ) * ‖(n : ℝ) • (f (x + ((n : ℝ))⁻¹ • u) - f x)‖)
+      atTop (𝓝 ((C : ℝ) * ‖f' u‖)) := hlim.norm.const_mul (C : ℝ)
+  exact ge_of_tendsto hlim2 hbd
+
+/-- **Step 2 (dual core, generic) — global `C¹` inverse of an antilipschitz `C¹` self-map.**
+If `Φ : E → E` (finite-dim) is `C¹` (derivative `M z` at `z`), antilipschitz, and Lipschitz, then
+each `M z` is invertible, `Φ` is bijective, and the global inverse `Ψ` is Lipschitz with
+`HasFDerivAt Ψ (M (Ψ w))⁻¹ w`.  No Liouville/Hadamard: open range
+(`isOpenMap_of_hasStrictFDerivAt_equiv`) + closed range (`AntilipschitzWith.isClosed_range`) ⇒
+clopen ⇒ surjective; inverse derivative from `HasStrictFDerivAt.to_local_left_inverse`. -/
+theorem exists_global_c1_inverse_of_antilipschitz
+    {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] [FiniteDimensional ℝ E]
+    {Φ : E → E} {M : E → (E →L[ℝ] E)} {Ca Cl : NNReal}
+    (hderiv : ∀ z, HasFDerivAt Φ (M z) z)
+    (hM_cont : Continuous M)
+    (hanti : AntilipschitzWith Ca Φ)
+    (hlip : LipschitzWith Cl Φ) :
+    ∃ (Ψ : E → E) (e : E → E ≃L[ℝ] E),
+      (∀ z, ((e z : E →L[ℝ] E)) = M z) ∧
+      Function.LeftInverse Ψ Φ ∧ Function.RightInverse Ψ Φ ∧
+      LipschitzWith Ca Ψ ∧
+      (∀ w, HasFDerivAt Ψ ((e (Ψ w)).symm : E →L[ℝ] E) w) := by
+  classical
+  have hMz_anti : ∀ z, AntilipschitzWith Ca (M z) := fun z =>
+    antilipschitzWith_fderiv_of_antilipschitz hanti (hderiv z)
+  have hker : ∀ z, LinearMap.ker (M z : E →ₗ[ℝ] E) = ⊥ := fun z =>
+    LinearMap.ker_eq_bot.mpr (hMz_anti z).injective
+  have hsurj_lin : ∀ z, LinearMap.range (M z : E →ₗ[ℝ] E) = ⊤ := fun z =>
+    LinearMap.range_eq_top.mpr (LinearMap.injective_iff_surjective.mp (hMz_anti z).injective)
+  set e : ∀ z, E ≃L[ℝ] E := fun z =>
+    ContinuousLinearEquiv.ofBijective (M z) (hker z) (hsurj_lin z) with he_def
+  have he_coe : ∀ z, ((e z : E →L[ℝ] E)) = M z := fun _ => rfl
+  have hC1 : ContDiff ℝ 1 Φ := contDiff_one_iff_hasFDerivAt.mpr ⟨M, hM_cont, hderiv⟩
+  have hstrict : ∀ z, HasStrictFDerivAt Φ ((e z : E →L[ℝ] E)) z := fun z => by
+    rw [he_coe z]; exact hC1.contDiffAt.hasStrictFDerivAt' (hderiv z) (by norm_num)
+  have hopen : IsOpenMap Φ := isOpenMap_of_hasStrictFDerivAt_equiv hstrict
+  have hrange_open : IsOpen (Set.range Φ) := hopen.isOpen_range
+  have hrange_closed : IsClosed (Set.range Φ) := hanti.isClosed_range hlip.uniformContinuous
+  have hrange_univ : Set.range Φ = Set.univ :=
+    IsClopen.eq_univ ⟨hrange_closed, hrange_open⟩ ⟨Φ 0, Set.mem_range_self 0⟩
+  have hsurj : Function.Surjective Φ := Set.range_eq_univ.mp hrange_univ
+  have hinj : Function.Injective Φ := hanti.injective
+  set Ψ : E → E := Function.invFun Φ with hΨ_def
+  have hLeft : Function.LeftInverse Ψ Φ := Function.leftInverse_invFun hinj
+  have hRight : Function.RightInverse Ψ Φ := Function.rightInverse_invFun hsurj
+  have hΨ_lip : LipschitzWith Ca Ψ := by
+    refine LipschitzWith.of_dist_le_mul (fun w₁ w₂ => ?_)
+    have h := hanti.le_mul_dist (Ψ w₁) (Ψ w₂)
+    rwa [hRight w₁, hRight w₂] at h
+  have hΨ_deriv : ∀ w, HasFDerivAt Ψ ((e (Ψ w)).symm : E →L[ℝ] E) w := by
+    intro w
+    have hz : Φ (Ψ w) = w := hRight w
+    have hev : ∀ᶠ x in 𝓝 (Ψ w), Ψ (Φ x) = x := Filter.Eventually.of_forall hLeft
+    have hsymm := (hstrict (Ψ w)).to_local_left_inverse hev
+    rw [hz] at hsymm
+    exact hsymm.hasFDerivAt
+  exact ⟨Ψ, e, he_coe, hLeft, hRight, hΨ_lip, hΨ_deriv⟩
+
+end Step2Inverse
+
+omit [NeZero d] in
+/-- **Step 2 (dual core) — the characteristic flow `Φ_t` is a `C¹` diffeomorphism on `(0,T)`.**
+Instantiates the generic global-inverse machinery at `Φ_t := (charX t, charV t)`: its derivative
+`e z` (= `#3`'s `Dflow t z`) is invertible, `Φ_t` is bijective, and the inverse `Ψ` is continuous
+with `HasFDerivAt Ψ (e (Ψ w))⁻¹ w`.  `hanti` comes from Step 1
+(`charFlow_antilipschitzInZ_via_gronwall_Ioo`), `hlip` from the existing upper Grönwall bound
+(`charFlow_lipschitzInZ_via_gronwall_Ioo`), the derivative family from `#3`. -/
+theorem exists_charFlow_inverse_On
+    (gradW : PhysSpace d → PhysSpace d) (hgradW_C1 : ContDiff ℝ 1 gradW)
+    (L : NNReal) (hL : LipschitzWith L gradW)
+    (ρ : ℝ → Measure (PhysSpace d)) [∀ s, IsProbabilityMeasure (ρ s)]
+    (charX charV : ℝ → PhaseSpace d → PhysSpace d)
+    (T : ℝ) (hT : 0 < T)
+    (hflow : IsCharacteristicFlowOn gradW ρ charX charV (Set.Ioo 0 T) Set.univ)
+    (h_int : ∀ s (x : PhysSpace d), Integrable (fun y => gradW (x - y)) (ρ s))
+    (hρD_cont : ContinuousOn
+      (fun p : ℝ × PhysSpace d => ∫ y, fderiv ℝ gradW (p.2 - y) ∂(ρ p.1))
+      (Set.Icc 0 T ×ˢ (Set.univ : Set (PhysSpace d))))
+    (hcontIcc : ∀ z : PhaseSpace d,
+      ContinuousOn (fun s => (charX s z, charV s z)) (Set.Icc (0 : ℝ) T)) :
+    ∀ t ∈ Set.Ioo (0 : ℝ) T,
+      ∃ (Ψ : PhaseSpace d → PhaseSpace d)
+        (e : PhaseSpace d → (PhaseSpace d ≃L[ℝ] PhaseSpace d)),
+        (∀ z, HasFDerivAt (fun w => (charX t w, charV t w))
+          ((e z : PhaseSpace d →L[ℝ] PhaseSpace d)) z) ∧
+        Function.LeftInverse Ψ (fun z => (charX t z, charV t z)) ∧
+        Function.RightInverse Ψ (fun z => (charX t z, charV t z)) ∧
+        Continuous Ψ ∧
+        (∀ w, HasFDerivAt Ψ ((e (Ψ w)).symm : PhaseSpace d →L[ℝ] PhaseSpace d) w) := by
+  have h_init : ∀ z : PhaseSpace d, (charX 0 z, charV 0 z) = z := fun z =>
+    Prod.ext_iff.mpr (hflow.1 z (Set.mem_univ z))
+  have h_deriv2 : ∀ z, ∀ s ∈ Set.Ioo (0 : ℝ) T,
+      HasDerivAt (fun s' => (charX s' z, charV s' z))
+        (vlasovVectorField gradW ρ s (charX s z, charV s z)) s := fun z s hs =>
+    HasDerivAt.prodMk (hflow.2.1 s hs z (Set.mem_univ z)) (hflow.2.2 s hs z (Set.mem_univ z))
+  have h_deriv_Ioo : ∀ z, ∀ s ∈ Set.Ioo (0 : ℝ) T,
+      HasDerivWithinAt (fun s' => (charX s' z, charV s' z))
+        (vlasovVectorField gradW ρ s (charX s z, charV s z)) (Set.Ici s) s := fun z s hs =>
+    (h_deriv2 z s hs).hasDerivWithinAt
+  obtain ⟨Dflow, hDeriv, hCont⟩ := charFlow_hasFDerivAt_in_initialPoint gradW hgradW_C1 L hL ρ
+    charX charV T hT hflow h_int hρD_cont hcontIcc
+  intro t ht
+  set K : ℝ := ((max 1 L : NNReal) : ℝ) with hK
+  have hCcoe : (((Real.exp (K * t)).toNNReal : NNReal) : ℝ) = Real.exp (K * t) :=
+    Real.coe_toNNReal _ (le_of_lt (Real.exp_pos _))
+  have hderiv : ∀ z, HasFDerivAt (fun z => (charX t z, charV t z)) (Dflow t z) z := fun z =>
+    hDeriv t ht z
+  have hM_cont : Continuous (Dflow t) := hCont t ht
+  have hanti : AntilipschitzWith (Real.exp (K * t)).toNNReal
+      (fun z => (charX t z, charV t z)) := by
+    refine AntilipschitzWith.of_le_mul_dist (fun z₁ z₂ => ?_)
+    have h1 := charFlow_antilipschitzInZ_via_gronwall_Ioo gradW L hL ρ h_int charX charV T
+      h_init hcontIcc h_deriv2 t ht z₁ z₂
+    rw [sub_zero] at h1
+    rw [hCcoe, mul_comm]
+    exact h1
+  have hlip : LipschitzWith (Real.exp (K * t)).toNNReal
+      (fun z => (charX t z, charV t z)) := by
+    refine LipschitzWith.of_dist_le_mul (fun z₁ z₂ => ?_)
+    have h1 := charFlow_lipschitzInZ_via_gronwall_Ioo gradW L hL ρ h_int charX charV T hT.le
+      h_init hcontIcc h_deriv_Ioo t (Set.Ioo_subset_Icc_self ht) z₁ z₂
+    rw [sub_zero] at h1
+    rw [hCcoe, mul_comm]
+    exact h1
+  obtain ⟨Ψ, e, he_coe, hLeft, hRight, hΨlip, hΨderiv⟩ :=
+    exists_global_c1_inverse_of_antilipschitz hderiv hM_cont hanti hlip
+  refine ⟨Ψ, e, ?_, hLeft, hRight, hΨlip.continuous, hΨderiv⟩
+  intro z; rw [he_coe z]; exact hderiv z
+
+section Step3Joint
+open Filter Topology Asymptotics
+
+
+end Step3Joint
+
+omit [NeZero d] in
+/-- **Step 3 — the forward flow `(s,z) ↦ Φ_s z` is jointly continuous** on `Icc 0 T ×ˢ univ`
+(`(s,z)`-order).  Gronwall Lipschitz-in-`z` (uniform over `[0,T]`) + per-`z` continuity-in-`s`, via
+the generic `continuousOn_prod_of_lipschitz_continuousOn`, then a prod-order swap.  Extracted from
+`#3`'s V2-branch pattern so the joint `C¹`-ness (Step 3 (iii)) can reuse it directly. -/
+lemma charFlow_continuousOn_joint
+    (gradW : PhysSpace d → PhysSpace d) (L : NNReal) (hL : LipschitzWith L gradW)
+    (ρ : ℝ → Measure (PhysSpace d)) [∀ s, IsProbabilityMeasure (ρ s)]
+    (h_int : ∀ s (x : PhysSpace d), Integrable (fun y => gradW (x - y)) (ρ s))
+    (charX charV : ℝ → PhaseSpace d → PhysSpace d) (T : ℝ) (hT : 0 ≤ T)
+    (hinit : ∀ z : PhaseSpace d, (charX 0 z, charV 0 z) = z)
+    (hcontIcc : ∀ z, ContinuousOn (fun s => (charX s z, charV s z)) (Set.Icc (0 : ℝ) T))
+    (hderiv : ∀ z, ∀ s ∈ Set.Ioo (0 : ℝ) T,
+      HasDerivWithinAt (fun s => (charX s z, charV s z))
+        (vlasovVectorField gradW ρ s (charX s z, charV s z)) (Set.Ici s) s) :
+    ContinuousOn (fun p : ℝ × PhaseSpace d => (charX p.1 p.2, charV p.1 p.2))
+      (Set.Icc (0 : ℝ) T ×ˢ Set.univ) := by
+  have hgron := charFlow_lipschitzInZ_via_gronwall_Ioo gradW L hL ρ h_int charX charV T hT
+    hinit hcontIcc hderiv
+  have hjoint_zs : ContinuousOn (fun p : PhaseSpace d × ℝ => (charX p.2 p.1, charV p.2 p.1))
+      (Set.univ ×ˢ Set.Icc (0 : ℝ) T) := by
+    refine continuousOn_prod_of_lipschitz_continuousOn (fun z s => (charX s z, charV s z)) T
+      (Real.exp (((max 1 L : NNReal) : ℝ) * T)) (fun s hs z₁ z₂ => ?_) hcontIcc
+    calc dist ((charX s z₁, charV s z₁) : PhaseSpace d) (charX s z₂, charV s z₂)
+        ≤ dist z₁ z₂ * Real.exp (((max 1 L : NNReal) : ℝ) * (s - 0)) := hgron s hs z₁ z₂
+      _ = Real.exp (((max 1 L : NNReal) : ℝ) * (s - 0)) * dist z₁ z₂ := by ring
+      _ ≤ Real.exp (((max 1 L : NNReal) : ℝ) * T) * dist z₁ z₂ := by
+          refine mul_le_mul_of_nonneg_right (Real.exp_le_exp.mpr ?_) dist_nonneg
+          have hsT : s - 0 ≤ T := by simp only [sub_zero]; exact hs.2
+          exact mul_le_mul_of_nonneg_left hsT (by positivity)
+  have hswap : ContinuousOn (fun p : ℝ × PhaseSpace d => ((p.2, p.1) : PhaseSpace d × ℝ))
+      (Set.Icc (0 : ℝ) T ×ˢ Set.univ) := (continuous_snd.prodMk continuous_fst).continuousOn
+  have hmaps : Set.MapsTo (fun p : ℝ × PhaseSpace d => ((p.2, p.1) : PhaseSpace d × ℝ))
+      (Set.Icc (0 : ℝ) T ×ˢ Set.univ) (Set.univ ×ˢ Set.Icc (0 : ℝ) T) :=
+    fun p hp => ⟨Set.mem_univ _, hp.1⟩
+  exact hjoint_zs.comp hswap hmaps
+
+omit [NeZero d] in
+/-- **Step 3 (ii) — the field along the flow `(s,z) ↦ b_s(Φ_s z)` is jointly continuous** on
+`Icc 0 T ×ˢ univ`.  First component `charV` from flow joint continuity; second component
+`-(∇W ∗ ρ_s)(charX s z)` from `(s,x) ↦ (∇W∗ρ_s)(x)` jointly continuous (equi-Lipschitz-in-`x` from
+`convolveFunctionMeasure_lipschitz_in_x` + continuous-in-`s` from `hf_cont`) composed with the flow.
+This is the partial-`s`-derivative continuity input to the joint `C¹`-ness (Step 3 (iii)). -/
+lemma vlasovField_along_flow_continuousOn
+    (gradW : PhysSpace d → PhysSpace d) (L : NNReal) (hL : LipschitzWith L gradW)
+    (ρ : ℝ → Measure (PhysSpace d)) [∀ s, IsProbabilityMeasure (ρ s)]
+    (h_int : ∀ s (x : PhysSpace d), Integrable (fun y => gradW (x - y)) (ρ s))
+    (hf_cont : ∀ x, Continuous (fun s => convolveFunctionMeasure gradW (ρ s) x))
+    (charX charV : ℝ → PhaseSpace d → PhysSpace d) (T : ℝ)
+    (hflowjoint : ContinuousOn (fun p : ℝ × PhaseSpace d => (charX p.1 p.2, charV p.1 p.2))
+      (Set.Icc (0 : ℝ) T ×ˢ Set.univ)) :
+    ContinuousOn (fun p : ℝ × PhaseSpace d =>
+        vlasovVectorField gradW ρ p.1 (charX p.1 p.2, charV p.1 p.2))
+      (Set.Icc (0 : ℝ) T ×ˢ Set.univ) := by
+  have hcomp1 : ContinuousOn (fun p : ℝ × PhaseSpace d => charV p.1 p.2)
+      (Set.Icc (0 : ℝ) T ×ˢ Set.univ) := continuous_snd.comp_continuousOn hflowjoint
+  have hcharX : ContinuousOn (fun p : ℝ × PhaseSpace d => charX p.1 p.2)
+      (Set.Icc (0 : ℝ) T ×ˢ Set.univ) := continuous_fst.comp_continuousOn hflowjoint
+  have hconv_joint : ContinuousOn
+      (fun p : PhysSpace d × ℝ => convolveFunctionMeasure gradW (ρ p.2) p.1)
+      (Set.univ ×ˢ Set.Icc (0 : ℝ) T) :=
+    continuousOn_prod_of_lipschitz_continuousOn
+      (fun (x : PhysSpace d) (s : ℝ) => convolveFunctionMeasure gradW (ρ s) x) T (L:ℝ)
+      (fun s _ x₁ x₂ =>
+        (convolveFunctionMeasure_lipschitz_in_x gradW L hL (ρ s) (h_int s)).dist_le_mul x₁ x₂)
+      (fun x => (hf_cont x).continuousOn)
+  have hg2 : ContinuousOn (fun p : ℝ × PhaseSpace d => ((charX p.1 p.2, p.1) : PhysSpace d × ℝ))
+      (Set.Icc (0 : ℝ) T ×ˢ Set.univ) := hcharX.prodMk continuousOn_fst
+  have hg2maps : Set.MapsTo (fun p : ℝ × PhaseSpace d => ((charX p.1 p.2, p.1) : PhysSpace d × ℝ))
+      (Set.Icc (0 : ℝ) T ×ˢ Set.univ) (Set.univ ×ˢ Set.Icc (0 : ℝ) T) :=
+    fun p hp => ⟨Set.mem_univ _, hp.1⟩
+  have hconv_along : ContinuousOn
+      (fun p : ℝ × PhaseSpace d => convolveFunctionMeasure gradW (ρ p.1) (charX p.1 p.2))
+      (Set.Icc (0 : ℝ) T ×ˢ Set.univ) := hconv_joint.comp hg2 hg2maps
+  have heq : (fun p : ℝ × PhaseSpace d =>
+        vlasovVectorField gradW ρ p.1 (charX p.1 p.2, charV p.1 p.2))
+      = fun p => ((charV p.1 p.2),
+          -(convolveFunctionMeasure gradW (ρ p.1) (charX p.1 p.2))) := by
+    funext p; rfl
+  rw [heq]
+  exact hcomp1.prodMk hconv_along.neg
+
+omit [NeZero d] in
+/-- **Step 3 (iii) — the forward flow `(s,z) ↦ Φ_s z` is jointly `C¹`** on `U := Ioo 0 T ×ˢ univ`:
+Fréchet-differentiable at every point with a jointly-continuous total derivative `DΦ`.  Built by
+composing the open-set gating theorem (`hasFDerivAt_of_continuous_partials_open`) — fed the
+`s`-partial `b_s(Φ_s z)` (flow ODE, jointly continuous by item (ii)) and the `z`-partial `M_s z`
+(the fundamental matrix, via D1c, jointly continuous by item (i)).  Per L14 the matrix is rebuilt
+concretely (`fundamentalMatrix (A z) s`), NOT routed through `#3`'s existential.
+
+The field `bfun` and matrix `Mfun` are made opaque locals (`clear_value`, the D1c lesson) so the
+gating unification stays syntactic and never unfolds the `vlasovVectorField`/`vlasovFieldJacobian`
+integrals — the per-point derivative facts are established in terms of them *before* clearing.
+`A` is kept transparent through the D1c call (whose coefficient is
+`vlasovFieldJacobian`) and cleared
+only afterwards (before the projection-reduction defeqs).  No `maxHeartbeats` bump needed. -/
+theorem charFlow_hasFDerivAt_joint
+    (gradW : PhysSpace d → PhysSpace d) (hgradW_C1 : ContDiff ℝ 1 gradW)
+    (L : NNReal) (hL : LipschitzWith L gradW)
+    (ρ : ℝ → Measure (PhysSpace d)) [∀ s, IsProbabilityMeasure (ρ s)]
+    (charX charV : ℝ → PhaseSpace d → PhysSpace d)
+    (T : ℝ) (hT : 0 < T)
+    (hflow : IsCharacteristicFlowOn gradW ρ charX charV (Set.Ioo 0 T) Set.univ)
+    (h_int : ∀ s (x : PhysSpace d), Integrable (fun y => gradW (x - y)) (ρ s))
+    (hf_cont : ∀ x, Continuous (fun s => convolveFunctionMeasure gradW (ρ s) x))
+    (hρD_cont : ContinuousOn
+      (fun p : ℝ × PhysSpace d => ∫ y, fderiv ℝ gradW (p.2 - y) ∂(ρ p.1))
+      (Set.Icc 0 T ×ˢ (Set.univ : Set (PhysSpace d))))
+    (hcontIcc : ∀ z : PhaseSpace d,
+      ContinuousOn (fun s => (charX s z, charV s z)) (Set.Icc (0 : ℝ) T)) :
+    ∃ DΦ : ℝ × PhaseSpace d → (ℝ × PhaseSpace d →L[ℝ] PhaseSpace d),
+      (∀ p ∈ Set.Ioo (0 : ℝ) T ×ˢ (Set.univ : Set (PhaseSpace d)),
+        HasFDerivAt (fun q : ℝ × PhaseSpace d => (charX q.1 q.2, charV q.1 q.2)) (DΦ p) p) ∧
+      ContinuousOn DΦ (Set.Ioo (0 : ℝ) T ×ˢ Set.univ) := by
+  set A : PhaseSpace d → ℝ → (PhaseSpace d →L[ℝ] PhaseSpace d) :=
+    fun z s => vlasovFieldJacobian gradW ρ (s, (charX s z, charV s z)) with hA_def
+  have hAcont : ∀ z, ContinuousOn (A z) (Set.Icc 0 T) := fun z =>
+    vlasovVariationalCoeff_continuousOn gradW ρ charX charV T z (hcontIcc z) hρD_cont
+  have h_init : ∀ z : PhaseSpace d, (charX 0 z, charV 0 z) = z := fun z =>
+    Prod.ext_iff.mpr ⟨(hflow.1 z (Set.mem_univ z)).1, (hflow.1 z (Set.mem_univ z)).2⟩
+  have h_deriv : ∀ z, ∀ s ∈ Set.Ioo (0 : ℝ) T,
+      HasDerivWithinAt (fun s => (charX s z, charV s z))
+        (vlasovVectorField gradW ρ s (charX s z, charV s z)) (Set.Ici s) s := fun z s hs =>
+    (HasDerivAt.prodMk (hflow.2.1 s hs z (Set.mem_univ z))
+      (hflow.2.2 s hs z (Set.mem_univ z))).hasDerivWithinAt
+  have hflowjoint_sz : ContinuousOn (fun q : ℝ × PhaseSpace d => (charX q.1 q.2, charV q.1 q.2))
+      (Set.Icc 0 T ×ˢ Set.univ) :=
+    charFlow_continuousOn_joint gradW L hL ρ h_int charX charV T hT.le h_init hcontIcc h_deriv
+  -- field as an opaque local
+  set bfun : ℝ × PhaseSpace d → PhaseSpace d :=
+    fun q => vlasovVectorField gradW ρ q.1 (charX q.1 q.2, charV q.1 q.2) with hbfun_def
+  have hb_cont : ContinuousOn bfun (Set.Icc 0 T ×ˢ Set.univ) :=
+    vlasovField_along_flow_continuousOn gradW L hL ρ h_int hf_cont charX charV T hflowjoint_sz
+  -- `A` jointly continuous + bounded ⇒ `M` jointly continuous (item (i))
+  have hflowjoint_zs : ContinuousOn (fun p : PhaseSpace d × ℝ => (charX p.2 p.1, charV p.2 p.1))
+      (Set.univ ×ˢ Set.Icc 0 T) := by
+    have hswap : ContinuousOn (fun p : PhaseSpace d × ℝ => ((p.2, p.1) : ℝ × PhaseSpace d))
+        (Set.univ ×ˢ Set.Icc 0 T) := (continuous_snd.prodMk continuous_fst).continuousOn
+    have hmaps : Set.MapsTo (fun p : PhaseSpace d × ℝ => ((p.2, p.1) : ℝ × PhaseSpace d))
+        (Set.univ ×ˢ Set.Icc 0 T) (Set.Icc 0 T ×ˢ Set.univ) := fun p hp => ⟨hp.2, Set.mem_univ _⟩
+    exact hflowjoint_sz.comp hswap hmaps
+  have hg : ContinuousOn
+      (fun p : PhaseSpace d × ℝ => ((p.2, (charX p.2 p.1, charV p.2 p.1)) : ℝ × PhaseSpace d))
+      (Set.univ ×ˢ Set.Icc 0 T) := continuousOn_snd.prodMk hflowjoint_zs
+  have hmapsg : Set.MapsTo
+      (fun p : PhaseSpace d × ℝ => ((p.2, (charX p.2 p.1, charV p.2 p.1)) : ℝ × PhaseSpace d))
+      (Set.univ ×ˢ Set.Icc 0 T) (Set.Icc 0 T ×ˢ Set.univ) := fun p hp => ⟨hp.2, Set.mem_univ _⟩
+  have hA_contOn : ContinuousOn (fun p : PhaseSpace d × ℝ => A p.1 p.2) (Set.univ ×ˢ Set.Icc 0 T) :=
+    (vlasovFieldJacobian_continuousOn gradW ρ T hρD_cont).comp hg hmapsg
+  have hA_bound : ∀ z, ∀ s ∈ Set.Icc (0 : ℝ) T, ‖A z s‖ ≤ ((max 1 L : NNReal) : ℝ) := by
+    intro z s _
+    have heq : A z s = fderiv ℝ (vlasovVectorField gradW ρ s) (charX s z, charV s z) := by
+      simp only [hA_def]
+      exact (vlasovVectorField_hasFDerivAt_in_z gradW hgradW_C1 L hL ρ h_int s
+        (charX s z, charV s z)).fderiv.symm
+    rw [heq]
+    exact norm_fderiv_le_of_lipschitz ℝ (vlasovVectorField_lipschitzWith gradW L hL ρ h_int s)
+  have hM_zs : ContinuousOn (fun p : PhaseSpace d × ℝ => fundamentalMatrix (A p.1) p.2)
+      (Set.univ ×ˢ Set.Icc 0 T) :=
+    fundamentalMatrix_continuous_param_joint A T hT.le ((max 1 L : NNReal) : ℝ) (by positivity)
+      hA_contOn hA_bound
+  have hU_open : IsOpen (Set.Ioo (0 : ℝ) T ×ˢ (Set.univ : Set (PhaseSpace d))) :=
+    isOpen_Ioo.prod isOpen_univ
+  have hU_sub : Set.Ioo (0 : ℝ) T ×ˢ (Set.univ : Set (PhaseSpace d)) ⊆ Set.Icc 0 T ×ˢ Set.univ :=
+    Set.prod_mono Set.Ioo_subset_Icc_self (subset_refl _)
+  -- matrix as a local (kept transparent for the D1c call, which needs `A`'s coefficient)
+  set Mfun : ℝ × PhaseSpace d → (PhaseSpace d →L[ℝ] PhaseSpace d) :=
+    fun p => fundamentalMatrix (A p.2) p.1 with hMfun_def
+  -- z-partial at base via D1c — needs `A` TRANSPARENT (its coefficient is `vlasovFieldJacobian`).
+  have hDz_all : ∀ s₀ ∈ Set.Ioo (0 : ℝ) T, ∀ z₀ : PhaseSpace d,
+      HasFDerivAt (fun z => (charX s₀ z, charV s₀ z)) (Mfun (s₀, z₀)) z₀ := by
+    intro s₀ hs₀ z₀
+    obtain ⟨h0, hMcont, hMderiv⟩ := fundamentalMatrix_spec (A z₀) T hT.le (hAcont z₀)
+    exact charFlow_hasFDerivAt_of_fundamentalMatrix gradW hgradW_C1 L hL ρ charX charV T hT hflow
+      h_int hρD_cont z₀ hcontIcc (fundamentalMatrix (A z₀)) h0 hMcont hMderiv s₀ hs₀
+  have hDs_all : ∀ p ∈ Set.Ioo (0 : ℝ) T ×ˢ (Set.univ : Set (PhaseSpace d)),
+      HasDerivAt (fun s => ((charX s p.2, charV s p.2) : PhaseSpace d)) (bfun p) p.1 := by
+    intro p hp'
+    exact HasDerivAt.prodMk (hflow.2.1 p.1 hp'.1 p.2 (Set.mem_univ _))
+      (hflow.2.2 p.1 hp'.1 p.2 (Set.mem_univ _))
+  -- NOW make `A`/field/matrix opaque so the projection-reduction defeqs below never unfold the
+  -- heavy `vlasovFieldJacobian`/`vlasovVectorField` integrals (D1c lesson).
+  clear_value A bfun Mfun
+  have hM_sz : ContinuousOn Mfun (Set.Ioo (0 : ℝ) T ×ˢ Set.univ) := by
+    rw [hMfun_def]
+    have hswap : ContinuousOn (fun p : ℝ × PhaseSpace d => ((p.2, p.1) : PhaseSpace d × ℝ))
+        (Set.Ioo (0 : ℝ) T ×ˢ Set.univ) := (continuous_snd.prodMk continuous_fst).continuousOn
+    have hmaps : Set.MapsTo (fun p : ℝ × PhaseSpace d => ((p.2, p.1) : PhaseSpace d × ℝ))
+        (Set.Ioo (0 : ℝ) T ×ˢ Set.univ) (Set.univ ×ˢ Set.Icc 0 T) :=
+      fun p hp => ⟨Set.mem_univ _, Set.Ioo_subset_Icc_self hp.1⟩
+    exact hM_zs.comp hswap hmaps
+  refine ⟨fun p => (ContinuousLinearMap.fst ℝ ℝ (PhaseSpace d)).smulRight (bfun p)
+      + (Mfun p).comp (ContinuousLinearMap.snd ℝ ℝ (PhaseSpace d)), ?_, ?_⟩
+  · rintro ⟨s₀, z₀⟩ hp
+    obtain ⟨hs₀, _⟩ := hp
+    exact hasFDerivAt_of_continuous_partials_open
+      (f := fun q : ℝ × PhaseSpace d => (charX q.1 q.2, charV q.1 q.2)) (Ds := bfun)
+      hU_open ⟨hs₀, Set.mem_univ _⟩ hDs_all (hb_cont.mono hU_sub) (hDz_all s₀ hs₀ z₀)
+  · have hT1 : ContinuousOn (fun p : ℝ × PhaseSpace d =>
+        (ContinuousLinearMap.fst ℝ ℝ (PhaseSpace d)).smulRight (bfun p))
+        (Set.Ioo (0 : ℝ) T ×ˢ Set.univ) := by
+      have hc : Continuous (fun v : PhaseSpace d =>
+          (ContinuousLinearMap.fst ℝ ℝ (PhaseSpace d)).smulRight v) :=
+        (ContinuousLinearMap.smulRightL ℝ (ℝ × PhaseSpace d) (PhaseSpace d)
+          (ContinuousLinearMap.fst ℝ ℝ (PhaseSpace d))).continuous
+      exact hc.comp_continuousOn (hb_cont.mono hU_sub)
+    have hT2 : ContinuousOn (fun p : ℝ × PhaseSpace d =>
+        (Mfun p).comp (ContinuousLinearMap.snd ℝ ℝ (PhaseSpace d)))
+        (Set.Ioo (0 : ℝ) T ×ˢ Set.univ) := hM_sz.clm_comp continuousOn_const
+    exact hT1.add hT2
+
+omit [NeZero d] in
+/-- **Step 3 (iv-A) — the forward flow `(s,z) ↦ Φ_s z` is `ContDiffAt ℝ 1`** at each point of the
+open window (the chart-IFT input for item (iv)).  Lifts item (iii)'s `HasFDerivAt`-everywhere +
+`ContinuousOn`-derivative to `ContDiffAt` via `contDiffAt_succ_iff_hasFDerivAt`. -/
+lemma charFlow_contDiffAt_joint
+    (gradW : PhysSpace d → PhysSpace d) (hgradW_C1 : ContDiff ℝ 1 gradW)
+    (L : NNReal) (hL : LipschitzWith L gradW)
+    (ρ : ℝ → Measure (PhysSpace d)) [∀ s, IsProbabilityMeasure (ρ s)]
+    (charX charV : ℝ → PhaseSpace d → PhysSpace d)
+    (T : ℝ) (hT : 0 < T)
+    (hflow : IsCharacteristicFlowOn gradW ρ charX charV (Set.Ioo 0 T) Set.univ)
+    (h_int : ∀ s (x : PhysSpace d), Integrable (fun y => gradW (x - y)) (ρ s))
+    (hf_cont : ∀ x, Continuous (fun s => convolveFunctionMeasure gradW (ρ s) x))
+    (hρD_cont : ContinuousOn
+      (fun p : ℝ × PhysSpace d => ∫ y, fderiv ℝ gradW (p.2 - y) ∂(ρ p.1))
+      (Set.Icc 0 T ×ˢ (Set.univ : Set (PhysSpace d))))
+    (hcontIcc : ∀ z : PhaseSpace d,
+      ContinuousOn (fun s => (charX s z, charV s z)) (Set.Icc (0 : ℝ) T)) :
+    ∀ p ∈ Set.Ioo (0 : ℝ) T ×ˢ (Set.univ : Set (PhaseSpace d)),
+      ContDiffAt ℝ 1 (fun q : ℝ × PhaseSpace d => (charX q.1 q.2, charV q.1 q.2)) p := by
+  obtain ⟨DΦ, hFDeriv, hDΦ_cont⟩ :=
+    charFlow_hasFDerivAt_joint gradW hgradW_C1 L hL ρ charX charV T hT
+    hflow h_int hf_cont hρD_cont hcontIcc
+  have hU_open : IsOpen (Set.Ioo (0 : ℝ) T ×ˢ (Set.univ : Set (PhaseSpace d))) :=
+    isOpen_Ioo.prod isOpen_univ
+  intro p hp
+  have hmain : ContDiffAt ℝ ((0:ℕ) + 1)
+      (fun q : ℝ × PhaseSpace d => (charX q.1 q.2, charV q.1 q.2)) p := by
+    rw [contDiffAt_succ_iff_hasFDerivAt]
+    refine ⟨DΦ, ⟨Set.Ioo (0 : ℝ) T ×ˢ Set.univ, hU_open.mem_nhds hp, fun y hy => hFDeriv y hy⟩, ?_⟩
+    exact contDiffAt_zero.mpr ⟨Set.Ioo (0 : ℝ) T ×ˢ Set.univ, hU_open.mem_nhds hp, hDΦ_cont⟩
+  simpa using hmain
+
+open Filter Topology in
+omit [NeZero d] in
+/-- **Step 3 (iv) — the per-slice inverse `Ψ_s := Φ_s⁻¹` is jointly `C¹`** on `Ioo 0 T ×ˢ univ`,
+the keystone of the two-time flow `Φ_{s→t} = Φ_t ∘ Φ_s⁻¹`.
+
+**PROVEN (axiom-clean)** via the space-time chart inverse-function theorem — see the proof plan
+below, realized exactly as scouted: `charFlow_contDiffAt_joint` (iv-A) for the chart `ContDiffAt`,
+the block-triangular `≃L` (invertibility from Step 2's `e z₀` via `HasFDerivAt.unique` +
+`ofBijective`), `ContDiffAt.to_localInverse`, and the global patch via `localInverse_unique` (the
+global per-slice inverse is a local left inverse of the chart, by injectivity on the window).
+
+Per slice `s ∈ Ioo 0 T`, Step 2 (`exists_charFlow_inverse_On`) already gives the inverse `Ψ_s` and
+its invertible derivative family `e` (`= M_s z`, `#3`/D1c); here we upgrade to JOINT `(s,w)`
+regularity via the space-time chart.
+
+**Proof plan (atoms scouted + verified, 2026-06-16):**
+1. **Forward chart `Ξ : (s,z) ↦ (s, Φ_s z)` is `ContDiffAt ℝ 1` at each
+   `(s₀,z₀) ∈ Ioo 0 T ×ˢ univ`.**
+   `Φ := (charX·, charV·)` is jointly `C¹` (`charFlow_hasFDerivAt_joint`, item (iii) — `∃ DΦ`,
+   `HasFDerivAt`-everywhere + `ContinuousOn DΦ`); lift to `ContDiffAt ℝ 1 Φ` via
+   `contDiffAt_succ_iff_hasFDerivAt` (`Mathlib/.../ContDiff/Defs.lean:994`, `n := 0`: feed `DΦ`, the
+   open nbhd `U ∈ 𝓝`, `HasFDerivAt`-on-`U`, and `ContDiffAt 0 DΦ` from `contDiffAt_zero` +
+   `ContinuousOn DΦ U`).  `Ξ = (fst, Φ)` so `ContDiffAt ℝ 1 Ξ` via `ContDiffAt.prod` with
+   `contDiffAt_fst`.
+2. **`DΞ(s₀,z₀)` is an invertible `≃L`.**  Block-lower-triangular `(h,k) ↦ (h, h•b + M·k)` with
+   `b := b_{s₀}(Φ_{s₀}z₀)`, `M := M_{s₀}z₀` invertible (Step 2's `e₀ z₀`).  Build the `ℝ×E ≃L ℝ×E`
+   via `ContinuousLinearEquiv.ofBijective` (inject: `(h,k)↦0 ⇒ h=0`, then `M k=0 ⇒ k=0`; finite-dim
+   `LinearMap.injective_iff_surjective`).  `HasStrictFDerivAt Ξ (this ≃L) (s₀,z₀)` via
+   `ContDiffAt.hasStrictFDerivAt'`.
+3. **Local `C¹` inverse + patch.**  `ContDiffAt.to_localInverse`
+   (`Mathlib/.../InverseFunctionTheorem/ContDiff.lean:66`) ⇒ `Ξ.localInverse` is `ContDiffAt ℝ 1` at
+   `Ξ(s₀,z₀) = (s₀, Φ_{s₀}z₀)`.  The global `(s,w)↦(s, Ψ_s w)` agrees with
+   `Ξ.localInverse` on a nbhd
+   (both left-inverses; `Ξ` injective on `Ioo 0 T ×ˢ univ` since `s` is preserved + each `Φ_s`
+   injective per Step 2) ⇒ `ContDiffAt.congr` ⇒ `(s,w)↦(s,Ψ_s w)` is `ContDiffAt ℝ 1` at each point
+   ⇒ `ContDiffOn ℝ 1` (projecting off the `s` component, `ContDiffAt.snd`).
+4. **Bijectivity** is the per-slice `LeftInverse`/`RightInverse` from `exists_charFlow_inverse_On`,
+   packaged into the `s`-indexed `Ψ`.
+The two-time flow `Φ_{s→t} = Φ_t ∘ Ψ_s` is then jointly `C¹` by composing with `Φ_t` (`C¹` in its
+argument, `#3`), and the dual core's transport identity differentiates it. -/
+theorem charFlow_inverse_contDiffOn_joint
+    (gradW : PhysSpace d → PhysSpace d) (hgradW_C1 : ContDiff ℝ 1 gradW)
+    (L : NNReal) (hL : LipschitzWith L gradW)
+    (ρ : ℝ → Measure (PhysSpace d)) [∀ s, IsProbabilityMeasure (ρ s)]
+    (charX charV : ℝ → PhaseSpace d → PhysSpace d)
+    (T : ℝ) (hT : 0 < T)
+    (hflow : IsCharacteristicFlowOn gradW ρ charX charV (Set.Ioo 0 T) Set.univ)
+    (h_int : ∀ s (x : PhysSpace d), Integrable (fun y => gradW (x - y)) (ρ s))
+    (hf_cont : ∀ x, Continuous (fun s => convolveFunctionMeasure gradW (ρ s) x))
+    (hρD_cont : ContinuousOn
+      (fun p : ℝ × PhysSpace d => ∫ y, fderiv ℝ gradW (p.2 - y) ∂(ρ p.1))
+      (Set.Icc 0 T ×ˢ (Set.univ : Set (PhysSpace d))))
+    (hcontIcc : ∀ z : PhaseSpace d,
+      ContinuousOn (fun s => (charX s z, charV s z)) (Set.Icc (0 : ℝ) T)) :
+    ∃ Ψ : ℝ → PhaseSpace d → PhaseSpace d,
+      (∀ s ∈ Set.Ioo (0 : ℝ) T,
+        Function.LeftInverse (Ψ s) (fun z => (charX s z, charV s z))) ∧
+      (∀ s ∈ Set.Ioo (0 : ℝ) T,
+        Function.RightInverse (Ψ s) (fun z => (charX s z, charV s z))) ∧
+      ContDiffOn ℝ 1 (fun p : ℝ × PhaseSpace d => Ψ p.1 p.2) (Set.Ioo 0 T ×ˢ Set.univ) := by
+  classical
+  obtain ⟨DΦ, hFDeriv, -⟩ := charFlow_hasFDerivAt_joint gradW hgradW_C1 L hL ρ charX charV T hT
+    hflow h_int hf_cont hρD_cont hcontIcc
+  have hΦ_cda := charFlow_contDiffAt_joint gradW hgradW_C1 L hL ρ charX charV T hT
+    hflow h_int hf_cont hρD_cont hcontIcc
+  have hstep2 := exists_charFlow_inverse_On gradW hgradW_C1 L hL ρ charX charV T hT
+    hflow h_int hρD_cont hcontIcc
+  have hbij : ∀ s ∈ Set.Ioo (0 : ℝ) T,
+      Function.Bijective (fun z => ((charX s z, charV s z) : PhaseSpace d)) := by
+    intro s hs
+    obtain ⟨Ψ', e, _, hL', hR', _, _⟩ := hstep2 s hs
+    exact ⟨hL'.injective, hR'.surjective⟩
+  set Ψ : ℝ → PhaseSpace d → PhaseSpace d :=
+    fun s => Function.invFun (fun z => (charX s z, charV s z)) with hΨ_def
+  have hLeft : ∀ s ∈ Set.Ioo (0 : ℝ) T,
+      Function.LeftInverse (Ψ s) (fun z => (charX s z, charV s z)) :=
+    fun s hs => Function.leftInverse_invFun (hbij s hs).1
+  have hRight : ∀ s ∈ Set.Ioo (0 : ℝ) T,
+      Function.RightInverse (Ψ s) (fun z => (charX s z, charV s z)) :=
+    fun s hs => Function.rightInverse_invFun (hbij s hs).2
+  refine ⟨Ψ, hLeft, hRight, ?_⟩
+  set Ξ : ℝ × PhaseSpace d → ℝ × PhaseSpace d :=
+    fun x => (x.1, (charX x.1 x.2, charV x.1 x.2)) with hΞ_def
+  intro pt hpt
+  obtain ⟨hs₀, -⟩ := hpt
+  obtain ⟨Ψ', e, he_deriv, -, -, -, -⟩ := hstep2 pt.1 hs₀
+  set z₀ : PhaseSpace d := Ψ pt.1 pt.2 with hz₀_def
+  have hΦz₀ : (charX pt.1 z₀, charV pt.1 z₀) = pt.2 := hRight pt.1 hs₀ pt.2
+  have hΞ_cda : ContDiffAt ℝ 1 Ξ (pt.1, z₀) :=
+    contDiffAt_fst.prodMk (hΦ_cda (pt.1, z₀) ⟨hs₀, Set.mem_univ _⟩)
+  set DΞ : (ℝ × PhaseSpace d) →L[ℝ] (ℝ × PhaseSpace d) :=
+    (ContinuousLinearMap.fst ℝ ℝ (PhaseSpace d)).prod (DΦ (pt.1, z₀)) with hDΞ_def
+  have hΞ_hd : HasFDerivAt Ξ DΞ (pt.1, z₀) :=
+    (hasFDerivAt_fst).prodMk (hFDeriv (pt.1, z₀) ⟨hs₀, Set.mem_univ _⟩)
+  have hincl : HasFDerivAt (fun z : PhaseSpace d => ((pt.1, z) : ℝ × PhaseSpace d))
+      ((0 : PhaseSpace d →L[ℝ] ℝ).prod (ContinuousLinearMap.id ℝ (PhaseSpace d))) z₀ :=
+    (hasFDerivAt_const (pt.1 : ℝ) z₀).prodMk (hasFDerivAt_id z₀)
+  have hslice : HasFDerivAt (fun z => (charX pt.1 z, charV pt.1 z))
+      ((DΦ (pt.1, z₀)).comp
+        ((0 : PhaseSpace d →L[ℝ] ℝ).prod (ContinuousLinearMap.id ℝ (PhaseSpace d)))) z₀ :=
+    (hFDeriv (pt.1, z₀) ⟨hs₀, Set.mem_univ _⟩).comp z₀ hincl
+  have hcomp_eq : (DΦ (pt.1, z₀)).comp
+      ((0 : PhaseSpace d →L[ℝ] ℝ).prod (ContinuousLinearMap.id ℝ (PhaseSpace d)))
+      = (e z₀ : PhaseSpace d →L[ℝ] PhaseSpace d) :=
+    hslice.unique (he_deriv z₀)
+  have hslice_app : ∀ k : PhaseSpace d,
+      DΦ (pt.1, z₀) ((0 : ℝ), k) = (e z₀ : PhaseSpace d →L[ℝ] PhaseSpace d) k := by
+    intro k
+    have h1 : ((0 : PhaseSpace d →L[ℝ] ℝ).prod (ContinuousLinearMap.id ℝ (PhaseSpace d))) k
+        = ((0 : ℝ), k) := by simp
+    rw [← h1, ← ContinuousLinearMap.comp_apply, hcomp_eq]
+  have hker : LinearMap.ker (DΞ : (ℝ × PhaseSpace d) →ₗ[ℝ] (ℝ × PhaseSpace d)) = ⊥ := by
+    refine LinearMap.ker_eq_bot'.mpr (fun x hx => ?_)
+    have hxapp : (x.1, DΦ (pt.1, z₀) x) = ((0 : ℝ), (0 : PhaseSpace d)) := by
+      have : DΞ x = ((0 : ℝ), (0 : PhaseSpace d)) := hx
+      simpa [hDΞ_def, ContinuousLinearMap.prod_apply] using this
+    have hx1 : x.1 = 0 := (Prod.ext_iff.mp hxapp).1
+    have hx2 : DΦ (pt.1, z₀) x = 0 := (Prod.ext_iff.mp hxapp).2
+    have hxz : x = ((0 : ℝ), x.2) := Prod.ext hx1 rfl
+    have hez : (e z₀ : PhaseSpace d →L[ℝ] PhaseSpace d) x.2 = 0 := by
+      rw [← hslice_app x.2, ← hxz]; exact hx2
+    have : x.2 = 0 := by
+      have hinj := (e z₀).injective
+      have : (e z₀) x.2 = (e z₀) 0 := by rw [map_zero]; exact_mod_cast hez
+      exact hinj this
+    exact Prod.ext hx1 this
+  have hrange : LinearMap.range (DΞ : (ℝ × PhaseSpace d) →ₗ[ℝ] (ℝ × PhaseSpace d)) = ⊤ :=
+    LinearMap.range_eq_top.mpr
+      (LinearMap.injective_iff_surjective.mp (LinearMap.ker_eq_bot.mp hker))
+  set eΞ : (ℝ × PhaseSpace d) ≃L[ℝ] (ℝ × PhaseSpace d) :=
+    ContinuousLinearEquiv.ofBijective DΞ hker hrange with heΞ_def
+  have hΞ_hd' : HasFDerivAt Ξ (eΞ : (ℝ × PhaseSpace d) →L[ℝ] (ℝ × PhaseSpace d)) (pt.1, z₀) :=
+    hΞ_hd
+  have hlocinv : ContDiffAt ℝ 1 (hΞ_cda.localInverse hΞ_hd' one_ne_zero) (Ξ (pt.1, z₀)) :=
+    hΞ_cda.to_localInverse hΞ_hd' one_ne_zero
+  have hstrict := hΞ_cda.hasStrictFDerivAt' hΞ_hd' (one_ne_zero)
+  have hloc : ∀ᶠ x in 𝓝 ((pt.1, z₀) : ℝ × PhaseSpace d),
+      ((fun y : ℝ × PhaseSpace d => ((y.1, Ψ y.1 y.2) : ℝ × PhaseSpace d)) (Ξ x)) = x := by
+    have hIoo : ∀ᶠ x in 𝓝 ((pt.1, z₀) : ℝ × PhaseSpace d), x.1 ∈ Set.Ioo (0 : ℝ) T :=
+      continuous_fst.continuousAt.eventually_mem (isOpen_Ioo.mem_nhds hs₀)
+    filter_upwards [hIoo] with x hx
+    have hL2 : Ψ x.1 (charX x.1 x.2, charV x.1 x.2) = x.2 := hLeft x.1 hx x.2
+    simp only [hΞ_def]
+    rw [hL2]
+  have huniq : ∀ᶠ y in 𝓝 (Ξ (pt.1, z₀)),
+      ((y.1, Ψ y.1 y.2) : ℝ × PhaseSpace d) = (hΞ_cda.localInverse hΞ_hd' one_ne_zero) y :=
+    hstrict.localInverse_unique hloc
+  have hΞeq : Ξ (pt.1, z₀) = (pt.1, pt.2) := by rw [hΞ_def]; exact Prod.ext rfl hΦz₀
+  have hG_cda : ContDiffAt ℝ 1
+      (fun y : ℝ × PhaseSpace d => ((y.1, Ψ y.1 y.2) : ℝ × PhaseSpace d)) (pt.1, pt.2) := by
+    rw [← hΞeq]
+    exact hlocinv.congr_of_eventuallyEq huniq
+  have hpt_eq : pt = (pt.1, pt.2) := rfl
+  rw [hpt_eq]
+  exact (hG_cda.snd).contDiffWithinAt
+
+/-! ### Step 4 — the transported test function and the transport identity
+
+The dual core's `s ↦ ∫ ψ_s d(f s)` argument rests on the backward-transported test
+`ψ_s := φ ∘ Φ_{s→t}` where `Φ_{s→t} = Φ_t ∘ Φ_s⁻¹` is the two-time flow (Step 3 gave it jointly
+`C¹`).  Two deliverables, both taking the *outputs* of Step 3 (the inverse `Ψ` + the `C¹` terminal
+map `Φ_t`) as hypotheses rather than re-deriving them from the flow-construction data: -/
+
+omit [NeZero d] in
+/-- **Step 4 (4a) — the two-time flow `Φ_{s→t} = Φ_t ∘ Φ_s⁻¹` is jointly `C¹`** on
+`Ioo 0 T ×ˢ univ`.
+
+The two-time flow `(s,w) ↦ (charX t (Ψ_s w), charV t (Ψ_s w))` is the composition of the terminal
+map `Φ_t = (charX t ·, charV t ·)` (`C¹` in its argument — `hΦt_C1`, from Step 2 / item (iii) at the
+fixed time `t`) with the jointly-`C¹` inverse family `(s,w) ↦ Ψ_s w` (`hΨ_C1`, item (iv)).  Proof:
+`ContDiff.comp_contDiffOn`. -/
+theorem twoTimeFlow_contDiffOn_joint
+    (charX charV : ℝ → PhaseSpace d → PhysSpace d) (T t : ℝ)
+    (Ψ : ℝ → PhaseSpace d → PhaseSpace d)
+    (hΨ_C1 : ContDiffOn ℝ 1 (fun p : ℝ × PhaseSpace d => Ψ p.1 p.2)
+      (Set.Ioo (0 : ℝ) T ×ˢ Set.univ))
+    (hΦt_C1 : ContDiff ℝ 1 (fun z : PhaseSpace d => (charX t z, charV t z))) :
+    ContDiffOn ℝ 1
+      (fun p : ℝ × PhaseSpace d => ((charX t (Ψ p.1 p.2), charV t (Ψ p.1 p.2)) : PhaseSpace d))
+      (Set.Ioo (0 : ℝ) T ×ˢ Set.univ) :=
+  hΦt_C1.comp_contDiffOn hΨ_C1
+
+omit [NeZero d] in
+/-- **Step 4 (4b) — the transport identity `∂_s ψ_s + Dψ_s · b_s = 0`.**
+
+For the backward-transported test `ψ_s(w) := φ(Φ_t(Ψ_s w)) = φ(Φ_{s→t} w)`, the partial
+`s`-derivative cancels the spatial directional derivative along the field:
+`∂_s ψ_s(w) = -(Dψ_s(w))(b_s(w))`, where `b_s = vlasovVectorField gradW ρ s` and
+`Dψ_s(w) = fderiv ℝ (ψ s) w`.  This is the dual of `vlasov_traj_chain_rule` (the pushforward
+direction) and the engine that makes `s ↦ ∫ ψ_s d(f s)` constant in Step 6.
+
+Proof:
+* `ψ` is jointly `C¹` on `Ioo 0 T ×ˢ univ` (4a + `φ` smooth), so `HasFDerivAt (uncurry ψ) Dψ (s,w)`
+  at the interior point `(s,w)`, with `Dψ` the joint Fréchet derivative.
+* Constancy curve: set `z₀ := Ψ_s w`, so `w = Φ_s z₀` (`hΨ_right`).  The composite
+  `s' ↦ ψ_{s'}(Φ_{s'} z₀) = φ(Φ_t(Ψ_{s'}(Φ_{s'} z₀))) = φ(Φ_t z₀)` is **constant** in `s'`
+  (`hΨ_left`: `Ψ_{s'} ∘ Φ_{s'} = id`), hence has zero `s'`-derivative.
+* The curve `c(s') := (s', Φ_{s'} z₀)` has `HasDerivAt c (1, b_s w) s` (`hflow_ode` + `id`), with
+  `c(s) = (s, w)`.  Chain rule: `0 = Dψ(s,w)(1, b_s w) = Dψ(s,w)(1,0) + Dψ(s,w)(0, b_s w)`.
+* `Dψ(s,w)(1,0) = ∂_s ψ_s(w)` (compose `uncurry ψ` with `s' ↦ (s', w)`) and
+  `Dψ(s,w)(0,k) = (fderiv ℝ (ψ s) w) k` (compose with `w' ↦ (s, w')`).  Surjectivity (`hΨ_right`)
+  covers every `w`.  Rearrange to the claimed `HasDerivAt`. -/
+theorem transportedTest_transport_identity
+    (gradW : PhysSpace d → PhysSpace d)
+    (ρ : ℝ → Measure (PhysSpace d))
+    (charX charV : ℝ → PhaseSpace d → PhysSpace d) (T t : ℝ)
+    (φ : PhaseSpace d → ℝ) (hφ : ContDiff ℝ (⊤ : ℕ∞) φ)
+    (Ψ : ℝ → PhaseSpace d → PhaseSpace d)
+    (hΨ_left : ∀ s ∈ Set.Ioo (0 : ℝ) T,
+      Function.LeftInverse (Ψ s) (fun z => (charX s z, charV s z)))
+    (hΨ_right : ∀ s ∈ Set.Ioo (0 : ℝ) T,
+      Function.RightInverse (Ψ s) (fun z => (charX s z, charV s z)))
+    (hΨ_C1 : ContDiffOn ℝ 1 (fun p : ℝ × PhaseSpace d => Ψ p.1 p.2)
+      (Set.Ioo (0 : ℝ) T ×ˢ Set.univ))
+    (hΦt_C1 : ContDiff ℝ 1 (fun z : PhaseSpace d => (charX t z, charV t z)))
+    (hflow_ode : ∀ z : PhaseSpace d, ∀ s ∈ Set.Ioo (0 : ℝ) T,
+      HasDerivAt (fun s' => (charX s' z, charV s' z))
+        (vlasovVectorField gradW ρ s (charX s z, charV s z)) s)
+    (s : ℝ) (hs : s ∈ Set.Ioo (0 : ℝ) T) (w : PhaseSpace d) :
+    HasDerivAt (fun s' => φ (charX t (Ψ s' w), charV t (Ψ s' w)))
+      (-(fderiv ℝ (fun w' : PhaseSpace d => φ (charX t (Ψ s w'), charV t (Ψ s w'))) w
+          (vlasovVectorField gradW ρ s w))) s := by
+  classical
+  -- uncurried two-time flow and transported test
+  set G2 : ℝ × PhaseSpace d → PhaseSpace d :=
+    fun p => (charX t (Ψ p.1 p.2), charV t (Ψ p.1 p.2)) with hG2_def
+  set g : ℝ × PhaseSpace d → ℝ := fun p => φ (G2 p) with hg_def
+  have hopen : IsOpen (Set.Ioo (0 : ℝ) T ×ˢ (Set.univ : Set (PhaseSpace d))) :=
+    isOpen_Ioo.prod isOpen_univ
+  have hmem : ((s, w) : ℝ × PhaseSpace d) ∈ Set.Ioo (0 : ℝ) T ×ˢ (Set.univ : Set (PhaseSpace d)) :=
+    ⟨hs, Set.mem_univ _⟩
+  -- right-inverse identity: Φ_s (Ψ_s w) = w
+  have hw : (charX s (Ψ s w), charV s (Ψ s w)) = w := hΨ_right s hs w
+  -- g is jointly C¹, hence HasFDerivAt at the interior point (s,w)
+  have hG2_cd : ContDiffOn ℝ 1 G2 (Set.Ioo (0 : ℝ) T ×ˢ Set.univ) :=
+    twoTimeFlow_contDiffOn_joint charX charV T t Ψ hΨ_C1 hΦt_C1
+  have hG2_diff : DifferentiableAt ℝ G2 (s, w) :=
+    hG2_cd.differentiableOn_one.differentiableAt (hopen.mem_nhds hmem)
+  have hφ_diff : DifferentiableAt ℝ φ (G2 (s, w)) := hφ.differentiable (by simp) _
+  have hg_fderiv : HasFDerivAt g (fderiv ℝ g (s, w)) (s, w) :=
+    (hφ_diff.comp (s, w) hG2_diff).hasFDerivAt
+  set G := fderiv ℝ g (s, w) with hG_def
+  -- (A) spatial slice w' ↦ g (s, w') : fderiv = G ∘ inr
+  have hslice_fderiv : HasFDerivAt (fun w' : PhaseSpace d => g (s, w'))
+      (G.comp (ContinuousLinearMap.inr ℝ ℝ (PhaseSpace d))) w := by
+    have := hg_fderiv.comp w (hasFDerivAt_prodMk_right s w)
+    simpa only [Function.comp_def] using this
+  -- (B) ∂_s slice s' ↦ g (s', w) : HasDerivAt with value G (1, 0)
+  have hscurve : HasDerivAt (fun s' => ((s', w) : ℝ × PhaseSpace d))
+      ((1 : ℝ), (0 : PhaseSpace d)) s :=
+    (hasDerivAt_id s).prodMk (hasDerivAt_const s w)
+  have hs_slice : HasDerivAt (fun s' => g (s', w)) (G ((1 : ℝ), (0 : PhaseSpace d))) s := by
+    have := hg_fderiv.comp_hasDerivAt s hscurve
+    simpa only [Function.comp_def] using this
+  -- (C) constancy curve c(s') = (s', Φ_{s'} (Ψ_s w)); chain rule gives G(1, b)
+  have hccurve : HasDerivAt
+      (fun s' => ((s', (charX s' (Ψ s w), charV s' (Ψ s w))) : ℝ × PhaseSpace d))
+      ((1 : ℝ), vlasovVectorField gradW ρ s (charX s (Ψ s w), charV s (Ψ s w))) s :=
+    (hasDerivAt_id s).prodMk (hflow_ode (Ψ s w) s hs)
+  have hcs : ((s, (charX s (Ψ s w), charV s (Ψ s w))) : ℝ × PhaseSpace d) = (s, w) := by rw [hw]
+  have hgc : HasDerivAt (fun s' => g (s', (charX s' (Ψ s w), charV s' (Ψ s w))))
+      (G ((1 : ℝ), vlasovVectorField gradW ρ s (charX s (Ψ s w), charV s (Ψ s w)))) s := by
+    have hF := hg_fderiv
+    rw [← hcs] at hF
+    have := hF.comp_hasDerivAt s hccurve
+    simpa only [Function.comp_def] using this
+  -- (D) the composite is eventually constant near s, so its derivative is 0
+  have hconst : (fun s' => g (s', (charX s' (Ψ s w), charV s' (Ψ s w)))) =ᶠ[nhds s]
+      (fun _ => φ (charX t (Ψ s w), charV t (Ψ s w))) := by
+    filter_upwards [isOpen_Ioo.mem_nhds hs] with s' hs'
+    simp only [hg_def, hG2_def]
+    rw [hΨ_left s' hs' (Ψ s w)]
+  have hgc0 : HasDerivAt (fun s' => g (s', (charX s' (Ψ s w), charV s' (Ψ s w)))) 0 s :=
+    (hasDerivAt_const s (φ (charX t (Ψ s w), charV t (Ψ s w)))).congr_of_eventuallyEq hconst
+  -- (E) uniqueness: G (1, b) = 0
+  have hGzero : G ((1 : ℝ), vlasovVectorField gradW ρ s (charX s (Ψ s w), charV s (Ψ s w))) = 0 :=
+    hgc.unique hgc0
+  -- (F) split G(1,b) = G(1,0) + G(0,b); identify G(0,b) with the target fderiv applied to b
+  have hsplit : ((1 : ℝ), vlasovVectorField gradW ρ s (charX s (Ψ s w), charV s (Ψ s w)))
+      = ((1 : ℝ), (0 : PhaseSpace d))
+        + ((0 : ℝ), vlasovVectorField gradW ρ s (charX s (Ψ s w), charV s (Ψ s w))) := by
+    ext <;> simp
+  have hb_eq : vlasovVectorField gradW ρ s (charX s (Ψ s w), charV s (Ψ s w))
+      = vlasovVectorField gradW ρ s w := by rw [hw]
+  have hG0b : G ((0 : ℝ), vlasovVectorField gradW ρ s (charX s (Ψ s w), charV s (Ψ s w)))
+      = (fderiv ℝ (fun w' : PhaseSpace d => φ (charX t (Ψ s w'), charV t (Ψ s w'))) w)
+          (vlasovVectorField gradW ρ s w) := by
+    have hfd : fderiv ℝ (fun w' : PhaseSpace d => g (s, w')) w
+        = G.comp (ContinuousLinearMap.inr ℝ ℝ (PhaseSpace d)) := hslice_fderiv.fderiv
+    have hfun : (fun w' : PhaseSpace d => g (s, w'))
+        = (fun w' : PhaseSpace d => φ (charX t (Ψ s w'), charV t (Ψ s w'))) := rfl
+    rw [hfun] at hfd
+    rw [hfd, ContinuousLinearMap.comp_apply, ContinuousLinearMap.inr_apply, hb_eq]
+  -- (G) G(1,0) = -(target fderiv)(b)
+  have hval : G ((1 : ℝ), (0 : PhaseSpace d))
+      = -(fderiv ℝ (fun w' : PhaseSpace d => φ (charX t (Ψ s w'), charV t (Ψ s w'))) w)
+          (vlasovVectorField gradW ρ s w) := by
+    have hsum : G ((1 : ℝ), (0 : PhaseSpace d))
+        + G ((0 : ℝ), vlasovVectorField gradW ρ s (charX s (Ψ s w), charV s (Ψ s w))) = 0 := by
+      rw [← map_add, ← hsplit]; exact hGzero
+    rw [hG0b] at hsum
+    linarith [hsum]
+  -- (H) conclude
+  have hgoalfun : (fun s' => φ (charX t (Ψ s' w), charV t (Ψ s' w)))
+      = (fun s' => g (s', w)) := rfl
+  rw [hgoalfun, ← hval]
+  exact hs_slice
+
+
+end Vlasov
diff --git a/LeanPool/Vlasov/OT/FrozenField.lean b/LeanPool/Vlasov/OT/FrozenField.lean
new file mode 100644
index 0000000000..188b698ca6
--- /dev/null
+++ b/LeanPool/Vlasov/OT/FrozenField.lean
@@ -0,0 +1,594 @@
+/-
+Copyright (c) 2026 Joseph K. Miller. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Joseph K. Miller
+-/
+module
+
+
+public import Mathlib.Analysis.Calculus.BumpFunction.FiniteDimension
+public import LeanPool.Vlasov.OT.CharacteristicFlow
+public import Mathlib.Analysis.Calculus.BumpFunction.Normed
+import Mathlib.Algebra.Order.Ring.Star
+import Mathlib.Analysis.Calculus.Deriv.MeanValue
+import Mathlib.Analysis.Calculus.Deriv.Prod
+import Mathlib.Analysis.Calculus.BumpFunction.Convolution
+import Mathlib.MeasureTheory.Integral.RieszMarkovKakutani.Real
+
+/-!
+# Frozen-field weak solutions and convolution derivatives
+
+The linear weak equation, frozen-flow existence, and differentiation of the convolution
+field support the weak-to-Lagrangian argument without its transported-test machinery.
+-/
+
+@[expose] public section
+
+namespace Vlasov
+
+open MeasureTheory
+
+variable {d : ℕ} [NeZero d]
+
+/-! ## Linear (external-field) weak Vlasov solutions
+
+The self-consistent weak predicate `IsVlasovSolutionOn` drives the convolution field by the
+solution's *own* spatial marginal.  For the superposition argument we need the **linear**
+version, where the field is driven by an *external* (frozen) measure curve `ρ` — both the given
+weak solution `f` (with `ρ := spatialMarginal ∘ f`) and the pushforward `g` along the
+frozen-field flow solve the *same* `IsLinearVlasovSolutionOn gradW ρ · T`, and uniqueness for it
+(the crux, C3) forces `f = g`. -/
+
+/-- Linear weak Vlasov evolution on `Ioo 0 T` for a test function `φ`, with the convolution field
+driven by an **external** measure curve `ρ` (frozen), not the solution's own spatial marginal.
+The self-consistent `WeakEvolutionEqOn gradW μ φ … (fun _ => 0) T` is the special case
+`ρ = spatialMarginal ∘ μ` (modulo the `+ 0` remainder term). -/
+def LinearWeakEvolutionEqOn
+    (gradW : PhysSpace d → PhysSpace d)
+    (ρ : ℝ → Measure (PhysSpace d))
+    (μ : ℝ → Measure (PhaseSpace d))
+    (φ : PhaseSpace d → ℝ)
+    (gradXφ gradVφ : PhaseSpace d → PhysSpace d)
+    (T : ℝ) : Prop :=
+  ∀ t ∈ Set.Ioo (0 : ℝ) T,
+    HasDerivAt (fun s => ∫ z, φ z ∂μ s)
+      (∫ z, (@inner ℝ (PhysSpace d) _ z.2 (gradXφ z) -
+              @inner ℝ (PhysSpace d) _
+                (convolveFunctionMeasure gradW (ρ t) z.1)
+                (gradVφ z))
+        ∂μ t) t
+
+/-- A measure curve `μ` solves the **linear** Vlasov equation on `[0,T]` driven by the external
+field `ρ`: the distributional identity `LinearWeakEvolutionEqOn` holds for every `C_c^∞` test
+function.  Mirror of `IsVlasovSolutionOn` with the field externalized. -/
+def IsLinearVlasovSolutionOn
+    (gradW : PhysSpace d → PhysSpace d)
+    (ρ : ℝ → Measure (PhysSpace d))
+    (μ : ℝ → Measure (PhaseSpace d)) (T : ℝ) : Prop :=
+  ∀ (φ : PhaseSpace d → ℝ),
+    ContDiff ℝ (⊤ : ℕ∞) φ → HasCompactSupport φ →
+    ∀ (gradXφ gradVφ : PhaseSpace d → PhysSpace d),
+      (∀ z, gradXφ z = gradient (fun x => φ (x, z.2)) z.1) →
+      (∀ z, gradVφ z = gradient (fun v => φ (z.1, v)) z.2) →
+      LinearWeakEvolutionEqOn gradW ρ μ φ gradXφ gradVφ T
+
+omit [NeZero d] in
+/-- A self-consistent weak solution is a linear solution driven by its **own** spatial marginal.
+The two differ only by `WeakEvolutionEqOn`'s `+ (fun _ => 0) t = + 0` remainder. -/
+lemma IsVlasovSolutionOn.toLinearSelf
+    {gradW : PhysSpace d → PhysSpace d} {f : ℝ → Measure (PhaseSpace d)} {T : ℝ}
+    (h : IsVlasovSolutionOn gradW f T) :
+    IsLinearVlasovSolutionOn gradW (fun t => spatialMarginal (f t)) f T := by
+  intro φ hφ hφc gradXφ gradVφ hgradXφ hgradVφ t ht
+  simpa using h φ hφ hφc gradXφ gradVφ hgradXφ hgradVφ t ht
+
+omit [NeZero d] in
+/-- **C1 #1 — pushforward solves the frozen linear weak equation.**
+
+For a characteristic flow `(charX, charV)` solving the ODE with an **external** field `ρ` on
+`Ioo 0 T`, the pushforward `g := (charX t, charV t)_# f₀` solves the linear Vlasov equation
+driven by that same `ρ`.  Proof: the generic SC.1–SC.3 machinery (change of variables +
+chain rule + differentiation-under-the-integral, all parametric in `ρ`) recomposed at this `ρ`,
+with SC.4's push-back inlined as `integral_map` (SC.4's packaged form hard-codes the
+self-consistent marginal).  This is `vlasovSolutionViaPushforward_isVlasovSolutionOn` with `ρ`
+left free — the `_hself` self-consistency hypothesis is unused. -/
+theorem vlasov_frozenField_pushforward_isLinearVlasovSolutionOn
+    (gradW : PhysSpace d → PhysSpace d)
+    (L : NNReal) (hL : LipschitzWith L gradW)
+    (ρ : ℝ → Measure (PhysSpace d)) [∀ s, IsProbabilityMeasure (ρ s)]
+    (charX charV : ℝ → PhaseSpace d → PhysSpace d)
+    (f₀ : Measure (PhaseSpace d)) [IsProbabilityMeasure f₀]
+    (hf₀_fm : Integrable (fun z : PhaseSpace d => ‖z‖) f₀)
+    {T : ℝ} (hT : 0 < T)
+    (hflow_on : IsCharacteristicFlowOn gradW ρ charX charV (Set.Ioo 0 T) Set.univ)
+    (h_init : ∀ z : PhaseSpace d, (charX 0 z, charV 0 z) = z)
+    (h_cont_Icc : ∀ z : PhaseSpace d,
+      ContinuousOn (fun s => (charX s z, charV s z)) (Set.Icc (0 : ℝ) T))
+    (h_deriv_Ico : ∀ z : PhaseSpace d, ∀ s ∈ Set.Ico (0 : ℝ) T,
+      HasDerivWithinAt (fun s' => (charX s' z, charV s' z))
+        (vlasovVectorField gradW ρ s (charX s z, charV s z)) (Set.Ici s) s)
+    (M_ρ : ℝ) (hM_ρ_nn : 0 ≤ M_ρ)
+    (hM_ρ : ∀ s ∈ Set.Icc (0 : ℝ) T, ∫ y, ‖y‖ ∂(ρ s) ≤ M_ρ)
+    (h_y_int : ∀ s ∈ Set.Icc (0 : ℝ) T, Integrable (fun y : PhysSpace d => ‖y‖) (ρ s))
+    (h_int : ∀ s (x : PhysSpace d), Integrable (fun y => gradW (x - y)) (ρ s))
+    (h_flow_meas : ∀ s, AEMeasurable (fun z : PhaseSpace d => (charX s z, charV s z)) f₀)
+    (hgradW_cont : Continuous gradW)
+    (hconv_cont : ∀ s, Continuous (fun x => convolveFunctionMeasure gradW (ρ s) x)) :
+    IsLinearVlasovSolutionOn gradW ρ (vlasovSolutionViaPushforward charX charV f₀) T := by
+  intro φ hφ_smooth hφ_compact gradXφ gradVφ hgradXφ hgradVφ t ht
+  have hφ_cont : Continuous φ := hφ_smooth.continuous
+  have hφ_aesm_general : ∀ μ : Measure (PhaseSpace d), AEStronglyMeasurable φ μ :=
+    fun μ => hφ_cont.aestronglyMeasurable
+  -- SC.1: ∫ φ d(pushforward s) = ∫ (φ ∘ flow_s) df₀.
+  have h_compose : ∀ s, ∫ z, φ z ∂(vlasovSolutionViaPushforward charX charV f₀ s) =
+      ∫ z, φ (charX s z, charV s z) ∂f₀ := fun s =>
+    vlasov_pushforward_integral_eq_compose charX charV f₀ s (h_flow_meas s) φ (hφ_aesm_general _)
+  -- SC.2 `_at`: pointwise chain rule at every z, at this t.
+  have h_pointwise : ∀ z, HasDerivAt (fun s => φ (charX s z, charV s z))
+      (@inner ℝ (PhysSpace d) _ (charV t z) (gradXφ (charX t z, charV t z))
+       - @inner ℝ (PhysSpace d) _
+          (convolveFunctionMeasure gradW (ρ t) (charX t z))
+          (gradVφ (charX t z, charV t z))) t := by
+    intro z
+    have hX_at := hflow_on.2.1 t ht z (Set.mem_univ z)
+    have hV_at := hflow_on.2.2 t ht z (Set.mem_univ z)
+    exact vlasov_traj_chain_rule_at gradW ρ charX charV φ hφ_smooth
+      gradXφ gradVφ hgradXφ hgradVφ t z hX_at hV_at
+  -- SC.3: differentiation under the integral via the DiffUnderIntegralData bundle.
+  have h_diff_data : DiffUnderIntegralData gradW ρ charX charV f₀ φ gradXφ gradVφ t := by
+    obtain ⟨nhd, bound, hnhd, h_lipsch, h_bound_int⟩ :=
+      vlasov_trajectory_lipschitz_bound_on gradW L hL ρ charX charV f₀
+        hf₀_fm φ hφ_smooth hφ_compact hT hflow_on h_init h_cont_Icc h_deriv_Ico
+        hgradW_cont hconv_cont t ht M_ρ hM_ρ_nn hM_ρ h_y_int h_int
+    refine ⟨nhd, bound, hnhd, ?_, ?_, ?_, h_lipsch, h_bound_int⟩
+    · exact vlasov_compose_flow_aestronglymeas charX charV f₀ φ hφ_cont h_flow_meas t
+    · exact vlasov_compose_flow_integrable_at charX charV f₀ φ hφ_cont hφ_compact t (h_flow_meas t)
+    · exact vlasov_pointwise_deriv_aestronglymeas gradW ρ charX charV f₀
+        φ hφ_smooth gradXφ gradVφ hgradXφ hgradVφ hconv_cont t (h_flow_meas t)
+  have h_under_integral :=
+    vlasov_pushforward_hasDerivAt_under_integral gradW ρ charX charV f₀
+      φ gradXφ gradVφ t h_pointwise h_diff_data
+  -- SC.4 (inlined; the packaged form hard-codes the self-consistent marginal): AE-strong-meas
+  -- of the dot-product integrand, then push back through `integral_map`.
+  have h_integrand_aesm : AEStronglyMeasurable
+      (fun y : PhaseSpace d =>
+        @inner ℝ (PhysSpace d) _ y.2 (gradXφ y)
+        - @inner ℝ (PhysSpace d) _
+            (convolveFunctionMeasure gradW (ρ t) y.1) (gradVφ y))
+      (vlasovSolutionViaPushforward charX charV f₀ t) := by
+    apply Continuous.aestronglyMeasurable
+    apply Continuous.sub
+    · apply Continuous.inner continuous_snd
+      have hfderiv_X : ∀ z : PhaseSpace d,
+          fderiv ℝ (fun x => φ (x, z.2)) z.1 =
+          (fderiv ℝ φ z).comp (ContinuousLinearMap.inl ℝ (PhysSpace d) (PhysSpace d)) :=
+        fun z => by
+          have h1 : HasFDerivAt φ (fderiv ℝ φ z) z :=
+            (hφ_smooth.differentiable (by simp) z).hasFDerivAt
+          have h2 : HasFDerivAt (fun x : PhysSpace d => (x, z.2))
+              (ContinuousLinearMap.inl ℝ (PhysSpace d) (PhysSpace d)) z.1 :=
+            hasFDerivAt_prodMk_left z.1 z.2
+          exact (h1.comp z.1 h2).fderiv
+      have heqX : gradXφ = fun z => gradient (fun x => φ (x, z.2)) z.1 := funext hgradXφ
+      simp_rw [heqX, gradient, hfderiv_X]
+      exact (InnerProductSpace.toDual ℝ (PhysSpace d)).symm.continuous.comp
+        ((ContinuousLinearMap.isBoundedLinearMap_comp_right
+          (ContinuousLinearMap.inl ℝ (PhysSpace d) (PhysSpace d))).continuous.comp
+          (hφ_smooth.continuous_fderiv (by simp)))
+    · apply Continuous.inner
+      · exact (hconv_cont t).comp continuous_fst
+      · have hfderiv_V : ∀ z : PhaseSpace d,
+            fderiv ℝ (fun v => φ (z.1, v)) z.2 =
+            (fderiv ℝ φ z).comp (ContinuousLinearMap.inr ℝ (PhysSpace d) (PhysSpace d)) :=
+          fun z => by
+            have h1 : HasFDerivAt φ (fderiv ℝ φ z) z :=
+              (hφ_smooth.differentiable (by simp) z).hasFDerivAt
+            have h2 : HasFDerivAt (fun v : PhysSpace d => (z.1, v))
+                (ContinuousLinearMap.inr ℝ (PhysSpace d) (PhysSpace d)) z.2 :=
+              hasFDerivAt_prodMk_right z.1 z.2
+            exact (h1.comp z.2 h2).fderiv
+        have heqV : gradVφ = fun z => gradient (fun v => φ (z.1, v)) z.2 := funext hgradVφ
+        simp_rw [heqV, gradient, hfderiv_V]
+        exact (InnerProductSpace.toDual ℝ (PhysSpace d)).symm.continuous.comp
+          ((ContinuousLinearMap.isBoundedLinearMap_comp_right
+            (ContinuousLinearMap.inr ℝ (PhysSpace d) (PhysSpace d))).continuous.comp
+            (hφ_smooth.continuous_fderiv (by simp)))
+  -- Assemble: rewrite LHS via SC.1; push the derivative integral back through `integral_map`.
+  have hLHS : (fun s => ∫ z, φ z ∂(vlasovSolutionViaPushforward charX charV f₀ s)) =
+              (fun s => ∫ z, φ (charX s z, charV s z) ∂f₀) := funext h_compose
+  have h_map_eq :
+      ∫ z, (@inner ℝ (PhysSpace d) _ z.2 (gradXφ z)
+            - @inner ℝ (PhysSpace d) _ (convolveFunctionMeasure gradW (ρ t) z.1) (gradVφ z))
+        ∂(vlasovSolutionViaPushforward charX charV f₀ t)
+      = ∫ z, (@inner ℝ (PhysSpace d) _ (charV t z) (gradXφ (charX t z, charV t z))
+            - @inner ℝ (PhysSpace d) _ (convolveFunctionMeasure gradW (ρ t) (charX t z))
+                (gradVφ (charX t z, charV t z)))
+        ∂f₀ := by
+    unfold vlasovSolutionViaPushforward at h_integrand_aesm ⊢
+    exact integral_map (h_flow_meas t) h_integrand_aesm
+  rw [hLHS, h_map_eq]
+  exact h_under_integral
+
+omit [NeZero d] in
+/-- **C1 #2 — characteristic flow for a frozen field from window data (L11 clamp).**
+
+Build the characteristic flow for the *given* external curve `ρ` on `Ioo 0 T` (with boundary
+regularity), from probability/moment/integrability/continuity data on the window `[0,T]` only.
+`exists_vlasov_characteristicFlow_global_smallT` demands *universal*-in-`t` instances; we clamp
+`t ↦ ρ (max 0 (min t T))` into the window (L11), apply the universal producer to the clamped
+curve, and transfer on `[0,T]` where the clamp is the identity. -/
+theorem exists_frozenField_charFlow_On
+    (W : PhysSpace d → ℝ)
+    (gradW : PhysSpace d → PhysSpace d) (hgradW : ∀ x, gradW x = gradient W x)
+    (L : NNReal) (hL : LipschitzWith L gradW)
+    (ρ : ℝ → Measure (PhysSpace d))
+    (T : ℝ) (hT : 0 < T) (hTL_PL : LocalSmallnessPLBuffer L T)
+    (hρ_prob : ∀ t ∈ Set.Icc (0 : ℝ) T, IsProbabilityMeasure (ρ t))
+    (h_int : ∀ t ∈ Set.Icc (0 : ℝ) T, ∀ (x : PhysSpace d),
+      Integrable (fun y => gradW (x - y)) (ρ t))
+    (hρ_cont : ∀ x : PhysSpace d,
+      ContinuousOn (fun t => convolveFunctionMeasure gradW (ρ t) x) (Set.Icc (0 : ℝ) T))
+    (h_y_int : ∀ t ∈ Set.Icc (0 : ℝ) T, Integrable (fun y : PhysSpace d => ‖y‖) (ρ t))
+    (M_ρ : ℝ) (hM_ρ_nn : 0 ≤ M_ρ)
+    (hM_ρ : ∀ t ∈ Set.Icc (0 : ℝ) T, ∫ y, ‖y‖ ∂(ρ t) ≤ M_ρ) :
+    ∃ charX charV : ℝ → PhaseSpace d → PhysSpace d,
+      IsCharacteristicFlowOn gradW ρ charX charV (Set.Ioo 0 T) Set.univ ∧
+      (∀ z : PhaseSpace d, (charX 0 z, charV 0 z) = z) ∧
+      (∀ z : PhaseSpace d,
+        ContinuousOn (fun s => (charX s z, charV s z)) (Set.Icc (0 : ℝ) T)) ∧
+      (∀ z : PhaseSpace d, ∀ s ∈ Set.Ico (0 : ℝ) T,
+        HasDerivWithinAt (fun s' => (charX s' z, charV s' z))
+          (vlasovVectorField gradW ρ s (charX s z, charV s z)) (Set.Ici s) s) := by
+  classical
+  -- L11 clamp: `clampT t ∈ [0,T]` for every `t`, and `clampT t = t` on `[0,T]`.
+  set clampT : ℝ → ℝ := fun t => max 0 (min t T) with hclampT_def
+  have hclampT_mem : ∀ t, clampT t ∈ Set.Icc (0 : ℝ) T := by
+    intro t
+    simp only [hclampT_def, Set.mem_Icc]
+    exact ⟨le_max_left _ _, max_le hT.le (min_le_right _ _)⟩
+  have hclampT_id : ∀ t ∈ Set.Icc (0 : ℝ) T, clampT t = t := by
+    intro t ht
+    simp only [hclampT_def, min_eq_left ht.2, max_eq_right ht.1]
+  have hclampT_cont : Continuous clampT := by
+    simp only [hclampT_def]
+    exact continuous_const.max (continuous_id.min continuous_const)
+  -- Clamped curve `ρ' := ρ ∘ clampT`, which satisfies the universal hypotheses.
+  set ρ' : ℝ → Measure (PhysSpace d) := fun t => ρ (clampT t) with hρ'_def
+  have hρ'_prob : ∀ t, IsProbabilityMeasure (ρ' t) :=
+    fun t => hρ_prob (clampT t) (hclampT_mem t)
+  have h_int' : ∀ t (x : PhysSpace d), Integrable (fun y => gradW (x - y)) (ρ' t) :=
+    fun t x => h_int (clampT t) (hclampT_mem t) x
+  have h_y_int' : ∀ t, Integrable (fun y : PhysSpace d => ‖y‖) (ρ' t) :=
+    fun t => h_y_int (clampT t) (hclampT_mem t)
+  have hM_ρ' : ∀ t, ∫ y, ‖y‖ ∂(ρ' t) ≤ M_ρ := fun t => hM_ρ (clampT t) (hclampT_mem t)
+  have hρ'_cont : ∀ x : PhysSpace d,
+      Continuous (fun t => convolveFunctionMeasure gradW (ρ' t) x) :=
+    fun x => (hρ_cont x).comp_continuous hclampT_cont (fun t => hclampT_mem t)
+  -- Apply the universal producer to `ρ'`.
+  obtain ⟨charX, charV, hflow', h_bdry'⟩ :=
+    exists_vlasov_characteristicFlow_global_smallT W gradW hgradW L hL ρ'
+      h_int' hρ'_cont h_y_int' M_ρ hM_ρ_nn hM_ρ' T hT.le hTL_PL
+  -- On `Ioo`/`Icc 0 T`, `clampT = id` so `ρ' = ρ`: transfer the flow back to `ρ`.
+  refine ⟨charX, charV, ⟨hflow'.1, hflow'.2.1, ?_⟩, ?_, ?_, ?_⟩
+  · -- velocity ODE for `ρ` on `Ioo 0 T`
+    intro t ht z hz
+    have h := hflow'.2.2 t ht z hz
+    have hρeq : ρ' t = ρ t := by
+      simp only [hρ'_def, hclampT_id t (Set.Ioo_subset_Icc_self ht)]
+    rwa [hρeq] at h
+  · -- initial condition
+    intro z
+    have h := hflow'.1 z (Set.mem_univ z)
+    exact Prod.ext h.1 h.2
+  · -- `ContinuousOn` on `Icc 0 T` from the producer's boundary derivatives
+    intro z t ht
+    obtain ⟨hX, hV⟩ := h_bdry' z t ht
+    exact (hX.prodMk hV).continuousWithinAt
+  · -- `h_deriv_Ico` (Ici-joint) from the producer's `Icc`-component derivatives
+    intro z s hs
+    have hsIcc : s ∈ Set.Icc (0 : ℝ) T := Set.Ico_subset_Icc_self hs
+    obtain ⟨hX, hV⟩ := h_bdry' z s hsIcc
+    have hρeq : ρ' s = ρ s := by simp only [hρ'_def, hclampT_id s hsIcc]
+    have hpair : HasDerivWithinAt (fun s' => (charX s' z, charV s' z))
+        (charV s z, -(convolveFunctionMeasure gradW (ρ' s) (charX s z)))
+        (Set.Icc 0 T) s := hX.prodMk hV
+    rw [hρeq] at hpair
+    -- convert the set `Icc 0 T` to `Ici s` (local subset near `s`, since `s < T`)
+    have hmem : Set.Iic ((s + T) / 2) ∈ nhds s := Iic_mem_nhds (by linarith [hs.2])
+    have hsub : Set.Ici s ∩ Set.Iic ((s + T) / 2) ⊆ Set.Icc 0 T := by
+      rintro u ⟨hu1, hu2⟩
+      exact ⟨le_trans hs.1 hu1, le_trans hu2 (by linarith [hs.2])⟩
+    exact (hasDerivWithinAt_inter hmem).mp (hpair.mono hsub)
+
+/-! ## Final-step layer (crux-independent): constancy + measure extensionality -/
+
+/-- **C2 #7 — constancy from a vanishing derivative.**
+
+If a real function is continuous on `[0,T]` and has zero derivative throughout the open
+interval, its endpoint values agree.  This is the dual argument's payoff step: `s ↦ ∫ ψ_s dμ_s`
+is constant, so its value at `T` (= `∫ φ dμ_T`) equals its value at `0` (= `∫ ψ_0 dμ_0`). Mean
+value theorem (`exists_hasDerivAt_eq_slope`). -/
+lemma transportedIntegral_const_On {h : ℝ → ℝ} {T : ℝ} (hT : 0 < T)
+    (hcont : ContinuousOn h (Set.Icc 0 T))
+    (hderiv : ∀ s ∈ Set.Ioo (0 : ℝ) T, HasDerivAt h 0 s) :
+    h 0 = h T := by
+  obtain ⟨c, _hc, hc'⟩ :=
+    exists_hasDerivAt_eq_slope h (fun _ => 0) hT hcont (fun s hs => hderiv s hs)
+  have hc0 : (0 : ℝ) = (h T - h 0) / (T - 0) := hc'
+  rcases div_eq_zero_iff.mp hc0.symm with h1 | h2
+  · exact (sub_eq_zero.mp h1).symm
+  · exact absurd h2 (ne_of_gt (by linarith : (0 : ℝ) < T - 0))
+
+omit [NeZero d] in
+/-- **C2 #9 — `C_c^∞` test functions determine a finite measure.**
+
+If `∫ φ dμ = ∫ φ dν` for every smooth compactly-supported `φ`, then `μ = ν` (finite measures on
+phase space).  The dual argument yields equality of integrals against the `IsVlasovSolution` test
+class `C_c^∞`; this closes the bridge's final step `f T = g T`.  Route: extend `C_c^∞ →`
+bounded-continuous (smooth approximation), then the in-house bounded-continuous extensionality
+`ext_of_forall_integral_eq_of_IsFiniteMeasure` (cf. `Wasserstein.lean`). -/
+lemma measure_eq_of_forall_Cc_integral_eq {μ ν : Measure (PhaseSpace d)}
+    [IsFiniteMeasure μ] [IsFiniteMeasure ν]
+    (h : ∀ φ : PhaseSpace d → ℝ, ContDiff ℝ (⊤ : ℕ∞) φ → HasCompactSupport φ →
+      ∫ z, φ z ∂μ = ∫ z, φ z ∂ν) :
+    μ = ν := by
+  -- Haar instance on the ambient volume via the product reduction.
+  have hHaar : (volume : Measure (PhaseSpace d)).IsAddHaarMeasure := by
+    rw [show (volume : Measure (PhaseSpace d)) = (volume : Measure (PhysSpace d)).prod volume from
+      Measure.volume_eq_prod _ _]
+    infer_instance
+  have hvolReg : (volume : Measure (PhaseSpace d)).Regular :=
+    Measure.Regular.of_sigmaCompactSpace_of_isLocallyFiniteMeasure _
+  have hμreg : μ.Regular := inferInstance
+  have hνreg : ν.Regular := inferInstance
+  -- Reduce `μ = ν` to equality of integrals against continuous compactly-supported `g`.
+  refine MeasureTheory.Measure.ext_of_integral_eq_on_compactlySupported (fun g => ?_)
+  set gf : PhaseSpace d → ℝ := ⇑g with hgf
+  have hg_cont : Continuous gf := map_continuous g
+  have hg_cs : HasCompactSupport gf := CompactlySupportedContinuousMap.hasCompactSupport g
+  -- Uniform sup bound on `g`.
+  obtain ⟨C, hC⟩ := hg_cont.bounded_above_of_compact_support hg_cs
+  have hCnn : 0 ≤ C := le_trans (norm_nonneg _) (hC 0)
+  -- A mollifier family `φ n` with outer radius `2/(n+2) → 0`.
+  set φ : ℕ → ContDiffBump (0 : PhaseSpace d) :=
+    fun n => ⟨1 / (n + 2), 2 / (n + 2), by positivity, by
+      rw [div_lt_div_iff_of_pos_right (by positivity)]; norm_num⟩ with hφ
+  have hrout : ∀ n, (φ n).rOut = 2 / (n + 2) := fun n => rfl
+  have hrout_tendsto : Filter.Tendsto (fun n => (φ n).rOut) Filter.atTop (nhds 0) := by
+    simp only [hrout]
+    apply Filter.Tendsto.div_atTop (tendsto_const_nhds)
+    exact Filter.tendsto_atTop_add_const_right _ 2 tendsto_natCast_atTop_atTop
+  -- The mollified functions.
+  set gn : ℕ → PhaseSpace d → ℝ :=
+    fun n => convolution ((φ n).normed volume) gf (ContinuousLinearMap.lsmul ℝ ℝ) volume with hgn
+  -- Each `gn n` is `C^∞` with compact support, hence covered by the hypothesis `h`.
+  have hgn_smooth : ∀ n, ContDiff ℝ (⊤ : ℕ∞) (gn n) := fun n =>
+    ((φ n).hasCompactSupport_normed).contDiff_convolution_left _
+      (φ n).contDiff_normed (hg_cont.locallyIntegrable)
+  have hgn_cs : ∀ n, HasCompactSupport (gn n) := fun n =>
+    HasCompactSupport.convolution _ (φ n).hasCompactSupport_normed hg_cs
+  have hgn_eq : ∀ n, ∫ z, gn n z ∂μ = ∫ z, gn n z ∂ν := fun n =>
+    h (gn n) (hgn_smooth n) (hgn_cs n)
+  -- Pointwise convergence `gn n → gf` (continuous `g`, shrinking bumps).
+  have hgn_lim : ∀ x, Filter.Tendsto (fun n => gn n x) Filter.atTop (nhds (gf x)) := fun x =>
+    ContDiffBump.convolution_tendsto_right_of_continuous hrout_tendsto hg_cont x
+  -- Uniform bound `‖gn n x‖ ≤ C` (averaging keeps the sup bound).
+  have hgn_bound : ∀ n, ∀ x, ‖gn n x‖ ≤ C := by
+    intro n x
+    rw [hgn]
+    simp only
+    rw [convolution_lsmul]
+    calc ‖∫ t, (φ n).normed volume t • gf (x - t) ∂volume‖
+        ≤ ∫ t, ‖(φ n).normed volume t • gf (x - t)‖ ∂volume := norm_integral_le_integral_norm _
+      _ ≤ ∫ t, (φ n).normed volume t * C ∂volume := by
+          apply integral_mono_of_nonneg
+          · exact Filter.Eventually.of_forall (fun t => norm_nonneg _)
+          · exact ((φ n).integrable_normed).mul_const C
+          · refine Filter.Eventually.of_forall (fun t => ?_)
+            simp only
+            rw [norm_smul, Real.norm_eq_abs, abs_of_nonneg ((φ n).nonneg_normed t)]
+            exact mul_le_mul_of_nonneg_left (hC _) ((φ n).nonneg_normed t)
+      _ = C := by rw [integral_mul_const, (φ n).integral_normed, one_mul]
+  -- DCT: `∫ gn n dμ → ∫ gf dμ` and likewise for `ν`.
+  have hconv_μ : Filter.Tendsto (fun n => ∫ z, gn n z ∂μ) Filter.atTop (nhds (∫ z, gf z ∂μ)) := by
+    apply tendsto_integral_of_dominated_convergence (fun _ => C)
+    · exact fun n => (hgn_smooth n).continuous.aestronglyMeasurable
+    · exact integrable_const C
+    · exact fun n => Filter.Eventually.of_forall (fun x => hgn_bound n x)
+    · exact Filter.Eventually.of_forall hgn_lim
+  have hconv_ν : Filter.Tendsto (fun n => ∫ z, gn n z ∂ν) Filter.atTop (nhds (∫ z, gf z ∂ν)) := by
+    apply tendsto_integral_of_dominated_convergence (fun _ => C)
+    · exact fun n => (hgn_smooth n).continuous.aestronglyMeasurable
+    · exact integrable_const C
+    · exact fun n => Filter.Eventually.of_forall (fun x => hgn_bound n x)
+    · exact Filter.Eventually.of_forall hgn_lim
+  -- The two limits coincide because the prelimit sequences are equal.
+  have hμν : Filter.Tendsto (fun n => ∫ z, gn n z ∂μ) Filter.atTop (nhds (∫ z, gf z ∂ν)) := by
+    simpa only [hgn_eq] using hconv_ν
+  exact tendsto_nhds_unique hconv_μ hμν
+
+omit [NeZero d] in
+/-- Convenience extractor: under `[AssW2 W]`, a gradient field `gradW= ∇W` is `C¹`.
+
+`AssW2.gradContDiff` gives `ContDiff ℝ 1 (fun x => fderiv ℝ W x)`; composing with the (smooth,
+linear) Riesz isometry `gradient W x = (toDual ℝ _).symm (fderiv ℝ W x)` and rewriting by `hgradW`
+yields `ContDiff ℝ 1 gradW`. -/
+lemma assW2_contDiff_gradW (W : PhysSpace d → ℝ) [AssW2 W]
+    (gradW : PhysSpace d → PhysSpace d) (hgradW : ∀ x, gradW x = gradient W x) :
+    ContDiff ℝ 1 gradW := by
+  have heq : gradW =
+      fun x => (InnerProductSpace.toDual ℝ (PhysSpace d)).symm (fderiv ℝ W x) := by
+    funext x; rw [hgradW]; rfl
+  rw [heq]
+  have hriesz : ContDiff ℝ 1 fun u => (InnerProductSpace.toDual ℝ (PhysSpace d)).symm u :=
+    (InnerProductSpace.toDual ℝ (PhysSpace d)).symm.toContinuousLinearEquiv.contDiff
+  exact hriesz.comp ‹AssW2 W›.gradContDiff
+
+/-! ## Crux layer (C3): the variational equation and the dual-transport assembly
+
+The two interfaces below were the load-bearing pieces of the bridge — both now proven and
+axiom-clean.  `#3` was the genuine research gap (C¹ dependence of an ODE flow on its initial point
+— absent from Mathlib), closed via route (b) (difference-quotient + Gronwall); `#8` is the
+bridge-specific dual-transported-test-function assembly that consumes it.  `#10` (the public
+theorem) composes the reuse layer (`exists_frozenField_charFlow_On`, #2) with `#8`.
+
+The dual-argument *internals* `#4`/`#5`/`#6` (test-class enlargement `C_c^∞ → C¹_c`, the
+transported test function `ψ_s = φ ∘ Φ_{s→t}` and its transport identity, and the zero-derivative
+of `s ↦ ∫ ψ_s dμ_s`) are realized against the two-time-flow representation `Φ_{s→t} = Φ_t ∘ Φ_s⁻¹`
+and proven below (`weakEvolution_test_C1c_On`, `transportedTest_transport_identity`,
+`transportedIntegral_hasDerivAt_zero`). -/
+
+omit [NeZero d] in
+/-- **C3 F1 — the convolution force field is `C¹` in space (Fréchet derivative under the
+integral).**  For `gradW ∈ C¹` (and `L`-Lipschitz, a probability measure `ρ` with the kernel
+integrable), `x ↦ ∫ y, gradW (x − y) ∂ρ` is Fréchet-differentiable with derivative
+`∫ y, fderiv ℝ gradW (x₀ − y) ∂ρ`.  This is the field-regularity foundation of the variational
+equation (#3): it makes `D_z (vlasovVectorField …)` exist and continuous, so the variational ODE
+`M' = (D_z b)·M` has continuous coefficients.
+
+Differentiation under the integral sign (`hasFDerivAt_integral_of_dominated_loc_of_lip`): the
+per-fibre map `x ↦ gradW (x − y)` is `L`-Lipschitz (a uniform, integrable bound against a
+probability measure) and differentiable, so the parametric integral differentiates with derivative
+the integral of the fibrewise derivatives. -/
+theorem convolveFunctionMeasure_hasFDerivAt
+    (gradW : PhysSpace d → PhysSpace d) (hgradW_C1 : ContDiff ℝ 1 gradW)
+    (L : NNReal) (hL : LipschitzWith L gradW)
+    (ρ : Measure (PhysSpace d)) [IsProbabilityMeasure ρ]
+    (h_int : ∀ x : PhysSpace d, Integrable (fun y => gradW (x - y)) ρ)
+    (x₀ : PhysSpace d) :
+    HasFDerivAt (fun x => convolveFunctionMeasure gradW ρ x)
+      (∫ y, fderiv ℝ gradW (x₀ - y) ∂ρ) x₀ := by
+  have hdiff : Differentiable ℝ gradW := hgradW_C1.differentiable one_ne_zero
+  have hfderiv_cont : Continuous (fun z => fderiv ℝ gradW z) :=
+    hgradW_C1.continuous_fderiv one_ne_zero
+  have key := hasFDerivAt_integral_of_dominated_loc_of_lip
+    (μ := ρ) (s := (Set.univ : Set (PhysSpace d))) (x₀ := x₀)
+    (F := fun x y => gradW (x - y))
+    (F' := fun y => fderiv ℝ gradW (x₀ - y))
+    (bound := fun _ => (L : ℝ))
+    (Filter.univ_mem)
+    (Filter.Eventually.of_forall fun x =>
+      (hL.continuous.comp (continuous_const.sub continuous_id)).aestronglyMeasurable)
+    (h_int x₀)
+    ((hfderiv_cont.comp (continuous_const.sub continuous_id)).aestronglyMeasurable)
+    (Filter.Eventually.of_forall fun a => ?_)
+    (integrable_const _)
+    (Filter.Eventually.of_forall fun a => ?_)
+  · have h2 := key.2
+    simpa only [convolveFunctionMeasure] using h2
+  · -- h_lip: `fun x => gradW (x - a)` is `L`-Lipschitz, hence `LipschitzOnWith (nnabs L)` on univ
+    have hLip : LipschitzWith L (fun x : PhysSpace d => gradW (x - a)) := by
+      refine LipschitzWith.of_dist_le_mul (fun x y => ?_)
+      have hd : dist (x - a) (y - a) = dist x y := by
+        rw [dist_eq_norm, dist_eq_norm]; congr 1; abel
+      calc dist (gradW (x - a)) (gradW (y - a))
+          ≤ (L : ℝ) * dist (x - a) (y - a) := hL.dist_le_mul _ _
+        _ = (L : ℝ) * dist x y := by rw [hd]
+    rw [Real.nnabs_coe L]
+    exact hLip.lipschitzOnWith
+  · -- h_diff: `HasFDerivAt (fun x => gradW (x - a)) (fderiv ℝ gradW (x₀ - a)) x₀`
+    have h1 : HasFDerivAt gradW (fderiv ℝ gradW (x₀ - a)) (x₀ - a) :=
+      (hdiff (x₀ - a)).hasFDerivAt
+    have h2 : HasFDerivAt (fun x : PhysSpace d => x - a)
+        (ContinuousLinearMap.id ℝ (PhysSpace d)) x₀ :=
+      (hasFDerivAt_id x₀).sub_const a
+    have hc := h1.comp x₀ h2
+    simpa [Function.comp_def] using hc
+
+omit [NeZero d] in
+/-- **C3 F2 — the Vlasov field is `C¹` in the phase-space variable, with the block Jacobian.**
+At fixed time `t`, `vlasovVectorField gradW ρ t = fun (x,v) ↦ (v, −conv(x))` is
+Fréchet-differentiable in `z = (x,v)` with derivative the block continuous-linear map
+`δ ↦ (δ.2, −(D_x conv)(δ.1))`, where `D_x conv = ∫ y, fderiv ℝ gradW (z.1 − y) ∂(ρ t)` (F1).
+This is the coefficient `A(t) := D_z b(t, Φ_t z)` of the variational ODE `M' = A(t)·M`. -/
+theorem vlasovVectorField_hasFDerivAt_in_z
+    (gradW : PhysSpace d → PhysSpace d) (hgradW_C1 : ContDiff ℝ 1 gradW)
+    (L : NNReal) (hL : LipschitzWith L gradW)
+    (ρ : ℝ → Measure (PhysSpace d)) [∀ s, IsProbabilityMeasure (ρ s)]
+    (h_int : ∀ s (x : PhysSpace d), Integrable (fun y => gradW (x - y)) (ρ s))
+    (t : ℝ) (z : PhaseSpace d) :
+    HasFDerivAt (vlasovVectorField gradW ρ t)
+      ((ContinuousLinearMap.snd ℝ (PhysSpace d) (PhysSpace d)).prod
+        (-((∫ y, fderiv ℝ gradW (z.1 - y) ∂(ρ t)).comp
+            (ContinuousLinearMap.fst ℝ (PhysSpace d) (PhysSpace d))))) z := by
+  have hconv : HasFDerivAt (fun x => convolveFunctionMeasure gradW (ρ t) x)
+      (∫ y, fderiv ℝ gradW (z.1 - y) ∂(ρ t)) z.1 :=
+    convolveFunctionMeasure_hasFDerivAt gradW hgradW_C1 L hL (ρ t) (h_int t) z.1
+  have hfst : HasFDerivAt (fun w : PhaseSpace d => w.1)
+      (ContinuousLinearMap.fst ℝ (PhysSpace d) (PhysSpace d)) z :=
+    (ContinuousLinearMap.fst ℝ (PhysSpace d) (PhysSpace d)).hasFDerivAt
+  have h1 : HasFDerivAt (fun w : PhaseSpace d => w.2)
+      (ContinuousLinearMap.snd ℝ (PhysSpace d) (PhysSpace d)) z :=
+    (ContinuousLinearMap.snd ℝ (PhysSpace d) (PhysSpace d)).hasFDerivAt
+  have h2 : HasFDerivAt (fun w : PhaseSpace d => convolveFunctionMeasure gradW (ρ t) w.1)
+      ((∫ y, fderiv ℝ gradW (z.1 - y) ∂(ρ t)).comp
+        (ContinuousLinearMap.fst ℝ (PhysSpace d) (PhysSpace d))) z :=
+    hconv.comp z hfst
+  have hprod := h1.prodMk h2.neg
+  exact hprod
+
+omit [NeZero d] in
+/-- **C3 F1c — the convolution derivative is continuous in space.**  `x ↦ ∫ y, fderiv ℝ gradW
+(x − y) ∂ρ` (the Fréchet derivative of the convolution field, F1) is continuous, by dominated
+convergence: the integrand is continuous in `x` and bounded by `‖fderiv gradW‖ ≤ L` (a constant,
+integrable against the probability measure `ρ`).  Continuity of the variational coefficient
+`A(t)` in its spatial argument — half of the `t`-continuity of `A` (the other half is the
+measure-curve regularity `t ↦ ρ t`, supplied at the V1c ODE-existence step). -/
+theorem convolveFunctionMeasure_fderiv_continuous
+    (gradW : PhysSpace d → PhysSpace d) (hgradW_C1 : ContDiff ℝ 1 gradW)
+    (L : NNReal) (hL : LipschitzWith L gradW)
+    (ρ : Measure (PhysSpace d)) [IsProbabilityMeasure ρ] :
+    Continuous (fun x => ∫ y, fderiv ℝ gradW (x - y) ∂ρ) := by
+  have hfderiv_cont : Continuous (fun z => fderiv ℝ gradW z) :=
+    hgradW_C1.continuous_fderiv one_ne_zero
+  refine continuous_of_dominated
+    (F := fun x y => fderiv ℝ gradW (x - y)) (bound := fun _ => (L : ℝ)) ?_ ?_ ?_ ?_
+  · intro x
+    exact (hfderiv_cont.comp (continuous_const.sub continuous_id)).aestronglyMeasurable
+  · intro x
+    exact Filter.Eventually.of_forall (fun y => norm_fderiv_le_of_lipschitz (𝕜 := ℝ) hL)
+  · exact integrable_const _
+  · exact Filter.Eventually.of_forall (fun y =>
+      hfderiv_cont.comp (continuous_id.sub continuous_const))
+
+omit [NeZero d] in
+/-- **C3 A-cont — the variational coefficient is continuous in time.**
+Compose the convolution-derivative continuity with the flow, then express the block map as a
+sum of continuous compositions.  This supplies the coefficient regularity for
+`exists_fundamentalMatrix`. -/
+lemma vlasovVariationalCoeff_continuousOn
+    (gradW : PhysSpace d → PhysSpace d)
+    (ρ : ℝ → Measure (PhysSpace d))
+    (charX charV : ℝ → PhaseSpace d → PhysSpace d) (T : ℝ) (z : PhaseSpace d)
+    (hcontIcc : ContinuousOn (fun s => (charX s z, charV s z)) (Set.Icc (0 : ℝ) T))
+    (hρD_cont : ContinuousOn
+      (fun p : ℝ × PhysSpace d => ∫ y, fderiv ℝ gradW (p.2 - y) ∂(ρ p.1))
+      (Set.Icc 0 T ×ˢ (Set.univ : Set (PhysSpace d)))) :
+    ContinuousOn (fun s => (ContinuousLinearMap.snd ℝ (PhysSpace d) (PhysSpace d)).prod
+      (-((∫ y, fderiv ℝ gradW (charX s z - y) ∂(ρ s)).comp
+          (ContinuousLinearMap.fst ℝ (PhysSpace d) (PhysSpace d))))) (Set.Icc 0 T) := by
+  have hX : ContinuousOn (fun s => charX s z) (Set.Icc (0 : ℝ) T) :=
+    continuous_fst.comp_continuousOn hcontIcc
+  have hpair : ContinuousOn (fun s => ((s, charX s z) : ℝ × PhysSpace d)) (Set.Icc (0 : ℝ) T) :=
+    continuousOn_id.prodMk hX
+  have hmaps : Set.MapsTo (fun s => ((s, charX s z) : ℝ × PhysSpace d))
+      (Set.Icc (0 : ℝ) T) (Set.Icc 0 T ×ˢ (Set.univ : Set (PhysSpace d))) :=
+    fun s hs => ⟨hs, Set.mem_univ _⟩
+  have hD : ContinuousOn (fun s => ∫ y, fderiv ℝ gradW (charX s z - y) ∂(ρ s)) (Set.Icc 0 T) :=
+    hρD_cont.comp hpair hmaps
+  have hDcomp : ContinuousOn (fun s => -((∫ y, fderiv ℝ gradW (charX s z - y) ∂(ρ s)).comp
+      (ContinuousLinearMap.fst ℝ (PhysSpace d) (PhysSpace d)))) (Set.Icc 0 T) :=
+    (hD.clm_comp continuousOn_const).neg
+  have heq : (fun s => (ContinuousLinearMap.snd ℝ (PhysSpace d) (PhysSpace d)).prod
+        (-((∫ y, fderiv ℝ gradW (charX s z - y) ∂(ρ s)).comp
+            (ContinuousLinearMap.fst ℝ (PhysSpace d) (PhysSpace d)))))
+      = (fun s => (ContinuousLinearMap.inl ℝ (PhysSpace d) (PhysSpace d)).comp
+            (ContinuousLinearMap.snd ℝ (PhysSpace d) (PhysSpace d))
+          + (ContinuousLinearMap.inr ℝ (PhysSpace d) (PhysSpace d)).comp
+            (-((∫ y, fderiv ℝ gradW (charX s z - y) ∂(ρ s)).comp
+                (ContinuousLinearMap.fst ℝ (PhysSpace d) (PhysSpace d))))) := by
+    funext s; ext x <;> simp
+  rw [heq]
+  exact continuousOn_const.add (continuousOn_const.clm_comp hDcomp)
+
+end Vlasov
diff --git a/LeanPool/Vlasov/OT/LocalWellPosedness.lean b/LeanPool/Vlasov/OT/LocalWellPosedness.lean
new file mode 100644
index 0000000000..408d8afb72
--- /dev/null
+++ b/LeanPool/Vlasov/OT/LocalWellPosedness.lean
@@ -0,0 +1,1471 @@
+/-
+Copyright (c) 2026 Joseph K. Miller. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Joseph K. Miller
+-/
+module
+
+public import LeanPool.Vlasov.OT.CharacteristicFlow
+import Mathlib.Algebra.Order.Ring.Star
+
+/-!
+# Local well-posedness for the Vlasov equation
+
+The Picard fixed point supplies the local characteristic flow, its moment bound,
+and the local Lagrangian solution. Continuation and stability use these results
+without retaining their elaboration in the same compilation unit.
+-/
+
+@[expose] public section
+
+namespace Vlasov
+
+open MeasureTheory ENNReal
+
+/-! ## §9  Theorem (Existence and uniqueness for Vlasov)   (tex: thm:vlasov-wp) -/
+-- The proof composes directly with the characteristic-flow infrastructure
+-- developed in `LeanPool/Vlasov/OT/CharacteristicFlow.lean`: `exists_vlasov_characteristicFlow`,
+-- `flow_distance_growth_bound`, and
+-- `vlasovSolutionViaPushforward_isLagrangianVlasovSolution`.  The
+-- `HasFiniteFirstMoment` predicate remains in `Basic.lean`.
+
+/-- **Project-internal: AEMeasurability of the Vlasov characteristic flow's
+joint map** `z ↦ (charX s z, charV s z)` on the window `Icc 0 T`.
+
+The window-restricted statement (`Icc 0 T`) is exactly what is needed: the
+Vlasov flow satisfies `HasDerivAt` only on `Ioo 0 T` (off-window it is
+uncontrolled `Classical.choose` data), and the sole consumer applies this
+only at `clampToIcc T s ∈ Icc 0 T`.  On the window the joint flow's
+measurability follows from `charFlow_measurable_via_gronwall` (genuine
+`Measurable`, via the boundary bundle through
+`characteristicFlow_boundary_regularity`).
+
+**In-project consumer**: `vlasovWellPosedness_local_picard_fixedPointFlow`'s
+AEMeasurable conjunct, applied at clamp times `clampToIcc T s ∈ Icc 0 T`. -/
+private lemma picardCharFlow_aemeasurable
+    {d : ℕ}
+    (gradW : PhysSpace d → PhysSpace d)
+    (L : NNReal) (hL : LipschitzWith L gradW)
+    (ρ : ℝ → Measure (PhysSpace d)) [∀ t, IsProbabilityMeasure (ρ t)]
+    (h_int : ∀ t (x : PhysSpace d), Integrable (fun y => gradW (x - y)) (ρ t))
+    (charX charV : ℝ → PhaseSpace d → PhysSpace d)
+    {T : ℝ} (hT : 0 ≤ T)
+    (hflow : IsCharacteristicFlowOn gradW ρ charX charV (Set.Ioo 0 T) Set.univ)
+    (hbdry : ∀ z : PhaseSpace d, ∀ t ∈ Set.Icc (0 : ℝ) T,
+        HasDerivWithinAt (fun s => charX s z) (charV t z) (Set.Icc 0 T) t ∧
+        HasDerivWithinAt (fun s => charV s z)
+          (-(convolveFunctionMeasure gradW (ρ t) (charX t z))) (Set.Icc 0 T) t)
+    (μ : Measure (PhaseSpace d)) :
+    ∀ s ∈ Set.Icc (0 : ℝ) T,
+      AEMeasurable (fun z : PhaseSpace d => (charX s z, charV s z)) μ := by
+  intro s hs
+  obtain ⟨h_init, h_cont, h_deriv⟩ :=
+    characteristicFlow_boundary_regularity gradW ρ charX charV T hT hflow hbdry
+  exact (charFlow_measurable_via_gronwall gradW L hL ρ h_int charX charV T hT
+    h_init h_cont h_deriv s hs).aemeasurable
+
+/-- **Contraction-input helper**: from a flow's exposed facts (`IsCharacteristicFlowOn`
+on `Ioo` + the boundary bundle on `Icc` — the `Phi_step_envelope` output shape)
+against a curve `ν`, derive the six per-`z` regularity facts that
+`Phi_supW1_contraction` consumes.  Chains `characteristicFlow_boundary_regularity`
+(→ init/cont/deriv, the last three EXACT), `charFlow_measurable_via_gronwall`
+(→ AEMeasurable), and `flow_distance_growth_bound_on` (→ growth bound, integrated
+to the two integrability facts). -/
+private lemma envelopeStep_contractionInputs {d : ℕ} [NeZero d]
+    (gradW : PhysSpace d → PhysSpace d) (L : NNReal) (hL : LipschitzWith L gradW)
+    (f₀ : Measure (PhaseSpace d)) [IsProbabilityMeasure f₀]
+    (h_f₀_int : Integrable (fun z : PhaseSpace d => ‖z‖) f₀)
+    {T : ℝ} (hT : 0 ≤ T) {m : ℝ → ℝ}
+    (ν : VlasovMeasureCurve d T m)
+    (Mbar : ℝ) (hMbar_nn : 0 ≤ Mbar)
+    (hM_ρ : ∀ t ∈ Set.Icc (0 : ℝ) T, ∫ y, ‖y‖ ∂(ν.extend t) ≤ Mbar)
+    (cX cV : ℝ → PhaseSpace d → PhysSpace d)
+    (hflow : IsCharacteristicFlowOn gradW ν.extend cX cV (Set.Ioo 0 T) Set.univ)
+    (hbdry : ∀ z : PhaseSpace d, ∀ t ∈ Set.Icc (0 : ℝ) T,
+        HasDerivWithinAt (fun s => cX s z) (cV t z) (Set.Icc 0 T) t ∧
+        HasDerivWithinAt (fun s => cV s z)
+          (-(convolveFunctionMeasure gradW (ν.extend t) (cX t z))) (Set.Icc 0 T) t)
+    (h_int_ext : ∀ t (x : PhysSpace d),
+        Integrable (fun y => gradW (x - y)) (ν.extend t)) :
+    (∀ t ∈ Set.Icc (0 : ℝ) T, AEMeasurable (fun z : PhaseSpace d => cX t z) f₀) ∧
+    (∀ t ∈ Set.Icc (0 : ℝ) T, Integrable (fun z : PhaseSpace d => ‖cX t z‖) f₀) ∧
+    (∀ t ∈ Set.Icc (0 : ℝ) T,
+      Integrable (fun y : PhysSpace d => ‖y‖) (Measure.map (fun z => cX t z) f₀)) ∧
+    (∀ z : PhaseSpace d, (cX 0 z, cV 0 z) = z) ∧
+    (∀ z : PhaseSpace d,
+      ContinuousOn (fun s => (cX s z, cV s z)) (Set.Icc (0 : ℝ) T)) ∧
+    (∀ z : PhaseSpace d, ∀ s ∈ Set.Ico (0 : ℝ) T,
+      HasDerivWithinAt (fun s' => (cX s' z, cV s' z))
+        (vlasovVectorField gradW (ν.extend) s (cX s z, cV s z))
+        (Set.Ici s) s) := by
+  have : ∀ t, IsProbabilityMeasure (ν.extend t) := VlasovMeasureCurve.extend_isProb ν
+  obtain ⟨h_init, h_cont, h_deriv⟩ :=
+    characteristicFlow_boundary_regularity gradW ν.extend cX cV T hT hflow hbdry
+  have h_meas : ∀ t ∈ Set.Icc (0 : ℝ) T,
+      AEMeasurable (fun z : PhaseSpace d => cX t z) f₀ := by
+    have h_meas_Icc := charFlow_measurable_via_gronwall gradW L hL ν.extend h_int_ext
+      cX cV T hT h_init h_cont h_deriv
+    exact fun t ht => (measurable_fst.comp (h_meas_Icc t ht)).aemeasurable
+  obtain ⟨C_T, hC_T_nn, h_growth⟩ :=
+    flow_distance_growth_bound_on gradW L hL ν.extend cX cV T hT
+      h_init h_cont h_deriv Mbar hMbar_nn hM_ρ
+      (fun t _ => VlasovMeasureCurve.extend_yIntegrable hT ν t) h_int_ext
+  have h_int_charX : ∀ t ∈ Set.Icc (0 : ℝ) T,
+      Integrable (fun z : PhaseSpace d => ‖cX t z‖) f₀ := by
+    intro t ht
+    have h_dom_int : Integrable (fun z : PhaseSpace d => C_T * (‖z‖ + 1)) f₀ := by
+      have h1 : Integrable (fun z : PhaseSpace d => C_T * ‖z‖) f₀ := h_f₀_int.const_mul C_T
+      have h2 : Integrable (fun _ : PhaseSpace d => C_T) f₀ := integrable_const _
+      have h_eq : (fun z : PhaseSpace d => C_T * (‖z‖ + 1)) = fun z => C_T * ‖z‖ + C_T := by
+        funext z; ring
+      rw [h_eq]; exact h1.add h2
+    refine h_dom_int.mono' (h_meas t ht).norm.aestronglyMeasurable ?_
+    refine Filter.Eventually.of_forall fun z => ?_
+    rw [Real.norm_of_nonneg (norm_nonneg _)]
+    exact le_trans (norm_fst_le (cX t z, cV t z)) (h_growth t ht z)
+  have h_yint_Phi : ∀ t ∈ Set.Icc (0 : ℝ) T,
+      Integrable (fun y : PhysSpace d => ‖y‖) (Measure.map (fun z => cX t z) f₀) := by
+    intro t ht
+    rw [integrable_map_measure continuous_norm.aestronglyMeasurable (h_meas t ht)]
+    exact h_int_charX t ht
+  exact ⟨h_meas, h_int_charX, h_yint_Phi, h_init, h_cont, h_deriv⟩
+
+/-- Lipschitz growth of the force plus a first moment of the measure make the
+shifted force integrable.  The workhorse integrability fact behind every
+`convolveFunctionMeasure` estimate. -/
+lemma integrable_gradW_shift
+    {d : ℕ}
+    (gradW : PhysSpace d → PhysSpace d)
+    (L : NNReal) (hL : LipschitzWith L gradW)
+    (μ : Measure (PhysSpace d)) [MeasureTheory.IsFiniteMeasure μ]
+    (h_yint : Integrable (fun y : PhysSpace d => ‖y‖) μ)
+    (xp : PhysSpace d) :
+    Integrable (fun y => gradW (xp - y)) μ := by
+  have h_aesm : AEStronglyMeasurable (fun y : PhysSpace d => gradW (xp - y)) μ :=
+    (hL.continuous.comp (continuous_const.sub continuous_id)).aestronglyMeasurable
+  have h_dom : ∀ y : PhysSpace d, ‖gradW (xp - y)‖ ≤
+      ‖gradW 0‖ + (L : ℝ) * ‖xp‖ + (L : ℝ) * ‖y‖ := by
+    intro y
+    have hd := hL.dist_le_mul (xp - y) 0
+    simp only [dist_eq_norm, sub_zero] at hd
+    have h_tri : ‖gradW (xp - y)‖ ≤ ‖gradW 0‖ + ‖gradW (xp - y) - gradW 0‖ := by
+      have := norm_add_le (gradW (xp - y) - gradW 0) (gradW 0)
+      simp only [sub_add_cancel] at this; linarith
+    have h_sub_le : ‖xp - y‖ ≤ ‖xp‖ + ‖y‖ := norm_sub_le xp y
+    have h_mul := mul_le_mul_of_nonneg_left h_sub_le L.coe_nonneg
+    linarith
+  have h_dom_int : Integrable
+      (fun y : PhysSpace d => ‖gradW 0‖ + (L : ℝ) * ‖xp‖ + (L : ℝ) * ‖y‖) μ := by
+    have h_eq : (fun y : PhysSpace d => ‖gradW 0‖ + (L : ℝ) * ‖xp‖ + (L : ℝ) * ‖y‖) =
+                fun y => (‖gradW 0‖ + (L : ℝ) * ‖xp‖) + (L : ℝ) * ‖y‖ := by funext y; ring
+    rw [h_eq]; exact (integrable_const _).add (h_yint.const_mul _)
+  exact h_dom_int.mono' h_aesm (Filter.Eventually.of_forall fun y => h_dom y)
+
+/-- `LocalSmallnessContraction L T` IS the Grönwall contraction factor
+`gronwallBound 0 (max 1 L) L T < 1`, after unfolding both definitions. -/
+lemma LocalSmallnessContraction.gronwallBound_lt_one
+    {L : NNReal} {T : ℝ} (hTL_con : LocalSmallnessContraction L T) :
+    gronwallBound 0 ((max 1 L : NNReal) : ℝ) (L : ℝ) T < 1 := by
+  have hK_pos : (0 : ℝ) < ((max 1 L : NNReal) : ℝ) := by
+    have : (1 : ℝ) ≤ ((max 1 L : NNReal) : ℝ) := by
+      rw [NNReal.coe_max, NNReal.coe_one]; exact le_max_left _ _
+    linarith
+  have hK_ne : ((max 1 L : NNReal) : ℝ) ≠ 0 := ne_of_gt hK_pos
+  rw [gronwallBound_of_K_ne_0 hK_ne]
+  simp only [zero_mul, zero_add]
+  have h_eq : (L : ℝ) / ((max 1 L : NNReal) : ℝ) *
+      (Real.exp (((max 1 L : NNReal) : ℝ) * T) - 1) =
+      (L : ℝ) * (Real.exp ((max 1 (L : ℝ)) * T) - 1) / (max 1 (L : ℝ)) := by
+    rw [NNReal.coe_max, NNReal.coe_one]
+    ring
+  rw [h_eq]
+  exact hTL_con
+
+/-- The Picard sequence of the local fixed-point construction, with its exposed
+per-step flows and the geometric contraction bound.  Extracted from
+`vlasovWellPosedness_local_picard_fixedPointFlow`; the parameters `q` (the
+contraction factor) and `D₀` (the initial `W₁`-input bound) are threaded with
+their defining equations so the parent's `let`-definitions supply `rfl`. -/
+private lemma vlasovWellPosedness_local_picard_sequence
+    {d : ℕ} [NeZero d]
+    (W : PhysSpace d → ℝ)
+    (gradW : PhysSpace d → PhysSpace d)
+    (hgradW : ∀ x, gradW x = gradient W x)
+    (L : NNReal) (hL : LipschitzWith L gradW)
+    (f₀ : Measure (PhaseSpace d)) [IsProbabilityMeasure f₀]
+    (hf₀_int : Integrable (fun z : PhaseSpace d => ‖z‖) f₀)
+    {T : ℝ} (hT : 0 < T)
+    (hTL_PL : LocalSmallnessPLBuffer L T)
+    (m : ℝ → ℝ) (hm_mono : MonotoneOn m (Set.Icc 0 T))
+    (hm_nn : ∀ t ∈ Set.Icc (0 : ℝ) T, 0 ≤ m t)
+    (hm_inv : ∀ t ∈ Set.Icc (0 : ℝ) T,
+      gronwallBound (∫ z, ‖z‖ ∂f₀) (1 + (L : ℝ)) (‖gradW 0‖ + (L : ℝ) * m t) t ≤ m t)
+    (hMbar_nn : 0 ≤ m T) (hMbar_mono : ∀ t ∈ Set.Icc (0 : ℝ) T, m t ≤ m T)
+    (hμ₀_prob : IsProbabilityMeasure (spatialMarginal f₀))
+    (hμ₀_int : Integrable (fun y : PhysSpace d => ‖y‖) (spatialMarginal f₀))
+    (hμ₀_le_m : ∀ t ∈ Set.Icc (0 : ℝ) T, ∫ y, ‖y‖ ∂(spatialMarginal f₀) ≤ m t)
+    (q : ℝ) (hq_nn : 0 ≤ q)
+    (hq_def : q = gronwallBound 0 ((max 1 L : NNReal) : ℝ) (L : ℝ) T)
+    (D₀ : ℝ) (hD₀_nn : 0 ≤ D₀) (hD₀_def : D₀ = 2 * (m T)) :
+    ∃ (x : ℕ → VlasovMeasureCurve d T m)
+      (charXs charVs : ℕ → ℝ → PhaseSpace d → PhysSpace d),
+      (∀ k, supW1On (Set.Icc 0 T) (x k).ρ (x (k + 1)).ρ ≤
+            ENNReal.ofReal (q ^ k * D₀)) ∧
+      (∀ k,
+        IsCharacteristicFlowOn gradW (x k).extend (charXs k) (charVs k)
+          (Set.Ioo 0 T) Set.univ ∧
+        (∀ z : PhaseSpace d, ∀ t ∈ Set.Icc (0 : ℝ) T,
+          HasDerivWithinAt (fun s => charXs k s z) (charVs k t z) (Set.Icc 0 T) t ∧
+          HasDerivWithinAt (fun s => charVs k s z)
+            (-(convolveFunctionMeasure gradW ((x k).extend t) (charXs k t z)))
+            (Set.Icc 0 T) t) ∧
+        (∀ t ∈ Set.Icc (0 : ℝ) T,
+          (x (k + 1)).ρ t
+            = Measure.map (fun z : PhaseSpace d => charXs k t z) f₀)) := by
+  have h_int_ext_gen : ∀ (ν : VlasovMeasureCurve d T m) (t : ℝ) (xp : PhysSpace d),
+      Integrable (fun y => gradW (xp - y)) (ν.extend t) := fun ν t xp =>
+    integrable_gradW_shift gradW L hL (ν.extend t)
+      (VlasovMeasureCurve.extend_yIntegrable hT.le ν t) xp
+  have step : ∀ (ν : VlasovMeasureCurve d T m),
+      ∃ (σ : VlasovMeasureCurve d T m) (cX cV : ℝ → PhaseSpace d → PhysSpace d),
+        (∀ t ∈ Set.Icc (0 : ℝ) T, σ.ρ t = Measure.map (fun z => cX t z) f₀) ∧
+        IsCharacteristicFlowOn gradW ν.extend cX cV (Set.Ioo 0 T) Set.univ ∧
+        (∀ z : PhaseSpace d, ∀ t ∈ Set.Icc (0 : ℝ) T,
+          HasDerivWithinAt (fun s => cX s z) (cV t z) (Set.Icc 0 T) t ∧
+          HasDerivWithinAt (fun s => cV s z)
+            (-(convolveFunctionMeasure gradW (ν.extend t) (cX t z))) (Set.Icc 0 T) t) := by
+    intro ν
+    obtain ⟨cX, cV, hflow, hbdry, σ, hσ⟩ :=
+      Phi_step_envelope W gradW hgradW L hL f₀ hf₀_int hT.le m hm_mono hm_nn hm_inv hTL_PL
+        ν (h_int_ext_gen ν)
+    exact ⟨σ, cX, cV, hσ, hflow, hbdry⟩
+  have hμ₀_prob_inst : IsProbabilityMeasure (spatialMarginal f₀) := hμ₀_prob
+  let base : VlasovMeasureCurve d T m := constantCurve (spatialMarginal f₀) hμ₀_int hμ₀_le_m
+  let x : ℕ → VlasovMeasureCurve d T m :=
+    fun n => Nat.rec base (fun _ ν => Classical.choose (step ν)) n
+  let charXs : ℕ → ℝ → PhaseSpace d → PhysSpace d :=
+    fun k => Classical.choose (Classical.choose_spec (step (x k)))
+  let charVs : ℕ → ℝ → PhaseSpace d → PhysSpace d :=
+    fun k => Classical.choose (Classical.choose_spec (Classical.choose_spec (step (x k))))
+  have hx_succ : ∀ k, x (k + 1) = Classical.choose (step (x k)) := fun _ => rfl
+  have hspec : ∀ k,
+      (∀ t ∈ Set.Icc (0 : ℝ) T,
+        (Classical.choose (step (x k))).ρ t = Measure.map (fun z => charXs k t z) f₀) ∧
+      IsCharacteristicFlowOn gradW (x k).extend (charXs k) (charVs k)
+        (Set.Ioo 0 T) Set.univ ∧
+      (∀ z : PhaseSpace d, ∀ t ∈ Set.Icc (0 : ℝ) T,
+        HasDerivWithinAt (fun s => charXs k s z) (charVs k t z) (Set.Icc 0 T) t ∧
+        HasDerivWithinAt (fun s => charVs k s z)
+          (-(convolveFunctionMeasure gradW ((x k).extend t) (charXs k t z)))
+          (Set.Icc 0 T) t) :=
+    fun k => Classical.choose_spec
+      (Classical.choose_spec (Classical.choose_spec (step (x k))))
+  have h_flow : ∀ k,
+      IsCharacteristicFlowOn gradW (x k).extend (charXs k) (charVs k)
+        (Set.Ioo 0 T) Set.univ ∧
+      (∀ z : PhaseSpace d, ∀ t ∈ Set.Icc (0 : ℝ) T,
+        HasDerivWithinAt (fun s => charXs k s z) (charVs k t z) (Set.Icc 0 T) t ∧
+        HasDerivWithinAt (fun s => charVs k s z)
+          (-(convolveFunctionMeasure gradW ((x k).extend t) (charXs k t z)))
+          (Set.Icc 0 T) t) ∧
+      (∀ t ∈ Set.Icc (0 : ℝ) T,
+        (x (k + 1)).ρ t = Measure.map (fun z : PhaseSpace d => charXs k t z) f₀) := by
+    intro k
+    obtain ⟨hpush, hcf, hbd⟩ := hspec k
+    refine ⟨hcf, hbd, fun t ht => ?_⟩
+    rw [hx_succ k]; exact hpush t ht
+  have hCI : ∀ k,
+      (∀ t ∈ Set.Icc (0 : ℝ) T, AEMeasurable (fun z : PhaseSpace d => charXs k t z) f₀) ∧
+      (∀ t ∈ Set.Icc (0 : ℝ) T, Integrable (fun z : PhaseSpace d => ‖charXs k t z‖) f₀) ∧
+      (∀ t ∈ Set.Icc (0 : ℝ) T,
+        Integrable (fun y : PhysSpace d => ‖y‖) (Measure.map (fun z => charXs k t z) f₀)) ∧
+      (∀ z : PhaseSpace d, (charXs k 0 z, charVs k 0 z) = z) ∧
+      (∀ z : PhaseSpace d,
+        ContinuousOn (fun s => (charXs k s z, charVs k s z)) (Set.Icc (0 : ℝ) T)) ∧
+      (∀ z : PhaseSpace d, ∀ s ∈ Set.Ico (0 : ℝ) T,
+        HasDerivWithinAt (fun s' => (charXs k s' z, charVs k s' z))
+          (vlasovVectorField gradW ((x k).extend) s (charXs k s z, charVs k s z))
+          (Set.Ici s) s) :=
+    fun k => envelopeStep_contractionInputs gradW L hL f₀ hf₀_int hT.le (x k) (m T) hMbar_nn
+      (fun t _ => le_trans (VlasovMeasureCurve.extend_hasMoment hT.le (x k) t)
+        (hMbar_mono (clampToIcc T t) (clampToIcc_mem hT.le t)))
+      (charXs k) (charVs k) (h_flow k).1 (h_flow k).2.1 (h_int_ext_gen (x k))
+  have hK_ne : ((max 1 L : NNReal) : ℝ) ≠ 0 := by
+    have h1 : (1:ℝ) ≤ ((max 1 L : NNReal):ℝ) := by
+      rw [NNReal.coe_max, NNReal.coe_one]; exact le_max_left _ _
+    linarith
+  have hq_scale : ∀ D : ℝ,
+      gronwallBound 0 ((max 1 L : NNReal):ℝ) ((L:ℝ)*D) T = D * q := by
+    intro D
+    rw [hq_def, gronwallBound_of_K_ne_0 hK_ne, gronwallBound_of_K_ne_0 hK_ne]; ring
+  have hPext : ∀ (ν : VlasovMeasureCurve d T m) (t : ℝ),
+      IsProbabilityMeasure (ν.extend t) :=
+    fun ν => VlasovMeasureCurve.extend_isProb ν
+  have h_contract : ∀ k, supW1On (Set.Icc 0 T) (x k).ρ (x (k + 1)).ρ ≤
+      ENNReal.ofReal (q ^ k * D₀) := by
+    intro k
+    induction k with
+    | zero =>
+      simp only [pow_zero, one_mul]
+      rw [hD₀_def]
+      exact supW1On_le_two_moment_of_VlasovMeasureCurve (m T) hMbar_mono (x 0) (x 1)
+    | succ k ih =>
+      set D : ℝ := q ^ k * D₀ with hD_def
+      have hD_nn : 0 ≤ D := mul_nonneg (pow_nonneg hq_nn k) hD₀_nn
+      have he : ∀ (ν : VlasovMeasureCurve d T m) s, s ∈ Set.Icc (0 : ℝ) T → ν.extend s = ν.ρ s := by
+        intro ν s hs
+        unfold VlasovMeasureCurve.extend clampToIcc; congr 1
+        rw [min_eq_left hs.2, max_eq_right hs.1]
+      have h_W1_fin : ∀ s ∈ Set.Icc (0 : ℝ) T,
+          wasserstein1 ((x k).extend s) ((x (k+1)).extend s) ≠ ⊤ := by
+        intro s hs
+        rw [he (x k) s hs, he (x (k+1)) s hs]
+        have := (x k).isProb s; have := (x (k+1)).isProb s
+        exact wasserstein1_ne_top_of_finite_moment _ _
+          ((x k).yIntegrable s hs) ((x (k+1)).yIntegrable s hs)
+      have h_W1_bound : ∀ s ∈ Set.Icc (0 : ℝ) T,
+          (wasserstein1 ((x k).extend s) ((x (k+1)).extend s)).toReal ≤ D := by
+        intro s hs
+        rw [he (x k) s hs, he (x (k+1)) s hs]
+        have h_le : wasserstein1 ((x k).ρ s) ((x (k+1)).ρ s)
+            ≤ ENNReal.ofReal D :=
+          le_trans (wasserstein1_le_supW1On _ _ _ s hs) ih
+        have h_ne : wasserstein1 ((x k).ρ s) ((x (k+1)).ρ s) ≠ ⊤ := by
+          have := (x k).isProb s; have := (x (k+1)).isProb s
+          exact wasserstein1_ne_top_of_finite_moment _ _
+            ((x k).yIntegrable s hs) ((x (k+1)).yIntegrable s hs)
+        calc (wasserstein1 ((x k).ρ s) ((x (k+1)).ρ s)).toReal
+            ≤ (ENNReal.ofReal D).toReal := ENNReal.toReal_mono ENNReal.ofReal_ne_top h_le
+          _ = D := ENNReal.toReal_ofReal hD_nn
+      have h_contr := @Phi_supW1_contraction d gradW L hL ((x k).extend) ((x (k+1)).extend)
+        (hPext (x k)) (hPext (x (k+1)))
+        (h_int_ext_gen (x k)) (h_int_ext_gen (x (k+1))) T hT.le D hD_nn h_W1_fin h_W1_bound
+        (charXs k) (charVs k) (charXs (k+1)) (charVs (k+1)) f₀ _
+        (hCI k).1 (hCI (k+1)).1 (hCI k).2.1 (hCI (k+1)).2.1
+        (hCI k).2.2.1 (hCI (k+1)).2.2.1 (hCI k).2.2.2.1 (hCI (k+1)).2.2.2.1
+        (hCI k).2.2.2.2.1 (hCI (k+1)).2.2.2.2.1 (hCI k).2.2.2.2.2 (hCI (k+1)).2.2.2.2.2
+      rw [hq_scale D] at h_contr
+      have h_supW1_eq : supW1On (Set.Icc 0 T) (x (k+1)).ρ (x (k+1+1)).ρ
+          = supW1On (Set.Icc 0 T)
+              (fun t => Measure.map (fun z => charXs k t z) f₀)
+              (fun t => Measure.map (fun z => charXs (k+1) t z) f₀) := by
+        unfold supW1On
+        exact iSup_congr fun t => iSup_congr fun ht => by
+          rw [(h_flow k).2.2 t ht, (h_flow (k+1)).2.2 t ht]
+      have hDq : D * q = q ^ (k + 1) * D₀ := by rw [hD_def, pow_succ]; ring
+      rw [hDq] at h_contr
+      have h_ne_top : supW1On (Set.Icc 0 T)
+          (fun t => Measure.map (fun z => charXs k t z) f₀)
+          (fun t => Measure.map (fun z => charXs (k+1) t z) f₀) ≠ ⊤ := by
+        rw [← h_supW1_eq]
+        exact supW1On_ne_top_of_VlasovMeasureCurve (m T) hMbar_mono (x (k+1)) (x (k+1+1))
+      have h_pow_nn : 0 ≤ q ^ (k + 1) * D₀ := mul_nonneg (pow_nonneg hq_nn _) hD₀_nn
+      rw [h_supW1_eq]
+      rw [← ENNReal.toReal_le_toReal h_ne_top ENNReal.ofReal_ne_top,
+          ENNReal.toReal_ofReal h_pow_nn]
+      exact h_contr
+  exact ⟨x, charXs, charVs, h_contract, h_flow⟩
+
+/-- Pointwise contraction of the Picard step between an iterate and the limit
+curve: the pushforwards under the two flows are `D·q`-close whenever the curves
+are uniformly `D`-close in `W₁`.  Wraps `Phi_pointwise_contraction` +
+`gronwallBound` monotonicity for a single curve pair. -/
+private lemma picardLimit_flow_pointwise_contraction
+    {d : ℕ} [NeZero d]
+    (gradW : PhysSpace d → PhysSpace d)
+    (L : NNReal) (hL : LipschitzWith L gradW)
+    (f₀ : Measure (PhaseSpace d)) [IsProbabilityMeasure f₀]
+    (hf₀_int : Integrable (fun z : PhaseSpace d => ‖z‖) f₀)
+    {T : ℝ} (hT : 0 < T)
+    (m : ℝ → ℝ) (hMbar_nn : 0 ≤ m T)
+    (hMbar_mono : ∀ t ∈ Set.Icc (0 : ℝ) T, m t ≤ m T)
+    (ν ρl : VlasovMeasureCurve d T m)
+    (cX cV charX charV : ℝ → PhaseSpace d → PhysSpace d)
+    (hflow_ν : IsCharacteristicFlowOn gradW ν.extend cX cV (Set.Ioo 0 T) Set.univ)
+    (hbdry_ν : ∀ z : PhaseSpace d, ∀ t ∈ Set.Icc (0 : ℝ) T,
+      HasDerivWithinAt (fun s => cX s z) (cV t z) (Set.Icc 0 T) t ∧
+      HasDerivWithinAt (fun s => cV s z)
+        (-(convolveFunctionMeasure gradW (ν.extend t) (cX t z))) (Set.Icc 0 T) t)
+    (hflow_l : IsCharacteristicFlowOn gradW ρl.extend charX charV (Set.Ioo 0 T) Set.univ)
+    (hbdry_l : ∀ z : PhaseSpace d, ∀ t ∈ Set.Icc (0 : ℝ) T,
+      HasDerivWithinAt (fun s => charX s z) (charV t z) (Set.Icc 0 T) t ∧
+      HasDerivWithinAt (fun s => charV s z)
+        (-(convolveFunctionMeasure gradW (ρl.extend t) (charX t z))) (Set.Icc 0 T) t)
+    (D : ℝ) (hD_nn : 0 ≤ D)
+    (h_W1_fin : ∀ s ∈ Set.Icc (0 : ℝ) T, wasserstein1 (ν.extend s) (ρl.extend s) ≠ ⊤)
+    (h_W1_bound : ∀ s ∈ Set.Icc (0 : ℝ) T,
+      (wasserstein1 (ν.extend s) (ρl.extend s)).toReal ≤ D)
+    (q : ℝ) (hq_def : q = gronwallBound 0 ((max 1 L : NNReal) : ℝ) (L : ℝ) T) :
+    ∀ t ∈ Set.Icc (0 : ℝ) T,
+      (wasserstein1 (Measure.map (fun z => cX t z) f₀)
+                    (Measure.map (fun z => charX t z) f₀)).toReal ≤ D * q := by
+  have hK_ge1 : (1 : ℝ) ≤ ((max 1 L : NNReal) : ℝ) := by
+    rw [NNReal.coe_max, NNReal.coe_one]; exact le_max_left _ _
+  have hK_ne : ((max 1 L : NNReal) : ℝ) ≠ 0 := ne_of_gt (by linarith)
+  have hK_pos : (0 : ℝ) ≤ ((max 1 L : NNReal) : ℝ) := by linarith
+  have hMm : ∀ (μ : VlasovMeasureCurve d T m), ∀ t ∈ Set.Icc (0 : ℝ) T,
+      ∫ y, ‖y‖ ∂(μ.extend t) ≤ m T :=
+    fun μ t _ => le_trans (VlasovMeasureCurve.extend_hasMoment hT.le μ t)
+      (hMbar_mono (clampToIcc T t) (clampToIcc_mem hT.le t))
+  have h_int_ν : ∀ t (xp : PhysSpace d),
+      Integrable (fun y => gradW (xp - y)) (ν.extend t) := fun t xp =>
+    integrable_gradW_shift gradW L hL (ν.extend t)
+      (VlasovMeasureCurve.extend_yIntegrable hT.le ν t) xp
+  have h_int_l : ∀ t (xp : PhysSpace d),
+      Integrable (fun y => gradW (xp - y)) (ρl.extend t) := fun t xp =>
+    integrable_gradW_shift gradW L hL (ρl.extend t)
+      (VlasovMeasureCurve.extend_yIntegrable hT.le ρl t) xp
+  have hCI_ν := envelopeStep_contractionInputs gradW L hL f₀ hf₀_int hT.le ν
+    (m T) hMbar_nn (hMm ν) cX cV hflow_ν hbdry_ν h_int_ν
+  have hCI_l := envelopeStep_contractionInputs gradW L hL f₀ hf₀_int hT.le ρl
+    (m T) hMbar_nn (hMm ρl) charX charV hflow_l hbdry_l h_int_l
+  have hq_scale : gronwallBound 0 ((max 1 L : NNReal) : ℝ) ((L:ℝ) * D) T = D * q := by
+    rw [hq_def, gronwallBound_of_K_ne_0 hK_ne, gronwallBound_of_K_ne_0 hK_ne]; ring
+  intro t ht
+  have hpt := @Phi_pointwise_contraction d gradW L hL (ν.extend) (ρl.extend)
+    (VlasovMeasureCurve.extend_isProb ν) (VlasovMeasureCurve.extend_isProb ρl)
+    h_int_ν h_int_l T hT.le D hD_nn h_W1_fin h_W1_bound
+    cX cV charX charV f₀ _
+    hCI_ν.1 hCI_l.1 hCI_ν.2.1 hCI_l.2.1
+    hCI_ν.2.2.2.1 hCI_l.2.2.2.1 hCI_ν.2.2.2.2.1 hCI_l.2.2.2.2.1
+    hCI_ν.2.2.2.2.2 hCI_l.2.2.2.2.2 t ht
+  have h_mono : gronwallBound 0 ((max 1 L : NNReal) : ℝ) ((L:ℝ) * D) t
+      ≤ gronwallBound 0 ((max 1 L : NNReal) : ℝ) ((L:ℝ) * D) T :=
+    gronwallBound_mono (le_refl 0) (mul_nonneg L.coe_nonneg hD_nn) hK_pos ht.2
+  rw [hq_scale] at h_mono
+  exact le_trans hpt h_mono
+
+/-- The Picard fixed-point equation at the limit: if the iterates converge to the
+limit curve in `W₁` and each step's pushforward is `Dₙ·q`-close to the limit
+flow's pushforward with `Dₙ·q → 0`, the limit curve equals the limit flow's
+pushforward.  Triangle through the iterates + the `W₁` separation lemma. -/
+private lemma picardLimit_fixed_point_eq
+    {d : ℕ} [NeZero d]
+    (f₀ : Measure (PhaseSpace d)) [IsProbabilityMeasure f₀]
+    {T : ℝ}
+    (m : ℝ → ℝ) (x : ℕ → VlasovMeasureCurve d T m) (ρl : VlasovMeasureCurve d T m)
+    (charXs : ℕ → ℝ → PhaseSpace d → PhysSpace d)
+    (charX : ℝ → PhaseSpace d → PhysSpace d)
+    (h_push : ∀ n, ∀ t ∈ Set.Icc (0 : ℝ) T,
+      (x (n + 1)).ρ t = Measure.map (fun z : PhaseSpace d => charXs n t z) f₀)
+    (h_tendsto : ∀ t ∈ Set.Icc (0 : ℝ) T,
+      Filter.Tendsto (fun n => wasserstein1 ((x n).ρ t) (ρl.ρ t)) Filter.atTop (nhds 0))
+    (h_aem_n : ∀ n, ∀ t ∈ Set.Icc (0 : ℝ) T,
+      AEMeasurable (fun z : PhaseSpace d => charXs n t z) f₀)
+    (h_aem_lim : ∀ t ∈ Set.Icc (0 : ℝ) T,
+      AEMeasurable (fun z : PhaseSpace d => charX t z) f₀)
+    (h_mom_n : ∀ n, ∀ t ∈ Set.Icc (0 : ℝ) T,
+      Integrable (fun y : PhysSpace d => ‖y‖) (Measure.map (fun z => charXs n t z) f₀))
+    (h_mom_lim : ∀ t ∈ Set.Icc (0 : ℝ) T,
+      Integrable (fun y : PhysSpace d => ‖y‖) (Measure.map (fun z => charX t z) f₀))
+    (Dn : ℕ → ℝ) (q : ℝ)
+    (hDnq_tendsto : Filter.Tendsto (fun n => Dn n * q) Filter.atTop (nhds 0))
+    (h_term2 : ∀ n t, t ∈ Set.Icc (0 : ℝ) T →
+      (wasserstein1 (Measure.map (fun z => charXs n t z) f₀)
+                    (Measure.map (fun z => charX t z) f₀)).toReal ≤ Dn n * q) :
+    ∀ t ∈ Set.Icc (0 : ℝ) T, ρl.ρ t = Measure.map (fun z => charX t z) f₀ := by
+  intro t ht
+  have hP1 : IsProbabilityMeasure (ρl.ρ t) := ρl.isProb t
+  have hP2 : IsProbabilityMeasure (Measure.map (fun z => charX t z) f₀) :=
+    (Measure.isProbabilityMeasure_map_iff (h_aem_lim t ht)).mpr inferInstance
+  refine (wasserstein1_eq_zero_iff_measure_eq (ρl.ρ t)
+    (Measure.map (fun z => charX t z) f₀)).mp ?_
+  have h_le_seq : ∀ n, wasserstein1 (ρl.ρ t) (Measure.map (fun z => charX t z) f₀)
+      ≤ wasserstein1 ((x (n+1)).ρ t) (ρl.ρ t) + ENNReal.ofReal (Dn n * q) := by
+    intro n
+    have h_mid : (x (n+1)).ρ t = Measure.map (fun z => charXs n t z) f₀ := h_push n t ht
+    calc wasserstein1 (ρl.ρ t) (Measure.map (fun z => charX t z) f₀)
+        ≤ wasserstein1 (ρl.ρ t) ((x (n+1)).ρ t)
+            + wasserstein1 ((x (n+1)).ρ t) (Measure.map (fun z => charX t z) f₀) :=
+          wasserstein1_triangle _ _ _
+      _ = wasserstein1 ((x (n+1)).ρ t) (ρl.ρ t)
+            + wasserstein1 ((x (n+1)).ρ t) (Measure.map (fun z => charX t z) f₀) := by
+          rw [wasserstein1_comm (ρl.ρ t) ((x (n+1)).ρ t)]
+      _ ≤ wasserstein1 ((x (n+1)).ρ t) (ρl.ρ t) + ENNReal.ofReal (Dn n * q) := by
+          gcongr
+          rw [h_mid]
+          have h_fin : wasserstein1 (Measure.map (fun z => charXs n t z) f₀)
+              (Measure.map (fun z => charX t z) f₀) ≠ ⊤ := by
+            have : IsProbabilityMeasure (Measure.map (fun z => charXs n t z) f₀) :=
+              (Measure.isProbabilityMeasure_map_iff (h_aem_n n t ht)).mpr inferInstance
+            exact wasserstein1_ne_top_of_finite_moment _ _
+              (h_mom_n n t ht) (h_mom_lim t ht)
+          rw [← ENNReal.ofReal_toReal h_fin]
+          exact ENNReal.ofReal_le_ofReal (h_term2 n t ht)
+  have hA : Filter.Tendsto (fun n => wasserstein1 ((x (n+1)).ρ t) (ρl.ρ t))
+      Filter.atTop (nhds 0) :=
+    (h_tendsto t ht).comp (Filter.tendsto_add_atTop_nat 1)
+  have hB : Filter.Tendsto (fun n => ENNReal.ofReal (Dn n * q)) Filter.atTop (nhds 0) := by
+    have := (ENNReal.continuous_ofReal.tendsto 0).comp hDnq_tendsto
+    simpa [Function.comp_def] using this
+  have h_seq : Filter.Tendsto
+      (fun n => wasserstein1 ((x (n+1)).ρ t) (ρl.ρ t) + ENNReal.ofReal (Dn n * q))
+      Filter.atTop (nhds 0) := by
+    have := hA.add hB
+    simpa using this
+  exact le_antisymm (ge_of_tendsto' h_seq h_le_seq) (zero_le)
+
+/-- Bundle the self-consistent Picard-limit flow, CLAMPED to the window, into the
+seven-conjunct conclusion of `vlasovWellPosedness_local_picard_fixedPointFlow`.
+The raw flow is controlled only on `[0, T]`; clamping (`clampToIcc`) makes every
+universal-in-`s` conjunct reduce to the window, where the clamp is the identity. -/
+private lemma picardFlow_clamp_bundle
+    {d : ℕ} [NeZero d]
+    (gradW : PhysSpace d → PhysSpace d)
+    (L : NNReal) (hL : LipschitzWith L gradW)
+    (f₀ : Measure (PhaseSpace d))
+    {T : ℝ} (hT : 0 < T)
+    (m : ℝ → ℝ) (hMbar_nn : 0 ≤ m T)
+    (hMbar_mono : ∀ t ∈ Set.Icc (0 : ℝ) T, m t ≤ m T)
+    (ρ_lim : VlasovMeasureCurve d T m)
+    (charX charV : ℝ → PhaseSpace d → PhysSpace d)
+    (hflow_on_ρlim : IsCharacteristicFlowOn gradW ρ_lim.extend charX charV
+      (Set.Ioo 0 T) Set.univ)
+    (h_boundary_ρlim : ∀ z : PhaseSpace d, ∀ t ∈ Set.Icc (0 : ℝ) T,
+      HasDerivWithinAt (fun s => charX s z) (charV t z) (Set.Icc 0 T) t ∧
+      HasDerivWithinAt (fun s => charV s z)
+        (-(convolveFunctionMeasure gradW (ρ_lim.extend t) (charX t z))) (Set.Icc 0 T) t)
+    (h_int_ρ_lim : ∀ t (x_pt : PhysSpace d),
+      Integrable (fun y => gradW (x_pt - y)) (ρ_lim.extend t))
+    (h_self_consist : ∀ t ∈ Set.Icc (0 : ℝ) T,
+      ρ_lim.extend t =
+      spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ t)) :
+    ∃ (charX' charV' : ℝ → PhaseSpace d → PhysSpace d) (M_ρ : ℝ), 0 ≤ M_ρ ∧
+      IsCharacteristicFlowOn gradW
+        (fun t => spatialMarginal (vlasovSolutionViaPushforward charX' charV' f₀ t))
+        charX' charV' (Set.Ioo 0 T) Set.univ ∧
+      (∀ z : PhaseSpace d, ∀ t ∈ Set.Icc (0 : ℝ) T,
+        HasDerivWithinAt (fun s => charX' s z) (charV' t z) (Set.Icc 0 T) t ∧
+        HasDerivWithinAt (fun s => charV' s z)
+          (-(convolveFunctionMeasure gradW
+              (spatialMarginal (vlasovSolutionViaPushforward charX' charV' f₀ t))
+              (charX' t z)))
+          (Set.Icc 0 T) t) ∧
+      (∀ s ∈ Set.Icc (0 : ℝ) T,
+        ∫ y, ‖y‖ ∂(spatialMarginal (vlasovSolutionViaPushforward charX' charV' f₀ s)) ≤ M_ρ) ∧
+      (∀ s ∈ Set.Icc (0 : ℝ) T,
+        Integrable (fun y : PhysSpace d => ‖y‖)
+          (spatialMarginal (vlasovSolutionViaPushforward charX' charV' f₀ s))) ∧
+      (∀ s, Continuous (fun x =>
+        convolveFunctionMeasure gradW
+          (spatialMarginal (vlasovSolutionViaPushforward charX' charV' f₀ s)) x)) ∧
+      (∀ s, AEMeasurable (fun z : PhaseSpace d => (charX' s z, charV' s z)) f₀) ∧
+      (∀ s (x : PhysSpace d),
+        Integrable (fun y => gradW (x - y))
+          (spatialMarginal (vlasovSolutionViaPushforward charX' charV' f₀ s))) := by
+  have hclamp_id : ∀ s ∈ Set.Icc (0 : ℝ) T, clampToIcc T s = s := fun s hs => by
+    unfold clampToIcc; rw [min_eq_left hs.2, max_eq_right hs.1]
+  have hclamp0 : clampToIcc T 0 = 0 := hclamp_id 0 ⟨le_refl 0, hT.le⟩
+  have h_rho_clamp : ∀ s : ℝ,
+      spatialMarginal (vlasovSolutionViaPushforward
+        (fun s' z => charX (clampToIcc T s') z)
+        (fun s' z => charV (clampToIcc T s') z) f₀ s) =
+      ρ_lim.extend (clampToIcc T s) := by
+    intro s
+    have h1 : spatialMarginal (vlasovSolutionViaPushforward
+        (fun s' z => charX (clampToIcc T s') z)
+        (fun s' z => charV (clampToIcc T s') z) f₀ s) =
+        spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ (clampToIcc T s)) :=
+      rfl
+    rw [h1, ← h_self_consist (clampToIcc T s) (clampToIcc_mem hT.le s)]
+  refine ⟨fun s z => charX (clampToIcc T s) z, fun s z => charV (clampToIcc T s) z,
+    m T, hMbar_nn, ?_, ?_, ?_, ?_, ?_, ?_, ?_⟩
+  · refine ⟨fun z _hz => ?_, fun t ht z _hz => ?_, fun t ht z _hz => ?_⟩
+    · change charX (clampToIcc T 0) z = z.1 ∧ charV (clampToIcc T 0) z = z.2
+      rw [hclamp0]; exact hflow_on_ρlim.1 z (Set.mem_univ z)
+    · have hEv : (fun s => charX (clampToIcc T s) z) =ᶠ[nhds t]
+          (fun s => charX s z) := by
+        filter_upwards [Ioo_mem_nhds ht.1 ht.2] with s hs
+        rw [hclamp_id s (Set.Ioo_subset_Icc_self hs)]
+      change HasDerivAt (fun s => charX (clampToIcc T s) z) (charV (clampToIcc T t) z) t
+      rw [hclamp_id t (Set.Ioo_subset_Icc_self ht)]
+      exact (hflow_on_ρlim.2.1 t ht z (Set.mem_univ z)).congr_of_eventuallyEq hEv
+    · have hEv : (fun s => charV (clampToIcc T s) z) =ᶠ[nhds t]
+          (fun s => charV s z) := by
+        filter_upwards [Ioo_mem_nhds ht.1 ht.2] with s hs
+        rw [hclamp_id s (Set.Ioo_subset_Icc_self hs)]
+      change HasDerivAt (fun s => charV (clampToIcc T s) z)
+        (-(convolveFunctionMeasure gradW
+            (spatialMarginal (vlasovSolutionViaPushforward
+              (fun s' z' => charX (clampToIcc T s') z')
+              (fun s' z' => charV (clampToIcc T s') z') f₀ t))
+            (charX (clampToIcc T t) z))) t
+      rw [h_rho_clamp t, hclamp_id t (Set.Ioo_subset_Icc_self ht)]
+      exact (hflow_on_ρlim.2.2 t ht z (Set.mem_univ z)).congr_of_eventuallyEq hEv
+  · intro z t ht
+    have hEqOn : Set.EqOn (fun s => charX (clampToIcc T s) z) (fun s => charX s z)
+        (Set.Icc 0 T) := fun s hs => by
+      change charX (clampToIcc T s) z = charX s z; rw [hclamp_id s hs]
+    have hEqOnV : Set.EqOn (fun s => charV (clampToIcc T s) z) (fun s => charV s z)
+        (Set.Icc 0 T) := fun s hs => by
+      change charV (clampToIcc T s) z = charV s z; rw [hclamp_id s hs]
+    obtain ⟨h1, h2⟩ := h_boundary_ρlim z t ht
+    refine ⟨?_, ?_⟩
+    · change HasDerivWithinAt (fun s => charX (clampToIcc T s) z)
+        (charV (clampToIcc T t) z) (Set.Icc 0 T) t
+      rw [hclamp_id t ht]
+      exact h1.congr hEqOn (hEqOn ht)
+    · change HasDerivWithinAt (fun s => charV (clampToIcc T s) z)
+        (-(convolveFunctionMeasure gradW
+            (spatialMarginal (vlasovSolutionViaPushforward
+              (fun s' z' => charX (clampToIcc T s') z')
+              (fun s' z' => charV (clampToIcc T s') z') f₀ t))
+            (charX (clampToIcc T t) z))) (Set.Icc 0 T) t
+      rw [h_rho_clamp t, hclamp_id t ht]
+      exact h2.congr hEqOnV (hEqOnV ht)
+  · intro s hs
+    rw [h_rho_clamp s, hclamp_id s hs]
+    exact le_trans (VlasovMeasureCurve.extend_hasMoment hT.le ρ_lim s)
+      (hMbar_mono (clampToIcc T s) (clampToIcc_mem hT.le s))
+  · intro s hs
+    rw [h_rho_clamp s, hclamp_id s hs]
+    exact VlasovMeasureCurve.extend_yIntegrable hT.le ρ_lim s
+  · intro s
+    rw [h_rho_clamp s]
+    have : IsProbabilityMeasure (ρ_lim.extend (clampToIcc T s)) :=
+      VlasovMeasureCurve.extend_isProb ρ_lim (clampToIcc T s)
+    exact (convolveFunctionMeasure_lipschitz_in_x gradW L hL
+      (ρ_lim.extend (clampToIcc T s)) (h_int_ρ_lim (clampToIcc T s))).continuous
+  · intro s
+    exact picardCharFlow_aemeasurable gradW L hL ρ_lim.extend h_int_ρ_lim charX charV hT.le
+      hflow_on_ρlim h_boundary_ρlim f₀ (clampToIcc T s) (clampToIcc_mem hT.le s)
+  · intro s x
+    rw [h_rho_clamp s]
+    exact h_int_ρ_lim (clampToIcc T s) x
+
+/-- **Sub-helper for `_picard_fixedPointFlow`** — the Picard fixed-point
+self-consistency equation.  For `t ∈ Icc 0 T`,
+
+`ρ_lim.extend t = spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ t)`,
+
+proved by the triangle through the iterates `x n`: the marginal-vs-limit leg
+tends to `0` by `h_tendsto`, the flow-pushforward leg is `≤ Dn n · q` by the
+pointwise contraction `picardLimit_flow_pointwise_contraction` (with
+`Dn n := (supW1On (Icc 0 T) (x n).ρ ρ_lim.ρ).toReal → 0` from the
+supW1On-Cauchy structure), and `picardLimit_fixed_point_eq` closes.  The
+contraction ratio `q` is threaded by its defining equation `hq_def`
+(let-bound parent supplies `rfl`). -/
+private lemma picardLimit_self_consistency
+    {d : ℕ} [NeZero d]
+    (gradW : PhysSpace d → PhysSpace d)
+    (L : NNReal) (hL : LipschitzWith L gradW)
+    (f₀ : Measure (PhaseSpace d)) [IsProbabilityMeasure f₀]
+    (hf₀_int : Integrable (fun z : PhaseSpace d => ‖z‖) f₀)
+    {T : ℝ} (hT : 0 < T)
+    (m : ℝ → ℝ) (hMbar_nn : 0 ≤ m T)
+    (hMbar_mono : ∀ t ∈ Set.Icc (0 : ℝ) T, m t ≤ m T)
+    (q : ℝ) (hq_nn : 0 ≤ q) (hq_lt : q < 1)
+    (hq_def : q = gronwallBound 0 ((max 1 L : NNReal) : ℝ) (L : ℝ) T)
+    (D₀ : ℝ) (hD₀_nn : 0 ≤ D₀)
+    (x : ℕ → VlasovMeasureCurve d T m)
+    (charXs charVs : ℕ → ℝ → PhaseSpace d → PhysSpace d)
+    (h_contract : ∀ k, supW1On (Set.Icc 0 T) (x k).ρ (x (k + 1)).ρ ≤
+      ENNReal.ofReal (q ^ k * D₀))
+    (h_flow : ∀ k,
+      IsCharacteristicFlowOn gradW (x k).extend (charXs k) (charVs k)
+        (Set.Ioo 0 T) Set.univ ∧
+      (∀ z : PhaseSpace d, ∀ t ∈ Set.Icc (0 : ℝ) T,
+        HasDerivWithinAt (fun s => charXs k s z) (charVs k t z) (Set.Icc 0 T) t ∧
+        HasDerivWithinAt (fun s => charVs k s z)
+          (-(convolveFunctionMeasure gradW ((x k).extend t) (charXs k t z)))
+          (Set.Icc 0 T) t) ∧
+      (∀ t ∈ Set.Icc (0 : ℝ) T,
+        (x (k + 1)).ρ t = Measure.map (fun z : PhaseSpace d => charXs k t z) f₀))
+    (ρ_lim : VlasovMeasureCurve d T m)
+    (h_tendsto : ∀ t ∈ Set.Icc (0 : ℝ) T,
+      Filter.Tendsto (fun n => wasserstein1 ((x n).ρ t) (ρ_lim.ρ t))
+        Filter.atTop (nhds 0))
+    (charX charV : ℝ → PhaseSpace d → PhysSpace d)
+    (hflow_on_ρlim : IsCharacteristicFlowOn gradW ρ_lim.extend charX charV
+      (Set.Ioo 0 T) Set.univ)
+    (h_boundary_ρlim : ∀ z : PhaseSpace d, ∀ t ∈ Set.Icc (0 : ℝ) T,
+      HasDerivWithinAt (fun s => charX s z) (charV t z) (Set.Icc 0 T) t ∧
+      HasDerivWithinAt (fun s => charV s z)
+        (-(convolveFunctionMeasure gradW (ρ_lim.extend t) (charX t z)))
+        (Set.Icc 0 T) t)
+    (h_int_ρ_lim : ∀ t (x_pt : PhysSpace d),
+      Integrable (fun y => gradW (x_pt - y)) (ρ_lim.extend t)) :
+    ∀ t ∈ Set.Icc (0 : ℝ) T,
+      ρ_lim.extend t =
+      spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ t) := by
+  have he : ∀ (ν : VlasovMeasureCurve d T m) s, s ∈ Set.Icc (0 : ℝ) T →
+      ν.extend s = ν.ρ s := by
+    intro ν s hs
+    unfold VlasovMeasureCurve.extend clampToIcc; congr 1
+    rw [min_eq_left hs.2, max_eq_right hs.1]
+  have hMm : ∀ (ν : VlasovMeasureCurve d T m), ∀ t ∈ Set.Icc (0 : ℝ) T,
+      ∫ y, ‖y‖ ∂(ν.extend t) ≤ m T :=
+    fun ν t _ => le_trans (VlasovMeasureCurve.extend_hasMoment hT.le ν t)
+      (hMbar_mono (clampToIcc T t) (clampToIcc_mem hT.le t))
+  have h_int_ext_gen : ∀ (ν : VlasovMeasureCurve d T m) (t : ℝ) (xp : PhysSpace d),
+      Integrable (fun y => gradW (xp - y)) (ν.extend t) := fun ν t xp =>
+    integrable_gradW_shift gradW L hL (ν.extend t)
+      (VlasovMeasureCurve.extend_yIntegrable hT.le ν t) xp
+  have hCI := fun k => envelopeStep_contractionInputs gradW L hL f₀ hf₀_int hT.le (x k)
+    (m T) hMbar_nn (hMm (x k)) (charXs k) (charVs k)
+    (h_flow k).1 (h_flow k).2.1 (h_int_ext_gen (x k))
+  have hCI_lim := envelopeStep_contractionInputs gradW L hL f₀ hf₀_int hT.le ρ_lim
+    (m T) hMbar_nn (hMm ρ_lim) charX charV hflow_on_ρlim h_boundary_ρlim h_int_ρ_lim
+  have h_marg : ∀ s ∈ Set.Icc (0 : ℝ) T,
+      spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ s)
+        = Measure.map (fun z => charX s z) f₀ := by
+    intro s hs
+    have h_pair_meas := charFlow_measurable_via_gronwall gradW L hL ρ_lim.extend h_int_ρ_lim
+      charX charV T hT.le hCI_lim.2.2.2.1 hCI_lim.2.2.2.2.1 hCI_lim.2.2.2.2.2 s hs
+    unfold spatialMarginal vlasovSolutionViaPushforward
+    rw [Measure.map_map measurable_fst h_pair_meas]
+    rfl
+  have h_cauchy := picard_iterate_isCauchy_of_contraction
+    (Set.Icc (0 : ℝ) T) (fun n => (x n).ρ) q hq_nn hq_lt D₀ hD₀_nn h_contract
+  have h_uniform := picard_iterate_limit_uniform_tendsto
+    (Set.Icc (0 : ℝ) T) (fun n => (x n).ρ) ρ_lim.ρ h_cauchy h_tendsto
+  have h_sup_ne_top : ∀ n, supW1On (Set.Icc 0 T) (x n).ρ ρ_lim.ρ ≠ ⊤ :=
+    fun n => supW1On_ne_top_of_VlasovMeasureCurve (m T) hMbar_mono (x n) ρ_lim
+  have h_sup_tendsto : Filter.Tendsto
+      (fun n => supW1On (Set.Icc 0 T) (x n).ρ ρ_lim.ρ) Filter.atTop (nhds 0) := by
+    rw [ENNReal.tendsto_atTop_zero]
+    intro ε hε
+    obtain ⟨N, hN⟩ := h_uniform ε hε
+    refine ⟨N, fun n hn => ?_⟩
+    unfold supW1On
+    exact iSup_le fun s => iSup_le fun hs => hN n hn s hs
+  set Dn : ℕ → ℝ := fun n => (supW1On (Set.Icc 0 T) (x n).ρ ρ_lim.ρ).toReal with hDn_def
+  have hDn_nn : ∀ n, 0 ≤ Dn n := fun n => ENNReal.toReal_nonneg
+  have hDn_tendsto : Filter.Tendsto Dn Filter.atTop (nhds 0) := by
+    have h := (ENNReal.tendsto_toReal (show (0:ENNReal) ≠ ⊤ by simp)).comp h_sup_tendsto
+    rw [ENNReal.toReal_zero] at h
+    exact h
+  have h_W1_fin_curve : ∀ n, ∀ s ∈ Set.Icc (0 : ℝ) T,
+      wasserstein1 ((x n).extend s) (ρ_lim.extend s) ≠ ⊤ := by
+    intro n s hs
+    rw [he (x n) s hs, he ρ_lim s hs]
+    have := (x n).isProb s; have := ρ_lim.isProb s
+    exact wasserstein1_ne_top_of_finite_moment _ _
+      ((x n).yIntegrable s hs) (ρ_lim.yIntegrable s hs)
+  have h_W1_bound_curve : ∀ n, ∀ s ∈ Set.Icc (0 : ℝ) T,
+      (wasserstein1 ((x n).extend s) (ρ_lim.extend s)).toReal ≤ Dn n := by
+    intro n s hs
+    rw [he (x n) s hs, he ρ_lim s hs]
+    exact ENNReal.toReal_mono (h_sup_ne_top n)
+      (wasserstein1_le_supW1On (Set.Icc 0 T) (x n).ρ ρ_lim.ρ s hs)
+  have h_term2 : ∀ n t, t ∈ Set.Icc (0 : ℝ) T →
+      (wasserstein1 (Measure.map (fun z => charXs n t z) f₀)
+                    (Measure.map (fun z => charX t z) f₀)).toReal ≤ Dn n * q :=
+    fun n t ht => picardLimit_flow_pointwise_contraction gradW L hL f₀ hf₀_int hT
+      m hMbar_nn hMbar_mono (x n) ρ_lim (charXs n) (charVs n) charX charV
+      (h_flow n).1 (h_flow n).2.1 hflow_on_ρlim h_boundary_ρlim
+      (Dn n) (hDn_nn n) (h_W1_fin_curve n) (h_W1_bound_curve n) q hq_def t ht
+  intro t ht
+  rw [he ρ_lim t ht, h_marg t ht]
+  exact picardLimit_fixed_point_eq f₀ m x ρ_lim charXs charX
+    (fun n t' ht' => (h_flow n).2.2 t' ht') h_tendsto
+    (fun n t' ht' => (hCI n).1 t' ht') (fun t' ht' => hCI_lim.1 t' ht')
+    (fun n t' ht' => (hCI n).2.2.1 t' ht') (fun t' ht' => hCI_lim.2.2.1 t' ht')
+    Dn q (by simpa using hDn_tendsto.mul_const q) h_term2 t ht
+
+/-- **Sub-helper for `vlasovWellPosedness_local`** — the Picard fixed-point
+self-consistent flow.
+
+Given `f₀ : Measure (PhaseSpace d)` with finite first moment, produces a
+characteristic flow `(charX, charV)` whose **own pushforward's spatial
+marginal** is the reference measure the flow is built against — i.e., the
+Picard fixed point at the spatial-marginal-curve level:
+
+  `ρ_t := spatialMarginal (Measure.map (z ↦ (charX t z, charV t z)) f₀)`
+  `charX, charV solve the Vlasov ODE against this ρ`.
+
+The body carries the substantive Picard analysis:
+
+* M-fixed-point: pick a moment bound `M ≥ A/(1 - B)` where
+  `A = gronwallBound 1 (1+L) ‖gradW 0‖ T · (M_f₀ + 1)` and
+  `B = L · (exp((1+L)·T) - 1)/(1+L) · (M_f₀ + 1)`.  Requires `B < 1`,
+  which is the genuine convergence criterion for the moment iteration
+  (stronger than the contraction predicate `LocalSmallnessContraction
+  L T` alone for large `M_f₀` — the contraction predicate gates the q
+  factor; the M-fixed-point additionally requires the moment iteration
+  to converge).
+* Picard sequence `x_n : ℕ → VlasovMeasureCurve d T M` starting from
+  `x_0 := constantCurve (spatialMarginal f₀)` and `x_{n+1} := Phi_step(x_n)`.
+* Contraction via `Phi_supW1_contraction`: `supW1On (Φρ) (Φσ) ≤ q · D`
+  with `q < 1`.  Apply `picard_iterate_isCauchy_of_contraction` +
+  `picard_iterate_exists_limit` to get the W₁-limit
+  `ρ_lim : VlasovMeasureCurve d T M`.
+* Self-consistency `Φ(ρ_lim) = ρ_lim`: triangle through `x_n`.
+* Apply `exists_vlasov_characteristicFlow_global_smallT` to `ρ_lim.extend`
+  to get the flow.
+
+**Metric-dependence note**.  The convergence rests on two independent
+predicates:
+* `LocalSmallnessContraction L T := L · (exp((max 1 L)·T) - 1) / (max 1 L) < 1`
+  — exponential in T, from `Phi_supW1_contraction`'s W₁-based shape.
+* `LocalSmallnessPLBuffer L T := L · T² < 1` — quadratic, from
+  per-ball Picard-Lindelöf's ball geometry.
+
+These are genuinely independent (neither universally implies the other), so
+each predicate matches its own sub-argument.
+
+Under the Wbar refactor (Dobrushin 1979, §5), both constraints become
+linear-in-T and align: `LocalSmallnessContraction` reduces to
+`C₂(L)·T < 1`, and the single algebraic constraint then suffices and is
+satisfiable for any `L > 0` by taking `T < 1/C₂(L)`.
+
+**Output bundle** (designed to feed
+`vlasovSolutionViaPushforward_isLagrangianVlasovSolutionOn` directly):
+
+* Flow `(charX, charV)` against the *spatial marginal of the pushforward*
+  — the load-bearing self-consistency conjunct.
+* Boundary regularity.
+* Uniform moment bound `M_ρ` on the spatial marginal trajectory. -/
+theorem vlasovWellPosedness_local_picard_fixedPointFlow
+    {d : ℕ} [NeZero d]
+    (W : PhysSpace d → ℝ)
+    (gradW : PhysSpace d → PhysSpace d)
+    (hgradW : ∀ x, gradW x = gradient W x)
+    (L : NNReal) (hL : LipschitzWith L gradW)
+    (f₀ : Measure (PhaseSpace d)) [IsProbabilityMeasure f₀]
+    (hf₀_int : Integrable (fun z : PhaseSpace d => ‖z‖) f₀)
+    {T : ℝ} (hT : 0 < T)
+    (hTL_PL : LocalSmallnessPLBuffer L T)
+    (hTL_con : LocalSmallnessContraction L T)
+    (hB : (L : ℝ) / (1 + (L : ℝ)) * (Real.exp ((1 + (L : ℝ)) * T) - 1) < 1) :
+    ∃ (charX charV : ℝ → PhaseSpace d → PhysSpace d) (M_ρ : ℝ), 0 ≤ M_ρ ∧
+      -- Self-consistent characteristic flow: against the spatial marginal
+      -- of its own phase-space pushforward.
+      IsCharacteristicFlowOn gradW
+        (fun t => spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ t))
+        charX charV (Set.Ioo 0 T) Set.univ ∧
+      -- Boundary regularity: HasDerivWithinAt on `Icc 0 T` for every z and
+      -- t ∈ Icc 0 T.
+      (∀ z : PhaseSpace d, ∀ t ∈ Set.Icc (0 : ℝ) T,
+        HasDerivWithinAt (fun s => charX s z) (charV t z) (Set.Icc 0 T) t ∧
+        HasDerivWithinAt (fun s => charV s z)
+          (-(convolveFunctionMeasure gradW
+              (spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ t))
+              (charX t z)))
+          (Set.Icc 0 T) t) ∧
+      -- Uniform first-moment bound on the spatial-marginal trajectory.
+      (∀ s ∈ Set.Icc (0 : ℝ) T,
+        ∫ y, ‖y‖ ∂(spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ s)) ≤ M_ρ) ∧
+      -- First-moment integrability on the spatial-marginal trajectory.
+      (∀ s ∈ Set.Icc (0 : ℝ) T,
+        Integrable (fun y : PhysSpace d => ‖y‖)
+          (spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ s))) ∧
+      -- Continuity of the convolution force in `x` (uniformly in `s`).
+      (∀ s, Continuous (fun x =>
+        convolveFunctionMeasure gradW
+          (spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ s)) x)) ∧
+      -- **AEMeasurable witness**, projected from the Picard fixed-point
+      -- construction's continuity-in-z — supplies the `h_aemeas` conjunct
+      -- in downstream `_finalAssembly_*`.
+      (∀ s, AEMeasurable (fun z : PhaseSpace d => (charX s z, charV s z)) f₀) ∧
+      -- **Universal-in-s convolution integrability**.  For `s ∈ Icc 0 T`
+      -- follows from `h_y_int_ρ` + Lipschitz of `gradW`; the extension to
+      -- all `s` uses constant-extension (clamp) past T inside the Picard
+      -- construction.  Supplies the `h_int_conv` conjunct in downstream
+      -- `_finalAssembly_*`.
+      (∀ s (x : PhysSpace d),
+        Integrable (fun y => gradW (x - y))
+          (spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ s))) := by
+  -- ============================================================
+  -- Step 1: Spatial marginal setup.
+  -- μ₀ := spatialMarginal f₀ = Measure.map Prod.fst f₀.
+  -- IsProbabilityMeasure μ₀ via Measure.isProbabilityMeasure_map.
+  -- Integrable ‖·‖ μ₀ from hf₀_int via integral_map on Prod.fst.
+  -- ============================================================
+  have hμ₀_prob : IsProbabilityMeasure (spatialMarginal f₀) :=
+    (Measure.isProbabilityMeasure_map_iff measurable_fst.aemeasurable).mpr inferInstance
+  have hμ₀_int : Integrable (fun y : PhysSpace d => ‖y‖) (spatialMarginal f₀) := by
+    unfold spatialMarginal
+    rw [integrable_map_measure
+      (Continuous.aestronglyMeasurable continuous_norm) measurable_fst.aemeasurable]
+    -- Need: Integrable (‖·‖ ∘ Prod.fst) f₀ = Integrable (fun z => ‖z.1‖) f₀.
+    -- This follows from hf₀_int (Integrable ‖·‖ f₀) and ‖z.1‖ ≤ ‖z‖.
+    refine hf₀_int.mono' ?_ (Filter.Eventually.of_forall fun z => ?_)
+    · exact (measurable_fst.norm.aestronglyMeasurable)
+    · simp only [Function.comp_def, Real.norm_of_nonneg (norm_nonneg _)]
+      exact (norm_fst_le z)
+  -- **F1 (phase-space anchor)**: `M_f₀` is the *phase-space* first moment
+  -- `∫z‖z‖∂f₀`, NOT the spatial marginal — matching `phi_moment_envelope_le`'s
+  -- (A.2) `integral_map` initial value, so the envelope dominates both the
+  -- pushforward moments (A.2) and the spatial base case (`∫‖x‖∂μ₀ ≤ M_f₀`).
+  let M_f₀ : ℝ := ∫ z : PhaseSpace d, ‖z‖ ∂f₀
+  have hM_f₀_nn : 0 ≤ M_f₀ := integral_nonneg (fun z => norm_nonneg z)
+  -- ============================================================
+  -- Step 2: time-dependent moment envelope `m` (option 2, dissolving the
+  -- constant-`M` fixed-point).  `gronwall_envelope_exists` (Piece A.3) under
+  -- `hB := B(T) < 1` yields a monotone `m` that is `Φ`-invariant at the moment
+  -- level, so `Φ : space(m) → space(m)` and the Picard sequence stays in one
+  -- fixed curve space.
+  -- ============================================================
+  obtain ⟨m, hm_mono, hm_ge, hm_inv⟩ :=
+    gronwall_envelope_exists M_f₀ ‖gradW 0‖ hM_f₀_nn (norm_nonneg _) L T hT.le hB
+  have hm_nn : ∀ t ∈ Set.Icc (0 : ℝ) T, 0 ≤ m t :=
+    fun t ht => le_trans hM_f₀_nn (hm_ge t ht)
+  have hMbar_nn : 0 ≤ m T := hm_nn T ⟨hT.le, le_refl T⟩
+  have hMbar_mono : ∀ t ∈ Set.Icc (0 : ℝ) T, m t ≤ m T :=
+    fun t ht => hm_mono ht ⟨hT.le, le_refl T⟩ ht.2
+  -- ============================================================
+  -- Step 3: Convolution integrability for constantCurve.
+  -- For the base case x 0 = constantCurve μ₀, need h_int_ext:
+  --   ∀ t (x : PhysSpace d), Integrable (fun y => gradW (x - y)) ((constantCurve μ₀).extend t).
+  -- This reduces to: Integrable (fun y => gradW (x - y)) μ₀, which follows
+  -- from hμ₀_int + Lipschitz bound on gradW.
+  -- Integrability of gradW against μ₀.
+  -- ============================================================
+  have h_int_gradW_μ₀ : ∀ (x_pt : PhysSpace d),
+      Integrable (fun y => gradW (x_pt - y)) (spatialMarginal f₀) :=
+    fun x_pt => integrable_gradW_shift gradW L hL (spatialMarginal f₀) hμ₀_int x_pt
+  -- ============================================================
+  -- Step 4: Picard sequence + contraction bound.
+  -- The sequence x : ℕ → VlasovMeasureCurve d T M is built by Phi_step +
+  -- induction; the contraction estimate uses Phi_supW1_contraction applied
+  -- to consecutive iterates.
+  -- ============================================================
+  -- `q` is the M-INDEPENDENT genuine contraction ratio (not 2M·q_true).
+  -- `Phi_supW1_contraction` outputs `q · D` per step, so `q^k · D₀ =
+  -- q^k · (2M)` is the iterated contraction bound; the contraction factor
+  -- `q = gronwallBound 0 (max 1 L) L T = (L/(max 1 L)) · (exp((max 1 L)·T) - 1)`
+  -- is separated from the W₁-input bound `D₀ = 2M`.  `hq_lt` closes by direct
+  -- citation of `hTL_con` (LocalSmallnessContraction) after one unfold.
+  let q : ℝ := gronwallBound 0 ((max 1 L : NNReal) : ℝ) (L : ℝ) T
+  have hq_nn : 0 ≤ q := by
+    have hK_nn : (0 : ℝ) ≤ ((max 1 L : NNReal) : ℝ) := NNReal.coe_nonneg _
+    have hε_nn : (0 : ℝ) ≤ (L : ℝ) := L.coe_nonneg
+    have := gronwallBound_mono (δ := (0 : ℝ)) (K := ((max 1 L : NNReal) : ℝ))
+      (ε := (L : ℝ)) (le_refl 0) hε_nn hK_nn hT.le
+    rw [gronwallBound_x0] at this; exact this
+  -- Direct citation: `LocalSmallnessContraction L T` IS `q < 1` after
+  -- unfolding both definitions.  No local derivation; the named-lemma
+  -- pattern from the soundness-fix mechanism.
+  have hq_lt : q < 1 := hTL_con.gronwallBound_lt_one
+  -- D₀: initial supW1On bound = supW1On (x 0).ρ (x 1).ρ ≤ 2 * M.
+  let D₀ : ℝ := 2 * (m T)
+  have hD₀_nn : 0 ≤ D₀ := by linarith [hMbar_nn]
+  -- Picard sequence + contraction, in the fixed envelope space `m`.  The
+  -- recursion uses `Phi_step_envelope` per step + `Phi_supW1_contraction`
+  -- for the geometric bound.
+  -- **Enriched existential**: the Picard sequence exposes, per
+  -- step `k`, the flow `(charXs k, charVs k)` against `(x k).extend` — exactly
+  -- `Phi_step_envelope`'s output shape — plus the pushforward identity
+  -- `(x(k+1)).ρ t = map (charXs k t) f₀`.  Exposing the flows lets the
+  -- self-consistency proof (Step 8) feed them directly to `Phi_supW1_contraction`,
+  -- dissolving the (un-banked) ODE-uniqueness that re-deriving them would need.
+  have hμ₀_int_fst : Integrable (fun z : PhaseSpace d => ‖z.1‖) f₀ :=
+    hf₀_int.mono' measurable_fst.norm.aestronglyMeasurable
+      (Filter.Eventually.of_forall fun z => by
+        rw [Real.norm_of_nonneg (norm_nonneg _)]; exact norm_fst_le z)
+  have hμ₀_le_m : ∀ t ∈ Set.Icc (0 : ℝ) T,
+      ∫ y, ‖y‖ ∂(spatialMarginal f₀) ≤ m t := by
+    intro t ht
+    have h_eq : ∫ y, ‖y‖ ∂(spatialMarginal f₀) = ∫ z, ‖z.1‖ ∂f₀ := by
+      unfold spatialMarginal
+      rw [integral_map measurable_fst.aemeasurable continuous_norm.aestronglyMeasurable]
+    have h_le : ∫ z, ‖z.1‖ ∂f₀ ≤ M_f₀ :=
+      integral_mono hμ₀_int_fst hf₀_int (fun z => norm_fst_le z)
+    rw [h_eq]; exact le_trans h_le (hm_ge t ht)
+  obtain ⟨x, charXs, charVs, h_contract, h_flow⟩ :=
+    vlasovWellPosedness_local_picard_sequence W gradW hgradW L hL f₀ hf₀_int hT hTL_PL
+      m hm_mono hm_nn hm_inv hMbar_nn hMbar_mono hμ₀_prob hμ₀_int hμ₀_le_m
+      q hq_nn rfl D₀ hD₀_nn rfl
+  -- ============================================================
+  -- Step 5: Extract limit ρ_lim via picard_iterate_exists_limit.
+  -- ============================================================
+  obtain ⟨ρ_lim, h_tendsto⟩ :=
+    picard_iterate_exists_limit x q hq_nn hq_lt D₀ hD₀_nn h_contract
+  -- ============================================================
+  -- Step 6: Convolution integrability for ρ_lim.extend.
+  -- Needed by exists_vlasov_characteristicFlow_global_smallT.
+  -- Integrability of gradW against ρ_lim.extend t.
+  -- ============================================================
+  have h_int_ρ_lim : ∀ t (x_pt : PhysSpace d),
+      Integrable (fun y => gradW (x_pt - y)) (ρ_lim.extend t) := fun t x_pt =>
+    integrable_gradW_shift gradW L hL (ρ_lim.extend t)
+      (VlasovMeasureCurve.extend_yIntegrable hT.le ρ_lim t) x_pt
+  -- Convolution continuity for ρ_lim.extend, universal in t.
+  -- Deduced from ρ_lim.extend_convCont + h_int_ρ_lim restricted to Icc 0 T.
+  have h_conv_cont_ρ_lim : ∀ x : PhysSpace d,
+      Continuous (fun t => convolveFunctionMeasure gradW (ρ_lim.extend t) x) := by
+    intro x_pt
+    have h_int_Icc : ∀ t ∈ Set.Icc (0 : ℝ) T,
+        Integrable (fun y => gradW (x_pt - y)) (ρ_lim.ρ t) := by
+      intro t ht
+      have h_eq : ρ_lim.extend t = ρ_lim.ρ t := by
+        unfold VlasovMeasureCurve.extend clampToIcc
+        congr 1
+        rw [min_eq_left ht.2, max_eq_right ht.1]
+      rw [← h_eq]; exact h_int_ρ_lim t x_pt
+    exact VlasovMeasureCurve.extend_convCont gradW L hL hT.le ρ_lim x_pt h_int_Icc
+  -- ============================================================
+  -- Step 7: Flow construction via exists_vlasov_characteristicFlow_global_smallT.
+  -- Build (charX, charV) against ρ_lim.extend.
+  -- ============================================================
+  obtain ⟨charX, charV, hflow_on_ρlim, h_boundary_ρlim⟩ :=
+    exists_vlasov_characteristicFlow_global_smallT W gradW hgradW L hL
+      ρ_lim.extend h_int_ρ_lim h_conv_cont_ρ_lim
+      (fun t => VlasovMeasureCurve.extend_yIntegrable hT.le ρ_lim t)
+      (m T) hMbar_nn
+      (fun t => le_trans (VlasovMeasureCurve.extend_hasMoment hT.le ρ_lim t)
+        (hMbar_mono (clampToIcc T t) (clampToIcc_mem hT.le t)))
+      T hT.le hTL_PL
+  -- ============================================================
+  -- Step 8: Self-consistency.  For t ∈ Icc 0 T,
+  --   ρ_lim.ρ t = spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ t).
+  -- This is the Picard fixed-point equation: Phi charX f₀ t = ρ_lim.ρ t,
+  -- proved by triangle through x n using contraction + tendsto.
+  -- ============================================================
+  -- ============================================================
+  -- Self-consistency on Icc 0 T.
+  -- For t ∈ Icc 0 T:
+  --   ρ_lim.extend t = ρ_lim.ρ t   (by clampToIcc identity on Icc)
+  --   ρ_lim.ρ t = spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ t)
+  -- The second equality is the Picard fixed-point equation, proved by triangle
+  -- through x n using contraction + tendsto.
+  -- ============================================================
+  have h_self_consist : ∀ t ∈ Set.Icc (0 : ℝ) T,
+      ρ_lim.extend t =
+      spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ t) :=
+    -- Step 8 extracted as `picardLimit_self_consistency`; the let-bound `q`'s
+    -- defining equation is supplied by `rfl`.
+    picardLimit_self_consistency gradW L hL f₀ hf₀_int hT m hMbar_nn hMbar_mono
+      q hq_nn hq_lt rfl D₀ hD₀_nn x charXs charVs h_contract h_flow
+      ρ_lim h_tendsto charX charV hflow_on_ρlim h_boundary_ρlim h_int_ρ_lim
+  -- ============================================================
+  -- Step 9: Bundle with a CLAMPED flow `cX s := charX (clampToIcc T s)`.
+  --
+  -- The raw flow from `exists_vlasov_characteristicFlow_global_smallT` is
+  -- controlled only on `[0, T]`; off-window it is uncontrolled
+  -- `Classical.choose` data with no growth bound.  The conclusion's
+  -- universal-in-`s` conjuncts (convolution integrability + continuity-in-x
+  -- for ALL `s`) therefore cannot hold for the raw flow.  We return instead
+  -- the clamped flow, whose pushforward at any `s` equals the on-window
+  -- pushforward at `clampToIcc T s ∈ [0, T]` — hence globally controlled.
+  -- On `[0, T]` the clamp is the identity (`clampToIcc T s = s`), so every
+  -- window conjunct (flow ODE on Ioo, boundary on Icc, moment, integrability)
+  -- transfers from the raw flow via `clampToIcc`-congruence.
+  -- ============================================================
+  exact picardFlow_clamp_bundle gradW L hL f₀ hT m hMbar_nn hMbar_mono ρ_lim
+    charX charV hflow_on_ρlim h_boundary_ρlim h_int_ρ_lim h_self_consist
+
+/-- **Sub-helper for `vlasovWellPosedness_local`** — moment-bound transport.
+
+Given the Picard fixed-point flow's bundle (from
+`_picard_fixedPointFlow`), produces `HasFiniteFirstMoment (f t)` for
+`t ∈ Icc 0 T`, where `f := vlasovSolutionViaPushforward charX charV f₀`.
+
+**Proof strategy**:
+
+1. Boundary transport: extract `h_init / h_cont_Icc / h_deriv_Ico` from
+   `hflow_on + h_boundary` via `characteristicFlow_boundary_regularity`.
+2. `flow_distance_growth_bound_on` applied to `(charX, charV)` produces
+   the growth constant `C_T` with `‖(charX t z, charV t z)‖ ≤ C_T * (‖z‖ + 1)`.
+3. Probability of `f t = Measure.map (z ↦ (charX t z, charV t z)) f₀` from
+   the AEMeasurable witness.
+4. Integrable `‖·‖` on `f t`: via `integrable_map_measure` + growth bound +
+   `Integrable ‖·‖ f₀`.
+
+Factored out to keep `vlasovWellPosedness_local`'s body a clean glue. -/
+theorem vlasovWellPosedness_local_moment
+    {d : ℕ}
+    (W : PhysSpace d → ℝ)
+    (gradW : PhysSpace d → PhysSpace d)
+    (_hgradW : ∀ x, gradW x = gradient W x)
+    (L : NNReal) (hL : LipschitzWith L gradW)
+    (f₀ : Measure (PhaseSpace d)) [IsProbabilityMeasure f₀]
+    (hf₀_int : Integrable (fun z : PhaseSpace d => ‖z‖) f₀)
+    {T : ℝ} (hT : 0 < T)
+    (_hTL_PL : LocalSmallnessPLBuffer L T)
+    (_hTL_con : LocalSmallnessContraction L T)
+    (charX charV : ℝ → PhaseSpace d → PhysSpace d)
+    (M_ρ : ℝ) (hM_ρ_nn : 0 ≤ M_ρ)
+    (hflow_on : IsCharacteristicFlowOn gradW
+      (fun t => spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ t))
+      charX charV (Set.Ioo 0 T) Set.univ)
+    (h_boundary : ∀ z : PhaseSpace d, ∀ t ∈ Set.Icc (0 : ℝ) T,
+      HasDerivWithinAt (fun s => charX s z) (charV t z) (Set.Icc 0 T) t ∧
+      HasDerivWithinAt (fun s => charV s z)
+        (-(convolveFunctionMeasure gradW
+            (spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ t))
+            (charX t z)))
+        (Set.Icc 0 T) t)
+    (hM_ρ_bound : ∀ s ∈ Set.Icc (0 : ℝ) T,
+      ∫ y, ‖y‖ ∂(spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ s)) ≤ M_ρ)
+    (h_y_int_ρ : ∀ s ∈ Set.Icc (0 : ℝ) T,
+      Integrable (fun y : PhysSpace d => ‖y‖)
+        (spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ s)))
+    (_hconv_cont : ∀ s, Continuous (fun x =>
+      convolveFunctionMeasure gradW
+        (spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ s)) x))
+    -- Passed from `_picard_fixedPointFlow`'s enriched output: the
+    -- AEMeasurable witness + universal-in-s convolution integrability.
+    (h_aemeas : ∀ s, AEMeasurable (fun z : PhaseSpace d => (charX s z, charV s z)) f₀)
+    (h_int_conv : ∀ s (x : PhysSpace d),
+      Integrable (fun y => gradW (x - y))
+        (spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ s)))
+    (t : ℝ) (ht : t ∈ Set.Icc (0 : ℝ) T) :
+    HasFiniteFirstMoment (vlasovSolutionViaPushforward charX charV f₀ t) := by
+  -- IsProbabilityMeasure for the spatial marginal (needed for the flow typeclass).
+  -- spatialMarginal μ = Measure.map Prod.fst μ, so IsProbabilityMeasure_map needs
+  -- AEMeasurable Prod.fst (Measure.map ... f₀). Since Prod.fst is measurable,
+  -- it is AEMeasurable wrt any measure.
+  have hρ_prob : ∀ s, IsProbabilityMeasure
+      (spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ s)) := by
+    intro s
+    unfold spatialMarginal vlasovSolutionViaPushforward
+    -- Need IsProbabilityMeasure (Measure.map Prod.fst (Measure.map (fun z => ...) f₀))
+    -- Use Measure.map_map to compose, then isProbabilityMeasure_map_iff on the composition.
+    have h_aemeas_pair : AEMeasurable (fun z : PhaseSpace d => (charX s z, charV s z)) f₀ :=
+      h_aemeas s
+    have h_prob_inner : IsProbabilityMeasure
+        (Measure.map (fun z : PhaseSpace d => (charX s z, charV s z)) f₀) :=
+      (Measure.isProbabilityMeasure_map_iff h_aemeas_pair).mpr inferInstance
+    exact (Measure.isProbabilityMeasure_map_iff measurable_fst.aemeasurable).mpr inferInstance
+  -- Step 1: Extract h_init, h_cont_Icc, h_deriv_Ico via boundary transport.
+  obtain ⟨h_init, h_cont_Icc, h_deriv_Ico⟩ :=
+    characteristicFlow_boundary_regularity gradW
+      (fun t => spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ t))
+      charX charV T hT.le hflow_on h_boundary
+  -- Step 2: Growth bound from flow_distance_growth_bound_on.
+  obtain ⟨C_T, hC_T_nn, h_growth⟩ :=
+    flow_distance_growth_bound_on gradW L hL
+      (fun s => spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ s))
+      charX charV T hT.le
+      h_init h_cont_Icc h_deriv_Ico
+      M_ρ hM_ρ_nn hM_ρ_bound h_y_int_ρ h_int_conv
+  -- Step 3: Conclude HasFiniteFirstMoment.
+  unfold HasFiniteFirstMoment vlasovSolutionViaPushforward
+  refine ⟨(Measure.isProbabilityMeasure_map_iff (h_aemeas t)).mpr inferInstance, ?_⟩
+  -- Integrable ‖·‖ wrt Measure.map (fun z => (charX t z, charV t z)) f₀.
+  rw [integrable_map_measure
+    (Continuous.aestronglyMeasurable continuous_norm) (h_aemeas t)]
+  -- Now need: Integrable (fun z : PhaseSpace d => ‖(charX t z, charV t z)‖) f₀.
+  have h_dom_int : Integrable (fun z : PhaseSpace d => C_T * (‖z‖ + 1)) f₀ := by
+    have h1 : Integrable (fun z : PhaseSpace d => C_T * ‖z‖) f₀ :=
+      hf₀_int.const_mul C_T
+    have h2 : Integrable (fun _ : PhaseSpace d => C_T) f₀ := integrable_const _
+    have h_eq : (fun z : PhaseSpace d => C_T * (‖z‖ + 1)) =
+                fun z => C_T * ‖z‖ + C_T := by funext z; ring
+    rw [h_eq]; exact h1.add h2
+  -- The goal after rw is: Integrable (‖·‖ ∘ fun z => (charX t z, charV t z)) f₀
+  -- = Integrable (fun z => ‖(charX t z, charV t z)‖) f₀.
+  -- Dominator: C_T * (‖z‖ + 1); AE bound from h_growth.
+  have h_norm_aesm : AEStronglyMeasurable
+      (fun z : PhaseSpace d => ‖(charX t z, charV t z)‖) f₀ :=
+    (h_aemeas t).norm.aestronglyMeasurable
+  refine h_dom_int.mono' ?_ (Filter.Eventually.of_forall fun z => ?_)
+  · -- AEStronglyMeasurable of ‖·‖ ∘ (charX t, charV t).
+    -- After integrable_map_measure rewrite, goal is for the composition form.
+    convert h_norm_aesm using 1
+    rfl
+  · -- Pointwise bound: ‖(charX t z, charV t z)‖ ≤ C_T * (‖z‖ + 1).
+    -- The norm in the goal is ‖(‖·‖ ∘ ...)(z)‖ = ‖‖(charX t z, charV t z)‖‖.
+    simp only [Function.comp_def, Real.norm_of_nonneg (norm_nonneg _)]
+    exact h_growth t ht z
+
+/-- **Sub-helper for `vlasovWellPosedness_local`** — IsLagrangianVlasovSolutionOn
+threading.
+
+Given the Picard fixed-point flow's bundle (from
+`_picard_fixedPointFlow`), produces the
+`IsLagrangianVlasovSolutionOn gradW f T` conjunct via the 20-hypothesis
+threading through
+`vlasovSolutionViaPushforward_isLagrangianVlasovSolutionOn`.
+
+**Proof strategy**:
+
+1. Boundary transport: extract `h_init / h_cont_Icc / h_deriv_Ico`.
+2. Universal-in-`s` convolution integrability (handling `s` outside
+   `[0, T]` via the clamp-extension argument).
+3. AEMeasurable witness.
+4. `IsCharacteristicFlowSelfConsistent`: `∀ t, ρ_lim t = Φ charX f₀ t`,
+   which expands by definition since `ρ_lim = spatialMarginal ∘ f` and
+   `f = vlasovSolutionViaPushforward charX charV f₀`; spatial marginal
+   of pushforward = pushforward under `Prod.fst ∘ ...` = `Φ charX f₀`.
+   The composition is the `Measure.map_map`-with-AEMeasurable bridge.
+5. Continuity of `gradW`: `hL.continuous`.
+6. Probability instance of `spatialMarginal ∘ f`: derived from
+   AEMeasurable + IsProbabilityMeasure f₀.
+7. Final invocation: `vlasovSolutionViaPushforward_isLagrangianVlasovSolutionOn`
+   with the full hypothesis bundle.
+
+Factored out to keep `vlasovWellPosedness_local`'s body a clean glue. -/
+theorem vlasovWellPosedness_local_isLagrangian
+    {d : ℕ}
+    (W : PhysSpace d → ℝ)
+    (gradW : PhysSpace d → PhysSpace d)
+    (_hgradW : ∀ x, gradW x = gradient W x)
+    (L : NNReal) (hL : LipschitzWith L gradW)
+    (f₀ : Measure (PhaseSpace d)) [IsProbabilityMeasure f₀]
+    (hf₀_int : Integrable (fun z : PhaseSpace d => ‖z‖) f₀)
+    {T : ℝ} (hT : 0 < T)
+    (_hTL_PL : LocalSmallnessPLBuffer L T)
+    (_hTL_con : LocalSmallnessContraction L T)
+    (charX charV : ℝ → PhaseSpace d → PhysSpace d)
+    (M_ρ : ℝ) (hM_ρ_nn : 0 ≤ M_ρ)
+    (hflow_on : IsCharacteristicFlowOn gradW
+      (fun t => spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ t))
+      charX charV (Set.Ioo 0 T) Set.univ)
+    (h_boundary : ∀ z : PhaseSpace d, ∀ t ∈ Set.Icc (0 : ℝ) T,
+      HasDerivWithinAt (fun s => charX s z) (charV t z) (Set.Icc 0 T) t ∧
+      HasDerivWithinAt (fun s => charV s z)
+        (-(convolveFunctionMeasure gradW
+            (spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ t))
+            (charX t z)))
+        (Set.Icc 0 T) t)
+    (hM_ρ_bound : ∀ s ∈ Set.Icc (0 : ℝ) T,
+      ∫ y, ‖y‖ ∂(spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ s)) ≤ M_ρ)
+    (h_y_int_ρ : ∀ s ∈ Set.Icc (0 : ℝ) T,
+      Integrable (fun y : PhysSpace d => ‖y‖)
+        (spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ s)))
+    (hconv_cont : ∀ s, Continuous (fun x =>
+      convolveFunctionMeasure gradW
+        (spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ s)) x))
+    -- Passed from `_picard_fixedPointFlow`'s enriched output: the
+    -- AEMeasurable witness + universal-in-s convolution integrability.
+    (h_aemeas : ∀ s, AEMeasurable (fun z : PhaseSpace d => (charX s z, charV s z)) f₀)
+    (h_int_conv : ∀ s (x : PhysSpace d),
+      Integrable (fun y => gradW (x - y))
+        (spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ s))) :
+    IsLagrangianVlasovSolutionOn gradW
+      (vlasovSolutionViaPushforward charX charV f₀) T := by
+  -- IsProbabilityMeasure for the spatial marginal (needed for the target typeclass).
+  have hρ_prob : ∀ s, IsProbabilityMeasure
+      (spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ s)) := by
+    intro s
+    unfold spatialMarginal vlasovSolutionViaPushforward
+    have h_aemeas_pair : AEMeasurable (fun z : PhaseSpace d => (charX s z, charV s z)) f₀ :=
+      h_aemeas s
+    have _h_prob_inner : IsProbabilityMeasure
+        (Measure.map (fun z : PhaseSpace d => (charX s z, charV s z)) f₀) :=
+      (Measure.isProbabilityMeasure_map_iff h_aemeas_pair).mpr inferInstance
+    exact (Measure.isProbabilityMeasure_map_iff measurable_fst.aemeasurable).mpr inferInstance
+  -- Step 1: Extract h_init, h_cont_Icc, h_deriv_Ico via boundary transport.
+  obtain ⟨h_init, h_cont_Icc, h_deriv_Ico⟩ :=
+    characteristicFlow_boundary_regularity gradW
+      (fun t => spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ t))
+      charX charV T hT.le hflow_on h_boundary
+  -- Step 2: IsCharacteristicFlowSelfConsistent
+  -- ρ t = spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ t)
+  --     = Measure.map Prod.fst (Measure.map (fun z => (charX t z, charV t z)) f₀)
+  --     = Measure.map (Prod.fst ∘ fun z => (charX t z, charV t z)) f₀
+  --         [by map_map_of_aemeasurable]
+  --     = Measure.map (charX t) f₀
+  have hself : IsCharacteristicFlowSelfConsistent charX f₀
+      (fun t => spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ t)) := by
+    intro t
+    simp only []
+    unfold spatialMarginal vlasovSolutionViaPushforward
+    -- Goal: Measure.map Prod.fst (Measure.map (fun z => (charX t z, charV t z)) f₀)
+    --     = Measure.map (fun z => charX t z) f₀
+    have h_comp : Measure.map Prod.fst
+        (Measure.map (fun z : PhaseSpace d => (charX t z, charV t z)) f₀) =
+        Measure.map (Prod.fst ∘ fun z : PhaseSpace d => (charX t z, charV t z)) f₀ := by
+      apply AEMeasurable.map_map_of_aemeasurable
+      · exact measurable_fst.aemeasurable
+      · exact h_aemeas t
+    rw [h_comp]; congr 1
+  -- Step 3: Apply the main threading theorem.
+  exact vlasovSolutionViaPushforward_isLagrangianVlasovSolutionOn
+    gradW L hL charX charV f₀ hf₀_int hT
+    hflow_on h_init h_cont_Icc h_deriv_Ico
+    M_ρ hM_ρ_nn hM_ρ_bound h_y_int_ρ h_int_conv
+    hself h_aemeas hL.continuous hconv_cont
+
+/-- **Local existence of a Vlasov solution on `[0, T]`.**
+
+Under the joint constraint `LocalSmallnessPLBuffer L T` (`L · T² < 1`) +
+`LocalSmallnessContraction L T`, produces a local-time Vlasov solution
+`f : ℝ → Measure (PhaseSpace d)` on `[0, T]` satisfying initial
+condition + local finite first moment + `IsLagrangianVlasovSolutionOn`.
+
+The forward-iteration continuation extends from local `T` to arbitrary
+`T_target` via **fixed-`T_0`** iteration: the contraction time `T_0`
+depends only on `L` (not on the moment bound `M_n` propagating through
+iterations), because `Phi_supW1_contraction`'s `q` is
+`gronwallBound 0 (max 1 L) (L · D) T` — independent of `M_n`.  So the
+continuation iterates `[0, T_0], [T_0, 2 T_0], …` with constant step `T_0`,
+reaching any `T_target` in `⌈T_target / T_0⌉` windows; gluing then bridges
+from `IsLagrangianVlasovSolutionOn` (local) to `IsLagrangianVlasovSolution`
+(global).
+
+**Proof strategy**:
+
+1. Initial spatial marginal: `μ₀ := spatialMarginal f₀`.  By
+   `HasFiniteFirstMoment f₀`, `μ₀` is a probability measure with
+   `Integrable ‖·‖`.  Let `M_f₀ := ∫ ‖z‖ ∂f₀` (finite by
+   `hf₀.2.integral_norm_le`).
+
+2. Picard sequence on spatial marginals:
+   - `ρ_0 := constantCurve μ₀`.
+   - `ρ_{n+1}` obtained via `Phi_step` applied to `ρ_n`'s flow.
+
+   Each `ρ_n` lives in `VlasovMeasureCurve d T M` for an appropriate
+   `M` chosen so that the growth bound from
+   `flow_distance_growth_bound_on` stays within `M` across iterations
+   (the M-preservation constraint).
+
+3. Contraction estimate via `Phi_supW1_contraction`:
+   `supW1On (ρ_n.ρ) (ρ_{n+1}.ρ) ≤ ENNReal.ofReal (q^n * D₀)`
+   for `q := gronwallBound 0 (max 1 L) (L · D) T < 1` (since `T` is
+   small enough per the joint constraint).
+
+4. Apply `picard_iterate_isCauchy_of_contraction` to get the ENNReal-form
+   Cauchy condition on the `supW1On` pseudodistance.
+
+5. Apply `picard_iterate_exists_limit` to extract the
+   limit `ρ_lim : VlasovMeasureCurve d T M` plus pointwise W₁-tendsto.
+
+6. Self-consistency `Φ(ρ_lim) = ρ_lim`: triangle through `ρ_n` using
+   the uniform-tendsto helper, contraction, and pointwise tendsto.
+
+7. Apply `exists_vlasov_characteristicFlow_global_smallT`
+   to `ρ_lim.extend` to get the characteristic flow `(charX, charV)`
+   against the self-consistent limit.
+
+8. Define `f := vlasovSolutionViaPushforward charX charV f₀`.  Verify:
+   - `f 0 = f₀` (from `IsCharacteristicFlowOn`'s initial-condition
+     clause + `Measure.map_id`).
+   - `HasFiniteFirstMoment (f t)` on `[0, T]` (from
+     `flow_distance_growth_bound_on` applied to `(charX, charV)` +
+     `hf₀.2`).
+   - `IsLagrangianVlasovSolutionOn gradW f T` via
+     `vlasovSolutionViaPushforward_isLagrangianVlasovSolutionOn`.
+
+The body invokes `vlasovWellPosedness_local_picard_fixedPointFlow` for the
+Picard fixed-point flow, then `vlasovWellPosedness_local_finalAssembly_*`
+for the moment and Lagrangian conjuncts, deriving `f 0 = f₀` inline. -/
+theorem vlasovWellPosedness_local
+    {d : ℕ} [NeZero d]
+    (W : PhysSpace d → ℝ)
+    (gradW : PhysSpace d → PhysSpace d)
+    (hgradW : ∀ x, gradW x = gradient W x)
+    (L : NNReal) (hL : LipschitzWith L gradW)
+    (f₀ : Measure (PhaseSpace d))
+    (hf₀ : HasFiniteFirstMoment f₀)
+    {T : ℝ} (hT : 0 < T)
+    (hTL_PL : LocalSmallnessPLBuffer L T)
+    (hTL_con : LocalSmallnessContraction L T)
+    (hB : (L : ℝ) / (1 + (L : ℝ)) * (Real.exp ((1 + (L : ℝ)) * T) - 1) < 1) :
+    ∃ (f : ℝ → Measure (PhaseSpace d))
+      (charX charV : ℝ → PhaseSpace d → PhysSpace d),
+      f 0 = f₀ ∧
+      (∀ t ∈ Set.Icc (0 : ℝ) T, HasFiniteFirstMoment (f t)) ∧
+      -- FLAT (window-constant) uniform first-moment bound on the spatial marginal.
+      (∃ M : ℝ, 0 ≤ M ∧
+        ∀ t ∈ Set.Icc (0 : ℝ) T, ∫ y, ‖y‖ ∂(spatialMarginal (f t)) ≤ M) ∧
+      IsLagrangianVlasovSolutionOn gradW f T ∧
+      -- Explicit flow bundle: pushforward, AEMeasurable, and boundary derivatives.
+      -- These use the SAME charX charV as the outer ∃ (not the hidden witnesses
+      -- inside IsLagrangianVlasovSolutionOn), enabling downstream consumers to
+      -- use them without witness-identity issues.
+      (∀ t ∈ Set.Icc (0 : ℝ) T,
+        f t = Measure.map (fun z : PhaseSpace d => (charX t z, charV t z)) (f 0)) ∧
+      (∀ s ∈ Set.Icc (0 : ℝ) T,
+        AEMeasurable (fun z : PhaseSpace d => (charX s z, charV s z)) (f 0)) ∧
+      (∀ z : PhaseSpace d, ∀ t ∈ Set.Icc (0 : ℝ) T,
+        HasDerivWithinAt (fun s => charX s z) (charV t z) (Set.Icc 0 T) t ∧
+        HasDerivWithinAt (fun s => charV s z)
+          (-(convolveFunctionMeasure gradW (spatialMarginal (f t)) (charX t z)))
+          (Set.Icc 0 T) t) ∧
+      -- Initial condition for the outer charX charV (same witnesses as boundary bundle above).
+      (∀ z : PhaseSpace d, charX 0 z = z.1 ∧ charV 0 z = z.2) := by
+  -- The body is decomposed into two sub-helpers plus an inline glue:
+  --   * `vlasovWellPosedness_local_picard_fixedPointFlow` carries the Picard
+  --     mathematics — spatial-marginal setup, the Picard sequence via
+  --     `Phi_step`, the contraction estimate via `Phi_supW1_contraction`,
+  --     the limit via `picard_iterate_exists_limit`,
+  --     self-consistency `Φ(ρ_lim) = ρ_lim`, and the flow construction via
+  --     `exists_vlasov_characteristicFlow_global_smallT`.
+  --   * `vlasovWellPosedness_local_finalAssembly_*` thread the moment and
+  --     `IsLagrangianVlasovSolutionOn` conjuncts through
+  --     `vlasovSolutionViaPushforward_isLagrangianVlasovSolutionOn`.
+  --   * This body invokes both, derives `f 0 = f₀` inline, and assembles.
+  obtain ⟨hf₀_prob, hf₀_int⟩ := hf₀
+  have : IsProbabilityMeasure f₀ := hf₀_prob
+  -- Sub-helper invocation: produces the self-consistent flow + regularity
+  -- + AEMeasurable witness + universal-in-s convolution integrability.
+  obtain ⟨charX, charV, _M_ρ, _hM_ρ_nn, _hflow_on, _h_boundary,
+          _hM_ρ_bound, _h_y_int_ρ, _hconv_cont, _h_aemeas, _h_int_conv⟩ :=
+    vlasovWellPosedness_local_picard_fixedPointFlow W gradW hgradW L hL
+      f₀ hf₀_int hT hTL_PL hTL_con hB
+  -- Bundle the f-shape result.
+  refine ⟨vlasovSolutionViaPushforward charX charV f₀, charX, charV, ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_⟩
+  · -- (a) f 0 = f₀.  The flow's initial-condition clause gives
+    -- (charX 0 z, charV 0 z) = z for every z, so the pushforward at t = 0
+    -- is `Measure.map id f₀ = f₀`.  Proved inline via the sub-helper's
+    -- initial-condition projection at t = 0.
+    have h_init : ∀ z : PhaseSpace d, (charX 0 z, charV 0 z) = z := by
+      intro z
+      have := (_hflow_on.1 z (Set.mem_univ z))
+      exact Prod.ext this.1 this.2
+    change vlasovSolutionViaPushforward charX charV f₀ 0 = f₀
+    unfold vlasovSolutionViaPushforward
+    have h_at_0 : (fun z : PhaseSpace d => (charX 0 z, charV 0 z)) = id := by
+      funext z; exact h_init z
+    rw [h_at_0, Measure.map_id]
+  · -- (b) HasFiniteFirstMoment (f t) on Icc 0 T.  Deferred to the
+    -- _finalAssembly sub-helper (since it requires C_T from
+    -- flow_distance_growth_bound_on, plus the integral_map +
+    -- pushforward-moment-bound chain — exactly the threading work that
+    -- the _finalAssembly sub-helper handles).
+    intro t ht
+    exact vlasovWellPosedness_local_moment W gradW hgradW L hL
+      f₀ hf₀_int hT hTL_PL hTL_con charX charV
+      _M_ρ _hM_ρ_nn _hflow_on _h_boundary _hM_ρ_bound _h_y_int_ρ _hconv_cont
+      _h_aemeas _h_int_conv
+      t ht
+  · -- (b′) FLAT uniform first-moment bound on the spatial marginal.
+    -- The picard fixed-point flow already exposes exactly this bound
+    -- (`_hM_ρ_bound`) for `M_ρ := _M_ρ` against
+    -- `spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ ·)`,
+    -- which is `spatialMarginal (f ·)` by definition of `f` here.
+    exact ⟨_M_ρ, _hM_ρ_nn, _hM_ρ_bound⟩
+  · -- (c) IsLagrangianVlasovSolutionOn gradW f T.  Handled by the
+    -- _finalAssembly sub-helper: it derives the AEMeasurable witness, the
+    -- IsCharacteristicFlowSelfConsistent discharge, the universal-in-s
+    -- convolution integrability (extension of `_hconv_cont`'s implications),
+    -- and threads all the hypotheses through
+    -- `vlasovSolutionViaPushforward_isLagrangianVlasovSolutionOn`.
+    exact vlasovWellPosedness_local_isLagrangian W gradW hgradW L hL
+      f₀ hf₀_int hT hTL_PL hTL_con charX charV
+      _M_ρ _hM_ρ_nn _hflow_on _h_boundary _hM_ρ_bound _h_y_int_ρ _hconv_cont
+      _h_aemeas _h_int_conv
+  · -- (d) Explicit pushforward equation for the outer charX charV.
+    -- vlasovSolutionViaPushforward charX charV f₀ t = Measure.map (charX t, charV t) f₀
+    -- by DEFINITION. And f 0 = f₀ (from goal (a), which used the initial condition).
+    -- So f t = Measure.map (charX t, charV t) (f 0) by congruence on f 0 = f₀.
+    have h_f0_eq : vlasovSolutionViaPushforward charX charV f₀ 0 = f₀ := by
+      have h_init : ∀ z : PhaseSpace d, (charX 0 z, charV 0 z) = z :=
+        fun z => Prod.ext (_hflow_on.1 z (Set.mem_univ z)).1 (_hflow_on.1 z (Set.mem_univ z)).2
+      simp [vlasovSolutionViaPushforward,
+            show (fun z : PhaseSpace d => (charX 0 z, charV 0 z)) = id from funext h_init]
+    intro t _
+    show vlasovSolutionViaPushforward charX charV f₀ t =
+      Measure.map (fun z : PhaseSpace d => (charX t z, charV t z))
+        (vlasovSolutionViaPushforward charX charV f₀ 0)
+    rw [h_f0_eq]
+    -- After rw, goal is: vlasovSolutionViaPushforward charX charV f₀ t = Measure.map ... f₀
+    -- This is rfl by definition of vlasovSolutionViaPushforward.
+    rfl
+  · -- (e) Explicit AEMeasurable for the outer charX charV.
+    -- AEMeasurable (fun z => (charX s z, charV s z)) f₀ comes from _h_aemeas.
+    -- The expected type uses (f 0) = vlasovSolutionViaPushforward charX charV f₀ 0 = f₀.
+    have h_f0_eq : vlasovSolutionViaPushforward charX charV f₀ 0 = f₀ := by
+      have h_init : ∀ z : PhaseSpace d, (charX 0 z, charV 0 z) = z :=
+        fun z => Prod.ext (_hflow_on.1 z (Set.mem_univ z)).1 (_hflow_on.1 z (Set.mem_univ z)).2
+      simp [vlasovSolutionViaPushforward,
+            show (fun z : PhaseSpace d => (charX 0 z, charV 0 z)) = id from funext h_init]
+    intro s _
+    rw [h_f0_eq]
+    exact _h_aemeas s
+  · -- (f) Boundary regularity bundle: HasDerivWithinAt on Icc 0 T for all z, t.
+    -- Directly from `_h_boundary` (the picard fixed-point flow's boundary output).
+    -- The measure in the velocity derivative uses spatialMarginal (f t) where
+    -- f = vlasovSolutionViaPushforward charX charV f₀, which is the same as
+    -- what _h_boundary was built against.
+    exact _h_boundary
+  · -- (g) Initial condition for the outer charX charV witnesses.
+    -- From _hflow_on.1 (IsCharacteristicFlowOn's first conjunct).
+    intro z
+    exact _hflow_on.1 z (Set.mem_univ z)
+
+end Vlasov
diff --git a/LeanPool/Vlasov/OT/TestApproximation.lean b/LeanPool/Vlasov/OT/TestApproximation.lean
new file mode 100644
index 0000000000..532e7a4969
--- /dev/null
+++ b/LeanPool/Vlasov/OT/TestApproximation.lean
@@ -0,0 +1,715 @@
+/-
+Copyright (c) 2026 Joseph K. Miller. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Joseph K. Miller
+-/
+module
+
+public import LeanPool.Vlasov.OT.CharacteristicFlow
+public import Mathlib.Analysis.Calculus.BumpFunction.FiniteDimension
+public import Mathlib.Analysis.Calculus.BumpFunction.Normed
+import Mathlib.Algebra.Order.Ring.Star
+import Mathlib.Analysis.Calculus.BumpFunction.Convolution
+
+/-!
+# Compactly supported test approximation for weak Vlasov solutions
+
+Mollification converges together with its first derivative. These estimates extend
+the weak equation to compactly supported C¹ tests, independently of flow inversion.
+-/
+
+@[expose] public section
+
+namespace Vlasov
+
+open MeasureTheory
+
+variable {d : ℕ} [NeZero d]
+
+open Filter Topology Metric in
+open scoped Convolution in
+omit [NeZero d] in
+/-- Helper 1 — uniform mollification of a continuous, compactly-supported function.
+The mollified family `ρ_n ⋆ g` converges to `g` **uniformly** (not just pointwise), the
+load-bearing analytic input the `C¹_c` test-class enlargement (#4) needs.  Proof: uniform
+continuity of `g` (compact support) gives a single `δ`; once `rOut_n < δ`, the pointwise bump
+estimate `dist_normed_convolution_le` fires at *every* base point simultaneously. -/
+theorem mollifier_tendstoUniformly {E : Type*}
+    [NormedAddCommGroup E] [NormedSpace ℝ E] [CompleteSpace E]
+    (g : PhaseSpace d → E) (hg_cont : Continuous g) (hg_cs : HasCompactSupport g)
+    (φ : ℕ → ContDiffBump (0 : PhaseSpace d))
+    (hφ : Tendsto (fun n => (φ n).rOut) atTop (𝓝 0)) :
+    TendstoUniformly
+      (fun n x => ((φ n).normed volume ⋆[ContinuousLinearMap.lsmul ℝ ℝ, volume] g) x) g atTop := by
+  have hHaar : (volume : Measure (PhaseSpace d)).IsAddHaarMeasure := by
+    rw [show (volume : Measure (PhaseSpace d)) = (volume : Measure (PhysSpace d)).prod volume from
+      Measure.volume_eq_prod _ _]
+    infer_instance
+  have hg_uc : UniformContinuous g := hg_cs.uniformContinuous_of_continuous hg_cont
+  rw [Metric.uniformContinuous_iff] at hg_uc
+  rw [Metric.tendstoUniformly_iff]
+  intro ε hε
+  obtain ⟨δ, hδ, hδ_prop⟩ := hg_uc (ε / 2) (by positivity)
+  have hev : ∀ᶠ n in atTop, (φ n).rOut < δ := hφ.eventually (Iio_mem_nhds hδ)
+  filter_upwards [hev] with n hn
+  intro x₀
+  rw [dist_comm]
+  have hball : ∀ x ∈ ball x₀ (φ n).rOut, dist (g x) (g x₀) ≤ ε / 2 := by
+    intro x hx
+    exact le_of_lt (hδ_prop (lt_trans (mem_ball.mp hx) hn))
+  have hbump := ContDiffBump.dist_normed_convolution_le (μ := volume) (φ := φ n) (g := g)
+    hg_cont.aestronglyMeasurable hball
+  exact lt_of_le_of_lt hbump (half_lt_self hε)
+
+open Filter Topology Metric in
+open scoped Convolution in
+omit [NeZero d] in
+/-- Helper 2 — the mollified Fréchet derivative converges uniformly.
+`fderiv (ρ_n ⋆ χ) = ρ_n ⋆ (fderiv χ)` (convolution commutes onto the `C¹` factor via
+`HasCompactSupport.hasFDerivAt_convolution_right`, with `precompR` reconciled to `lsmul` on the
+operator codomain), and the right-hand side converges uniformly to `fderiv χ` by Helper 1 applied
+to the continuous, compactly-supported `fderiv χ`. -/
+theorem mollifiedFDeriv_tendstoUniformly
+    (χ : PhaseSpace d → ℝ) (hχ_C1 : ContDiff ℝ 1 χ) (hχc : HasCompactSupport χ)
+    (φ : ℕ → ContDiffBump (0 : PhaseSpace d))
+    (hφ : Tendsto (fun n => (φ n).rOut) atTop (𝓝 0)) :
+    TendstoUniformly
+      (fun n z => fderiv ℝ ((φ n).normed volume ⋆[ContinuousLinearMap.lsmul ℝ ℝ, volume] χ) z)
+      (fderiv ℝ χ) atTop := by
+  have hHaar : (volume : Measure (PhaseSpace d)).IsAddHaarMeasure := by
+    rw [show (volume : Measure (PhaseSpace d)) = (volume : Measure (PhysSpace d)).prod volume from
+      Measure.volume_eq_prod _ _]
+    infer_instance
+  have hdf_cont : Continuous (fderiv ℝ χ) := hχ_C1.continuous_fderiv one_ne_zero
+  have hdf_cs : HasCompactSupport (fderiv ℝ χ) := hχc.fderiv ℝ
+  -- the `precompR` bilinear map coincides with `lsmul` on the operator codomain
+  have hbridge : (ContinuousLinearMap.lsmul ℝ ℝ).precompR (PhaseSpace d)
+      = (ContinuousLinearMap.lsmul ℝ ℝ :
+          ℝ →L[ℝ] (PhaseSpace d →L[ℝ] ℝ) →L[ℝ] (PhaseSpace d →L[ℝ] ℝ)) := by
+    refine ContinuousLinearMap.ext fun u => ?_
+    refine ContinuousLinearMap.ext fun v => ?_
+    refine ContinuousLinearMap.ext fun x => ?_
+    simp [ContinuousLinearMap.precompR_apply, ContinuousLinearMap.lsmul_apply]
+  have hfd : ∀ n, (fun z => fderiv ℝ
+        ((φ n).normed volume ⋆[ContinuousLinearMap.lsmul ℝ ℝ, volume] χ) z)
+      = (fun z => ((φ n).normed volume ⋆[ContinuousLinearMap.lsmul ℝ ℝ, volume] fderiv ℝ χ) z) := by
+    intro n
+    funext z
+    rw [(hχc.hasFDerivAt_convolution_right (L := ContinuousLinearMap.lsmul ℝ ℝ)
+      ((φ n).continuous_normed.locallyIntegrable) hχ_C1 z).fderiv, hbridge]
+  have hgoal_eq :
+      (fun n z => fderiv ℝ ((φ n).normed volume ⋆[ContinuousLinearMap.lsmul ℝ ℝ, volume] χ) z)
+      = (fun n z =>
+          ((φ n).normed volume ⋆[ContinuousLinearMap.lsmul ℝ ℝ, volume] fderiv ℝ χ) z) := by
+    funext n; exact hfd n
+  rw [hgoal_eq]
+  exact mollifier_tendstoUniformly (fderiv ℝ χ) hdf_cont hdf_cs φ hφ
+
+-- ── Helpers for `weakEvolution_test_C1c_On`, extracted from its proof body (the
+--    mathematical content is unchanged; each piece is generic in the test function). ──
+
+omit [NeZero d] in
+/-- Norm bound for the dual-composed difference of two Fréchet derivatives. -/
+lemma toDualSymm_comp_sub_norm_le (ψ ϕ : PhaseSpace d → ℝ)
+    (z : PhaseSpace d) (e : PhysSpace d →L[ℝ] PhaseSpace d) :
+    ‖(InnerProductSpace.toDual ℝ (PhysSpace d)).symm ((fderiv ℝ ψ z).comp e)
+      - (InnerProductSpace.toDual ℝ (PhysSpace d)).symm ((fderiv ℝ ϕ z).comp e)‖
+    ≤ ‖fderiv ℝ ψ z - fderiv ℝ ϕ z‖ * ‖e‖ := by
+  rw [← map_sub, LinearIsometryEquiv.norm_map, ← ContinuousLinearMap.sub_comp]
+  exact ContinuousLinearMap.opNorm_comp_le _ _
+
+omit [NeZero d] in
+/-- Chain rule: the Fréchet derivative of an `x`-slice is the composition with `inl`. -/
+lemma fderiv_slice_fst (ψ : PhaseSpace d → ℝ) (hψ : Differentiable ℝ ψ) (z : PhaseSpace d) :
+    fderiv ℝ (fun x => ψ (x, z.2)) z.1
+      = (fderiv ℝ ψ z).comp (ContinuousLinearMap.inl ℝ (PhysSpace d) (PhysSpace d)) := by
+  have h2 : HasFDerivAt (fun x : PhysSpace d => (x, z.2))
+      (ContinuousLinearMap.inl ℝ (PhysSpace d) (PhysSpace d)) z.1 :=
+    hasFDerivAt_prodMk_left z.1 z.2
+  exact ((hψ z).hasFDerivAt.comp z.1 h2).fderiv
+
+omit [NeZero d] in
+/-- Chain rule: the Fréchet derivative of a `v`-slice is the composition with `inr`. -/
+lemma fderiv_slice_snd (ψ : PhaseSpace d → ℝ) (hψ : Differentiable ℝ ψ) (z : PhaseSpace d) :
+    fderiv ℝ (fun v => ψ (z.1, v)) z.2
+      = (fderiv ℝ ψ z).comp (ContinuousLinearMap.inr ℝ (PhysSpace d) (PhysSpace d)) := by
+  have h2 : HasFDerivAt (fun v : PhysSpace d => (z.1, v))
+      (ContinuousLinearMap.inr ℝ (PhysSpace d) (PhysSpace d)) z.2 :=
+    hasFDerivAt_prodMk_right z.1 z.2
+  exact ((hψ z).hasFDerivAt.comp z.2 h2).fderiv
+
+omit [NeZero d] in
+/-- Continuity of the first-slot partial-gradient field of a `C¹` test function. -/
+lemma continuous_gradientSlice_fst (ψ : PhaseSpace d → ℝ) (g : PhaseSpace d → PhysSpace d)
+    (hψ : Differentiable ℝ ψ) (hψ' : Continuous (fderiv ℝ ψ))
+    (hg : ∀ z, g z = gradient (fun x => ψ (x, z.2)) z.1) : Continuous g := by
+  have heq : g = fun z => (InnerProductSpace.toDual ℝ (PhysSpace d)).symm
+      ((fderiv ℝ ψ z).comp (ContinuousLinearMap.inl ℝ (PhysSpace d) (PhysSpace d))) := by
+    funext z; rw [hg z]; simp only [gradient]; rw [fderiv_slice_fst ψ hψ z]
+  rw [heq]
+  exact (InnerProductSpace.toDual ℝ (PhysSpace d)).symm.continuous.comp
+    (hψ'.clm_comp continuous_const)
+
+omit [NeZero d] in
+/-- Continuity of the second-slot partial-gradient field of a `C¹` test function. -/
+lemma continuous_gradientSlice_snd (ψ : PhaseSpace d → ℝ) (g : PhaseSpace d → PhysSpace d)
+    (hψ : Differentiable ℝ ψ) (hψ' : Continuous (fderiv ℝ ψ))
+    (hg : ∀ z, g z = gradient (fun v => ψ (z.1, v)) z.2) : Continuous g := by
+  have heq : g = fun z => (InnerProductSpace.toDual ℝ (PhysSpace d)).symm
+      ((fderiv ℝ ψ z).comp (ContinuousLinearMap.inr ℝ (PhysSpace d) (PhysSpace d))) := by
+    funext z; rw [hg z]; simp only [gradient]; rw [fderiv_slice_snd ψ hψ z]
+  rw [heq]
+  exact (InnerProductSpace.toDual ℝ (PhysSpace d)).symm.continuous.comp
+    (hψ'.clm_comp continuous_const)
+
+omit [NeZero d] in
+/-- Compact support of the first-slot partial-gradient field. -/
+lemma hasCompactSupport_gradientSlice_fst (ψ : PhaseSpace d → ℝ)
+    (g : PhaseSpace d → PhysSpace d) (hψ : Differentiable ℝ ψ) (hψcs : HasCompactSupport ψ)
+    (hg : ∀ z, g z = gradient (fun x => ψ (x, z.2)) z.1) : HasCompactSupport g := by
+  apply HasCompactSupport.intro hψcs
+  intro z hz
+  have hf0 : fderiv ℝ ψ z = 0 := fderiv_of_notMem_tsupport ℝ hz
+  rw [hg z]; simp only [gradient]; rw [fderiv_slice_fst ψ hψ z, hf0]; simp
+
+omit [NeZero d] in
+/-- Compact support of the second-slot partial-gradient field. -/
+lemma hasCompactSupport_gradientSlice_snd (ψ : PhaseSpace d → ℝ)
+    (g : PhaseSpace d → PhysSpace d) (hψ : Differentiable ℝ ψ) (hψcs : HasCompactSupport ψ)
+    (hg : ∀ z, g z = gradient (fun v => ψ (z.1, v)) z.2) : HasCompactSupport g := by
+  apply HasCompactSupport.intro hψcs
+  intro z hz
+  have hf0 : fderiv ℝ ψ z = 0 := fderiv_of_notMem_tsupport ℝ hz
+  rw [hg z]; simp only [gradient]; rw [fderiv_slice_snd ψ hψ z, hf0]; simp
+
+omit [NeZero d] in
+/-- First-slot partial gradients of two tests differ by at most the full
+Fréchet-derivative difference. -/
+lemma gradientSlice_fst_sub_norm_le (ψ ϕ : PhaseSpace d → ℝ)
+    (hψ : Differentiable ℝ ψ) (hϕ : Differentiable ℝ ϕ)
+    (gψ gϕ : PhaseSpace d → PhysSpace d)
+    (hgψ : ∀ z, gψ z = gradient (fun x => ψ (x, z.2)) z.1)
+    (hgϕ : ∀ z, gϕ z = gradient (fun x => ϕ (x, z.2)) z.1) (z : PhaseSpace d) :
+    ‖gψ z - gϕ z‖ ≤ ‖fderiv ℝ ψ z - fderiv ℝ ϕ z‖ := by
+  have e1 : gψ z = (InnerProductSpace.toDual ℝ (PhysSpace d)).symm
+      ((fderiv ℝ ψ z).comp (ContinuousLinearMap.inl ℝ (PhysSpace d) (PhysSpace d))) := by
+    rw [hgψ z]; simp only [gradient]; rw [fderiv_slice_fst ψ hψ z]
+  have e2 : gϕ z = (InnerProductSpace.toDual ℝ (PhysSpace d)).symm
+      ((fderiv ℝ ϕ z).comp (ContinuousLinearMap.inl ℝ (PhysSpace d) (PhysSpace d))) := by
+    rw [hgϕ z]; simp only [gradient]; rw [fderiv_slice_fst ϕ hϕ z]
+  rw [e1, e2]
+  refine le_trans (toDualSymm_comp_sub_norm_le ψ ϕ z _) ?_
+  calc ‖fderiv ℝ ψ z - fderiv ℝ ϕ z‖ * ‖ContinuousLinearMap.inl ℝ (PhysSpace d) (PhysSpace d)‖
+      ≤ ‖fderiv ℝ ψ z - fderiv ℝ ϕ z‖ * 1 := by
+        gcongr; exact ContinuousLinearMap.norm_inl_le_one ℝ (PhysSpace d) (PhysSpace d)
+    _ = ‖fderiv ℝ ψ z - fderiv ℝ ϕ z‖ := mul_one _
+
+omit [NeZero d] in
+/-- Second-slot partial gradients of two tests differ by at most the full
+Fréchet-derivative difference. -/
+lemma gradientSlice_snd_sub_norm_le (ψ ϕ : PhaseSpace d → ℝ)
+    (hψ : Differentiable ℝ ψ) (hϕ : Differentiable ℝ ϕ)
+    (gψ gϕ : PhaseSpace d → PhysSpace d)
+    (hgψ : ∀ z, gψ z = gradient (fun v => ψ (z.1, v)) z.2)
+    (hgϕ : ∀ z, gϕ z = gradient (fun v => ϕ (z.1, v)) z.2) (z : PhaseSpace d) :
+    ‖gψ z - gϕ z‖ ≤ ‖fderiv ℝ ψ z - fderiv ℝ ϕ z‖ := by
+  have e1 : gψ z = (InnerProductSpace.toDual ℝ (PhysSpace d)).symm
+      ((fderiv ℝ ψ z).comp (ContinuousLinearMap.inr ℝ (PhysSpace d) (PhysSpace d))) := by
+    rw [hgψ z]; simp only [gradient]; rw [fderiv_slice_snd ψ hψ z]
+  have e2 : gϕ z = (InnerProductSpace.toDual ℝ (PhysSpace d)).symm
+      ((fderiv ℝ ϕ z).comp (ContinuousLinearMap.inr ℝ (PhysSpace d) (PhysSpace d))) := by
+    rw [hgϕ z]; simp only [gradient]; rw [fderiv_slice_snd ϕ hϕ z]
+  rw [e1, e2]
+  refine le_trans (toDualSymm_comp_sub_norm_le ψ ϕ z _) ?_
+  calc ‖fderiv ℝ ψ z - fderiv ℝ ϕ z‖ * ‖ContinuousLinearMap.inr ℝ (PhysSpace d) (PhysSpace d)‖
+      ≤ ‖fderiv ℝ ψ z - fderiv ℝ ϕ z‖ * 1 := by
+        gcongr; exact ContinuousLinearMap.norm_inr_le_one ℝ (PhysSpace d) (PhysSpace d)
+    _ = ‖fderiv ℝ ψ z - fderiv ℝ ϕ z‖ := mul_one _
+
+omit [NeZero d] in
+/-- Integrability of the weak-evolution integrand against a probability measure:
+continuous with compact support (both gradient slots), continuous field. -/
+lemma inner_integrand_integrable
+    (μ : Measure (PhaseSpace d)) [IsProbabilityMeasure μ]
+    (fld : PhysSpace d → PhysSpace d) (hfld : Continuous fld)
+    (gX gV : PhaseSpace d → PhysSpace d)
+    (hgXc : Continuous gX) (hgVc : Continuous gV)
+    (hgXcs : HasCompactSupport gX) (hgVcs : HasCompactSupport gV) :
+    Integrable (fun z => @inner ℝ (PhysSpace d) _ z.2 (gX z)
+      - @inner ℝ (PhysSpace d) _ (fld z.1) (gV z)) μ := by
+  have hcont : Continuous (fun z => @inner ℝ (PhysSpace d) _ z.2 (gX z)
+      - @inner ℝ (PhysSpace d) _ (fld z.1) (gV z)) :=
+    (continuous_snd.inner hgXc).sub ((hfld.comp continuous_fst).inner hgVc)
+  have hcs : HasCompactSupport (fun z => @inner ℝ (PhysSpace d) _ z.2 (gX z)
+      - @inner ℝ (PhysSpace d) _ (fld z.1) (gV z)) := by
+    apply HasCompactSupport.intro (IsCompact.union hgXcs hgVcs)
+    intro z hz
+    simp only [Set.mem_union, not_or] at hz
+    rw [image_eq_zero_of_notMem_tsupport hz.1, image_eq_zero_of_notMem_tsupport hz.2]
+    simp
+  exact hcont.integrable_of_hasCompactSupport hcs
+
+omit [NeZero d] in
+/-- Pointwise bound on the difference of two weak-evolution integrands: on the
+common support `K` it is `(R_K + B) * δ` (norm bound `R_K` on `K`, field bound `B`
+on `K`, gradient-slot distance `δ`); off `K` both integrands agree. -/
+lemma inner_integrand_sub_norm_le
+    (K : Set (PhaseSpace d)) (R_K : ℝ) (hR_K_nn : 0 ≤ R_K) (hR_K : ∀ z ∈ K, ‖z‖ ≤ R_K)
+    (fld : PhysSpace d → PhysSpace d) (B : ℝ) (hB_nn : 0 ≤ B)
+    (hfld_K : ∀ z ∈ K, ‖fld (Prod.fst z)‖ ≤ B)
+    (gX gV gX' gV' : PhaseSpace d → PhysSpace d) (δ : ℝ) (hδ_nn : 0 ≤ δ)
+    (hXd : ∀ z, ‖gX' z - gX z‖ ≤ δ) (hVd : ∀ z, ‖gV' z - gV z‖ ≤ δ)
+    (hXoff : ∀ z ∉ K, gX' z = gX z) (hVoff : ∀ z ∉ K, gV' z = gV z)
+    (z : PhaseSpace d) :
+    ‖(@inner ℝ (PhysSpace d) _ z.2 (gX z) - @inner ℝ (PhysSpace d) _ (fld z.1) (gV z))
+      - (@inner ℝ (PhysSpace d) _ z.2 (gX' z)
+          - @inner ℝ (PhysSpace d) _ (fld z.1) (gV' z))‖
+    ≤ (R_K + B) * δ := by
+  by_cases hzK : z ∈ K
+  · have hrw : (@inner ℝ (PhysSpace d) _ z.2 (gX z)
+          - @inner ℝ (PhysSpace d) _ (fld z.1) (gV z))
+        - (@inner ℝ (PhysSpace d) _ z.2 (gX' z)
+          - @inner ℝ (PhysSpace d) _ (fld z.1) (gV' z))
+        = @inner ℝ (PhysSpace d) _ z.2 (gX z - gX' z)
+          - @inner ℝ (PhysSpace d) _ (fld z.1) (gV z - gV' z) := by
+      rw [inner_sub_right, inner_sub_right]; ring
+    rw [Real.norm_eq_abs, hrw]
+    have hb1 : |@inner ℝ (PhysSpace d) _ z.2 (gX z - gX' z)| ≤ R_K * δ := by
+      refine le_trans (abs_real_inner_le_norm _ _) ?_
+      have hz2 : ‖z.2‖ ≤ R_K := le_trans (norm_snd_le z) (hR_K z hzK)
+      rw [norm_sub_rev (gX z)]
+      exact mul_le_mul hz2 (hXd z) (norm_nonneg _) hR_K_nn
+    have hb2 : |@inner ℝ (PhysSpace d) _ (fld z.1) (gV z - gV' z)| ≤ B * δ := by
+      refine le_trans (abs_real_inner_le_norm _ _) ?_
+      rw [norm_sub_rev (gV z)]
+      exact mul_le_mul (hfld_K z hzK) (hVd z) (norm_nonneg _) hB_nn
+    calc |@inner ℝ (PhysSpace d) _ z.2 (gX z - gX' z)
+            - @inner ℝ (PhysSpace d) _ (fld z.1) (gV z - gV' z)|
+        ≤ |@inner ℝ (PhysSpace d) _ z.2 (gX z - gX' z)|
+          + |@inner ℝ (PhysSpace d) _ (fld z.1) (gV z - gV' z)| := abs_sub _ _
+      _ ≤ R_K * δ + B * δ := by linarith
+      _ = (R_K + B) * δ := by ring
+  · rw [hXoff z hzK, hVoff z hzK]
+    simp only [sub_self, norm_zero]
+    positivity
+
+omit [NeZero d] in
+/-- On the window, the frozen convolution field over the spatial marginal is
+integrable (in force form), linearly bounded, and continuous — packaged for
+consumers that quantify over the window. -/
+lemma convolveField_window_setup
+    (gradW : PhysSpace d → PhysSpace d)
+    (L : NNReal) (hL : LipschitzWith L gradW)
+    (f : ℝ → Measure (PhaseSpace d)) (T : ℝ)
+    (hf_mom : ∀ t ∈ Set.Icc (0 : ℝ) T, HasFiniteFirstMoment (f t))
+    (M_ρ : ℝ)
+    (hM_ρ : ∀ t ∈ Set.Icc (0 : ℝ) T, ∫ y, ‖y‖ ∂(spatialMarginal (f t)) ≤ M_ρ)
+    (ε₀ : ℝ) (hε₀_def : ε₀ = ‖gradW 0‖ + (L : ℝ) * M_ρ) :
+    ∀ σ ∈ Set.Icc (0 : ℝ) T,
+      (Integrable (fun y : PhysSpace d => ‖y‖) (spatialMarginal (f σ)))
+      ∧ (∀ x : PhysSpace d, Integrable (fun y => gradW (x - y)) (spatialMarginal (f σ)))
+      ∧ (∀ x : PhysSpace d,
+          ‖convolveFunctionMeasure gradW (spatialMarginal (f σ)) x‖ ≤ ε₀ + (L:ℝ) * ‖x‖)
+      ∧ Continuous (fun x => convolveFunctionMeasure gradW (spatialMarginal (f σ)) x) := by
+  intro σ hσ
+  have : IsProbabilityMeasure (f σ) := (hf_mom σ hσ).1
+  have hprob_m : IsProbabilityMeasure (spatialMarginal (f σ)) :=
+    (Measure.isProbabilityMeasure_map_iff measurable_fst.aemeasurable).mpr inferInstance
+  -- ‖·‖ integrable wrt the spatial marginal (from the finite first moment of f σ)
+  have h_y_int : Integrable (fun y : PhysSpace d => ‖y‖) (spatialMarginal (f σ)) := by
+    unfold spatialMarginal
+    rw [integrable_map_measure (continuous_norm.measurable).aestronglyMeasurable
+      measurable_fst.aemeasurable]
+    refine Integrable.mono' (hf_mom σ hσ).2
+      ((continuous_norm.comp continuous_fst).aestronglyMeasurable)
+      (Filter.Eventually.of_forall fun z => ?_)
+    change |‖z.1‖| ≤ ‖z‖
+    rw [abs_of_nonneg (norm_nonneg _)]; exact norm_fst_le z
+  -- force-integrability (Lipschitz growth + finite moment)
+  have h_int : ∀ x : PhysSpace d,
+      Integrable (fun y => gradW (x - y)) (spatialMarginal (f σ)) := by
+    intro x
+    have h_aesm : AEStronglyMeasurable (fun y : PhysSpace d => gradW (x - y))
+        (spatialMarginal (f σ)) :=
+      (hL.continuous.comp (continuous_const.sub continuous_id)).aestronglyMeasurable
+    have h_dom : ∀ y : PhysSpace d,
+        ‖gradW (x - y)‖ ≤ ‖gradW 0‖ + (L:ℝ) * ‖x‖ + (L:ℝ) * ‖y‖ := by
+      intro y
+      have hd := hL.dist_le_mul (x - y) 0
+      simp only [dist_eq_norm, sub_zero] at hd
+      have h_tri : ‖gradW (x - y)‖ ≤ ‖gradW 0‖ + ‖gradW (x - y) - gradW 0‖ := by
+        have := norm_add_le (gradW (x - y) - gradW 0) (gradW 0)
+        simp only [sub_add_cancel] at this; linarith
+      have h_sub_le : ‖x - y‖ ≤ ‖x‖ + ‖y‖ := norm_sub_le x y
+      have h_mul := mul_le_mul_of_nonneg_left h_sub_le L.coe_nonneg
+      linarith
+    have h_dom_int : Integrable
+        (fun y : PhysSpace d => ‖gradW 0‖ + (L:ℝ) * ‖x‖ + (L:ℝ) * ‖y‖)
+        (spatialMarginal (f σ)) := by
+      have h_eq : (fun y : PhysSpace d => ‖gradW 0‖ + (L:ℝ) * ‖x‖ + (L:ℝ) * ‖y‖)
+          = fun y => (‖gradW 0‖ + (L:ℝ) * ‖x‖) + (L:ℝ) * ‖y‖ := by funext y; ring
+      rw [h_eq]; exact (integrable_const _).add (h_y_int.const_mul _)
+    exact Integrable.mono' h_dom_int h_aesm (Filter.Eventually.of_forall h_dom)
+  -- field bound (CharFlow idiom)
+  have hbound : ∀ x : PhysSpace d,
+      ‖convolveFunctionMeasure gradW (spatialMarginal (f σ)) x‖ ≤ ε₀ + (L:ℝ) * ‖x‖ := by
+    intro x
+    rw [hε₀_def]
+    exact norm_convolveFunctionMeasure_le_affine gradW L hL (spatialMarginal (f σ))
+      h_int h_y_int M_ρ (hM_ρ σ hσ) x
+  -- field continuity from the Lipschitz-in-x lemma
+  have hcont : Continuous (fun x => convolveFunctionMeasure gradW (spatialMarginal (f σ)) x) :=
+    (convolveFunctionMeasure_lipschitz_in_x gradW L hL (spatialMarginal (f σ)) h_int).continuous
+  exact ⟨h_y_int, h_int, hbound, hcont⟩
+
+omit [NeZero d] in
+open Filter Topology Metric in
+/-- Uniform convergence of integrands implies convergence of the integrals against
+a probability measure (every term integrable). -/
+lemma integral_tendsto_of_tendstoUniformly
+    (μ : Measure (PhaseSpace d)) [IsProbabilityMeasure μ]
+    (g : ℕ → PhaseSpace d → ℝ) (g₀ : PhaseSpace d → ℝ)
+    (hUnif : TendstoUniformly g g₀ atTop)
+    (hg₀_int : Integrable g₀ μ) (hg_int : ∀ n, Integrable (g n) μ) :
+    Tendsto (fun n => ∫ z, g n z ∂μ) atTop (𝓝 (∫ z, g₀ z ∂μ)) := by
+  rw [Metric.tendsto_atTop]
+  intro ε hε
+  obtain ⟨N, hN⟩ := eventually_atTop.mp
+    (Metric.tendstoUniformly_iff.mp hUnif (ε/2) (by positivity))
+  refine ⟨N, fun n hn => ?_⟩
+  rw [Real.dist_eq]
+  have hpt : ∀ z, |g n z - g₀ z| ≤ ε/2 := by
+    intro z
+    have h := hN n hn z
+    rw [Real.dist_eq, abs_sub_comm] at h
+    exact le_of_lt h
+  calc |∫ z, g n z ∂μ - ∫ z, g₀ z ∂μ|
+      = |∫ z, (g n z - g₀ z) ∂μ| := by rw [integral_sub (hg_int n) hg₀_int]
+    _ ≤ ∫ z, |g n z - g₀ z| ∂μ := abs_integral_le_integral_abs
+    _ ≤ ∫ _z, (ε/2) ∂μ :=
+        integral_mono_of_nonneg (Eventually.of_forall fun z => abs_nonneg _)
+          (integrable_const _) (Eventually.of_forall hpt)
+    _ = ε/2 := by simp
+    _ < ε := half_lt_self hε
+
+-- #4 (Step 5 interface): the weak evolution equation extended to C¹_c test functions.
+open Filter Topology Metric in
+open scoped Convolution Pointwise in
+omit [NeZero d] in
+theorem weakEvolution_test_C1c_On
+    (gradW : PhysSpace d → PhysSpace d)
+    (f : ℝ → Measure (PhaseSpace d)) (T : ℝ)
+    (hf_weak : IsVlasovSolutionOn gradW f T)
+    (hf_mom : ∀ t ∈ Set.Icc (0 : ℝ) T, HasFiniteFirstMoment (f t))
+    -- B2 enrichment (mollification proof): the velocity-term needs a uniform-in-σ bound on the
+    -- frozen field `‖∇W∗ρ_σ‖` over the fixed compact support of the test, supplied by the
+    -- Lipschitz growth of `gradW` (`hL`) and the uniform first-moment bound `hM_ρ`.
+    (L : NNReal) (hL : LipschitzWith L gradW)
+    (M_ρ : ℝ) (hM_ρ_nn : 0 ≤ M_ρ)
+    (hM_ρ : ∀ t ∈ Set.Icc (0 : ℝ) T, ∫ y, ‖y‖ ∂(spatialMarginal (f t)) ≤ M_ρ)
+    (χ : PhaseSpace d → ℝ) (hχ_C1 : ContDiff ℝ 1 χ) (hχc : HasCompactSupport χ)
+    (gradXχ gradVχ : PhaseSpace d → PhysSpace d)
+    (hgradXχ : ∀ z, gradXχ z = gradient (fun x => χ (x, z.2)) z.1)
+    (hgradVχ : ∀ z, gradVχ z = gradient (fun v => χ (z.1, v)) z.2)
+    (s : ℝ) (hs : s ∈ Set.Ioo (0 : ℝ) T) :
+    HasDerivAt (fun σ => ∫ z, χ z ∂(f σ))
+      (∫ z, (@inner ℝ (PhysSpace d) _ z.2 (gradXχ z)
+             - @inner ℝ (PhysSpace d) _
+                (convolveFunctionMeasure gradW (spatialMarginal (f s)) z.1)
+                (gradVχ z)) ∂(f s)) s := by
+  classical
+  have hHaar : (volume : Measure (PhaseSpace d)).IsAddHaarMeasure := by
+    rw [show (volume : Measure (PhaseSpace d)) = (volume : Measure (PhysSpace d)).prod volume from
+      Measure.volume_eq_prod _ _]
+    infer_instance
+  have hvolReg : (volume : Measure (PhaseSpace d)).Regular :=
+    Measure.Regular.of_sigmaCompactSpace_of_isLocallyFiniteMeasure _
+  -- mollifier family (shrinking bumps); copy of #9's
+  set φ : ℕ → ContDiffBump (0 : PhaseSpace d) :=
+    fun n => ⟨1 / (n + 2), 2 / (n + 2), by positivity, by
+      rw [div_lt_div_iff_of_pos_right (by positivity)]; norm_num⟩ with hφ_def
+  have hrout : ∀ n, (φ n).rOut = 2 / (n + 2) := fun n => rfl
+  have hrout_tendsto : Tendsto (fun n => (φ n).rOut) atTop (𝓝 0) := by
+    simp only [hrout]
+    apply Filter.Tendsto.div_atTop (tendsto_const_nhds)
+    exact Filter.tendsto_atTop_add_const_right _ 2 tendsto_natCast_atTop_atTop
+  -- mollified test functions
+  set χn : ℕ → PhaseSpace d → ℝ :=
+    fun n => (φ n).normed volume ⋆[ContinuousLinearMap.lsmul ℝ ℝ, volume] χ with hχn_def
+  have hχn_smooth : ∀ n, ContDiff ℝ (⊤ : ℕ∞) (χn n) := fun n =>
+    ((φ n).hasCompactSupport_normed).contDiff_convolution_left _
+      (φ n).contDiff_normed hχ_C1.continuous.locallyIntegrable
+  have hχn_cs : ∀ n, HasCompactSupport (χn n) := fun n =>
+    HasCompactSupport.convolution _ (φ n).hasCompactSupport_normed hχc
+  -- genuine partial gradients of χ_n
+  set gXn : ℕ → PhaseSpace d → PhysSpace d :=
+    fun n z => gradient (fun x => χn n (x, z.2)) z.1 with hgXn_def
+  set gVn : ℕ → PhaseSpace d → PhysSpace d :=
+    fun n z => gradient (fun v => χn n (z.1, v)) z.2 with hgVn_def
+  -- D_n: the C^∞ weak-evolution derivative, from hf_weak applied to χ_n
+  have hDn : ∀ n, ∀ σ ∈ Set.Ioo (0 : ℝ) T, HasDerivAt (fun σ' => ∫ z, χn n z ∂(f σ'))
+      (∫ z, (@inner ℝ (PhysSpace d) _ z.2 (gXn n z)
+             - @inner ℝ (PhysSpace d) _
+                (convolveFunctionMeasure gradW (spatialMarginal (f σ)) z.1)
+                (gVn n z)) ∂(f σ)) σ := by
+    intro n σ hσ
+    have h := hf_weak (χn n) (hχn_smooth n) (hχn_cs n) (gXn n) (gVn n)
+      (fun z => rfl) (fun z => rfl) σ hσ
+    simpa using h
+  -- pointwise convergence (0th order): ∫ χ_n d(f σ) → ∫ χ d(f σ)
+  have hfg : ∀ σ ∈ Set.Ioo (0 : ℝ) T, Tendsto (fun n => ∫ z, χn n z ∂(f σ)) atTop
+      (𝓝 (∫ z, χ z ∂(f σ))) := by
+    intro σ hσ
+    have : IsProbabilityMeasure (f σ) := (hf_mom σ (Set.Ioo_subset_Icc_self hσ)).1
+    exact integral_tendsto_of_tendstoUniformly (f σ) χn χ
+      (mollifier_tendstoUniformly χ hχ_C1.continuous hχc φ hrout_tendsto)
+      (hχ_C1.continuous.integrable_of_hasCompactSupport hχc)
+      (fun n => (hχn_smooth n).continuous.integrable_of_hasCompactSupport (hχn_cs n))
+  -- uniform-in-σ convergence of the derivatives (the term bound)
+  -- Helper 2: uniform fderiv convergence
+  have hH2 := mollifiedFDeriv_tendstoUniformly χ hχ_C1 hχc φ hrout_tendsto
+  -- fixed compact K containing all supports
+  set K : Set (PhaseSpace d) := tsupport χ + Metric.closedBall (0 : PhaseSpace d) 1 with hK_def
+  have hK_compact : IsCompact K := IsCompact.add hχc (isCompact_closedBall 0 1)
+  obtain ⟨R0, hR0⟩ := (hK_compact.image continuous_norm).bddAbove
+  set R_K := max R0 0 with hRK_def
+  have hR_K_nn : (0 : ℝ) ≤ R_K := le_max_right _ _
+  have hR_K : ∀ z ∈ K, ‖z‖ ≤ R_K := fun z hz => le_trans (hR0 ⟨z, hz, rfl⟩) (le_max_left _ _)
+  -- tsupport χ ⊆ K, and fderiv χ vanishes off K
+  have htsuppχ_K : tsupport χ ⊆ K := by
+    intro z hz
+    rw [hK_def]
+    exact (add_zero z) ▸ Set.add_mem_add hz (by simp : (0:PhaseSpace d) ∈ Metric.closedBall 0 1)
+  have hsuppχ : ∀ z ∉ K, fderiv ℝ χ z = 0 := by
+    intro z hz
+    exact fderiv_of_notMem_tsupport ℝ (fun h => hz (htsuppχ_K h))
+  -- tsupport (χn n) ⊆ K, and fderiv (χn n) vanishes off K
+  have htsuppχn_K : ∀ n, tsupport (χn n) ⊆ K := by
+    intro n
+    have h1 : Function.support (χn n)
+        ⊆ Function.support ((φ n).normed volume) + Function.support χ :=
+      support_convolution_subset _
+    have h2 : Function.support ((φ n).normed volume) ⊆ Metric.closedBall 0 1 := by
+      rw [(φ n).support_normed_eq]
+      refine Metric.ball_subset_closedBall.trans (Metric.closedBall_subset_closedBall ?_)
+      rw [hrout n]; rw [div_le_one (by positivity)]; norm_num
+    have h4 : Function.support (χn n) ⊆ K := by
+      refine h1.trans ?_
+      rw [hK_def, add_comm (tsupport χ)]
+      exact Set.add_subset_add h2 (subset_tsupport χ)
+    exact (closure_minimal h4 hK_compact.isClosed)
+  have hsuppχn : ∀ n, ∀ z ∉ K, fderiv ℝ (χn n) z = 0 := by
+    intro n z hz
+    exact fderiv_of_notMem_tsupport ℝ (fun h => hz (htsuppχn_K n h))
+  -- partial-gradient projection bounds (X and V), off Helper 2's fderiv difference
+  -- field: integrability, bound, continuity — all on the window
+  set ε₀ : ℝ := ‖gradW 0‖ + (L : ℝ) * M_ρ with hε₀_def
+  have hε₀_nn : 0 ≤ ε₀ := by positivity
+  have hfield_setup := convolveField_window_setup gradW L hL f T hf_mom M_ρ hM_ρ ε₀ hε₀_def
+  -- THE ESTIMATE
+  -- continuity of the four partial gradients (off the uniform fderiv)
+  have htop : ((⊤ : ℕ∞) : WithTop ℕ∞) ≠ 0 := by simp
+  have hχdiff : Differentiable ℝ χ := hχ_C1.differentiable one_ne_zero
+  have hχ'cont : Continuous (fderiv ℝ χ) := hχ_C1.continuous_fderiv one_ne_zero
+  have hgXχc : Continuous gradXχ :=
+    continuous_gradientSlice_fst χ gradXχ hχdiff hχ'cont hgradXχ
+  have hgVχc : Continuous gradVχ :=
+    continuous_gradientSlice_snd χ gradVχ hχdiff hχ'cont hgradVχ
+  have hgXnc : ∀ n, Continuous (gXn n) := fun n => continuous_gradientSlice_fst (χn n) (gXn n)
+    ((hχn_smooth n).differentiable htop) ((hχn_smooth n).continuous_fderiv htop)
+    (fun z => by rw [hgXn_def])
+  have hgVnc : ∀ n, Continuous (gVn n) := fun n => continuous_gradientSlice_snd (χn n) (gVn n)
+    ((hχn_smooth n).differentiable htop) ((hχn_smooth n).continuous_fderiv htop)
+    (fun z => by rw [hgVn_def])
+  -- compact support of the four partial gradients (vanish off the test's support)
+  have hgXχcs : HasCompactSupport gradXχ :=
+    hasCompactSupport_gradientSlice_fst χ gradXχ hχdiff hχc hgradXχ
+  have hgVχcs : HasCompactSupport gradVχ :=
+    hasCompactSupport_gradientSlice_snd χ gradVχ hχdiff hχc hgradVχ
+  have hgXncs : ∀ n, HasCompactSupport (gXn n) := fun n =>
+    hasCompactSupport_gradientSlice_fst (χn n) (gXn n)
+      ((hχn_smooth n).differentiable htop) (hχn_cs n) (fun z => by rw [hgXn_def])
+  have hgVncs : ∀ n, HasCompactSupport (gVn n) := fun n =>
+    hasCompactSupport_gradientSlice_snd (χn n) (gVn n)
+      ((hχn_smooth n).differentiable htop) (hχn_cs n) (fun z => by rw [hgVn_def])
+  -- THE ESTIMATE
+  have hf'unif : TendstoUniformlyOn
+      (fun n σ => ∫ z, (@inner ℝ (PhysSpace d) _ z.2 (gXn n z)
+             - @inner ℝ (PhysSpace d) _
+                (convolveFunctionMeasure gradW (spatialMarginal (f σ)) z.1) (gVn n z)) ∂(f σ))
+      (fun σ => ∫ z, (@inner ℝ (PhysSpace d) _ z.2 (gradXχ z)
+             - @inner ℝ (PhysSpace d) _
+                (convolveFunctionMeasure gradW (spatialMarginal (f σ)) z.1) (gradVχ z)) ∂(f σ))
+      atTop (Set.Ioo 0 T) := by
+    rw [Metric.tendstoUniformlyOn_iff]
+    intro ε hε
+    set C : ℝ := R_K + (ε₀ + (L:ℝ) * R_K) with hC_def
+    have hC_nn : (0 : ℝ) ≤ C := by rw [hC_def]; positivity
+    rw [Metric.tendstoUniformly_iff] at hH2
+    filter_upwards [hH2 (ε/(C+1)) (by positivity)] with n hn
+    intro σ hσ
+    have hσ' : σ ∈ Set.Icc (0 : ℝ) T := Set.Ioo_subset_Icc_self hσ
+    have : IsProbabilityMeasure (f σ) := (hf_mom σ hσ').1
+    obtain ⟨_, _, hbnd, hfc⟩ := hfield_setup σ hσ'
+    -- L15: make the field opaque so defeq never unfolds its Bochner integral
+    set fldσ : PhysSpace d → PhysSpace d := convolveFunctionMeasure gradW (spatialMarginal (f σ))
+      with hfldσ_def
+    clear_value fldσ
+    -- projection bounds for this n
+    have hXp : ∀ z, ‖gXn n z - gradXχ z‖ ≤ ‖fderiv ℝ (χn n) z - fderiv ℝ χ z‖ :=
+      fun z => gradientSlice_fst_sub_norm_le (χn n) χ
+        ((hχn_smooth n).differentiable htop) hχdiff (gXn n) gradXχ
+        (fun z => by rw [hgXn_def]) hgradXχ z
+    have hVp : ∀ z, ‖gVn n z - gradVχ z‖ ≤ ‖fderiv ℝ (χn n) z - fderiv ℝ χ z‖ :=
+      fun z => gradientSlice_snd_sub_norm_le (χn n) χ
+        ((hχn_smooth n).differentiable htop) hχdiff (gVn n) gradVχ
+        (fun z => by rw [hgVn_def]) hgradVχ z
+    -- uniform fderiv bound at this n (uses χn = the convolution defeq, before clearing)
+    have hfd_le : ∀ z, ‖fderiv ℝ (χn n) z - fderiv ℝ χ z‖ ≤ ε/(C+1) := by
+      intro z
+      have h := hn z
+      rw [dist_eq_norm, norm_sub_rev] at h
+      exact le_of_lt h
+    -- L15: with the projection + fderiv bounds proven, make the heavy convolution defs opaque so
+    -- the integrand-difference manipulations never unfold their Bochner integrals
+    clear_value gXn gVn χn
+    -- off K both gradient pairs agree (fderivs vanish there)
+    have hXoff : ∀ z ∉ K, gXn n z = gradXχ z := by
+      intro z hzK
+      have hfd0 : fderiv ℝ (χn n) z = 0 := hsuppχn n z hzK
+      have hfd0' : fderiv ℝ χ z = 0 := hsuppχ z hzK
+      have := hXp z; rw [hfd0, hfd0', sub_self, norm_zero] at this
+      exact sub_eq_zero.mp (norm_le_zero_iff.mp this)
+    have hVoff : ∀ z ∉ K, gVn n z = gradVχ z := by
+      intro z hzK
+      have hfd0 : fderiv ℝ (χn n) z = 0 := hsuppχn n z hzK
+      have hfd0' : fderiv ℝ χ z = 0 := hsuppχ z hzK
+      have := hVp z; rw [hfd0, hfd0', sub_self, norm_zero] at this
+      exact sub_eq_zero.mp (norm_le_zero_iff.mp this)
+    -- field bound on K
+    have hfld_K : ∀ z ∈ K, ‖fldσ (Prod.fst z)‖ ≤ ε₀ + (L:ℝ) * R_K := by
+      intro z hzK
+      refine le_trans (hbnd z.1) ?_
+      have : ‖z.1‖ ≤ R_K := le_trans (norm_fst_le z) (hR_K z hzK)
+      gcongr
+    -- pointwise bound on the integrand difference
+    have hpt : ∀ z, ‖(@inner ℝ (PhysSpace d) _ z.2 (gradXχ z)
+          - @inner ℝ (PhysSpace d) _ (fldσ z.1)
+              (gradVχ z))
+        - (@inner ℝ (PhysSpace d) _ z.2 (gXn n z)
+          - @inner ℝ (PhysSpace d) _ (fldσ z.1)
+              (gVn n z))‖ ≤ C * (ε/(C+1)) := by
+      intro z
+      have h := inner_integrand_sub_norm_le K R_K hR_K_nn hR_K fldσ
+        (ε₀ + (L:ℝ) * R_K) (by positivity) hfld_K
+        gradXχ gradVχ (gXn n) (gVn n) (ε/(C+1)) (by positivity)
+        (fun z => le_trans (hXp z) (hfd_le z)) (fun z => le_trans (hVp z) (hfd_le z))
+        hXoff hVoff z
+      refine le_trans h (le_of_eq ?_)
+      rw [hC_def]
+    -- integrability of both integrands (continuous + compact support in K)
+    have hGd_int := inner_integrand_integrable (f σ) fldσ hfc gradXχ gradVχ
+      hgXχc hgVχc hgXχcs hgVχcs
+    have hGnd_int := inner_integrand_integrable (f σ) fldσ hfc (gXn n) (gVn n)
+      (hgXnc n) (hgVnc n) (hgXncs n) (hgVncs n)
+    -- assemble
+    rw [Real.dist_eq, ← integral_sub hGd_int hGnd_int]
+    calc |∫ z, ((@inner ℝ (PhysSpace d) _ z.2 (gradXχ z)
+            - @inner ℝ (PhysSpace d) _ (fldσ z.1)
+                (gradVχ z))
+          - (@inner ℝ (PhysSpace d) _ z.2 (gXn n z)
+            - @inner ℝ (PhysSpace d) _ (fldσ z.1)
+                (gVn n z))) ∂(f σ)|
+        ≤ ∫ z, C * (ε/(C+1)) ∂(f σ) := by
+          refine le_trans (abs_integral_le_integral_abs) ?_
+          refine integral_mono_of_nonneg (Filter.Eventually.of_forall fun z => abs_nonneg _)
+            (integrable_const _) (Filter.Eventually.of_forall fun z => ?_)
+          have := hpt z; rwa [Real.norm_eq_abs] at this
+      _ = C * (ε/(C+1)) := by simp
+      _ < ε := by
+          have h1 : (0 : ℝ) < C + 1 := by positivity
+          rw [← mul_div_assoc, div_lt_iff₀ h1]
+          nlinarith [hε, hC_nn]
+  -- assemble via the uniform-limit-of-derivatives theorem
+  exact hasDerivAt_of_tendstoUniformlyOn isOpen_Ioo hf'unif (Eventually.of_forall hDn) hfg hs
+
+-- NC (consumption form): integral of a jointly-continuous, uniformly-compactly-supported
+-- family against the weak-solution measure curve is continuous in time.
+omit [NeZero d] in
+theorem vlasovSolutionOn_integral_continuousOn
+    (f : ℝ → Measure (PhaseSpace d)) (T : ℝ)
+    (hf_mom : ∀ t ∈ Set.Icc (0 : ℝ) T, HasFiniteFirstMoment (f t))
+    (hf_narrow : ∀ (g : PhaseSpace d → ℝ), Continuous g → HasCompactSupport g →
+      ContinuousOn (fun s => ∫ z, g z ∂(f s)) (Set.Icc 0 T))
+    (G : ℝ → PhaseSpace d → ℝ)
+    (hG_cont : Continuous (fun p : ℝ × PhaseSpace d => G p.1 p.2))
+    (K : Set (PhaseSpace d)) (hK : IsCompact K)
+    (hG_supp : ∀ s, ∀ z ∉ K, G s z = 0) :
+    ContinuousOn (fun s => ∫ z, G s z ∂(f s)) (Set.Icc (0 : ℝ) T) := by
+  -- Each slice G a is continuous, supported in K, hence integrable wrt the probability f b.
+  have hGs_cont : ∀ a : ℝ, Continuous (fun z => G a z) := fun a =>
+    hG_cont.comp (Continuous.prodMk_right a)
+  have hGs_cs : ∀ a : ℝ, HasCompactSupport (fun z => G a z) := by
+    intro a
+    have hsub : tsupport (fun z => G a z) ⊆ K :=
+      closure_minimal (fun z hz => by by_contra hzK; exact hz (hG_supp a z hzK)) hK.isClosed
+    exact IsCompact.of_isClosed_subset hK (isClosed_tsupport _) hsub
+  have hGint : ∀ (a b : ℝ), b ∈ Set.Icc (0 : ℝ) T → Integrable (fun z => G a z) (f b) := by
+    intro a b hb
+    have := (hf_mom b hb).1
+    exact (hGs_cont a).integrable_of_hasCompactSupport (hGs_cs a)
+  -- Uniform continuity of the uncurried G on the compact Icc 0 T ×ˢ K.
+  have hC : IsCompact (Set.Icc (0 : ℝ) T ×ˢ K) := isCompact_Icc.prod hK
+  have hG_uc : UniformContinuousOn (fun p : ℝ × PhaseSpace d => G p.1 p.2)
+      (Set.Icc (0 : ℝ) T ×ˢ K) :=
+    hC.uniformContinuousOn_of_continuous hG_cont.continuousOn
+  rw [Metric.uniformContinuousOn_iff] at hG_uc
+  -- Main ε–δ.
+  rw [Metric.continuousOn_iff]
+  intro s₀ hs₀ ε hε
+  obtain ⟨δ₁, hδ₁, hδ₁_prop⟩ := hG_uc (ε/2) (by positivity)
+  -- term2: narrow continuity of f tested against the frozen g := G s₀.
+  have hterm2 : ContinuousWithinAt (fun s => ∫ z, G s₀ z ∂(f s)) (Set.Icc 0 T) s₀ :=
+    (hf_narrow (fun z => G s₀ z) (hGs_cont s₀) (hGs_cs s₀)) s₀ hs₀
+  rw [Metric.continuousWithinAt_iff] at hterm2
+  obtain ⟨δ₂, hδ₂, hδ₂_prop⟩ := hterm2 (ε/2) (by positivity)
+  refine ⟨min δ₁ δ₂, lt_min hδ₁ hδ₂, fun s hs hsd => ?_⟩
+  have hp_s : IsProbabilityMeasure (f s) := (hf_mom s hs).1
+  have hsd1 : dist s s₀ < δ₁ := lt_of_lt_of_le hsd (min_le_left _ _)
+  have hsd2 : dist s s₀ < δ₂ := lt_of_lt_of_le hsd (min_le_right _ _)
+  -- pointwise: |G s z - G s₀ z| ≤ ε/2 (uniform continuity on K; both zero off K)
+  have hpoint : ∀ z, |G s z - G s₀ z| ≤ ε/2 := by
+    intro z
+    by_cases hzK : z ∈ K
+    · have hp : ((s, z) : ℝ × PhaseSpace d) ∈ Set.Icc (0 : ℝ) T ×ˢ K := ⟨hs, hzK⟩
+      have hq : ((s₀, z) : ℝ × PhaseSpace d) ∈ Set.Icc (0 : ℝ) T ×ˢ K := ⟨hs₀, hzK⟩
+      have hdpq : dist ((s, z) : ℝ × PhaseSpace d) (s₀, z) < δ₁ := by
+        rw [Prod.dist_eq]
+        exact max_lt hsd1 (by rw [dist_self]; exact hδ₁)
+      have hlt := hδ₁_prop _ hp _ hq hdpq
+      rw [Real.dist_eq] at hlt
+      exact le_of_lt hlt
+    · rw [hG_supp s z hzK, hG_supp s₀ z hzK, sub_zero, abs_zero]; positivity
+  -- split the s-integral
+  have key : ∫ z, G s z ∂(f s) - ∫ z, G s₀ z ∂(f s)
+      = ∫ z, (G s z - G s₀ z) ∂(f s) :=
+    (integral_sub (hGint s s hs) (hGint s₀ s hs)).symm
+  have hfirst : dist (∫ z, G s z ∂(f s)) (∫ z, G s₀ z ∂(f s)) ≤ ε/2 := by
+    rw [Real.dist_eq, key]
+    calc |∫ z, (G s z - G s₀ z) ∂(f s)|
+        ≤ ∫ z, |G s z - G s₀ z| ∂(f s) := by
+            have h := norm_integral_le_integral_norm (μ := f s) (fun z => G s z - G s₀ z)
+            simpa only [Real.norm_eq_abs] using h
+      _ ≤ ∫ _z, (ε/2) ∂(f s) :=
+            integral_mono (((hGint s s hs).sub (hGint s₀ s hs)).abs)
+              (integrable_const _) hpoint
+      _ = ε/2 := by simp
+  have hsecond : dist (∫ z, G s₀ z ∂(f s)) (∫ z, G s₀ z ∂(f s₀)) < ε/2 :=
+    hδ₂_prop hs hsd2
+  calc dist (∫ z, G s z ∂(f s)) (∫ z, G s₀ z ∂(f s₀))
+      ≤ dist (∫ z, G s z ∂(f s)) (∫ z, G s₀ z ∂(f s))
+        + dist (∫ z, G s₀ z ∂(f s)) (∫ z, G s₀ z ∂(f s₀)) := dist_triangle _ _ _
+    _ < ε/2 + ε/2 := add_lt_add_of_le_of_lt hfirst hsecond
+    _ = ε := by ring
+
+end Vlasov
diff --git a/LeanPool/Vlasov/OT/WeakToLagrangian.lean b/LeanPool/Vlasov/OT/WeakToLagrangian.lean
index 128916837e..a3fa6cb1a5 100644
--- a/LeanPool/Vlasov/OT/WeakToLagrangian.lean
+++ b/LeanPool/Vlasov/OT/WeakToLagrangian.lean
@@ -6,14 +6,12 @@ Authors: Joseph K. Miller
 module
 
 
-public import Mathlib.Analysis.Calculus.BumpFunction.FiniteDimension
-public import LeanPool.Vlasov.OT.CharacteristicFlow
-public import Mathlib.Analysis.Calculus.BumpFunction.Normed
-import Mathlib.Algebra.Order.Ring.Star
-import Mathlib.Analysis.Calculus.BumpFunction.Convolution
-import Mathlib.Analysis.Calculus.InverseFunctionTheorem.ContDiff
-import Mathlib.Analysis.SpecialFunctions.Integrals.Basic
-import Mathlib.MeasureTheory.Integral.RieszMarkovKakutani.Real
+public import LeanPool.Vlasov.OT.FlowDifferentiability
+import all LeanPool.Vlasov.OT.FlowDifferentiability
+public import LeanPool.Vlasov.OT.TestApproximation
+import all LeanPool.Vlasov.OT.TestApproximation
+import all LeanPool.Vlasov.OT.FrozenField
+import all LeanPool.Vlasov.ForMathlib.VariationalEquation
 
 /-!
 # Weak ⟹ Lagrangian: every weak Vlasov solution is transported by its characteristic flow
@@ -91,3466 +89,6 @@ open MeasureTheory
 
 variable {d : ℕ} [NeZero d]
 
-/-! ## Linear (external-field) weak Vlasov solutions
-
-The self-consistent weak predicate `IsVlasovSolutionOn` drives the convolution field by the
-solution's *own* spatial marginal.  For the superposition argument we need the **linear**
-version, where the field is driven by an *external* (frozen) measure curve `ρ` — both the given
-weak solution `f` (with `ρ := spatialMarginal ∘ f`) and the pushforward `g` along the
-frozen-field flow solve the *same* `IsLinearVlasovSolutionOn gradW ρ · T`, and uniqueness for it
-(the crux, C3) forces `f = g`. -/
-
-/-- Linear weak Vlasov evolution on `Ioo 0 T` for a test function `φ`, with the convolution field
-driven by an **external** measure curve `ρ` (frozen), not the solution's own spatial marginal.
-The self-consistent `WeakEvolutionEqOn gradW μ φ … (fun _ => 0) T` is the special case
-`ρ = spatialMarginal ∘ μ` (modulo the `+ 0` remainder term). -/
-def LinearWeakEvolutionEqOn
-    (gradW : PhysSpace d → PhysSpace d)
-    (ρ : ℝ → Measure (PhysSpace d))
-    (μ : ℝ → Measure (PhaseSpace d))
-    (φ : PhaseSpace d → ℝ)
-    (gradXφ gradVφ : PhaseSpace d → PhysSpace d)
-    (T : ℝ) : Prop :=
-  ∀ t ∈ Set.Ioo (0 : ℝ) T,
-    HasDerivAt (fun s => ∫ z, φ z ∂μ s)
-      (∫ z, (@inner ℝ (PhysSpace d) _ z.2 (gradXφ z) -
-              @inner ℝ (PhysSpace d) _
-                (convolveFunctionMeasure gradW (ρ t) z.1)
-                (gradVφ z))
-        ∂μ t) t
-
-/-- A measure curve `μ` solves the **linear** Vlasov equation on `[0,T]` driven by the external
-field `ρ`: the distributional identity `LinearWeakEvolutionEqOn` holds for every `C_c^∞` test
-function.  Mirror of `IsVlasovSolutionOn` with the field externalized. -/
-def IsLinearVlasovSolutionOn
-    (gradW : PhysSpace d → PhysSpace d)
-    (ρ : ℝ → Measure (PhysSpace d))
-    (μ : ℝ → Measure (PhaseSpace d)) (T : ℝ) : Prop :=
-  ∀ (φ : PhaseSpace d → ℝ),
-    ContDiff ℝ (⊤ : ℕ∞) φ → HasCompactSupport φ →
-    ∀ (gradXφ gradVφ : PhaseSpace d → PhysSpace d),
-      (∀ z, gradXφ z = gradient (fun x => φ (x, z.2)) z.1) →
-      (∀ z, gradVφ z = gradient (fun v => φ (z.1, v)) z.2) →
-      LinearWeakEvolutionEqOn gradW ρ μ φ gradXφ gradVφ T
-
-omit [NeZero d] in
-/-- A self-consistent weak solution is a linear solution driven by its **own** spatial marginal.
-The two differ only by `WeakEvolutionEqOn`'s `+ (fun _ => 0) t = + 0` remainder. -/
-lemma IsVlasovSolutionOn.toLinearSelf
-    {gradW : PhysSpace d → PhysSpace d} {f : ℝ → Measure (PhaseSpace d)} {T : ℝ}
-    (h : IsVlasovSolutionOn gradW f T) :
-    IsLinearVlasovSolutionOn gradW (fun t => spatialMarginal (f t)) f T := by
-  intro φ hφ hφc gradXφ gradVφ hgradXφ hgradVφ t ht
-  simpa using h φ hφ hφc gradXφ gradVφ hgradXφ hgradVφ t ht
-
-omit [NeZero d] in
-/-- **C1 #1 — pushforward solves the frozen linear weak equation.**
-
-For a characteristic flow `(charX, charV)` solving the ODE with an **external** field `ρ` on
-`Ioo 0 T`, the pushforward `g := (charX t, charV t)_# f₀` solves the linear Vlasov equation
-driven by that same `ρ`.  Proof: the generic SC.1–SC.3 machinery (change of variables +
-chain rule + differentiation-under-the-integral, all parametric in `ρ`) recomposed at this `ρ`,
-with SC.4's push-back inlined as `integral_map` (SC.4's packaged form hard-codes the
-self-consistent marginal).  This is `vlasovSolutionViaPushforward_isVlasovSolutionOn` with `ρ`
-left free — the `_hself` self-consistency hypothesis is unused. -/
-theorem vlasov_frozenField_pushforward_isLinearVlasovSolutionOn
-    (gradW : PhysSpace d → PhysSpace d)
-    (L : NNReal) (hL : LipschitzWith L gradW)
-    (ρ : ℝ → Measure (PhysSpace d)) [∀ s, IsProbabilityMeasure (ρ s)]
-    (charX charV : ℝ → PhaseSpace d → PhysSpace d)
-    (f₀ : Measure (PhaseSpace d)) [IsProbabilityMeasure f₀]
-    (hf₀_fm : Integrable (fun z : PhaseSpace d => ‖z‖) f₀)
-    {T : ℝ} (hT : 0 < T)
-    (hflow_on : IsCharacteristicFlowOn gradW ρ charX charV (Set.Ioo 0 T) Set.univ)
-    (h_init : ∀ z : PhaseSpace d, (charX 0 z, charV 0 z) = z)
-    (h_cont_Icc : ∀ z : PhaseSpace d,
-      ContinuousOn (fun s => (charX s z, charV s z)) (Set.Icc (0 : ℝ) T))
-    (h_deriv_Ico : ∀ z : PhaseSpace d, ∀ s ∈ Set.Ico (0 : ℝ) T,
-      HasDerivWithinAt (fun s' => (charX s' z, charV s' z))
-        (vlasovVectorField gradW ρ s (charX s z, charV s z)) (Set.Ici s) s)
-    (M_ρ : ℝ) (hM_ρ_nn : 0 ≤ M_ρ)
-    (hM_ρ : ∀ s ∈ Set.Icc (0 : ℝ) T, ∫ y, ‖y‖ ∂(ρ s) ≤ M_ρ)
-    (h_y_int : ∀ s ∈ Set.Icc (0 : ℝ) T, Integrable (fun y : PhysSpace d => ‖y‖) (ρ s))
-    (h_int : ∀ s (x : PhysSpace d), Integrable (fun y => gradW (x - y)) (ρ s))
-    (h_flow_meas : ∀ s, AEMeasurable (fun z : PhaseSpace d => (charX s z, charV s z)) f₀)
-    (hgradW_cont : Continuous gradW)
-    (hconv_cont : ∀ s, Continuous (fun x => convolveFunctionMeasure gradW (ρ s) x)) :
-    IsLinearVlasovSolutionOn gradW ρ (vlasovSolutionViaPushforward charX charV f₀) T := by
-  intro φ hφ_smooth hφ_compact gradXφ gradVφ hgradXφ hgradVφ t ht
-  have hφ_cont : Continuous φ := hφ_smooth.continuous
-  have hφ_aesm_general : ∀ μ : Measure (PhaseSpace d), AEStronglyMeasurable φ μ :=
-    fun μ => hφ_cont.aestronglyMeasurable
-  -- SC.1: ∫ φ d(pushforward s) = ∫ (φ ∘ flow_s) df₀.
-  have h_compose : ∀ s, ∫ z, φ z ∂(vlasovSolutionViaPushforward charX charV f₀ s) =
-      ∫ z, φ (charX s z, charV s z) ∂f₀ := fun s =>
-    vlasov_pushforward_integral_eq_compose charX charV f₀ s (h_flow_meas s) φ (hφ_aesm_general _)
-  -- SC.2 `_at`: pointwise chain rule at every z, at this t.
-  have h_pointwise : ∀ z, HasDerivAt (fun s => φ (charX s z, charV s z))
-      (@inner ℝ (PhysSpace d) _ (charV t z) (gradXφ (charX t z, charV t z))
-       - @inner ℝ (PhysSpace d) _
-          (convolveFunctionMeasure gradW (ρ t) (charX t z))
-          (gradVφ (charX t z, charV t z))) t := by
-    intro z
-    have hX_at := hflow_on.2.1 t ht z (Set.mem_univ z)
-    have hV_at := hflow_on.2.2 t ht z (Set.mem_univ z)
-    exact vlasov_traj_chain_rule_at gradW ρ charX charV φ hφ_smooth
-      gradXφ gradVφ hgradXφ hgradVφ t z hX_at hV_at
-  -- SC.3: differentiation under the integral via the DiffUnderIntegralData bundle.
-  have h_diff_data : DiffUnderIntegralData gradW ρ charX charV f₀ φ gradXφ gradVφ t := by
-    obtain ⟨nhd, bound, hnhd, h_lipsch, h_bound_int⟩ :=
-      vlasov_trajectory_lipschitz_bound_on gradW L hL ρ charX charV f₀
-        hf₀_fm φ hφ_smooth hφ_compact hT hflow_on h_init h_cont_Icc h_deriv_Ico
-        hgradW_cont hconv_cont t ht M_ρ hM_ρ_nn hM_ρ h_y_int h_int
-    refine ⟨nhd, bound, hnhd, ?_, ?_, ?_, h_lipsch, h_bound_int⟩
-    · exact vlasov_compose_flow_aestronglymeas charX charV f₀ φ hφ_cont h_flow_meas t
-    · exact vlasov_compose_flow_integrable_at charX charV f₀ φ hφ_cont hφ_compact t (h_flow_meas t)
-    · exact vlasov_pointwise_deriv_aestronglymeas gradW ρ charX charV f₀
-        φ hφ_smooth gradXφ gradVφ hgradXφ hgradVφ hconv_cont t (h_flow_meas t)
-  have h_under_integral :=
-    vlasov_pushforward_hasDerivAt_under_integral gradW ρ charX charV f₀
-      φ gradXφ gradVφ t h_pointwise h_diff_data
-  -- SC.4 (inlined; the packaged form hard-codes the self-consistent marginal): AE-strong-meas
-  -- of the dot-product integrand, then push back through `integral_map`.
-  have h_integrand_aesm : AEStronglyMeasurable
-      (fun y : PhaseSpace d =>
-        @inner ℝ (PhysSpace d) _ y.2 (gradXφ y)
-        - @inner ℝ (PhysSpace d) _
-            (convolveFunctionMeasure gradW (ρ t) y.1) (gradVφ y))
-      (vlasovSolutionViaPushforward charX charV f₀ t) := by
-    apply Continuous.aestronglyMeasurable
-    apply Continuous.sub
-    · apply Continuous.inner continuous_snd
-      have hfderiv_X : ∀ z : PhaseSpace d,
-          fderiv ℝ (fun x => φ (x, z.2)) z.1 =
-          (fderiv ℝ φ z).comp (ContinuousLinearMap.inl ℝ (PhysSpace d) (PhysSpace d)) :=
-        fun z => by
-          have h1 : HasFDerivAt φ (fderiv ℝ φ z) z :=
-            (hφ_smooth.differentiable (by simp) z).hasFDerivAt
-          have h2 : HasFDerivAt (fun x : PhysSpace d => (x, z.2))
-              (ContinuousLinearMap.inl ℝ (PhysSpace d) (PhysSpace d)) z.1 :=
-            hasFDerivAt_prodMk_left z.1 z.2
-          exact (h1.comp z.1 h2).fderiv
-      have heqX : gradXφ = fun z => gradient (fun x => φ (x, z.2)) z.1 := funext hgradXφ
-      simp_rw [heqX, gradient, hfderiv_X]
-      exact (InnerProductSpace.toDual ℝ (PhysSpace d)).symm.continuous.comp
-        ((ContinuousLinearMap.isBoundedLinearMap_comp_right
-          (ContinuousLinearMap.inl ℝ (PhysSpace d) (PhysSpace d))).continuous.comp
-          (hφ_smooth.continuous_fderiv (by simp)))
-    · apply Continuous.inner
-      · exact (hconv_cont t).comp continuous_fst
-      · have hfderiv_V : ∀ z : PhaseSpace d,
-            fderiv ℝ (fun v => φ (z.1, v)) z.2 =
-            (fderiv ℝ φ z).comp (ContinuousLinearMap.inr ℝ (PhysSpace d) (PhysSpace d)) :=
-          fun z => by
-            have h1 : HasFDerivAt φ (fderiv ℝ φ z) z :=
-              (hφ_smooth.differentiable (by simp) z).hasFDerivAt
-            have h2 : HasFDerivAt (fun v : PhysSpace d => (z.1, v))
-                (ContinuousLinearMap.inr ℝ (PhysSpace d) (PhysSpace d)) z.2 :=
-              hasFDerivAt_prodMk_right z.1 z.2
-            exact (h1.comp z.2 h2).fderiv
-        have heqV : gradVφ = fun z => gradient (fun v => φ (z.1, v)) z.2 := funext hgradVφ
-        simp_rw [heqV, gradient, hfderiv_V]
-        exact (InnerProductSpace.toDual ℝ (PhysSpace d)).symm.continuous.comp
-          ((ContinuousLinearMap.isBoundedLinearMap_comp_right
-            (ContinuousLinearMap.inr ℝ (PhysSpace d) (PhysSpace d))).continuous.comp
-            (hφ_smooth.continuous_fderiv (by simp)))
-  -- Assemble: rewrite LHS via SC.1; push the derivative integral back through `integral_map`.
-  have hLHS : (fun s => ∫ z, φ z ∂(vlasovSolutionViaPushforward charX charV f₀ s)) =
-              (fun s => ∫ z, φ (charX s z, charV s z) ∂f₀) := funext h_compose
-  have h_map_eq :
-      ∫ z, (@inner ℝ (PhysSpace d) _ z.2 (gradXφ z)
-            - @inner ℝ (PhysSpace d) _ (convolveFunctionMeasure gradW (ρ t) z.1) (gradVφ z))
-        ∂(vlasovSolutionViaPushforward charX charV f₀ t)
-      = ∫ z, (@inner ℝ (PhysSpace d) _ (charV t z) (gradXφ (charX t z, charV t z))
-            - @inner ℝ (PhysSpace d) _ (convolveFunctionMeasure gradW (ρ t) (charX t z))
-                (gradVφ (charX t z, charV t z)))
-        ∂f₀ := by
-    unfold vlasovSolutionViaPushforward at h_integrand_aesm ⊢
-    exact integral_map (h_flow_meas t) h_integrand_aesm
-  rw [hLHS, h_map_eq]
-  exact h_under_integral
-
-omit [NeZero d] in
-/-- **C1 #2 — characteristic flow for a frozen field from window data (L11 clamp).**
-
-Build the characteristic flow for the *given* external curve `ρ` on `Ioo 0 T` (with boundary
-regularity), from probability/moment/integrability/continuity data on the window `[0,T]` only.
-`exists_vlasov_characteristicFlow_global_smallT` demands *universal*-in-`t` instances; we clamp
-`t ↦ ρ (max 0 (min t T))` into the window (L11), apply the universal producer to the clamped
-curve, and transfer on `[0,T]` where the clamp is the identity. -/
-theorem exists_frozenField_charFlow_On
-    (W : PhysSpace d → ℝ)
-    (gradW : PhysSpace d → PhysSpace d) (hgradW : ∀ x, gradW x = gradient W x)
-    (L : NNReal) (hL : LipschitzWith L gradW)
-    (ρ : ℝ → Measure (PhysSpace d))
-    (T : ℝ) (hT : 0 < T) (hTL_PL : LocalSmallnessPLBuffer L T)
-    (hρ_prob : ∀ t ∈ Set.Icc (0 : ℝ) T, IsProbabilityMeasure (ρ t))
-    (h_int : ∀ t ∈ Set.Icc (0 : ℝ) T, ∀ (x : PhysSpace d),
-      Integrable (fun y => gradW (x - y)) (ρ t))
-    (hρ_cont : ∀ x : PhysSpace d,
-      ContinuousOn (fun t => convolveFunctionMeasure gradW (ρ t) x) (Set.Icc (0 : ℝ) T))
-    (h_y_int : ∀ t ∈ Set.Icc (0 : ℝ) T, Integrable (fun y : PhysSpace d => ‖y‖) (ρ t))
-    (M_ρ : ℝ) (hM_ρ_nn : 0 ≤ M_ρ)
-    (hM_ρ : ∀ t ∈ Set.Icc (0 : ℝ) T, ∫ y, ‖y‖ ∂(ρ t) ≤ M_ρ) :
-    ∃ charX charV : ℝ → PhaseSpace d → PhysSpace d,
-      IsCharacteristicFlowOn gradW ρ charX charV (Set.Ioo 0 T) Set.univ ∧
-      (∀ z : PhaseSpace d, (charX 0 z, charV 0 z) = z) ∧
-      (∀ z : PhaseSpace d,
-        ContinuousOn (fun s => (charX s z, charV s z)) (Set.Icc (0 : ℝ) T)) ∧
-      (∀ z : PhaseSpace d, ∀ s ∈ Set.Ico (0 : ℝ) T,
-        HasDerivWithinAt (fun s' => (charX s' z, charV s' z))
-          (vlasovVectorField gradW ρ s (charX s z, charV s z)) (Set.Ici s) s) := by
-  classical
-  -- L11 clamp: `clampT t ∈ [0,T]` for every `t`, and `clampT t = t` on `[0,T]`.
-  set clampT : ℝ → ℝ := fun t => max 0 (min t T) with hclampT_def
-  have hclampT_mem : ∀ t, clampT t ∈ Set.Icc (0 : ℝ) T := by
-    intro t
-    simp only [hclampT_def, Set.mem_Icc]
-    exact ⟨le_max_left _ _, max_le hT.le (min_le_right _ _)⟩
-  have hclampT_id : ∀ t ∈ Set.Icc (0 : ℝ) T, clampT t = t := by
-    intro t ht
-    simp only [hclampT_def, min_eq_left ht.2, max_eq_right ht.1]
-  have hclampT_cont : Continuous clampT := by
-    simp only [hclampT_def]
-    exact continuous_const.max (continuous_id.min continuous_const)
-  -- Clamped curve `ρ' := ρ ∘ clampT`, which satisfies the universal hypotheses.
-  set ρ' : ℝ → Measure (PhysSpace d) := fun t => ρ (clampT t) with hρ'_def
-  have hρ'_prob : ∀ t, IsProbabilityMeasure (ρ' t) :=
-    fun t => hρ_prob (clampT t) (hclampT_mem t)
-  have h_int' : ∀ t (x : PhysSpace d), Integrable (fun y => gradW (x - y)) (ρ' t) :=
-    fun t x => h_int (clampT t) (hclampT_mem t) x
-  have h_y_int' : ∀ t, Integrable (fun y : PhysSpace d => ‖y‖) (ρ' t) :=
-    fun t => h_y_int (clampT t) (hclampT_mem t)
-  have hM_ρ' : ∀ t, ∫ y, ‖y‖ ∂(ρ' t) ≤ M_ρ := fun t => hM_ρ (clampT t) (hclampT_mem t)
-  have hρ'_cont : ∀ x : PhysSpace d,
-      Continuous (fun t => convolveFunctionMeasure gradW (ρ' t) x) :=
-    fun x => (hρ_cont x).comp_continuous hclampT_cont (fun t => hclampT_mem t)
-  -- Apply the universal producer to `ρ'`.
-  obtain ⟨charX, charV, hflow', h_bdry'⟩ :=
-    exists_vlasov_characteristicFlow_global_smallT W gradW hgradW L hL ρ'
-      h_int' hρ'_cont h_y_int' M_ρ hM_ρ_nn hM_ρ' T hT.le hTL_PL
-  -- On `Ioo`/`Icc 0 T`, `clampT = id` so `ρ' = ρ`: transfer the flow back to `ρ`.
-  refine ⟨charX, charV, ⟨hflow'.1, hflow'.2.1, ?_⟩, ?_, ?_, ?_⟩
-  · -- velocity ODE for `ρ` on `Ioo 0 T`
-    intro t ht z hz
-    have h := hflow'.2.2 t ht z hz
-    have hρeq : ρ' t = ρ t := by
-      simp only [hρ'_def, hclampT_id t (Set.Ioo_subset_Icc_self ht)]
-    rwa [hρeq] at h
-  · -- initial condition
-    intro z
-    have h := hflow'.1 z (Set.mem_univ z)
-    exact Prod.ext h.1 h.2
-  · -- `ContinuousOn` on `Icc 0 T` from the producer's boundary derivatives
-    intro z t ht
-    obtain ⟨hX, hV⟩ := h_bdry' z t ht
-    exact (hX.prodMk hV).continuousWithinAt
-  · -- `h_deriv_Ico` (Ici-joint) from the producer's `Icc`-component derivatives
-    intro z s hs
-    have hsIcc : s ∈ Set.Icc (0 : ℝ) T := Set.Ico_subset_Icc_self hs
-    obtain ⟨hX, hV⟩ := h_bdry' z s hsIcc
-    have hρeq : ρ' s = ρ s := by simp only [hρ'_def, hclampT_id s hsIcc]
-    have hpair : HasDerivWithinAt (fun s' => (charX s' z, charV s' z))
-        (charV s z, -(convolveFunctionMeasure gradW (ρ' s) (charX s z)))
-        (Set.Icc 0 T) s := hX.prodMk hV
-    rw [hρeq] at hpair
-    -- convert the set `Icc 0 T` to `Ici s` (local subset near `s`, since `s < T`)
-    have hmem : Set.Iic ((s + T) / 2) ∈ nhds s := Iic_mem_nhds (by linarith [hs.2])
-    have hsub : Set.Ici s ∩ Set.Iic ((s + T) / 2) ⊆ Set.Icc 0 T := by
-      rintro u ⟨hu1, hu2⟩
-      exact ⟨le_trans hs.1 hu1, le_trans hu2 (by linarith [hs.2])⟩
-    exact (hasDerivWithinAt_inter hmem).mp (hpair.mono hsub)
-
-/-! ## Final-step layer (crux-independent): constancy + measure extensionality -/
-
-/-- **C2 #7 — constancy from a vanishing derivative.**
-
-If a real function is continuous on `[0,T]` and has zero derivative throughout the open
-interval, its endpoint values agree.  This is the dual argument's payoff step: `s ↦ ∫ ψ_s dμ_s`
-is constant, so its value at `T` (= `∫ φ dμ_T`) equals its value at `0` (= `∫ ψ_0 dμ_0`). Mean
-value theorem (`exists_hasDerivAt_eq_slope`). -/
-lemma transportedIntegral_const_On {h : ℝ → ℝ} {T : ℝ} (hT : 0 < T)
-    (hcont : ContinuousOn h (Set.Icc 0 T))
-    (hderiv : ∀ s ∈ Set.Ioo (0 : ℝ) T, HasDerivAt h 0 s) :
-    h 0 = h T := by
-  obtain ⟨c, _hc, hc'⟩ :=
-    exists_hasDerivAt_eq_slope h (fun _ => 0) hT hcont (fun s hs => hderiv s hs)
-  have hc0 : (0 : ℝ) = (h T - h 0) / (T - 0) := hc'
-  rcases div_eq_zero_iff.mp hc0.symm with h1 | h2
-  · exact (sub_eq_zero.mp h1).symm
-  · exact absurd h2 (ne_of_gt (by linarith : (0 : ℝ) < T - 0))
-
-omit [NeZero d] in
-/-- **C2 #9 — `C_c^∞` test functions determine a finite measure.**
-
-If `∫ φ dμ = ∫ φ dν` for every smooth compactly-supported `φ`, then `μ = ν` (finite measures on
-phase space).  The dual argument yields equality of integrals against the `IsVlasovSolution` test
-class `C_c^∞`; this closes the bridge's final step `f T = g T`.  Route: extend `C_c^∞ →`
-bounded-continuous (smooth approximation), then the in-house bounded-continuous extensionality
-`ext_of_forall_integral_eq_of_IsFiniteMeasure` (cf. `Wasserstein.lean`). -/
-lemma measure_eq_of_forall_Cc_integral_eq {μ ν : Measure (PhaseSpace d)}
-    [IsFiniteMeasure μ] [IsFiniteMeasure ν]
-    (h : ∀ φ : PhaseSpace d → ℝ, ContDiff ℝ (⊤ : ℕ∞) φ → HasCompactSupport φ →
-      ∫ z, φ z ∂μ = ∫ z, φ z ∂ν) :
-    μ = ν := by
-  -- Haar instance on the ambient volume via the product reduction.
-  have hHaar : (volume : Measure (PhaseSpace d)).IsAddHaarMeasure := by
-    rw [show (volume : Measure (PhaseSpace d)) = (volume : Measure (PhysSpace d)).prod volume from
-      Measure.volume_eq_prod _ _]
-    infer_instance
-  have hvolReg : (volume : Measure (PhaseSpace d)).Regular :=
-    Measure.Regular.of_sigmaCompactSpace_of_isLocallyFiniteMeasure _
-  have hμreg : μ.Regular := inferInstance
-  have hνreg : ν.Regular := inferInstance
-  -- Reduce `μ = ν` to equality of integrals against continuous compactly-supported `g`.
-  refine MeasureTheory.Measure.ext_of_integral_eq_on_compactlySupported (fun g => ?_)
-  set gf : PhaseSpace d → ℝ := ⇑g with hgf
-  have hg_cont : Continuous gf := map_continuous g
-  have hg_cs : HasCompactSupport gf := CompactlySupportedContinuousMap.hasCompactSupport g
-  -- Uniform sup bound on `g`.
-  obtain ⟨C, hC⟩ := hg_cont.bounded_above_of_compact_support hg_cs
-  have hCnn : 0 ≤ C := le_trans (norm_nonneg _) (hC 0)
-  -- A mollifier family `φ n` with outer radius `2/(n+2) → 0`.
-  set φ : ℕ → ContDiffBump (0 : PhaseSpace d) :=
-    fun n => ⟨1 / (n + 2), 2 / (n + 2), by positivity, by
-      rw [div_lt_div_iff_of_pos_right (by positivity)]; norm_num⟩ with hφ
-  have hrout : ∀ n, (φ n).rOut = 2 / (n + 2) := fun n => rfl
-  have hrout_tendsto : Filter.Tendsto (fun n => (φ n).rOut) Filter.atTop (nhds 0) := by
-    simp only [hrout]
-    apply Filter.Tendsto.div_atTop (tendsto_const_nhds)
-    exact Filter.tendsto_atTop_add_const_right _ 2 tendsto_natCast_atTop_atTop
-  -- The mollified functions.
-  set gn : ℕ → PhaseSpace d → ℝ :=
-    fun n => convolution ((φ n).normed volume) gf (ContinuousLinearMap.lsmul ℝ ℝ) volume with hgn
-  -- Each `gn n` is `C^∞` with compact support, hence covered by the hypothesis `h`.
-  have hgn_smooth : ∀ n, ContDiff ℝ (⊤ : ℕ∞) (gn n) := fun n =>
-    ((φ n).hasCompactSupport_normed).contDiff_convolution_left _
-      (φ n).contDiff_normed (hg_cont.locallyIntegrable)
-  have hgn_cs : ∀ n, HasCompactSupport (gn n) := fun n =>
-    HasCompactSupport.convolution _ (φ n).hasCompactSupport_normed hg_cs
-  have hgn_eq : ∀ n, ∫ z, gn n z ∂μ = ∫ z, gn n z ∂ν := fun n =>
-    h (gn n) (hgn_smooth n) (hgn_cs n)
-  -- Pointwise convergence `gn n → gf` (continuous `g`, shrinking bumps).
-  have hgn_lim : ∀ x, Filter.Tendsto (fun n => gn n x) Filter.atTop (nhds (gf x)) := fun x =>
-    ContDiffBump.convolution_tendsto_right_of_continuous hrout_tendsto hg_cont x
-  -- Uniform bound `‖gn n x‖ ≤ C` (averaging keeps the sup bound).
-  have hgn_bound : ∀ n, ∀ x, ‖gn n x‖ ≤ C := by
-    intro n x
-    rw [hgn]
-    simp only
-    rw [convolution_lsmul]
-    calc ‖∫ t, (φ n).normed volume t • gf (x - t) ∂volume‖
-        ≤ ∫ t, ‖(φ n).normed volume t • gf (x - t)‖ ∂volume := norm_integral_le_integral_norm _
-      _ ≤ ∫ t, (φ n).normed volume t * C ∂volume := by
-          apply integral_mono_of_nonneg
-          · exact Filter.Eventually.of_forall (fun t => norm_nonneg _)
-          · exact ((φ n).integrable_normed).mul_const C
-          · refine Filter.Eventually.of_forall (fun t => ?_)
-            simp only
-            rw [norm_smul, Real.norm_eq_abs, abs_of_nonneg ((φ n).nonneg_normed t)]
-            exact mul_le_mul_of_nonneg_left (hC _) ((φ n).nonneg_normed t)
-      _ = C := by rw [integral_mul_const, (φ n).integral_normed, one_mul]
-  -- DCT: `∫ gn n dμ → ∫ gf dμ` and likewise for `ν`.
-  have hconv_μ : Filter.Tendsto (fun n => ∫ z, gn n z ∂μ) Filter.atTop (nhds (∫ z, gf z ∂μ)) := by
-    apply tendsto_integral_of_dominated_convergence (fun _ => C)
-    · exact fun n => (hgn_smooth n).continuous.aestronglyMeasurable
-    · exact integrable_const C
-    · exact fun n => Filter.Eventually.of_forall (fun x => hgn_bound n x)
-    · exact Filter.Eventually.of_forall hgn_lim
-  have hconv_ν : Filter.Tendsto (fun n => ∫ z, gn n z ∂ν) Filter.atTop (nhds (∫ z, gf z ∂ν)) := by
-    apply tendsto_integral_of_dominated_convergence (fun _ => C)
-    · exact fun n => (hgn_smooth n).continuous.aestronglyMeasurable
-    · exact integrable_const C
-    · exact fun n => Filter.Eventually.of_forall (fun x => hgn_bound n x)
-    · exact Filter.Eventually.of_forall hgn_lim
-  -- The two limits coincide because the prelimit sequences are equal.
-  have hμν : Filter.Tendsto (fun n => ∫ z, gn n z ∂μ) Filter.atTop (nhds (∫ z, gf z ∂ν)) := by
-    simpa only [hgn_eq] using hconv_ν
-  exact tendsto_nhds_unique hconv_μ hμν
-
-omit [NeZero d] in
-/-- Convenience extractor: under `[AssW2 W]`, a gradient field `gradW= ∇W` is `C¹`.
-
-`AssW2.gradContDiff` gives `ContDiff ℝ 1 (fun x => fderiv ℝ W x)`; composing with the (smooth,
-linear) Riesz isometry `gradient W x = (toDual ℝ _).symm (fderiv ℝ W x)` and rewriting by `hgradW`
-yields `ContDiff ℝ 1 gradW`. -/
-lemma assW2_contDiff_gradW (W : PhysSpace d → ℝ) [AssW2 W]
-    (gradW : PhysSpace d → PhysSpace d) (hgradW : ∀ x, gradW x = gradient W x) :
-    ContDiff ℝ 1 gradW := by
-  have heq : gradW =
-      fun x => (InnerProductSpace.toDual ℝ (PhysSpace d)).symm (fderiv ℝ W x) := by
-    funext x; rw [hgradW]; rfl
-  rw [heq]
-  have hriesz : ContDiff ℝ 1 fun u => (InnerProductSpace.toDual ℝ (PhysSpace d)).symm u :=
-    (InnerProductSpace.toDual ℝ (PhysSpace d)).symm.toContinuousLinearEquiv.contDiff
-  exact hriesz.comp ‹AssW2 W›.gradContDiff
-
-/-! ## Crux layer (C3): the variational equation and the dual-transport assembly
-
-The two interfaces below were the load-bearing pieces of the bridge — both now proven and
-axiom-clean.  `#3` was the genuine research gap (C¹ dependence of an ODE flow on its initial point
-— absent from Mathlib), closed via route (b) (difference-quotient + Gronwall); `#8` is the
-bridge-specific dual-transported-test-function assembly that consumes it.  `#10` (the public
-theorem) composes the reuse layer (`exists_frozenField_charFlow_On`, #2) with `#8`.
-
-The dual-argument *internals* `#4`/`#5`/`#6` (test-class enlargement `C_c^∞ → C¹_c`, the
-transported test function `ψ_s = φ ∘ Φ_{s→t}` and its transport identity, and the zero-derivative
-of `s ↦ ∫ ψ_s dμ_s`) are realized against the two-time-flow representation `Φ_{s→t} = Φ_t ∘ Φ_s⁻¹`
-and proven below (`weakEvolution_test_C1c_On`, `transportedTest_transport_identity`,
-`transportedIntegral_hasDerivAt_zero`). -/
-
-omit [NeZero d] in
-/-- **C3 F1 — the convolution force field is `C¹` in space (Fréchet derivative under the
-integral).**  For `gradW ∈ C¹` (and `L`-Lipschitz, a probability measure `ρ` with the kernel
-integrable), `x ↦ ∫ y, gradW (x − y) ∂ρ` is Fréchet-differentiable with derivative
-`∫ y, fderiv ℝ gradW (x₀ − y) ∂ρ`.  This is the field-regularity foundation of the variational
-equation (#3): it makes `D_z (vlasovVectorField …)` exist and continuous, so the variational ODE
-`M' = (D_z b)·M` has continuous coefficients.
-
-Differentiation under the integral sign (`hasFDerivAt_integral_of_dominated_loc_of_lip`): the
-per-fibre map `x ↦ gradW (x − y)` is `L`-Lipschitz (a uniform, integrable bound against a
-probability measure) and differentiable, so the parametric integral differentiates with derivative
-the integral of the fibrewise derivatives. -/
-theorem convolveFunctionMeasure_hasFDerivAt
-    (gradW : PhysSpace d → PhysSpace d) (hgradW_C1 : ContDiff ℝ 1 gradW)
-    (L : NNReal) (hL : LipschitzWith L gradW)
-    (ρ : Measure (PhysSpace d)) [IsProbabilityMeasure ρ]
-    (h_int : ∀ x : PhysSpace d, Integrable (fun y => gradW (x - y)) ρ)
-    (x₀ : PhysSpace d) :
-    HasFDerivAt (fun x => convolveFunctionMeasure gradW ρ x)
-      (∫ y, fderiv ℝ gradW (x₀ - y) ∂ρ) x₀ := by
-  have hdiff : Differentiable ℝ gradW := hgradW_C1.differentiable one_ne_zero
-  have hfderiv_cont : Continuous (fun z => fderiv ℝ gradW z) :=
-    hgradW_C1.continuous_fderiv one_ne_zero
-  have key := hasFDerivAt_integral_of_dominated_loc_of_lip
-    (μ := ρ) (s := (Set.univ : Set (PhysSpace d))) (x₀ := x₀)
-    (F := fun x y => gradW (x - y))
-    (F' := fun y => fderiv ℝ gradW (x₀ - y))
-    (bound := fun _ => (L : ℝ))
-    (Filter.univ_mem)
-    (Filter.Eventually.of_forall fun x =>
-      (hL.continuous.comp (continuous_const.sub continuous_id)).aestronglyMeasurable)
-    (h_int x₀)
-    ((hfderiv_cont.comp (continuous_const.sub continuous_id)).aestronglyMeasurable)
-    (Filter.Eventually.of_forall fun a => ?_)
-    (integrable_const _)
-    (Filter.Eventually.of_forall fun a => ?_)
-  · have h2 := key.2
-    simpa only [convolveFunctionMeasure] using h2
-  · -- h_lip: `fun x => gradW (x - a)` is `L`-Lipschitz, hence `LipschitzOnWith (nnabs L)` on univ
-    have hLip : LipschitzWith L (fun x : PhysSpace d => gradW (x - a)) := by
-      refine LipschitzWith.of_dist_le_mul (fun x y => ?_)
-      have hd : dist (x - a) (y - a) = dist x y := by
-        rw [dist_eq_norm, dist_eq_norm]; congr 1; abel
-      calc dist (gradW (x - a)) (gradW (y - a))
-          ≤ (L : ℝ) * dist (x - a) (y - a) := hL.dist_le_mul _ _
-        _ = (L : ℝ) * dist x y := by rw [hd]
-    rw [Real.nnabs_coe L]
-    exact hLip.lipschitzOnWith
-  · -- h_diff: `HasFDerivAt (fun x => gradW (x - a)) (fderiv ℝ gradW (x₀ - a)) x₀`
-    have h1 : HasFDerivAt gradW (fderiv ℝ gradW (x₀ - a)) (x₀ - a) :=
-      (hdiff (x₀ - a)).hasFDerivAt
-    have h2 : HasFDerivAt (fun x : PhysSpace d => x - a)
-        (ContinuousLinearMap.id ℝ (PhysSpace d)) x₀ :=
-      (hasFDerivAt_id x₀).sub_const a
-    have hc := h1.comp x₀ h2
-    simpa [Function.comp_def] using hc
-
-omit [NeZero d] in
-/-- **C3 F2 — the Vlasov field is `C¹` in the phase-space variable, with the block Jacobian.**
-At fixed time `t`, `vlasovVectorField gradW ρ t = fun (x,v) ↦ (v, −conv(x))` is
-Fréchet-differentiable in `z = (x,v)` with derivative the block continuous-linear map
-`δ ↦ (δ.2, −(D_x conv)(δ.1))`, where `D_x conv = ∫ y, fderiv ℝ gradW (z.1 − y) ∂(ρ t)` (F1).
-This is the coefficient `A(t) := D_z b(t, Φ_t z)` of the variational ODE `M' = A(t)·M`. -/
-theorem vlasovVectorField_hasFDerivAt_in_z
-    (gradW : PhysSpace d → PhysSpace d) (hgradW_C1 : ContDiff ℝ 1 gradW)
-    (L : NNReal) (hL : LipschitzWith L gradW)
-    (ρ : ℝ → Measure (PhysSpace d)) [∀ s, IsProbabilityMeasure (ρ s)]
-    (h_int : ∀ s (x : PhysSpace d), Integrable (fun y => gradW (x - y)) (ρ s))
-    (t : ℝ) (z : PhaseSpace d) :
-    HasFDerivAt (vlasovVectorField gradW ρ t)
-      ((ContinuousLinearMap.snd ℝ (PhysSpace d) (PhysSpace d)).prod
-        (-((∫ y, fderiv ℝ gradW (z.1 - y) ∂(ρ t)).comp
-            (ContinuousLinearMap.fst ℝ (PhysSpace d) (PhysSpace d))))) z := by
-  have hconv : HasFDerivAt (fun x => convolveFunctionMeasure gradW (ρ t) x)
-      (∫ y, fderiv ℝ gradW (z.1 - y) ∂(ρ t)) z.1 :=
-    convolveFunctionMeasure_hasFDerivAt gradW hgradW_C1 L hL (ρ t) (h_int t) z.1
-  have hfst : HasFDerivAt (fun w : PhaseSpace d => w.1)
-      (ContinuousLinearMap.fst ℝ (PhysSpace d) (PhysSpace d)) z :=
-    (ContinuousLinearMap.fst ℝ (PhysSpace d) (PhysSpace d)).hasFDerivAt
-  have h1 : HasFDerivAt (fun w : PhaseSpace d => w.2)
-      (ContinuousLinearMap.snd ℝ (PhysSpace d) (PhysSpace d)) z :=
-    (ContinuousLinearMap.snd ℝ (PhysSpace d) (PhysSpace d)).hasFDerivAt
-  have h2 : HasFDerivAt (fun w : PhaseSpace d => convolveFunctionMeasure gradW (ρ t) w.1)
-      ((∫ y, fderiv ℝ gradW (z.1 - y) ∂(ρ t)).comp
-        (ContinuousLinearMap.fst ℝ (PhysSpace d) (PhysSpace d))) z :=
-    hconv.comp z hfst
-  have hprod := h1.prodMk h2.neg
-  exact hprod
-
-omit [NeZero d] in
-/-- **C3 F1c — the convolution derivative is continuous in space.**  `x ↦ ∫ y, fderiv ℝ gradW
-(x − y) ∂ρ` (the Fréchet derivative of the convolution field, F1) is continuous, by dominated
-convergence: the integrand is continuous in `x` and bounded by `‖fderiv gradW‖ ≤ L` (a constant,
-integrable against the probability measure `ρ`).  Continuity of the variational coefficient
-`A(t)` in its spatial argument — half of the `t`-continuity of `A` (the other half is the
-measure-curve regularity `t ↦ ρ t`, supplied at the V1c ODE-existence step). -/
-theorem convolveFunctionMeasure_fderiv_continuous
-    (gradW : PhysSpace d → PhysSpace d) (hgradW_C1 : ContDiff ℝ 1 gradW)
-    (L : NNReal) (hL : LipschitzWith L gradW)
-    (ρ : Measure (PhysSpace d)) [IsProbabilityMeasure ρ] :
-    Continuous (fun x => ∫ y, fderiv ℝ gradW (x - y) ∂ρ) := by
-  have hfderiv_cont : Continuous (fun z => fderiv ℝ gradW z) :=
-    hgradW_C1.continuous_fderiv one_ne_zero
-  refine continuous_of_dominated
-    (F := fun x y => fderiv ℝ gradW (x - y)) (bound := fun _ => (L : ℝ)) ?_ ?_ ?_ ?_
-  · intro x
-    exact (hfderiv_cont.comp (continuous_const.sub continuous_id)).aestronglyMeasurable
-  · intro x
-    exact Filter.Eventually.of_forall (fun y => norm_fderiv_le_of_lipschitz (𝕜 := ℝ) hL)
-  · exact integrable_const _
-  · exact Filter.Eventually.of_forall (fun y =>
-      hfderiv_cont.comp (continuous_id.sub continuous_const))
-
-/-- Picard iterates for the linear IVP `x' = 𝒜(t)x`, `x(0)=x₀` (the V1c engine):
-`I₀ ≡ x₀`, `I_{n+1}(t) = ∫₀ᵗ 𝒜(s)(Iₙ(s)) ds`. -/
-noncomputable def picardIter {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
-    (𝒜 : ℝ → (E →L[ℝ] E)) (x₀ : E) : ℕ → ℝ → E
-  | 0, _ => x₀
-  | (n + 1), t => ∫ s in (0 : ℝ)..t, 𝒜 s (picardIter 𝒜 x₀ n s)
-
-@[simp] lemma picardIter_zero {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
-    (𝒜 : ℝ → (E →L[ℝ] E)) (x₀ : E) (t : ℝ) : picardIter 𝒜 x₀ 0 t = x₀ := rfl
-
-lemma picardIter_succ {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
-    (𝒜 : ℝ → (E →L[ℝ] E)) (x₀ : E) (n : ℕ) (t : ℝ) :
-    picardIter 𝒜 x₀ (n + 1) t = ∫ s in (0 : ℝ)..t, 𝒜 s (picardIter 𝒜 x₀ n s) := rfl
-
-/-- **C3 V1c-engine — the Picard iterates are continuous and satisfy the geometric
-`(Kt)ⁿ/n!`-bound on `[0,T]`.**  Proved by simultaneous induction (continuity feeds
-integrability, which feeds the next bound).  This `Σ (KT)ⁿ/n! = e^{KT}`-summable bound is the
-convergence driver for the V1c fixed point. -/
-lemma picardIter_continuousOn_and_bound {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
-    (𝒜 : ℝ → (E →L[ℝ] E)) (x₀ : E)
-    (T : ℝ) (hT : 0 ≤ T) (K : ℝ) (hK : 0 ≤ K)
-    (hcont𝒜 : ContinuousOn 𝒜 (Set.Icc 0 T))
-    (hbound𝒜 : ∀ t ∈ Set.Icc 0 T, ‖𝒜 t‖ ≤ K) :
-    ∀ n, ContinuousOn (picardIter 𝒜 x₀ n) (Set.Icc 0 T) ∧
-      ∀ t ∈ Set.Icc 0 T, ‖picardIter 𝒜 x₀ n t‖ ≤ (K * t) ^ n / n.factorial * ‖x₀‖ := by
-  intro n
-  induction n with
-  | zero =>
-    refine ⟨continuousOn_const, fun t ht => ?_⟩
-    simp
-  | succ n ih =>
-    obtain ⟨ih_cont, ih_bd⟩ := ih
-    have hg_cont : ContinuousOn (fun s => 𝒜 s (picardIter 𝒜 x₀ n s)) (Set.Icc 0 T) :=
-      hcont𝒜.clm_apply ih_cont
-    have hg_int : IntegrableOn (fun s => 𝒜 s (picardIter 𝒜 x₀ n s)) (Set.Icc 0 T) :=
-      hg_cont.integrableOn_Icc
-    refine ⟨?_, ?_⟩
-    · have hcp := intervalIntegral.continuousOn_primitive_interval (a := 0) (b := T) (μ := volume)
-        (f := fun s => 𝒜 s (picardIter 𝒜 x₀ n s)) (by rw [Set.uIcc_of_le hT]; exact hg_int)
-      rw [Set.uIcc_of_le hT] at hcp
-      exact hcp
-    · intro t ht
-      have ht0 : (0 : ℝ) ≤ t := ht.1
-      have htT : t ≤ T := ht.2
-      have h_ptwise : ∀ s ∈ Set.Icc (0 : ℝ) t,
-          ‖𝒜 s (picardIter 𝒜 x₀ n s)‖ ≤ K * (K * s) ^ n / n.factorial * ‖x₀‖ := by
-        intro s hs
-        have hsT : s ∈ Set.Icc (0 : ℝ) T := ⟨hs.1, le_trans hs.2 htT⟩
-        calc ‖𝒜 s (picardIter 𝒜 x₀ n s)‖
-            ≤ ‖𝒜 s‖ * ‖picardIter 𝒜 x₀ n s‖ := (𝒜 s).le_opNorm _
-          _ ≤ K * ((K * s) ^ n / n.factorial * ‖x₀‖) :=
-              mul_le_mul (hbound𝒜 s hsT) (ih_bd s hsT) (norm_nonneg _) hK
-          _ = K * (K * s) ^ n / n.factorial * ‖x₀‖ := by ring
-      have hRHS_int : IntervalIntegrable
-          (fun s => K * (K * s) ^ n / n.factorial * ‖x₀‖) volume 0 t :=
-        (Continuous.intervalIntegrable (by fun_prop) 0 t)
-      have hLHS_int : IntervalIntegrable
-          (fun s => ‖𝒜 s (picardIter 𝒜 x₀ n s)‖) volume 0 t := by
-        apply ContinuousOn.intervalIntegrable
-        rw [Set.uIcc_of_le ht0]
-        exact (hg_cont.mono (Set.Icc_subset_Icc_right htT)).norm
-      calc ‖picardIter 𝒜 x₀ (n + 1) t‖
-          = ‖∫ s in (0 : ℝ)..t, 𝒜 s (picardIter 𝒜 x₀ n s)‖ := by rw [picardIter_succ]
-        _ ≤ ∫ s in (0 : ℝ)..t, ‖𝒜 s (picardIter 𝒜 x₀ n s)‖ :=
-            intervalIntegral.norm_integral_le_integral_norm ht0
-        _ ≤ ∫ s in (0 : ℝ)..t, K * (K * s) ^ n / n.factorial * ‖x₀‖ :=
-            intervalIntegral.integral_mono_on ht0 hLHS_int hRHS_int h_ptwise
-        _ = (K * t) ^ (n + 1) / (n + 1).factorial * ‖x₀‖ := by
-            have hpow : ∀ s : ℝ, K * (K * s) ^ n / n.factorial * ‖x₀‖
-                = (K ^ (n + 1) * ‖x₀‖ / n.factorial) * s ^ n := by
-              intro s; rw [mul_pow]; ring
-            simp_rw [hpow]
-            rw [intervalIntegral.integral_const_mul, integral_pow]
-            rw [Nat.factorial_succ]
-            push_cast
-            rw [mul_pow]
-            field_simp
-            ring
-
-/-- **C3 V1c-conv — the Dyson sum `M := ∑ₙ Iₙ` is continuous on `[0,T]`.**  Weierstrass M-test:
-the terms are dominated by the summable majorant `(KT)ⁿ/n!·‖x₀‖`, so the series converges
-uniformly; the uniform limit of the continuous partial sums is continuous.  (`M` is the candidate
-solution: `M = x₀ + ∫₀ᵗ 𝒜(s)(M s) ds`, proved next.) -/
-lemma picardSum_continuousOn {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] [CompleteSpace E]
-    (𝒜 : ℝ → (E →L[ℝ] E)) (x₀ : E) (T : ℝ) (hT : 0 ≤ T) (K : ℝ) (hK : 0 ≤ K)
-    (hcont𝒜 : ContinuousOn 𝒜 (Set.Icc 0 T)) (hbound𝒜 : ∀ t ∈ Set.Icc 0 T, ‖𝒜 t‖ ≤ K) :
-    ContinuousOn (fun t => ∑' n, picardIter 𝒜 x₀ n t) (Set.Icc 0 T) := by
-  have hcb := picardIter_continuousOn_and_bound 𝒜 x₀ T hT K hK hcont𝒜 hbound𝒜
-  have hbd : ∀ (n : ℕ) (t : ℝ), t ∈ Set.Icc (0 : ℝ) T →
-      ‖picardIter 𝒜 x₀ n t‖ ≤ (K * T) ^ n / n.factorial * ‖x₀‖ := by
-    intro n t ht
-    refine le_trans ((hcb n).2 t ht) ?_
-    have hKt : 0 ≤ K * t := mul_nonneg hK ht.1
-    have hle : K * t ≤ K * T := mul_le_mul_of_nonneg_left ht.2 hK
-    gcongr
-  have hsum : Summable (fun n => (K * T) ^ n / n.factorial * ‖x₀‖) :=
-    (Real.summable_pow_div_factorial (K * T)).mul_right ‖x₀‖
-  have hunif : TendstoUniformlyOn
-      (fun (u : Finset ℕ) (t : ℝ) => ∑ n ∈ u, picardIter 𝒜 x₀ n t)
-      (fun t => ∑' n, picardIter 𝒜 x₀ n t) Filter.atTop (Set.Icc 0 T) :=
-    tendstoUniformlyOn_tsum hsum hbd
-  refine hunif.continuousOn ?_
-  exact (Filter.Eventually.of_forall
-    (fun u => continuousOn_finsetSum u (fun n _ => (hcb n).1))).frequently
-
-/-- **C3 V2-core — the Dyson sum is continuous in a PARAMETER (the V2 ingredient).**  If the
-coefficient family `𝒜 : Z → ℝ → (E →L E)` is jointly continuous in `(z, s)` (globally) and
-uniformly `K`-bounded on `[0,T]` (with `x₀` constant in `z`), then `z ↦ ∑ₙ Iₙ(z)(t)` is continuous
-for each fixed `t ∈ [0,T]`.  This is the parameter analogue of `picardSum_continuousOn`: each
-iterate `z ↦ Iₙ(z)(t)` is continuous (joint `(z,s)`-continuity, by induction through the parametric
-primitive `continuous_parametric_primitive_of_continuous`), and the M-test majorant `(KT)ⁿ/n!·‖x₀‖`
-is **`z`-independent**, so the uniform-in-`z` limit of continuous maps is continuous.  This is what
-makes the variational fundamental matrix `z ↦ M z t` continuous (V2) — the property the abstract
-`exists_fundamentalMatrix` + `choose` cannot supply (the `choose`'d witness is an arbitrary
-fiberwise section; see lesson L14). -/
-lemma picardSum_continuous_param
-    {Z E : Type*} [TopologicalSpace Z] [NormedAddCommGroup E] [NormedSpace ℝ E] [CompleteSpace E]
-    (𝒜 : Z → ℝ → (E →L[ℝ] E)) (x₀ : E) (T : ℝ) (hT : 0 ≤ T) (K : ℝ) (hK : 0 ≤ K)
-    (h𝒜_cont : Continuous (fun p : Z × ℝ => 𝒜 p.1 p.2))
-    (h𝒜_bound : ∀ z, ∀ s ∈ Set.Icc (0 : ℝ) T, ‖𝒜 z s‖ ≤ K)
-    (t : ℝ) (ht : t ∈ Set.Icc (0 : ℝ) T) :
-    Continuous (fun z => ∑' n, picardIter (𝒜 z) x₀ n t) := by
-  -- (1) joint continuity of each Picard iterate on `Z × ℝ`.
-  have hiter_cont : ∀ n, Continuous (fun p : Z × ℝ => picardIter (𝒜 p.1) x₀ n p.2) := by
-    intro n
-    induction n with
-    | zero =>
-      simp only [picardIter_zero]
-      exact continuous_const
-    | succ n ih =>
-      have hg : Continuous (Function.uncurry fun z v => 𝒜 z v (picardIter (𝒜 z) x₀ n v)) :=
-        h𝒜_cont.clm_apply ih
-      have hpp := intervalIntegral.continuous_parametric_primitive_of_continuous
-        (μ := volume) (a₀ := (0 : ℝ)) hg
-      simp only [picardIter_succ]
-      exact hpp
-  -- (2) per-`z` slice continuity + the `z`-independent M-test bound.
-  have h𝒜cont_z : ∀ z, ContinuousOn (𝒜 z) (Set.Icc (0 : ℝ) T) := fun z =>
-    (h𝒜_cont.comp (continuous_const.prodMk continuous_id)).continuousOn
-  have hbd : ∀ (n : ℕ) (z : Z), z ∈ (Set.univ : Set Z) →
-      ‖picardIter (𝒜 z) x₀ n t‖ ≤ (K * T) ^ n / n.factorial * ‖x₀‖ := by
-    intro n z _
-    have hb := (picardIter_continuousOn_and_bound (𝒜 z) x₀ T hT K hK (h𝒜cont_z z)
-      (h𝒜_bound z) n).2 t ht
-    refine le_trans hb ?_
-    have hKt : (0 : ℝ) ≤ K * t := mul_nonneg hK ht.1
-    have hle : K * t ≤ K * T := mul_le_mul_of_nonneg_left ht.2 hK
-    gcongr
-  have hsum : Summable (fun n => (K * T) ^ n / n.factorial * ‖x₀‖) :=
-    (Real.summable_pow_div_factorial (K * T)).mul_right ‖x₀‖
-  have hsummands_cont : ∀ n, Continuous (fun z => picardIter (𝒜 z) x₀ n t) := fun n =>
-    (hiter_cont n).comp (continuous_id.prodMk continuous_const)
-  have hunif : TendstoUniformlyOn
-      (fun (u : Finset ℕ) (z : Z) => ∑ n ∈ u, picardIter (𝒜 z) x₀ n t)
-      (fun z => ∑' n, picardIter (𝒜 z) x₀ n t) Filter.atTop (Set.univ : Set Z) :=
-    tendstoUniformlyOn_tsum hsum hbd
-  rw [← continuousOn_univ]
-  refine hunif.continuousOn ?_
-  exact (Filter.Eventually.of_forall
-    (fun u => continuousOn_finsetSum u (fun n _ => (hsummands_cont n).continuousOn))).frequently
-
-/-- Window version of `picardSum_continuous_param`: only joint continuity ON `[0,T]` is needed.
-The coefficient is clamped into `[0,T]` (`projIcc`, L11) so the global parametric-primitive lemma
-applies, then transferred back by agreement of the iterates on `[0,T]` (they only integrate over
-`[0,t] ⊆ [0,T]`).  This is the form the variational coefficient `A(s,z) = D_z b(s, Φ_s z)` needs —
-it is jointly continuous only on the window `[0,T]` (the flow `Φ_s z` is). -/
-lemma picardSum_continuous_param_Icc
-    {Z E : Type*} [TopologicalSpace Z] [NormedAddCommGroup E] [NormedSpace ℝ E] [CompleteSpace E]
-    (𝒜 : Z → ℝ → (E →L[ℝ] E)) (x₀ : E) (T : ℝ) (hT : 0 ≤ T) (K : ℝ) (hK : 0 ≤ K)
-    (h𝒜_contOn : ContinuousOn (fun p : Z × ℝ => 𝒜 p.1 p.2) (Set.univ ×ˢ Set.Icc (0 : ℝ) T))
-    (h𝒜_bound : ∀ z, ∀ s ∈ Set.Icc (0 : ℝ) T, ‖𝒜 z s‖ ≤ K)
-    (t : ℝ) (ht : t ∈ Set.Icc (0 : ℝ) T) :
-    Continuous (fun z => ∑' n, picardIter (𝒜 z) x₀ n t) := by
-  set cl : ℝ → ℝ := fun s => ↑(Set.projIcc 0 T hT s) with hcl
-  have hcl_cont : Continuous cl := continuous_subtype_val.comp continuous_projIcc
-  have hcl_mem : ∀ s, cl s ∈ Set.Icc (0 : ℝ) T := fun s => (Set.projIcc 0 T hT s).2
-  have hcl_eq : ∀ s ∈ Set.Icc (0 : ℝ) T, cl s = s := by
-    intro s hs; change (↑(Set.projIcc 0 T hT s) : ℝ) = s; rw [Set.projIcc_of_mem hT hs]
-  set 𝒜c : Z → ℝ → (E →L[ℝ] E) := fun z s => 𝒜 z (cl s) with h𝒜c
-  have h𝒜c_cont : Continuous (fun p : Z × ℝ => 𝒜c p.1 p.2) := by
-    have hmap : Continuous (fun p : Z × ℝ => ((p.1, cl p.2) : Z × ℝ)) :=
-      continuous_fst.prodMk (hcl_cont.comp continuous_snd)
-    have hmem : ∀ p : Z × ℝ, ((p.1, cl p.2) : Z × ℝ) ∈ Set.univ ×ˢ Set.Icc (0 : ℝ) T :=
-      fun p => ⟨Set.mem_univ _, hcl_mem p.2⟩
-    exact h𝒜_contOn.comp_continuous hmap hmem
-  have h𝒜c_bound : ∀ z, ∀ s ∈ Set.Icc (0 : ℝ) T, ‖𝒜c z s‖ ≤ K :=
-    fun z s _ => h𝒜_bound z (cl s) (hcl_mem s)
-  have hagree : ∀ (n : ℕ) (z : Z), ∀ s ∈ Set.Icc (0 : ℝ) T,
-      picardIter (𝒜c z) x₀ n s = picardIter (𝒜 z) x₀ n s := by
-    intro n
-    induction n with
-    | zero => intro z s _; simp
-    | succ n ih =>
-      intro z s hs
-      simp only [picardIter_succ]
-      refine intervalIntegral.integral_congr (fun u hu => ?_)
-      have huIcc : u ∈ Set.Icc (0 : ℝ) T := by
-        rw [Set.uIcc_of_le hs.1] at hu; exact ⟨hu.1, le_trans hu.2 hs.2⟩
-      have e1 : 𝒜c z u = 𝒜 z u := by simp only [h𝒜c, hcl_eq u huIcc]
-      rw [e1, ih z u huIcc]
-  have key := picardSum_continuous_param 𝒜c x₀ T hT K hK h𝒜c_cont h𝒜c_bound t ht
-  have heq : (fun z => ∑' n, picardIter (𝒜c z) x₀ n t)
-      = (fun z => ∑' n, picardIter (𝒜 z) x₀ n t) := by
-    funext z; congr 1; funext n; exact hagree n z t ht
-  rwa [heq] at key
-
-/-- **C3 V1c-rec — finite Picard recurrence.**  The `(N+1)`-th partial Dyson sum equals
-`x₀ + ∫₀ᵗ 𝒜(s)(Sₙ(s)) ds`, where `Sₙ = ∑_{n<N} Iₙ`.  Only finite-sum swaps
-(`integral_finsetSum`, `map_sum`); no infinite interchange.  Passing `N → ∞` against the
-uniform convergence (`picardSum_continuousOn`'s M-test) yields the integral equation for `M`. -/
-lemma picardSum_finset_recurrence
-    {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
-    (𝒜 : ℝ → (E →L[ℝ] E)) (x₀ : E) (T : ℝ) (hT : 0 ≤ T) (K : ℝ) (hK : 0 ≤ K)
-    (hcont𝒜 : ContinuousOn 𝒜 (Set.Icc 0 T)) (hbound𝒜 : ∀ t ∈ Set.Icc 0 T, ‖𝒜 t‖ ≤ K)
-    (N : ℕ) (t : ℝ) (ht : t ∈ Set.Icc (0 : ℝ) T) :
-    ∑ n ∈ Finset.range (N + 1), picardIter 𝒜 x₀ n t
-      = x₀ + ∫ s in (0 : ℝ)..t, 𝒜 s (∑ n ∈ Finset.range N, picardIter 𝒜 x₀ n s) := by
-  have hcb := picardIter_continuousOn_and_bound 𝒜 x₀ T hT K hK hcont𝒜 hbound𝒜
-  have hint : ∀ n, IntervalIntegrable
-      (fun s => 𝒜 s (picardIter 𝒜 x₀ n s)) volume 0 t := by
-    intro n
-    apply ContinuousOn.intervalIntegrable
-    rw [Set.uIcc_of_le ht.1]
-    exact (hcont𝒜.clm_apply (hcb n).1).mono (Set.Icc_subset_Icc_right ht.2)
-  rw [Finset.sum_range_succ', picardIter_zero]
-  simp only [picardIter_succ]
-  rw [add_comm]
-  congr 1
-  rw [← intervalIntegral.integral_finsetSum (fun i _ => hint i)]
-  refine intervalIntegral.integral_congr (fun s _ => ?_)
-  exact (map_sum (𝒜 s) (fun i => picardIter 𝒜 x₀ i s) (Finset.range N)).symm
-
-/-- **C3 V1c-inteq — the Dyson sum solves the integral equation.**
-`M(t) = x₀ + ∫₀ᵗ 𝒜(s)(M s) ds` on `[0,T]`, where `M = ∑'ₙ Iₙ`.  Pass `N → ∞` in the finite
-recurrence: LHS → `M t` (partial sums of the summable series); RHS via DCT (the terms
-`𝒜(s)(S_N s) → 𝒜(s)(M s)` pointwise, dominated by the constant `K·∑'ₙ (KT)ⁿ/n!·‖x₀‖`). -/
-lemma picardSum_solves_integralEq
-    {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] [CompleteSpace E]
-    (𝒜 : ℝ → (E →L[ℝ] E)) (x₀ : E) (T : ℝ) (hT : 0 ≤ T) (K : ℝ) (hK : 0 ≤ K)
-    (hcont𝒜 : ContinuousOn 𝒜 (Set.Icc 0 T)) (hbound𝒜 : ∀ t ∈ Set.Icc 0 T, ‖𝒜 t‖ ≤ K)
-    (t : ℝ) (ht : t ∈ Set.Icc (0 : ℝ) T) :
-    (∑' n, picardIter 𝒜 x₀ n t)
-      = x₀ + ∫ s in (0 : ℝ)..t, 𝒜 s (∑' n, picardIter 𝒜 x₀ n s) := by
-  have hcb := picardIter_continuousOn_and_bound 𝒜 x₀ T hT K hK hcont𝒜 hbound𝒜
-  have ht0 : (0 : ℝ) ≤ t := ht.1
-  have htT : t ≤ T := ht.2
-  have hmaj : ∀ n, ∀ s ∈ Set.Icc (0 : ℝ) T,
-      ‖picardIter 𝒜 x₀ n s‖ ≤ (K * T) ^ n / n.factorial * ‖x₀‖ := by
-    intro n s hs
-    refine le_trans ((hcb n).2 s hs) ?_
-    have hKs : 0 ≤ K * s := mul_nonneg hK hs.1
-    have hle : K * s ≤ K * T := mul_le_mul_of_nonneg_left hs.2 hK
-    gcongr
-  have hmaj_summable : Summable (fun n => (K * T) ^ n / n.factorial * ‖x₀‖) :=
-    (Real.summable_pow_div_factorial (K * T)).mul_right ‖x₀‖
-  have hsummable : ∀ s ∈ Set.Icc (0 : ℝ) T, Summable (fun n => picardIter 𝒜 x₀ n s) := by
-    intro s hs
-    exact (hmaj_summable.of_nonneg_of_le (fun n => norm_nonneg _) (fun n => hmaj n s hs)).of_norm
-  set C : ℝ := ∑' n, (K * T) ^ n / n.factorial * ‖x₀‖ with hC
-  have hSbound : ∀ N, ∀ s ∈ Set.Icc (0 : ℝ) T,
-      ‖∑ n ∈ Finset.range N, picardIter 𝒜 x₀ n s‖ ≤ C := by
-    intro N s hs
-    refine le_trans (norm_sum_le _ _) ?_
-    refine le_trans (Finset.sum_le_sum (fun n _ => hmaj n s hs)) ?_
-    exact hmaj_summable.sum_le_tsum _ (fun n _ => by positivity)
-  set M : ℝ → E := fun u => ∑' n, picardIter 𝒜 x₀ n u with hM
-  have hLHS : Filter.Tendsto (fun N => ∑ n ∈ Finset.range (N + 1), picardIter 𝒜 x₀ n t)
-      Filter.atTop (nhds (M t)) :=
-    ((hsummable t ht).hasSum.tendsto_sum_nat).comp (Filter.tendsto_add_atTop_nat 1)
-  have hRHS_int : Filter.Tendsto
-      (fun N => ∫ s in Set.Ioc (0 : ℝ) t, 𝒜 s (∑ n ∈ Finset.range N, picardIter 𝒜 x₀ n s))
-      Filter.atTop (nhds (∫ s in Set.Ioc (0 : ℝ) t, 𝒜 s (M s))) := by
-    apply MeasureTheory.tendsto_integral_of_dominated_convergence (bound := fun _ => K * C)
-    · intro N
-      apply ContinuousOn.aestronglyMeasurable _ measurableSet_Ioc
-      exact (hcont𝒜.clm_apply (continuousOn_finsetSum _ (fun n _ => (hcb n).1))).mono
-        (Set.Ioc_subset_Icc_self.trans (Set.Icc_subset_Icc_right htT))
-    · exact integrableOn_const (hs := measure_Ioc_lt_top.ne)
-    · intro N
-      refine MeasureTheory.ae_restrict_of_forall_mem measurableSet_Ioc (fun s hs => ?_)
-      have hsT : s ∈ Set.Icc (0 : ℝ) T := ⟨le_of_lt hs.1, le_trans hs.2 htT⟩
-      calc ‖𝒜 s (∑ n ∈ Finset.range N, picardIter 𝒜 x₀ n s)‖
-          ≤ ‖𝒜 s‖ * ‖∑ n ∈ Finset.range N, picardIter 𝒜 x₀ n s‖ := (𝒜 s).le_opNorm _
-        _ ≤ K * C := mul_le_mul (hbound𝒜 s hsT) (hSbound N s hsT) (norm_nonneg _) hK
-    · refine MeasureTheory.ae_restrict_of_forall_mem measurableSet_Ioc (fun s hs => ?_)
-      have hsT : s ∈ Set.Icc (0 : ℝ) T := ⟨le_of_lt hs.1, le_trans hs.2 htT⟩
-      exact ((𝒜 s).continuous.tendsto (M s)).comp ((hsummable s hsT).hasSum.tendsto_sum_nat)
-  rw [intervalIntegral.integral_of_le ht0]
-  have hrec' : ∀ N, ∑ n ∈ Finset.range (N + 1), picardIter 𝒜 x₀ n t
-      = x₀ + ∫ s in Set.Ioc (0 : ℝ) t, 𝒜 s (∑ n ∈ Finset.range N, picardIter 𝒜 x₀ n s) := by
-    intro N
-    rw [picardSum_finset_recurrence 𝒜 x₀ T hT K hK hcont𝒜 hbound𝒜 N t ht,
-      intervalIntegral.integral_of_le ht0]
-  exact tendsto_nhds_unique hLHS ((hRHS_int.const_add x₀).congr (fun N => (hrec' N).symm))
-
-/-- **C3 V1c — existence for a linear ODE with continuous coefficients on a compact interval**
-(the fundamental solution of the variational equation; a Mathlib gap).
-
-For a continuous family of bounded linear maps `𝒜 : ℝ → (E →L[ℝ] E)` on a Banach space `E`, the
-linear IVP `x' = 𝒜(t) x`, `x(0) = x₀` has a solution on `[0,T]`.  Generic and reusable
-(promotable to `Mathlib/Analysis/ODE/`); instantiated for the variational equation with
-`E := PhaseSpace d →L[ℝ] PhaseSpace d`, `𝒜(t) := (·).comp-by A(t)` (left composition), `x₀ := id`
-to produce the fundamental matrix `M(t)`, where `A(t) = vlasovVectorField_hasFDerivAt_in_z`'s
-block CLM evaluated along the flow.
-
-**Why not Mathlib's `IsPicardLindelof`**: that needs a *globally bounded* field
-(`norm_le : ‖f t x‖ ≤ L`); the linear field `x ↦ 𝒜(t) x` is unbounded, and confining to a ball
-makes the Picard window-condition `K·e^{KT}·T ≤ e^{KT}−1` fail for a single window (⇒ tiling).
-
-**Proof plan (integral-operator contraction, no tiling)**: on the Banach space
-`C([0,T]; E)` the Picard operator `𝒯[M](t) := x₀ + ∫_0^t 𝒜(s) (M s) ds` is `K·T`-Lipschitz
-(`K := sup_{[0,T]} ‖𝒜‖`, finite by continuity on the compact `[0,T]`), and its `n`-th iterate is
-`(K·T)^n/n!`-Lipschitz (induction on the Bochner-integral bound), which is `< 1` for large `n`;
-so `𝒯` has a unique fixed point by the iterated-contraction Banach theorem
-(`ContractingWith` + `exists_fixedPoint`, `Mathlib/Topology/MetricSpace/Contracting.lean`).
-Differentiating the fixed-point integral equation (FTC, `HasDerivWithinAt` of `t ↦ ∫_0^t …`)
-recovers `x' = 𝒜(t) x`; `x(0) = x₀` from the lower integral limit. -/
-theorem exists_linearODE_solution_Icc
-    {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] [CompleteSpace E]
-    (𝒜 : ℝ → (E →L[ℝ] E)) (T : ℝ) (hT : 0 ≤ T)
-    (h𝒜 : ContinuousOn 𝒜 (Set.Icc 0 T)) (x₀ : E) :
-    ∃ M : ℝ → E, M 0 = x₀ ∧ ContinuousOn M (Set.Icc 0 T) ∧
-      ∀ t ∈ Set.Icc 0 T, HasDerivWithinAt M (𝒜 t (M t)) (Set.Icc 0 T) t := by
-  obtain ⟨K, hbK⟩ := isCompact_Icc.exists_bound_of_continuousOn h𝒜
-  have hK'0 : 0 ≤ max K 0 := le_max_right _ _
-  have hbound : ∀ t ∈ Set.Icc (0 : ℝ) T, ‖𝒜 t‖ ≤ max K 0 :=
-    fun t ht => le_trans (hbK t ht) (le_max_left _ _)
-  set M : ℝ → E := fun u => ∑' n, picardIter 𝒜 x₀ n u with hM
-  have hMcont : ContinuousOn M (Set.Icc 0 T) :=
-    picardSum_continuousOn 𝒜 x₀ T hT (max K 0) hK'0 h𝒜 hbound
-  have hMeq : ∀ t ∈ Set.Icc (0 : ℝ) T, M t = x₀ + ∫ s in (0 : ℝ)..t, 𝒜 s (M s) :=
-    fun t ht => picardSum_solves_integralEq 𝒜 x₀ T hT (max K 0) hK'0 h𝒜 hbound t ht
-  have hg_cont : ContinuousOn (fun s => 𝒜 s (M s)) (Set.Icc 0 T) := h𝒜.clm_apply hMcont
-  refine ⟨M, ?_, hMcont, fun t ht => ?_⟩
-  · rw [hMeq 0 ⟨le_refl 0, hT⟩, intervalIntegral.integral_same, add_zero]
-  · have : Fact (t ∈ Set.Icc (0 : ℝ) T) := ⟨ht⟩
-    have hg_int : IntervalIntegrable (fun s => 𝒜 s (M s)) volume 0 t := by
-      apply ContinuousOn.intervalIntegrable
-      rw [Set.uIcc_of_le ht.1]
-      exact hg_cont.mono (Set.Icc_subset_Icc_right ht.2)
-    have hg_meas : StronglyMeasurableAtFilter (fun s => 𝒜 s (M s)) (nhdsWithin t (Set.Icc 0 T)) :=
-      ⟨Set.Icc 0 T, self_mem_nhdsWithin, hg_cont.aestronglyMeasurable measurableSet_Icc⟩
-    have hFTC : HasDerivWithinAt (fun u => ∫ s in (0 : ℝ)..u, 𝒜 s (M s)) (𝒜 t (M t))
-        (Set.Icc 0 T) t :=
-      intervalIntegral.integral_hasDerivWithinAt_right hg_int hg_meas (hg_cont t ht)
-    exact (hFTC.const_add x₀).congr (fun y hy => hMeq y hy) (hMeq t ht)
-
-/-- **C3 V1c→matrix — the fundamental matrix of a linear ODE.**  Specialising
-`exists_linearODE_solution_Icc` to the operator space `E := F →L[ℝ] F` with `𝒜(s) := A(s) ∘ (·)`
-(left composition) and `x₀ := id` gives the fundamental solution `M' = A(t)∘M`, `M(0) = id`.
-This `M(t)` is the candidate `Dflow t z` of the variational equation (#3), once `A` is the Vlasov
-field Jacobian `A(s) = D_z b(s, Φ_s z)` along the flow (F2). -/
-lemma exists_fundamentalMatrix
-    {F : Type*} [NormedAddCommGroup F] [NormedSpace ℝ F] [CompleteSpace F]
-    (A : ℝ → (F →L[ℝ] F)) (T : ℝ) (hT : 0 ≤ T) (hA : ContinuousOn A (Set.Icc 0 T)) :
-    ∃ M : ℝ → (F →L[ℝ] F), M 0 = ContinuousLinearMap.id ℝ F ∧ ContinuousOn M (Set.Icc 0 T) ∧
-      ∀ t ∈ Set.Icc 0 T, HasDerivWithinAt M ((A t).comp (M t)) (Set.Icc 0 T) t := by
-  obtain ⟨M, hM0, hMcont, hMderiv⟩ := exists_linearODE_solution_Icc
-    (fun s => ContinuousLinearMap.compL ℝ F F F (A s)) T hT
-    ((ContinuousLinearMap.compL ℝ F F F).continuous.comp_continuousOn hA)
-    (ContinuousLinearMap.id ℝ F)
-  refine ⟨M, hM0, hMcont, fun t ht => ?_⟩
-  simpa [ContinuousLinearMap.compL_apply] using hMderiv t ht
-
-omit [NeZero d] in
-/-- **C3 A-cont — the variational coefficient `A(s,z) = D_z b(s, Φ_s z)` is continuous in `s`.**
-`A(s,z)` is the F2 block CLM `(snd).prod(−(∫ fderiv gradW (charX s z − y) ∂ρ_s) ∘ fst)`; its only
-`s`-varying part is the convolution-derivative integral, continuous via `hρD_cont` composed with
-the flow.  The block CLM is reassembled with `inl∘snd + inr∘(·)` (Mathlib has no `clm_prod`
-continuity combinator).  This `ContinuousOn` is the coefficient input to `exists_fundamentalMatrix`
-that produces the fundamental matrix `M_t(z) = Dflow t z` for `#3`. -/
-lemma vlasovVariationalCoeff_continuousOn
-    (gradW : PhysSpace d → PhysSpace d)
-    (ρ : ℝ → Measure (PhysSpace d))
-    (charX charV : ℝ → PhaseSpace d → PhysSpace d) (T : ℝ) (z : PhaseSpace d)
-    (hcontIcc : ContinuousOn (fun s => (charX s z, charV s z)) (Set.Icc (0 : ℝ) T))
-    (hρD_cont : ContinuousOn
-      (fun p : ℝ × PhysSpace d => ∫ y, fderiv ℝ gradW (p.2 - y) ∂(ρ p.1))
-      (Set.Icc 0 T ×ˢ (Set.univ : Set (PhysSpace d)))) :
-    ContinuousOn (fun s => (ContinuousLinearMap.snd ℝ (PhysSpace d) (PhysSpace d)).prod
-      (-((∫ y, fderiv ℝ gradW (charX s z - y) ∂(ρ s)).comp
-          (ContinuousLinearMap.fst ℝ (PhysSpace d) (PhysSpace d))))) (Set.Icc 0 T) := by
-  have hX : ContinuousOn (fun s => charX s z) (Set.Icc (0 : ℝ) T) :=
-    continuous_fst.comp_continuousOn hcontIcc
-  have hpair : ContinuousOn (fun s => ((s, charX s z) : ℝ × PhysSpace d)) (Set.Icc (0 : ℝ) T) :=
-    continuousOn_id.prodMk hX
-  have hmaps : Set.MapsTo (fun s => ((s, charX s z) : ℝ × PhysSpace d))
-      (Set.Icc (0 : ℝ) T) (Set.Icc 0 T ×ˢ (Set.univ : Set (PhysSpace d))) :=
-    fun s hs => ⟨hs, Set.mem_univ _⟩
-  have hD : ContinuousOn (fun s => ∫ y, fderiv ℝ gradW (charX s z - y) ∂(ρ s)) (Set.Icc 0 T) :=
-    hρD_cont.comp hpair hmaps
-  have hDcomp : ContinuousOn (fun s => -((∫ y, fderiv ℝ gradW (charX s z - y) ∂(ρ s)).comp
-      (ContinuousLinearMap.fst ℝ (PhysSpace d) (PhysSpace d)))) (Set.Icc 0 T) :=
-    (hD.clm_comp continuousOn_const).neg
-  have heq : (fun s => (ContinuousLinearMap.snd ℝ (PhysSpace d) (PhysSpace d)).prod
-        (-((∫ y, fderiv ℝ gradW (charX s z - y) ∂(ρ s)).comp
-            (ContinuousLinearMap.fst ℝ (PhysSpace d) (PhysSpace d)))))
-      = (fun s => (ContinuousLinearMap.inl ℝ (PhysSpace d) (PhysSpace d)).comp
-            (ContinuousLinearMap.snd ℝ (PhysSpace d) (PhysSpace d))
-          + (ContinuousLinearMap.inr ℝ (PhysSpace d) (PhysSpace d)).comp
-            (-((∫ y, fderiv ℝ gradW (charX s z - y) ∂(ρ s)).comp
-                (ContinuousLinearMap.fst ℝ (PhysSpace d) (PhysSpace d))))) := by
-    funext s; ext x <;> simp
-  rw [heq]
-  exact continuousOn_const.add (continuousOn_const.clm_comp hDcomp)
-
-/-- **C3 D1 (Jacobian).**  The phase-space Jacobian `A(s, p) = D_w b(s, p)` of the frozen Vlasov
-field at the base point `p`: the block continuous-linear map `δ ↦ (δ.2, −(D_x conv ρ_s)(p.1)·δ.1)`,
-where `D_x conv ρ_s (p.1) = ∫ y, fderiv ℝ gradW (p.1 − y) ∂ρ_s` (F1).  This is the coefficient of
-the linear variational ODE `M' = A(s, Φ_s z)·M`; `vlasovVectorField_hasFDerivAt_in_z` (F2) says it
-is the Fréchet derivative of `vlasovVectorField gradW ρ s` at `p.2`. -/
-noncomputable def vlasovFieldJacobian (gradW : PhysSpace d → PhysSpace d)
-    (ρ : ℝ → Measure (PhysSpace d)) (p : ℝ × PhaseSpace d) : PhaseSpace d →L[ℝ] PhaseSpace d :=
-  (ContinuousLinearMap.snd ℝ (PhysSpace d) (PhysSpace d)).prod
-    (-((∫ y, fderiv ℝ gradW (p.2.1 - y) ∂(ρ p.1)).comp
-        (ContinuousLinearMap.fst ℝ (PhysSpace d) (PhysSpace d))))
-
-omit [NeZero d] in
-/-- **C3 D1a — the uniform-over-compact first-order Taylor remainder of the Vlasov field.**
-
-For a fixed initial point `z`, the first-order remainder of the frozen field `b(s,·)` at the moving
-base point `Φ_s z := (charX s z, charV s z)`,
-`R(s,w) = b(s,w) − b(s,Φ_s z) − A(s,Φ_s z)·(w − Φ_s z)`, is `o(‖w − Φ_s z‖)` **uniformly in
-`s ∈ [0,T]`**: for every `η > 0` there is a single `δ > 0` (independent of `s`) with
-`‖R(s,w)‖ ≤ η·‖w − Φ_s z‖` whenever `‖w − Φ_s z‖ ≤ δ`.
-
-This uniformity is the load-bearing analytic core of D1 (the variational-equation difference
-quotient): it is what lets Grönwall bound `Φ_t(z+h) − Φ_t(z) − M_t(z)·h` by `o(‖h‖)` *uniformly
-along the trajectory*.  Proof: the flow image `{Φ_s z : s ∈ [0,T]}` is compact (continuous image of
-`[0,T]`), `A = D_w b` is jointly `(s,w)`-continuous (from `hρD_cont`), so `A` is **uniformly**
-continuous on the compact tube `Γ = {(s, Φ_s z + e) : s ∈ [0,T], ‖e‖ ≤ 1}` (Heine–Cantor); the
-mean-value inequality on `closedBall (Φ_s z) δ` then converts the modulus into the remainder
-bound. -/
-lemma vlasovField_taylorRemainder_uniform
-    (gradW : PhysSpace d → PhysSpace d) (hgradW_C1 : ContDiff ℝ 1 gradW)
-    (L : NNReal) (hL : LipschitzWith L gradW)
-    (ρ : ℝ → Measure (PhysSpace d)) [∀ s, IsProbabilityMeasure (ρ s)]
-    (h_int : ∀ s (x : PhysSpace d), Integrable (fun y => gradW (x - y)) (ρ s))
-    (charX charV : ℝ → PhaseSpace d → PhysSpace d) (T : ℝ) (z : PhaseSpace d)
-    (hcontIcc : ContinuousOn (fun s => (charX s z, charV s z)) (Set.Icc (0 : ℝ) T))
-    (hρD_cont : ContinuousOn
-      (fun p : ℝ × PhysSpace d => ∫ y, fderiv ℝ gradW (p.2 - y) ∂(ρ p.1))
-      (Set.Icc 0 T ×ˢ (Set.univ : Set (PhysSpace d)))) :
-    ∀ η : ℝ, 0 < η → ∃ δ : ℝ, 0 < δ ∧ ∀ s ∈ Set.Icc (0 : ℝ) T, ∀ w : PhaseSpace d,
-      ‖w - (charX s z, charV s z)‖ ≤ δ →
-      ‖vlasovVectorField gradW ρ s w - vlasovVectorField gradW ρ s (charX s z, charV s z)
-        - (vlasovFieldJacobian gradW ρ (s, (charX s z, charV s z))) (w - (charX s z, charV s z))‖
-        ≤ η * ‖w - (charX s z, charV s z)‖ := by
-  set Φ : ℝ → PhaseSpace d := fun s => (charX s z, charV s z) with hΦ
-  -- F2: the field is differentiable in the phase variable with derivative `vlasovFieldJacobian`.
-  have hF2 : ∀ s (w : PhaseSpace d),
-      HasFDerivAt (vlasovVectorField gradW ρ s) (vlasovFieldJacobian gradW ρ (s, w)) w :=
-    fun s w => vlasovVectorField_hasFDerivAt_in_z gradW hgradW_C1 L hL ρ h_int s w
-  -- Joint continuity of the Jacobian on `Icc 0 T ×ˢ Set.univ` (from `hρD_cont`).
-  have hg_cont : Continuous (fun p : ℝ × PhaseSpace d => ((p.1, p.2.1) : ℝ × PhysSpace d)) :=
-    continuous_fst.prodMk (continuous_fst.comp continuous_snd)
-  have hmaps : Set.MapsTo (fun p : ℝ × PhaseSpace d => ((p.1, p.2.1) : ℝ × PhysSpace d))
-      (Set.Icc 0 T ×ˢ (Set.univ : Set (PhaseSpace d)))
-      (Set.Icc 0 T ×ˢ (Set.univ : Set (PhysSpace d))) :=
-    fun p hp => ⟨hp.1, Set.mem_univ _⟩
-  have hD2 : ContinuousOn
-      (fun p : ℝ × PhaseSpace d => ∫ y, fderiv ℝ gradW (p.2.1 - y) ∂(ρ p.1))
-      (Set.Icc 0 T ×ˢ Set.univ) :=
-    hρD_cont.comp hg_cont.continuousOn hmaps
-  have hDcomp : ContinuousOn
-      (fun p : ℝ × PhaseSpace d => -((∫ y, fderiv ℝ gradW (p.2.1 - y) ∂(ρ p.1)).comp
-        (ContinuousLinearMap.fst ℝ (PhysSpace d) (PhysSpace d)))) (Set.Icc 0 T ×ˢ Set.univ) :=
-    (hD2.clm_comp continuousOn_const).neg
-  have heq : (fun p : ℝ × PhaseSpace d => vlasovFieldJacobian gradW ρ p) = fun p =>
-        (ContinuousLinearMap.inl ℝ (PhysSpace d) (PhysSpace d)).comp
-          (ContinuousLinearMap.snd ℝ (PhysSpace d) (PhysSpace d))
-        + (ContinuousLinearMap.inr ℝ (PhysSpace d) (PhysSpace d)).comp
-          (-((∫ y, fderiv ℝ gradW (p.2.1 - y) ∂(ρ p.1)).comp
-              (ContinuousLinearMap.fst ℝ (PhysSpace d) (PhysSpace d)))) := by
-    funext p; ext x <;> simp [vlasovFieldJacobian]
-  have hAj_cont : ContinuousOn (fun p : ℝ × PhaseSpace d => vlasovFieldJacobian gradW ρ p)
-      (Set.Icc 0 T ×ˢ Set.univ) := by
-    rw [heq]; exact continuousOn_const.add (continuousOn_const.clm_comp hDcomp)
-  -- The compact tube `Γ = {(s, Φ s + e) : s ∈ [0,T], ‖e‖ ≤ 1}`.
-  set ball1 : Set (PhaseSpace d) := Metric.closedBall 0 1 with hball1
-  have hmap : ContinuousOn (fun q : ℝ × PhaseSpace d => ((q.1, Φ q.1 + q.2) : ℝ × PhaseSpace d))
-      (Set.Icc 0 T ×ˢ ball1) :=
-    continuousOn_fst.prodMk
-      ((hcontIcc.comp continuousOn_fst (fun q hq => hq.1)).add continuousOn_snd)
-  set Γ : Set (ℝ × PhaseSpace d) :=
-    (fun q : ℝ × PhaseSpace d => ((q.1, Φ q.1 + q.2) : ℝ × PhaseSpace d)) '' (Set.Icc 0 T ×ˢ ball1)
-    with hΓ
-  have hΓcompact : IsCompact Γ :=
-    (isCompact_Icc.prod (isCompact_closedBall 0 1)).image_of_continuousOn hmap
-  have hΓsub : Γ ⊆ Set.Icc 0 T ×ˢ Set.univ := by
-    rintro _ ⟨q, hq, rfl⟩; exact ⟨hq.1, Set.mem_univ _⟩
-  have hUC : UniformContinuousOn (fun p => vlasovFieldJacobian gradW ρ p) Γ :=
-    hΓcompact.uniformContinuousOn_of_continuous (hAj_cont.mono hΓsub)
-  have hmemΓ : ∀ s ∈ Set.Icc (0 : ℝ) T, ∀ e : PhaseSpace d, ‖e‖ ≤ 1 →
-      ((s, Φ s + e) : ℝ × PhaseSpace d) ∈ Γ := by
-    intro s hs e he
-    exact ⟨(s, e), ⟨hs, by simpa [hball1, Metric.mem_closedBall, dist_eq_norm] using he⟩, rfl⟩
-  -- Extract the uniform-continuity modulus.
-  intro η hη
-  obtain ⟨δ₀, hδ₀, H⟩ := Metric.uniformContinuousOn_iff_le.mp hUC η hη
-  refine ⟨min δ₀ 1, lt_min hδ₀ one_pos, ?_⟩
-  intro s hs w hw
-  -- Mean value on the convex ball `C = closedBall (Φ s) (min δ₀ 1)`.
-  set C : Set (PhaseSpace d) := Metric.closedBall (Φ s) (min δ₀ 1) with hC
-  have hΦmem : Φ s ∈ C := Metric.mem_closedBall_self (le_min hδ₀.le zero_le_one)
-  have hwmem : w ∈ C := by
-    rw [hC, Metric.mem_closedBall, dist_eq_norm]; exact hw
-  -- The fderiv bound on `C` from uniform continuity.
-  have hbound : ∀ w' ∈ C,
-      ‖vlasovFieldJacobian gradW ρ (s, w') - vlasovFieldJacobian gradW ρ (s, Φ s)‖ ≤ η := by
-    intro w' hw'
-    have hw'norm : ‖w' - Φ s‖ ≤ min δ₀ 1 := by
-      rw [← dist_eq_norm]; rw [hC, Metric.mem_closedBall] at hw'; exact hw'
-    have hw'le1 : ‖w' - Φ s‖ ≤ 1 := hw'norm.trans (min_le_right _ _)
-    have hmem1 : ((s, w') : ℝ × PhaseSpace d) ∈ Γ := by
-      have := hmemΓ s hs (w' - Φ s) hw'le1
-      rwa [add_sub_cancel] at this
-    have hmem2 : ((s, Φ s) : ℝ × PhaseSpace d) ∈ Γ := by
-      have := hmemΓ s hs 0 (by simp)
-      rwa [add_zero] at this
-    have hdist : dist ((s, w') : ℝ × PhaseSpace d) (s, Φ s) ≤ δ₀ := by
-      rw [Prod.dist_eq]
-      simp only [dist_self, max_le_iff]
-      refine ⟨hδ₀.le, ?_⟩
-      rw [dist_eq_norm]; exact hw'norm.trans (min_le_left _ _)
-    have := H _ hmem1 _ hmem2 hdist
-    rwa [dist_eq_norm] at this
-  -- Apply the mean value inequality to `g u = b(s,u) − A(s,Φ s)·u`.
-  have hg : ∀ w' ∈ C, HasFDerivWithinAt
-      (fun u => vlasovVectorField gradW ρ s u - vlasovFieldJacobian gradW ρ (s, Φ s) u)
-      (vlasovFieldJacobian gradW ρ (s, w') - vlasovFieldJacobian gradW ρ (s, Φ s)) C w' := by
-    intro w' _
-    have h1 := hF2 s w'
-    have h2 : HasFDerivAt (fun u => vlasovFieldJacobian gradW ρ (s, Φ s) u)
-        (vlasovFieldJacobian gradW ρ (s, Φ s)) w' :=
-      (vlasovFieldJacobian gradW ρ (s, Φ s)).hasFDerivAt
-    exact (h1.sub h2).hasFDerivWithinAt
-  have hmv := (convex_closedBall (Φ s) (min δ₀ 1)).norm_image_sub_le_of_norm_hasFDerivWithin_le
-    hg hbound hΦmem hwmem
-  -- Rewrite `g w − g (Φ s)` as the remainder.
-  have hReq : (vlasovVectorField gradW ρ s w - vlasovFieldJacobian gradW ρ (s, Φ s) w)
-        - (vlasovVectorField gradW ρ s (Φ s) - vlasovFieldJacobian gradW ρ (s, Φ s) (Φ s))
-      = vlasovVectorField gradW ρ s w - vlasovVectorField gradW ρ s (Φ s)
-        - vlasovFieldJacobian gradW ρ (s, Φ s) (w - Φ s) := by
-    rw [map_sub]; abel
-  simpa only [hReq] using hmv
-
-omit [NeZero d] in
-/-- **C3 (shared) — joint continuity of the Jacobian** on `Icc 0 T ×ˢuniv` (used by V2's
-`hA_contOn`).  The block CLM `vlasovFieldJacobian` is reassembled `inl∘snd + inr∘(·)` and its
-varying part is continuous via `hρD_cont`. -/
-lemma vlasovFieldJacobian_continuousOn
-    (gradW : PhysSpace d → PhysSpace d) (ρ : ℝ → Measure (PhysSpace d)) (T : ℝ)
-    (hρD_cont : ContinuousOn
-      (fun p : ℝ × PhysSpace d => ∫ y, fderiv ℝ gradW (p.2 - y) ∂(ρ p.1))
-      (Set.Icc 0 T ×ˢ (Set.univ : Set (PhysSpace d)))) :
-    ContinuousOn (fun p : ℝ × PhaseSpace d => vlasovFieldJacobian gradW ρ p)
-      (Set.Icc 0 T ×ˢ (Set.univ : Set (PhaseSpace d))) := by
-  have hg_cont : Continuous (fun p : ℝ × PhaseSpace d => ((p.1, p.2.1) : ℝ × PhysSpace d)) :=
-    continuous_fst.prodMk (continuous_fst.comp continuous_snd)
-  have hmaps : Set.MapsTo (fun p : ℝ × PhaseSpace d => ((p.1, p.2.1) : ℝ × PhysSpace d))
-      (Set.Icc 0 T ×ˢ (Set.univ : Set (PhaseSpace d)))
-      (Set.Icc 0 T ×ˢ (Set.univ : Set (PhysSpace d))) :=
-    fun p hp => ⟨hp.1, Set.mem_univ _⟩
-  have hD2 : ContinuousOn
-      (fun p : ℝ × PhaseSpace d => ∫ y, fderiv ℝ gradW (p.2.1 - y) ∂(ρ p.1))
-      (Set.Icc 0 T ×ˢ Set.univ) :=
-    hρD_cont.comp hg_cont.continuousOn hmaps
-  have hDcomp : ContinuousOn
-      (fun p : ℝ × PhaseSpace d => -((∫ y, fderiv ℝ gradW (p.2.1 - y) ∂(ρ p.1)).comp
-        (ContinuousLinearMap.fst ℝ (PhysSpace d) (PhysSpace d)))) (Set.Icc 0 T ×ˢ Set.univ) :=
-    (hD2.clm_comp continuousOn_const).neg
-  have heq : (fun p : ℝ × PhaseSpace d => vlasovFieldJacobian gradW ρ p) = fun p =>
-        (ContinuousLinearMap.inl ℝ (PhysSpace d) (PhysSpace d)).comp
-          (ContinuousLinearMap.snd ℝ (PhysSpace d) (PhysSpace d))
-        + (ContinuousLinearMap.inr ℝ (PhysSpace d) (PhysSpace d)).comp
-          (-((∫ y, fderiv ℝ gradW (p.2.1 - y) ∂(ρ p.1)).comp
-              (ContinuousLinearMap.fst ℝ (PhysSpace d) (PhysSpace d)))) := by
-    funext p; ext x <;> simp [vlasovFieldJacobian]
-  rw [heq]; exact continuousOn_const.add (continuousOn_const.clm_comp hDcomp)
-
-/-- **C3 (shared) — Lipschitz-in-parameter + ContinuousOn-in-time ⇒ jointly ContinuousOn.**
-A generic upgrade: if `G z ·` is `ContinuousOn (Icc 0 T)` for each `z` and `z ↦ G z s` is
-`C`-Lipschitz uniformly over `s ∈ [0,T]`, then `(z,s) ↦ G z s` is jointly continuous on
-`univ ×ˢ Icc 0 T`.  Used to derive flow joint continuity `(z,s) ↦ Φ_s z` from
-`charFlow_lipschitzInZ_via_gronwall_Ioo` (Lipschitz-in-`z`) + per-`z` continuity in `s`. -/
-lemma continuousOn_prod_of_lipschitz_continuousOn
-    {Z E : Type*} [PseudoMetricSpace Z] [PseudoMetricSpace E]
-    (G : Z → ℝ → E) (T C : ℝ)
-    (hlip : ∀ s ∈ Set.Icc (0 : ℝ) T, ∀ z₁ z₂, dist (G z₁ s) (G z₂ s) ≤ C * dist z₁ z₂)
-    (hcont : ∀ z, ContinuousOn (fun s => G z s) (Set.Icc (0 : ℝ) T)) :
-    ContinuousOn (fun p : Z × ℝ => G p.1 p.2) (Set.univ ×ˢ Set.Icc (0 : ℝ) T) := by
-  rw [Metric.continuousOn_iff]
-  rintro ⟨z₀, s₀⟩ ⟨_, hs₀⟩ ε hε
-  obtain ⟨δ₁, hδ₁, hcs⟩ :=
-    (Metric.continuousWithinAt_iff).mp (hcont z₀ s₀ hs₀) (ε/2) (by positivity)
-  have hC1 : (0 : ℝ) < |C| + 1 := by positivity
-  refine ⟨min δ₁ (ε / (2 * (|C| + 1))), by positivity, ?_⟩
-  rintro ⟨z, s⟩ ⟨_, hs⟩ hd
-  rw [Prod.dist_eq, max_lt_iff] at hd
-  obtain ⟨hdz, hds⟩ := hd
-  have hterm1 : dist (G z s) (G z₀ s) < ε/2 := by
-    calc dist (G z s) (G z₀ s)
-        ≤ C * dist z z₀ := hlip s hs z z₀
-      _ ≤ (|C| + 1) * dist z z₀ :=
-          mul_le_mul_of_nonneg_right (by linarith [le_abs_self C]) dist_nonneg
-      _ < (|C| + 1) * (ε / (2 * (|C| + 1))) :=
-          mul_lt_mul_of_pos_left (lt_of_lt_of_le hdz (min_le_right _ _)) hC1
-      _ = ε/2 := by field_simp
-  have hterm2 : dist (G z₀ s) (G z₀ s₀) < ε/2 :=
-    hcs hs (lt_of_lt_of_le hds (min_le_left _ _))
-  calc dist (G z s) (G z₀ s₀)
-      ≤ dist (G z s) (G z₀ s) + dist (G z₀ s) (G z₀ s₀) := dist_triangle _ _ _
-    _ < ε/2 + ε/2 := add_lt_add hterm1 hterm2
-    _ = ε := by ring
-
-/-- **C3 V2 — the explicit fundamental matrix** (Route A, lesson L14): the canonical Dyson-series
-solution of `M' = A(t)·M`, `M 0 = id`, as a *function* (not a `choose`-d witness), so its
-parameter-regularity is accessible. -/
-noncomputable def fundamentalMatrix {F : Type*} [NormedAddCommGroup F] [NormedSpace ℝ F]
-    (A : ℝ → (F →L[ℝ] F)) : ℝ → (F →L[ℝ] F) :=
-  fun t => ∑' n, picardIter (fun s => ContinuousLinearMap.compL ℝ F F F (A s))
-    (ContinuousLinearMap.id ℝ F) n t
-
-/-- `fundamentalMatrix A` solves the fundamental-matrix IVP on `[0,T]` (the non-existential form of
-`exists_fundamentalMatrix`; same proof through the picardSum lemmas). -/
-lemma fundamentalMatrix_spec {F : Type*} [NormedAddCommGroup F] [NormedSpace ℝ F] [CompleteSpace F]
-    (A : ℝ → (F →L[ℝ] F)) (T : ℝ) (hT : 0 ≤ T) (hA : ContinuousOn A (Set.Icc 0 T)) :
-    fundamentalMatrix A 0 = ContinuousLinearMap.id ℝ F ∧
-      ContinuousOn (fundamentalMatrix A) (Set.Icc 0 T) ∧
-      ∀ t ∈ Set.Icc 0 T, HasDerivWithinAt (fundamentalMatrix A)
-        ((A t).comp (fundamentalMatrix A t)) (Set.Icc 0 T) t := by
-  have h𝒜cont : ContinuousOn (fun s => ContinuousLinearMap.compL ℝ F F F (A s)) (Set.Icc 0 T) :=
-    (ContinuousLinearMap.compL ℝ F F F).continuous.comp_continuousOn hA
-  obtain ⟨KA, hKA⟩ :=
-    (isCompact_Icc (a := (0 : ℝ)) (b := T)).exists_bound_of_continuousOn hA
-  have hK'0 : (0 : ℝ) ≤ max KA 0 := le_max_right _ _
-  have hbound : ∀ t ∈ Set.Icc (0 : ℝ) T, ‖ContinuousLinearMap.compL ℝ F F F (A t)‖ ≤ max KA 0 := by
-    intro t ht
-    have h1 : ‖ContinuousLinearMap.compL ℝ F F F (A t)‖ ≤ ‖A t‖ := by
-      refine ContinuousLinearMap.opNorm_le_bound _ (norm_nonneg _) (fun g => ?_)
-      rw [ContinuousLinearMap.compL_apply]; exact (A t).opNorm_comp_le g
-    exact le_trans (le_trans h1 (hKA t ht)) (le_max_left KA 0)
-  have hMcont : ContinuousOn (fundamentalMatrix A) (Set.Icc 0 T) :=
-    picardSum_continuousOn (fun s => ContinuousLinearMap.compL ℝ F F F (A s))
-      (ContinuousLinearMap.id ℝ F) T hT (max KA 0) hK'0 h𝒜cont hbound
-  have hMeq : ∀ t ∈ Set.Icc (0 : ℝ) T, fundamentalMatrix A t = ContinuousLinearMap.id ℝ F
-      + ∫ s in (0 : ℝ)..t, ContinuousLinearMap.compL ℝ F F F (A s) (fundamentalMatrix A s) :=
-    fun t ht => picardSum_solves_integralEq (fun s => ContinuousLinearMap.compL ℝ F F F (A s))
-      (ContinuousLinearMap.id ℝ F) T hT (max KA 0) hK'0 h𝒜cont hbound t ht
-  have hg_cont : ContinuousOn
-      (fun s => ContinuousLinearMap.compL ℝ F F F (A s) (fundamentalMatrix A s)) (Set.Icc 0 T) :=
-    h𝒜cont.clm_apply hMcont
-  refine ⟨?_, hMcont, fun t ht => ?_⟩
-  · rw [hMeq 0 ⟨le_refl 0, hT⟩, intervalIntegral.integral_same, add_zero]
-  · have : Fact (t ∈ Set.Icc (0 : ℝ) T) := ⟨ht⟩
-    have hg_int : IntervalIntegrable
-        (fun s => ContinuousLinearMap.compL ℝ F F F (A s) (fundamentalMatrix A s)) volume 0 t := by
-      apply ContinuousOn.intervalIntegrable
-      rw [Set.uIcc_of_le ht.1]; exact hg_cont.mono (Set.Icc_subset_Icc_right ht.2)
-    have hg_meas : StronglyMeasurableAtFilter
-        (fun s => ContinuousLinearMap.compL ℝ F F F (A s) (fundamentalMatrix A s))
-        (nhdsWithin t (Set.Icc 0 T)) :=
-      ⟨Set.Icc 0 T, self_mem_nhdsWithin, hg_cont.aestronglyMeasurable measurableSet_Icc⟩
-    have hFTC : HasDerivWithinAt
-        (fun u => ∫ s in (0 : ℝ)..u,
-          ContinuousLinearMap.compL ℝ F F F (A s) (fundamentalMatrix A s))
-        (ContinuousLinearMap.compL ℝ F F F (A t) (fundamentalMatrix A t)) (Set.Icc 0 T) t :=
-      intervalIntegral.integral_hasDerivWithinAt_right hg_int hg_meas (hg_cont t ht)
-    have hHD := (hFTC.const_add (ContinuousLinearMap.id ℝ F)).congr
-      (fun y hy => hMeq y hy) (hMeq t ht)
-    rwa [ContinuousLinearMap.compL_apply] at hHD
-
-/-- **C3 V2 — the fundamental matrix is continuous in a PARAMETER** (closes V2 via Route A).
-Specialises `picardSum_continuous_param_Icc` to `𝒜 := compL∘A`, `x₀ := id`; the `compL` factor is
-`1`-bounded so the `K`-bound transfers from `A`. -/
-lemma fundamentalMatrix_continuous_param
-    {Z F : Type*} [TopologicalSpace Z] [NormedAddCommGroup F] [NormedSpace ℝ F] [CompleteSpace F]
-    (A : Z → ℝ → (F →L[ℝ] F)) (T : ℝ) (hT : 0 ≤ T) (K : ℝ) (hK : 0 ≤ K)
-    (hA_contOn : ContinuousOn (fun p : Z × ℝ => A p.1 p.2) (Set.univ ×ˢ Set.Icc (0 : ℝ) T))
-    (hA_bound : ∀ z, ∀ s ∈ Set.Icc (0 : ℝ) T, ‖A z s‖ ≤ K)
-    (t : ℝ) (ht : t ∈ Set.Icc (0 : ℝ) T) :
-    Continuous (fun z => fundamentalMatrix (A z) t) := by
-  have h𝒜_contOn : ContinuousOn
-      (fun p : Z × ℝ => ContinuousLinearMap.compL ℝ F F F (A p.1 p.2))
-      (Set.univ ×ˢ Set.Icc (0 : ℝ) T) :=
-    (ContinuousLinearMap.compL ℝ F F F).continuous.comp_continuousOn hA_contOn
-  have h𝒜_bound : ∀ z, ∀ s ∈ Set.Icc (0 : ℝ) T,
-      ‖ContinuousLinearMap.compL ℝ F F F (A z s)‖ ≤ K := by
-    intro z s hs
-    refine le_trans ?_ (hA_bound z s hs)
-    refine ContinuousLinearMap.opNorm_le_bound _ (norm_nonneg _) (fun g => ?_)
-    rw [ContinuousLinearMap.compL_apply]
-    exact (A z s).opNorm_comp_le g
-  exact picardSum_continuous_param_Icc (fun z s => ContinuousLinearMap.compL ℝ F F F (A z s))
-    (ContinuousLinearMap.id ℝ F) T hT K hK h𝒜_contOn h𝒜_bound t ht
-
-/-- **Step 3 (i) — joint `(z,s)` continuity of the Dyson sum** (global-hypothesis form).
-Mirror of `picardSum_continuous_param`, concluding JOINT `ContinuousOn` on `univ ×ˢ Icc 0 T`
-instead of per-`t` continuity in `z`.  The proof reuses the same joint iterate continuity
-(`hiter_cont` on `Z × ℝ`) and the same `(z,s)`-independent M-test majorant `(KT)ⁿ/n!·‖x₀‖`; only
-the final `tendstoUniformlyOn` ranges over `univ ×ˢ Icc 0 T`.  Used to make the variational
-fundamental matrix `(z,s) ↦ M z s` jointly continuous (the partial-derivative continuity the
-two-time-flow joint `C¹`-ness needs). -/
-lemma picardSum_continuous_param_joint
-    {Z E : Type*} [TopologicalSpace Z] [NormedAddCommGroup E] [NormedSpace ℝ E] [CompleteSpace E]
-    (𝒜 : Z → ℝ → (E →L[ℝ] E)) (x₀ : E) (T : ℝ) (hT : 0 ≤ T) (K : ℝ) (hK : 0 ≤ K)
-    (h𝒜_cont : Continuous (fun p : Z × ℝ => 𝒜 p.1 p.2))
-    (h𝒜_bound : ∀ z, ∀ s ∈ Set.Icc (0 : ℝ) T, ‖𝒜 z s‖ ≤ K) :
-    ContinuousOn (fun p : Z × ℝ => ∑' n, picardIter (𝒜 p.1) x₀ n p.2)
-      (Set.univ ×ˢ Set.Icc (0 : ℝ) T) := by
-  have hiter_cont : ∀ n, Continuous (fun p : Z × ℝ => picardIter (𝒜 p.1) x₀ n p.2) := by
-    intro n
-    induction n with
-    | zero =>
-      simp only [picardIter_zero]
-      exact continuous_const
-    | succ n ih =>
-      have hg : Continuous (Function.uncurry fun z v => 𝒜 z v (picardIter (𝒜 z) x₀ n v)) :=
-        h𝒜_cont.clm_apply ih
-      have hpp := intervalIntegral.continuous_parametric_primitive_of_continuous
-        (μ := volume) (a₀ := (0 : ℝ)) hg
-      simp only [picardIter_succ]
-      exact hpp
-  have h𝒜cont_z : ∀ z, ContinuousOn (𝒜 z) (Set.Icc (0 : ℝ) T) := fun z =>
-    (h𝒜_cont.comp (continuous_const.prodMk continuous_id)).continuousOn
-  have hbd : ∀ (n : ℕ) (p : Z × ℝ), p ∈ Set.univ ×ˢ Set.Icc (0 : ℝ) T →
-      ‖picardIter (𝒜 p.1) x₀ n p.2‖ ≤ (K * T) ^ n / n.factorial * ‖x₀‖ := by
-    intro n p hp
-    have hps : p.2 ∈ Set.Icc (0 : ℝ) T := hp.2
-    have hb := (picardIter_continuousOn_and_bound (𝒜 p.1) x₀ T hT K hK (h𝒜cont_z p.1)
-      (h𝒜_bound p.1) n).2 p.2 hps
-    refine le_trans hb ?_
-    have hKt : (0 : ℝ) ≤ K * p.2 := mul_nonneg hK hps.1
-    have hle : K * p.2 ≤ K * T := mul_le_mul_of_nonneg_left hps.2 hK
-    gcongr
-  have hsum : Summable (fun n => (K * T) ^ n / n.factorial * ‖x₀‖) :=
-    (Real.summable_pow_div_factorial (K * T)).mul_right ‖x₀‖
-  have hunif : TendstoUniformlyOn
-      (fun (u : Finset ℕ) (p : Z × ℝ) => ∑ n ∈ u, picardIter (𝒜 p.1) x₀ n p.2)
-      (fun p => ∑' n, picardIter (𝒜 p.1) x₀ n p.2) Filter.atTop
-      (Set.univ ×ˢ Set.Icc (0 : ℝ) T) :=
-    tendstoUniformlyOn_tsum hsum hbd
-  refine hunif.continuousOn ?_
-  exact (Filter.Eventually.of_forall
-    (fun u => continuousOn_finsetSum u (fun n _ => (hiter_cont n).continuousOn))).frequently
-
-/-- **Step 3 (i) — joint `(z,s)` continuity of the Dyson sum** (window / `ContinuousOn`-hypothesis
-form).  Mirror of `picardSum_continuous_param_Icc`: clamp `s` into `[0,T]` (`projIcc`, L11) so the
-global form applies, then transfer back by iterate-agreement on `[0,T]`. -/
-lemma picardSum_continuous_param_Icc_joint
-    {Z E : Type*} [TopologicalSpace Z] [NormedAddCommGroup E] [NormedSpace ℝ E] [CompleteSpace E]
-    (𝒜 : Z → ℝ → (E →L[ℝ] E)) (x₀ : E) (T : ℝ) (hT : 0 ≤ T) (K : ℝ) (hK : 0 ≤ K)
-    (h𝒜_contOn : ContinuousOn (fun p : Z × ℝ => 𝒜 p.1 p.2) (Set.univ ×ˢ Set.Icc (0 : ℝ) T))
-    (h𝒜_bound : ∀ z, ∀ s ∈ Set.Icc (0 : ℝ) T, ‖𝒜 z s‖ ≤ K) :
-    ContinuousOn (fun p : Z × ℝ => ∑' n, picardIter (𝒜 p.1) x₀ n p.2)
-      (Set.univ ×ˢ Set.Icc (0 : ℝ) T) := by
-  set cl : ℝ → ℝ := fun s => ↑(Set.projIcc 0 T hT s) with hcl
-  have hcl_cont : Continuous cl := continuous_subtype_val.comp continuous_projIcc
-  have hcl_mem : ∀ s, cl s ∈ Set.Icc (0 : ℝ) T := fun s => (Set.projIcc 0 T hT s).2
-  have hcl_eq : ∀ s ∈ Set.Icc (0 : ℝ) T, cl s = s := by
-    intro s hs; change (↑(Set.projIcc 0 T hT s) : ℝ) = s; rw [Set.projIcc_of_mem hT hs]
-  set 𝒜c : Z → ℝ → (E →L[ℝ] E) := fun z s => 𝒜 z (cl s) with h𝒜c
-  have h𝒜c_cont : Continuous (fun p : Z × ℝ => 𝒜c p.1 p.2) := by
-    have hmap : Continuous (fun p : Z × ℝ => ((p.1, cl p.2) : Z × ℝ)) :=
-      continuous_fst.prodMk (hcl_cont.comp continuous_snd)
-    have hmem : ∀ p : Z × ℝ, ((p.1, cl p.2) : Z × ℝ) ∈ Set.univ ×ˢ Set.Icc (0 : ℝ) T :=
-      fun p => ⟨Set.mem_univ _, hcl_mem p.2⟩
-    exact h𝒜_contOn.comp_continuous hmap hmem
-  have h𝒜c_bound : ∀ z, ∀ s ∈ Set.Icc (0 : ℝ) T, ‖𝒜c z s‖ ≤ K :=
-    fun z s _ => h𝒜_bound z (cl s) (hcl_mem s)
-  have hagree : ∀ (n : ℕ) (z : Z), ∀ s ∈ Set.Icc (0 : ℝ) T,
-      picardIter (𝒜c z) x₀ n s = picardIter (𝒜 z) x₀ n s := by
-    intro n
-    induction n with
-    | zero => intro z s _; simp
-    | succ n ih =>
-      intro z s hs
-      simp only [picardIter_succ]
-      refine intervalIntegral.integral_congr (fun u hu => ?_)
-      have huIcc : u ∈ Set.Icc (0 : ℝ) T := by
-        rw [Set.uIcc_of_le hs.1] at hu; exact ⟨hu.1, le_trans hu.2 hs.2⟩
-      have e1 : 𝒜c z u = 𝒜 z u := by simp only [h𝒜c, hcl_eq u huIcc]
-      rw [e1, ih z u huIcc]
-  have key := picardSum_continuous_param_joint 𝒜c x₀ T hT K hK h𝒜c_cont h𝒜c_bound
-  refine key.congr ?_
-  rintro ⟨z, s⟩ ⟨_, hs⟩
-  simp only
-  congr 1; funext n; exact (hagree n z s hs).symm
-
-/-- **Step 3 (i) — the fundamental matrix is jointly `(z,s)`-continuous.**  Joint companion of
-`fundamentalMatrix_continuous_param`; specialises `picardSum_continuous_param_Icc_joint` to
-`𝒜 := compL∘A`, `x₀ := id`.  This is the partial-`z`-derivative continuity input to the joint
-`C¹`-ness of the forward flow `(s,z) ↦ Φ_s z` (Step 3 (iii)). -/
-lemma fundamentalMatrix_continuous_param_joint
-    {Z F : Type*} [TopologicalSpace Z] [NormedAddCommGroup F] [NormedSpace ℝ F] [CompleteSpace F]
-    (A : Z → ℝ → (F →L[ℝ] F)) (T : ℝ) (hT : 0 ≤ T) (K : ℝ) (hK : 0 ≤ K)
-    (hA_contOn : ContinuousOn (fun p : Z × ℝ => A p.1 p.2) (Set.univ ×ˢ Set.Icc (0 : ℝ) T))
-    (hA_bound : ∀ z, ∀ s ∈ Set.Icc (0 : ℝ) T, ‖A z s‖ ≤ K) :
-    ContinuousOn (fun p : Z × ℝ => fundamentalMatrix (A p.1) p.2)
-      (Set.univ ×ˢ Set.Icc (0 : ℝ) T) := by
-  have h𝒜_contOn : ContinuousOn
-      (fun p : Z × ℝ => ContinuousLinearMap.compL ℝ F F F (A p.1 p.2))
-      (Set.univ ×ˢ Set.Icc (0 : ℝ) T) :=
-    (ContinuousLinearMap.compL ℝ F F F).continuous.comp_continuousOn hA_contOn
-  have h𝒜_bound : ∀ z, ∀ s ∈ Set.Icc (0 : ℝ) T,
-      ‖ContinuousLinearMap.compL ℝ F F F (A z s)‖ ≤ K := by
-    intro z s hs
-    refine le_trans ?_ (hA_bound z s hs)
-    refine ContinuousLinearMap.opNorm_le_bound _ (norm_nonneg _) (fun g => ?_)
-    rw [ContinuousLinearMap.compL_apply]
-    exact (A z s).opNorm_comp_le g
-  exact picardSum_continuous_param_Icc_joint
-    (fun z s => ContinuousLinearMap.compL ℝ F F F (A z s))
-    (ContinuousLinearMap.id ℝ F) T hT K hK h𝒜_contOn h𝒜_bound
-
-section CharFlowDeriv
-open Filter Topology
-
-/-- Generic Grönwall difference-quotient bound (open-interval ODE + `s₀→0⁺` limit).  Two curves
-`uh, mh` that approximately solve the same linear ODE `w' = vlin·w` on `Ioo 0 T` from the same datum
-(`uh 0 = mh 0`), with `mh` exact and `uh`'s defect uniformly `≤ εf`, satisfy
-`dist (uh t) (mh t) ≤ gronwallBound 0 K εf t`.  `vlin` is abstract (kept opaque to avoid unfolding
-the heavy `vlasovFieldJacobian` integral in the Grönwall application). -/
-lemma gronwall_diffQuotient_bound
-    {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
-    (vlin : ℝ → (E →L[ℝ] E)) (K : NNReal) (hvlin_lip : ∀ s, LipschitzWith K (vlin s))
-    (uh mh Fuh : ℝ → E) (εf : ℝ) (T t : ℝ) (ht : t ∈ Set.Ioo (0 : ℝ) T)
-    (huh_cont : ContinuousOn uh (Set.Icc 0 T)) (hmh_cont : ContinuousOn mh (Set.Icc 0 T))
-    (huh_deriv : ∀ s ∈ Set.Ioo (0 : ℝ) T, HasDerivAt uh (Fuh s) s)
-    (hmh_deriv : ∀ s ∈ Set.Ioo (0 : ℝ) T, HasDerivAt mh ((vlin s) (mh s)) s)
-    (hdefect : ∀ s ∈ Set.Ioo (0 : ℝ) T, dist (Fuh s) (vlin s (uh s)) ≤ εf)
-    (h0 : uh 0 = mh 0) :
-    dist (uh t) (mh t) ≤ gronwallBound 0 (K:ℝ) εf t := by
-  have hbound_s0 : ∀ s₀ ∈ Set.Ioo (0 : ℝ) t,
-      dist (uh t) (mh t) ≤ gronwallBound (dist (uh s₀) (mh s₀)) (K:ℝ) εf (t - s₀) := by
-    intro s₀ hs₀
-    have hIco_sub : Set.Ico s₀ t ⊆ Set.Ioo 0 T := fun s hs =>
-      ⟨lt_of_lt_of_le hs₀.1 hs.1, hs.2.trans ht.2⟩
-    have hIcc_sub : Set.Icc s₀ t ⊆ Set.Icc 0 T := fun s hs =>
-      ⟨le_trans hs₀.1.le hs.1, le_trans hs.2 ht.2.le⟩
-    have key := dist_le_of_approx_trajectories_ODE (K := K)
-      (εf := εf) (εg := 0) (δ := dist (uh s₀) (mh s₀))
-      hvlin_lip (huh_cont.mono hIcc_sub)
-      (fun s hs => (huh_deriv s (hIco_sub hs)).hasDerivWithinAt)
-      (fun s hs => hdefect s (hIco_sub hs))
-      (hmh_cont.mono hIcc_sub)
-      (fun s hs => (hmh_deriv s (hIco_sub hs)).hasDerivWithinAt)
-      (fun s _ => le_of_eq (dist_self _)) (le_refl _)
-    have hkey := key t ⟨hs₀.2.le, le_refl t⟩
-    simpa only [add_zero] using hkey
-  have : (𝓝[Set.Ioo 0 t] (0 : ℝ)).NeBot := left_nhdsWithin_Ioo_neBot ht.1
-  have hT0 : (0 : ℝ) ≤ T := le_trans ht.1.le ht.2.le
-  have hsub_Icc : Set.Ioo (0 : ℝ) t ⊆ Set.Icc 0 T := fun s hs => ⟨hs.1.le, le_trans hs.2.le ht.2.le⟩
-  have htend_uh : Tendsto uh (𝓝[Set.Ioo 0 t] 0) (𝓝 (uh 0)) :=
-    (huh_cont 0 ⟨le_refl 0, hT0⟩).tendsto.mono_left (nhdsWithin_mono 0 hsub_Icc)
-  have htend_mh : Tendsto mh (𝓝[Set.Ioo 0 t] 0) (𝓝 (mh 0)) :=
-    (hmh_cont 0 ⟨le_refl 0, hT0⟩).tendsto.mono_left (nhdsWithin_mono 0 hsub_Icc)
-  have htend_δ : Tendsto (fun s₀ => dist (uh s₀) (mh s₀)) (𝓝[Set.Ioo 0 t] 0) (𝓝 0) := by
-    have := htend_uh.dist htend_mh
-    rwa [h0, dist_self] at this
-  have htend_x : Tendsto (fun s₀ : ℝ => t - s₀) (𝓝[Set.Ioo 0 t] 0) (𝓝 t) := by
-    have h0' : Tendsto (fun s₀ : ℝ => t - s₀) (𝓝 0) (𝓝 (t - 0)) :=
-      (continuous_const.sub continuous_id).tendsto 0
-    rw [sub_zero] at h0'; exact h0'.mono_left nhdsWithin_le_nhds
-  have hgb_cont : Continuous (fun p : ℝ × ℝ => gronwallBound p.1 (K:ℝ) εf p.2) := by
-    by_cases hK : (K:ℝ) = 0
-    · simp only [hK, gronwallBound_K0]; fun_prop
-    · have heq : (fun p : ℝ × ℝ => gronwallBound p.1 (K:ℝ) εf p.2)
-          = fun p => p.1 * Real.exp ((K:ℝ) * p.2) + εf / (K:ℝ) * (Real.exp ((K:ℝ) * p.2) - 1) := by
-        funext p; rw [gronwallBound_of_K_ne_0 hK]
-      rw [heq]; fun_prop
-  have htend_gb : Tendsto (fun s₀ => gronwallBound (dist (uh s₀) (mh s₀)) (K:ℝ) εf (t - s₀))
-      (𝓝[Set.Ioo 0 t] 0) (𝓝 (gronwallBound 0 (K:ℝ) εf t)) :=
-    (hgb_cont.tendsto (0, t)).comp (htend_δ.prodMk_nhds htend_x)
-  exact ge_of_tendsto htend_gb (eventually_nhdsWithin_of_forall (fun s₀ hs₀ => hbound_s0 s₀ hs₀))
-
-omit [NeZero d] in
-/-- **C3 D1 — the difference-quotient heart of the variational equation.**
-
-Given the fundamental matrix `Mz` of the linear variational ODE `M' = A(s, Φ_s z)·M`, `M 0 = id`
-(coefficient `A = vlasovFieldJacobian`), the time-`t` flow map `w ↦ (charX t w, charV t w)` is
-Fréchet-differentiable **at the fixed point `z`** with derivative exactly `Mz t`.
-
-This is the load-bearing difference-quotient estimate `Φ_t(z+h) − Φ_t(z) − Mz t·h = o(‖h‖)`.
-The matrix is threaded as an explicit hypothesis (rather than `choose`-d) so the proof can use its
-ODE/continuity data directly.
-
-**Proof plan (route b — Grönwall on the linearisation remainder).**  Reduce via
-`hasFDerivAt_iff_isLittleO_nhds_zero` + `Asymptotics.isLittleO_iff` to: `∀ c>0, ∀ᶠ h, ‖Φ_t(z+h) −
-Φ_t(z) − Mz t·h‖ ≤ c‖h‖`.  For fixed small `h`, the two curves `u_h(s) := Φ_s(z+h) − Φ_s(z)`
-(approximate) and `m_h(s) := Mz s·h` (exact) both solve `w' = A(s, Φ_s z)·w` from the same datum
-`h` (`Φ_0 = id`, `Mz 0 = id`):
-* `m_h` is exact — its defect is `0` (its derivative `(A·Mz)(s)·h = A(s)·m_h(s)` by `hMzderiv` +
-  `HasDerivWithinAt.clm_apply`).
-* `u_h`'s defect is the Taylor remainder `R(s, Φ_s(z+h))`, bounded by `η·‖u_h(s)‖` (D1a,
-  `vlasovField_taylorRemainder_uniform`) once `‖u_h(s)‖ ≤ δ(η)`, which holds with
-  `‖u_h(s)‖ ≤ exp(K T)·‖h‖` (flow Lipschitz-in-`z`, `charFlow_lipschitzInZ_via_gronwall_Ioo`) for
-  `‖h‖` small.  So `εf = η·exp(K T)·‖h‖`, uniform in `s`.
-The frozen field's two-sided ODE holds only on `Ioo 0 T`, so apply
-`dist_le_of_approx_trajectories_ODE` on `[s₀, t]` (`s₀ ∈ Ioo 0 t`) and take `s₀ → 0⁺` (the initial
-defect `dist(u_h s₀, m_h s₀) → 0` by continuity), giving `‖u_h t − m_h t‖ ≤ gronwallBound 0 K εf t =
-εf·(exp(K t)−1)/K`.  Since `η` is arbitrary this is `o(‖h‖)`.  `K := max 1 L` is the uniform field
-Lipschitz constant; `‖A(s,·)‖ ≤ K` via `norm_fderiv_le_of_lipschitz`.  (`hcontIcc` is universal in
-the initial point because the `s₀→0⁺` limit needs continuity of `Φ_·(z+h)`, M2.) -/
-theorem charFlow_hasFDerivAt_of_fundamentalMatrix
-    (gradW : PhysSpace d → PhysSpace d) (hgradW_C1 : ContDiff ℝ 1 gradW)
-    (L : NNReal) (hL : LipschitzWith L gradW)
-    (ρ : ℝ → Measure (PhysSpace d)) [∀ s, IsProbabilityMeasure (ρ s)]
-    (charX charV : ℝ → PhaseSpace d → PhysSpace d)
-    (T : ℝ) (hT : 0 < T)
-    (hflow : IsCharacteristicFlowOn gradW ρ charX charV (Set.Ioo 0 T) Set.univ)
-    (h_int : ∀ s (x : PhysSpace d), Integrable (fun y => gradW (x - y)) (ρ s))
-    (hρD_cont : ContinuousOn
-      (fun p : ℝ × PhysSpace d => ∫ y, fderiv ℝ gradW (p.2 - y) ∂(ρ p.1))
-      (Set.Icc 0 T ×ˢ (Set.univ : Set (PhysSpace d))))
-    (z : PhaseSpace d)
-    (hcontIcc : ∀ z' : PhaseSpace d,
-      ContinuousOn (fun s => (charX s z', charV s z')) (Set.Icc (0 : ℝ) T))
-    (Mz : ℝ → (PhaseSpace d →L[ℝ] PhaseSpace d))
-    (hMz0 : Mz 0 = ContinuousLinearMap.id ℝ (PhaseSpace d))
-    (hMzcont : ContinuousOn Mz (Set.Icc 0 T))
-    (hMzderiv : ∀ s ∈ Set.Icc (0 : ℝ) T,
-      HasDerivWithinAt Mz
-        ((vlasovFieldJacobian gradW ρ (s, (charX s z, charV s z))).comp (Mz s))
-        (Set.Icc 0 T) s) :
-    ∀ t ∈ Set.Ioo (0 : ℝ) T, HasFDerivAt (fun w => (charX t w, charV t w)) (Mz t) z := by
-  intro t ht
-  set Kr : ℝ := ((max 1 L : NNReal) : ℝ) with hKr
-  have hKr1 : (1:ℝ) ≤ Kr := by rw [hKr]; exact_mod_cast le_max_left 1 L
-  have hKrpos : (0 : ℝ) < Kr := lt_of_lt_of_le one_pos hKr1
-  set Φ : ℝ → PhaseSpace d := fun s => (charX s z, charV s z) with hΦ
-  have hF2 : ∀ s (w : PhaseSpace d),
-      HasFDerivAt (vlasovVectorField gradW ρ s) (vlasovFieldJacobian gradW ρ (s, w)) w :=
-    fun s w => vlasovVectorField_hasFDerivAt_in_z gradW hgradW_C1 L hL ρ h_int s w
-  have hVF_lip : ∀ s, LipschitzWith (max 1 L) (vlasovVectorField gradW ρ s) := fun s =>
-    vlasovVectorField_lipschitzWith gradW L hL ρ h_int s
-  set vlin : ℝ → (PhaseSpace d →L[ℝ] PhaseSpace d) := fun s => vlasovFieldJacobian gradW ρ (s, Φ s)
-    with hvlin
-  have hvlin_norm : ∀ s, ‖vlin s‖ ≤ Kr := by
-    intro s
-    change ‖vlasovFieldJacobian gradW ρ (s, Φ s)‖ ≤ Kr
-    rw [← (hF2 s (Φ s)).fderiv]
-    exact norm_fderiv_le_of_lipschitz ℝ (hVF_lip s)
-  have hvlin_lip : ∀ s, LipschitzWith (max 1 L) (vlin s) := by
-    intro s
-    refine LipschitzWith.of_dist_le_mul (fun x y => ?_)
-    rw [dist_eq_norm, dist_eq_norm, ← map_sub]
-    calc ‖vlin s (x - y)‖ ≤ ‖vlin s‖ * ‖x - y‖ := (vlin s).le_opNorm _
-      _ ≤ Kr * ‖x - y‖ := by gcongr; exact hvlin_norm s
-  clear_value vlin
-  have h_init : ∀ z' : PhaseSpace d, (charX 0 z', charV 0 z') = z' := fun z' =>
-    Prod.ext_iff.mpr ⟨(hflow.1 z' (Set.mem_univ z')).1, (hflow.1 z' (Set.mem_univ z')).2⟩
-  have h_derivAt : ∀ z', ∀ s ∈ Set.Ioo (0 : ℝ) T,
-      HasDerivAt (fun s => (charX s z', charV s z'))
-        (vlasovVectorField gradW ρ s (charX s z', charV s z')) s := fun z' s hs =>
-    HasDerivAt.prodMk (hflow.2.1 s hs z' (Set.mem_univ z')) (hflow.2.2 s hs z' (Set.mem_univ z'))
-  have hgron := charFlow_lipschitzInZ_via_gronwall_Ioo gradW L hL ρ h_int charX charV T hT.le
-    h_init hcontIcc (fun z' s hs => (h_derivAt z' s hs).hasDerivWithinAt)
-  rw [hasFDerivAt_iff_isLittleO_nhds_zero, Asymptotics.isLittleO_iff]
-  intro c hc
-  set Cexp : ℝ := Real.exp (Kr * T) with hCexp
-  have hCexp_pos : 0 < Cexp := Real.exp_pos _
-  set Cgron : ℝ := (Real.exp (Kr * t) - 1) / Kr with hCgron
-  have hCgron_nonneg : 0 ≤ Cgron := by
-    rw [hCgron]; apply div_nonneg _ hKrpos.le
-    simp only [sub_nonneg]; exact Real.one_le_exp (mul_nonneg hKrpos.le ht.1.le)
-  set G : ℝ := Cexp * Cgron with hG
-  have hG_nonneg : 0 ≤ G := mul_nonneg hCexp_pos.le hCgron_nonneg
-  set η : ℝ := c / (G + 1) with hη
-  have hη_pos : 0 < η := by rw [hη]; positivity
-  obtain ⟨δη, hδη_pos, hδη⟩ := vlasovField_taylorRemainder_uniform gradW hgradW_C1 L hL ρ h_int
-    charX charV T z (hcontIcc z) hρD_cont η hη_pos
-  refine Metric.eventually_nhds_iff.mpr
-    ⟨δη / (Cexp + 1), div_pos hδη_pos (by linarith [hCexp_pos]), ?_⟩
-  intro h hh
-  rw [dist_zero_right] at hh
-  have hCexph : Cexp * ‖h‖ ≤ δη := by
-    have hle : ‖h‖ * (Cexp + 1) ≤ δη := by rw [← le_div_iff₀ (by linarith [hCexp_pos])]; exact hh.le
-    nlinarith [norm_nonneg h, hCexp_pos, hle]
-  set uh : ℝ → PhaseSpace d := fun s => (charX s (z + h), charV s (z + h)) - (charX s z, charV s z)
-    with huh
-  set mh : ℝ → PhaseSpace d := fun s => (Mz s) h with hmh
-  set εf : ℝ := η * Cexp * ‖h‖ with hεf
-  have huh_cont : ContinuousOn uh (Set.Icc 0 T) := (hcontIcc (z + h)).sub (hcontIcc z)
-  have hmh_cont : ContinuousOn mh (Set.Icc 0 T) := hMzcont.clm_apply continuousOn_const
-  have huh_bound : ∀ s ∈ Set.Icc (0 : ℝ) T, ‖uh s‖ ≤ Cexp * ‖h‖ := by
-    intro s hs
-    change ‖(charX s (z + h), charV s (z + h)) - (charX s z, charV s z)‖ ≤ Cexp * ‖h‖
-    rw [← dist_eq_norm]
-    calc dist ((charX s (z + h), charV s (z + h)) : PhaseSpace d) (charX s z, charV s z)
-        ≤ dist (z + h) z * Real.exp (Kr * (s - 0)) := hgron s hs (z + h) z
-      _ = ‖h‖ * Real.exp (Kr * s) := by rw [dist_eq_norm, add_sub_cancel_left, sub_zero]
-      _ ≤ ‖h‖ * Cexp := by
-          refine mul_le_mul_of_nonneg_left ?_ (norm_nonneg h)
-          rw [hCexp]; exact Real.exp_le_exp.mpr (mul_le_mul_of_nonneg_left hs.2 hKrpos.le)
-      _ = Cexp * ‖h‖ := mul_comm _ _
-  have huh_derivAt : ∀ s ∈ Set.Ioo (0 : ℝ) T, HasDerivAt uh
-      (vlasovVectorField gradW ρ s (charX s (z + h), charV s (z + h))
-        - vlasovVectorField gradW ρ s (charX s z, charV s z)) s := fun s hs =>
-    (h_derivAt (z + h) s hs).sub (h_derivAt z s hs)
-  have hmh_derivAt : ∀ s ∈ Set.Ioo (0 : ℝ) T, HasDerivAt mh ((vlin s) (mh s)) s := by
-    intro s hs
-    have hMz_at : HasDerivAt Mz ((vlin s).comp (Mz s)) s := by
-      simp only [hvlin]
-      exact (hMzderiv s (Set.Ioo_subset_Icc_self hs)).hasDerivAt (Icc_mem_nhds hs.1 hs.2)
-    have hck := hMz_at.clm_apply (hasDerivAt_const s h)
-    simpa only [ContinuousLinearMap.comp_apply, map_zero, add_zero] using hck
-  have hdefect : ∀ s ∈ Set.Ioo (0 : ℝ) T,
-      dist (vlasovVectorField gradW ρ s (charX s (z + h), charV s (z + h))
-        - vlasovVectorField gradW ρ s (charX s z, charV s z)) (vlin s (uh s)) ≤ εf := by
-    intro s hs
-    have hsIcc : s ∈ Set.Icc (0 : ℝ) T := Set.Ioo_subset_Icc_self hs
-    have huhs_le : ‖uh s‖ ≤ δη := le_trans (huh_bound s hsIcc) hCexph
-    have hR := hδη s hsIcc (charX s (z + h), charV s (z + h)) huhs_le
-    rw [dist_eq_norm]; simp only [hvlin]
-    calc ‖vlasovVectorField gradW ρ s (charX s (z + h), charV s (z + h))
-            - vlasovVectorField gradW ρ s (charX s z, charV s z)
-            - vlasovFieldJacobian gradW ρ (s, Φ s) (uh s)‖
-        ≤ η * ‖uh s‖ := hR
-      _ ≤ η * (Cexp * ‖h‖) := mul_le_mul_of_nonneg_left (huh_bound s hsIcc) hη_pos.le
-      _ = εf := by rw [hεf]; ring
-  have huh0 : uh 0 = h := by
-    change (charX 0 (z + h), charV 0 (z + h)) - (charX 0 z, charV 0 z) = h
-    rw [h_init (z + h), h_init z, add_sub_cancel_left]
-  have hmh0 : mh 0 = h := by change (Mz 0) h = h; rw [hMz0]; rfl
-  have hlim : dist (uh t) (mh t) ≤ gronwallBound 0 Kr εf t := by
-    have := gronwall_diffQuotient_bound vlin (max 1 L) hvlin_lip uh mh
-      (fun s => vlasovVectorField gradW ρ s (charX s (z + h), charV s (z + h))
-        - vlasovVectorField gradW ρ s (charX s z, charV s z)) εf T t ht
-      huh_cont hmh_cont huh_derivAt hmh_derivAt hdefect (huh0.trans hmh0.symm)
-    rwa [← hKr] at this
-  have hgb_val : gronwallBound 0 Kr εf t = εf * Cgron := by
-    rw [gronwallBound_of_K_ne_0 hKrpos.ne']; simp only [zero_mul, zero_add]; rw [hCgron]; ring
-  have hηG : η * G ≤ c := by
-    rw [hη]; rw [div_mul_eq_mul_div, div_le_iff₀ (by linarith [hG_nonneg] : (0 : ℝ) < G + 1)]
-    nlinarith [hG_nonneg, hc.le]
-  change ‖(charX t (z + h), charV t (z + h)) - (charX t z, charV t z) - (Mz t) h‖ ≤ c * ‖h‖
-  rw [show (charX t (z + h), charV t (z + h)) - (charX t z, charV t z) - (Mz t) h
-      = uh t - mh t from rfl, ← dist_eq_norm]
-  calc dist (uh t) (mh t)
-      ≤ gronwallBound 0 Kr εf t := hlim
-    _ = εf * Cgron := hgb_val
-    _ = η * G * ‖h‖ := by rw [hεf, hG]; ring
-    _ ≤ c * ‖h‖ := mul_le_mul_of_nonneg_right hηG (norm_nonneg h)
-
-end CharFlowDeriv
-
-omit [NeZero d] in
-/-- **C3 #3 — the variational equation (`HasFDerivAt` of the flow in its initial point).**
-
-For the frozen field `b(t,·) = vlasovVectorField gradW ρ t` with `gradW ∈ C¹` (supplied by the
-consumer via `assW2_contDiff_gradW`), the time-`t` characteristic map
-`z ↦ (charX t z, charV t z)` is Fréchet-differentiable in the initial point `z`, with a derivative
-`Dflow t z` that is continuous in `z` (so the flow map is `C¹` in `z`).  The derivative solves the
-linear matrix variational ODE `M' = (D_z b(t, Φ_t z)) · M`, `M_0 = id`.
-
-**This was the load-bearing research gap** — Mathlib has no C¹-dependence-of-an-ODE-flow-on-its-
-initial-condition lemma — now proven (axiom-clean) via route (b)
-(`charFlow_lipschitzInZ_via_gronwall_Ioo`, `CharacteristicFlow.lean`, is the Lipschitz-in-`z`
-scaffold; Mathlib Gronwall + the vendored `IsPicardLindelof` confinement are the analytic inputs):
-3.1 existence/uniqueness of the continuous matrix solution `M_t(z)` of the variational ODE
-(`fundamentalMatrix`); 3.2 joint `(t,z)` continuity of `M` (`fundamentalMatrix_continuous_param`);
-3.3 the difference-quotient estimate `Φ_t(z+h) − Φ_t(z) − M_t(z)·h = o(‖h‖)` uniformly on compacts
-(Gronwall on the linearization remainder, using `gradW ∈ C¹`,
-`charFlow_hasFDerivAt_of_fundamentalMatrix`); 3.4 assembled into `HasFDerivAt`.
-
-The `HasFDerivAt`/continuity *conclusion* is route-independent, so this interface is stable; the
-universal-`t` probability instance + force-integrability `h_int` are the field-regularity inputs
-the proof consumes (the window-only application clamps, L11, at the grind).
-
-**`hρD_cont` (joint continuity of the convolution-derivative field).**  This is the regularity that
-makes the variational coefficient `A(s,z) = D_z b(s, Φ_s z)` continuous in `s` — its only non-flow
-varying part is `D_x conv(ρ_s)(x) = ∫ fderiv gradW (x − y) ∂ρ_s`, evaluated at the *moving* point
-`Φ_s z`, so per-`x` continuity is not enough; joint `(s,x)`-continuity is needed.  Note the
-asymmetry with the *field*: `∫ gradW(x−y) dρ_s` gets joint continuity for free (per-`x` continuity
-+ uniform Lipschitz-in-`x`, `convolveFunctionMeasure_lipschitz_in_x`), but the *derivative* field is
-NOT uniformly Lipschitz in `x` (that needs `W ∈ C³`; `AssW2` gives only `C²`), so its joint
-continuity must be supplied.
-
-**Option-B note (running — eventual extension).**  `hρD_cont` is, in the complete theory, NOT a new
-assumption: it is *derivable* from **narrow continuity of `s ↦ ρ_s`** (since `fderiv gradW` is
-bounded continuous, `‖·‖ ≤ L`), which is in turn derivable from `IsVlasovSolutionOn` + tightness
-(the uniform moment bound) via the standard **"`C_c^∞`-continuity + tight ⟹ narrow-continuity"**
-upgrade — a self-contained measure-theory lemma not yet in the codebase.  We thread it as a
-hypothesis (Option A) to unblock the variational-equation grind; folding it into a derived fact
-(so the bridge assumes only the weak solution + moments) is the **Option-B extension**, tracked as
-a follow-up. -/
-theorem charFlow_hasFDerivAt_in_initialPoint
-    (gradW : PhysSpace d → PhysSpace d) (hgradW_C1 : ContDiff ℝ 1 gradW)
-    (L : NNReal) (hL : LipschitzWith L gradW)
-    (ρ : ℝ → Measure (PhysSpace d)) [∀ s, IsProbabilityMeasure (ρ s)]
-    (charX charV : ℝ → PhaseSpace d → PhysSpace d)
-    (T : ℝ) (hT : 0 < T)
-    (hflow : IsCharacteristicFlowOn gradW ρ charX charV (Set.Ioo 0 T) Set.univ)
-    (h_int : ∀ s (x : PhysSpace d), Integrable (fun y => gradW (x - y)) (ρ s))
-    (hρD_cont : ContinuousOn
-      (fun p : ℝ × PhysSpace d => ∫ y, fderiv ℝ gradW (p.2 - y) ∂(ρ p.1))
-      (Set.Icc 0 T ×ˢ (Set.univ : Set (PhysSpace d))))
-    (hcontIcc : ∀ z : PhaseSpace d,
-      ContinuousOn (fun s => (charX s z, charV s z)) (Set.Icc (0 : ℝ) T)) :
-    ∃ Dflow : ℝ → PhaseSpace d → (PhaseSpace d →L[ℝ] PhaseSpace d),
-      (∀ t ∈ Set.Ioo (0 : ℝ) T, ∀ z : PhaseSpace d,
-        HasFDerivAt (fun w => (charX t w, charV t w)) (Dflow t z) z) ∧
-      (∀ t ∈ Set.Ioo (0 : ℝ) T, Continuous (Dflow t)) := by
-  -- **Reduction (Route A — explicit fundamental matrix, lesson L14).**  `M z := fundamentalMatrix
-  -- (A z)` with `A z s := vlasovFieldJacobian gradW ρ (s, Φ_s z)`; its ODE/continuity
-  -- data come from
-  -- `fundamentalMatrix_spec` (feeds D1), and `z ↦ M z t` continuity (V2) from
-  -- `fundamentalMatrix_continuous_param` — the parameter-regularity an existential
-  -- `choose` could not
-  -- supply.  `Dflow t z := fundamentalMatrix (A z) t`.
-  set A : PhaseSpace d → ℝ → (PhaseSpace d →L[ℝ] PhaseSpace d) :=
-    fun z s => vlasovFieldJacobian gradW ρ (s, (charX s z, charV s z)) with hA_def
-  have hAcont : ∀ z : PhaseSpace d, ContinuousOn (A z) (Set.Icc 0 T) := fun z =>
-    vlasovVariationalCoeff_continuousOn gradW ρ charX charV T z (hcontIcc z) hρD_cont
-  refine ⟨fun t z => fundamentalMatrix (A z) t, ?_, ?_⟩
-  · -- **D1** — `charFlow_hasFDerivAt_of_fundamentalMatrix` fed by `fundamentalMatrix_spec`.
-    intro t ht z
-    obtain ⟨h0, hcont, hderiv⟩ := fundamentalMatrix_spec (A z) T hT.le (hAcont z)
-    exact charFlow_hasFDerivAt_of_fundamentalMatrix gradW hgradW_C1 L hL ρ charX charV T hT hflow
-      h_int hρD_cont z hcontIcc (fundamentalMatrix (A z)) h0 hcont hderiv t ht
-  · -- **V2** — `fundamentalMatrix_continuous_param`: flow joint continuity ⇒ `A` jointly continuous
-    -- ⇒ `z ↦ M z t` continuous.
-    intro t ht
-    -- Flow joint continuity `(z,s) ↦ Φ_s z` on `univ ×ˢ Icc 0 T` (Grönwall Lipschitz-in-`z` from
-    -- `hflow` + per-`z` continuity in `s`).
-    have h_init : ∀ z : PhaseSpace d, (charX 0 z, charV 0 z) = z := fun z =>
-      Prod.ext_iff.mpr ⟨(hflow.1 z (Set.mem_univ z)).1, (hflow.1 z (Set.mem_univ z)).2⟩
-    have h_deriv : ∀ z, ∀ s ∈ Set.Ioo (0 : ℝ) T,
-        HasDerivWithinAt (fun s => (charX s z, charV s z))
-          (vlasovVectorField gradW ρ s (charX s z, charV s z)) (Set.Ici s) s := fun z s hs =>
-      (HasDerivAt.prodMk (hflow.2.1 s hs z (Set.mem_univ z))
-        (hflow.2.2 s hs z (Set.mem_univ z))).hasDerivWithinAt
-    have hgron := charFlow_lipschitzInZ_via_gronwall_Ioo gradW L hL ρ h_int charX charV T hT.le
-      h_init hcontIcc h_deriv
-    have hflowjoint : ContinuousOn
-        (fun p : PhaseSpace d × ℝ => (charX p.2 p.1, charV p.2 p.1)) (Set.univ ×ˢ Set.Icc 0 T) := by
-      refine continuousOn_prod_of_lipschitz_continuousOn (fun z s => (charX s z, charV s z)) T
-        (Real.exp (((max 1 L : NNReal) : ℝ) * T)) (fun s hs z₁ z₂ => ?_) hcontIcc
-      calc dist ((charX s z₁, charV s z₁) : PhaseSpace d) (charX s z₂, charV s z₂)
-          ≤ dist z₁ z₂ * Real.exp (((max 1 L : NNReal) : ℝ) * (s - 0)) := hgron s hs z₁ z₂
-        _ = Real.exp (((max 1 L : NNReal) : ℝ) * (s - 0)) * dist z₁ z₂ := by ring
-        _ ≤ Real.exp (((max 1 L : NNReal) : ℝ) * T) * dist z₁ z₂ := by
-            refine mul_le_mul_of_nonneg_right (Real.exp_le_exp.mpr ?_) dist_nonneg
-            have hsT : s - 0 ≤ T := by simp only [sub_zero]; exact hs.2
-            exact mul_le_mul_of_nonneg_left hsT (by positivity)
-    -- `A` jointly continuous (Jacobian along the flow) and uniformly bounded by `max 1 L`.
-    have hg : ContinuousOn
-        (fun p : PhaseSpace d × ℝ => ((p.2, (charX p.2 p.1, charV p.2 p.1)) : ℝ × PhaseSpace d))
-        (Set.univ ×ˢ Set.Icc 0 T) := continuousOn_snd.prodMk hflowjoint
-    have hmapsg : Set.MapsTo
-        (fun p : PhaseSpace d × ℝ => ((p.2, (charX p.2 p.1, charV p.2 p.1)) : ℝ × PhaseSpace d))
-        (Set.univ ×ˢ Set.Icc 0 T) (Set.Icc 0 T ×ˢ Set.univ) := fun p hp => ⟨hp.2, Set.mem_univ _⟩
-    have hA_contOn : ContinuousOn (fun p : PhaseSpace d × ℝ => A p.1 p.2)
-        (Set.univ ×ˢ Set.Icc 0 T) :=
-      (vlasovFieldJacobian_continuousOn gradW ρ T hρD_cont).comp hg hmapsg
-    have hA_bound : ∀ z, ∀ s ∈ Set.Icc (0 : ℝ) T, ‖A z s‖ ≤ ((max 1 L : NNReal) : ℝ) := by
-      intro z s _
-      have heq : A z s = fderiv ℝ (vlasovVectorField gradW ρ s) (charX s z, charV s z) := by
-        simp only [hA_def]
-        exact (vlasovVectorField_hasFDerivAt_in_z gradW hgradW_C1 L hL ρ h_int s
-          (charX s z, charV s z)).fderiv.symm
-      rw [heq]
-      exact norm_fderiv_le_of_lipschitz ℝ (vlasovVectorField_lipschitzWith gradW L hL ρ h_int s)
-    exact fundamentalMatrix_continuous_param A T hT.le ((max 1 L : NNReal) : ℝ) (by positivity)
-      hA_contOn hA_bound t (Set.Ioo_subset_Icc_self ht)
-
-open Filter Topology in
-omit [NeZero d] in
-/-- **Step 1 (dual core) — lower Grönwall / anti-Lipschitz bound on the characteristic flow.**
-For `t ∈ (0,T)`, the flow `Φ_t : z ↦ (charX t z, charV t z)` satisfies
-`dist z₁ z₂ ≤ dist (Φ_t z₁) (Φ_t z₂) · exp(K t)` (K = max 1 L), i.e. `Φ_t` is `AntilipschitzWith`.
-This is the keystone of the two-time-flow inverse construction (Step 2): bi-Lipschitz makes `Φ_t`
-injective with closed range and `M_t = DΦ_t` invertible (no Liouville needed).
-
-Proof: time-reverse the two trajectories on each `[s₀,t] ⊆ (0,T)` (so they solve
-`w' = −b_{s₀+t−r}(w)`, still K-Lipschitz) and apply the existing forward
-`dist_le_of_trajectories_ODE`; take `s₀→0⁺`.  `h_deriv2` is the two-sided `HasDerivAt` on the open
-interval, supplied by `IsCharacteristicFlowOn`. -/
-theorem charFlow_antilipschitzInZ_via_gronwall_Ioo
-    (gradW : PhysSpace d → PhysSpace d)
-    (L : NNReal) (hL : LipschitzWith L gradW)
-    (ρ : ℝ → Measure (PhysSpace d))
-    [∀ t, IsProbabilityMeasure (ρ t)]
-    (h_int : ∀ t (x : PhysSpace d), Integrable (fun y => gradW (x - y)) (ρ t))
-    (charX charV : ℝ → PhaseSpace d → PhysSpace d)
-    (T : ℝ)
-    (h_init : ∀ z : PhaseSpace d, (charX 0 z, charV 0 z) = z)
-    (h_cont_Icc : ∀ z, ContinuousOn (fun s => (charX s z, charV s z)) (Set.Icc (0 : ℝ) T))
-    (h_deriv2 : ∀ z, ∀ s ∈ Set.Ioo (0 : ℝ) T,
-      HasDerivAt (fun s' => (charX s' z, charV s' z))
-        (vlasovVectorField gradW ρ s (charX s z, charV s z)) s) :
-    ∀ t ∈ Set.Ioo (0 : ℝ) T, ∀ z₁ z₂ : PhaseSpace d,
-      dist z₁ z₂ ≤
-        dist ((charX t z₁, charV t z₁) : PhaseSpace d) (charX t z₂, charV t z₂)
-          * Real.exp (((max 1 L : NNReal) : ℝ) * (t - 0)) := by
-  intro t ht z₁ z₂
-  set K : NNReal := max 1 L with hK_def
-  have h_vf_lip : ∀ s, LipschitzWith K (vlasovVectorField gradW ρ s) := fun s =>
-    vlasovVectorField_lipschitzWith gradW L hL ρ h_int s
-  set F : ℝ → PhaseSpace d := fun s => (charX s z₁, charV s z₁) with hF_def
-  set G : ℝ → PhaseSpace d := fun s => (charX s z₂, charV s z₂) with hG_def
-  -- Per-`s₀` antilipschitz bound on `[s₀, t]`.
-  have h_perS0 : ∀ s₀ ∈ Set.Ioo (0 : ℝ) t,
-      dist (F s₀) (G s₀) ≤ dist (F t) (G t) * Real.exp ((K : ℝ) * (t - s₀)) := by
-    intro s₀ hs₀
-    have hsub_Ioo : Set.Icc s₀ t ⊆ Set.Ioo (0 : ℝ) T := fun r hr =>
-      ⟨lt_of_lt_of_le hs₀.1 hr.1, lt_of_le_of_lt hr.2 ht.2⟩
-    have hsub_Icc : Set.Icc s₀ t ⊆ Set.Icc (0 : ℝ) T := fun r hr =>
-      ⟨le_of_lt (lt_of_lt_of_le hs₀.1 hr.1), le_of_lt (lt_of_le_of_lt hr.2 ht.2)⟩
-    have hrefl_mem : ∀ r ∈ Set.Icc s₀ t, s₀ + t - r ∈ Set.Icc s₀ t := by
-      intro r hr; exact ⟨by linarith [hr.2], by linarith [hr.1]⟩
-    have hrefl_cont : ContinuousOn (fun r : ℝ => s₀ + t - r) (Set.Icc s₀ t) :=
-      (continuous_const.sub continuous_id).continuousOn
-    set vr : ℝ → PhaseSpace d → PhaseSpace d :=
-      fun r w => -(vlasovVectorField gradW ρ (s₀ + t - r) w) with hvr_def
-    have hvr_lip : ∀ r, LipschitzWith K (vr r) := fun r => (h_vf_lip (s₀ + t - r)).neg
-    have hFr_cont : ContinuousOn (fun r => F (s₀ + t - r)) (Set.Icc s₀ t) :=
-      (h_cont_Icc z₁).comp hrefl_cont (fun r hr => hsub_Icc (hrefl_mem r hr))
-    have hGr_cont : ContinuousOn (fun r => G (s₀ + t - r)) (Set.Icc s₀ t) :=
-      (h_cont_Icc z₂).comp hrefl_cont (fun r hr => hsub_Icc (hrefl_mem r hr))
-    have hFr' : ∀ r ∈ Set.Ico s₀ t,
-        HasDerivWithinAt (fun r => F (s₀ + t - r)) (vr r (F (s₀ + t - r))) (Set.Ici r) r := by
-      intro r hr
-      have hrIoo : s₀ + t - r ∈ Set.Ioo (0 : ℝ) T :=
-        hsub_Ioo ⟨by linarith [hr.2], by linarith [hr.1]⟩
-      have hlin : HasDerivAt (fun r : ℝ => s₀ + t - r) (-1) r := by
-        simpa using (hasDerivAt_id r).const_sub (s₀ + t)
-      have key : HasDerivAt (fun r => F (s₀ + t - r))
-          ((-1 : ℝ) • vlasovVectorField gradW ρ (s₀ + t - r) (F (s₀ + t - r))) r :=
-        HasDerivAt.scomp_of_eq r (h_deriv2 z₁ (s₀ + t - r) hrIoo) hlin rfl
-      simp only [neg_one_smul] at key
-      exact key.hasDerivWithinAt
-    have hGr' : ∀ r ∈ Set.Ico s₀ t,
-        HasDerivWithinAt (fun r => G (s₀ + t - r)) (vr r (G (s₀ + t - r))) (Set.Ici r) r := by
-      intro r hr
-      have hrIoo : s₀ + t - r ∈ Set.Ioo (0 : ℝ) T :=
-        hsub_Ioo ⟨by linarith [hr.2], by linarith [hr.1]⟩
-      have hlin : HasDerivAt (fun r : ℝ => s₀ + t - r) (-1) r := by
-        simpa using (hasDerivAt_id r).const_sub (s₀ + t)
-      have key : HasDerivAt (fun r => G (s₀ + t - r))
-          ((-1 : ℝ) • vlasovVectorField gradW ρ (s₀ + t - r) (G (s₀ + t - r))) r :=
-        HasDerivAt.scomp_of_eq r (h_deriv2 z₂ (s₀ + t - r) hrIoo) hlin rfl
-      simp only [neg_one_smul] at key
-      exact key.hasDerivWithinAt
-    have hgron := dist_le_of_trajectories_ODE hvr_lip hFr_cont hFr' hGr_cont hGr'
-      (le_refl (dist (F (s₀ + t - s₀)) (G (s₀ + t - s₀)))) t ⟨hs₀.2.le, le_refl t⟩
-    simp only [show s₀ + t - t = s₀ from by ring, show s₀ + t - s₀ = t from by ring] at hgron
-    exact hgron
-  -- `s₀ → 0⁺` limit.
-  have hfilt : (nhdsWithin (0 : ℝ) (Set.Ioo 0 t)).NeBot := left_nhdsWithin_Ioo_neBot ht.1
-  have hIoo_sub_Icc : Set.Ioo (0 : ℝ) t ⊆ Set.Icc (0 : ℝ) T := fun s hs =>
-    ⟨hs.1.le, le_of_lt (lt_trans hs.2 ht.2)⟩
-  have h_tendsto_F : Tendsto F (nhdsWithin (0 : ℝ) (Set.Ioo 0 t)) (nhds z₁) := by
-    have hcw : ContinuousWithinAt F (Set.Icc (0 : ℝ) T) 0 :=
-      (h_cont_Icc z₁) 0 ⟨le_refl 0, le_of_lt (lt_trans ht.1 ht.2)⟩
-    have h0 : Tendsto F (nhdsWithin (0 : ℝ) (Set.Icc 0 T)) (nhds (F 0)) := hcw
-    rw [show F 0 = z₁ from h_init z₁] at h0
-    exact h0.mono_left (nhdsWithin_mono 0 hIoo_sub_Icc)
-  have h_tendsto_G : Tendsto G (nhdsWithin (0 : ℝ) (Set.Ioo 0 t)) (nhds z₂) := by
-    have hcw : ContinuousWithinAt G (Set.Icc (0 : ℝ) T) 0 :=
-      (h_cont_Icc z₂) 0 ⟨le_refl 0, le_of_lt (lt_trans ht.1 ht.2)⟩
-    have h0 : Tendsto G (nhdsWithin (0 : ℝ) (Set.Icc 0 T)) (nhds (G 0)) := hcw
-    rw [show G 0 = z₂ from h_init z₂] at h0
-    exact h0.mono_left (nhdsWithin_mono 0 hIoo_sub_Icc)
-  have h_tendsto_lhs : Tendsto (fun s₀ => dist (F s₀) (G s₀))
-      (nhdsWithin (0 : ℝ) (Set.Ioo 0 t)) (nhds (dist z₁ z₂)) :=
-    h_tendsto_F.dist h_tendsto_G
-  have h_tendsto_rhs : Tendsto (fun s₀ => dist (F t) (G t) * Real.exp ((K : ℝ) * (t - s₀)))
-      (nhdsWithin (0 : ℝ) (Set.Ioo 0 t))
-      (nhds (dist (F t) (G t) * Real.exp ((K : ℝ) * (t - 0)))) := by
-    have hcont : Continuous (fun s₀ : ℝ => dist (F t) (G t) * Real.exp ((K : ℝ) * (t - s₀))) := by
-      fun_prop
-    exact (hcont.tendsto 0).mono_left nhdsWithin_le_nhds
-  exact le_of_tendsto_of_tendsto h_tendsto_lhs h_tendsto_rhs
-    (eventually_nhdsWithin_of_forall h_perS0)
-
-section Step2Inverse
-open Filter Topology
-
-/-- **Step 2a (dual core, generic) — antilipschitz map ⇒ antilipschitz derivative.**
-If `f` is antilipschitz and Fréchet-differentiable at `x`, its derivative `f'` is antilipschitz
-(hence injective) with the same constant.  `f' u` is the limit of slopes `n•(f(x+n⁻¹•u)−f x)`, each
-of norm `≥ ‖u‖/C` by antilipschitz; pass to the limit.  (Mathlib lacks this producer.) -/
-theorem antilipschitzWith_fderiv_of_antilipschitz
-    {E F : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
-    [NormedAddCommGroup F] [NormedSpace ℝ F]
-    {f : E → F} {f' : E →L[ℝ] F} {x : E} {C : NNReal}
-    (hf : AntilipschitzWith C f) (hf' : HasFDerivAt f f' x) :
-    AntilipschitzWith C f' := by
-  refine AntilipschitzWith.of_le_mul_dist (fun v w => ?_)
-  rw [dist_eq_norm, dist_eq_norm, ← map_sub]
-  set u := v - w with hu
-  have hc : Tendsto (fun n : ℕ => ‖((n : ℝ))‖) atTop atTop := by
-    simpa [Real.norm_natCast] using tendsto_natCast_atTop_atTop (R := ℝ)
-  have hlim := hf'.lim u hc
-  have hbd : ∀ᶠ n : ℕ in atTop,
-      ‖u‖ ≤ (C : ℝ) * ‖(n : ℝ) • (f (x + ((n : ℝ))⁻¹ • u) - f x)‖ := by
-    filter_upwards [eventually_gt_atTop 0] with n hn
-    have hn0 : (0 : ℝ) < (n : ℝ) := by exact_mod_cast hn
-    have hd := hf.le_mul_dist (x + ((n : ℝ))⁻¹ • u) x
-    rw [dist_eq_norm, dist_eq_norm, add_sub_cancel_left, norm_smul, norm_inv,
-      Real.norm_natCast] at hd
-    rw [norm_smul, Real.norm_natCast]
-    calc ‖u‖ = (n : ℝ) * ((n : ℝ)⁻¹ * ‖u‖) := by
-              rw [← mul_assoc, mul_inv_cancel₀ (ne_of_gt hn0), one_mul]
-      _ ≤ (n : ℝ) * ((C : ℝ) * ‖f (x + ((n : ℝ))⁻¹ • u) - f x‖) :=
-              mul_le_mul_of_nonneg_left hd (le_of_lt hn0)
-      _ = (C : ℝ) * ((n : ℝ) * ‖f (x + ((n : ℝ))⁻¹ • u) - f x‖) := by ring
-  have hlim2 : Tendsto (fun n : ℕ => (C : ℝ) * ‖(n : ℝ) • (f (x + ((n : ℝ))⁻¹ • u) - f x)‖)
-      atTop (𝓝 ((C : ℝ) * ‖f' u‖)) := hlim.norm.const_mul (C : ℝ)
-  exact ge_of_tendsto hlim2 hbd
-
-/-- **Step 2 (dual core, generic) — global `C¹` inverse of an antilipschitz `C¹` self-map.**
-If `Φ : E → E` (finite-dim) is `C¹` (derivative `M z` at `z`), antilipschitz, and Lipschitz, then
-each `M z` is invertible, `Φ` is bijective, and the global inverse `Ψ` is Lipschitz with
-`HasFDerivAt Ψ (M (Ψ w))⁻¹ w`.  No Liouville/Hadamard: open range
-(`isOpenMap_of_hasStrictFDerivAt_equiv`) + closed range (`AntilipschitzWith.isClosed_range`) ⇒
-clopen ⇒ surjective; inverse derivative from `HasStrictFDerivAt.to_local_left_inverse`. -/
-theorem exists_global_c1_inverse_of_antilipschitz
-    {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] [FiniteDimensional ℝ E]
-    {Φ : E → E} {M : E → (E →L[ℝ] E)} {Ca Cl : NNReal}
-    (hderiv : ∀ z, HasFDerivAt Φ (M z) z)
-    (hM_cont : Continuous M)
-    (hanti : AntilipschitzWith Ca Φ)
-    (hlip : LipschitzWith Cl Φ) :
-    ∃ (Ψ : E → E) (e : E → E ≃L[ℝ] E),
-      (∀ z, ((e z : E →L[ℝ] E)) = M z) ∧
-      Function.LeftInverse Ψ Φ ∧ Function.RightInverse Ψ Φ ∧
-      LipschitzWith Ca Ψ ∧
-      (∀ w, HasFDerivAt Ψ ((e (Ψ w)).symm : E →L[ℝ] E) w) := by
-  classical
-  have hMz_anti : ∀ z, AntilipschitzWith Ca (M z) := fun z =>
-    antilipschitzWith_fderiv_of_antilipschitz hanti (hderiv z)
-  have hker : ∀ z, LinearMap.ker (M z : E →ₗ[ℝ] E) = ⊥ := fun z =>
-    LinearMap.ker_eq_bot.mpr (hMz_anti z).injective
-  have hsurj_lin : ∀ z, LinearMap.range (M z : E →ₗ[ℝ] E) = ⊤ := fun z =>
-    LinearMap.range_eq_top.mpr (LinearMap.injective_iff_surjective.mp (hMz_anti z).injective)
-  set e : ∀ z, E ≃L[ℝ] E := fun z =>
-    ContinuousLinearEquiv.ofBijective (M z) (hker z) (hsurj_lin z) with he_def
-  have he_coe : ∀ z, ((e z : E →L[ℝ] E)) = M z := fun _ => rfl
-  have hC1 : ContDiff ℝ 1 Φ := contDiff_one_iff_hasFDerivAt.mpr ⟨M, hM_cont, hderiv⟩
-  have hstrict : ∀ z, HasStrictFDerivAt Φ ((e z : E →L[ℝ] E)) z := fun z => by
-    rw [he_coe z]; exact hC1.contDiffAt.hasStrictFDerivAt' (hderiv z) (by norm_num)
-  have hopen : IsOpenMap Φ := isOpenMap_of_hasStrictFDerivAt_equiv hstrict
-  have hrange_open : IsOpen (Set.range Φ) := hopen.isOpen_range
-  have hrange_closed : IsClosed (Set.range Φ) := hanti.isClosed_range hlip.uniformContinuous
-  have hrange_univ : Set.range Φ = Set.univ :=
-    IsClopen.eq_univ ⟨hrange_closed, hrange_open⟩ ⟨Φ 0, Set.mem_range_self 0⟩
-  have hsurj : Function.Surjective Φ := Set.range_eq_univ.mp hrange_univ
-  have hinj : Function.Injective Φ := hanti.injective
-  set Ψ : E → E := Function.invFun Φ with hΨ_def
-  have hLeft : Function.LeftInverse Ψ Φ := Function.leftInverse_invFun hinj
-  have hRight : Function.RightInverse Ψ Φ := Function.rightInverse_invFun hsurj
-  have hΨ_lip : LipschitzWith Ca Ψ := by
-    refine LipschitzWith.of_dist_le_mul (fun w₁ w₂ => ?_)
-    have h := hanti.le_mul_dist (Ψ w₁) (Ψ w₂)
-    rwa [hRight w₁, hRight w₂] at h
-  have hΨ_deriv : ∀ w, HasFDerivAt Ψ ((e (Ψ w)).symm : E →L[ℝ] E) w := by
-    intro w
-    have hz : Φ (Ψ w) = w := hRight w
-    have hev : ∀ᶠ x in 𝓝 (Ψ w), Ψ (Φ x) = x := Filter.Eventually.of_forall hLeft
-    have hsymm := (hstrict (Ψ w)).to_local_left_inverse hev
-    rw [hz] at hsymm
-    exact hsymm.hasFDerivAt
-  exact ⟨Ψ, e, he_coe, hLeft, hRight, hΨ_lip, hΨ_deriv⟩
-
-end Step2Inverse
-
-omit [NeZero d] in
-/-- **Step 2 (dual core) — the characteristic flow `Φ_t` is a `C¹` diffeomorphism on `(0,T)`.**
-Instantiates the generic global-inverse machinery at `Φ_t := (charX t, charV t)`: its derivative
-`e z` (= `#3`'s `Dflow t z`) is invertible, `Φ_t` is bijective, and the inverse `Ψ` is continuous
-with `HasFDerivAt Ψ (e (Ψ w))⁻¹ w`.  `hanti` comes from Step 1
-(`charFlow_antilipschitzInZ_via_gronwall_Ioo`), `hlip` from the existing upper Grönwall bound
-(`charFlow_lipschitzInZ_via_gronwall_Ioo`), the derivative family from `#3`. -/
-theorem exists_charFlow_inverse_On
-    (gradW : PhysSpace d → PhysSpace d) (hgradW_C1 : ContDiff ℝ 1 gradW)
-    (L : NNReal) (hL : LipschitzWith L gradW)
-    (ρ : ℝ → Measure (PhysSpace d)) [∀ s, IsProbabilityMeasure (ρ s)]
-    (charX charV : ℝ → PhaseSpace d → PhysSpace d)
-    (T : ℝ) (hT : 0 < T)
-    (hflow : IsCharacteristicFlowOn gradW ρ charX charV (Set.Ioo 0 T) Set.univ)
-    (h_int : ∀ s (x : PhysSpace d), Integrable (fun y => gradW (x - y)) (ρ s))
-    (hρD_cont : ContinuousOn
-      (fun p : ℝ × PhysSpace d => ∫ y, fderiv ℝ gradW (p.2 - y) ∂(ρ p.1))
-      (Set.Icc 0 T ×ˢ (Set.univ : Set (PhysSpace d))))
-    (hcontIcc : ∀ z : PhaseSpace d,
-      ContinuousOn (fun s => (charX s z, charV s z)) (Set.Icc (0 : ℝ) T)) :
-    ∀ t ∈ Set.Ioo (0 : ℝ) T,
-      ∃ (Ψ : PhaseSpace d → PhaseSpace d)
-        (e : PhaseSpace d → (PhaseSpace d ≃L[ℝ] PhaseSpace d)),
-        (∀ z, HasFDerivAt (fun w => (charX t w, charV t w))
-          ((e z : PhaseSpace d →L[ℝ] PhaseSpace d)) z) ∧
-        Function.LeftInverse Ψ (fun z => (charX t z, charV t z)) ∧
-        Function.RightInverse Ψ (fun z => (charX t z, charV t z)) ∧
-        Continuous Ψ ∧
-        (∀ w, HasFDerivAt Ψ ((e (Ψ w)).symm : PhaseSpace d →L[ℝ] PhaseSpace d) w) := by
-  have h_init : ∀ z : PhaseSpace d, (charX 0 z, charV 0 z) = z := fun z =>
-    Prod.ext_iff.mpr (hflow.1 z (Set.mem_univ z))
-  have h_deriv2 : ∀ z, ∀ s ∈ Set.Ioo (0 : ℝ) T,
-      HasDerivAt (fun s' => (charX s' z, charV s' z))
-        (vlasovVectorField gradW ρ s (charX s z, charV s z)) s := fun z s hs =>
-    HasDerivAt.prodMk (hflow.2.1 s hs z (Set.mem_univ z)) (hflow.2.2 s hs z (Set.mem_univ z))
-  have h_deriv_Ioo : ∀ z, ∀ s ∈ Set.Ioo (0 : ℝ) T,
-      HasDerivWithinAt (fun s' => (charX s' z, charV s' z))
-        (vlasovVectorField gradW ρ s (charX s z, charV s z)) (Set.Ici s) s := fun z s hs =>
-    (h_deriv2 z s hs).hasDerivWithinAt
-  obtain ⟨Dflow, hDeriv, hCont⟩ := charFlow_hasFDerivAt_in_initialPoint gradW hgradW_C1 L hL ρ
-    charX charV T hT hflow h_int hρD_cont hcontIcc
-  intro t ht
-  set K : ℝ := ((max 1 L : NNReal) : ℝ) with hK
-  have hCcoe : (((Real.exp (K * t)).toNNReal : NNReal) : ℝ) = Real.exp (K * t) :=
-    Real.coe_toNNReal _ (le_of_lt (Real.exp_pos _))
-  have hderiv : ∀ z, HasFDerivAt (fun z => (charX t z, charV t z)) (Dflow t z) z := fun z =>
-    hDeriv t ht z
-  have hM_cont : Continuous (Dflow t) := hCont t ht
-  have hanti : AntilipschitzWith (Real.exp (K * t)).toNNReal
-      (fun z => (charX t z, charV t z)) := by
-    refine AntilipschitzWith.of_le_mul_dist (fun z₁ z₂ => ?_)
-    have h1 := charFlow_antilipschitzInZ_via_gronwall_Ioo gradW L hL ρ h_int charX charV T
-      h_init hcontIcc h_deriv2 t ht z₁ z₂
-    rw [sub_zero] at h1
-    rw [hCcoe, mul_comm]
-    exact h1
-  have hlip : LipschitzWith (Real.exp (K * t)).toNNReal
-      (fun z => (charX t z, charV t z)) := by
-    refine LipschitzWith.of_dist_le_mul (fun z₁ z₂ => ?_)
-    have h1 := charFlow_lipschitzInZ_via_gronwall_Ioo gradW L hL ρ h_int charX charV T hT.le
-      h_init hcontIcc h_deriv_Ioo t (Set.Ioo_subset_Icc_self ht) z₁ z₂
-    rw [sub_zero] at h1
-    rw [hCcoe, mul_comm]
-    exact h1
-  obtain ⟨Ψ, e, he_coe, hLeft, hRight, hΨlip, hΨderiv⟩ :=
-    exists_global_c1_inverse_of_antilipschitz hderiv hM_cont hanti hlip
-  refine ⟨Ψ, e, ?_, hLeft, hRight, hΨlip.continuous, hΨderiv⟩
-  intro z; rw [he_coe z]; exact hderiv z
-
-section Step3Joint
-open Filter Topology Asymptotics
-
-/-- **Step 3 gating lemma (generic) — joint `C¹` from continuous partial derivatives** on a
-`ℝ × E` domain (Mathlib-absent).  A partial `s`-derivative `Ds p` at every point (`Ds` continuous)
-plus a partial `z`-derivative `Dz₀` at the base point ⇒ `f` is Fréchet-differentiable at `(s₀,z₀)`
-with total derivative `(h,k) ↦ h•Ds(s₀,z₀) + Dz₀ k`.  Proof: split the increment into an
-`s`-part (FTC `∫₀ʰ Ds(s₀+u,z₀+k)du ≈ h•Ds₀` by continuity of `Ds`) and a `z`-part
-(`= Dz₀ k + o(k)`).
-This is the keystone for the joint `(s,w)` regularity of the two-time flow `Φ_{s→t}`: the flow's
-partials are `M_s z` (jointly continuous, V2) in `z` and `b_s(Φ_s z)` in `s`.
-
-**PR-ABLE (Mathlib upstream candidate).**  This is a general real-analysis result with no Vlasov
-content — "a function on `ℝ × E` with a continuous partial derivative in the `ℝ` factor and a
-Fréchet partial derivative in the `E` factor is Fréchet-differentiable" — filling a genuine gap in
-`Mathlib/Analysis/Calculus`.  Generalisation worth doing before a PR: replace the `ℝ` factor by an
-arbitrary first factor with an analogous "integrate the partial along segments" hypothesis, and
-weaken `Continuous Ds` to `ContinuousAt Ds` at the base point (the proof only uses a neighbourhood
-of `(s₀,z₀)`). -/
-theorem hasFDerivAt_of_continuous_partials
-    {E F : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
-    [NormedAddCommGroup F] [NormedSpace ℝ F] [CompleteSpace F]
-    {f : ℝ × E → F} {Ds : ℝ × E → F} {Dz₀ : E →L[ℝ] F} (s₀ : ℝ) (z₀ : E)
-    (hDs : ∀ p : ℝ × E, HasDerivAt (fun s => f (s, p.2)) (Ds p) p.1)
-    (hDs_cont : Continuous Ds)
-    (hDz₀ : HasFDerivAt (fun z => f (s₀, z)) Dz₀ z₀) :
-    HasFDerivAt f
-      ((ContinuousLinearMap.fst ℝ ℝ E).smulRight (Ds (s₀, z₀))
-        + Dz₀.comp (ContinuousLinearMap.snd ℝ ℝ E)) (s₀, z₀) := by
-  set Ds₀ : F := Ds (s₀, z₀) with hDs₀
-  rw [hasFDerivAt_iff_isLittleO_nhds_zero, isLittleO_iff]
-  intro ε hε
-  have hBz : ∀ᶠ k in 𝓝 (0 : E),
-      ‖f (s₀, z₀ + k) - f (s₀, z₀) - Dz₀ k‖ ≤ (ε / 2) * ‖k‖ := by
-    have hz := hDz₀
-    rw [hasFDerivAt_iff_isLittleO_nhds_zero, isLittleO_iff] at hz
-    exact hz (half_pos hε)
-  have hBz' : ∀ᶠ p : ℝ × E in 𝓝 0,
-      ‖f (s₀, z₀ + p.2) - f (s₀, z₀) - Dz₀ p.2‖ ≤ (ε / 2) * ‖p.2‖ :=
-    (continuous_snd.tendsto (0 : ℝ × E)).eventually hBz
-  have hball : ∀ᶠ q in 𝓝 ((s₀, z₀) : ℝ × E), ‖Ds q - Ds₀‖ ≤ ε / 2 := by
-    have hc : Tendsto Ds (𝓝 (s₀, z₀)) (𝓝 Ds₀) := hDs_cont.continuousAt
-    have hsub : Tendsto (fun q => Ds q - Ds₀) (𝓝 (s₀, z₀)) (𝓝 (Ds₀ - Ds₀)) :=
-      hc.sub tendsto_const_nhds
-    rw [sub_self] at hsub
-    have h0 : Tendsto (fun q => ‖Ds q - Ds₀‖) (𝓝 (s₀, z₀)) (𝓝 0) := by
-      simpa using hsub.norm
-    exact h0.eventually (Iic_mem_nhds (half_pos hε))
-  obtain ⟨δ, hδpos, hδ⟩ := Metric.eventually_nhds_iff.mp hball
-  have hAs : ∀ᶠ p : ℝ × E in 𝓝 0,
-      ‖f (s₀ + p.1, z₀ + p.2) - f (s₀, z₀ + p.2) - p.1 • Ds₀‖ ≤ (ε / 2) * ‖p‖ := by
-    filter_upwards [Metric.ball_mem_nhds (0 : ℝ × E) hδpos] with p hp
-    rw [mem_ball_zero_iff] at hp
-    have hcont_u : Continuous (fun u => Ds (u, z₀ + p.2)) :=
-      hDs_cont.comp (continuous_id.prodMk continuous_const)
-    have hg_deriv : ∀ u : ℝ, HasDerivAt (fun s => f (s, z₀ + p.2)) (Ds (u, z₀ + p.2)) u :=
-      fun u => hDs (u, z₀ + p.2)
-    have hftc : ∫ u in s₀..(s₀ + p.1), Ds (u, z₀ + p.2)
-        = f (s₀ + p.1, z₀ + p.2) - f (s₀, z₀ + p.2) := by
-      rw [intervalIntegral.integral_eq_sub_of_hasDerivAt (fun u _ => hg_deriv u)
-        (hcont_u.intervalIntegrable _ _)]
-    have hbound_u : ∀ u ∈ Set.uIoc s₀ (s₀ + p.1), ‖Ds (u, z₀ + p.2) - Ds₀‖ ≤ ε / 2 := by
-      intro u hu
-      refine @hδ (u, z₀ + p.2) ?_
-      have hple : |p.1| ≤ ‖p‖ := by rw [← Real.norm_eq_abs]; exact norm_fst_le p
-      have hp1 : |u - s₀| ≤ ‖p‖ := by
-        rcases Set.mem_uIcc.mp (Set.uIoc_subset_uIcc hu) with ⟨ha, hb⟩ | ⟨ha, hb⟩
-        · rw [abs_of_nonneg (by linarith : (0 : ℝ) ≤ u - s₀)]
-          rw [abs_of_nonneg (by linarith : (0 : ℝ) ≤ p.1)] at hple; linarith
-        · rw [abs_of_nonpos (by linarith : u - s₀ ≤ 0)]
-          rw [abs_of_nonpos (by linarith : p.1 ≤ 0)] at hple; linarith
-      have hp2 : ‖p.2‖ ≤ ‖p‖ := norm_snd_le p
-      rw [Prod.dist_eq]
-      simp only [dist_eq_norm, add_sub_cancel_left, Real.norm_eq_abs]
-      exact lt_of_le_of_lt (max_le hp1 hp2) hp
-    have hA_eq : f (s₀ + p.1, z₀ + p.2) - f (s₀, z₀ + p.2) - p.1 • Ds₀
-        = ∫ u in s₀..(s₀ + p.1), (Ds (u, z₀ + p.2) - Ds₀) := by
-      rw [intervalIntegral.integral_sub (hcont_u.intervalIntegrable _ _)
-          (intervalIntegrable_const), hftc, intervalIntegral.integral_const,
-          add_sub_cancel_left]
-    rw [hA_eq]
-    calc ‖∫ u in s₀..(s₀ + p.1), (Ds (u, z₀ + p.2) - Ds₀)‖
-        ≤ (ε / 2) * |(s₀ + p.1) - s₀| :=
-          intervalIntegral.norm_integral_le_of_norm_le_const hbound_u
-      _ = (ε / 2) * ‖p.1‖ := by rw [add_sub_cancel_left, Real.norm_eq_abs]
-      _ ≤ (ε / 2) * ‖p‖ := mul_le_mul_of_nonneg_left (norm_fst_le p) (by positivity)
-  filter_upwards [hAs, hBz'] with p hAp hBp
-  have hdecomp :
-      f ((s₀, z₀) + p) - f (s₀, z₀)
-        - ((ContinuousLinearMap.fst ℝ ℝ E).smulRight Ds₀
-            + Dz₀.comp (ContinuousLinearMap.snd ℝ ℝ E)) p
-      = (f (s₀ + p.1, z₀ + p.2) - f (s₀, z₀ + p.2) - p.1 • Ds₀)
-        + (f (s₀, z₀ + p.2) - f (s₀, z₀) - Dz₀ p.2) := by
-    rw [show ((s₀, z₀) + p : ℝ × E) = (s₀ + p.1, z₀ + p.2) from rfl]
-    simp only [add_apply, ContinuousLinearMap.smulRight_apply,
-      ContinuousLinearMap.coe_fst', ContinuousLinearMap.comp_apply,
-      ContinuousLinearMap.coe_snd']
-    abel
-  rw [hdecomp]
-  calc ‖(f (s₀ + p.1, z₀ + p.2) - f (s₀, z₀ + p.2) - p.1 • Ds₀)
-          + (f (s₀, z₀ + p.2) - f (s₀, z₀) - Dz₀ p.2)‖
-      ≤ ‖f (s₀ + p.1, z₀ + p.2) - f (s₀, z₀ + p.2) - p.1 • Ds₀‖
-        + ‖f (s₀, z₀ + p.2) - f (s₀, z₀) - Dz₀ p.2‖ := norm_add_le _ _
-    _ ≤ (ε / 2) * ‖p‖ + (ε / 2) * ‖p‖ :=
-        add_le_add hAp (le_trans hBp (mul_le_mul_of_nonneg_left (norm_snd_le p) (by positivity)))
-    _ = ε * ‖p‖ := by ring
-
-/-- **Step 3 gating lemma (LOCAL / open-set form)** — joint `HasFDerivAt` from continuous partial
-derivatives on an open set `U ⊆ ℝ × E`.  The open-set generalisation of
-`hasFDerivAt_of_continuous_partials` (which is the `U := univ` special case) that the PR-note above
-flagged: the `s`-partial is required only on `U`, and `Ds` only `ContinuousOn U`.  This is the form
-the Vlasov flow needs — its partials exist and are continuous only on the open window
-`Ioo 0 T ×ˢ univ`.  Proof = the global proof + ball-in-`U` bookkeeping (`B((s₀,z₀),r) ⊆ U`; the FTC
-segment points `(u, z₀+p.2)`, `u ∈ uIcc s₀ (s₀+p.1)`, lie within `‖p‖ < min δ (r/2)` of `(s₀,z₀)`,
-hence in `U` and within the continuity radius `δ`).
-
-NOTE (consolidation TODO): the global `hasFDerivAt_of_continuous_partials` above is the `univ`
-special case of this; a follow-up cleanup should rewrite it as the one-line corollary
-`hasFDerivAt_of_continuous_partials_open isOpen_univ (Set.mem_univ _) (fun p _ => hDs p)
-hDs_cont.continuousOn hDz₀` to drop the duplicated proof.  **PR-ABLE** (the more
-general statement). -/
-theorem hasFDerivAt_of_continuous_partials_open
-    {E F : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
-    [NormedAddCommGroup F] [NormedSpace ℝ F] [CompleteSpace F]
-    {f : ℝ × E → F} {Ds : ℝ × E → F} {Dz₀ : E →L[ℝ] F}
-    {U : Set (ℝ × E)} (hU : IsOpen U) {s₀ : ℝ} {z₀ : E} (hmem : (s₀, z₀) ∈ U)
-    (hDs : ∀ p ∈ U, HasDerivAt (fun s => f (s, p.2)) (Ds p) p.1)
-    (hDs_cont : ContinuousOn Ds U)
-    (hDz₀ : HasFDerivAt (fun z => f (s₀, z)) Dz₀ z₀) :
-    HasFDerivAt f
-      ((ContinuousLinearMap.fst ℝ ℝ E).smulRight (Ds (s₀, z₀))
-        + Dz₀.comp (ContinuousLinearMap.snd ℝ ℝ E)) (s₀, z₀) := by
-  set Ds₀ : F := Ds (s₀, z₀) with hDs₀
-  obtain ⟨r, hrpos, hrU⟩ := Metric.isOpen_iff.mp hU (s₀, z₀) hmem
-  rw [hasFDerivAt_iff_isLittleO_nhds_zero, isLittleO_iff]
-  intro ε hε
-  have hBz : ∀ᶠ k in 𝓝 (0 : E),
-      ‖f (s₀, z₀ + k) - f (s₀, z₀) - Dz₀ k‖ ≤ (ε / 2) * ‖k‖ := by
-    have hz := hDz₀
-    rw [hasFDerivAt_iff_isLittleO_nhds_zero, isLittleO_iff] at hz
-    exact hz (half_pos hε)
-  have hBz' : ∀ᶠ p : ℝ × E in 𝓝 0,
-      ‖f (s₀, z₀ + p.2) - f (s₀, z₀) - Dz₀ p.2‖ ≤ (ε / 2) * ‖p.2‖ :=
-    (continuous_snd.tendsto (0 : ℝ × E)).eventually hBz
-  have hball : ∀ᶠ q in 𝓝 ((s₀, z₀) : ℝ × E), ‖Ds q - Ds₀‖ ≤ ε / 2 := by
-    have hc : Tendsto Ds (𝓝 (s₀, z₀)) (𝓝 Ds₀) := hDs_cont.continuousAt (hU.mem_nhds hmem)
-    have hsub : Tendsto (fun q => Ds q - Ds₀) (𝓝 (s₀, z₀)) (𝓝 (Ds₀ - Ds₀)) :=
-      hc.sub tendsto_const_nhds
-    rw [sub_self] at hsub
-    have h0 : Tendsto (fun q => ‖Ds q - Ds₀‖) (𝓝 (s₀, z₀)) (𝓝 0) := by
-      simpa using hsub.norm
-    exact h0.eventually (Iic_mem_nhds (half_pos hε))
-  obtain ⟨δ, hδpos, hδ⟩ := Metric.eventually_nhds_iff.mp hball
-  set ρr : ℝ := min δ (r / 2) with hρr
-  have hρrpos : 0 < ρr := lt_min hδpos (by positivity)
-  have hAs : ∀ᶠ p : ℝ × E in 𝓝 0,
-      ‖f (s₀ + p.1, z₀ + p.2) - f (s₀, z₀ + p.2) - p.1 • Ds₀‖ ≤ (ε / 2) * ‖p‖ := by
-    filter_upwards [Metric.ball_mem_nhds (0 : ℝ × E) hρrpos] with p hp
-    rw [mem_ball_zero_iff] at hp
-    have hdist : ∀ u ∈ Set.uIcc s₀ (s₀ + p.1),
-        dist ((u, z₀ + p.2) : ℝ × E) (s₀, z₀) ≤ ‖p‖ := by
-      intro u hu
-      have hple : |p.1| ≤ ‖p‖ := by rw [← Real.norm_eq_abs]; exact norm_fst_le p
-      have hp1 : |u - s₀| ≤ ‖p‖ := by
-        rcases Set.mem_uIcc.mp hu with ⟨ha, hb⟩ | ⟨ha, hb⟩
-        · rw [abs_of_nonneg (by linarith : (0 : ℝ) ≤ u - s₀)]
-          rw [abs_of_nonneg (by linarith : (0 : ℝ) ≤ p.1)] at hple; linarith
-        · rw [abs_of_nonpos (by linarith : u - s₀ ≤ 0)]
-          rw [abs_of_nonpos (by linarith : p.1 ≤ 0)] at hple; linarith
-      have hp2 : ‖p.2‖ ≤ ‖p‖ := norm_snd_le p
-      rw [Prod.dist_eq]
-      refine max_le ?_ ?_
-      · rw [dist_eq_norm]; simpa [Real.norm_eq_abs] using hp1
-      · rw [dist_eq_norm, add_sub_cancel_left]; exact hp2
-    have hmemU : ∀ u ∈ Set.uIcc s₀ (s₀ + p.1), ((u, z₀ + p.2) : ℝ × E) ∈ U := by
-      intro u hu
-      apply hrU
-      rw [Metric.mem_ball]
-      exact lt_of_le_of_lt (hdist u hu)
-        (lt_of_lt_of_le hp (le_trans (min_le_right _ _) (by linarith)))
-    have hcont_u : ContinuousOn (fun u => Ds (u, z₀ + p.2)) (Set.uIcc s₀ (s₀ + p.1)) := by
-      refine hDs_cont.comp (continuous_id.prodMk continuous_const).continuousOn ?_
-      exact fun u hu => hmemU u hu
-    have hg_deriv : ∀ u ∈ Set.uIcc s₀ (s₀ + p.1),
-        HasDerivAt (fun s => f (s, z₀ + p.2)) (Ds (u, z₀ + p.2)) u :=
-      fun u hu => hDs (u, z₀ + p.2) (hmemU u hu)
-    have hftc : ∫ u in s₀..(s₀ + p.1), Ds (u, z₀ + p.2)
-        = f (s₀ + p.1, z₀ + p.2) - f (s₀, z₀ + p.2) := by
-      rw [intervalIntegral.integral_eq_sub_of_hasDerivAt (fun u hu => hg_deriv u hu)
-        (hcont_u.intervalIntegrable)]
-    have hbound_u : ∀ u ∈ Set.uIoc s₀ (s₀ + p.1), ‖Ds (u, z₀ + p.2) - Ds₀‖ ≤ ε / 2 := by
-      intro u hu
-      refine @hδ (u, z₀ + p.2) ?_
-      have hmem' := hdist u (Set.uIoc_subset_uIcc hu)
-      exact lt_of_le_of_lt hmem' (lt_of_lt_of_le hp (min_le_left _ _))
-    have hA_eq : f (s₀ + p.1, z₀ + p.2) - f (s₀, z₀ + p.2) - p.1 • Ds₀
-        = ∫ u in s₀..(s₀ + p.1), (Ds (u, z₀ + p.2) - Ds₀) := by
-      rw [intervalIntegral.integral_sub (hcont_u.intervalIntegrable)
-          (intervalIntegrable_const), hftc, intervalIntegral.integral_const,
-          add_sub_cancel_left]
-    rw [hA_eq]
-    calc ‖∫ u in s₀..(s₀ + p.1), (Ds (u, z₀ + p.2) - Ds₀)‖
-        ≤ (ε / 2) * |(s₀ + p.1) - s₀| :=
-          intervalIntegral.norm_integral_le_of_norm_le_const hbound_u
-      _ = (ε / 2) * ‖p.1‖ := by rw [add_sub_cancel_left, Real.norm_eq_abs]
-      _ ≤ (ε / 2) * ‖p‖ := mul_le_mul_of_nonneg_left (norm_fst_le p) (by positivity)
-  filter_upwards [hAs, hBz'] with p hAp hBp
-  have hdecomp :
-      f ((s₀, z₀) + p) - f (s₀, z₀)
-        - ((ContinuousLinearMap.fst ℝ ℝ E).smulRight Ds₀
-            + Dz₀.comp (ContinuousLinearMap.snd ℝ ℝ E)) p
-      = (f (s₀ + p.1, z₀ + p.2) - f (s₀, z₀ + p.2) - p.1 • Ds₀)
-        + (f (s₀, z₀ + p.2) - f (s₀, z₀) - Dz₀ p.2) := by
-    rw [show ((s₀, z₀) + p : ℝ × E) = (s₀ + p.1, z₀ + p.2) from rfl]
-    simp only [add_apply, ContinuousLinearMap.smulRight_apply,
-      ContinuousLinearMap.coe_fst', ContinuousLinearMap.comp_apply,
-      ContinuousLinearMap.coe_snd']
-    abel
-  rw [hdecomp]
-  calc ‖(f (s₀ + p.1, z₀ + p.2) - f (s₀, z₀ + p.2) - p.1 • Ds₀)
-          + (f (s₀, z₀ + p.2) - f (s₀, z₀) - Dz₀ p.2)‖
-      ≤ ‖f (s₀ + p.1, z₀ + p.2) - f (s₀, z₀ + p.2) - p.1 • Ds₀‖
-        + ‖f (s₀, z₀ + p.2) - f (s₀, z₀) - Dz₀ p.2‖ := norm_add_le _ _
-    _ ≤ (ε / 2) * ‖p‖ + (ε / 2) * ‖p‖ :=
-        add_le_add hAp (le_trans hBp (mul_le_mul_of_nonneg_left (norm_snd_le p) (by positivity)))
-    _ = ε * ‖p‖ := by ring
-
-end Step3Joint
-
-omit [NeZero d] in
-/-- **Step 3 — the forward flow `(s,z) ↦ Φ_s z` is jointly continuous** on `Icc 0 T ×ˢ univ`
-(`(s,z)`-order).  Gronwall Lipschitz-in-`z` (uniform over `[0,T]`) + per-`z` continuity-in-`s`, via
-the generic `continuousOn_prod_of_lipschitz_continuousOn`, then a prod-order swap.  Extracted from
-`#3`'s V2-branch pattern so the joint `C¹`-ness (Step 3 (iii)) can reuse it directly. -/
-lemma charFlow_continuousOn_joint
-    (gradW : PhysSpace d → PhysSpace d) (L : NNReal) (hL : LipschitzWith L gradW)
-    (ρ : ℝ → Measure (PhysSpace d)) [∀ s, IsProbabilityMeasure (ρ s)]
-    (h_int : ∀ s (x : PhysSpace d), Integrable (fun y => gradW (x - y)) (ρ s))
-    (charX charV : ℝ → PhaseSpace d → PhysSpace d) (T : ℝ) (hT : 0 ≤ T)
-    (hinit : ∀ z : PhaseSpace d, (charX 0 z, charV 0 z) = z)
-    (hcontIcc : ∀ z, ContinuousOn (fun s => (charX s z, charV s z)) (Set.Icc (0 : ℝ) T))
-    (hderiv : ∀ z, ∀ s ∈ Set.Ioo (0 : ℝ) T,
-      HasDerivWithinAt (fun s => (charX s z, charV s z))
-        (vlasovVectorField gradW ρ s (charX s z, charV s z)) (Set.Ici s) s) :
-    ContinuousOn (fun p : ℝ × PhaseSpace d => (charX p.1 p.2, charV p.1 p.2))
-      (Set.Icc (0 : ℝ) T ×ˢ Set.univ) := by
-  have hgron := charFlow_lipschitzInZ_via_gronwall_Ioo gradW L hL ρ h_int charX charV T hT
-    hinit hcontIcc hderiv
-  have hjoint_zs : ContinuousOn (fun p : PhaseSpace d × ℝ => (charX p.2 p.1, charV p.2 p.1))
-      (Set.univ ×ˢ Set.Icc (0 : ℝ) T) := by
-    refine continuousOn_prod_of_lipschitz_continuousOn (fun z s => (charX s z, charV s z)) T
-      (Real.exp (((max 1 L : NNReal) : ℝ) * T)) (fun s hs z₁ z₂ => ?_) hcontIcc
-    calc dist ((charX s z₁, charV s z₁) : PhaseSpace d) (charX s z₂, charV s z₂)
-        ≤ dist z₁ z₂ * Real.exp (((max 1 L : NNReal) : ℝ) * (s - 0)) := hgron s hs z₁ z₂
-      _ = Real.exp (((max 1 L : NNReal) : ℝ) * (s - 0)) * dist z₁ z₂ := by ring
-      _ ≤ Real.exp (((max 1 L : NNReal) : ℝ) * T) * dist z₁ z₂ := by
-          refine mul_le_mul_of_nonneg_right (Real.exp_le_exp.mpr ?_) dist_nonneg
-          have hsT : s - 0 ≤ T := by simp only [sub_zero]; exact hs.2
-          exact mul_le_mul_of_nonneg_left hsT (by positivity)
-  have hswap : ContinuousOn (fun p : ℝ × PhaseSpace d => ((p.2, p.1) : PhaseSpace d × ℝ))
-      (Set.Icc (0 : ℝ) T ×ˢ Set.univ) := (continuous_snd.prodMk continuous_fst).continuousOn
-  have hmaps : Set.MapsTo (fun p : ℝ × PhaseSpace d => ((p.2, p.1) : PhaseSpace d × ℝ))
-      (Set.Icc (0 : ℝ) T ×ˢ Set.univ) (Set.univ ×ˢ Set.Icc (0 : ℝ) T) :=
-    fun p hp => ⟨Set.mem_univ _, hp.1⟩
-  exact hjoint_zs.comp hswap hmaps
-
-omit [NeZero d] in
-/-- **Step 3 (ii) — the field along the flow `(s,z) ↦ b_s(Φ_s z)` is jointly continuous** on
-`Icc 0 T ×ˢ univ`.  First component `charV` from flow joint continuity; second component
-`-(∇W ∗ ρ_s)(charX s z)` from `(s,x) ↦ (∇W∗ρ_s)(x)` jointly continuous (equi-Lipschitz-in-`x` from
-`convolveFunctionMeasure_lipschitz_in_x` + continuous-in-`s` from `hf_cont`) composed with the flow.
-This is the partial-`s`-derivative continuity input to the joint `C¹`-ness (Step 3 (iii)). -/
-lemma vlasovField_along_flow_continuousOn
-    (gradW : PhysSpace d → PhysSpace d) (L : NNReal) (hL : LipschitzWith L gradW)
-    (ρ : ℝ → Measure (PhysSpace d)) [∀ s, IsProbabilityMeasure (ρ s)]
-    (h_int : ∀ s (x : PhysSpace d), Integrable (fun y => gradW (x - y)) (ρ s))
-    (hf_cont : ∀ x, Continuous (fun s => convolveFunctionMeasure gradW (ρ s) x))
-    (charX charV : ℝ → PhaseSpace d → PhysSpace d) (T : ℝ)
-    (hflowjoint : ContinuousOn (fun p : ℝ × PhaseSpace d => (charX p.1 p.2, charV p.1 p.2))
-      (Set.Icc (0 : ℝ) T ×ˢ Set.univ)) :
-    ContinuousOn (fun p : ℝ × PhaseSpace d =>
-        vlasovVectorField gradW ρ p.1 (charX p.1 p.2, charV p.1 p.2))
-      (Set.Icc (0 : ℝ) T ×ˢ Set.univ) := by
-  have hcomp1 : ContinuousOn (fun p : ℝ × PhaseSpace d => charV p.1 p.2)
-      (Set.Icc (0 : ℝ) T ×ˢ Set.univ) := continuous_snd.comp_continuousOn hflowjoint
-  have hcharX : ContinuousOn (fun p : ℝ × PhaseSpace d => charX p.1 p.2)
-      (Set.Icc (0 : ℝ) T ×ˢ Set.univ) := continuous_fst.comp_continuousOn hflowjoint
-  have hconv_joint : ContinuousOn
-      (fun p : PhysSpace d × ℝ => convolveFunctionMeasure gradW (ρ p.2) p.1)
-      (Set.univ ×ˢ Set.Icc (0 : ℝ) T) :=
-    continuousOn_prod_of_lipschitz_continuousOn
-      (fun (x : PhysSpace d) (s : ℝ) => convolveFunctionMeasure gradW (ρ s) x) T (L:ℝ)
-      (fun s _ x₁ x₂ =>
-        (convolveFunctionMeasure_lipschitz_in_x gradW L hL (ρ s) (h_int s)).dist_le_mul x₁ x₂)
-      (fun x => (hf_cont x).continuousOn)
-  have hg2 : ContinuousOn (fun p : ℝ × PhaseSpace d => ((charX p.1 p.2, p.1) : PhysSpace d × ℝ))
-      (Set.Icc (0 : ℝ) T ×ˢ Set.univ) := hcharX.prodMk continuousOn_fst
-  have hg2maps : Set.MapsTo (fun p : ℝ × PhaseSpace d => ((charX p.1 p.2, p.1) : PhysSpace d × ℝ))
-      (Set.Icc (0 : ℝ) T ×ˢ Set.univ) (Set.univ ×ˢ Set.Icc (0 : ℝ) T) :=
-    fun p hp => ⟨Set.mem_univ _, hp.1⟩
-  have hconv_along : ContinuousOn
-      (fun p : ℝ × PhaseSpace d => convolveFunctionMeasure gradW (ρ p.1) (charX p.1 p.2))
-      (Set.Icc (0 : ℝ) T ×ˢ Set.univ) := hconv_joint.comp hg2 hg2maps
-  have heq : (fun p : ℝ × PhaseSpace d =>
-        vlasovVectorField gradW ρ p.1 (charX p.1 p.2, charV p.1 p.2))
-      = fun p => ((charV p.1 p.2),
-          -(convolveFunctionMeasure gradW (ρ p.1) (charX p.1 p.2))) := by
-    funext p; rfl
-  rw [heq]
-  exact hcomp1.prodMk hconv_along.neg
-
-omit [NeZero d] in
-/-- **Step 3 (iii) — the forward flow `(s,z) ↦ Φ_s z` is jointly `C¹`** on `U := Ioo 0 T ×ˢ univ`:
-Fréchet-differentiable at every point with a jointly-continuous total derivative `DΦ`.  Built by
-composing the open-set gating theorem (`hasFDerivAt_of_continuous_partials_open`) — fed the
-`s`-partial `b_s(Φ_s z)` (flow ODE, jointly continuous by item (ii)) and the `z`-partial `M_s z`
-(the fundamental matrix, via D1c, jointly continuous by item (i)).  Per L14 the matrix is rebuilt
-concretely (`fundamentalMatrix (A z) s`), NOT routed through `#3`'s existential.
-
-The field `bfun` and matrix `Mfun` are made opaque locals (`clear_value`, the D1c lesson) so the
-gating unification stays syntactic and never unfolds the `vlasovVectorField`/`vlasovFieldJacobian`
-integrals — the per-point derivative facts are established in terms of them *before* clearing.
-`A` is kept transparent through the D1c call (whose coefficient is
-`vlasovFieldJacobian`) and cleared
-only afterwards (before the projection-reduction defeqs).  No `maxHeartbeats` bump needed. -/
-theorem charFlow_hasFDerivAt_joint
-    (gradW : PhysSpace d → PhysSpace d) (hgradW_C1 : ContDiff ℝ 1 gradW)
-    (L : NNReal) (hL : LipschitzWith L gradW)
-    (ρ : ℝ → Measure (PhysSpace d)) [∀ s, IsProbabilityMeasure (ρ s)]
-    (charX charV : ℝ → PhaseSpace d → PhysSpace d)
-    (T : ℝ) (hT : 0 < T)
-    (hflow : IsCharacteristicFlowOn gradW ρ charX charV (Set.Ioo 0 T) Set.univ)
-    (h_int : ∀ s (x : PhysSpace d), Integrable (fun y => gradW (x - y)) (ρ s))
-    (hf_cont : ∀ x, Continuous (fun s => convolveFunctionMeasure gradW (ρ s) x))
-    (hρD_cont : ContinuousOn
-      (fun p : ℝ × PhysSpace d => ∫ y, fderiv ℝ gradW (p.2 - y) ∂(ρ p.1))
-      (Set.Icc 0 T ×ˢ (Set.univ : Set (PhysSpace d))))
-    (hcontIcc : ∀ z : PhaseSpace d,
-      ContinuousOn (fun s => (charX s z, charV s z)) (Set.Icc (0 : ℝ) T)) :
-    ∃ DΦ : ℝ × PhaseSpace d → (ℝ × PhaseSpace d →L[ℝ] PhaseSpace d),
-      (∀ p ∈ Set.Ioo (0 : ℝ) T ×ˢ (Set.univ : Set (PhaseSpace d)),
-        HasFDerivAt (fun q : ℝ × PhaseSpace d => (charX q.1 q.2, charV q.1 q.2)) (DΦ p) p) ∧
-      ContinuousOn DΦ (Set.Ioo (0 : ℝ) T ×ˢ Set.univ) := by
-  set A : PhaseSpace d → ℝ → (PhaseSpace d →L[ℝ] PhaseSpace d) :=
-    fun z s => vlasovFieldJacobian gradW ρ (s, (charX s z, charV s z)) with hA_def
-  have hAcont : ∀ z, ContinuousOn (A z) (Set.Icc 0 T) := fun z =>
-    vlasovVariationalCoeff_continuousOn gradW ρ charX charV T z (hcontIcc z) hρD_cont
-  have h_init : ∀ z : PhaseSpace d, (charX 0 z, charV 0 z) = z := fun z =>
-    Prod.ext_iff.mpr ⟨(hflow.1 z (Set.mem_univ z)).1, (hflow.1 z (Set.mem_univ z)).2⟩
-  have h_deriv : ∀ z, ∀ s ∈ Set.Ioo (0 : ℝ) T,
-      HasDerivWithinAt (fun s => (charX s z, charV s z))
-        (vlasovVectorField gradW ρ s (charX s z, charV s z)) (Set.Ici s) s := fun z s hs =>
-    (HasDerivAt.prodMk (hflow.2.1 s hs z (Set.mem_univ z))
-      (hflow.2.2 s hs z (Set.mem_univ z))).hasDerivWithinAt
-  have hflowjoint_sz : ContinuousOn (fun q : ℝ × PhaseSpace d => (charX q.1 q.2, charV q.1 q.2))
-      (Set.Icc 0 T ×ˢ Set.univ) :=
-    charFlow_continuousOn_joint gradW L hL ρ h_int charX charV T hT.le h_init hcontIcc h_deriv
-  -- field as an opaque local
-  set bfun : ℝ × PhaseSpace d → PhaseSpace d :=
-    fun q => vlasovVectorField gradW ρ q.1 (charX q.1 q.2, charV q.1 q.2) with hbfun_def
-  have hb_cont : ContinuousOn bfun (Set.Icc 0 T ×ˢ Set.univ) :=
-    vlasovField_along_flow_continuousOn gradW L hL ρ h_int hf_cont charX charV T hflowjoint_sz
-  -- `A` jointly continuous + bounded ⇒ `M` jointly continuous (item (i))
-  have hflowjoint_zs : ContinuousOn (fun p : PhaseSpace d × ℝ => (charX p.2 p.1, charV p.2 p.1))
-      (Set.univ ×ˢ Set.Icc 0 T) := by
-    have hswap : ContinuousOn (fun p : PhaseSpace d × ℝ => ((p.2, p.1) : ℝ × PhaseSpace d))
-        (Set.univ ×ˢ Set.Icc 0 T) := (continuous_snd.prodMk continuous_fst).continuousOn
-    have hmaps : Set.MapsTo (fun p : PhaseSpace d × ℝ => ((p.2, p.1) : ℝ × PhaseSpace d))
-        (Set.univ ×ˢ Set.Icc 0 T) (Set.Icc 0 T ×ˢ Set.univ) := fun p hp => ⟨hp.2, Set.mem_univ _⟩
-    exact hflowjoint_sz.comp hswap hmaps
-  have hg : ContinuousOn
-      (fun p : PhaseSpace d × ℝ => ((p.2, (charX p.2 p.1, charV p.2 p.1)) : ℝ × PhaseSpace d))
-      (Set.univ ×ˢ Set.Icc 0 T) := continuousOn_snd.prodMk hflowjoint_zs
-  have hmapsg : Set.MapsTo
-      (fun p : PhaseSpace d × ℝ => ((p.2, (charX p.2 p.1, charV p.2 p.1)) : ℝ × PhaseSpace d))
-      (Set.univ ×ˢ Set.Icc 0 T) (Set.Icc 0 T ×ˢ Set.univ) := fun p hp => ⟨hp.2, Set.mem_univ _⟩
-  have hA_contOn : ContinuousOn (fun p : PhaseSpace d × ℝ => A p.1 p.2) (Set.univ ×ˢ Set.Icc 0 T) :=
-    (vlasovFieldJacobian_continuousOn gradW ρ T hρD_cont).comp hg hmapsg
-  have hA_bound : ∀ z, ∀ s ∈ Set.Icc (0 : ℝ) T, ‖A z s‖ ≤ ((max 1 L : NNReal) : ℝ) := by
-    intro z s _
-    have heq : A z s = fderiv ℝ (vlasovVectorField gradW ρ s) (charX s z, charV s z) := by
-      simp only [hA_def]
-      exact (vlasovVectorField_hasFDerivAt_in_z gradW hgradW_C1 L hL ρ h_int s
-        (charX s z, charV s z)).fderiv.symm
-    rw [heq]
-    exact norm_fderiv_le_of_lipschitz ℝ (vlasovVectorField_lipschitzWith gradW L hL ρ h_int s)
-  have hM_zs : ContinuousOn (fun p : PhaseSpace d × ℝ => fundamentalMatrix (A p.1) p.2)
-      (Set.univ ×ˢ Set.Icc 0 T) :=
-    fundamentalMatrix_continuous_param_joint A T hT.le ((max 1 L : NNReal) : ℝ) (by positivity)
-      hA_contOn hA_bound
-  have hU_open : IsOpen (Set.Ioo (0 : ℝ) T ×ˢ (Set.univ : Set (PhaseSpace d))) :=
-    isOpen_Ioo.prod isOpen_univ
-  have hU_sub : Set.Ioo (0 : ℝ) T ×ˢ (Set.univ : Set (PhaseSpace d)) ⊆ Set.Icc 0 T ×ˢ Set.univ :=
-    Set.prod_mono Set.Ioo_subset_Icc_self (subset_refl _)
-  -- matrix as a local (kept transparent for the D1c call, which needs `A`'s coefficient)
-  set Mfun : ℝ × PhaseSpace d → (PhaseSpace d →L[ℝ] PhaseSpace d) :=
-    fun p => fundamentalMatrix (A p.2) p.1 with hMfun_def
-  -- z-partial at base via D1c — needs `A` TRANSPARENT (its coefficient is `vlasovFieldJacobian`).
-  have hDz_all : ∀ s₀ ∈ Set.Ioo (0 : ℝ) T, ∀ z₀ : PhaseSpace d,
-      HasFDerivAt (fun z => (charX s₀ z, charV s₀ z)) (Mfun (s₀, z₀)) z₀ := by
-    intro s₀ hs₀ z₀
-    obtain ⟨h0, hMcont, hMderiv⟩ := fundamentalMatrix_spec (A z₀) T hT.le (hAcont z₀)
-    exact charFlow_hasFDerivAt_of_fundamentalMatrix gradW hgradW_C1 L hL ρ charX charV T hT hflow
-      h_int hρD_cont z₀ hcontIcc (fundamentalMatrix (A z₀)) h0 hMcont hMderiv s₀ hs₀
-  have hDs_all : ∀ p ∈ Set.Ioo (0 : ℝ) T ×ˢ (Set.univ : Set (PhaseSpace d)),
-      HasDerivAt (fun s => ((charX s p.2, charV s p.2) : PhaseSpace d)) (bfun p) p.1 := by
-    intro p hp'
-    exact HasDerivAt.prodMk (hflow.2.1 p.1 hp'.1 p.2 (Set.mem_univ _))
-      (hflow.2.2 p.1 hp'.1 p.2 (Set.mem_univ _))
-  -- NOW make `A`/field/matrix opaque so the projection-reduction defeqs below never unfold the
-  -- heavy `vlasovFieldJacobian`/`vlasovVectorField` integrals (D1c lesson).
-  clear_value A bfun Mfun
-  have hM_sz : ContinuousOn Mfun (Set.Ioo (0 : ℝ) T ×ˢ Set.univ) := by
-    rw [hMfun_def]
-    have hswap : ContinuousOn (fun p : ℝ × PhaseSpace d => ((p.2, p.1) : PhaseSpace d × ℝ))
-        (Set.Ioo (0 : ℝ) T ×ˢ Set.univ) := (continuous_snd.prodMk continuous_fst).continuousOn
-    have hmaps : Set.MapsTo (fun p : ℝ × PhaseSpace d => ((p.2, p.1) : PhaseSpace d × ℝ))
-        (Set.Ioo (0 : ℝ) T ×ˢ Set.univ) (Set.univ ×ˢ Set.Icc 0 T) :=
-      fun p hp => ⟨Set.mem_univ _, Set.Ioo_subset_Icc_self hp.1⟩
-    exact hM_zs.comp hswap hmaps
-  refine ⟨fun p => (ContinuousLinearMap.fst ℝ ℝ (PhaseSpace d)).smulRight (bfun p)
-      + (Mfun p).comp (ContinuousLinearMap.snd ℝ ℝ (PhaseSpace d)), ?_, ?_⟩
-  · rintro ⟨s₀, z₀⟩ hp
-    obtain ⟨hs₀, _⟩ := hp
-    exact hasFDerivAt_of_continuous_partials_open
-      (f := fun q : ℝ × PhaseSpace d => (charX q.1 q.2, charV q.1 q.2)) (Ds := bfun)
-      hU_open ⟨hs₀, Set.mem_univ _⟩ hDs_all (hb_cont.mono hU_sub) (hDz_all s₀ hs₀ z₀)
-  · have hT1 : ContinuousOn (fun p : ℝ × PhaseSpace d =>
-        (ContinuousLinearMap.fst ℝ ℝ (PhaseSpace d)).smulRight (bfun p))
-        (Set.Ioo (0 : ℝ) T ×ˢ Set.univ) := by
-      have hc : Continuous (fun v : PhaseSpace d =>
-          (ContinuousLinearMap.fst ℝ ℝ (PhaseSpace d)).smulRight v) :=
-        (ContinuousLinearMap.smulRightL ℝ (ℝ × PhaseSpace d) (PhaseSpace d)
-          (ContinuousLinearMap.fst ℝ ℝ (PhaseSpace d))).continuous
-      exact hc.comp_continuousOn (hb_cont.mono hU_sub)
-    have hT2 : ContinuousOn (fun p : ℝ × PhaseSpace d =>
-        (Mfun p).comp (ContinuousLinearMap.snd ℝ ℝ (PhaseSpace d)))
-        (Set.Ioo (0 : ℝ) T ×ˢ Set.univ) := hM_sz.clm_comp continuousOn_const
-    exact hT1.add hT2
-
-omit [NeZero d] in
-/-- **Step 3 (iv-A) — the forward flow `(s,z) ↦ Φ_s z` is `ContDiffAt ℝ 1`** at each point of the
-open window (the chart-IFT input for item (iv)).  Lifts item (iii)'s `HasFDerivAt`-everywhere +
-`ContinuousOn`-derivative to `ContDiffAt` via `contDiffAt_succ_iff_hasFDerivAt`. -/
-lemma charFlow_contDiffAt_joint
-    (gradW : PhysSpace d → PhysSpace d) (hgradW_C1 : ContDiff ℝ 1 gradW)
-    (L : NNReal) (hL : LipschitzWith L gradW)
-    (ρ : ℝ → Measure (PhysSpace d)) [∀ s, IsProbabilityMeasure (ρ s)]
-    (charX charV : ℝ → PhaseSpace d → PhysSpace d)
-    (T : ℝ) (hT : 0 < T)
-    (hflow : IsCharacteristicFlowOn gradW ρ charX charV (Set.Ioo 0 T) Set.univ)
-    (h_int : ∀ s (x : PhysSpace d), Integrable (fun y => gradW (x - y)) (ρ s))
-    (hf_cont : ∀ x, Continuous (fun s => convolveFunctionMeasure gradW (ρ s) x))
-    (hρD_cont : ContinuousOn
-      (fun p : ℝ × PhysSpace d => ∫ y, fderiv ℝ gradW (p.2 - y) ∂(ρ p.1))
-      (Set.Icc 0 T ×ˢ (Set.univ : Set (PhysSpace d))))
-    (hcontIcc : ∀ z : PhaseSpace d,
-      ContinuousOn (fun s => (charX s z, charV s z)) (Set.Icc (0 : ℝ) T)) :
-    ∀ p ∈ Set.Ioo (0 : ℝ) T ×ˢ (Set.univ : Set (PhaseSpace d)),
-      ContDiffAt ℝ 1 (fun q : ℝ × PhaseSpace d => (charX q.1 q.2, charV q.1 q.2)) p := by
-  obtain ⟨DΦ, hFDeriv, hDΦ_cont⟩ :=
-    charFlow_hasFDerivAt_joint gradW hgradW_C1 L hL ρ charX charV T hT
-    hflow h_int hf_cont hρD_cont hcontIcc
-  have hU_open : IsOpen (Set.Ioo (0 : ℝ) T ×ˢ (Set.univ : Set (PhaseSpace d))) :=
-    isOpen_Ioo.prod isOpen_univ
-  intro p hp
-  have hmain : ContDiffAt ℝ ((0:ℕ) + 1)
-      (fun q : ℝ × PhaseSpace d => (charX q.1 q.2, charV q.1 q.2)) p := by
-    rw [contDiffAt_succ_iff_hasFDerivAt]
-    refine ⟨DΦ, ⟨Set.Ioo (0 : ℝ) T ×ˢ Set.univ, hU_open.mem_nhds hp, fun y hy => hFDeriv y hy⟩, ?_⟩
-    exact contDiffAt_zero.mpr ⟨Set.Ioo (0 : ℝ) T ×ˢ Set.univ, hU_open.mem_nhds hp, hDΦ_cont⟩
-  simpa using hmain
-
-open Filter Topology in
-omit [NeZero d] in
-/-- **Step 3 (iv) — the per-slice inverse `Ψ_s := Φ_s⁻¹` is jointly `C¹`** on `Ioo 0 T ×ˢ univ`,
-the keystone of the two-time flow `Φ_{s→t} = Φ_t ∘ Φ_s⁻¹`.
-
-**PROVEN (axiom-clean)** via the space-time chart inverse-function theorem — see the proof plan
-below, realized exactly as scouted: `charFlow_contDiffAt_joint` (iv-A) for the chart `ContDiffAt`,
-the block-triangular `≃L` (invertibility from Step 2's `e z₀` via `HasFDerivAt.unique` +
-`ofBijective`), `ContDiffAt.to_localInverse`, and the global patch via `localInverse_unique` (the
-global per-slice inverse is a local left inverse of the chart, by injectivity on the window).
-
-Per slice `s ∈ Ioo 0 T`, Step 2 (`exists_charFlow_inverse_On`) already gives the inverse `Ψ_s` and
-its invertible derivative family `e` (`= M_s z`, `#3`/D1c); here we upgrade to JOINT `(s,w)`
-regularity via the space-time chart.
-
-**Proof plan (atoms scouted + verified, 2026-06-16):**
-1. **Forward chart `Ξ : (s,z) ↦ (s, Φ_s z)` is `ContDiffAt ℝ 1` at each
-   `(s₀,z₀) ∈ Ioo 0 T ×ˢ univ`.**
-   `Φ := (charX·, charV·)` is jointly `C¹` (`charFlow_hasFDerivAt_joint`, item (iii) — `∃ DΦ`,
-   `HasFDerivAt`-everywhere + `ContinuousOn DΦ`); lift to `ContDiffAt ℝ 1 Φ` via
-   `contDiffAt_succ_iff_hasFDerivAt` (`Mathlib/.../ContDiff/Defs.lean:994`, `n := 0`: feed `DΦ`, the
-   open nbhd `U ∈ 𝓝`, `HasFDerivAt`-on-`U`, and `ContDiffAt 0 DΦ` from `contDiffAt_zero` +
-   `ContinuousOn DΦ U`).  `Ξ = (fst, Φ)` so `ContDiffAt ℝ 1 Ξ` via `ContDiffAt.prod` with
-   `contDiffAt_fst`.
-2. **`DΞ(s₀,z₀)` is an invertible `≃L`.**  Block-lower-triangular `(h,k) ↦ (h, h•b + M·k)` with
-   `b := b_{s₀}(Φ_{s₀}z₀)`, `M := M_{s₀}z₀` invertible (Step 2's `e₀ z₀`).  Build the `ℝ×E ≃L ℝ×E`
-   via `ContinuousLinearEquiv.ofBijective` (inject: `(h,k)↦0 ⇒ h=0`, then `M k=0 ⇒ k=0`; finite-dim
-   `LinearMap.injective_iff_surjective`).  `HasStrictFDerivAt Ξ (this ≃L) (s₀,z₀)` via
-   `ContDiffAt.hasStrictFDerivAt'`.
-3. **Local `C¹` inverse + patch.**  `ContDiffAt.to_localInverse`
-   (`Mathlib/.../InverseFunctionTheorem/ContDiff.lean:66`) ⇒ `Ξ.localInverse` is `ContDiffAt ℝ 1` at
-   `Ξ(s₀,z₀) = (s₀, Φ_{s₀}z₀)`.  The global `(s,w)↦(s, Ψ_s w)` agrees with
-   `Ξ.localInverse` on a nbhd
-   (both left-inverses; `Ξ` injective on `Ioo 0 T ×ˢ univ` since `s` is preserved + each `Φ_s`
-   injective per Step 2) ⇒ `ContDiffAt.congr` ⇒ `(s,w)↦(s,Ψ_s w)` is `ContDiffAt ℝ 1` at each point
-   ⇒ `ContDiffOn ℝ 1` (projecting off the `s` component, `ContDiffAt.snd`).
-4. **Bijectivity** is the per-slice `LeftInverse`/`RightInverse` from `exists_charFlow_inverse_On`,
-   packaged into the `s`-indexed `Ψ`.
-The two-time flow `Φ_{s→t} = Φ_t ∘ Ψ_s` is then jointly `C¹` by composing with `Φ_t` (`C¹` in its
-argument, `#3`), and the dual core's transport identity differentiates it. -/
-theorem charFlow_inverse_contDiffOn_joint
-    (gradW : PhysSpace d → PhysSpace d) (hgradW_C1 : ContDiff ℝ 1 gradW)
-    (L : NNReal) (hL : LipschitzWith L gradW)
-    (ρ : ℝ → Measure (PhysSpace d)) [∀ s, IsProbabilityMeasure (ρ s)]
-    (charX charV : ℝ → PhaseSpace d → PhysSpace d)
-    (T : ℝ) (hT : 0 < T)
-    (hflow : IsCharacteristicFlowOn gradW ρ charX charV (Set.Ioo 0 T) Set.univ)
-    (h_int : ∀ s (x : PhysSpace d), Integrable (fun y => gradW (x - y)) (ρ s))
-    (hf_cont : ∀ x, Continuous (fun s => convolveFunctionMeasure gradW (ρ s) x))
-    (hρD_cont : ContinuousOn
-      (fun p : ℝ × PhysSpace d => ∫ y, fderiv ℝ gradW (p.2 - y) ∂(ρ p.1))
-      (Set.Icc 0 T ×ˢ (Set.univ : Set (PhysSpace d))))
-    (hcontIcc : ∀ z : PhaseSpace d,
-      ContinuousOn (fun s => (charX s z, charV s z)) (Set.Icc (0 : ℝ) T)) :
-    ∃ Ψ : ℝ → PhaseSpace d → PhaseSpace d,
-      (∀ s ∈ Set.Ioo (0 : ℝ) T,
-        Function.LeftInverse (Ψ s) (fun z => (charX s z, charV s z))) ∧
-      (∀ s ∈ Set.Ioo (0 : ℝ) T,
-        Function.RightInverse (Ψ s) (fun z => (charX s z, charV s z))) ∧
-      ContDiffOn ℝ 1 (fun p : ℝ × PhaseSpace d => Ψ p.1 p.2) (Set.Ioo 0 T ×ˢ Set.univ) := by
-  classical
-  obtain ⟨DΦ, hFDeriv, -⟩ := charFlow_hasFDerivAt_joint gradW hgradW_C1 L hL ρ charX charV T hT
-    hflow h_int hf_cont hρD_cont hcontIcc
-  have hΦ_cda := charFlow_contDiffAt_joint gradW hgradW_C1 L hL ρ charX charV T hT
-    hflow h_int hf_cont hρD_cont hcontIcc
-  have hstep2 := exists_charFlow_inverse_On gradW hgradW_C1 L hL ρ charX charV T hT
-    hflow h_int hρD_cont hcontIcc
-  have hbij : ∀ s ∈ Set.Ioo (0 : ℝ) T,
-      Function.Bijective (fun z => ((charX s z, charV s z) : PhaseSpace d)) := by
-    intro s hs
-    obtain ⟨Ψ', e, _, hL', hR', _, _⟩ := hstep2 s hs
-    exact ⟨hL'.injective, hR'.surjective⟩
-  set Ψ : ℝ → PhaseSpace d → PhaseSpace d :=
-    fun s => Function.invFun (fun z => (charX s z, charV s z)) with hΨ_def
-  have hLeft : ∀ s ∈ Set.Ioo (0 : ℝ) T,
-      Function.LeftInverse (Ψ s) (fun z => (charX s z, charV s z)) :=
-    fun s hs => Function.leftInverse_invFun (hbij s hs).1
-  have hRight : ∀ s ∈ Set.Ioo (0 : ℝ) T,
-      Function.RightInverse (Ψ s) (fun z => (charX s z, charV s z)) :=
-    fun s hs => Function.rightInverse_invFun (hbij s hs).2
-  refine ⟨Ψ, hLeft, hRight, ?_⟩
-  set Ξ : ℝ × PhaseSpace d → ℝ × PhaseSpace d :=
-    fun x => (x.1, (charX x.1 x.2, charV x.1 x.2)) with hΞ_def
-  intro pt hpt
-  obtain ⟨hs₀, -⟩ := hpt
-  obtain ⟨Ψ', e, he_deriv, -, -, -, -⟩ := hstep2 pt.1 hs₀
-  set z₀ : PhaseSpace d := Ψ pt.1 pt.2 with hz₀_def
-  have hΦz₀ : (charX pt.1 z₀, charV pt.1 z₀) = pt.2 := hRight pt.1 hs₀ pt.2
-  have hΞ_cda : ContDiffAt ℝ 1 Ξ (pt.1, z₀) :=
-    contDiffAt_fst.prodMk (hΦ_cda (pt.1, z₀) ⟨hs₀, Set.mem_univ _⟩)
-  set DΞ : (ℝ × PhaseSpace d) →L[ℝ] (ℝ × PhaseSpace d) :=
-    (ContinuousLinearMap.fst ℝ ℝ (PhaseSpace d)).prod (DΦ (pt.1, z₀)) with hDΞ_def
-  have hΞ_hd : HasFDerivAt Ξ DΞ (pt.1, z₀) :=
-    (hasFDerivAt_fst).prodMk (hFDeriv (pt.1, z₀) ⟨hs₀, Set.mem_univ _⟩)
-  have hincl : HasFDerivAt (fun z : PhaseSpace d => ((pt.1, z) : ℝ × PhaseSpace d))
-      ((0 : PhaseSpace d →L[ℝ] ℝ).prod (ContinuousLinearMap.id ℝ (PhaseSpace d))) z₀ :=
-    (hasFDerivAt_const (pt.1 : ℝ) z₀).prodMk (hasFDerivAt_id z₀)
-  have hslice : HasFDerivAt (fun z => (charX pt.1 z, charV pt.1 z))
-      ((DΦ (pt.1, z₀)).comp
-        ((0 : PhaseSpace d →L[ℝ] ℝ).prod (ContinuousLinearMap.id ℝ (PhaseSpace d)))) z₀ :=
-    (hFDeriv (pt.1, z₀) ⟨hs₀, Set.mem_univ _⟩).comp z₀ hincl
-  have hcomp_eq : (DΦ (pt.1, z₀)).comp
-      ((0 : PhaseSpace d →L[ℝ] ℝ).prod (ContinuousLinearMap.id ℝ (PhaseSpace d)))
-      = (e z₀ : PhaseSpace d →L[ℝ] PhaseSpace d) :=
-    hslice.unique (he_deriv z₀)
-  have hslice_app : ∀ k : PhaseSpace d,
-      DΦ (pt.1, z₀) ((0 : ℝ), k) = (e z₀ : PhaseSpace d →L[ℝ] PhaseSpace d) k := by
-    intro k
-    have h1 : ((0 : PhaseSpace d →L[ℝ] ℝ).prod (ContinuousLinearMap.id ℝ (PhaseSpace d))) k
-        = ((0 : ℝ), k) := by simp
-    rw [← h1, ← ContinuousLinearMap.comp_apply, hcomp_eq]
-  have hker : LinearMap.ker (DΞ : (ℝ × PhaseSpace d) →ₗ[ℝ] (ℝ × PhaseSpace d)) = ⊥ := by
-    refine LinearMap.ker_eq_bot'.mpr (fun x hx => ?_)
-    have hxapp : (x.1, DΦ (pt.1, z₀) x) = ((0 : ℝ), (0 : PhaseSpace d)) := by
-      have : DΞ x = ((0 : ℝ), (0 : PhaseSpace d)) := hx
-      simpa [hDΞ_def, ContinuousLinearMap.prod_apply] using this
-    have hx1 : x.1 = 0 := (Prod.ext_iff.mp hxapp).1
-    have hx2 : DΦ (pt.1, z₀) x = 0 := (Prod.ext_iff.mp hxapp).2
-    have hxz : x = ((0 : ℝ), x.2) := Prod.ext hx1 rfl
-    have hez : (e z₀ : PhaseSpace d →L[ℝ] PhaseSpace d) x.2 = 0 := by
-      rw [← hslice_app x.2, ← hxz]; exact hx2
-    have : x.2 = 0 := by
-      have hinj := (e z₀).injective
-      have : (e z₀) x.2 = (e z₀) 0 := by rw [map_zero]; exact_mod_cast hez
-      exact hinj this
-    exact Prod.ext hx1 this
-  have hrange : LinearMap.range (DΞ : (ℝ × PhaseSpace d) →ₗ[ℝ] (ℝ × PhaseSpace d)) = ⊤ :=
-    LinearMap.range_eq_top.mpr
-      (LinearMap.injective_iff_surjective.mp (LinearMap.ker_eq_bot.mp hker))
-  set eΞ : (ℝ × PhaseSpace d) ≃L[ℝ] (ℝ × PhaseSpace d) :=
-    ContinuousLinearEquiv.ofBijective DΞ hker hrange with heΞ_def
-  have hΞ_hd' : HasFDerivAt Ξ (eΞ : (ℝ × PhaseSpace d) →L[ℝ] (ℝ × PhaseSpace d)) (pt.1, z₀) :=
-    hΞ_hd
-  have hlocinv : ContDiffAt ℝ 1 (hΞ_cda.localInverse hΞ_hd' one_ne_zero) (Ξ (pt.1, z₀)) :=
-    hΞ_cda.to_localInverse hΞ_hd' one_ne_zero
-  have hstrict := hΞ_cda.hasStrictFDerivAt' hΞ_hd' (one_ne_zero)
-  have hloc : ∀ᶠ x in 𝓝 ((pt.1, z₀) : ℝ × PhaseSpace d),
-      ((fun y : ℝ × PhaseSpace d => ((y.1, Ψ y.1 y.2) : ℝ × PhaseSpace d)) (Ξ x)) = x := by
-    have hIoo : ∀ᶠ x in 𝓝 ((pt.1, z₀) : ℝ × PhaseSpace d), x.1 ∈ Set.Ioo (0 : ℝ) T :=
-      continuous_fst.continuousAt.eventually_mem (isOpen_Ioo.mem_nhds hs₀)
-    filter_upwards [hIoo] with x hx
-    have hL2 : Ψ x.1 (charX x.1 x.2, charV x.1 x.2) = x.2 := hLeft x.1 hx x.2
-    simp only [hΞ_def]
-    rw [hL2]
-  have huniq : ∀ᶠ y in 𝓝 (Ξ (pt.1, z₀)),
-      ((y.1, Ψ y.1 y.2) : ℝ × PhaseSpace d) = (hΞ_cda.localInverse hΞ_hd' one_ne_zero) y :=
-    hstrict.localInverse_unique hloc
-  have hΞeq : Ξ (pt.1, z₀) = (pt.1, pt.2) := by rw [hΞ_def]; exact Prod.ext rfl hΦz₀
-  have hG_cda : ContDiffAt ℝ 1
-      (fun y : ℝ × PhaseSpace d => ((y.1, Ψ y.1 y.2) : ℝ × PhaseSpace d)) (pt.1, pt.2) := by
-    rw [← hΞeq]
-    exact hlocinv.congr_of_eventuallyEq huniq
-  have hpt_eq : pt = (pt.1, pt.2) := rfl
-  rw [hpt_eq]
-  exact (hG_cda.snd).contDiffWithinAt
-
-/-! ### Step 4 — the transported test function and the transport identity
-
-The dual core's `s ↦ ∫ ψ_s d(f s)` argument rests on the backward-transported test
-`ψ_s := φ ∘ Φ_{s→t}` where `Φ_{s→t} = Φ_t ∘ Φ_s⁻¹` is the two-time flow (Step 3 gave it jointly
-`C¹`).  Two deliverables, both taking the *outputs* of Step 3 (the inverse `Ψ` + the `C¹` terminal
-map `Φ_t`) as hypotheses rather than re-deriving them from the flow-construction data: -/
-
-omit [NeZero d] in
-/-- **Step 4 (4a) — the two-time flow `Φ_{s→t} = Φ_t ∘ Φ_s⁻¹` is jointly `C¹`** on
-`Ioo 0 T ×ˢ univ`.
-
-The two-time flow `(s,w) ↦ (charX t (Ψ_s w), charV t (Ψ_s w))` is the composition of the terminal
-map `Φ_t = (charX t ·, charV t ·)` (`C¹` in its argument — `hΦt_C1`, from Step 2 / item (iii) at the
-fixed time `t`) with the jointly-`C¹` inverse family `(s,w) ↦ Ψ_s w` (`hΨ_C1`, item (iv)).  Proof:
-`ContDiff.comp_contDiffOn`. -/
-theorem twoTimeFlow_contDiffOn_joint
-    (charX charV : ℝ → PhaseSpace d → PhysSpace d) (T t : ℝ)
-    (Ψ : ℝ → PhaseSpace d → PhaseSpace d)
-    (hΨ_C1 : ContDiffOn ℝ 1 (fun p : ℝ × PhaseSpace d => Ψ p.1 p.2)
-      (Set.Ioo (0 : ℝ) T ×ˢ Set.univ))
-    (hΦt_C1 : ContDiff ℝ 1 (fun z : PhaseSpace d => (charX t z, charV t z))) :
-    ContDiffOn ℝ 1
-      (fun p : ℝ × PhaseSpace d => ((charX t (Ψ p.1 p.2), charV t (Ψ p.1 p.2)) : PhaseSpace d))
-      (Set.Ioo (0 : ℝ) T ×ˢ Set.univ) :=
-  hΦt_C1.comp_contDiffOn hΨ_C1
-
-omit [NeZero d] in
-/-- **Step 4 (4b) — the transport identity `∂_s ψ_s + Dψ_s · b_s = 0`.**
-
-For the backward-transported test `ψ_s(w) := φ(Φ_t(Ψ_s w)) = φ(Φ_{s→t} w)`, the partial
-`s`-derivative cancels the spatial directional derivative along the field:
-`∂_s ψ_s(w) = -(Dψ_s(w))(b_s(w))`, where `b_s = vlasovVectorField gradW ρ s` and
-`Dψ_s(w) = fderiv ℝ (ψ s) w`.  This is the dual of `vlasov_traj_chain_rule` (the pushforward
-direction) and the engine that makes `s ↦ ∫ ψ_s d(f s)` constant in Step 6.
-
-Proof:
-* `ψ` is jointly `C¹` on `Ioo 0 T ×ˢ univ` (4a + `φ` smooth), so `HasFDerivAt (uncurry ψ) Dψ (s,w)`
-  at the interior point `(s,w)`, with `Dψ` the joint Fréchet derivative.
-* Constancy curve: set `z₀ := Ψ_s w`, so `w = Φ_s z₀` (`hΨ_right`).  The composite
-  `s' ↦ ψ_{s'}(Φ_{s'} z₀) = φ(Φ_t(Ψ_{s'}(Φ_{s'} z₀))) = φ(Φ_t z₀)` is **constant** in `s'`
-  (`hΨ_left`: `Ψ_{s'} ∘ Φ_{s'} = id`), hence has zero `s'`-derivative.
-* The curve `c(s') := (s', Φ_{s'} z₀)` has `HasDerivAt c (1, b_s w) s` (`hflow_ode` + `id`), with
-  `c(s) = (s, w)`.  Chain rule: `0 = Dψ(s,w)(1, b_s w) = Dψ(s,w)(1,0) + Dψ(s,w)(0, b_s w)`.
-* `Dψ(s,w)(1,0) = ∂_s ψ_s(w)` (compose `uncurry ψ` with `s' ↦ (s', w)`) and
-  `Dψ(s,w)(0,k) = (fderiv ℝ (ψ s) w) k` (compose with `w' ↦ (s, w')`).  Surjectivity (`hΨ_right`)
-  covers every `w`.  Rearrange to the claimed `HasDerivAt`. -/
-theorem transportedTest_transport_identity
-    (gradW : PhysSpace d → PhysSpace d)
-    (ρ : ℝ → Measure (PhysSpace d))
-    (charX charV : ℝ → PhaseSpace d → PhysSpace d) (T t : ℝ)
-    (φ : PhaseSpace d → ℝ) (hφ : ContDiff ℝ (⊤ : ℕ∞) φ)
-    (Ψ : ℝ → PhaseSpace d → PhaseSpace d)
-    (hΨ_left : ∀ s ∈ Set.Ioo (0 : ℝ) T,
-      Function.LeftInverse (Ψ s) (fun z => (charX s z, charV s z)))
-    (hΨ_right : ∀ s ∈ Set.Ioo (0 : ℝ) T,
-      Function.RightInverse (Ψ s) (fun z => (charX s z, charV s z)))
-    (hΨ_C1 : ContDiffOn ℝ 1 (fun p : ℝ × PhaseSpace d => Ψ p.1 p.2)
-      (Set.Ioo (0 : ℝ) T ×ˢ Set.univ))
-    (hΦt_C1 : ContDiff ℝ 1 (fun z : PhaseSpace d => (charX t z, charV t z)))
-    (hflow_ode : ∀ z : PhaseSpace d, ∀ s ∈ Set.Ioo (0 : ℝ) T,
-      HasDerivAt (fun s' => (charX s' z, charV s' z))
-        (vlasovVectorField gradW ρ s (charX s z, charV s z)) s)
-    (s : ℝ) (hs : s ∈ Set.Ioo (0 : ℝ) T) (w : PhaseSpace d) :
-    HasDerivAt (fun s' => φ (charX t (Ψ s' w), charV t (Ψ s' w)))
-      (-(fderiv ℝ (fun w' : PhaseSpace d => φ (charX t (Ψ s w'), charV t (Ψ s w'))) w
-          (vlasovVectorField gradW ρ s w))) s := by
-  classical
-  -- uncurried two-time flow and transported test
-  set G2 : ℝ × PhaseSpace d → PhaseSpace d :=
-    fun p => (charX t (Ψ p.1 p.2), charV t (Ψ p.1 p.2)) with hG2_def
-  set g : ℝ × PhaseSpace d → ℝ := fun p => φ (G2 p) with hg_def
-  have hopen : IsOpen (Set.Ioo (0 : ℝ) T ×ˢ (Set.univ : Set (PhaseSpace d))) :=
-    isOpen_Ioo.prod isOpen_univ
-  have hmem : ((s, w) : ℝ × PhaseSpace d) ∈ Set.Ioo (0 : ℝ) T ×ˢ (Set.univ : Set (PhaseSpace d)) :=
-    ⟨hs, Set.mem_univ _⟩
-  -- right-inverse identity: Φ_s (Ψ_s w) = w
-  have hw : (charX s (Ψ s w), charV s (Ψ s w)) = w := hΨ_right s hs w
-  -- g is jointly C¹, hence HasFDerivAt at the interior point (s,w)
-  have hG2_cd : ContDiffOn ℝ 1 G2 (Set.Ioo (0 : ℝ) T ×ˢ Set.univ) :=
-    twoTimeFlow_contDiffOn_joint charX charV T t Ψ hΨ_C1 hΦt_C1
-  have hG2_diff : DifferentiableAt ℝ G2 (s, w) :=
-    hG2_cd.differentiableOn_one.differentiableAt (hopen.mem_nhds hmem)
-  have hφ_diff : DifferentiableAt ℝ φ (G2 (s, w)) := hφ.differentiable (by simp) _
-  have hg_fderiv : HasFDerivAt g (fderiv ℝ g (s, w)) (s, w) :=
-    (hφ_diff.comp (s, w) hG2_diff).hasFDerivAt
-  set G := fderiv ℝ g (s, w) with hG_def
-  -- (A) spatial slice w' ↦ g (s, w') : fderiv = G ∘ inr
-  have hslice_fderiv : HasFDerivAt (fun w' : PhaseSpace d => g (s, w'))
-      (G.comp (ContinuousLinearMap.inr ℝ ℝ (PhaseSpace d))) w := by
-    have := hg_fderiv.comp w (hasFDerivAt_prodMk_right s w)
-    simpa only [Function.comp_def] using this
-  -- (B) ∂_s slice s' ↦ g (s', w) : HasDerivAt with value G (1, 0)
-  have hscurve : HasDerivAt (fun s' => ((s', w) : ℝ × PhaseSpace d))
-      ((1 : ℝ), (0 : PhaseSpace d)) s :=
-    (hasDerivAt_id s).prodMk (hasDerivAt_const s w)
-  have hs_slice : HasDerivAt (fun s' => g (s', w)) (G ((1 : ℝ), (0 : PhaseSpace d))) s := by
-    have := hg_fderiv.comp_hasDerivAt s hscurve
-    simpa only [Function.comp_def] using this
-  -- (C) constancy curve c(s') = (s', Φ_{s'} (Ψ_s w)); chain rule gives G(1, b)
-  have hccurve : HasDerivAt
-      (fun s' => ((s', (charX s' (Ψ s w), charV s' (Ψ s w))) : ℝ × PhaseSpace d))
-      ((1 : ℝ), vlasovVectorField gradW ρ s (charX s (Ψ s w), charV s (Ψ s w))) s :=
-    (hasDerivAt_id s).prodMk (hflow_ode (Ψ s w) s hs)
-  have hcs : ((s, (charX s (Ψ s w), charV s (Ψ s w))) : ℝ × PhaseSpace d) = (s, w) := by rw [hw]
-  have hgc : HasDerivAt (fun s' => g (s', (charX s' (Ψ s w), charV s' (Ψ s w))))
-      (G ((1 : ℝ), vlasovVectorField gradW ρ s (charX s (Ψ s w), charV s (Ψ s w)))) s := by
-    have hF := hg_fderiv
-    rw [← hcs] at hF
-    have := hF.comp_hasDerivAt s hccurve
-    simpa only [Function.comp_def] using this
-  -- (D) the composite is eventually constant near s, so its derivative is 0
-  have hconst : (fun s' => g (s', (charX s' (Ψ s w), charV s' (Ψ s w)))) =ᶠ[nhds s]
-      (fun _ => φ (charX t (Ψ s w), charV t (Ψ s w))) := by
-    filter_upwards [isOpen_Ioo.mem_nhds hs] with s' hs'
-    simp only [hg_def, hG2_def]
-    rw [hΨ_left s' hs' (Ψ s w)]
-  have hgc0 : HasDerivAt (fun s' => g (s', (charX s' (Ψ s w), charV s' (Ψ s w)))) 0 s :=
-    (hasDerivAt_const s (φ (charX t (Ψ s w), charV t (Ψ s w)))).congr_of_eventuallyEq hconst
-  -- (E) uniqueness: G (1, b) = 0
-  have hGzero : G ((1 : ℝ), vlasovVectorField gradW ρ s (charX s (Ψ s w), charV s (Ψ s w))) = 0 :=
-    hgc.unique hgc0
-  -- (F) split G(1,b) = G(1,0) + G(0,b); identify G(0,b) with the target fderiv applied to b
-  have hsplit : ((1 : ℝ), vlasovVectorField gradW ρ s (charX s (Ψ s w), charV s (Ψ s w)))
-      = ((1 : ℝ), (0 : PhaseSpace d))
-        + ((0 : ℝ), vlasovVectorField gradW ρ s (charX s (Ψ s w), charV s (Ψ s w))) := by
-    ext <;> simp
-  have hb_eq : vlasovVectorField gradW ρ s (charX s (Ψ s w), charV s (Ψ s w))
-      = vlasovVectorField gradW ρ s w := by rw [hw]
-  have hG0b : G ((0 : ℝ), vlasovVectorField gradW ρ s (charX s (Ψ s w), charV s (Ψ s w)))
-      = (fderiv ℝ (fun w' : PhaseSpace d => φ (charX t (Ψ s w'), charV t (Ψ s w'))) w)
-          (vlasovVectorField gradW ρ s w) := by
-    have hfd : fderiv ℝ (fun w' : PhaseSpace d => g (s, w')) w
-        = G.comp (ContinuousLinearMap.inr ℝ ℝ (PhaseSpace d)) := hslice_fderiv.fderiv
-    have hfun : (fun w' : PhaseSpace d => g (s, w'))
-        = (fun w' : PhaseSpace d => φ (charX t (Ψ s w'), charV t (Ψ s w'))) := rfl
-    rw [hfun] at hfd
-    rw [hfd, ContinuousLinearMap.comp_apply, ContinuousLinearMap.inr_apply, hb_eq]
-  -- (G) G(1,0) = -(target fderiv)(b)
-  have hval : G ((1 : ℝ), (0 : PhaseSpace d))
-      = -(fderiv ℝ (fun w' : PhaseSpace d => φ (charX t (Ψ s w'), charV t (Ψ s w'))) w)
-          (vlasovVectorField gradW ρ s w) := by
-    have hsum : G ((1 : ℝ), (0 : PhaseSpace d))
-        + G ((0 : ℝ), vlasovVectorField gradW ρ s (charX s (Ψ s w), charV s (Ψ s w))) = 0 := by
-      rw [← map_add, ← hsplit]; exact hGzero
-    rw [hG0b] at hsum
-    linarith [hsum]
-  -- (H) conclude
-  have hgoalfun : (fun s' => φ (charX t (Ψ s' w), charV t (Ψ s' w)))
-      = (fun s' => g (s', w)) := rfl
-  rw [hgoalfun, ← hval]
-  exact hs_slice
-
-
-open Filter Topology Metric in
-open scoped Convolution in
-omit [NeZero d] in
-/-- Helper 1 — uniform mollification of a continuous, compactly-supported function.
-The mollified family `ρ_n ⋆ g` converges to `g` **uniformly** (not just pointwise), the
-load-bearing analytic input the `C¹_c` test-class enlargement (#4) needs.  Proof: uniform
-continuity of `g` (compact support) gives a single `δ`; once `rOut_n < δ`, the pointwise bump
-estimate `dist_normed_convolution_le` fires at *every* base point simultaneously. -/
-theorem mollifier_tendstoUniformly {E : Type*}
-    [NormedAddCommGroup E] [NormedSpace ℝ E] [CompleteSpace E]
-    (g : PhaseSpace d → E) (hg_cont : Continuous g) (hg_cs : HasCompactSupport g)
-    (φ : ℕ → ContDiffBump (0 : PhaseSpace d))
-    (hφ : Tendsto (fun n => (φ n).rOut) atTop (𝓝 0)) :
-    TendstoUniformly
-      (fun n x => ((φ n).normed volume ⋆[ContinuousLinearMap.lsmul ℝ ℝ, volume] g) x) g atTop := by
-  have hHaar : (volume : Measure (PhaseSpace d)).IsAddHaarMeasure := by
-    rw [show (volume : Measure (PhaseSpace d)) = (volume : Measure (PhysSpace d)).prod volume from
-      Measure.volume_eq_prod _ _]
-    infer_instance
-  have hg_uc : UniformContinuous g := hg_cs.uniformContinuous_of_continuous hg_cont
-  rw [Metric.uniformContinuous_iff] at hg_uc
-  rw [Metric.tendstoUniformly_iff]
-  intro ε hε
-  obtain ⟨δ, hδ, hδ_prop⟩ := hg_uc (ε / 2) (by positivity)
-  have hev : ∀ᶠ n in atTop, (φ n).rOut < δ := hφ.eventually (Iio_mem_nhds hδ)
-  filter_upwards [hev] with n hn
-  intro x₀
-  rw [dist_comm]
-  have hball : ∀ x ∈ ball x₀ (φ n).rOut, dist (g x) (g x₀) ≤ ε / 2 := by
-    intro x hx
-    exact le_of_lt (hδ_prop (lt_trans (mem_ball.mp hx) hn))
-  have hbump := ContDiffBump.dist_normed_convolution_le (μ := volume) (φ := φ n) (g := g)
-    hg_cont.aestronglyMeasurable hball
-  exact lt_of_le_of_lt hbump (half_lt_self hε)
-
-open Filter Topology Metric in
-open scoped Convolution in
-omit [NeZero d] in
-/-- Helper 2 — the mollified Fréchet derivative converges uniformly.
-`fderiv (ρ_n ⋆ χ) = ρ_n ⋆ (fderiv χ)` (convolution commutes onto the `C¹` factor via
-`HasCompactSupport.hasFDerivAt_convolution_right`, with `precompR` reconciled to `lsmul` on the
-operator codomain), and the right-hand side converges uniformly to `fderiv χ` by Helper 1 applied
-to the continuous, compactly-supported `fderiv χ`. -/
-theorem mollifiedFDeriv_tendstoUniformly
-    (χ : PhaseSpace d → ℝ) (hχ_C1 : ContDiff ℝ 1 χ) (hχc : HasCompactSupport χ)
-    (φ : ℕ → ContDiffBump (0 : PhaseSpace d))
-    (hφ : Tendsto (fun n => (φ n).rOut) atTop (𝓝 0)) :
-    TendstoUniformly
-      (fun n z => fderiv ℝ ((φ n).normed volume ⋆[ContinuousLinearMap.lsmul ℝ ℝ, volume] χ) z)
-      (fderiv ℝ χ) atTop := by
-  have hHaar : (volume : Measure (PhaseSpace d)).IsAddHaarMeasure := by
-    rw [show (volume : Measure (PhaseSpace d)) = (volume : Measure (PhysSpace d)).prod volume from
-      Measure.volume_eq_prod _ _]
-    infer_instance
-  have hdf_cont : Continuous (fderiv ℝ χ) := hχ_C1.continuous_fderiv one_ne_zero
-  have hdf_cs : HasCompactSupport (fderiv ℝ χ) := hχc.fderiv ℝ
-  -- the `precompR` bilinear map coincides with `lsmul` on the operator codomain
-  have hbridge : (ContinuousLinearMap.lsmul ℝ ℝ).precompR (PhaseSpace d)
-      = (ContinuousLinearMap.lsmul ℝ ℝ :
-          ℝ →L[ℝ] (PhaseSpace d →L[ℝ] ℝ) →L[ℝ] (PhaseSpace d →L[ℝ] ℝ)) := by
-    refine ContinuousLinearMap.ext fun u => ?_
-    refine ContinuousLinearMap.ext fun v => ?_
-    refine ContinuousLinearMap.ext fun x => ?_
-    simp [ContinuousLinearMap.precompR_apply, ContinuousLinearMap.lsmul_apply]
-  have hfd : ∀ n, (fun z => fderiv ℝ
-        ((φ n).normed volume ⋆[ContinuousLinearMap.lsmul ℝ ℝ, volume] χ) z)
-      = (fun z => ((φ n).normed volume ⋆[ContinuousLinearMap.lsmul ℝ ℝ, volume] fderiv ℝ χ) z) := by
-    intro n
-    funext z
-    rw [(hχc.hasFDerivAt_convolution_right (L := ContinuousLinearMap.lsmul ℝ ℝ)
-      ((φ n).continuous_normed.locallyIntegrable) hχ_C1 z).fderiv, hbridge]
-  have hgoal_eq :
-      (fun n z => fderiv ℝ ((φ n).normed volume ⋆[ContinuousLinearMap.lsmul ℝ ℝ, volume] χ) z)
-      = (fun n z =>
-          ((φ n).normed volume ⋆[ContinuousLinearMap.lsmul ℝ ℝ, volume] fderiv ℝ χ) z) := by
-    funext n; exact hfd n
-  rw [hgoal_eq]
-  exact mollifier_tendstoUniformly (fderiv ℝ χ) hdf_cont hdf_cs φ hφ
-
--- ── Helpers for `weakEvolution_test_C1c_On`, extracted from its proof body (the
---    mathematical content is unchanged; each piece is generic in the test function). ──
-
-omit [NeZero d] in
-/-- Norm bound for the dual-composed difference of two Fréchet derivatives. -/
-lemma toDualSymm_comp_sub_norm_le (ψ ϕ : PhaseSpace d → ℝ)
-    (z : PhaseSpace d) (e : PhysSpace d →L[ℝ] PhaseSpace d) :
-    ‖(InnerProductSpace.toDual ℝ (PhysSpace d)).symm ((fderiv ℝ ψ z).comp e)
-      - (InnerProductSpace.toDual ℝ (PhysSpace d)).symm ((fderiv ℝ ϕ z).comp e)‖
-    ≤ ‖fderiv ℝ ψ z - fderiv ℝ ϕ z‖ * ‖e‖ := by
-  rw [← map_sub, LinearIsometryEquiv.norm_map, ← ContinuousLinearMap.sub_comp]
-  exact ContinuousLinearMap.opNorm_comp_le _ _
-
-omit [NeZero d] in
-/-- Chain rule: the Fréchet derivative of an `x`-slice is the composition with `inl`. -/
-lemma fderiv_slice_fst (ψ : PhaseSpace d → ℝ) (hψ : Differentiable ℝ ψ) (z : PhaseSpace d) :
-    fderiv ℝ (fun x => ψ (x, z.2)) z.1
-      = (fderiv ℝ ψ z).comp (ContinuousLinearMap.inl ℝ (PhysSpace d) (PhysSpace d)) := by
-  have h2 : HasFDerivAt (fun x : PhysSpace d => (x, z.2))
-      (ContinuousLinearMap.inl ℝ (PhysSpace d) (PhysSpace d)) z.1 :=
-    hasFDerivAt_prodMk_left z.1 z.2
-  exact ((hψ z).hasFDerivAt.comp z.1 h2).fderiv
-
-omit [NeZero d] in
-/-- Chain rule: the Fréchet derivative of a `v`-slice is the composition with `inr`. -/
-lemma fderiv_slice_snd (ψ : PhaseSpace d → ℝ) (hψ : Differentiable ℝ ψ) (z : PhaseSpace d) :
-    fderiv ℝ (fun v => ψ (z.1, v)) z.2
-      = (fderiv ℝ ψ z).comp (ContinuousLinearMap.inr ℝ (PhysSpace d) (PhysSpace d)) := by
-  have h2 : HasFDerivAt (fun v : PhysSpace d => (z.1, v))
-      (ContinuousLinearMap.inr ℝ (PhysSpace d) (PhysSpace d)) z.2 :=
-    hasFDerivAt_prodMk_right z.1 z.2
-  exact ((hψ z).hasFDerivAt.comp z.2 h2).fderiv
-
-omit [NeZero d] in
-/-- Continuity of the first-slot partial-gradient field of a `C¹` test function. -/
-lemma continuous_gradientSlice_fst (ψ : PhaseSpace d → ℝ) (g : PhaseSpace d → PhysSpace d)
-    (hψ : Differentiable ℝ ψ) (hψ' : Continuous (fderiv ℝ ψ))
-    (hg : ∀ z, g z = gradient (fun x => ψ (x, z.2)) z.1) : Continuous g := by
-  have heq : g = fun z => (InnerProductSpace.toDual ℝ (PhysSpace d)).symm
-      ((fderiv ℝ ψ z).comp (ContinuousLinearMap.inl ℝ (PhysSpace d) (PhysSpace d))) := by
-    funext z; rw [hg z]; simp only [gradient]; rw [fderiv_slice_fst ψ hψ z]
-  rw [heq]
-  exact (InnerProductSpace.toDual ℝ (PhysSpace d)).symm.continuous.comp
-    (hψ'.clm_comp continuous_const)
-
-omit [NeZero d] in
-/-- Continuity of the second-slot partial-gradient field of a `C¹` test function. -/
-lemma continuous_gradientSlice_snd (ψ : PhaseSpace d → ℝ) (g : PhaseSpace d → PhysSpace d)
-    (hψ : Differentiable ℝ ψ) (hψ' : Continuous (fderiv ℝ ψ))
-    (hg : ∀ z, g z = gradient (fun v => ψ (z.1, v)) z.2) : Continuous g := by
-  have heq : g = fun z => (InnerProductSpace.toDual ℝ (PhysSpace d)).symm
-      ((fderiv ℝ ψ z).comp (ContinuousLinearMap.inr ℝ (PhysSpace d) (PhysSpace d))) := by
-    funext z; rw [hg z]; simp only [gradient]; rw [fderiv_slice_snd ψ hψ z]
-  rw [heq]
-  exact (InnerProductSpace.toDual ℝ (PhysSpace d)).symm.continuous.comp
-    (hψ'.clm_comp continuous_const)
-
-omit [NeZero d] in
-/-- Compact support of the first-slot partial-gradient field. -/
-lemma hasCompactSupport_gradientSlice_fst (ψ : PhaseSpace d → ℝ)
-    (g : PhaseSpace d → PhysSpace d) (hψ : Differentiable ℝ ψ) (hψcs : HasCompactSupport ψ)
-    (hg : ∀ z, g z = gradient (fun x => ψ (x, z.2)) z.1) : HasCompactSupport g := by
-  apply HasCompactSupport.intro hψcs
-  intro z hz
-  have hf0 : fderiv ℝ ψ z = 0 := fderiv_of_notMem_tsupport ℝ hz
-  rw [hg z]; simp only [gradient]; rw [fderiv_slice_fst ψ hψ z, hf0]; simp
-
-omit [NeZero d] in
-/-- Compact support of the second-slot partial-gradient field. -/
-lemma hasCompactSupport_gradientSlice_snd (ψ : PhaseSpace d → ℝ)
-    (g : PhaseSpace d → PhysSpace d) (hψ : Differentiable ℝ ψ) (hψcs : HasCompactSupport ψ)
-    (hg : ∀ z, g z = gradient (fun v => ψ (z.1, v)) z.2) : HasCompactSupport g := by
-  apply HasCompactSupport.intro hψcs
-  intro z hz
-  have hf0 : fderiv ℝ ψ z = 0 := fderiv_of_notMem_tsupport ℝ hz
-  rw [hg z]; simp only [gradient]; rw [fderiv_slice_snd ψ hψ z, hf0]; simp
-
-omit [NeZero d] in
-/-- First-slot partial gradients of two tests differ by at most the full
-Fréchet-derivative difference. -/
-lemma gradientSlice_fst_sub_norm_le (ψ ϕ : PhaseSpace d → ℝ)
-    (hψ : Differentiable ℝ ψ) (hϕ : Differentiable ℝ ϕ)
-    (gψ gϕ : PhaseSpace d → PhysSpace d)
-    (hgψ : ∀ z, gψ z = gradient (fun x => ψ (x, z.2)) z.1)
-    (hgϕ : ∀ z, gϕ z = gradient (fun x => ϕ (x, z.2)) z.1) (z : PhaseSpace d) :
-    ‖gψ z - gϕ z‖ ≤ ‖fderiv ℝ ψ z - fderiv ℝ ϕ z‖ := by
-  have e1 : gψ z = (InnerProductSpace.toDual ℝ (PhysSpace d)).symm
-      ((fderiv ℝ ψ z).comp (ContinuousLinearMap.inl ℝ (PhysSpace d) (PhysSpace d))) := by
-    rw [hgψ z]; simp only [gradient]; rw [fderiv_slice_fst ψ hψ z]
-  have e2 : gϕ z = (InnerProductSpace.toDual ℝ (PhysSpace d)).symm
-      ((fderiv ℝ ϕ z).comp (ContinuousLinearMap.inl ℝ (PhysSpace d) (PhysSpace d))) := by
-    rw [hgϕ z]; simp only [gradient]; rw [fderiv_slice_fst ϕ hϕ z]
-  rw [e1, e2]
-  refine le_trans (toDualSymm_comp_sub_norm_le ψ ϕ z _) ?_
-  calc ‖fderiv ℝ ψ z - fderiv ℝ ϕ z‖ * ‖ContinuousLinearMap.inl ℝ (PhysSpace d) (PhysSpace d)‖
-      ≤ ‖fderiv ℝ ψ z - fderiv ℝ ϕ z‖ * 1 := by
-        gcongr; exact ContinuousLinearMap.norm_inl_le_one ℝ (PhysSpace d) (PhysSpace d)
-    _ = ‖fderiv ℝ ψ z - fderiv ℝ ϕ z‖ := mul_one _
-
-omit [NeZero d] in
-/-- Second-slot partial gradients of two tests differ by at most the full
-Fréchet-derivative difference. -/
-lemma gradientSlice_snd_sub_norm_le (ψ ϕ : PhaseSpace d → ℝ)
-    (hψ : Differentiable ℝ ψ) (hϕ : Differentiable ℝ ϕ)
-    (gψ gϕ : PhaseSpace d → PhysSpace d)
-    (hgψ : ∀ z, gψ z = gradient (fun v => ψ (z.1, v)) z.2)
-    (hgϕ : ∀ z, gϕ z = gradient (fun v => ϕ (z.1, v)) z.2) (z : PhaseSpace d) :
-    ‖gψ z - gϕ z‖ ≤ ‖fderiv ℝ ψ z - fderiv ℝ ϕ z‖ := by
-  have e1 : gψ z = (InnerProductSpace.toDual ℝ (PhysSpace d)).symm
-      ((fderiv ℝ ψ z).comp (ContinuousLinearMap.inr ℝ (PhysSpace d) (PhysSpace d))) := by
-    rw [hgψ z]; simp only [gradient]; rw [fderiv_slice_snd ψ hψ z]
-  have e2 : gϕ z = (InnerProductSpace.toDual ℝ (PhysSpace d)).symm
-      ((fderiv ℝ ϕ z).comp (ContinuousLinearMap.inr ℝ (PhysSpace d) (PhysSpace d))) := by
-    rw [hgϕ z]; simp only [gradient]; rw [fderiv_slice_snd ϕ hϕ z]
-  rw [e1, e2]
-  refine le_trans (toDualSymm_comp_sub_norm_le ψ ϕ z _) ?_
-  calc ‖fderiv ℝ ψ z - fderiv ℝ ϕ z‖ * ‖ContinuousLinearMap.inr ℝ (PhysSpace d) (PhysSpace d)‖
-      ≤ ‖fderiv ℝ ψ z - fderiv ℝ ϕ z‖ * 1 := by
-        gcongr; exact ContinuousLinearMap.norm_inr_le_one ℝ (PhysSpace d) (PhysSpace d)
-    _ = ‖fderiv ℝ ψ z - fderiv ℝ ϕ z‖ := mul_one _
-
-omit [NeZero d] in
-/-- Integrability of the weak-evolution integrand against a probability measure:
-continuous with compact support (both gradient slots), continuous field. -/
-lemma inner_integrand_integrable
-    (μ : Measure (PhaseSpace d)) [IsProbabilityMeasure μ]
-    (fld : PhysSpace d → PhysSpace d) (hfld : Continuous fld)
-    (gX gV : PhaseSpace d → PhysSpace d)
-    (hgXc : Continuous gX) (hgVc : Continuous gV)
-    (hgXcs : HasCompactSupport gX) (hgVcs : HasCompactSupport gV) :
-    Integrable (fun z => @inner ℝ (PhysSpace d) _ z.2 (gX z)
-      - @inner ℝ (PhysSpace d) _ (fld z.1) (gV z)) μ := by
-  have hcont : Continuous (fun z => @inner ℝ (PhysSpace d) _ z.2 (gX z)
-      - @inner ℝ (PhysSpace d) _ (fld z.1) (gV z)) :=
-    (continuous_snd.inner hgXc).sub ((hfld.comp continuous_fst).inner hgVc)
-  have hcs : HasCompactSupport (fun z => @inner ℝ (PhysSpace d) _ z.2 (gX z)
-      - @inner ℝ (PhysSpace d) _ (fld z.1) (gV z)) := by
-    apply HasCompactSupport.intro (IsCompact.union hgXcs hgVcs)
-    intro z hz
-    simp only [Set.mem_union, not_or] at hz
-    rw [image_eq_zero_of_notMem_tsupport hz.1, image_eq_zero_of_notMem_tsupport hz.2]
-    simp
-  exact hcont.integrable_of_hasCompactSupport hcs
-
-omit [NeZero d] in
-/-- Pointwise bound on the difference of two weak-evolution integrands: on the
-common support `K` it is `(R_K + B) * δ` (norm bound `R_K` on `K`, field bound `B`
-on `K`, gradient-slot distance `δ`); off `K` both integrands agree. -/
-lemma inner_integrand_sub_norm_le
-    (K : Set (PhaseSpace d)) (R_K : ℝ) (hR_K_nn : 0 ≤ R_K) (hR_K : ∀ z ∈ K, ‖z‖ ≤ R_K)
-    (fld : PhysSpace d → PhysSpace d) (B : ℝ) (hB_nn : 0 ≤ B)
-    (hfld_K : ∀ z ∈ K, ‖fld (Prod.fst z)‖ ≤ B)
-    (gX gV gX' gV' : PhaseSpace d → PhysSpace d) (δ : ℝ) (hδ_nn : 0 ≤ δ)
-    (hXd : ∀ z, ‖gX' z - gX z‖ ≤ δ) (hVd : ∀ z, ‖gV' z - gV z‖ ≤ δ)
-    (hXoff : ∀ z ∉ K, gX' z = gX z) (hVoff : ∀ z ∉ K, gV' z = gV z)
-    (z : PhaseSpace d) :
-    ‖(@inner ℝ (PhysSpace d) _ z.2 (gX z) - @inner ℝ (PhysSpace d) _ (fld z.1) (gV z))
-      - (@inner ℝ (PhysSpace d) _ z.2 (gX' z)
-          - @inner ℝ (PhysSpace d) _ (fld z.1) (gV' z))‖
-    ≤ (R_K + B) * δ := by
-  by_cases hzK : z ∈ K
-  · have hrw : (@inner ℝ (PhysSpace d) _ z.2 (gX z)
-          - @inner ℝ (PhysSpace d) _ (fld z.1) (gV z))
-        - (@inner ℝ (PhysSpace d) _ z.2 (gX' z)
-          - @inner ℝ (PhysSpace d) _ (fld z.1) (gV' z))
-        = @inner ℝ (PhysSpace d) _ z.2 (gX z - gX' z)
-          - @inner ℝ (PhysSpace d) _ (fld z.1) (gV z - gV' z) := by
-      rw [inner_sub_right, inner_sub_right]; ring
-    rw [Real.norm_eq_abs, hrw]
-    have hb1 : |@inner ℝ (PhysSpace d) _ z.2 (gX z - gX' z)| ≤ R_K * δ := by
-      refine le_trans (abs_real_inner_le_norm _ _) ?_
-      have hz2 : ‖z.2‖ ≤ R_K := le_trans (norm_snd_le z) (hR_K z hzK)
-      rw [norm_sub_rev (gX z)]
-      exact mul_le_mul hz2 (hXd z) (norm_nonneg _) hR_K_nn
-    have hb2 : |@inner ℝ (PhysSpace d) _ (fld z.1) (gV z - gV' z)| ≤ B * δ := by
-      refine le_trans (abs_real_inner_le_norm _ _) ?_
-      rw [norm_sub_rev (gV z)]
-      exact mul_le_mul (hfld_K z hzK) (hVd z) (norm_nonneg _) hB_nn
-    calc |@inner ℝ (PhysSpace d) _ z.2 (gX z - gX' z)
-            - @inner ℝ (PhysSpace d) _ (fld z.1) (gV z - gV' z)|
-        ≤ |@inner ℝ (PhysSpace d) _ z.2 (gX z - gX' z)|
-          + |@inner ℝ (PhysSpace d) _ (fld z.1) (gV z - gV' z)| := abs_sub _ _
-      _ ≤ R_K * δ + B * δ := by linarith
-      _ = (R_K + B) * δ := by ring
-  · rw [hXoff z hzK, hVoff z hzK]
-    simp only [sub_self, norm_zero]
-    positivity
-
-omit [NeZero d] in
-/-- On the window, the frozen convolution field over the spatial marginal is
-integrable (in force form), linearly bounded, and continuous — packaged for
-consumers that quantify over the window. -/
-lemma convolveField_window_setup
-    (gradW : PhysSpace d → PhysSpace d)
-    (L : NNReal) (hL : LipschitzWith L gradW)
-    (f : ℝ → Measure (PhaseSpace d)) (T : ℝ)
-    (hf_mom : ∀ t ∈ Set.Icc (0 : ℝ) T, HasFiniteFirstMoment (f t))
-    (M_ρ : ℝ)
-    (hM_ρ : ∀ t ∈ Set.Icc (0 : ℝ) T, ∫ y, ‖y‖ ∂(spatialMarginal (f t)) ≤ M_ρ)
-    (ε₀ : ℝ) (hε₀_def : ε₀ = ‖gradW 0‖ + (L : ℝ) * M_ρ) :
-    ∀ σ ∈ Set.Icc (0 : ℝ) T,
-      (Integrable (fun y : PhysSpace d => ‖y‖) (spatialMarginal (f σ)))
-      ∧ (∀ x : PhysSpace d, Integrable (fun y => gradW (x - y)) (spatialMarginal (f σ)))
-      ∧ (∀ x : PhysSpace d,
-          ‖convolveFunctionMeasure gradW (spatialMarginal (f σ)) x‖ ≤ ε₀ + (L:ℝ) * ‖x‖)
-      ∧ Continuous (fun x => convolveFunctionMeasure gradW (spatialMarginal (f σ)) x) := by
-  intro σ hσ
-  have : IsProbabilityMeasure (f σ) := (hf_mom σ hσ).1
-  have hprob_m : IsProbabilityMeasure (spatialMarginal (f σ)) :=
-    (Measure.isProbabilityMeasure_map_iff measurable_fst.aemeasurable).mpr inferInstance
-  -- ‖·‖ integrable wrt the spatial marginal (from the finite first moment of f σ)
-  have h_y_int : Integrable (fun y : PhysSpace d => ‖y‖) (spatialMarginal (f σ)) := by
-    unfold spatialMarginal
-    rw [integrable_map_measure (continuous_norm.measurable).aestronglyMeasurable
-      measurable_fst.aemeasurable]
-    refine Integrable.mono' (hf_mom σ hσ).2
-      ((continuous_norm.comp continuous_fst).aestronglyMeasurable)
-      (Filter.Eventually.of_forall fun z => ?_)
-    change |‖z.1‖| ≤ ‖z‖
-    rw [abs_of_nonneg (norm_nonneg _)]; exact norm_fst_le z
-  -- force-integrability (Lipschitz growth + finite moment)
-  have h_int : ∀ x : PhysSpace d,
-      Integrable (fun y => gradW (x - y)) (spatialMarginal (f σ)) := by
-    intro x
-    have h_aesm : AEStronglyMeasurable (fun y : PhysSpace d => gradW (x - y))
-        (spatialMarginal (f σ)) :=
-      (hL.continuous.comp (continuous_const.sub continuous_id)).aestronglyMeasurable
-    have h_dom : ∀ y : PhysSpace d,
-        ‖gradW (x - y)‖ ≤ ‖gradW 0‖ + (L:ℝ) * ‖x‖ + (L:ℝ) * ‖y‖ := by
-      intro y
-      have hd := hL.dist_le_mul (x - y) 0
-      simp only [dist_eq_norm, sub_zero] at hd
-      have h_tri : ‖gradW (x - y)‖ ≤ ‖gradW 0‖ + ‖gradW (x - y) - gradW 0‖ := by
-        have := norm_add_le (gradW (x - y) - gradW 0) (gradW 0)
-        simp only [sub_add_cancel] at this; linarith
-      have h_sub_le : ‖x - y‖ ≤ ‖x‖ + ‖y‖ := norm_sub_le x y
-      have h_mul := mul_le_mul_of_nonneg_left h_sub_le L.coe_nonneg
-      linarith
-    have h_dom_int : Integrable
-        (fun y : PhysSpace d => ‖gradW 0‖ + (L:ℝ) * ‖x‖ + (L:ℝ) * ‖y‖)
-        (spatialMarginal (f σ)) := by
-      have h_eq : (fun y : PhysSpace d => ‖gradW 0‖ + (L:ℝ) * ‖x‖ + (L:ℝ) * ‖y‖)
-          = fun y => (‖gradW 0‖ + (L:ℝ) * ‖x‖) + (L:ℝ) * ‖y‖ := by funext y; ring
-      rw [h_eq]; exact (integrable_const _).add (h_y_int.const_mul _)
-    exact Integrable.mono' h_dom_int h_aesm (Filter.Eventually.of_forall h_dom)
-  -- field bound (CharFlow idiom)
-  have hbound : ∀ x : PhysSpace d,
-      ‖convolveFunctionMeasure gradW (spatialMarginal (f σ)) x‖ ≤ ε₀ + (L:ℝ) * ‖x‖ := by
-    intro x
-    unfold convolveFunctionMeasure
-    have h_sub_int : Integrable (fun y => ‖x - y‖) (spatialMarginal (f σ)) :=
-      Integrable.mono' ((integrable_const ‖x‖).add h_y_int)
-        ((aestronglyMeasurable_const (b := x)).sub aestronglyMeasurable_id |>.norm)
-        (Filter.Eventually.of_forall fun y => by
-          simp only [Real.norm_of_nonneg (norm_nonneg _)]; exact norm_sub_le x y)
-    have h_bnd_int : Integrable (fun y => ‖gradW 0‖ + (L:ℝ) * ‖x - y‖) (spatialMarginal (f σ)) :=
-      (integrable_const _).add (h_sub_int.const_mul _)
-    have h_pt : ∀ y, ‖gradW (x - y)‖ ≤ ‖gradW 0‖ + (L:ℝ) * ‖x - y‖ := by
-      intro y
-      have hd := hL.dist_le_mul (x - y) 0
-      simp only [dist_eq_norm, sub_zero] at hd
-      have h_tri : ‖gradW (x - y)‖ ≤ ‖gradW 0‖ + ‖gradW (x - y) - gradW 0‖ := by
-        have := norm_add_le (gradW (x - y) - gradW 0) (gradW 0)
-        simp only [sub_add_cancel] at this; linarith
-      linarith
-    calc ‖∫ y, gradW (x - y) ∂(spatialMarginal (f σ))‖
-        ≤ ∫ y, ‖gradW (x - y)‖ ∂(spatialMarginal (f σ)) := norm_integral_le_integral_norm _
-      _ ≤ ∫ y, (‖gradW 0‖ + (L:ℝ) * ‖x - y‖) ∂(spatialMarginal (f σ)) :=
-          integral_mono (h_int x).norm h_bnd_int (fun y => h_pt y)
-      _ = ‖gradW 0‖ + (L:ℝ) * ∫ y, ‖x - y‖ ∂(spatialMarginal (f σ)) := by
-          rw [integral_add (integrable_const _) (h_sub_int.const_mul _)]
-          simp [integral_const, measureReal_def, measure_univ, integral_const_mul]
-      _ ≤ ε₀ + (L:ℝ) * ‖x‖ := by
-          have h_int_le : ∫ y, ‖x - y‖ ∂(spatialMarginal (f σ)) ≤ ‖x‖ + M_ρ := by
-            calc ∫ y, ‖x - y‖ ∂(spatialMarginal (f σ))
-                ≤ ∫ y, (‖x‖ + ‖y‖) ∂(spatialMarginal (f σ)) :=
-                  integral_mono h_sub_int ((integrable_const _).add h_y_int)
-                    (fun y => norm_sub_le x y)
-              _ = ‖x‖ + ∫ y, ‖y‖ ∂(spatialMarginal (f σ)) := by
-                  rw [integral_add (integrable_const _) h_y_int]
-                  simp [integral_const, measureReal_def, measure_univ]
-              _ ≤ ‖x‖ + M_ρ := by linarith [hM_ρ σ hσ]
-          simp only [hε₀_def]
-          linarith [mul_le_mul_of_nonneg_left h_int_le (NNReal.coe_nonneg L)]
-  -- field continuity from the Lipschitz-in-x lemma
-  have hcont : Continuous (fun x => convolveFunctionMeasure gradW (spatialMarginal (f σ)) x) :=
-    (convolveFunctionMeasure_lipschitz_in_x gradW L hL (spatialMarginal (f σ)) h_int).continuous
-  exact ⟨h_y_int, h_int, hbound, hcont⟩
-
-omit [NeZero d] in
-open Filter Topology Metric in
-/-- Uniform convergence of integrands implies convergence of the integrals against
-a probability measure (every term integrable). -/
-lemma integral_tendsto_of_tendstoUniformly
-    (μ : Measure (PhaseSpace d)) [IsProbabilityMeasure μ]
-    (g : ℕ → PhaseSpace d → ℝ) (g₀ : PhaseSpace d → ℝ)
-    (hUnif : TendstoUniformly g g₀ atTop)
-    (hg₀_int : Integrable g₀ μ) (hg_int : ∀ n, Integrable (g n) μ) :
-    Tendsto (fun n => ∫ z, g n z ∂μ) atTop (𝓝 (∫ z, g₀ z ∂μ)) := by
-  rw [Metric.tendsto_atTop]
-  intro ε hε
-  obtain ⟨N, hN⟩ := eventually_atTop.mp
-    (Metric.tendstoUniformly_iff.mp hUnif (ε/2) (by positivity))
-  refine ⟨N, fun n hn => ?_⟩
-  rw [Real.dist_eq]
-  have hpt : ∀ z, |g n z - g₀ z| ≤ ε/2 := by
-    intro z
-    have h := hN n hn z
-    rw [Real.dist_eq, abs_sub_comm] at h
-    exact le_of_lt h
-  calc |∫ z, g n z ∂μ - ∫ z, g₀ z ∂μ|
-      = |∫ z, (g n z - g₀ z) ∂μ| := by rw [integral_sub (hg_int n) hg₀_int]
-    _ ≤ ∫ z, |g n z - g₀ z| ∂μ := abs_integral_le_integral_abs
-    _ ≤ ∫ _z, (ε/2) ∂μ :=
-        integral_mono_of_nonneg (Eventually.of_forall fun z => abs_nonneg _)
-          (integrable_const _) (Eventually.of_forall hpt)
-    _ = ε/2 := by simp
-    _ < ε := half_lt_self hε
-
--- #4 (Step 5 interface): the weak evolution equation extended to C¹_c test functions.
-open Filter Topology Metric in
-open scoped Convolution Pointwise in
-omit [NeZero d] in
-theorem weakEvolution_test_C1c_On
-    (gradW : PhysSpace d → PhysSpace d)
-    (f : ℝ → Measure (PhaseSpace d)) (T : ℝ)
-    (hf_weak : IsVlasovSolutionOn gradW f T)
-    (hf_mom : ∀ t ∈ Set.Icc (0 : ℝ) T, HasFiniteFirstMoment (f t))
-    -- B2 enrichment (mollification proof): the velocity-term needs a uniform-in-σ bound on the
-    -- frozen field `‖∇W∗ρ_σ‖` over the fixed compact support of the test, supplied by the
-    -- Lipschitz growth of `gradW` (`hL`) and the uniform first-moment bound `hM_ρ`.
-    (L : NNReal) (hL : LipschitzWith L gradW)
-    (M_ρ : ℝ) (hM_ρ_nn : 0 ≤ M_ρ)
-    (hM_ρ : ∀ t ∈ Set.Icc (0 : ℝ) T, ∫ y, ‖y‖ ∂(spatialMarginal (f t)) ≤ M_ρ)
-    (χ : PhaseSpace d → ℝ) (hχ_C1 : ContDiff ℝ 1 χ) (hχc : HasCompactSupport χ)
-    (gradXχ gradVχ : PhaseSpace d → PhysSpace d)
-    (hgradXχ : ∀ z, gradXχ z = gradient (fun x => χ (x, z.2)) z.1)
-    (hgradVχ : ∀ z, gradVχ z = gradient (fun v => χ (z.1, v)) z.2)
-    (s : ℝ) (hs : s ∈ Set.Ioo (0 : ℝ) T) :
-    HasDerivAt (fun σ => ∫ z, χ z ∂(f σ))
-      (∫ z, (@inner ℝ (PhysSpace d) _ z.2 (gradXχ z)
-             - @inner ℝ (PhysSpace d) _
-                (convolveFunctionMeasure gradW (spatialMarginal (f s)) z.1)
-                (gradVχ z)) ∂(f s)) s := by
-  classical
-  have hHaar : (volume : Measure (PhaseSpace d)).IsAddHaarMeasure := by
-    rw [show (volume : Measure (PhaseSpace d)) = (volume : Measure (PhysSpace d)).prod volume from
-      Measure.volume_eq_prod _ _]
-    infer_instance
-  have hvolReg : (volume : Measure (PhaseSpace d)).Regular :=
-    Measure.Regular.of_sigmaCompactSpace_of_isLocallyFiniteMeasure _
-  -- mollifier family (shrinking bumps); copy of #9's
-  set φ : ℕ → ContDiffBump (0 : PhaseSpace d) :=
-    fun n => ⟨1 / (n + 2), 2 / (n + 2), by positivity, by
-      rw [div_lt_div_iff_of_pos_right (by positivity)]; norm_num⟩ with hφ_def
-  have hrout : ∀ n, (φ n).rOut = 2 / (n + 2) := fun n => rfl
-  have hrout_tendsto : Tendsto (fun n => (φ n).rOut) atTop (𝓝 0) := by
-    simp only [hrout]
-    apply Filter.Tendsto.div_atTop (tendsto_const_nhds)
-    exact Filter.tendsto_atTop_add_const_right _ 2 tendsto_natCast_atTop_atTop
-  -- mollified test functions
-  set χn : ℕ → PhaseSpace d → ℝ :=
-    fun n => (φ n).normed volume ⋆[ContinuousLinearMap.lsmul ℝ ℝ, volume] χ with hχn_def
-  have hχn_smooth : ∀ n, ContDiff ℝ (⊤ : ℕ∞) (χn n) := fun n =>
-    ((φ n).hasCompactSupport_normed).contDiff_convolution_left _
-      (φ n).contDiff_normed hχ_C1.continuous.locallyIntegrable
-  have hχn_cs : ∀ n, HasCompactSupport (χn n) := fun n =>
-    HasCompactSupport.convolution _ (φ n).hasCompactSupport_normed hχc
-  -- genuine partial gradients of χ_n
-  set gXn : ℕ → PhaseSpace d → PhysSpace d :=
-    fun n z => gradient (fun x => χn n (x, z.2)) z.1 with hgXn_def
-  set gVn : ℕ → PhaseSpace d → PhysSpace d :=
-    fun n z => gradient (fun v => χn n (z.1, v)) z.2 with hgVn_def
-  -- D_n: the C^∞ weak-evolution derivative, from hf_weak applied to χ_n
-  have hDn : ∀ n, ∀ σ ∈ Set.Ioo (0 : ℝ) T, HasDerivAt (fun σ' => ∫ z, χn n z ∂(f σ'))
-      (∫ z, (@inner ℝ (PhysSpace d) _ z.2 (gXn n z)
-             - @inner ℝ (PhysSpace d) _
-                (convolveFunctionMeasure gradW (spatialMarginal (f σ)) z.1)
-                (gVn n z)) ∂(f σ)) σ := by
-    intro n σ hσ
-    have h := hf_weak (χn n) (hχn_smooth n) (hχn_cs n) (gXn n) (gVn n)
-      (fun z => rfl) (fun z => rfl) σ hσ
-    simpa using h
-  -- pointwise convergence (0th order): ∫ χ_n d(f σ) → ∫ χ d(f σ)
-  have hfg : ∀ σ ∈ Set.Ioo (0 : ℝ) T, Tendsto (fun n => ∫ z, χn n z ∂(f σ)) atTop
-      (𝓝 (∫ z, χ z ∂(f σ))) := by
-    intro σ hσ
-    have : IsProbabilityMeasure (f σ) := (hf_mom σ (Set.Ioo_subset_Icc_self hσ)).1
-    exact integral_tendsto_of_tendstoUniformly (f σ) χn χ
-      (mollifier_tendstoUniformly χ hχ_C1.continuous hχc φ hrout_tendsto)
-      (hχ_C1.continuous.integrable_of_hasCompactSupport hχc)
-      (fun n => (hχn_smooth n).continuous.integrable_of_hasCompactSupport (hχn_cs n))
-  -- uniform-in-σ convergence of the derivatives (the term bound)
-  -- Helper 2: uniform fderiv convergence
-  have hH2 := mollifiedFDeriv_tendstoUniformly χ hχ_C1 hχc φ hrout_tendsto
-  -- fixed compact K containing all supports
-  set K : Set (PhaseSpace d) := tsupport χ + Metric.closedBall (0 : PhaseSpace d) 1 with hK_def
-  have hK_compact : IsCompact K := IsCompact.add hχc (isCompact_closedBall 0 1)
-  obtain ⟨R0, hR0⟩ := (hK_compact.image continuous_norm).bddAbove
-  set R_K := max R0 0 with hRK_def
-  have hR_K_nn : (0 : ℝ) ≤ R_K := le_max_right _ _
-  have hR_K : ∀ z ∈ K, ‖z‖ ≤ R_K := fun z hz => le_trans (hR0 ⟨z, hz, rfl⟩) (le_max_left _ _)
-  -- tsupport χ ⊆ K, and fderiv χ vanishes off K
-  have htsuppχ_K : tsupport χ ⊆ K := by
-    intro z hz
-    rw [hK_def]
-    exact (add_zero z) ▸ Set.add_mem_add hz (by simp : (0:PhaseSpace d) ∈ Metric.closedBall 0 1)
-  have hsuppχ : ∀ z ∉ K, fderiv ℝ χ z = 0 := by
-    intro z hz
-    exact fderiv_of_notMem_tsupport ℝ (fun h => hz (htsuppχ_K h))
-  -- tsupport (χn n) ⊆ K, and fderiv (χn n) vanishes off K
-  have htsuppχn_K : ∀ n, tsupport (χn n) ⊆ K := by
-    intro n
-    have h1 : Function.support (χn n)
-        ⊆ Function.support ((φ n).normed volume) + Function.support χ :=
-      support_convolution_subset _
-    have h2 : Function.support ((φ n).normed volume) ⊆ Metric.closedBall 0 1 := by
-      rw [(φ n).support_normed_eq]
-      refine Metric.ball_subset_closedBall.trans (Metric.closedBall_subset_closedBall ?_)
-      rw [hrout n]; rw [div_le_one (by positivity)]; norm_num
-    have h4 : Function.support (χn n) ⊆ K := by
-      refine h1.trans ?_
-      rw [hK_def, add_comm (tsupport χ)]
-      exact Set.add_subset_add h2 (subset_tsupport χ)
-    exact (closure_minimal h4 hK_compact.isClosed)
-  have hsuppχn : ∀ n, ∀ z ∉ K, fderiv ℝ (χn n) z = 0 := by
-    intro n z hz
-    exact fderiv_of_notMem_tsupport ℝ (fun h => hz (htsuppχn_K n h))
-  -- partial-gradient projection bounds (X and V), off Helper 2's fderiv difference
-  -- field: integrability, bound, continuity — all on the window
-  set ε₀ : ℝ := ‖gradW 0‖ + (L : ℝ) * M_ρ with hε₀_def
-  have hε₀_nn : 0 ≤ ε₀ := by positivity
-  have hfield_setup := convolveField_window_setup gradW L hL f T hf_mom M_ρ hM_ρ ε₀ hε₀_def
-  -- THE ESTIMATE
-  -- continuity of the four partial gradients (off the uniform fderiv)
-  have htop : ((⊤ : ℕ∞) : WithTop ℕ∞) ≠ 0 := by simp
-  have hχdiff : Differentiable ℝ χ := hχ_C1.differentiable one_ne_zero
-  have hχ'cont : Continuous (fderiv ℝ χ) := hχ_C1.continuous_fderiv one_ne_zero
-  have hgXχc : Continuous gradXχ :=
-    continuous_gradientSlice_fst χ gradXχ hχdiff hχ'cont hgradXχ
-  have hgVχc : Continuous gradVχ :=
-    continuous_gradientSlice_snd χ gradVχ hχdiff hχ'cont hgradVχ
-  have hgXnc : ∀ n, Continuous (gXn n) := fun n => continuous_gradientSlice_fst (χn n) (gXn n)
-    ((hχn_smooth n).differentiable htop) ((hχn_smooth n).continuous_fderiv htop)
-    (fun z => by rw [hgXn_def])
-  have hgVnc : ∀ n, Continuous (gVn n) := fun n => continuous_gradientSlice_snd (χn n) (gVn n)
-    ((hχn_smooth n).differentiable htop) ((hχn_smooth n).continuous_fderiv htop)
-    (fun z => by rw [hgVn_def])
-  -- compact support of the four partial gradients (vanish off the test's support)
-  have hgXχcs : HasCompactSupport gradXχ :=
-    hasCompactSupport_gradientSlice_fst χ gradXχ hχdiff hχc hgradXχ
-  have hgVχcs : HasCompactSupport gradVχ :=
-    hasCompactSupport_gradientSlice_snd χ gradVχ hχdiff hχc hgradVχ
-  have hgXncs : ∀ n, HasCompactSupport (gXn n) := fun n =>
-    hasCompactSupport_gradientSlice_fst (χn n) (gXn n)
-      ((hχn_smooth n).differentiable htop) (hχn_cs n) (fun z => by rw [hgXn_def])
-  have hgVncs : ∀ n, HasCompactSupport (gVn n) := fun n =>
-    hasCompactSupport_gradientSlice_snd (χn n) (gVn n)
-      ((hχn_smooth n).differentiable htop) (hχn_cs n) (fun z => by rw [hgVn_def])
-  -- THE ESTIMATE
-  have hf'unif : TendstoUniformlyOn
-      (fun n σ => ∫ z, (@inner ℝ (PhysSpace d) _ z.2 (gXn n z)
-             - @inner ℝ (PhysSpace d) _
-                (convolveFunctionMeasure gradW (spatialMarginal (f σ)) z.1) (gVn n z)) ∂(f σ))
-      (fun σ => ∫ z, (@inner ℝ (PhysSpace d) _ z.2 (gradXχ z)
-             - @inner ℝ (PhysSpace d) _
-                (convolveFunctionMeasure gradW (spatialMarginal (f σ)) z.1) (gradVχ z)) ∂(f σ))
-      atTop (Set.Ioo 0 T) := by
-    rw [Metric.tendstoUniformlyOn_iff]
-    intro ε hε
-    set C : ℝ := R_K + (ε₀ + (L:ℝ) * R_K) with hC_def
-    have hC_nn : (0 : ℝ) ≤ C := by rw [hC_def]; positivity
-    rw [Metric.tendstoUniformly_iff] at hH2
-    filter_upwards [hH2 (ε/(C+1)) (by positivity)] with n hn
-    intro σ hσ
-    have hσ' : σ ∈ Set.Icc (0 : ℝ) T := Set.Ioo_subset_Icc_self hσ
-    have : IsProbabilityMeasure (f σ) := (hf_mom σ hσ').1
-    obtain ⟨_, _, hbnd, hfc⟩ := hfield_setup σ hσ'
-    -- L15: make the field opaque so defeq never unfolds its Bochner integral
-    set fldσ : PhysSpace d → PhysSpace d := convolveFunctionMeasure gradW (spatialMarginal (f σ))
-      with hfldσ_def
-    clear_value fldσ
-    -- projection bounds for this n
-    have hXp : ∀ z, ‖gXn n z - gradXχ z‖ ≤ ‖fderiv ℝ (χn n) z - fderiv ℝ χ z‖ :=
-      fun z => gradientSlice_fst_sub_norm_le (χn n) χ
-        ((hχn_smooth n).differentiable htop) hχdiff (gXn n) gradXχ
-        (fun z => by rw [hgXn_def]) hgradXχ z
-    have hVp : ∀ z, ‖gVn n z - gradVχ z‖ ≤ ‖fderiv ℝ (χn n) z - fderiv ℝ χ z‖ :=
-      fun z => gradientSlice_snd_sub_norm_le (χn n) χ
-        ((hχn_smooth n).differentiable htop) hχdiff (gVn n) gradVχ
-        (fun z => by rw [hgVn_def]) hgradVχ z
-    -- uniform fderiv bound at this n (uses χn = the convolution defeq, before clearing)
-    have hfd_le : ∀ z, ‖fderiv ℝ (χn n) z - fderiv ℝ χ z‖ ≤ ε/(C+1) := by
-      intro z
-      have h := hn z
-      rw [dist_eq_norm, norm_sub_rev] at h
-      exact le_of_lt h
-    -- L15: with the projection + fderiv bounds proven, make the heavy convolution defs opaque so
-    -- the integrand-difference manipulations never unfold their Bochner integrals
-    clear_value gXn gVn χn
-    -- off K both gradient pairs agree (fderivs vanish there)
-    have hXoff : ∀ z ∉ K, gXn n z = gradXχ z := by
-      intro z hzK
-      have hfd0 : fderiv ℝ (χn n) z = 0 := hsuppχn n z hzK
-      have hfd0' : fderiv ℝ χ z = 0 := hsuppχ z hzK
-      have := hXp z; rw [hfd0, hfd0', sub_self, norm_zero] at this
-      exact sub_eq_zero.mp (norm_le_zero_iff.mp this)
-    have hVoff : ∀ z ∉ K, gVn n z = gradVχ z := by
-      intro z hzK
-      have hfd0 : fderiv ℝ (χn n) z = 0 := hsuppχn n z hzK
-      have hfd0' : fderiv ℝ χ z = 0 := hsuppχ z hzK
-      have := hVp z; rw [hfd0, hfd0', sub_self, norm_zero] at this
-      exact sub_eq_zero.mp (norm_le_zero_iff.mp this)
-    -- field bound on K
-    have hfld_K : ∀ z ∈ K, ‖fldσ (Prod.fst z)‖ ≤ ε₀ + (L:ℝ) * R_K := by
-      intro z hzK
-      refine le_trans (hbnd z.1) ?_
-      have : ‖z.1‖ ≤ R_K := le_trans (norm_fst_le z) (hR_K z hzK)
-      gcongr
-    -- pointwise bound on the integrand difference
-    have hpt : ∀ z, ‖(@inner ℝ (PhysSpace d) _ z.2 (gradXχ z)
-          - @inner ℝ (PhysSpace d) _ (fldσ z.1)
-              (gradVχ z))
-        - (@inner ℝ (PhysSpace d) _ z.2 (gXn n z)
-          - @inner ℝ (PhysSpace d) _ (fldσ z.1)
-              (gVn n z))‖ ≤ C * (ε/(C+1)) := by
-      intro z
-      have h := inner_integrand_sub_norm_le K R_K hR_K_nn hR_K fldσ
-        (ε₀ + (L:ℝ) * R_K) (by positivity) hfld_K
-        gradXχ gradVχ (gXn n) (gVn n) (ε/(C+1)) (by positivity)
-        (fun z => le_trans (hXp z) (hfd_le z)) (fun z => le_trans (hVp z) (hfd_le z))
-        hXoff hVoff z
-      refine le_trans h (le_of_eq ?_)
-      rw [hC_def]
-    -- integrability of both integrands (continuous + compact support in K)
-    have hGd_int := inner_integrand_integrable (f σ) fldσ hfc gradXχ gradVχ
-      hgXχc hgVχc hgXχcs hgVχcs
-    have hGnd_int := inner_integrand_integrable (f σ) fldσ hfc (gXn n) (gVn n)
-      (hgXnc n) (hgVnc n) (hgXncs n) (hgVncs n)
-    -- assemble
-    rw [Real.dist_eq, ← integral_sub hGd_int hGnd_int]
-    calc |∫ z, ((@inner ℝ (PhysSpace d) _ z.2 (gradXχ z)
-            - @inner ℝ (PhysSpace d) _ (fldσ z.1)
-                (gradVχ z))
-          - (@inner ℝ (PhysSpace d) _ z.2 (gXn n z)
-            - @inner ℝ (PhysSpace d) _ (fldσ z.1)
-                (gVn n z))) ∂(f σ)|
-        ≤ ∫ z, C * (ε/(C+1)) ∂(f σ) := by
-          refine le_trans (abs_integral_le_integral_abs) ?_
-          refine integral_mono_of_nonneg (Filter.Eventually.of_forall fun z => abs_nonneg _)
-            (integrable_const _) (Filter.Eventually.of_forall fun z => ?_)
-          have := hpt z; rwa [Real.norm_eq_abs] at this
-      _ = C * (ε/(C+1)) := by simp
-      _ < ε := by
-          have h1 : (0 : ℝ) < C + 1 := by positivity
-          rw [← mul_div_assoc, div_lt_iff₀ h1]
-          nlinarith [hε, hC_nn]
-  -- assemble via the uniform-limit-of-derivatives theorem
-  exact hasDerivAt_of_tendstoUniformlyOn isOpen_Ioo hf'unif (Eventually.of_forall hDn) hfg hs
-
--- NC (consumption form): integral of a jointly-continuous, uniformly-compactly-supported
--- family against the weak-solution measure curve is continuous in time.
-omit [NeZero d] in
-theorem vlasovSolutionOn_integral_continuousOn
-    (f : ℝ → Measure (PhaseSpace d)) (T : ℝ)
-    (hf_mom : ∀ t ∈ Set.Icc (0 : ℝ) T, HasFiniteFirstMoment (f t))
-    (hf_narrow : ∀ (g : PhaseSpace d → ℝ), Continuous g → HasCompactSupport g →
-      ContinuousOn (fun s => ∫ z, g z ∂(f s)) (Set.Icc 0 T))
-    (G : ℝ → PhaseSpace d → ℝ)
-    (hG_cont : Continuous (fun p : ℝ × PhaseSpace d => G p.1 p.2))
-    (K : Set (PhaseSpace d)) (hK : IsCompact K)
-    (hG_supp : ∀ s, ∀ z ∉ K, G s z = 0) :
-    ContinuousOn (fun s => ∫ z, G s z ∂(f s)) (Set.Icc (0 : ℝ) T) := by
-  -- Each slice G a is continuous, supported in K, hence integrable wrt the probability f b.
-  have hGs_cont : ∀ a : ℝ, Continuous (fun z => G a z) := fun a =>
-    hG_cont.comp (Continuous.prodMk_right a)
-  have hGs_cs : ∀ a : ℝ, HasCompactSupport (fun z => G a z) := by
-    intro a
-    have hsub : tsupport (fun z => G a z) ⊆ K :=
-      closure_minimal (fun z hz => by by_contra hzK; exact hz (hG_supp a z hzK)) hK.isClosed
-    exact IsCompact.of_isClosed_subset hK (isClosed_tsupport _) hsub
-  have hGint : ∀ (a b : ℝ), b ∈ Set.Icc (0 : ℝ) T → Integrable (fun z => G a z) (f b) := by
-    intro a b hb
-    have := (hf_mom b hb).1
-    exact (hGs_cont a).integrable_of_hasCompactSupport (hGs_cs a)
-  -- Uniform continuity of the uncurried G on the compact Icc 0 T ×ˢ K.
-  have hC : IsCompact (Set.Icc (0 : ℝ) T ×ˢ K) := isCompact_Icc.prod hK
-  have hG_uc : UniformContinuousOn (fun p : ℝ × PhaseSpace d => G p.1 p.2)
-      (Set.Icc (0 : ℝ) T ×ˢ K) :=
-    hC.uniformContinuousOn_of_continuous hG_cont.continuousOn
-  rw [Metric.uniformContinuousOn_iff] at hG_uc
-  -- Main ε–δ.
-  rw [Metric.continuousOn_iff]
-  intro s₀ hs₀ ε hε
-  obtain ⟨δ₁, hδ₁, hδ₁_prop⟩ := hG_uc (ε/2) (by positivity)
-  -- term2: narrow continuity of f tested against the frozen g := G s₀.
-  have hterm2 : ContinuousWithinAt (fun s => ∫ z, G s₀ z ∂(f s)) (Set.Icc 0 T) s₀ :=
-    (hf_narrow (fun z => G s₀ z) (hGs_cont s₀) (hGs_cs s₀)) s₀ hs₀
-  rw [Metric.continuousWithinAt_iff] at hterm2
-  obtain ⟨δ₂, hδ₂, hδ₂_prop⟩ := hterm2 (ε/2) (by positivity)
-  refine ⟨min δ₁ δ₂, lt_min hδ₁ hδ₂, fun s hs hsd => ?_⟩
-  have hp_s : IsProbabilityMeasure (f s) := (hf_mom s hs).1
-  have hsd1 : dist s s₀ < δ₁ := lt_of_lt_of_le hsd (min_le_left _ _)
-  have hsd2 : dist s s₀ < δ₂ := lt_of_lt_of_le hsd (min_le_right _ _)
-  -- pointwise: |G s z - G s₀ z| ≤ ε/2 (uniform continuity on K; both zero off K)
-  have hpoint : ∀ z, |G s z - G s₀ z| ≤ ε/2 := by
-    intro z
-    by_cases hzK : z ∈ K
-    · have hp : ((s, z) : ℝ × PhaseSpace d) ∈ Set.Icc (0 : ℝ) T ×ˢ K := ⟨hs, hzK⟩
-      have hq : ((s₀, z) : ℝ × PhaseSpace d) ∈ Set.Icc (0 : ℝ) T ×ˢ K := ⟨hs₀, hzK⟩
-      have hdpq : dist ((s, z) : ℝ × PhaseSpace d) (s₀, z) < δ₁ := by
-        rw [Prod.dist_eq]
-        exact max_lt hsd1 (by rw [dist_self]; exact hδ₁)
-      have hlt := hδ₁_prop _ hp _ hq hdpq
-      rw [Real.dist_eq] at hlt
-      exact le_of_lt hlt
-    · rw [hG_supp s z hzK, hG_supp s₀ z hzK, sub_zero, abs_zero]; positivity
-  -- split the s-integral
-  have key : ∫ z, G s z ∂(f s) - ∫ z, G s₀ z ∂(f s)
-      = ∫ z, (G s z - G s₀ z) ∂(f s) :=
-    (integral_sub (hGint s s hs) (hGint s₀ s hs)).symm
-  have hfirst : dist (∫ z, G s z ∂(f s)) (∫ z, G s₀ z ∂(f s)) ≤ ε/2 := by
-    rw [Real.dist_eq, key]
-    calc |∫ z, (G s z - G s₀ z) ∂(f s)|
-        ≤ ∫ z, |G s z - G s₀ z| ∂(f s) := by
-            have h := norm_integral_le_integral_norm (μ := f s) (fun z => G s z - G s₀ z)
-            simpa only [Real.norm_eq_abs] using h
-      _ ≤ ∫ _z, (ε/2) ∂(f s) :=
-            integral_mono (((hGint s s hs).sub (hGint s₀ s hs)).abs)
-              (integrable_const _) hpoint
-      _ = ε/2 := by simp
-  have hsecond : dist (∫ z, G s₀ z ∂(f s)) (∫ z, G s₀ z ∂(f s₀)) < ε/2 :=
-    hδ₂_prop hs hsd2
-  calc dist (∫ z, G s z ∂(f s)) (∫ z, G s₀ z ∂(f s₀))
-      ≤ dist (∫ z, G s z ∂(f s)) (∫ z, G s₀ z ∂(f s))
-        + dist (∫ z, G s₀ z ∂(f s)) (∫ z, G s₀ z ∂(f s₀)) := dist_triangle _ _ _
-    _ < ε/2 + ε/2 := add_lt_add_of_le_of_lt hfirst hsecond
-    _ = ε := by ring
-
 -- ── Helpers for `transportedIntegral_hasDerivAt_zero`, extracted from its proof body. ──
 
 omit [NeZero d] in
diff --git a/LeanPool/Vlasov/OT/WellPosedness.lean b/LeanPool/Vlasov/OT/WellPosedness.lean
index e927c6b8bc..abe857238d 100644
--- a/LeanPool/Vlasov/OT/WellPosedness.lean
+++ b/LeanPool/Vlasov/OT/WellPosedness.lean
@@ -5,12 +5,11 @@ Authors: Joseph K. Miller
 -/
 module
 
-public import LeanPool.Vlasov.OT.CharacteristicFlow
+public import LeanPool.Vlasov.OT.Continuation
+import all LeanPool.Vlasov.OT.Continuation
+import all LeanPool.Vlasov.OT.LocalWellPosedness
 import Mathlib.Algebra.Order.Ring.Star
 import Mathlib.Analysis.Calculus.Deriv.Prod
-import Mathlib.Analysis.Calculus.FDeriv.Extend
-import Mathlib.Analysis.SpecialFunctions.Trigonometric.Arctan
-import Mathlib.MeasureTheory.Covering.Besicovitch
 
 /-!
 # Well-posedness ladder for the Vlasov equation + Dobrushin stability
@@ -44,4339 +43,99 @@ namespace Vlasov
 
 open MeasureTheory ENNReal
 
-/-! ## §9  Theorem (Existence and uniqueness for Vlasov)   (tex: thm:vlasov-wp) -/
--- The proof composes directly with the characteristic-flow infrastructure
--- developed in `LeanPool/Vlasov/OT/CharacteristicFlow.lean`: `exists_vlasov_characteristicFlow`,
--- `flow_distance_growth_bound`, and
--- `vlasovSolutionViaPushforward_isLagrangianVlasovSolution`.  The
--- `HasFiniteFirstMoment` predicate remains in `Basic.lean`.
+-- Preserve existing private names when moving their proofs.
+private alias envelopeStep_contractionInputs :=
+  _root_.Vlasov.envelopeStep_contractionInputs
 
-/-- **Project-internal: AEMeasurability of the Vlasov characteristic flow's
-joint map** `z ↦ (charX s z, charV s z)` on the window `Icc 0 T`.
+private alias picardCharFlow_aemeasurable :=
+  _root_.Vlasov.picardCharFlow_aemeasurable
 
-The window-restricted statement (`Icc 0 T`) is exactly what is needed: the
-Vlasov flow satisfies `HasDerivAt` only on `Ioo 0 T` (off-window it is
-uncontrolled `Classical.choose` data), and the sole consumer applies this
-only at `clampToIcc T s ∈ Icc 0 T`.  On the window the joint flow's
-measurability follows from `charFlow_measurable_via_gronwall` (genuine
-`Measurable`, via the boundary bundle through
-`characteristicFlow_boundary_regularity`).
+private alias picardFlow_clamp_bundle :=
+  _root_.Vlasov.picardFlow_clamp_bundle
 
-**In-project consumer**: `vlasovWellPosedness_local_picard_fixedPointFlow`'s
-AEMeasurable conjunct, applied at clamp times `clampToIcc T s ∈ Icc 0 T`. -/
-private lemma picardCharFlow_aemeasurable
-    {d : ℕ}
-    (gradW : PhysSpace d → PhysSpace d)
-    (L : NNReal) (hL : LipschitzWith L gradW)
-    (ρ : ℝ → Measure (PhysSpace d)) [∀ t, IsProbabilityMeasure (ρ t)]
-    (h_int : ∀ t (x : PhysSpace d), Integrable (fun y => gradW (x - y)) (ρ t))
-    (charX charV : ℝ → PhaseSpace d → PhysSpace d)
-    {T : ℝ} (hT : 0 ≤ T)
-    (hflow : IsCharacteristicFlowOn gradW ρ charX charV (Set.Ioo 0 T) Set.univ)
-    (hbdry : ∀ z : PhaseSpace d, ∀ t ∈ Set.Icc (0 : ℝ) T,
-        HasDerivWithinAt (fun s => charX s z) (charV t z) (Set.Icc 0 T) t ∧
-        HasDerivWithinAt (fun s => charV s z)
-          (-(convolveFunctionMeasure gradW (ρ t) (charX t z))) (Set.Icc 0 T) t)
-    (μ : Measure (PhaseSpace d)) :
-    ∀ s ∈ Set.Icc (0 : ℝ) T,
-      AEMeasurable (fun z : PhaseSpace d => (charX s z, charV s z)) μ := by
-  intro s hs
-  obtain ⟨h_init, h_cont, h_deriv⟩ :=
-    characteristicFlow_boundary_regularity gradW ρ charX charV T hT hflow hbdry
-  exact (charFlow_measurable_via_gronwall gradW L hL ρ h_int charX charV T hT
-    h_init h_cont h_deriv s hs).aemeasurable
-
-/-- **Contraction-input helper**: from a flow's exposed facts (`IsCharacteristicFlowOn`
-on `Ioo` + the boundary bundle on `Icc` — the `Phi_step_envelope` output shape)
-against a curve `ν`, derive the six per-`z` regularity facts that
-`Phi_supW1_contraction` consumes.  Chains `characteristicFlow_boundary_regularity`
-(→ init/cont/deriv, the last three EXACT), `charFlow_measurable_via_gronwall`
-(→ AEMeasurable), and `flow_distance_growth_bound_on` (→ growth bound, integrated
-to the two integrability facts). -/
-private lemma envelopeStep_contractionInputs {d : ℕ} [NeZero d]
-    (gradW : PhysSpace d → PhysSpace d) (L : NNReal) (hL : LipschitzWith L gradW)
-    (f₀ : Measure (PhaseSpace d)) [IsProbabilityMeasure f₀]
-    (h_f₀_int : Integrable (fun z : PhaseSpace d => ‖z‖) f₀)
-    {T : ℝ} (hT : 0 ≤ T) {m : ℝ → ℝ}
-    (ν : VlasovMeasureCurve d T m)
-    (Mbar : ℝ) (hMbar_nn : 0 ≤ Mbar)
-    (hM_ρ : ∀ t ∈ Set.Icc (0 : ℝ) T, ∫ y, ‖y‖ ∂(ν.extend t) ≤ Mbar)
-    (cX cV : ℝ → PhaseSpace d → PhysSpace d)
-    (hflow : IsCharacteristicFlowOn gradW ν.extend cX cV (Set.Ioo 0 T) Set.univ)
-    (hbdry : ∀ z : PhaseSpace d, ∀ t ∈ Set.Icc (0 : ℝ) T,
-        HasDerivWithinAt (fun s => cX s z) (cV t z) (Set.Icc 0 T) t ∧
-        HasDerivWithinAt (fun s => cV s z)
-          (-(convolveFunctionMeasure gradW (ν.extend t) (cX t z))) (Set.Icc 0 T) t)
-    (h_int_ext : ∀ t (x : PhysSpace d),
-        Integrable (fun y => gradW (x - y)) (ν.extend t)) :
-    (∀ t ∈ Set.Icc (0 : ℝ) T, AEMeasurable (fun z : PhaseSpace d => cX t z) f₀) ∧
-    (∀ t ∈ Set.Icc (0 : ℝ) T, Integrable (fun z : PhaseSpace d => ‖cX t z‖) f₀) ∧
-    (∀ t ∈ Set.Icc (0 : ℝ) T,
-      Integrable (fun y : PhysSpace d => ‖y‖) (Measure.map (fun z => cX t z) f₀)) ∧
-    (∀ z : PhaseSpace d, (cX 0 z, cV 0 z) = z) ∧
-    (∀ z : PhaseSpace d,
-      ContinuousOn (fun s => (cX s z, cV s z)) (Set.Icc (0 : ℝ) T)) ∧
-    (∀ z : PhaseSpace d, ∀ s ∈ Set.Ico (0 : ℝ) T,
-      HasDerivWithinAt (fun s' => (cX s' z, cV s' z))
-        (vlasovVectorField gradW (ν.extend) s (cX s z, cV s z))
-        (Set.Ici s) s) := by
-  have : ∀ t, IsProbabilityMeasure (ν.extend t) := VlasovMeasureCurve.extend_isProb ν
-  obtain ⟨h_init, h_cont, h_deriv⟩ :=
-    characteristicFlow_boundary_regularity gradW ν.extend cX cV T hT hflow hbdry
-  have h_meas : ∀ t ∈ Set.Icc (0 : ℝ) T,
-      AEMeasurable (fun z : PhaseSpace d => cX t z) f₀ := by
-    have h_meas_Icc := charFlow_measurable_via_gronwall gradW L hL ν.extend h_int_ext
-      cX cV T hT h_init h_cont h_deriv
-    exact fun t ht => (measurable_fst.comp (h_meas_Icc t ht)).aemeasurable
-  obtain ⟨C_T, hC_T_nn, h_growth⟩ :=
-    flow_distance_growth_bound_on gradW L hL ν.extend cX cV T hT
-      h_init h_cont h_deriv Mbar hMbar_nn hM_ρ
-      (fun t _ => VlasovMeasureCurve.extend_yIntegrable hT ν t) h_int_ext
-  have h_int_charX : ∀ t ∈ Set.Icc (0 : ℝ) T,
-      Integrable (fun z : PhaseSpace d => ‖cX t z‖) f₀ := by
-    intro t ht
-    have h_dom_int : Integrable (fun z : PhaseSpace d => C_T * (‖z‖ + 1)) f₀ := by
-      have h1 : Integrable (fun z : PhaseSpace d => C_T * ‖z‖) f₀ := h_f₀_int.const_mul C_T
-      have h2 : Integrable (fun _ : PhaseSpace d => C_T) f₀ := integrable_const _
-      have h_eq : (fun z : PhaseSpace d => C_T * (‖z‖ + 1)) = fun z => C_T * ‖z‖ + C_T := by
-        funext z; ring
-      rw [h_eq]; exact h1.add h2
-    refine h_dom_int.mono' (h_meas t ht).norm.aestronglyMeasurable ?_
-    refine Filter.Eventually.of_forall fun z => ?_
-    rw [Real.norm_of_nonneg (norm_nonneg _)]
-    exact le_trans (norm_fst_le (cX t z, cV t z)) (h_growth t ht z)
-  have h_yint_Phi : ∀ t ∈ Set.Icc (0 : ℝ) T,
-      Integrable (fun y : PhysSpace d => ‖y‖) (Measure.map (fun z => cX t z) f₀) := by
-    intro t ht
-    rw [integrable_map_measure continuous_norm.aestronglyMeasurable (h_meas t ht)]
-    exact h_int_charX t ht
-  exact ⟨h_meas, h_int_charX, h_yint_Phi, h_init, h_cont, h_deriv⟩
-
-/-- Lipschitz growth of the force plus a first moment of the measure make the
-shifted force integrable.  The workhorse integrability fact behind every
-`convolveFunctionMeasure` estimate. -/
-lemma integrable_gradW_shift
-    {d : ℕ}
-    (gradW : PhysSpace d → PhysSpace d)
-    (L : NNReal) (hL : LipschitzWith L gradW)
-    (μ : Measure (PhysSpace d)) [MeasureTheory.IsFiniteMeasure μ]
-    (h_yint : Integrable (fun y : PhysSpace d => ‖y‖) μ)
-    (xp : PhysSpace d) :
-    Integrable (fun y => gradW (xp - y)) μ := by
-  have h_aesm : AEStronglyMeasurable (fun y : PhysSpace d => gradW (xp - y)) μ :=
-    (hL.continuous.comp (continuous_const.sub continuous_id)).aestronglyMeasurable
-  have h_dom : ∀ y : PhysSpace d, ‖gradW (xp - y)‖ ≤
-      ‖gradW 0‖ + (L : ℝ) * ‖xp‖ + (L : ℝ) * ‖y‖ := by
-    intro y
-    have hd := hL.dist_le_mul (xp - y) 0
-    simp only [dist_eq_norm, sub_zero] at hd
-    have h_tri : ‖gradW (xp - y)‖ ≤ ‖gradW 0‖ + ‖gradW (xp - y) - gradW 0‖ := by
-      have := norm_add_le (gradW (xp - y) - gradW 0) (gradW 0)
-      simp only [sub_add_cancel] at this; linarith
-    have h_sub_le : ‖xp - y‖ ≤ ‖xp‖ + ‖y‖ := norm_sub_le xp y
-    have h_mul := mul_le_mul_of_nonneg_left h_sub_le L.coe_nonneg
-    linarith
-  have h_dom_int : Integrable
-      (fun y : PhysSpace d => ‖gradW 0‖ + (L : ℝ) * ‖xp‖ + (L : ℝ) * ‖y‖) μ := by
-    have h_eq : (fun y : PhysSpace d => ‖gradW 0‖ + (L : ℝ) * ‖xp‖ + (L : ℝ) * ‖y‖) =
-                fun y => (‖gradW 0‖ + (L : ℝ) * ‖xp‖) + (L : ℝ) * ‖y‖ := by funext y; ring
-    rw [h_eq]; exact (integrable_const _).add (h_yint.const_mul _)
-  exact h_dom_int.mono' h_aesm (Filter.Eventually.of_forall fun y => h_dom y)
-
-/-- `LocalSmallnessContraction L T` IS the Grönwall contraction factor
-`gronwallBound 0 (max 1 L) L T < 1`, after unfolding both definitions. -/
-lemma LocalSmallnessContraction.gronwallBound_lt_one
-    {L : NNReal} {T : ℝ} (hTL_con : LocalSmallnessContraction L T) :
-    gronwallBound 0 ((max 1 L : NNReal) : ℝ) (L : ℝ) T < 1 := by
-  have hK_pos : (0 : ℝ) < ((max 1 L : NNReal) : ℝ) := by
-    have : (1 : ℝ) ≤ ((max 1 L : NNReal) : ℝ) := by
-      rw [NNReal.coe_max, NNReal.coe_one]; exact le_max_left _ _
-    linarith
-  have hK_ne : ((max 1 L : NNReal) : ℝ) ≠ 0 := ne_of_gt hK_pos
-  rw [gronwallBound_of_K_ne_0 hK_ne]
-  simp only [zero_mul, zero_add]
-  have h_eq : (L : ℝ) / ((max 1 L : NNReal) : ℝ) *
-      (Real.exp (((max 1 L : NNReal) : ℝ) * T) - 1) =
-      (L : ℝ) * (Real.exp ((max 1 (L : ℝ)) * T) - 1) / (max 1 (L : ℝ)) := by
-    rw [NNReal.coe_max, NNReal.coe_one]
-    ring
-  rw [h_eq]
-  exact hTL_con
-
-/-- The Picard sequence of the local fixed-point construction, with its exposed
-per-step flows and the geometric contraction bound.  Extracted from
-`vlasovWellPosedness_local_picard_fixedPointFlow`; the parameters `q` (the
-contraction factor) and `D₀` (the initial `W₁`-input bound) are threaded with
-their defining equations so the parent's `let`-definitions supply `rfl`. -/
-private lemma vlasovWellPosedness_local_picard_sequence
-    {d : ℕ} [NeZero d]
-    (W : PhysSpace d → ℝ)
-    (gradW : PhysSpace d → PhysSpace d)
-    (hgradW : ∀ x, gradW x = gradient W x)
-    (L : NNReal) (hL : LipschitzWith L gradW)
-    (f₀ : Measure (PhaseSpace d)) [IsProbabilityMeasure f₀]
-    (hf₀_int : Integrable (fun z : PhaseSpace d => ‖z‖) f₀)
-    {T : ℝ} (hT : 0 < T)
-    (hTL_PL : LocalSmallnessPLBuffer L T)
-    (m : ℝ → ℝ) (hm_mono : MonotoneOn m (Set.Icc 0 T))
-    (hm_nn : ∀ t ∈ Set.Icc (0 : ℝ) T, 0 ≤ m t)
-    (hm_inv : ∀ t ∈ Set.Icc (0 : ℝ) T,
-      gronwallBound (∫ z, ‖z‖ ∂f₀) (1 + (L : ℝ)) (‖gradW 0‖ + (L : ℝ) * m t) t ≤ m t)
-    (hMbar_nn : 0 ≤ m T) (hMbar_mono : ∀ t ∈ Set.Icc (0 : ℝ) T, m t ≤ m T)
-    (hμ₀_prob : IsProbabilityMeasure (spatialMarginal f₀))
-    (hμ₀_int : Integrable (fun y : PhysSpace d => ‖y‖) (spatialMarginal f₀))
-    (hμ₀_le_m : ∀ t ∈ Set.Icc (0 : ℝ) T, ∫ y, ‖y‖ ∂(spatialMarginal f₀) ≤ m t)
-    (q : ℝ) (hq_nn : 0 ≤ q)
-    (hq_def : q = gronwallBound 0 ((max 1 L : NNReal) : ℝ) (L : ℝ) T)
-    (D₀ : ℝ) (hD₀_nn : 0 ≤ D₀) (hD₀_def : D₀ = 2 * (m T)) :
-    ∃ (x : ℕ → VlasovMeasureCurve d T m)
-      (charXs charVs : ℕ → ℝ → PhaseSpace d → PhysSpace d),
-      (∀ k, supW1On (Set.Icc 0 T) (x k).ρ (x (k + 1)).ρ ≤
-            ENNReal.ofReal (q ^ k * D₀)) ∧
-      (∀ k,
-        IsCharacteristicFlowOn gradW (x k).extend (charXs k) (charVs k)
-          (Set.Ioo 0 T) Set.univ ∧
-        (∀ z : PhaseSpace d, ∀ t ∈ Set.Icc (0 : ℝ) T,
-          HasDerivWithinAt (fun s => charXs k s z) (charVs k t z) (Set.Icc 0 T) t ∧
-          HasDerivWithinAt (fun s => charVs k s z)
-            (-(convolveFunctionMeasure gradW ((x k).extend t) (charXs k t z)))
-            (Set.Icc 0 T) t) ∧
-        (∀ t ∈ Set.Icc (0 : ℝ) T,
-          (x (k + 1)).ρ t
-            = Measure.map (fun z : PhaseSpace d => charXs k t z) f₀)) := by
-  have h_int_ext_gen : ∀ (ν : VlasovMeasureCurve d T m) (t : ℝ) (xp : PhysSpace d),
-      Integrable (fun y => gradW (xp - y)) (ν.extend t) := fun ν t xp =>
-    integrable_gradW_shift gradW L hL (ν.extend t)
-      (VlasovMeasureCurve.extend_yIntegrable hT.le ν t) xp
-  have step : ∀ (ν : VlasovMeasureCurve d T m),
-      ∃ (σ : VlasovMeasureCurve d T m) (cX cV : ℝ → PhaseSpace d → PhysSpace d),
-        (∀ t ∈ Set.Icc (0 : ℝ) T, σ.ρ t = Measure.map (fun z => cX t z) f₀) ∧
-        IsCharacteristicFlowOn gradW ν.extend cX cV (Set.Ioo 0 T) Set.univ ∧
-        (∀ z : PhaseSpace d, ∀ t ∈ Set.Icc (0 : ℝ) T,
-          HasDerivWithinAt (fun s => cX s z) (cV t z) (Set.Icc 0 T) t ∧
-          HasDerivWithinAt (fun s => cV s z)
-            (-(convolveFunctionMeasure gradW (ν.extend t) (cX t z))) (Set.Icc 0 T) t) := by
-    intro ν
-    obtain ⟨cX, cV, hflow, hbdry, σ, hσ⟩ :=
-      Phi_step_envelope W gradW hgradW L hL f₀ hf₀_int hT.le m hm_mono hm_nn hm_inv hTL_PL
-        ν (h_int_ext_gen ν)
-    exact ⟨σ, cX, cV, hσ, hflow, hbdry⟩
-  have hμ₀_prob_inst : IsProbabilityMeasure (spatialMarginal f₀) := hμ₀_prob
-  let base : VlasovMeasureCurve d T m := constantCurve (spatialMarginal f₀) hμ₀_int hμ₀_le_m
-  let x : ℕ → VlasovMeasureCurve d T m :=
-    fun n => Nat.rec base (fun _ ν => Classical.choose (step ν)) n
-  let charXs : ℕ → ℝ → PhaseSpace d → PhysSpace d :=
-    fun k => Classical.choose (Classical.choose_spec (step (x k)))
-  let charVs : ℕ → ℝ → PhaseSpace d → PhysSpace d :=
-    fun k => Classical.choose (Classical.choose_spec (Classical.choose_spec (step (x k))))
-  have hx_succ : ∀ k, x (k + 1) = Classical.choose (step (x k)) := fun _ => rfl
-  have hspec : ∀ k,
-      (∀ t ∈ Set.Icc (0 : ℝ) T,
-        (Classical.choose (step (x k))).ρ t = Measure.map (fun z => charXs k t z) f₀) ∧
-      IsCharacteristicFlowOn gradW (x k).extend (charXs k) (charVs k)
-        (Set.Ioo 0 T) Set.univ ∧
-      (∀ z : PhaseSpace d, ∀ t ∈ Set.Icc (0 : ℝ) T,
-        HasDerivWithinAt (fun s => charXs k s z) (charVs k t z) (Set.Icc 0 T) t ∧
-        HasDerivWithinAt (fun s => charVs k s z)
-          (-(convolveFunctionMeasure gradW ((x k).extend t) (charXs k t z)))
-          (Set.Icc 0 T) t) :=
-    fun k => Classical.choose_spec
-      (Classical.choose_spec (Classical.choose_spec (step (x k))))
-  have h_flow : ∀ k,
-      IsCharacteristicFlowOn gradW (x k).extend (charXs k) (charVs k)
-        (Set.Ioo 0 T) Set.univ ∧
-      (∀ z : PhaseSpace d, ∀ t ∈ Set.Icc (0 : ℝ) T,
-        HasDerivWithinAt (fun s => charXs k s z) (charVs k t z) (Set.Icc 0 T) t ∧
-        HasDerivWithinAt (fun s => charVs k s z)
-          (-(convolveFunctionMeasure gradW ((x k).extend t) (charXs k t z)))
-          (Set.Icc 0 T) t) ∧
-      (∀ t ∈ Set.Icc (0 : ℝ) T,
-        (x (k + 1)).ρ t = Measure.map (fun z : PhaseSpace d => charXs k t z) f₀) := by
-    intro k
-    obtain ⟨hpush, hcf, hbd⟩ := hspec k
-    refine ⟨hcf, hbd, fun t ht => ?_⟩
-    rw [hx_succ k]; exact hpush t ht
-  have hCI : ∀ k,
-      (∀ t ∈ Set.Icc (0 : ℝ) T, AEMeasurable (fun z : PhaseSpace d => charXs k t z) f₀) ∧
-      (∀ t ∈ Set.Icc (0 : ℝ) T, Integrable (fun z : PhaseSpace d => ‖charXs k t z‖) f₀) ∧
-      (∀ t ∈ Set.Icc (0 : ℝ) T,
-        Integrable (fun y : PhysSpace d => ‖y‖) (Measure.map (fun z => charXs k t z) f₀)) ∧
-      (∀ z : PhaseSpace d, (charXs k 0 z, charVs k 0 z) = z) ∧
-      (∀ z : PhaseSpace d,
-        ContinuousOn (fun s => (charXs k s z, charVs k s z)) (Set.Icc (0 : ℝ) T)) ∧
-      (∀ z : PhaseSpace d, ∀ s ∈ Set.Ico (0 : ℝ) T,
-        HasDerivWithinAt (fun s' => (charXs k s' z, charVs k s' z))
-          (vlasovVectorField gradW ((x k).extend) s (charXs k s z, charVs k s z))
-          (Set.Ici s) s) :=
-    fun k => envelopeStep_contractionInputs gradW L hL f₀ hf₀_int hT.le (x k) (m T) hMbar_nn
-      (fun t _ => le_trans (VlasovMeasureCurve.extend_hasMoment hT.le (x k) t)
-        (hMbar_mono (clampToIcc T t) (clampToIcc_mem hT.le t)))
-      (charXs k) (charVs k) (h_flow k).1 (h_flow k).2.1 (h_int_ext_gen (x k))
-  have hK_ne : ((max 1 L : NNReal) : ℝ) ≠ 0 := by
-    have h1 : (1:ℝ) ≤ ((max 1 L : NNReal):ℝ) := by
-      rw [NNReal.coe_max, NNReal.coe_one]; exact le_max_left _ _
-    linarith
-  have hq_scale : ∀ D : ℝ,
-      gronwallBound 0 ((max 1 L : NNReal):ℝ) ((L:ℝ)*D) T = D * q := by
-    intro D
-    rw [hq_def, gronwallBound_of_K_ne_0 hK_ne, gronwallBound_of_K_ne_0 hK_ne]; ring
-  have hPext : ∀ (ν : VlasovMeasureCurve d T m) (t : ℝ),
-      IsProbabilityMeasure (ν.extend t) :=
-    fun ν => VlasovMeasureCurve.extend_isProb ν
-  have h_contract : ∀ k, supW1On (Set.Icc 0 T) (x k).ρ (x (k + 1)).ρ ≤
-      ENNReal.ofReal (q ^ k * D₀) := by
-    intro k
-    induction k with
-    | zero =>
-      simp only [pow_zero, one_mul]
-      rw [hD₀_def]
-      exact supW1On_le_two_moment_of_VlasovMeasureCurve (m T) hMbar_mono (x 0) (x 1)
-    | succ k ih =>
-      set D : ℝ := q ^ k * D₀ with hD_def
-      have hD_nn : 0 ≤ D := mul_nonneg (pow_nonneg hq_nn k) hD₀_nn
-      have he : ∀ (ν : VlasovMeasureCurve d T m) s, s ∈ Set.Icc (0 : ℝ) T → ν.extend s = ν.ρ s := by
-        intro ν s hs
-        unfold VlasovMeasureCurve.extend clampToIcc; congr 1
-        rw [min_eq_left hs.2, max_eq_right hs.1]
-      have h_W1_fin : ∀ s ∈ Set.Icc (0 : ℝ) T,
-          wasserstein1 ((x k).extend s) ((x (k+1)).extend s) ≠ ⊤ := by
-        intro s hs
-        rw [he (x k) s hs, he (x (k+1)) s hs]
-        have := (x k).isProb s; have := (x (k+1)).isProb s
-        exact wasserstein1_ne_top_of_finite_moment _ _
-          ((x k).yIntegrable s hs) ((x (k+1)).yIntegrable s hs)
-      have h_W1_bound : ∀ s ∈ Set.Icc (0 : ℝ) T,
-          (wasserstein1 ((x k).extend s) ((x (k+1)).extend s)).toReal ≤ D := by
-        intro s hs
-        rw [he (x k) s hs, he (x (k+1)) s hs]
-        have h_le : wasserstein1 ((x k).ρ s) ((x (k+1)).ρ s)
-            ≤ ENNReal.ofReal D :=
-          le_trans (wasserstein1_le_supW1On _ _ _ s hs) ih
-        have h_ne : wasserstein1 ((x k).ρ s) ((x (k+1)).ρ s) ≠ ⊤ := by
-          have := (x k).isProb s; have := (x (k+1)).isProb s
-          exact wasserstein1_ne_top_of_finite_moment _ _
-            ((x k).yIntegrable s hs) ((x (k+1)).yIntegrable s hs)
-        calc (wasserstein1 ((x k).ρ s) ((x (k+1)).ρ s)).toReal
-            ≤ (ENNReal.ofReal D).toReal := ENNReal.toReal_mono ENNReal.ofReal_ne_top h_le
-          _ = D := ENNReal.toReal_ofReal hD_nn
-      have h_contr := @Phi_supW1_contraction d gradW L hL ((x k).extend) ((x (k+1)).extend)
-        (hPext (x k)) (hPext (x (k+1)))
-        (h_int_ext_gen (x k)) (h_int_ext_gen (x (k+1))) T hT.le D hD_nn h_W1_fin h_W1_bound
-        (charXs k) (charVs k) (charXs (k+1)) (charVs (k+1)) f₀ _
-        (hCI k).1 (hCI (k+1)).1 (hCI k).2.1 (hCI (k+1)).2.1
-        (hCI k).2.2.1 (hCI (k+1)).2.2.1 (hCI k).2.2.2.1 (hCI (k+1)).2.2.2.1
-        (hCI k).2.2.2.2.1 (hCI (k+1)).2.2.2.2.1 (hCI k).2.2.2.2.2 (hCI (k+1)).2.2.2.2.2
-      rw [hq_scale D] at h_contr
-      have h_supW1_eq : supW1On (Set.Icc 0 T) (x (k+1)).ρ (x (k+1+1)).ρ
-          = supW1On (Set.Icc 0 T)
-              (fun t => Measure.map (fun z => charXs k t z) f₀)
-              (fun t => Measure.map (fun z => charXs (k+1) t z) f₀) := by
-        unfold supW1On
-        exact iSup_congr fun t => iSup_congr fun ht => by
-          rw [(h_flow k).2.2 t ht, (h_flow (k+1)).2.2 t ht]
-      have hDq : D * q = q ^ (k + 1) * D₀ := by rw [hD_def, pow_succ]; ring
-      rw [hDq] at h_contr
-      have h_ne_top : supW1On (Set.Icc 0 T)
-          (fun t => Measure.map (fun z => charXs k t z) f₀)
-          (fun t => Measure.map (fun z => charXs (k+1) t z) f₀) ≠ ⊤ := by
-        rw [← h_supW1_eq]
-        exact supW1On_ne_top_of_VlasovMeasureCurve (m T) hMbar_mono (x (k+1)) (x (k+1+1))
-      have h_pow_nn : 0 ≤ q ^ (k + 1) * D₀ := mul_nonneg (pow_nonneg hq_nn _) hD₀_nn
-      rw [h_supW1_eq]
-      rw [← ENNReal.toReal_le_toReal h_ne_top ENNReal.ofReal_ne_top,
-          ENNReal.toReal_ofReal h_pow_nn]
-      exact h_contr
-  exact ⟨x, charXs, charVs, h_contract, h_flow⟩
-
-/-- Pointwise contraction of the Picard step between an iterate and the limit
-curve: the pushforwards under the two flows are `D·q`-close whenever the curves
-are uniformly `D`-close in `W₁`.  Wraps `Phi_pointwise_contraction` +
-`gronwallBound` monotonicity for a single curve pair. -/
-private lemma picardLimit_flow_pointwise_contraction
-    {d : ℕ} [NeZero d]
-    (gradW : PhysSpace d → PhysSpace d)
-    (L : NNReal) (hL : LipschitzWith L gradW)
-    (f₀ : Measure (PhaseSpace d)) [IsProbabilityMeasure f₀]
-    (hf₀_int : Integrable (fun z : PhaseSpace d => ‖z‖) f₀)
-    {T : ℝ} (hT : 0 < T)
-    (m : ℝ → ℝ) (hMbar_nn : 0 ≤ m T)
-    (hMbar_mono : ∀ t ∈ Set.Icc (0 : ℝ) T, m t ≤ m T)
-    (ν ρl : VlasovMeasureCurve d T m)
-    (cX cV charX charV : ℝ → PhaseSpace d → PhysSpace d)
-    (hflow_ν : IsCharacteristicFlowOn gradW ν.extend cX cV (Set.Ioo 0 T) Set.univ)
-    (hbdry_ν : ∀ z : PhaseSpace d, ∀ t ∈ Set.Icc (0 : ℝ) T,
-      HasDerivWithinAt (fun s => cX s z) (cV t z) (Set.Icc 0 T) t ∧
-      HasDerivWithinAt (fun s => cV s z)
-        (-(convolveFunctionMeasure gradW (ν.extend t) (cX t z))) (Set.Icc 0 T) t)
-    (hflow_l : IsCharacteristicFlowOn gradW ρl.extend charX charV (Set.Ioo 0 T) Set.univ)
-    (hbdry_l : ∀ z : PhaseSpace d, ∀ t ∈ Set.Icc (0 : ℝ) T,
-      HasDerivWithinAt (fun s => charX s z) (charV t z) (Set.Icc 0 T) t ∧
-      HasDerivWithinAt (fun s => charV s z)
-        (-(convolveFunctionMeasure gradW (ρl.extend t) (charX t z))) (Set.Icc 0 T) t)
-    (D : ℝ) (hD_nn : 0 ≤ D)
-    (h_W1_fin : ∀ s ∈ Set.Icc (0 : ℝ) T, wasserstein1 (ν.extend s) (ρl.extend s) ≠ ⊤)
-    (h_W1_bound : ∀ s ∈ Set.Icc (0 : ℝ) T,
-      (wasserstein1 (ν.extend s) (ρl.extend s)).toReal ≤ D)
-    (q : ℝ) (hq_def : q = gronwallBound 0 ((max 1 L : NNReal) : ℝ) (L : ℝ) T) :
-    ∀ t ∈ Set.Icc (0 : ℝ) T,
-      (wasserstein1 (Measure.map (fun z => cX t z) f₀)
-                    (Measure.map (fun z => charX t z) f₀)).toReal ≤ D * q := by
-  have hK_ge1 : (1 : ℝ) ≤ ((max 1 L : NNReal) : ℝ) := by
-    rw [NNReal.coe_max, NNReal.coe_one]; exact le_max_left _ _
-  have hK_ne : ((max 1 L : NNReal) : ℝ) ≠ 0 := ne_of_gt (by linarith)
-  have hK_pos : (0 : ℝ) ≤ ((max 1 L : NNReal) : ℝ) := by linarith
-  have hMm : ∀ (μ : VlasovMeasureCurve d T m), ∀ t ∈ Set.Icc (0 : ℝ) T,
-      ∫ y, ‖y‖ ∂(μ.extend t) ≤ m T :=
-    fun μ t _ => le_trans (VlasovMeasureCurve.extend_hasMoment hT.le μ t)
-      (hMbar_mono (clampToIcc T t) (clampToIcc_mem hT.le t))
-  have h_int_ν : ∀ t (xp : PhysSpace d),
-      Integrable (fun y => gradW (xp - y)) (ν.extend t) := fun t xp =>
-    integrable_gradW_shift gradW L hL (ν.extend t)
-      (VlasovMeasureCurve.extend_yIntegrable hT.le ν t) xp
-  have h_int_l : ∀ t (xp : PhysSpace d),
-      Integrable (fun y => gradW (xp - y)) (ρl.extend t) := fun t xp =>
-    integrable_gradW_shift gradW L hL (ρl.extend t)
-      (VlasovMeasureCurve.extend_yIntegrable hT.le ρl t) xp
-  have hCI_ν := envelopeStep_contractionInputs gradW L hL f₀ hf₀_int hT.le ν
-    (m T) hMbar_nn (hMm ν) cX cV hflow_ν hbdry_ν h_int_ν
-  have hCI_l := envelopeStep_contractionInputs gradW L hL f₀ hf₀_int hT.le ρl
-    (m T) hMbar_nn (hMm ρl) charX charV hflow_l hbdry_l h_int_l
-  have hq_scale : gronwallBound 0 ((max 1 L : NNReal) : ℝ) ((L:ℝ) * D) T = D * q := by
-    rw [hq_def, gronwallBound_of_K_ne_0 hK_ne, gronwallBound_of_K_ne_0 hK_ne]; ring
-  intro t ht
-  have hpt := @Phi_pointwise_contraction d gradW L hL (ν.extend) (ρl.extend)
-    (VlasovMeasureCurve.extend_isProb ν) (VlasovMeasureCurve.extend_isProb ρl)
-    h_int_ν h_int_l T hT.le D hD_nn h_W1_fin h_W1_bound
-    cX cV charX charV f₀ _
-    hCI_ν.1 hCI_l.1 hCI_ν.2.1 hCI_l.2.1
-    hCI_ν.2.2.2.1 hCI_l.2.2.2.1 hCI_ν.2.2.2.2.1 hCI_l.2.2.2.2.1
-    hCI_ν.2.2.2.2.2 hCI_l.2.2.2.2.2 t ht
-  have h_mono : gronwallBound 0 ((max 1 L : NNReal) : ℝ) ((L:ℝ) * D) t
-      ≤ gronwallBound 0 ((max 1 L : NNReal) : ℝ) ((L:ℝ) * D) T :=
-    gronwallBound_mono (le_refl 0) (mul_nonneg L.coe_nonneg hD_nn) hK_pos ht.2
-  rw [hq_scale] at h_mono
-  exact le_trans hpt h_mono
-
-/-- The Picard fixed-point equation at the limit: if the iterates converge to the
-limit curve in `W₁` and each step's pushforward is `Dₙ·q`-close to the limit
-flow's pushforward with `Dₙ·q → 0`, the limit curve equals the limit flow's
-pushforward.  Triangle through the iterates + the `W₁` separation lemma. -/
-private lemma picardLimit_fixed_point_eq
-    {d : ℕ} [NeZero d]
-    (f₀ : Measure (PhaseSpace d)) [IsProbabilityMeasure f₀]
-    {T : ℝ}
-    (m : ℝ → ℝ) (x : ℕ → VlasovMeasureCurve d T m) (ρl : VlasovMeasureCurve d T m)
-    (charXs : ℕ → ℝ → PhaseSpace d → PhysSpace d)
-    (charX : ℝ → PhaseSpace d → PhysSpace d)
-    (h_push : ∀ n, ∀ t ∈ Set.Icc (0 : ℝ) T,
-      (x (n + 1)).ρ t = Measure.map (fun z : PhaseSpace d => charXs n t z) f₀)
-    (h_tendsto : ∀ t ∈ Set.Icc (0 : ℝ) T,
-      Filter.Tendsto (fun n => wasserstein1 ((x n).ρ t) (ρl.ρ t)) Filter.atTop (nhds 0))
-    (h_aem_n : ∀ n, ∀ t ∈ Set.Icc (0 : ℝ) T,
-      AEMeasurable (fun z : PhaseSpace d => charXs n t z) f₀)
-    (h_aem_lim : ∀ t ∈ Set.Icc (0 : ℝ) T,
-      AEMeasurable (fun z : PhaseSpace d => charX t z) f₀)
-    (h_mom_n : ∀ n, ∀ t ∈ Set.Icc (0 : ℝ) T,
-      Integrable (fun y : PhysSpace d => ‖y‖) (Measure.map (fun z => charXs n t z) f₀))
-    (h_mom_lim : ∀ t ∈ Set.Icc (0 : ℝ) T,
-      Integrable (fun y : PhysSpace d => ‖y‖) (Measure.map (fun z => charX t z) f₀))
-    (Dn : ℕ → ℝ) (q : ℝ)
-    (hDnq_tendsto : Filter.Tendsto (fun n => Dn n * q) Filter.atTop (nhds 0))
-    (h_term2 : ∀ n t, t ∈ Set.Icc (0 : ℝ) T →
-      (wasserstein1 (Measure.map (fun z => charXs n t z) f₀)
-                    (Measure.map (fun z => charX t z) f₀)).toReal ≤ Dn n * q) :
-    ∀ t ∈ Set.Icc (0 : ℝ) T, ρl.ρ t = Measure.map (fun z => charX t z) f₀ := by
-  intro t ht
-  have hP1 : IsProbabilityMeasure (ρl.ρ t) := ρl.isProb t
-  have hP2 : IsProbabilityMeasure (Measure.map (fun z => charX t z) f₀) :=
-    (Measure.isProbabilityMeasure_map_iff (h_aem_lim t ht)).mpr inferInstance
-  refine (wasserstein1_eq_zero_iff_measure_eq (ρl.ρ t)
-    (Measure.map (fun z => charX t z) f₀)).mp ?_
-  have h_le_seq : ∀ n, wasserstein1 (ρl.ρ t) (Measure.map (fun z => charX t z) f₀)
-      ≤ wasserstein1 ((x (n+1)).ρ t) (ρl.ρ t) + ENNReal.ofReal (Dn n * q) := by
-    intro n
-    have h_mid : (x (n+1)).ρ t = Measure.map (fun z => charXs n t z) f₀ := h_push n t ht
-    calc wasserstein1 (ρl.ρ t) (Measure.map (fun z => charX t z) f₀)
-        ≤ wasserstein1 (ρl.ρ t) ((x (n+1)).ρ t)
-            + wasserstein1 ((x (n+1)).ρ t) (Measure.map (fun z => charX t z) f₀) :=
-          wasserstein1_triangle _ _ _
-      _ = wasserstein1 ((x (n+1)).ρ t) (ρl.ρ t)
-            + wasserstein1 ((x (n+1)).ρ t) (Measure.map (fun z => charX t z) f₀) := by
-          rw [wasserstein1_comm (ρl.ρ t) ((x (n+1)).ρ t)]
-      _ ≤ wasserstein1 ((x (n+1)).ρ t) (ρl.ρ t) + ENNReal.ofReal (Dn n * q) := by
-          gcongr
-          rw [h_mid]
-          have h_fin : wasserstein1 (Measure.map (fun z => charXs n t z) f₀)
-              (Measure.map (fun z => charX t z) f₀) ≠ ⊤ := by
-            have : IsProbabilityMeasure (Measure.map (fun z => charXs n t z) f₀) :=
-              (Measure.isProbabilityMeasure_map_iff (h_aem_n n t ht)).mpr inferInstance
-            exact wasserstein1_ne_top_of_finite_moment _ _
-              (h_mom_n n t ht) (h_mom_lim t ht)
-          rw [← ENNReal.ofReal_toReal h_fin]
-          exact ENNReal.ofReal_le_ofReal (h_term2 n t ht)
-  have hA : Filter.Tendsto (fun n => wasserstein1 ((x (n+1)).ρ t) (ρl.ρ t))
-      Filter.atTop (nhds 0) :=
-    (h_tendsto t ht).comp (Filter.tendsto_add_atTop_nat 1)
-  have hB : Filter.Tendsto (fun n => ENNReal.ofReal (Dn n * q)) Filter.atTop (nhds 0) := by
-    have := (ENNReal.continuous_ofReal.tendsto 0).comp hDnq_tendsto
-    simpa [Function.comp_def] using this
-  have h_seq : Filter.Tendsto
-      (fun n => wasserstein1 ((x (n+1)).ρ t) (ρl.ρ t) + ENNReal.ofReal (Dn n * q))
-      Filter.atTop (nhds 0) := by
-    have := hA.add hB
-    simpa using this
-  exact le_antisymm (ge_of_tendsto' h_seq h_le_seq) (zero_le)
-
-/-- Bundle the self-consistent Picard-limit flow, CLAMPED to the window, into the
-seven-conjunct conclusion of `vlasovWellPosedness_local_picard_fixedPointFlow`.
-The raw flow is controlled only on `[0, T]`; clamping (`clampToIcc`) makes every
-universal-in-`s` conjunct reduce to the window, where the clamp is the identity. -/
-private lemma picardFlow_clamp_bundle
-    {d : ℕ} [NeZero d]
-    (gradW : PhysSpace d → PhysSpace d)
-    (L : NNReal) (hL : LipschitzWith L gradW)
-    (f₀ : Measure (PhaseSpace d))
-    {T : ℝ} (hT : 0 < T)
-    (m : ℝ → ℝ) (hMbar_nn : 0 ≤ m T)
-    (hMbar_mono : ∀ t ∈ Set.Icc (0 : ℝ) T, m t ≤ m T)
-    (ρ_lim : VlasovMeasureCurve d T m)
-    (charX charV : ℝ → PhaseSpace d → PhysSpace d)
-    (hflow_on_ρlim : IsCharacteristicFlowOn gradW ρ_lim.extend charX charV
-      (Set.Ioo 0 T) Set.univ)
-    (h_boundary_ρlim : ∀ z : PhaseSpace d, ∀ t ∈ Set.Icc (0 : ℝ) T,
-      HasDerivWithinAt (fun s => charX s z) (charV t z) (Set.Icc 0 T) t ∧
-      HasDerivWithinAt (fun s => charV s z)
-        (-(convolveFunctionMeasure gradW (ρ_lim.extend t) (charX t z))) (Set.Icc 0 T) t)
-    (h_int_ρ_lim : ∀ t (x_pt : PhysSpace d),
-      Integrable (fun y => gradW (x_pt - y)) (ρ_lim.extend t))
-    (h_self_consist : ∀ t ∈ Set.Icc (0 : ℝ) T,
-      ρ_lim.extend t =
-      spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ t)) :
-    ∃ (charX' charV' : ℝ → PhaseSpace d → PhysSpace d) (M_ρ : ℝ), 0 ≤ M_ρ ∧
-      IsCharacteristicFlowOn gradW
-        (fun t => spatialMarginal (vlasovSolutionViaPushforward charX' charV' f₀ t))
-        charX' charV' (Set.Ioo 0 T) Set.univ ∧
-      (∀ z : PhaseSpace d, ∀ t ∈ Set.Icc (0 : ℝ) T,
-        HasDerivWithinAt (fun s => charX' s z) (charV' t z) (Set.Icc 0 T) t ∧
-        HasDerivWithinAt (fun s => charV' s z)
-          (-(convolveFunctionMeasure gradW
-              (spatialMarginal (vlasovSolutionViaPushforward charX' charV' f₀ t))
-              (charX' t z)))
-          (Set.Icc 0 T) t) ∧
-      (∀ s ∈ Set.Icc (0 : ℝ) T,
-        ∫ y, ‖y‖ ∂(spatialMarginal (vlasovSolutionViaPushforward charX' charV' f₀ s)) ≤ M_ρ) ∧
-      (∀ s ∈ Set.Icc (0 : ℝ) T,
-        Integrable (fun y : PhysSpace d => ‖y‖)
-          (spatialMarginal (vlasovSolutionViaPushforward charX' charV' f₀ s))) ∧
-      (∀ s, Continuous (fun x =>
-        convolveFunctionMeasure gradW
-          (spatialMarginal (vlasovSolutionViaPushforward charX' charV' f₀ s)) x)) ∧
-      (∀ s, AEMeasurable (fun z : PhaseSpace d => (charX' s z, charV' s z)) f₀) ∧
-      (∀ s (x : PhysSpace d),
-        Integrable (fun y => gradW (x - y))
-          (spatialMarginal (vlasovSolutionViaPushforward charX' charV' f₀ s))) := by
-  have hclamp_id : ∀ s ∈ Set.Icc (0 : ℝ) T, clampToIcc T s = s := fun s hs => by
-    unfold clampToIcc; rw [min_eq_left hs.2, max_eq_right hs.1]
-  have hclamp0 : clampToIcc T 0 = 0 := hclamp_id 0 ⟨le_refl 0, hT.le⟩
-  have h_rho_clamp : ∀ s : ℝ,
-      spatialMarginal (vlasovSolutionViaPushforward
-        (fun s' z => charX (clampToIcc T s') z)
-        (fun s' z => charV (clampToIcc T s') z) f₀ s) =
-      ρ_lim.extend (clampToIcc T s) := by
-    intro s
-    have h1 : spatialMarginal (vlasovSolutionViaPushforward
-        (fun s' z => charX (clampToIcc T s') z)
-        (fun s' z => charV (clampToIcc T s') z) f₀ s) =
-        spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ (clampToIcc T s)) :=
-      rfl
-    rw [h1, ← h_self_consist (clampToIcc T s) (clampToIcc_mem hT.le s)]
-  refine ⟨fun s z => charX (clampToIcc T s) z, fun s z => charV (clampToIcc T s) z,
-    m T, hMbar_nn, ?_, ?_, ?_, ?_, ?_, ?_, ?_⟩
-  · refine ⟨fun z _hz => ?_, fun t ht z _hz => ?_, fun t ht z _hz => ?_⟩
-    · change charX (clampToIcc T 0) z = z.1 ∧ charV (clampToIcc T 0) z = z.2
-      rw [hclamp0]; exact hflow_on_ρlim.1 z (Set.mem_univ z)
-    · have hEv : (fun s => charX (clampToIcc T s) z) =ᶠ[nhds t]
-          (fun s => charX s z) := by
-        filter_upwards [Ioo_mem_nhds ht.1 ht.2] with s hs
-        rw [hclamp_id s (Set.Ioo_subset_Icc_self hs)]
-      change HasDerivAt (fun s => charX (clampToIcc T s) z) (charV (clampToIcc T t) z) t
-      rw [hclamp_id t (Set.Ioo_subset_Icc_self ht)]
-      exact (hflow_on_ρlim.2.1 t ht z (Set.mem_univ z)).congr_of_eventuallyEq hEv
-    · have hEv : (fun s => charV (clampToIcc T s) z) =ᶠ[nhds t]
-          (fun s => charV s z) := by
-        filter_upwards [Ioo_mem_nhds ht.1 ht.2] with s hs
-        rw [hclamp_id s (Set.Ioo_subset_Icc_self hs)]
-      change HasDerivAt (fun s => charV (clampToIcc T s) z)
-        (-(convolveFunctionMeasure gradW
-            (spatialMarginal (vlasovSolutionViaPushforward
-              (fun s' z' => charX (clampToIcc T s') z')
-              (fun s' z' => charV (clampToIcc T s') z') f₀ t))
-            (charX (clampToIcc T t) z))) t
-      rw [h_rho_clamp t, hclamp_id t (Set.Ioo_subset_Icc_self ht)]
-      exact (hflow_on_ρlim.2.2 t ht z (Set.mem_univ z)).congr_of_eventuallyEq hEv
-  · intro z t ht
-    have hEqOn : Set.EqOn (fun s => charX (clampToIcc T s) z) (fun s => charX s z)
-        (Set.Icc 0 T) := fun s hs => by
-      change charX (clampToIcc T s) z = charX s z; rw [hclamp_id s hs]
-    have hEqOnV : Set.EqOn (fun s => charV (clampToIcc T s) z) (fun s => charV s z)
-        (Set.Icc 0 T) := fun s hs => by
-      change charV (clampToIcc T s) z = charV s z; rw [hclamp_id s hs]
-    obtain ⟨h1, h2⟩ := h_boundary_ρlim z t ht
-    refine ⟨?_, ?_⟩
-    · change HasDerivWithinAt (fun s => charX (clampToIcc T s) z)
-        (charV (clampToIcc T t) z) (Set.Icc 0 T) t
-      rw [hclamp_id t ht]
-      exact h1.congr hEqOn (hEqOn ht)
-    · change HasDerivWithinAt (fun s => charV (clampToIcc T s) z)
-        (-(convolveFunctionMeasure gradW
-            (spatialMarginal (vlasovSolutionViaPushforward
-              (fun s' z' => charX (clampToIcc T s') z')
-              (fun s' z' => charV (clampToIcc T s') z') f₀ t))
-            (charX (clampToIcc T t) z))) (Set.Icc 0 T) t
-      rw [h_rho_clamp t, hclamp_id t ht]
-      exact h2.congr hEqOnV (hEqOnV ht)
-  · intro s hs
-    rw [h_rho_clamp s, hclamp_id s hs]
-    exact le_trans (VlasovMeasureCurve.extend_hasMoment hT.le ρ_lim s)
-      (hMbar_mono (clampToIcc T s) (clampToIcc_mem hT.le s))
-  · intro s hs
-    rw [h_rho_clamp s, hclamp_id s hs]
-    exact VlasovMeasureCurve.extend_yIntegrable hT.le ρ_lim s
-  · intro s
-    rw [h_rho_clamp s]
-    have : IsProbabilityMeasure (ρ_lim.extend (clampToIcc T s)) :=
-      VlasovMeasureCurve.extend_isProb ρ_lim (clampToIcc T s)
-    exact (convolveFunctionMeasure_lipschitz_in_x gradW L hL
-      (ρ_lim.extend (clampToIcc T s)) (h_int_ρ_lim (clampToIcc T s))).continuous
-  · intro s
-    exact picardCharFlow_aemeasurable gradW L hL ρ_lim.extend h_int_ρ_lim charX charV hT.le
-      hflow_on_ρlim h_boundary_ρlim f₀ (clampToIcc T s) (clampToIcc_mem hT.le s)
-  · intro s x
-    rw [h_rho_clamp s]
-    exact h_int_ρ_lim (clampToIcc T s) x
-
-/-- **Sub-helper for `_picard_fixedPointFlow`** — the Picard fixed-point
-self-consistency equation.  For `t ∈ Icc 0 T`,
-
-`ρ_lim.extend t = spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ t)`,
-
-proved by the triangle through the iterates `x n`: the marginal-vs-limit leg
-tends to `0` by `h_tendsto`, the flow-pushforward leg is `≤ Dn n · q` by the
-pointwise contraction `picardLimit_flow_pointwise_contraction` (with
-`Dn n := (supW1On (Icc 0 T) (x n).ρ ρ_lim.ρ).toReal → 0` from the
-supW1On-Cauchy structure), and `picardLimit_fixed_point_eq` closes.  The
-contraction ratio `q` is threaded by its defining equation `hq_def`
-(let-bound parent supplies `rfl`). -/
-private lemma picardLimit_self_consistency
-    {d : ℕ} [NeZero d]
-    (gradW : PhysSpace d → PhysSpace d)
-    (L : NNReal) (hL : LipschitzWith L gradW)
-    (f₀ : Measure (PhaseSpace d)) [IsProbabilityMeasure f₀]
-    (hf₀_int : Integrable (fun z : PhaseSpace d => ‖z‖) f₀)
-    {T : ℝ} (hT : 0 < T)
-    (m : ℝ → ℝ) (hMbar_nn : 0 ≤ m T)
-    (hMbar_mono : ∀ t ∈ Set.Icc (0 : ℝ) T, m t ≤ m T)
-    (q : ℝ) (hq_nn : 0 ≤ q) (hq_lt : q < 1)
-    (hq_def : q = gronwallBound 0 ((max 1 L : NNReal) : ℝ) (L : ℝ) T)
-    (D₀ : ℝ) (hD₀_nn : 0 ≤ D₀)
-    (x : ℕ → VlasovMeasureCurve d T m)
-    (charXs charVs : ℕ → ℝ → PhaseSpace d → PhysSpace d)
-    (h_contract : ∀ k, supW1On (Set.Icc 0 T) (x k).ρ (x (k + 1)).ρ ≤
-      ENNReal.ofReal (q ^ k * D₀))
-    (h_flow : ∀ k,
-      IsCharacteristicFlowOn gradW (x k).extend (charXs k) (charVs k)
-        (Set.Ioo 0 T) Set.univ ∧
-      (∀ z : PhaseSpace d, ∀ t ∈ Set.Icc (0 : ℝ) T,
-        HasDerivWithinAt (fun s => charXs k s z) (charVs k t z) (Set.Icc 0 T) t ∧
-        HasDerivWithinAt (fun s => charVs k s z)
-          (-(convolveFunctionMeasure gradW ((x k).extend t) (charXs k t z)))
-          (Set.Icc 0 T) t) ∧
-      (∀ t ∈ Set.Icc (0 : ℝ) T,
-        (x (k + 1)).ρ t = Measure.map (fun z : PhaseSpace d => charXs k t z) f₀))
-    (ρ_lim : VlasovMeasureCurve d T m)
-    (h_tendsto : ∀ t ∈ Set.Icc (0 : ℝ) T,
-      Filter.Tendsto (fun n => wasserstein1 ((x n).ρ t) (ρ_lim.ρ t))
-        Filter.atTop (nhds 0))
-    (charX charV : ℝ → PhaseSpace d → PhysSpace d)
-    (hflow_on_ρlim : IsCharacteristicFlowOn gradW ρ_lim.extend charX charV
-      (Set.Ioo 0 T) Set.univ)
-    (h_boundary_ρlim : ∀ z : PhaseSpace d, ∀ t ∈ Set.Icc (0 : ℝ) T,
-      HasDerivWithinAt (fun s => charX s z) (charV t z) (Set.Icc 0 T) t ∧
-      HasDerivWithinAt (fun s => charV s z)
-        (-(convolveFunctionMeasure gradW (ρ_lim.extend t) (charX t z)))
-        (Set.Icc 0 T) t)
-    (h_int_ρ_lim : ∀ t (x_pt : PhysSpace d),
-      Integrable (fun y => gradW (x_pt - y)) (ρ_lim.extend t)) :
-    ∀ t ∈ Set.Icc (0 : ℝ) T,
-      ρ_lim.extend t =
-      spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ t) := by
-  have he : ∀ (ν : VlasovMeasureCurve d T m) s, s ∈ Set.Icc (0 : ℝ) T →
-      ν.extend s = ν.ρ s := by
-    intro ν s hs
-    unfold VlasovMeasureCurve.extend clampToIcc; congr 1
-    rw [min_eq_left hs.2, max_eq_right hs.1]
-  have hMm : ∀ (ν : VlasovMeasureCurve d T m), ∀ t ∈ Set.Icc (0 : ℝ) T,
-      ∫ y, ‖y‖ ∂(ν.extend t) ≤ m T :=
-    fun ν t _ => le_trans (VlasovMeasureCurve.extend_hasMoment hT.le ν t)
-      (hMbar_mono (clampToIcc T t) (clampToIcc_mem hT.le t))
-  have h_int_ext_gen : ∀ (ν : VlasovMeasureCurve d T m) (t : ℝ) (xp : PhysSpace d),
-      Integrable (fun y => gradW (xp - y)) (ν.extend t) := fun ν t xp =>
-    integrable_gradW_shift gradW L hL (ν.extend t)
-      (VlasovMeasureCurve.extend_yIntegrable hT.le ν t) xp
-  have hCI := fun k => envelopeStep_contractionInputs gradW L hL f₀ hf₀_int hT.le (x k)
-    (m T) hMbar_nn (hMm (x k)) (charXs k) (charVs k)
-    (h_flow k).1 (h_flow k).2.1 (h_int_ext_gen (x k))
-  have hCI_lim := envelopeStep_contractionInputs gradW L hL f₀ hf₀_int hT.le ρ_lim
-    (m T) hMbar_nn (hMm ρ_lim) charX charV hflow_on_ρlim h_boundary_ρlim h_int_ρ_lim
-  have h_marg : ∀ s ∈ Set.Icc (0 : ℝ) T,
-      spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ s)
-        = Measure.map (fun z => charX s z) f₀ := by
-    intro s hs
-    have h_pair_meas := charFlow_measurable_via_gronwall gradW L hL ρ_lim.extend h_int_ρ_lim
-      charX charV T hT.le hCI_lim.2.2.2.1 hCI_lim.2.2.2.2.1 hCI_lim.2.2.2.2.2 s hs
-    unfold spatialMarginal vlasovSolutionViaPushforward
-    rw [Measure.map_map measurable_fst h_pair_meas]
-    rfl
-  have h_cauchy := picard_iterate_isCauchy_of_contraction
-    (Set.Icc (0 : ℝ) T) (fun n => (x n).ρ) q hq_nn hq_lt D₀ hD₀_nn h_contract
-  have h_uniform := picard_iterate_limit_uniform_tendsto
-    (Set.Icc (0 : ℝ) T) (fun n => (x n).ρ) ρ_lim.ρ h_cauchy h_tendsto
-  have h_sup_ne_top : ∀ n, supW1On (Set.Icc 0 T) (x n).ρ ρ_lim.ρ ≠ ⊤ :=
-    fun n => supW1On_ne_top_of_VlasovMeasureCurve (m T) hMbar_mono (x n) ρ_lim
-  have h_sup_tendsto : Filter.Tendsto
-      (fun n => supW1On (Set.Icc 0 T) (x n).ρ ρ_lim.ρ) Filter.atTop (nhds 0) := by
-    rw [ENNReal.tendsto_atTop_zero]
-    intro ε hε
-    obtain ⟨N, hN⟩ := h_uniform ε hε
-    refine ⟨N, fun n hn => ?_⟩
-    unfold supW1On
-    exact iSup_le fun s => iSup_le fun hs => hN n hn s hs
-  set Dn : ℕ → ℝ := fun n => (supW1On (Set.Icc 0 T) (x n).ρ ρ_lim.ρ).toReal with hDn_def
-  have hDn_nn : ∀ n, 0 ≤ Dn n := fun n => ENNReal.toReal_nonneg
-  have hDn_tendsto : Filter.Tendsto Dn Filter.atTop (nhds 0) := by
-    have h := (ENNReal.tendsto_toReal (show (0:ENNReal) ≠ ⊤ by simp)).comp h_sup_tendsto
-    rw [ENNReal.toReal_zero] at h
-    exact h
-  have h_W1_fin_curve : ∀ n, ∀ s ∈ Set.Icc (0 : ℝ) T,
-      wasserstein1 ((x n).extend s) (ρ_lim.extend s) ≠ ⊤ := by
-    intro n s hs
-    rw [he (x n) s hs, he ρ_lim s hs]
-    have := (x n).isProb s; have := ρ_lim.isProb s
-    exact wasserstein1_ne_top_of_finite_moment _ _
-      ((x n).yIntegrable s hs) (ρ_lim.yIntegrable s hs)
-  have h_W1_bound_curve : ∀ n, ∀ s ∈ Set.Icc (0 : ℝ) T,
-      (wasserstein1 ((x n).extend s) (ρ_lim.extend s)).toReal ≤ Dn n := by
-    intro n s hs
-    rw [he (x n) s hs, he ρ_lim s hs]
-    exact ENNReal.toReal_mono (h_sup_ne_top n)
-      (wasserstein1_le_supW1On (Set.Icc 0 T) (x n).ρ ρ_lim.ρ s hs)
-  have h_term2 : ∀ n t, t ∈ Set.Icc (0 : ℝ) T →
-      (wasserstein1 (Measure.map (fun z => charXs n t z) f₀)
-                    (Measure.map (fun z => charX t z) f₀)).toReal ≤ Dn n * q :=
-    fun n t ht => picardLimit_flow_pointwise_contraction gradW L hL f₀ hf₀_int hT
-      m hMbar_nn hMbar_mono (x n) ρ_lim (charXs n) (charVs n) charX charV
-      (h_flow n).1 (h_flow n).2.1 hflow_on_ρlim h_boundary_ρlim
-      (Dn n) (hDn_nn n) (h_W1_fin_curve n) (h_W1_bound_curve n) q hq_def t ht
-  intro t ht
-  rw [he ρ_lim t ht, h_marg t ht]
-  exact picardLimit_fixed_point_eq f₀ m x ρ_lim charXs charX
-    (fun n t' ht' => (h_flow n).2.2 t' ht') h_tendsto
-    (fun n t' ht' => (hCI n).1 t' ht') (fun t' ht' => hCI_lim.1 t' ht')
-    (fun n t' ht' => (hCI n).2.2.1 t' ht') (fun t' ht' => hCI_lim.2.2.1 t' ht')
-    Dn q (by simpa using hDn_tendsto.mul_const q) h_term2 t ht
-
-/-- **Sub-helper for `vlasovWellPosedness_local`** — the Picard fixed-point
-self-consistent flow.
-
-Given `f₀ : Measure (PhaseSpace d)` with finite first moment, produces a
-characteristic flow `(charX, charV)` whose **own pushforward's spatial
-marginal** is the reference measure the flow is built against — i.e., the
-Picard fixed point at the spatial-marginal-curve level:
-
-  `ρ_t := spatialMarginal (Measure.map (z ↦ (charX t z, charV t z)) f₀)`
-  `charX, charV solve the Vlasov ODE against this ρ`.
-
-The body carries the substantive Picard analysis:
-
-* M-fixed-point: pick a moment bound `M ≥ A/(1 - B)` where
-  `A = gronwallBound 1 (1+L) ‖gradW 0‖ T · (M_f₀ + 1)` and
-  `B = L · (exp((1+L)·T) - 1)/(1+L) · (M_f₀ + 1)`.  Requires `B < 1`,
-  which is the genuine convergence criterion for the moment iteration
-  (stronger than the contraction predicate `LocalSmallnessContraction
-  L T` alone for large `M_f₀` — the contraction predicate gates the q
-  factor; the M-fixed-point additionally requires the moment iteration
-  to converge).
-* Picard sequence `x_n : ℕ → VlasovMeasureCurve d T M` starting from
-  `x_0 := constantCurve (spatialMarginal f₀)` and `x_{n+1} := Phi_step(x_n)`.
-* Contraction via `Phi_supW1_contraction`: `supW1On (Φρ) (Φσ) ≤ q · D`
-  with `q < 1`.  Apply `picard_iterate_isCauchy_of_contraction` +
-  `picard_iterate_exists_limit` to get the W₁-limit
-  `ρ_lim : VlasovMeasureCurve d T M`.
-* Self-consistency `Φ(ρ_lim) = ρ_lim`: triangle through `x_n`.
-* Apply `exists_vlasov_characteristicFlow_global_smallT` to `ρ_lim.extend`
-  to get the flow.
-
-**Metric-dependence note**.  The convergence rests on two independent
-predicates:
-* `LocalSmallnessContraction L T := L · (exp((max 1 L)·T) - 1) / (max 1 L) < 1`
-  — exponential in T, from `Phi_supW1_contraction`'s W₁-based shape.
-* `LocalSmallnessPLBuffer L T := L · T² < 1` — quadratic, from
-  per-ball Picard-Lindelöf's ball geometry.
-
-These are genuinely independent (neither universally implies the other), so
-each predicate matches its own sub-argument.
-
-Under the Wbar refactor (Dobrushin 1979, §5), both constraints become
-linear-in-T and align: `LocalSmallnessContraction` reduces to
-`C₂(L)·T < 1`, and the single algebraic constraint then suffices and is
-satisfiable for any `L > 0` by taking `T < 1/C₂(L)`.
-
-**Output bundle** (designed to feed
-`vlasovSolutionViaPushforward_isLagrangianVlasovSolutionOn` directly):
-
-* Flow `(charX, charV)` against the *spatial marginal of the pushforward*
-  — the load-bearing self-consistency conjunct.
-* Boundary regularity.
-* Uniform moment bound `M_ρ` on the spatial marginal trajectory. -/
-theorem vlasovWellPosedness_local_picard_fixedPointFlow
-    {d : ℕ} [NeZero d]
-    (W : PhysSpace d → ℝ)
-    (gradW : PhysSpace d → PhysSpace d)
-    (hgradW : ∀ x, gradW x = gradient W x)
-    (L : NNReal) (hL : LipschitzWith L gradW)
-    (f₀ : Measure (PhaseSpace d)) [IsProbabilityMeasure f₀]
-    (hf₀_int : Integrable (fun z : PhaseSpace d => ‖z‖) f₀)
-    {T : ℝ} (hT : 0 < T)
-    (hTL_PL : LocalSmallnessPLBuffer L T)
-    (hTL_con : LocalSmallnessContraction L T)
-    (hB : (L : ℝ) / (1 + (L : ℝ)) * (Real.exp ((1 + (L : ℝ)) * T) - 1) < 1) :
-    ∃ (charX charV : ℝ → PhaseSpace d → PhysSpace d) (M_ρ : ℝ), 0 ≤ M_ρ ∧
-      -- Self-consistent characteristic flow: against the spatial marginal
-      -- of its own phase-space pushforward.
-      IsCharacteristicFlowOn gradW
-        (fun t => spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ t))
-        charX charV (Set.Ioo 0 T) Set.univ ∧
-      -- Boundary regularity: HasDerivWithinAt on `Icc 0 T` for every z and
-      -- t ∈ Icc 0 T.
-      (∀ z : PhaseSpace d, ∀ t ∈ Set.Icc (0 : ℝ) T,
-        HasDerivWithinAt (fun s => charX s z) (charV t z) (Set.Icc 0 T) t ∧
-        HasDerivWithinAt (fun s => charV s z)
-          (-(convolveFunctionMeasure gradW
-              (spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ t))
-              (charX t z)))
-          (Set.Icc 0 T) t) ∧
-      -- Uniform first-moment bound on the spatial-marginal trajectory.
-      (∀ s ∈ Set.Icc (0 : ℝ) T,
-        ∫ y, ‖y‖ ∂(spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ s)) ≤ M_ρ) ∧
-      -- First-moment integrability on the spatial-marginal trajectory.
-      (∀ s ∈ Set.Icc (0 : ℝ) T,
-        Integrable (fun y : PhysSpace d => ‖y‖)
-          (spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ s))) ∧
-      -- Continuity of the convolution force in `x` (uniformly in `s`).
-      (∀ s, Continuous (fun x =>
-        convolveFunctionMeasure gradW
-          (spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ s)) x)) ∧
-      -- **AEMeasurable witness**, projected from the Picard fixed-point
-      -- construction's continuity-in-z — supplies the `h_aemeas` conjunct
-      -- in downstream `_finalAssembly_*`.
-      (∀ s, AEMeasurable (fun z : PhaseSpace d => (charX s z, charV s z)) f₀) ∧
-      -- **Universal-in-s convolution integrability**.  For `s ∈ Icc 0 T`
-      -- follows from `h_y_int_ρ` + Lipschitz of `gradW`; the extension to
-      -- all `s` uses constant-extension (clamp) past T inside the Picard
-      -- construction.  Supplies the `h_int_conv` conjunct in downstream
-      -- `_finalAssembly_*`.
-      (∀ s (x : PhysSpace d),
-        Integrable (fun y => gradW (x - y))
-          (spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ s))) := by
-  -- ============================================================
-  -- Step 1: Spatial marginal setup.
-  -- μ₀ := spatialMarginal f₀ = Measure.map Prod.fst f₀.
-  -- IsProbabilityMeasure μ₀ via Measure.isProbabilityMeasure_map.
-  -- Integrable ‖·‖ μ₀ from hf₀_int via integral_map on Prod.fst.
-  -- ============================================================
-  have hμ₀_prob : IsProbabilityMeasure (spatialMarginal f₀) :=
-    (Measure.isProbabilityMeasure_map_iff measurable_fst.aemeasurable).mpr inferInstance
-  have hμ₀_int : Integrable (fun y : PhysSpace d => ‖y‖) (spatialMarginal f₀) := by
-    unfold spatialMarginal
-    rw [integrable_map_measure
-      (Continuous.aestronglyMeasurable continuous_norm) measurable_fst.aemeasurable]
-    -- Need: Integrable (‖·‖ ∘ Prod.fst) f₀ = Integrable (fun z => ‖z.1‖) f₀.
-    -- This follows from hf₀_int (Integrable ‖·‖ f₀) and ‖z.1‖ ≤ ‖z‖.
-    refine hf₀_int.mono' ?_ (Filter.Eventually.of_forall fun z => ?_)
-    · exact (measurable_fst.norm.aestronglyMeasurable)
-    · simp only [Function.comp_def, Real.norm_of_nonneg (norm_nonneg _)]
-      exact (norm_fst_le z)
-  -- **F1 (phase-space anchor)**: `M_f₀` is the *phase-space* first moment
-  -- `∫z‖z‖∂f₀`, NOT the spatial marginal — matching `phi_moment_envelope_le`'s
-  -- (A.2) `integral_map` initial value, so the envelope dominates both the
-  -- pushforward moments (A.2) and the spatial base case (`∫‖x‖∂μ₀ ≤ M_f₀`).
-  let M_f₀ : ℝ := ∫ z : PhaseSpace d, ‖z‖ ∂f₀
-  have hM_f₀_nn : 0 ≤ M_f₀ := integral_nonneg (fun z => norm_nonneg z)
-  -- ============================================================
-  -- Step 2: time-dependent moment envelope `m` (option 2, dissolving the
-  -- constant-`M` fixed-point).  `gronwall_envelope_exists` (Piece A.3) under
-  -- `hB := B(T) < 1` yields a monotone `m` that is `Φ`-invariant at the moment
-  -- level, so `Φ : space(m) → space(m)` and the Picard sequence stays in one
-  -- fixed curve space.
-  -- ============================================================
-  obtain ⟨m, hm_mono, hm_ge, hm_inv⟩ :=
-    gronwall_envelope_exists M_f₀ ‖gradW 0‖ hM_f₀_nn (norm_nonneg _) L T hT.le hB
-  have hm_nn : ∀ t ∈ Set.Icc (0 : ℝ) T, 0 ≤ m t :=
-    fun t ht => le_trans hM_f₀_nn (hm_ge t ht)
-  have hMbar_nn : 0 ≤ m T := hm_nn T ⟨hT.le, le_refl T⟩
-  have hMbar_mono : ∀ t ∈ Set.Icc (0 : ℝ) T, m t ≤ m T :=
-    fun t ht => hm_mono ht ⟨hT.le, le_refl T⟩ ht.2
-  -- ============================================================
-  -- Step 3: Convolution integrability for constantCurve.
-  -- For the base case x 0 = constantCurve μ₀, need h_int_ext:
-  --   ∀ t (x : PhysSpace d), Integrable (fun y => gradW (x - y)) ((constantCurve μ₀).extend t).
-  -- This reduces to: Integrable (fun y => gradW (x - y)) μ₀, which follows
-  -- from hμ₀_int + Lipschitz bound on gradW.
-  -- Integrability of gradW against μ₀.
-  -- ============================================================
-  have h_int_gradW_μ₀ : ∀ (x_pt : PhysSpace d),
-      Integrable (fun y => gradW (x_pt - y)) (spatialMarginal f₀) :=
-    fun x_pt => integrable_gradW_shift gradW L hL (spatialMarginal f₀) hμ₀_int x_pt
-  -- ============================================================
-  -- Step 4: Picard sequence + contraction bound.
-  -- The sequence x : ℕ → VlasovMeasureCurve d T M is built by Phi_step +
-  -- induction; the contraction estimate uses Phi_supW1_contraction applied
-  -- to consecutive iterates.
-  -- ============================================================
-  -- `q` is the M-INDEPENDENT genuine contraction ratio (not 2M·q_true).
-  -- `Phi_supW1_contraction` outputs `q · D` per step, so `q^k · D₀ =
-  -- q^k · (2M)` is the iterated contraction bound; the contraction factor
-  -- `q = gronwallBound 0 (max 1 L) L T = (L/(max 1 L)) · (exp((max 1 L)·T) - 1)`
-  -- is separated from the W₁-input bound `D₀ = 2M`.  `hq_lt` closes by direct
-  -- citation of `hTL_con` (LocalSmallnessContraction) after one unfold.
-  let q : ℝ := gronwallBound 0 ((max 1 L : NNReal) : ℝ) (L : ℝ) T
-  have hq_nn : 0 ≤ q := by
-    have hK_nn : (0 : ℝ) ≤ ((max 1 L : NNReal) : ℝ) := NNReal.coe_nonneg _
-    have hε_nn : (0 : ℝ) ≤ (L : ℝ) := L.coe_nonneg
-    have := gronwallBound_mono (δ := (0 : ℝ)) (K := ((max 1 L : NNReal) : ℝ))
-      (ε := (L : ℝ)) (le_refl 0) hε_nn hK_nn hT.le
-    rw [gronwallBound_x0] at this; exact this
-  -- Direct citation: `LocalSmallnessContraction L T` IS `q < 1` after
-  -- unfolding both definitions.  No local derivation; the named-lemma
-  -- pattern from the soundness-fix mechanism.
-  have hq_lt : q < 1 := hTL_con.gronwallBound_lt_one
-  -- D₀: initial supW1On bound = supW1On (x 0).ρ (x 1).ρ ≤ 2 * M.
-  let D₀ : ℝ := 2 * (m T)
-  have hD₀_nn : 0 ≤ D₀ := by linarith [hMbar_nn]
-  -- Picard sequence + contraction, in the fixed envelope space `m`.  The
-  -- recursion uses `Phi_step_envelope` per step + `Phi_supW1_contraction`
-  -- for the geometric bound.
-  -- **Enriched existential**: the Picard sequence exposes, per
-  -- step `k`, the flow `(charXs k, charVs k)` against `(x k).extend` — exactly
-  -- `Phi_step_envelope`'s output shape — plus the pushforward identity
-  -- `(x(k+1)).ρ t = map (charXs k t) f₀`.  Exposing the flows lets the
-  -- self-consistency proof (Step 8) feed them directly to `Phi_supW1_contraction`,
-  -- dissolving the (un-banked) ODE-uniqueness that re-deriving them would need.
-  have hμ₀_int_fst : Integrable (fun z : PhaseSpace d => ‖z.1‖) f₀ :=
-    hf₀_int.mono' measurable_fst.norm.aestronglyMeasurable
-      (Filter.Eventually.of_forall fun z => by
-        rw [Real.norm_of_nonneg (norm_nonneg _)]; exact norm_fst_le z)
-  have hμ₀_le_m : ∀ t ∈ Set.Icc (0 : ℝ) T,
-      ∫ y, ‖y‖ ∂(spatialMarginal f₀) ≤ m t := by
-    intro t ht
-    have h_eq : ∫ y, ‖y‖ ∂(spatialMarginal f₀) = ∫ z, ‖z.1‖ ∂f₀ := by
-      unfold spatialMarginal
-      rw [integral_map measurable_fst.aemeasurable continuous_norm.aestronglyMeasurable]
-    have h_le : ∫ z, ‖z.1‖ ∂f₀ ≤ M_f₀ :=
-      integral_mono hμ₀_int_fst hf₀_int (fun z => norm_fst_le z)
-    rw [h_eq]; exact le_trans h_le (hm_ge t ht)
-  obtain ⟨x, charXs, charVs, h_contract, h_flow⟩ :=
-    vlasovWellPosedness_local_picard_sequence W gradW hgradW L hL f₀ hf₀_int hT hTL_PL
-      m hm_mono hm_nn hm_inv hMbar_nn hMbar_mono hμ₀_prob hμ₀_int hμ₀_le_m
-      q hq_nn rfl D₀ hD₀_nn rfl
-  -- ============================================================
-  -- Step 5: Extract limit ρ_lim via picard_iterate_exists_limit.
-  -- ============================================================
-  obtain ⟨ρ_lim, h_tendsto⟩ :=
-    picard_iterate_exists_limit x q hq_nn hq_lt D₀ hD₀_nn h_contract
-  -- ============================================================
-  -- Step 6: Convolution integrability for ρ_lim.extend.
-  -- Needed by exists_vlasov_characteristicFlow_global_smallT.
-  -- Integrability of gradW against ρ_lim.extend t.
-  -- ============================================================
-  have h_int_ρ_lim : ∀ t (x_pt : PhysSpace d),
-      Integrable (fun y => gradW (x_pt - y)) (ρ_lim.extend t) := fun t x_pt =>
-    integrable_gradW_shift gradW L hL (ρ_lim.extend t)
-      (VlasovMeasureCurve.extend_yIntegrable hT.le ρ_lim t) x_pt
-  -- Convolution continuity for ρ_lim.extend, universal in t.
-  -- Deduced from ρ_lim.extend_convCont + h_int_ρ_lim restricted to Icc 0 T.
-  have h_conv_cont_ρ_lim : ∀ x : PhysSpace d,
-      Continuous (fun t => convolveFunctionMeasure gradW (ρ_lim.extend t) x) := by
-    intro x_pt
-    have h_int_Icc : ∀ t ∈ Set.Icc (0 : ℝ) T,
-        Integrable (fun y => gradW (x_pt - y)) (ρ_lim.ρ t) := by
-      intro t ht
-      have h_eq : ρ_lim.extend t = ρ_lim.ρ t := by
-        unfold VlasovMeasureCurve.extend clampToIcc
-        congr 1
-        rw [min_eq_left ht.2, max_eq_right ht.1]
-      rw [← h_eq]; exact h_int_ρ_lim t x_pt
-    exact VlasovMeasureCurve.extend_convCont gradW L hL hT.le ρ_lim x_pt h_int_Icc
-  -- ============================================================
-  -- Step 7: Flow construction via exists_vlasov_characteristicFlow_global_smallT.
-  -- Build (charX, charV) against ρ_lim.extend.
-  -- ============================================================
-  obtain ⟨charX, charV, hflow_on_ρlim, h_boundary_ρlim⟩ :=
-    exists_vlasov_characteristicFlow_global_smallT W gradW hgradW L hL
-      ρ_lim.extend h_int_ρ_lim h_conv_cont_ρ_lim
-      (fun t => VlasovMeasureCurve.extend_yIntegrable hT.le ρ_lim t)
-      (m T) hMbar_nn
-      (fun t => le_trans (VlasovMeasureCurve.extend_hasMoment hT.le ρ_lim t)
-        (hMbar_mono (clampToIcc T t) (clampToIcc_mem hT.le t)))
-      T hT.le hTL_PL
-  -- ============================================================
-  -- Step 8: Self-consistency.  For t ∈ Icc 0 T,
-  --   ρ_lim.ρ t = spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ t).
-  -- This is the Picard fixed-point equation: Phi charX f₀ t = ρ_lim.ρ t,
-  -- proved by triangle through x n using contraction + tendsto.
-  -- ============================================================
-  -- ============================================================
-  -- Self-consistency on Icc 0 T.
-  -- For t ∈ Icc 0 T:
-  --   ρ_lim.extend t = ρ_lim.ρ t   (by clampToIcc identity on Icc)
-  --   ρ_lim.ρ t = spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ t)
-  -- The second equality is the Picard fixed-point equation, proved by triangle
-  -- through x n using contraction + tendsto.
-  -- ============================================================
-  have h_self_consist : ∀ t ∈ Set.Icc (0 : ℝ) T,
-      ρ_lim.extend t =
-      spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ t) :=
-    -- Step 8 extracted as `picardLimit_self_consistency`; the let-bound `q`'s
-    -- defining equation is supplied by `rfl`.
-    picardLimit_self_consistency gradW L hL f₀ hf₀_int hT m hMbar_nn hMbar_mono
-      q hq_nn hq_lt rfl D₀ hD₀_nn x charXs charVs h_contract h_flow
-      ρ_lim h_tendsto charX charV hflow_on_ρlim h_boundary_ρlim h_int_ρ_lim
-  -- ============================================================
-  -- Step 9: Bundle with a CLAMPED flow `cX s := charX (clampToIcc T s)`.
-  --
-  -- The raw flow from `exists_vlasov_characteristicFlow_global_smallT` is
-  -- controlled only on `[0, T]`; off-window it is uncontrolled
-  -- `Classical.choose` data with no growth bound.  The conclusion's
-  -- universal-in-`s` conjuncts (convolution integrability + continuity-in-x
-  -- for ALL `s`) therefore cannot hold for the raw flow.  We return instead
-  -- the clamped flow, whose pushforward at any `s` equals the on-window
-  -- pushforward at `clampToIcc T s ∈ [0, T]` — hence globally controlled.
-  -- On `[0, T]` the clamp is the identity (`clampToIcc T s = s`), so every
-  -- window conjunct (flow ODE on Ioo, boundary on Icc, moment, integrability)
-  -- transfers from the raw flow via `clampToIcc`-congruence.
-  -- ============================================================
-  exact picardFlow_clamp_bundle gradW L hL f₀ hT m hMbar_nn hMbar_mono ρ_lim
-    charX charV hflow_on_ρlim h_boundary_ρlim h_int_ρ_lim h_self_consist
-
-/-- **Sub-helper for `vlasovWellPosedness_local`** — moment-bound transport.
-
-Given the Picard fixed-point flow's bundle (from
-`_picard_fixedPointFlow`), produces `HasFiniteFirstMoment (f t)` for
-`t ∈ Icc 0 T`, where `f := vlasovSolutionViaPushforward charX charV f₀`.
-
-**Proof strategy**:
-
-1. Boundary transport: extract `h_init / h_cont_Icc / h_deriv_Ico` from
-   `hflow_on + h_boundary` via `characteristicFlow_boundary_regularity`.
-2. `flow_distance_growth_bound_on` applied to `(charX, charV)` produces
-   the growth constant `C_T` with `‖(charX t z, charV t z)‖ ≤ C_T * (‖z‖ + 1)`.
-3. Probability of `f t = Measure.map (z ↦ (charX t z, charV t z)) f₀` from
-   the AEMeasurable witness.
-4. Integrable `‖·‖` on `f t`: via `integrable_map_measure` + growth bound +
-   `Integrable ‖·‖ f₀`.
-
-Factored out to keep `vlasovWellPosedness_local`'s body a clean glue. -/
-theorem vlasovWellPosedness_local_moment
-    {d : ℕ}
-    (W : PhysSpace d → ℝ)
-    (gradW : PhysSpace d → PhysSpace d)
-    (_hgradW : ∀ x, gradW x = gradient W x)
-    (L : NNReal) (hL : LipschitzWith L gradW)
-    (f₀ : Measure (PhaseSpace d)) [IsProbabilityMeasure f₀]
-    (hf₀_int : Integrable (fun z : PhaseSpace d => ‖z‖) f₀)
-    {T : ℝ} (hT : 0 < T)
-    (_hTL_PL : LocalSmallnessPLBuffer L T)
-    (_hTL_con : LocalSmallnessContraction L T)
-    (charX charV : ℝ → PhaseSpace d → PhysSpace d)
-    (M_ρ : ℝ) (hM_ρ_nn : 0 ≤ M_ρ)
-    (hflow_on : IsCharacteristicFlowOn gradW
-      (fun t => spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ t))
-      charX charV (Set.Ioo 0 T) Set.univ)
-    (h_boundary : ∀ z : PhaseSpace d, ∀ t ∈ Set.Icc (0 : ℝ) T,
-      HasDerivWithinAt (fun s => charX s z) (charV t z) (Set.Icc 0 T) t ∧
-      HasDerivWithinAt (fun s => charV s z)
-        (-(convolveFunctionMeasure gradW
-            (spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ t))
-            (charX t z)))
-        (Set.Icc 0 T) t)
-    (hM_ρ_bound : ∀ s ∈ Set.Icc (0 : ℝ) T,
-      ∫ y, ‖y‖ ∂(spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ s)) ≤ M_ρ)
-    (h_y_int_ρ : ∀ s ∈ Set.Icc (0 : ℝ) T,
-      Integrable (fun y : PhysSpace d => ‖y‖)
-        (spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ s)))
-    (_hconv_cont : ∀ s, Continuous (fun x =>
-      convolveFunctionMeasure gradW
-        (spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ s)) x))
-    -- Passed from `_picard_fixedPointFlow`'s enriched output: the
-    -- AEMeasurable witness + universal-in-s convolution integrability.
-    (h_aemeas : ∀ s, AEMeasurable (fun z : PhaseSpace d => (charX s z, charV s z)) f₀)
-    (h_int_conv : ∀ s (x : PhysSpace d),
-      Integrable (fun y => gradW (x - y))
-        (spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ s)))
-    (t : ℝ) (ht : t ∈ Set.Icc (0 : ℝ) T) :
-    HasFiniteFirstMoment (vlasovSolutionViaPushforward charX charV f₀ t) := by
-  -- IsProbabilityMeasure for the spatial marginal (needed for the flow typeclass).
-  -- spatialMarginal μ = Measure.map Prod.fst μ, so IsProbabilityMeasure_map needs
-  -- AEMeasurable Prod.fst (Measure.map ... f₀). Since Prod.fst is measurable,
-  -- it is AEMeasurable wrt any measure.
-  have hρ_prob : ∀ s, IsProbabilityMeasure
-      (spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ s)) := by
-    intro s
-    unfold spatialMarginal vlasovSolutionViaPushforward
-    -- Need IsProbabilityMeasure (Measure.map Prod.fst (Measure.map (fun z => ...) f₀))
-    -- Use Measure.map_map to compose, then isProbabilityMeasure_map_iff on the composition.
-    have h_aemeas_pair : AEMeasurable (fun z : PhaseSpace d => (charX s z, charV s z)) f₀ :=
-      h_aemeas s
-    have h_prob_inner : IsProbabilityMeasure
-        (Measure.map (fun z : PhaseSpace d => (charX s z, charV s z)) f₀) :=
-      (Measure.isProbabilityMeasure_map_iff h_aemeas_pair).mpr inferInstance
-    exact (Measure.isProbabilityMeasure_map_iff measurable_fst.aemeasurable).mpr inferInstance
-  -- Step 1: Extract h_init, h_cont_Icc, h_deriv_Ico via boundary transport.
-  obtain ⟨h_init, h_cont_Icc, h_deriv_Ico⟩ :=
-    characteristicFlow_boundary_regularity gradW
-      (fun t => spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ t))
-      charX charV T hT.le hflow_on h_boundary
-  -- Step 2: Growth bound from flow_distance_growth_bound_on.
-  obtain ⟨C_T, hC_T_nn, h_growth⟩ :=
-    flow_distance_growth_bound_on gradW L hL
-      (fun s => spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ s))
-      charX charV T hT.le
-      h_init h_cont_Icc h_deriv_Ico
-      M_ρ hM_ρ_nn hM_ρ_bound h_y_int_ρ h_int_conv
-  -- Step 3: Conclude HasFiniteFirstMoment.
-  unfold HasFiniteFirstMoment vlasovSolutionViaPushforward
-  refine ⟨(Measure.isProbabilityMeasure_map_iff (h_aemeas t)).mpr inferInstance, ?_⟩
-  -- Integrable ‖·‖ wrt Measure.map (fun z => (charX t z, charV t z)) f₀.
-  rw [integrable_map_measure
-    (Continuous.aestronglyMeasurable continuous_norm) (h_aemeas t)]
-  -- Now need: Integrable (fun z : PhaseSpace d => ‖(charX t z, charV t z)‖) f₀.
-  have h_dom_int : Integrable (fun z : PhaseSpace d => C_T * (‖z‖ + 1)) f₀ := by
-    have h1 : Integrable (fun z : PhaseSpace d => C_T * ‖z‖) f₀ :=
-      hf₀_int.const_mul C_T
-    have h2 : Integrable (fun _ : PhaseSpace d => C_T) f₀ := integrable_const _
-    have h_eq : (fun z : PhaseSpace d => C_T * (‖z‖ + 1)) =
-                fun z => C_T * ‖z‖ + C_T := by funext z; ring
-    rw [h_eq]; exact h1.add h2
-  -- The goal after rw is: Integrable (‖·‖ ∘ fun z => (charX t z, charV t z)) f₀
-  -- = Integrable (fun z => ‖(charX t z, charV t z)‖) f₀.
-  -- Dominator: C_T * (‖z‖ + 1); AE bound from h_growth.
-  have h_norm_aesm : AEStronglyMeasurable
-      (fun z : PhaseSpace d => ‖(charX t z, charV t z)‖) f₀ :=
-    (h_aemeas t).norm.aestronglyMeasurable
-  refine h_dom_int.mono' ?_ (Filter.Eventually.of_forall fun z => ?_)
-  · -- AEStronglyMeasurable of ‖·‖ ∘ (charX t, charV t).
-    -- After integrable_map_measure rewrite, goal is for the composition form.
-    convert h_norm_aesm using 1
-    rfl
-  · -- Pointwise bound: ‖(charX t z, charV t z)‖ ≤ C_T * (‖z‖ + 1).
-    -- The norm in the goal is ‖(‖·‖ ∘ ...)(z)‖ = ‖‖(charX t z, charV t z)‖‖.
-    simp only [Function.comp_def, Real.norm_of_nonneg (norm_nonneg _)]
-    exact h_growth t ht z
-
-/-- **Sub-helper for `vlasovWellPosedness_local`** — IsLagrangianVlasovSolutionOn
-threading.
-
-Given the Picard fixed-point flow's bundle (from
-`_picard_fixedPointFlow`), produces the
-`IsLagrangianVlasovSolutionOn gradW f T` conjunct via the 20-hypothesis
-threading through
-`vlasovSolutionViaPushforward_isLagrangianVlasovSolutionOn`.
-
-**Proof strategy**:
-
-1. Boundary transport: extract `h_init / h_cont_Icc / h_deriv_Ico`.
-2. Universal-in-`s` convolution integrability (handling `s` outside
-   `[0, T]` via the clamp-extension argument).
-3. AEMeasurable witness.
-4. `IsCharacteristicFlowSelfConsistent`: `∀ t, ρ_lim t = Φ charX f₀ t`,
-   which expands by definition since `ρ_lim = spatialMarginal ∘ f` and
-   `f = vlasovSolutionViaPushforward charX charV f₀`; spatial marginal
-   of pushforward = pushforward under `Prod.fst ∘ ...` = `Φ charX f₀`.
-   The composition is the `Measure.map_map`-with-AEMeasurable bridge.
-5. Continuity of `gradW`: `hL.continuous`.
-6. Probability instance of `spatialMarginal ∘ f`: derived from
-   AEMeasurable + IsProbabilityMeasure f₀.
-7. Final invocation: `vlasovSolutionViaPushforward_isLagrangianVlasovSolutionOn`
-   with the full hypothesis bundle.
-
-Factored out to keep `vlasovWellPosedness_local`'s body a clean glue. -/
-theorem vlasovWellPosedness_local_isLagrangian
-    {d : ℕ}
-    (W : PhysSpace d → ℝ)
-    (gradW : PhysSpace d → PhysSpace d)
-    (_hgradW : ∀ x, gradW x = gradient W x)
-    (L : NNReal) (hL : LipschitzWith L gradW)
-    (f₀ : Measure (PhaseSpace d)) [IsProbabilityMeasure f₀]
-    (hf₀_int : Integrable (fun z : PhaseSpace d => ‖z‖) f₀)
-    {T : ℝ} (hT : 0 < T)
-    (_hTL_PL : LocalSmallnessPLBuffer L T)
-    (_hTL_con : LocalSmallnessContraction L T)
-    (charX charV : ℝ → PhaseSpace d → PhysSpace d)
-    (M_ρ : ℝ) (hM_ρ_nn : 0 ≤ M_ρ)
-    (hflow_on : IsCharacteristicFlowOn gradW
-      (fun t => spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ t))
-      charX charV (Set.Ioo 0 T) Set.univ)
-    (h_boundary : ∀ z : PhaseSpace d, ∀ t ∈ Set.Icc (0 : ℝ) T,
-      HasDerivWithinAt (fun s => charX s z) (charV t z) (Set.Icc 0 T) t ∧
-      HasDerivWithinAt (fun s => charV s z)
-        (-(convolveFunctionMeasure gradW
-            (spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ t))
-            (charX t z)))
-        (Set.Icc 0 T) t)
-    (hM_ρ_bound : ∀ s ∈ Set.Icc (0 : ℝ) T,
-      ∫ y, ‖y‖ ∂(spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ s)) ≤ M_ρ)
-    (h_y_int_ρ : ∀ s ∈ Set.Icc (0 : ℝ) T,
-      Integrable (fun y : PhysSpace d => ‖y‖)
-        (spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ s)))
-    (hconv_cont : ∀ s, Continuous (fun x =>
-      convolveFunctionMeasure gradW
-        (spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ s)) x))
-    -- Passed from `_picard_fixedPointFlow`'s enriched output: the
-    -- AEMeasurable witness + universal-in-s convolution integrability.
-    (h_aemeas : ∀ s, AEMeasurable (fun z : PhaseSpace d => (charX s z, charV s z)) f₀)
-    (h_int_conv : ∀ s (x : PhysSpace d),
-      Integrable (fun y => gradW (x - y))
-        (spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ s))) :
-    IsLagrangianVlasovSolutionOn gradW
-      (vlasovSolutionViaPushforward charX charV f₀) T := by
-  -- IsProbabilityMeasure for the spatial marginal (needed for the target typeclass).
-  have hρ_prob : ∀ s, IsProbabilityMeasure
-      (spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ s)) := by
-    intro s
-    unfold spatialMarginal vlasovSolutionViaPushforward
-    have h_aemeas_pair : AEMeasurable (fun z : PhaseSpace d => (charX s z, charV s z)) f₀ :=
-      h_aemeas s
-    have _h_prob_inner : IsProbabilityMeasure
-        (Measure.map (fun z : PhaseSpace d => (charX s z, charV s z)) f₀) :=
-      (Measure.isProbabilityMeasure_map_iff h_aemeas_pair).mpr inferInstance
-    exact (Measure.isProbabilityMeasure_map_iff measurable_fst.aemeasurable).mpr inferInstance
-  -- Step 1: Extract h_init, h_cont_Icc, h_deriv_Ico via boundary transport.
-  obtain ⟨h_init, h_cont_Icc, h_deriv_Ico⟩ :=
-    characteristicFlow_boundary_regularity gradW
-      (fun t => spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ t))
-      charX charV T hT.le hflow_on h_boundary
-  -- Step 2: IsCharacteristicFlowSelfConsistent
-  -- ρ t = spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ t)
-  --     = Measure.map Prod.fst (Measure.map (fun z => (charX t z, charV t z)) f₀)
-  --     = Measure.map (Prod.fst ∘ fun z => (charX t z, charV t z)) f₀
-  --         [by map_map_of_aemeasurable]
-  --     = Measure.map (charX t) f₀
-  have hself : IsCharacteristicFlowSelfConsistent charX f₀
-      (fun t => spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ t)) := by
-    intro t
-    simp only []
-    unfold spatialMarginal vlasovSolutionViaPushforward
-    -- Goal: Measure.map Prod.fst (Measure.map (fun z => (charX t z, charV t z)) f₀)
-    --     = Measure.map (fun z => charX t z) f₀
-    have h_comp : Measure.map Prod.fst
-        (Measure.map (fun z : PhaseSpace d => (charX t z, charV t z)) f₀) =
-        Measure.map (Prod.fst ∘ fun z : PhaseSpace d => (charX t z, charV t z)) f₀ := by
-      apply AEMeasurable.map_map_of_aemeasurable
-      · exact measurable_fst.aemeasurable
-      · exact h_aemeas t
-    rw [h_comp]; congr 1
-  -- Step 3: Apply the main threading theorem.
-  exact vlasovSolutionViaPushforward_isLagrangianVlasovSolutionOn
-    gradW L hL charX charV f₀ hf₀_int hT
-    hflow_on h_init h_cont_Icc h_deriv_Ico
-    M_ρ hM_ρ_nn hM_ρ_bound h_y_int_ρ h_int_conv
-    hself h_aemeas hL.continuous hconv_cont
-
-/-- **Local existence of a Vlasov solution on `[0, T]`.**
-
-Under the joint constraint `LocalSmallnessPLBuffer L T` (`L · T² < 1`) +
-`LocalSmallnessContraction L T`, produces a local-time Vlasov solution
-`f : ℝ → Measure (PhaseSpace d)` on `[0, T]` satisfying initial
-condition + local finite first moment + `IsLagrangianVlasovSolutionOn`.
-
-The forward-iteration continuation extends from local `T` to arbitrary
-`T_target` via **fixed-`T_0`** iteration: the contraction time `T_0`
-depends only on `L` (not on the moment bound `M_n` propagating through
-iterations), because `Phi_supW1_contraction`'s `q` is
-`gronwallBound 0 (max 1 L) (L · D) T` — independent of `M_n`.  So the
-continuation iterates `[0, T_0], [T_0, 2 T_0], …` with constant step `T_0`,
-reaching any `T_target` in `⌈T_target / T_0⌉` windows; gluing then bridges
-from `IsLagrangianVlasovSolutionOn` (local) to `IsLagrangianVlasovSolution`
-(global).
-
-**Proof strategy**:
-
-1. Initial spatial marginal: `μ₀ := spatialMarginal f₀`.  By
-   `HasFiniteFirstMoment f₀`, `μ₀` is a probability measure with
-   `Integrable ‖·‖`.  Let `M_f₀ := ∫ ‖z‖ ∂f₀` (finite by
-   `hf₀.2.integral_norm_le`).
-
-2. Picard sequence on spatial marginals:
-   - `ρ_0 := constantCurve μ₀`.
-   - `ρ_{n+1}` obtained via `Phi_step` applied to `ρ_n`'s flow.
-
-   Each `ρ_n` lives in `VlasovMeasureCurve d T M` for an appropriate
-   `M` chosen so that the growth bound from
-   `flow_distance_growth_bound_on` stays within `M` across iterations
-   (the M-preservation constraint).
-
-3. Contraction estimate via `Phi_supW1_contraction`:
-   `supW1On (ρ_n.ρ) (ρ_{n+1}.ρ) ≤ ENNReal.ofReal (q^n * D₀)`
-   for `q := gronwallBound 0 (max 1 L) (L · D) T < 1` (since `T` is
-   small enough per the joint constraint).
-
-4. Apply `picard_iterate_isCauchy_of_contraction` to get the ENNReal-form
-   Cauchy condition on the `supW1On` pseudodistance.
-
-5. Apply `picard_iterate_exists_limit` to extract the
-   limit `ρ_lim : VlasovMeasureCurve d T M` plus pointwise W₁-tendsto.
-
-6. Self-consistency `Φ(ρ_lim) = ρ_lim`: triangle through `ρ_n` using
-   the uniform-tendsto helper, contraction, and pointwise tendsto.
-
-7. Apply `exists_vlasov_characteristicFlow_global_smallT`
-   to `ρ_lim.extend` to get the characteristic flow `(charX, charV)`
-   against the self-consistent limit.
-
-8. Define `f := vlasovSolutionViaPushforward charX charV f₀`.  Verify:
-   - `f 0 = f₀` (from `IsCharacteristicFlowOn`'s initial-condition
-     clause + `Measure.map_id`).
-   - `HasFiniteFirstMoment (f t)` on `[0, T]` (from
-     `flow_distance_growth_bound_on` applied to `(charX, charV)` +
-     `hf₀.2`).
-   - `IsLagrangianVlasovSolutionOn gradW f T` via
-     `vlasovSolutionViaPushforward_isLagrangianVlasovSolutionOn`.
-
-The body invokes `vlasovWellPosedness_local_picard_fixedPointFlow` for the
-Picard fixed-point flow, then `vlasovWellPosedness_local_finalAssembly_*`
-for the moment and Lagrangian conjuncts, deriving `f 0 = f₀` inline. -/
-theorem vlasovWellPosedness_local
-    {d : ℕ} [NeZero d]
-    (W : PhysSpace d → ℝ)
-    (gradW : PhysSpace d → PhysSpace d)
-    (hgradW : ∀ x, gradW x = gradient W x)
-    (L : NNReal) (hL : LipschitzWith L gradW)
-    (f₀ : Measure (PhaseSpace d))
-    (hf₀ : HasFiniteFirstMoment f₀)
-    {T : ℝ} (hT : 0 < T)
-    (hTL_PL : LocalSmallnessPLBuffer L T)
-    (hTL_con : LocalSmallnessContraction L T)
-    (hB : (L : ℝ) / (1 + (L : ℝ)) * (Real.exp ((1 + (L : ℝ)) * T) - 1) < 1) :
-    ∃ (f : ℝ → Measure (PhaseSpace d))
-      (charX charV : ℝ → PhaseSpace d → PhysSpace d),
-      f 0 = f₀ ∧
-      (∀ t ∈ Set.Icc (0 : ℝ) T, HasFiniteFirstMoment (f t)) ∧
-      -- FLAT (window-constant) uniform first-moment bound on the spatial marginal.
-      (∃ M : ℝ, 0 ≤ M ∧
-        ∀ t ∈ Set.Icc (0 : ℝ) T, ∫ y, ‖y‖ ∂(spatialMarginal (f t)) ≤ M) ∧
-      IsLagrangianVlasovSolutionOn gradW f T ∧
-      -- Explicit flow bundle: pushforward, AEMeasurable, and boundary derivatives.
-      -- These use the SAME charX charV as the outer ∃ (not the hidden witnesses
-      -- inside IsLagrangianVlasovSolutionOn), enabling downstream consumers to
-      -- use them without witness-identity issues.
-      (∀ t ∈ Set.Icc (0 : ℝ) T,
-        f t = Measure.map (fun z : PhaseSpace d => (charX t z, charV t z)) (f 0)) ∧
-      (∀ s ∈ Set.Icc (0 : ℝ) T,
-        AEMeasurable (fun z : PhaseSpace d => (charX s z, charV s z)) (f 0)) ∧
-      (∀ z : PhaseSpace d, ∀ t ∈ Set.Icc (0 : ℝ) T,
-        HasDerivWithinAt (fun s => charX s z) (charV t z) (Set.Icc 0 T) t ∧
-        HasDerivWithinAt (fun s => charV s z)
-          (-(convolveFunctionMeasure gradW (spatialMarginal (f t)) (charX t z)))
-          (Set.Icc 0 T) t) ∧
-      -- Initial condition for the outer charX charV (same witnesses as boundary bundle above).
-      (∀ z : PhaseSpace d, charX 0 z = z.1 ∧ charV 0 z = z.2) := by
-  -- The body is decomposed into two sub-helpers plus an inline glue:
-  --   * `vlasovWellPosedness_local_picard_fixedPointFlow` carries the Picard
-  --     mathematics — spatial-marginal setup, the Picard sequence via
-  --     `Phi_step`, the contraction estimate via `Phi_supW1_contraction`,
-  --     the limit via `picard_iterate_exists_limit`,
-  --     self-consistency `Φ(ρ_lim) = ρ_lim`, and the flow construction via
-  --     `exists_vlasov_characteristicFlow_global_smallT`.
-  --   * `vlasovWellPosedness_local_finalAssembly_*` thread the moment and
-  --     `IsLagrangianVlasovSolutionOn` conjuncts through
-  --     `vlasovSolutionViaPushforward_isLagrangianVlasovSolutionOn`.
-  --   * This body invokes both, derives `f 0 = f₀` inline, and assembles.
-  obtain ⟨hf₀_prob, hf₀_int⟩ := hf₀
-  have : IsProbabilityMeasure f₀ := hf₀_prob
-  -- Sub-helper invocation: produces the self-consistent flow + regularity
-  -- + AEMeasurable witness + universal-in-s convolution integrability.
-  obtain ⟨charX, charV, _M_ρ, _hM_ρ_nn, _hflow_on, _h_boundary,
-          _hM_ρ_bound, _h_y_int_ρ, _hconv_cont, _h_aemeas, _h_int_conv⟩ :=
-    vlasovWellPosedness_local_picard_fixedPointFlow W gradW hgradW L hL
-      f₀ hf₀_int hT hTL_PL hTL_con hB
-  -- Bundle the f-shape result.
-  refine ⟨vlasovSolutionViaPushforward charX charV f₀, charX, charV, ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_⟩
-  · -- (a) f 0 = f₀.  The flow's initial-condition clause gives
-    -- (charX 0 z, charV 0 z) = z for every z, so the pushforward at t = 0
-    -- is `Measure.map id f₀ = f₀`.  Proved inline via the sub-helper's
-    -- initial-condition projection at t = 0.
-    have h_init : ∀ z : PhaseSpace d, (charX 0 z, charV 0 z) = z := by
-      intro z
-      have := (_hflow_on.1 z (Set.mem_univ z))
-      exact Prod.ext this.1 this.2
-    change vlasovSolutionViaPushforward charX charV f₀ 0 = f₀
-    unfold vlasovSolutionViaPushforward
-    have h_at_0 : (fun z : PhaseSpace d => (charX 0 z, charV 0 z)) = id := by
-      funext z; exact h_init z
-    rw [h_at_0, Measure.map_id]
-  · -- (b) HasFiniteFirstMoment (f t) on Icc 0 T.  Deferred to the
-    -- _finalAssembly sub-helper (since it requires C_T from
-    -- flow_distance_growth_bound_on, plus the integral_map +
-    -- pushforward-moment-bound chain — exactly the threading work that
-    -- the _finalAssembly sub-helper handles).
-    intro t ht
-    exact vlasovWellPosedness_local_moment W gradW hgradW L hL
-      f₀ hf₀_int hT hTL_PL hTL_con charX charV
-      _M_ρ _hM_ρ_nn _hflow_on _h_boundary _hM_ρ_bound _h_y_int_ρ _hconv_cont
-      _h_aemeas _h_int_conv
-      t ht
-  · -- (b′) FLAT uniform first-moment bound on the spatial marginal.
-    -- The picard fixed-point flow already exposes exactly this bound
-    -- (`_hM_ρ_bound`) for `M_ρ := _M_ρ` against
-    -- `spatialMarginal (vlasovSolutionViaPushforward charX charV f₀ ·)`,
-    -- which is `spatialMarginal (f ·)` by definition of `f` here.
-    exact ⟨_M_ρ, _hM_ρ_nn, _hM_ρ_bound⟩
-  · -- (c) IsLagrangianVlasovSolutionOn gradW f T.  Handled by the
-    -- _finalAssembly sub-helper: it derives the AEMeasurable witness, the
-    -- IsCharacteristicFlowSelfConsistent discharge, the universal-in-s
-    -- convolution integrability (extension of `_hconv_cont`'s implications),
-    -- and threads all the hypotheses through
-    -- `vlasovSolutionViaPushforward_isLagrangianVlasovSolutionOn`.
-    exact vlasovWellPosedness_local_isLagrangian W gradW hgradW L hL
-      f₀ hf₀_int hT hTL_PL hTL_con charX charV
-      _M_ρ _hM_ρ_nn _hflow_on _h_boundary _hM_ρ_bound _h_y_int_ρ _hconv_cont
-      _h_aemeas _h_int_conv
-  · -- (d) Explicit pushforward equation for the outer charX charV.
-    -- vlasovSolutionViaPushforward charX charV f₀ t = Measure.map (charX t, charV t) f₀
-    -- by DEFINITION. And f 0 = f₀ (from goal (a), which used the initial condition).
-    -- So f t = Measure.map (charX t, charV t) (f 0) by congruence on f 0 = f₀.
-    have h_f0_eq : vlasovSolutionViaPushforward charX charV f₀ 0 = f₀ := by
-      have h_init : ∀ z : PhaseSpace d, (charX 0 z, charV 0 z) = z :=
-        fun z => Prod.ext (_hflow_on.1 z (Set.mem_univ z)).1 (_hflow_on.1 z (Set.mem_univ z)).2
-      simp [vlasovSolutionViaPushforward,
-            show (fun z : PhaseSpace d => (charX 0 z, charV 0 z)) = id from funext h_init]
-    intro t _
-    show vlasovSolutionViaPushforward charX charV f₀ t =
-      Measure.map (fun z : PhaseSpace d => (charX t z, charV t z))
-        (vlasovSolutionViaPushforward charX charV f₀ 0)
-    rw [h_f0_eq]
-    -- After rw, goal is: vlasovSolutionViaPushforward charX charV f₀ t = Measure.map ... f₀
-    -- This is rfl by definition of vlasovSolutionViaPushforward.
-    rfl
-  · -- (e) Explicit AEMeasurable for the outer charX charV.
-    -- AEMeasurable (fun z => (charX s z, charV s z)) f₀ comes from _h_aemeas.
-    -- The expected type uses (f 0) = vlasovSolutionViaPushforward charX charV f₀ 0 = f₀.
-    have h_f0_eq : vlasovSolutionViaPushforward charX charV f₀ 0 = f₀ := by
-      have h_init : ∀ z : PhaseSpace d, (charX 0 z, charV 0 z) = z :=
-        fun z => Prod.ext (_hflow_on.1 z (Set.mem_univ z)).1 (_hflow_on.1 z (Set.mem_univ z)).2
-      simp [vlasovSolutionViaPushforward,
-            show (fun z : PhaseSpace d => (charX 0 z, charV 0 z)) = id from funext h_init]
-    intro s _
-    rw [h_f0_eq]
-    exact _h_aemeas s
-  · -- (f) Boundary regularity bundle: HasDerivWithinAt on Icc 0 T for all z, t.
-    -- Directly from `_h_boundary` (the picard fixed-point flow's boundary output).
-    -- The measure in the velocity derivative uses spatialMarginal (f t) where
-    -- f = vlasovSolutionViaPushforward charX charV f₀, which is the same as
-    -- what _h_boundary was built against.
-    exact _h_boundary
-  · -- (g) Initial condition for the outer charX charV witnesses.
-    -- From _hflow_on.1 (IsCharacteristicFlowOn's first conjunct).
-    intro z
-    exact _hflow_on.1 z (Set.mem_univ z)
+private alias picardLimit_fixed_point_eq :=
+  _root_.Vlasov.picardLimit_fixed_point_eq
 
-/-! ## Banked infrastructure: localized `hasDerivAt_of_hasDerivAt_of_ne` -/
--- Generic real-analysis helper banked for `vlasovWellPosedness_glue` case (a)'s substantive
--- close.  Mathlib's `hasDerivAt_of_hasDerivAt_of_ne`
--- (Mathlib/Analysis/Calculus/FDeriv/Extend.lean) requires a UNIVERSAL
--- `∀ y ≠ x, HasDerivAt f (g y) y` hypothesis; the `vlasovWellPosedness_glue` setting only
--- gives HasDerivAt on a bounded interval `Ioo 0 (T + T_0)`.  This helper
--- localizes the Mathlib pattern to a neighborhood-eventually hypothesis,
--- enabling case (a)'s close via union of one-sided extension lemmas.
+private alias picardLimit_flow_pointwise_contraction :=
+  _root_.Vlasov.picardLimit_flow_pointwise_contraction
 
-section HasDerivAtPunctured
-open scoped Topology
-open Filter
+private alias picardLimit_self_consistency :=
+  _root_.Vlasov.picardLimit_self_consistency
 
-/-- Local version of `hasDerivAt_of_hasDerivAt_of_ne` (Mathlib/Analysis/Calculus/
-FDeriv/Extend.lean): if `f : ℝ → ℝ` has HasDerivAt with derivative `g(y)` at
-every `y ≠ x₀` in some neighborhood of `x₀`, and both `f` and `g` are continuous
-at `x₀`, then `f` has HasDerivAt with derivative `g(x₀)` at `x₀`.
+private alias vlasovWellPosedness_local_picard_sequence :=
+  _root_.Vlasov.vlasovWellPosedness_local_picard_sequence
 
-The proof composes `hasDerivWithinAt_Iic_of_tendsto_deriv` (left side) +
-`hasDerivWithinAt_Ici_of_tendsto_deriv` (right side) + `HasDerivWithinAt.union`,
-following the Mathlib lemma's proof structure but with locally-quantified
-hypothesis (enabling use when the punctured-HasDerivAt holds only on a bounded
-interval, not all of ℝ). -/
-theorem hasDerivAt_of_hasDerivAt_of_ne_in_nhds
-    {f g : ℝ → ℝ} {x₀ : ℝ}
-    (h_diff_ne : ∀ᶠ y in 𝓝 x₀, y ≠ x₀ → HasDerivAt f (g y) y)
-    (hf : ContinuousAt f x₀) (hg : ContinuousAt g x₀) :
-    HasDerivAt f (g x₀) x₀ := by
-  -- Extract an open ball around x₀ on which the punctured HasDerivAt holds.
-  obtain ⟨U, hU_sub, hU_open, hx₀_U⟩ := mem_nhds_iff.mp h_diff_ne
-  obtain ⟨ε, ε_pos, hε⟩ := Metric.isOpen_iff.mp hU_open x₀ hx₀_U
-  -- Right side: HasDerivWithinAt on Ici x₀ via hasDerivWithinAt_Ici_of_tendsto_deriv.
-  have h_right : HasDerivWithinAt f (g x₀) (Set.Ici x₀) x₀ := by
-    have hs_right : Set.Ioo x₀ (x₀ + ε) ∈ 𝓝[>] x₀ :=
-      Ioo_mem_nhdsGT (by linarith : x₀ < x₀ + ε)
-    have h_diff_right : DifferentiableOn ℝ f (Set.Ioo x₀ (x₀ + ε)) := by
-      intro y hy
-      have hy_U : y ∈ U := hε (by
-        rw [Metric.mem_ball, Real.dist_eq, abs_lt]
-        exact ⟨by linarith [hy.1, hy.2], by linarith [hy.1, hy.2]⟩)
-      exact (hU_sub hy_U (ne_of_gt hy.1)).differentiableAt.differentiableWithinAt
-    apply hasDerivWithinAt_Ici_of_tendsto_deriv h_diff_right hf.continuousWithinAt hs_right
-    have h_g_tendsto : Tendsto g (𝓝[>] x₀) (𝓝 (g x₀)) := tendsto_inf_left hg
-    apply h_g_tendsto.congr'
-    apply mem_of_superset hs_right
-    intro y hy
-    have hy_U : y ∈ U := hε (by
-      rw [Metric.mem_ball, Real.dist_eq, abs_lt]
-      exact ⟨by linarith [hy.1, hy.2], by linarith [hy.1, hy.2]⟩)
-    exact (hU_sub hy_U (ne_of_gt hy.1)).deriv.symm
-  -- Left side: symmetric.
-  have h_left : HasDerivWithinAt f (g x₀) (Set.Iic x₀) x₀ := by
-    have hs_left : Set.Ioo (x₀ - ε) x₀ ∈ 𝓝[<] x₀ :=
-      Ioo_mem_nhdsLT (by linarith : x₀ - ε < x₀)
-    have h_diff_left : DifferentiableOn ℝ f (Set.Ioo (x₀ - ε) x₀) := by
-      intro y hy
-      have hy_U : y ∈ U := hε (by
-        rw [Metric.mem_ball, Real.dist_eq, abs_lt]
-        exact ⟨by linarith [hy.1, hy.2], by linarith [hy.1, hy.2]⟩)
-      exact (hU_sub hy_U (ne_of_lt hy.2)).differentiableAt.differentiableWithinAt
-    apply hasDerivWithinAt_Iic_of_tendsto_deriv h_diff_left hf.continuousWithinAt hs_left
-    have h_g_tendsto : Tendsto g (𝓝[<] x₀) (𝓝 (g x₀)) := tendsto_inf_left hg
-    apply h_g_tendsto.congr'
-    apply mem_of_superset hs_left
-    intro y hy
-    have hy_U : y ∈ U := hε (by
-      rw [Metric.mem_ball, Real.dist_eq, abs_lt]
-      exact ⟨by linarith [hy.1, hy.2], by linarith [hy.1, hy.2]⟩)
-    exact (hU_sub hy_U (ne_of_lt hy.2)).deriv.symm
-  -- Union via Set.Iic_union_Ici = Set.univ → HasDerivAt at x₀.
-  simpa using h_left.union h_right
+private alias dobrushinFlow_marginal_gradW_integrable :=
+  _root_.Vlasov.dobrushinFlow_marginal_gradW_integrable
 
-end HasDerivAtPunctured
+private alias vlasovGlue_composed_integral_eq :=
+  _root_.Vlasov.vlasovGlue_composed_integral_eq
 
-/-! ## Variable-`T_target` continuation via fixed-`T_0` iteration -/
--- Composes `vlasovWellPosedness_local` against itself to extend the local
--- solution from `[0, T_0]` to `[0, T_target]` for any `T_target > 0`.  The
--- contraction time `T_0` is *fixed* (depends only on `L`, not on iteration-
--- accumulated moment bounds) — see the docstring on `vlasovWellPosedness_local`
--- (above) for why fixed-`T_0` is the correct iteration shape (the
--- `Phi_supW1_contraction` factor `q` depends only on `L` and `T`).
---
--- Two sub-theorems:
--- * `vlasovWellPosedness_glue`: extend a solution on `[0, T]` by one
---   window of length `T_0`, gluing at `t = T`.
--- * `vlasovWellPosedness_forward`: `Nat.rec` iteration of `vlasovWellPosedness_glue`
---   to reach any `T_target`.
---
--- The universal-in-`t` bridge (below) then goes from
--- `IsLagrangianVlasovSolutionOn` (any `T_target`) to
--- `IsLagrangianVlasovSolution` (universal-in-`t`), and uniqueness follows.
+private alias vlasovGlue_composed_pushforward :=
+  _root_.Vlasov.vlasovGlue_composed_pushforward
 
-/-- The `t = T` seam of the glue: both one-sided derivatives of the spliced
-flow at the junction agree (`g`'s flow starts at the identity on
-`f_prev T`'s data), so `HasDerivWithinAt.union` on `Iic T ∪ Ici T = univ`
-gives the two-sided derivative, restricted back to `Icc 0 (T + T_0)`. -/
-private lemma vlasovWellPosedness_glue_boundary_seam {d : ℕ}
-    (gradW : PhysSpace d → PhysSpace d)
-    {T T_0 : ℝ} (hT_pos : 0 < T) (hT_0_pos : 0 < T_0)
-    (f_prev g f_next : ℝ → Measure (PhaseSpace d))
-    (charX_prev charV_prev charX_g charV_g : ℝ → PhaseSpace d → PhysSpace d)
-    (hdef_f : f_next = fun t => if t ≤ T then f_prev t else g (t - T))
-    (h_prev_boundary : ∀ (z : PhaseSpace d) (t : ℝ), t ∈ Set.Icc (0 : ℝ) T →
-        HasDerivWithinAt (fun s => charX_prev s z) (charV_prev t z) (Set.Icc 0 T) t ∧
-        HasDerivWithinAt (fun s => charV_prev s z)
-          (-(convolveFunctionMeasure gradW (spatialMarginal (f_prev t)) (charX_prev t z)))
-          (Set.Icc 0 T) t)
-    (hg_boundary : ∀ (w : PhaseSpace d) (t : ℝ), t ∈ Set.Icc (0 : ℝ) T_0 →
-        HasDerivWithinAt (fun s => charX_g s w) (charV_g t w) (Set.Icc 0 T_0) t ∧
-        HasDerivWithinAt (fun s => charV_g s w)
-          (-(convolveFunctionMeasure gradW (spatialMarginal (g t)) (charX_g t w)))
-          (Set.Icc 0 T_0) t)
-    (hg_init : g 0 = f_prev T)
-    (hg_init_cond : ∀ (w : PhaseSpace d), charX_g 0 w = w.1 ∧ charV_g 0 w = w.2)
-    (z : PhaseSpace d) :
-    HasDerivWithinAt
-      (fun s => if s ≤ T then charX_prev s z
-        else charX_g (s - T) (charX_prev T z, charV_prev T z))
-      (charV_prev T z) (Set.Icc 0 (T + T_0)) T ∧
-    HasDerivWithinAt
-      (fun s => if s ≤ T then charV_prev s z
-        else charV_g (s - T) (charX_prev T z, charV_prev T z))
-      (-(convolveFunctionMeasure gradW (spatialMarginal (f_next T)) (charX_prev T z)))
-      (Set.Icc 0 (T + T_0)) T := by
-  have hT_in : T ∈ Set.Icc (0 : ℝ) T := ⟨hT_pos.le, le_refl T⟩
-  have h_bX := (h_prev_boundary z T hT_in).1
-  have h_bV := (h_prev_boundary z T hT_in).2
-  have h0_T0_in : (0 : ℝ) ∈ Set.Icc (0 : ℝ) T_0 := ⟨le_refl 0, hT_0_pos.le⟩
-  have h_g_bX := (hg_boundary (charX_prev T z, charV_prev T z) 0 h0_T0_in).1
-  have h_g_bV := (hg_boundary (charX_prev T z, charV_prev T z) 0 h0_T0_in).2
-  have h_nhd_L : Set.Icc 0 T ∈ nhdsWithin T (Set.Iic T) := Icc_mem_nhdsLE hT_pos
-  have h_nhd_R : Set.Icc 0 T_0 ∈ nhdsWithin (0 : ℝ) (Set.Ici 0) := Icc_mem_nhdsGE hT_0_pos
-  -- charX: left one-sided
-  have hX_Lic := h_bX.mono_of_mem_nhdsWithin h_nhd_L
-  have hX_left : HasDerivWithinAt
-      (fun s => if s ≤ T then charX_prev s z
-        else charX_g (s - T) (charX_prev T z, charV_prev T z))
-      (charV_prev T z) (Set.Iic T) T :=
-    hX_Lic.congr_of_mem (fun s hs => by simp [Set.mem_Iic.mp hs]) Set.self_mem_Iic
-  -- charX: right one-sided via chain rule on g's boundary
-  have hX_Ici0 := h_g_bX.mono_of_mem_nhdsWithin h_nhd_R
-  have h_sub_R : HasDerivWithinAt (· - T) 1 (Set.Ici T) T :=
-    ((hasDerivAt_id' T).sub_const T).hasDerivWithinAt
-  have h_mapR : Set.MapsTo (· - T) (Set.Ici T) (Set.Ici 0) :=
-    fun s hs => Set.mem_Ici.mpr (by linarith [Set.mem_Ici.mp hs])
-  have h_chainX : HasDerivWithinAt
-      (fun s => charX_g (s - T) (charX_prev T z, charV_prev T z))
-      (charV_g 0 (charX_prev T z, charV_prev T z)) (Set.Ici T) T := by
-    have := HasDerivWithinAt.scomp_of_eq T hX_Ici0 h_sub_R h_mapR (sub_self T).symm
-    simpa [Function.comp_def, one_smul] using this
-  have hVg0_eq : charV_g 0 (charX_prev T z, charV_prev T z) = charV_prev T z :=
-    (hg_init_cond (charX_prev T z, charV_prev T z)).2
-  rw [hVg0_eq] at h_chainX
-  have hX_right : HasDerivWithinAt
-      (fun s => if s ≤ T then charX_prev s z
-        else charX_g (s - T) (charX_prev T z, charV_prev T z))
-      (charV_prev T z) (Set.Ici T) T :=
-    h_chainX.congr_of_mem
-      (fun s hs => by
-        by_cases hle : s ≤ T
-        · have heq : s = T := le_antisymm hle (Set.mem_Ici.mp hs)
-          simp [heq, sub_self,
-            (hg_init_cond (charX_prev T z, charV_prev T z)).1]
-        · simp [hle])
-      Set.self_mem_Ici
-  have hX_union := hX_left.union hX_right
-  rw [Set.Iic_union_Ici] at hX_union
-  -- charV: analogously
-  have hV_Lic := h_bV.mono_of_mem_nhdsWithin h_nhd_L
-  have hV_left : HasDerivWithinAt
-      (fun s => if s ≤ T then charV_prev s z
-        else charV_g (s - T) (charX_prev T z, charV_prev T z))
-      (-(convolveFunctionMeasure gradW (spatialMarginal (f_next T)) (charX_prev T z)))
-      (Set.Iic T) T := by
-    simp only [hdef_f, ite_eq_left (le_refl T)]
-    exact hV_Lic.congr_of_mem (fun s hs => by simp [Set.mem_Iic.mp hs]) Set.self_mem_Iic
-  have hV_Ici0 := h_g_bV.mono_of_mem_nhdsWithin h_nhd_R
-  have h_chainV : HasDerivWithinAt
-      (fun s => charV_g (s - T) (charX_prev T z, charV_prev T z))
-      (-(convolveFunctionMeasure gradW
-        (spatialMarginal (g 0))
-        (charX_g 0 (charX_prev T z, charV_prev T z))))
-      (Set.Ici T) T := by
-    have := HasDerivWithinAt.scomp_of_eq T hV_Ici0 h_sub_R h_mapR (sub_self T).symm
-    simpa [Function.comp_def, one_smul] using this
-  have hXg0_eq : charX_g 0 (charX_prev T z, charV_prev T z) = charX_prev T z :=
-    (hg_init_cond (charX_prev T z, charV_prev T z)).1
-  have hg0_spat : spatialMarginal (g 0) = spatialMarginal (f_prev T) :=
-    congrArg spatialMarginal hg_init
-  have hfnextT : spatialMarginal (f_next T) = spatialMarginal (f_prev T) :=
-    congrArg spatialMarginal (by rw [hdef_f]; simp only [ite_eq_left (le_refl T)])
-  rw [hXg0_eq, hg0_spat, ← hfnextT] at h_chainV
-  have hV_right : HasDerivWithinAt
-      (fun s => if s ≤ T then charV_prev s z
-        else charV_g (s - T) (charX_prev T z, charV_prev T z))
-      (-(convolveFunctionMeasure gradW (spatialMarginal (f_next T)) (charX_prev T z)))
-      (Set.Ici T) T :=
-    h_chainV.congr_of_mem
-      (fun s hs => by
-        by_cases hle : s ≤ T
-        · have heq : s = T := le_antisymm hle (Set.mem_Ici.mp hs)
-          simp [heq, sub_self,
-            (hg_init_cond (charX_prev T z, charV_prev T z)).2]
-        · simp [hle])
-      Set.self_mem_Ici
-  have hV_union := hV_left.union hV_right
-  rw [Set.Iic_union_Ici] at hV_union
-  exact ⟨hX_union.hasDerivAt Filter.univ_mem |>.hasDerivWithinAt,
-    hV_union.hasDerivAt Filter.univ_mem |>.hasDerivWithinAt⟩
+private alias vlasovGlue_conv_force_bound :=
+  _root_.Vlasov.vlasovGlue_conv_force_bound
 
-private lemma vlasovWellPosedness_glue_boundary {d : ℕ}
-    (gradW : PhysSpace d → PhysSpace d)
-    {T T_0 : ℝ} (hT_pos : 0 < T) (hT_0_pos : 0 < T_0)
-    (f_prev g f_next : ℝ → Measure (PhaseSpace d))
-    (charX_prev charV_prev charX_g charV_g charX_next charV_next :
-        ℝ → PhaseSpace d → PhysSpace d)
-    (hdef_X : charX_next = fun t z =>
-        if t ≤ T then charX_prev t z else charX_g (t - T) (charX_prev T z, charV_prev T z))
-    (hdef_V : charV_next = fun t z =>
-        if t ≤ T then charV_prev t z else charV_g (t - T) (charX_prev T z, charV_prev T z))
-    (hdef_f : f_next = fun t => if t ≤ T then f_prev t else g (t - T))
-    (h_prev_boundary : ∀ (z : PhaseSpace d) (t : ℝ), t ∈ Set.Icc (0 : ℝ) T →
-        HasDerivWithinAt (fun s => charX_prev s z) (charV_prev t z) (Set.Icc 0 T) t ∧
-        HasDerivWithinAt (fun s => charV_prev s z)
-          (-(convolveFunctionMeasure gradW (spatialMarginal (f_prev t)) (charX_prev t z)))
-          (Set.Icc 0 T) t)
-    (hg_boundary : ∀ (w : PhaseSpace d) (t : ℝ), t ∈ Set.Icc (0 : ℝ) T_0 →
-        HasDerivWithinAt (fun s => charX_g s w) (charV_g t w) (Set.Icc 0 T_0) t ∧
-        HasDerivWithinAt (fun s => charV_g s w)
-          (-(convolveFunctionMeasure gradW (spatialMarginal (g t)) (charX_g t w)))
-          (Set.Icc 0 T_0) t)
-    (hg_init : g 0 = f_prev T)
-    (hg_init_cond : ∀ (w : PhaseSpace d), charX_g 0 w = w.1 ∧ charV_g 0 w = w.2) :
-    ∀ (z : PhaseSpace d) (t : ℝ), t ∈ Set.Icc (0 : ℝ) (T + T_0) →
-      HasDerivWithinAt (fun s => charX_next s z) (charV_next t z) (Set.Icc 0 (T + T_0)) t ∧
-      HasDerivWithinAt (fun s => charV_next s z)
-        (-(convolveFunctionMeasure gradW (spatialMarginal (f_next t)) (charX_next t z)))
-        (Set.Icc 0 (T + T_0)) t := by
-  subst hdef_X hdef_V
-  intro z t ht
-  simp only []
-  -- Abbreviate the initial phase-space point for g
-  have hz₀_def : (charX_prev T z, charV_prev T z) = (charX_prev T z, charV_prev T z) := rfl
-  by_cases ht_le : t ≤ T
-  · -- t ≤ T: use h_prev_boundary + upgrade to Icc 0 (T + T_0)
-    simp only [ite_eq_left ht_le]
-    have ht_in : t ∈ Set.Icc (0 : ℝ) T := ⟨ht.1, ht_le⟩
-    have h_bX := (h_prev_boundary z t ht_in).1
-    have h_bV := (h_prev_boundary z t ht_in).2
-    by_cases ht_eqT : t = T
-    · -- t = T: the seam case, extracted as `_glue_boundary_seam`.
-      rw [ht_eqT]
-      exact vlasovWellPosedness_glue_boundary_seam gradW hT_pos hT_0_pos f_prev g f_next
-        charX_prev charV_prev charX_g charV_g hdef_f h_prev_boundary hg_boundary
-        hg_init hg_init_cond z
-    · -- t < T: use mono_of_mem_nhdsWithin to extend to Icc 0 (T + T_0)
-      have ht_ltT : t < T := lt_of_le_of_ne ht_le ht_eqT
-      -- Get Icc 0 T ∈ nhdsWithin t (Icc 0 (T + T_0))
-      have h_mem : Set.Icc (0 : ℝ) T ∈ nhdsWithin t (Set.Icc 0 (T + T_0)) := by
-        rcases eq_or_lt_of_le ht.1 with rfl | ht_pos
-        · exact (nhdsWithin_mono 0 Set.Icc_subset_Ici_self) (Icc_mem_nhdsGE hT_pos)
-        · exact mem_nhdsWithin_of_mem_nhds (Icc_mem_nhds ht_pos ht_ltT)
-      -- Upgrade HasDerivWithinAt from Icc 0 T to Icc 0 (T + T_0)
-      have hX_big := h_bX.mono_of_mem_nhdsWithin h_mem
-      have hV_big := h_bV.mono_of_mem_nhdsWithin h_mem
-      -- Congr: charX_next = charX_prev on Icc 0 T (within Icc 0 (T+T_0))
-      have hX_ev : (fun s => if s ≤ T then charX_prev s z
-            else charX_g (s - T) (charX_prev T z, charV_prev T z))
-          =ᶠ[nhdsWithin t (Set.Icc 0 (T + T_0))] (charX_prev · z) :=
-        Filter.Eventually.mono h_mem (fun s hs => by simp [hs.2])
-      have hV_ev : (fun s => if s ≤ T then charV_prev s z
-            else charV_g (s - T) (charX_prev T z, charV_prev T z))
-          =ᶠ[nhdsWithin t (Set.Icc 0 (T + T_0))] (charV_prev · z) :=
-        Filter.Eventually.mono h_mem (fun s hs => by simp [hs.2])
-      -- f_next t = f_prev t, so marginals match
-      have hfnext : f_next t = f_prev t := by rw [hdef_f]; simp only [ite_eq_left ht_le]
-      have hfnext_spat : spatialMarginal (f_next t) = spatialMarginal (f_prev t) :=
-        congrArg spatialMarginal hfnext
-      rw [← hfnext_spat] at hV_big
-      constructor
-      · exact hX_big.congr_of_eventuallyEq_of_mem hX_ev ht
-      · exact hV_big.congr_of_eventuallyEq_of_mem hV_ev ht
-  · -- T < t: use hg_boundary + chain rule
-    push Not at ht_le
-    simp only [ite_eq_right (not_le.mpr ht_le)]
-    have htT_mem : t - T ∈ Set.Icc (0 : ℝ) T_0 := ⟨by linarith, by linarith [ht.2]⟩
-    have h_bdry_gX := (hg_boundary (charX_prev T z, charV_prev T z) (t - T) htT_mem).1
-    have h_bdry_gV := (hg_boundary (charX_prev T z, charV_prev T z) (t - T) htT_mem).2
-    by_cases ht_ltTT0 : t < T + T_0
-    · -- t ∈ Ioo T (T + T_0): interior case, use HasDerivAt + congr
-      have htT_Ioo : t - T ∈ Set.Ioo (0 : ℝ) T_0 := ⟨by linarith, by linarith⟩
-      have hX_da := h_bdry_gX.hasDerivAt (Icc_mem_nhds htT_Ioo.1 htT_Ioo.2)
-      have hV_da := h_bdry_gV.hasDerivAt (Icc_mem_nhds htT_Ioo.1 htT_Ioo.2)
-      have h_sub : HasDerivAt (· - T) 1 t := (hasDerivAt_id' t).sub_const T
-      have h_chainX : HasDerivAt (fun s => charX_g (s - T) (charX_prev T z, charV_prev T z))
-          (charV_g (t - T) (charX_prev T z, charV_prev T z)) t := by
-        have := HasDerivAt.scomp_of_eq t hX_da h_sub rfl
-        simpa [Function.comp_def, one_smul] using this
-      have h_chainV : HasDerivAt (fun s => charV_g (s - T) (charX_prev T z, charV_prev T z))
-          (-(convolveFunctionMeasure gradW
-            (spatialMarginal (g (t - T)))
-            (charX_g (t - T) (charX_prev T z, charV_prev T z)))) t := by
-        have := HasDerivAt.scomp_of_eq t hV_da h_sub rfl
-        simpa [Function.comp_def, one_smul] using this
-      -- f_next t = g (t - T), so marginals match
-      have h_fnext_t : f_next t = g (t - T) := by
-        rw [hdef_f]; simp only [ite_eq_right (not_le.mpr ht_le)]
-      rw [← congrArg spatialMarginal h_fnext_t] at h_chainV
-      -- piecewise = charX_g (· - T) (charX_prev T z, charV_prev T z) near t (since T < t)
-      have h_ev_gt : ∀ᶠ s in nhds t, T < s := eventually_gt_nhds ht_le
-      have hX_ev : (fun s => if s ≤ T then charX_prev s z
-            else charX_g (s - T) (charX_prev T z, charV_prev T z))
-          =ᶠ[nhds t] (fun s => charX_g (s - T) (charX_prev T z, charV_prev T z)) :=
-        Filter.Eventually.mono h_ev_gt (fun s hs => by simp [not_le.mpr hs])
-      have hV_ev : (fun s => if s ≤ T then charV_prev s z
-            else charV_g (s - T) (charX_prev T z, charV_prev T z))
-          =ᶠ[nhds t] (fun s => charV_g (s - T) (charX_prev T z, charV_prev T z)) :=
-        Filter.Eventually.mono h_ev_gt (fun s hs => by simp [not_le.mpr hs])
-      exact ⟨(h_chainX.congr_of_eventuallyEq hX_ev).hasDerivWithinAt,
-             (h_chainV.congr_of_eventuallyEq hV_ev).hasDerivWithinAt⟩
-    · -- t = T + T_0: endpoint, use mono_of_mem_nhdsWithin + chain rule + mono
-      push Not at ht_ltTT0
-      have htT0 : t = T + T_0 := le_antisymm ht.2 ht_ltTT0
-      rw [show t - T = T_0 from by linarith] at h_bdry_gX h_bdry_gV
-      -- Upgrade to Iic T_0 via Icc_mem_nhdsLE
-      have h_nhd_LE : Set.Icc 0 T_0 ∈ nhdsWithin T_0 (Set.Iic T_0) := Icc_mem_nhdsLE hT_0_pos
-      have hX_Lic := h_bdry_gX.mono_of_mem_nhdsWithin h_nhd_LE
-      have hV_Lic := h_bdry_gV.mono_of_mem_nhdsWithin h_nhd_LE
-      -- Chain rule: (· - T) maps Iic (T + T_0) to Iic T_0
-      have h_sub_LE : HasDerivWithinAt (· - T) 1 (Set.Iic (T + T_0)) (T + T_0) :=
-        ((hasDerivAt_id' (T + T_0)).sub_const T).hasDerivWithinAt.mono
-          (fun _ _ => Set.mem_univ _)
-      have h_mapLE : Set.MapsTo (· - T) (Set.Iic (T + T_0)) (Set.Iic T_0) :=
-        fun s hs => Set.mem_Iic.mpr (by linarith [Set.mem_Iic.mp hs])
-      have h_chainX : HasDerivWithinAt
-          (fun s => charX_g (s - T) (charX_prev T z, charV_prev T z))
-          (charV_g T_0 (charX_prev T z, charV_prev T z)) (Set.Iic (T + T_0)) (T + T_0) := by
-        have := HasDerivWithinAt.scomp_of_eq (T + T_0) hX_Lic h_sub_LE h_mapLE
-          (show T_0 = (T + T_0) - T by ring)
-        simpa [Function.comp_def, one_smul] using this
-      have h_chainV : HasDerivWithinAt
-          (fun s => charV_g (s - T) (charX_prev T z, charV_prev T z))
-          (-(convolveFunctionMeasure gradW
-            (spatialMarginal (g T_0))
-            (charX_g T_0 (charX_prev T z, charV_prev T z))))
-          (Set.Iic (T + T_0)) (T + T_0) := by
-        have := HasDerivWithinAt.scomp_of_eq (T + T_0) hV_Lic h_sub_LE h_mapLE
-          (show T_0 = (T + T_0) - T by ring)
-        simpa [Function.comp_def, one_smul] using this
-      -- Congr: near T+T_0 within Iic (T+T_0), points > T eventually
-      have h_ev_gt2 : ∀ᶠ s in nhdsWithin (T + T_0) (Set.Iic (T + T_0)), T < s :=
-        (eventually_gt_nhds (show T < T + T_0 by linarith)).filter_mono nhdsWithin_le_nhds
-      have hX_ev2 : (fun s => if s ≤ T then charX_prev s z
-            else charX_g (s - T) (charX_prev T z, charV_prev T z))
-          =ᶠ[nhdsWithin (T + T_0) (Set.Iic (T + T_0))]
-          (fun s => charX_g (s - T) (charX_prev T z, charV_prev T z)) :=
-        Filter.Eventually.mono h_ev_gt2 (fun s hs => by simp [not_le.mpr hs])
-      have hV_ev2 : (fun s => if s ≤ T then charV_prev s z
-            else charV_g (s - T) (charX_prev T z, charV_prev T z))
-          =ᶠ[nhdsWithin (T + T_0) (Set.Iic (T + T_0))]
-          (fun s => charV_g (s - T) (charX_prev T z, charV_prev T z)) :=
-        Filter.Eventually.mono h_ev_gt2 (fun s hs => by simp [not_le.mpr hs])
-      have h_Iic_sub : Set.Icc 0 (T + T_0) ⊆ Set.Iic (T + T_0) := Set.Icc_subset_Iic_self
-      have h_TT0_Iic : (T + T_0) ∈ Set.Iic (T + T_0) := Set.mem_Iic.mpr (le_refl _)
-      -- f_next (T + T_0) = g T_0
-      have h_fnext_TT0 : f_next (T + T_0) = g T_0 := by
-        simp [hdef_f, not_le.mpr (show T < T + T_0 by linarith)]
-      constructor
-      · have h_cX : HasDerivWithinAt
-            (fun s => if s ≤ T then charX_prev s z
-              else charX_g (s - T) (charX_prev T z, charV_prev T z))
-            (charV_g T_0 (charX_prev T z, charV_prev T z))
-            (Set.Icc 0 (T + T_0)) (T + T_0) :=
-          (h_chainX.congr_of_eventuallyEq_of_mem hX_ev2 h_TT0_Iic).mono h_Iic_sub
-        rw [htT0]
-        rw [show T + T_0 - T = T_0 from by ring]
-        exact h_cX
-      · have h_cV : HasDerivWithinAt
-            (fun s => if s ≤ T then charV_prev s z
-              else charV_g (s - T) (charX_prev T z, charV_prev T z))
-            (-(convolveFunctionMeasure gradW
-              (spatialMarginal (g T_0))
-              (charX_g T_0 (charX_prev T z, charV_prev T z))))
-            (Set.Icc 0 (T + T_0)) (T + T_0) :=
-          (h_chainV.congr_of_eventuallyEq_of_mem hV_ev2 h_TT0_Iic).mono h_Iic_sub
-        rw [htT0]
-        rw [h_fnext_TT0]
-        rw [show T + T_0 - T = T_0 from by ring]
-        exact h_cV
+private alias vlasovGlue_diff_ne :=
+  _root_.Vlasov.vlasovGlue_diff_ne
 
+private alias vlasovGlue_flowV_hasDerivAt :=
+  _root_.Vlasov.vlasovGlue_flowV_hasDerivAt
 
-/-- **Route 2 inner kernel for `glue_step` `h_cont_g`** (LEFT / `Iic T`): continuity
-at the seam `T` of `s ↦ (∇W ∗ μ_s)(charX s z)`, where the window measure curve `μ` is
-the flow-pushforward of `f₀`.
+private alias vlasovGlue_flowX_hasDerivAt :=
+  _root_.Vlasov.vlasovGlue_flowX_hasDerivAt
 
-Proven from PROVEN tools only (no deferred OT).  The pushforward rewrite
-`(∇W ∗ μ_s)(x) = ∫ z', gradW (x − charX s z') ∂f₀` (`integral_map`) turns the
-moving-measure convolution into a fixed-`f₀` integral with moving integrand, closed by
-dominated convergence: convergence from the flow's seam continuity `h_charX_cont`,
-domination from the Gronwall growth bound `hC_T` (Piece A) against `f₀`'s finite first
-moment.  This is the structural reason `h_cont_g` does NOT need the general narrow→W₁
-kernel — its consumer carries a pushforward representation. -/
-lemma flowConv_continuousWithinAt_Iic_seam
-    {d : ℕ}
-    (gradW : PhysSpace d → PhysSpace d)
-    (L : NNReal) (hL : LipschitzWith L gradW)
-    (charX : ℝ → PhaseSpace d → PhysSpace d)
-    (f₀ : Measure (PhaseSpace d)) [IsProbabilityMeasure f₀]
-    (hf₀_int : Integrable (fun z : PhaseSpace d => ‖z‖) f₀)
-    {T : ℝ} (hT : 0 < T)
-    (μ : ℝ → Measure (PhysSpace d))
-    (h_push : ∀ s ∈ Set.Icc (0 : ℝ) T,
-        μ s = Measure.map (fun z : PhaseSpace d => charX s z) f₀)
-    (h_aemeas : ∀ s ∈ Set.Icc (0 : ℝ) T,
-        AEMeasurable (fun z : PhaseSpace d => charX s z) f₀)
-    (h_charX_cont : ∀ z : PhaseSpace d,
-        ContinuousWithinAt (fun s => charX s z) (Set.Icc (0 : ℝ) T) T)
-    (C_T : ℝ) (_hC_T_nn : 0 ≤ C_T)
-    (hC_T : ∀ s ∈ Set.Icc (0 : ℝ) T, ∀ z : PhaseSpace d, ‖charX s z‖ ≤ C_T * (‖z‖ + 1))
-    (z : PhaseSpace d) :
-    ContinuousWithinAt (fun s => convolveFunctionMeasure gradW (μ s) (charX s z))
-      (Set.Iic T) T := by
-  have h_nhd_L : Set.Icc (0 : ℝ) T ∈ nhdsWithin T (Set.Iic T) := Icc_mem_nhdsLE hT
-  have hgradW_cont : Continuous gradW := hL.continuous
-  have hL_nn : (0 : ℝ) ≤ (L : ℝ) := L.coe_nonneg
-  -- Pushforward rewrite of the convolution, eventually in s (on the window).
-  have h_eq : (fun s => convolveFunctionMeasure gradW (μ s) (charX s z))
-      =ᶠ[nhdsWithin T (Set.Iic T)]
-      (fun s => ∫ z', gradW (charX s z - charX s z') ∂f₀) := by
-    apply Filter.Eventually.mono h_nhd_L
-    intro s hs
-    change ∫ y, gradW (charX s z - y) ∂(μ s)
-        = ∫ z', gradW (charX s z - charX s z') ∂f₀
-    rw [h_push s hs]
-    exact integral_map (h_aemeas s hs)
-      (hgradW_cont.comp (continuous_const.sub continuous_id)).aestronglyMeasurable
-  -- The rewritten f₀-integral is continuous at T by dominated convergence.
-  have h_cont_rhs : ContinuousWithinAt
-      (fun s => ∫ z', gradW (charX s z - charX s z') ∂f₀) (Set.Iic T) T := by
-    apply continuousWithinAt_of_dominated
-      (bound := fun z' => ‖gradW 0‖ + (L : ℝ) * (C_T * (‖z‖ + 1))
-        + (L : ℝ) * (C_T * (‖z'‖ + 1)))
-    · -- AEStronglyMeasurable in z', eventually in s
-      apply Filter.Eventually.mono h_nhd_L
-      intro s hs
-      exact (hgradW_cont.measurable.comp_aemeasurable
-        (aemeasurable_const.sub (h_aemeas s hs))).aestronglyMeasurable
-    · -- pointwise dominator bound, eventually in s
-      apply Filter.Eventually.mono h_nhd_L
-      intro s hs
-      apply Filter.Eventually.of_forall
-      intro z'
-      have h1 : ‖gradW (charX s z - charX s z')‖
-          ≤ ‖gradW 0‖ + (L : ℝ) * ‖charX s z - charX s z'‖ := by
-        have hd := hL.dist_le_mul (charX s z - charX s z') 0
-        simp only [dist_eq_norm, sub_zero] at hd
-        have htri : ‖gradW (charX s z - charX s z')‖
-            ≤ ‖gradW 0‖ + ‖gradW (charX s z - charX s z') - gradW 0‖ := by
-          have := norm_add_le (gradW (charX s z - charX s z') - gradW 0) (gradW 0)
-          simp only [sub_add_cancel] at this; linarith
-        linarith
-      have h2 : ‖charX s z - charX s z'‖ ≤ ‖charX s z‖ + ‖charX s z'‖ := norm_sub_le _ _
-      have h3 : ‖charX s z‖ ≤ C_T * (‖z‖ + 1) := hC_T s hs z
-      have h4 : ‖charX s z'‖ ≤ C_T * (‖z'‖ + 1) := hC_T s hs z'
-      nlinarith [mul_le_mul_of_nonneg_left (h2.trans (add_le_add h3 h4)) hL_nn]
-    · -- integrability of the dominator
-      apply Integrable.add (integrable_const _)
-      exact ((hf₀_int.add (integrable_const (1 : ℝ))).const_mul C_T).const_mul (L : ℝ)
-    · -- pointwise continuity in s, a.e. z'
-      apply Filter.Eventually.of_forall
-      intro z'
-      have hcz : ContinuousWithinAt (fun s => charX s z) (Set.Iic T) T :=
-        (h_charX_cont z).mono_of_mem_nhdsWithin h_nhd_L
-      have hcz' : ContinuousWithinAt (fun s => charX s z') (Set.Iic T) T :=
-        (h_charX_cont z').mono_of_mem_nhdsWithin h_nhd_L
-      exact hgradW_cont.continuousAt.comp_continuousWithinAt (hcz.sub hcz')
-  -- Bridge value at T and conclude.
-  have h_val_T : convolveFunctionMeasure gradW (μ T) (charX T z)
-      = ∫ z', gradW (charX T z - charX T z') ∂f₀ := by
-    have hT_mem : T ∈ Set.Icc (0 : ℝ) T := ⟨hT.le, le_refl T⟩
-    change ∫ y, gradW (charX T z - y) ∂(μ T)
-        = ∫ z', gradW (charX T z - charX T z') ∂f₀
-    rw [h_push T hT_mem]
-    exact integral_map (h_aemeas T hT_mem)
-      (hgradW_cont.comp (continuous_const.sub continuous_id)).aestronglyMeasurable
-  exact h_cont_rhs.congr_of_eventuallyEq h_eq h_val_T
-
-/-- **Route 2 inner kernel for `glue_step` `h_cont_g`** (RIGHT / `Ici a`): the
-exact mirror of `flowConv_continuousWithinAt_Iic_seam`, but on `Set.Ici a` over a
-generic window `[a, b]` with the seam at the lower endpoint `a`.  Same proof shape;
-the only set-dependent swaps are `Iic T → Ici a`, `Icc_mem_nhdsLE → Icc_mem_nhdsGE`,
-and the window `[0, T] → [a, b]`.  Used for the RIGHT side of the seam at `T` where
-`charX` is the composed position flow `Z_s z = charX_g (s-T) (charX_prev T z, …)` and
-`μ s = spatialMarginal (g (s-T))` is its pushforward of `f₀`. -/
-lemma flowConv_continuousWithinAt_Ici_seam
-    {d : ℕ}
-    (gradW : PhysSpace d → PhysSpace d)
-    (L : NNReal) (hL : LipschitzWith L gradW)
-    (charX : ℝ → PhaseSpace d → PhysSpace d)
-    (f₀ : Measure (PhaseSpace d)) [IsProbabilityMeasure f₀]
-    (hf₀_int : Integrable (fun z : PhaseSpace d => ‖z‖) f₀)
-    {a b : ℝ} (hab : a < b)
-    (μ : ℝ → Measure (PhysSpace d))
-    (h_push : ∀ s ∈ Set.Icc a b,
-        μ s = Measure.map (fun z : PhaseSpace d => charX s z) f₀)
-    (h_aemeas : ∀ s ∈ Set.Icc a b,
-        AEMeasurable (fun z : PhaseSpace d => charX s z) f₀)
-    (h_charX_cont : ∀ z : PhaseSpace d,
-        ContinuousWithinAt (fun s => charX s z) (Set.Ici a) a)
-    (C_T : ℝ) (_hC_T_nn : 0 ≤ C_T)
-    (hC_T : ∀ s ∈ Set.Icc a b, ∀ z : PhaseSpace d, ‖charX s z‖ ≤ C_T * (‖z‖ + 1))
-    (z : PhaseSpace d) :
-    ContinuousWithinAt (fun s => convolveFunctionMeasure gradW (μ s) (charX s z))
-      (Set.Ici a) a := by
-  have h_nhd_R : Set.Icc a b ∈ nhdsWithin a (Set.Ici a) := Icc_mem_nhdsGE hab
-  have hgradW_cont : Continuous gradW := hL.continuous
-  have hL_nn : (0 : ℝ) ≤ (L : ℝ) := L.coe_nonneg
-  -- Pushforward rewrite of the convolution, eventually in s (on the window).
-  have h_eq : (fun s => convolveFunctionMeasure gradW (μ s) (charX s z))
-      =ᶠ[nhdsWithin a (Set.Ici a)]
-      (fun s => ∫ z', gradW (charX s z - charX s z') ∂f₀) := by
-    apply Filter.Eventually.mono h_nhd_R
-    intro s hs
-    change ∫ y, gradW (charX s z - y) ∂(μ s)
-        = ∫ z', gradW (charX s z - charX s z') ∂f₀
-    rw [h_push s hs]
-    exact integral_map (h_aemeas s hs)
-      (hgradW_cont.comp (continuous_const.sub continuous_id)).aestronglyMeasurable
-  -- The rewritten f₀-integral is continuous at a by dominated convergence.
-  have h_cont_rhs : ContinuousWithinAt
-      (fun s => ∫ z', gradW (charX s z - charX s z') ∂f₀) (Set.Ici a) a := by
-    apply continuousWithinAt_of_dominated
-      (bound := fun z' => ‖gradW 0‖ + (L : ℝ) * (C_T * (‖z‖ + 1))
-        + (L : ℝ) * (C_T * (‖z'‖ + 1)))
-    · -- AEStronglyMeasurable in z', eventually in s
-      apply Filter.Eventually.mono h_nhd_R
-      intro s hs
-      exact (hgradW_cont.measurable.comp_aemeasurable
-        (aemeasurable_const.sub (h_aemeas s hs))).aestronglyMeasurable
-    · -- pointwise dominator bound, eventually in s
-      apply Filter.Eventually.mono h_nhd_R
-      intro s hs
-      apply Filter.Eventually.of_forall
-      intro z'
-      have h1 : ‖gradW (charX s z - charX s z')‖
-          ≤ ‖gradW 0‖ + (L : ℝ) * ‖charX s z - charX s z'‖ := by
-        have hd := hL.dist_le_mul (charX s z - charX s z') 0
-        simp only [dist_eq_norm, sub_zero] at hd
-        have htri : ‖gradW (charX s z - charX s z')‖
-            ≤ ‖gradW 0‖ + ‖gradW (charX s z - charX s z') - gradW 0‖ := by
-          have := norm_add_le (gradW (charX s z - charX s z') - gradW 0) (gradW 0)
-          simp only [sub_add_cancel] at this; linarith
-        linarith
-      have h2 : ‖charX s z - charX s z'‖ ≤ ‖charX s z‖ + ‖charX s z'‖ := norm_sub_le _ _
-      have h3 : ‖charX s z‖ ≤ C_T * (‖z‖ + 1) := hC_T s hs z
-      have h4 : ‖charX s z'‖ ≤ C_T * (‖z'‖ + 1) := hC_T s hs z'
-      nlinarith [mul_le_mul_of_nonneg_left (h2.trans (add_le_add h3 h4)) hL_nn]
-    · -- integrability of the dominator
-      apply Integrable.add (integrable_const _)
-      exact ((hf₀_int.add (integrable_const (1 : ℝ))).const_mul C_T).const_mul (L : ℝ)
-    · -- pointwise continuity in s, a.e. z'
-      apply Filter.Eventually.of_forall
-      intro z'
-      have hcz : ContinuousWithinAt (fun s => charX s z) (Set.Ici a) a := h_charX_cont z
-      have hcz' : ContinuousWithinAt (fun s => charX s z') (Set.Ici a) a := h_charX_cont z'
-      exact hgradW_cont.continuousAt.comp_continuousWithinAt (hcz.sub hcz')
-  -- Bridge value at a and conclude.
-  have h_val_a : convolveFunctionMeasure gradW (μ a) (charX a z)
-      = ∫ z', gradW (charX a z - charX a z') ∂f₀ := by
-    have ha_mem : a ∈ Set.Icc a b := ⟨le_refl a, hab.le⟩
-    change ∫ y, gradW (charX a z - y) ∂(μ a)
-        = ∫ z', gradW (charX a z - charX a z') ∂f₀
-    rw [h_push a ha_mem]
-    exact integral_map (h_aemeas a ha_mem)
-      (hgradW_cont.comp (continuous_const.sub continuous_id)).aestronglyMeasurable
-  exact h_cont_rhs.congr_of_eventuallyEq h_eq h_val_a
+private alias vlasovGlue_flow_aemeasurable :=
+  _root_.Vlasov.vlasovGlue_flow_aemeasurable
 
-/-- gradW-kernel integrability on the spatial marginals of a finite-first-moment
-curve (window-generic over the curve `μ`).  The first-moment transfer to the
-marginal feeds `integrable_gradW_shift`. -/
-private lemma dobrushinFlow_marginal_gradW_integrable
-    {d : ℕ}
-    (gradW : PhysSpace d → PhysSpace d)
-    (L : NNReal) (hL : LipschitzWith L gradW)
-    (T : ℝ) (μ : ℝ → Measure (PhaseSpace d))
-    (hμ_mom : ∀ t ∈ Set.Icc (0 : ℝ) T, HasFiniteFirstMoment (μ t)) :
-    ∀ t ∈ Set.Icc (0 : ℝ) T, ∀ (x_pt : PhysSpace d),
-      Integrable (fun y => gradW (x_pt - y)) (spatialMarginal (μ t)) := by
-  intro t ht x_pt
-  have : IsProbabilityMeasure (μ t) := (hμ_mom t ht).1
-  have : IsProbabilityMeasure (spatialMarginal (μ t)) :=
-    (Measure.isProbabilityMeasure_map_iff measurable_fst.aemeasurable).mpr inferInstance
-  have h_y_int : Integrable (fun y : PhysSpace d => ‖y‖) (spatialMarginal (μ t)) := by
-    unfold spatialMarginal
-    rw [integrable_map_measure
-      (by exact (continuous_norm.measurable).aestronglyMeasurable)
-      measurable_fst.aemeasurable]
-    refine Integrable.mono' (hμ_mom t ht).2
-      ((continuous_norm.comp continuous_fst).aestronglyMeasurable)
-      (Filter.Eventually.of_forall fun z => ?_)
-    change |‖z.1‖| ≤ ‖z‖
-    rw [abs_of_nonneg (norm_nonneg _)]; exact norm_fst_le z
-  exact integrable_gradW_shift gradW L hL (spatialMarginal (μ t)) h_y_int x_pt
+private alias vlasovGlue_flow_growthBound :=
+  _root_.Vlasov.vlasovGlue_flow_growthBound
 
-/-- First-moment integrability transfers to the spatial marginal:
-`∫ ‖z‖ ∂μ < ∞` gives `∫ ‖y‖ ∂(spatialMarginal μ) < ∞`. -/
-private lemma vlasovGlue_marginal_norm_integrable
-    {d : ℕ}
-    (μ : Measure (PhaseSpace d)) (hμ : HasFiniteFirstMoment μ) :
-    Integrable (fun y : PhysSpace d => ‖y‖) (spatialMarginal μ) := by
-  have : IsProbabilityMeasure μ := hμ.1
-  unfold spatialMarginal
-  rw [integrable_map_measure
-    (by exact (continuous_norm.measurable).aestronglyMeasurable)
-    measurable_fst.aemeasurable]
-  refine Integrable.mono' hμ.2
-    ((continuous_norm.comp continuous_fst).aestronglyMeasurable)
-    (Filter.Eventually.of_forall fun z => ?_)
-  change |‖z.1‖| ≤ ‖z‖
-  rw [abs_of_nonneg (norm_nonneg _)]; exact norm_fst_le z
+private alias vlasovGlue_gradVφ_continuous :=
+  _root_.Vlasov.vlasovGlue_gradVφ_continuous
 
-/-- Continuity of the spatial-gradient component `gradXφ` of a smooth test
-function `φ` on phase space. -/
-private lemma vlasovGlue_gradXφ_continuous
-    {d : ℕ}
-    (φ : PhaseSpace d → ℝ) (hφ_smooth : ContDiff ℝ (⊤ : ℕ∞) φ)
-    (gradXφ : PhaseSpace d → PhysSpace d)
-    (hgradXφ : ∀ z : PhaseSpace d, gradXφ z = gradient (fun x => φ (x, z.2)) z.1) :
-    Continuous gradXφ := by
-  have hfderiv_X : ∀ z : PhaseSpace d,
-      fderiv ℝ (fun x => φ (x, z.2)) z.1 =
-      (fderiv ℝ φ z).comp (ContinuousLinearMap.inl ℝ (PhysSpace d) (PhysSpace d)) :=
-    fun z => by
-      have h1 : HasFDerivAt φ (fderiv ℝ φ z) z :=
-        (hφ_smooth.differentiable (by simp) z).hasFDerivAt
-      have h2 : HasFDerivAt (fun x : PhysSpace d => (x, z.2))
-          (ContinuousLinearMap.inl ℝ (PhysSpace d) (PhysSpace d)) z.1 :=
-        hasFDerivAt_prodMk_left z.1 z.2
-      exact (h1.comp z.1 h2).fderiv
-  have heqX : gradXφ = fun z => gradient (fun x => φ (x, z.2)) z.1 :=
-    funext hgradXφ
-  rw [heqX]
-  simp_rw [gradient, hfderiv_X]
-  exact (InnerProductSpace.toDual ℝ (PhysSpace d)).symm.continuous.comp
-    ((ContinuousLinearMap.isBoundedLinearMap_comp_right
-      (ContinuousLinearMap.inl ℝ (PhysSpace d) (PhysSpace d))).continuous.comp
-      (hφ_smooth.continuous_fderiv (by simp)))
+private alias vlasovGlue_gradXφ_continuous :=
+  _root_.Vlasov.vlasovGlue_gradXφ_continuous
 
-/-- Continuity of the velocity-gradient component `gradVφ` of a smooth test
-function `φ` on phase space. -/
-private lemma vlasovGlue_gradVφ_continuous
-    {d : ℕ}
-    (φ : PhaseSpace d → ℝ) (hφ_smooth : ContDiff ℝ (⊤ : ℕ∞) φ)
-    (gradVφ : PhaseSpace d → PhysSpace d)
-    (hgradVφ : ∀ z : PhaseSpace d, gradVφ z = gradient (fun v => φ (z.1, v)) z.2) :
-    Continuous gradVφ := by
-  have hfderiv_V : ∀ z : PhaseSpace d,
-      fderiv ℝ (fun v => φ (z.1, v)) z.2 =
-      (fderiv ℝ φ z).comp (ContinuousLinearMap.inr ℝ (PhysSpace d) (PhysSpace d)) :=
-    fun z => by
-      have h1 : HasFDerivAt φ (fderiv ℝ φ z) z :=
-        (hφ_smooth.differentiable (by simp) z).hasFDerivAt
-      have h2 : HasFDerivAt (fun v : PhysSpace d => (z.1, v))
-          (ContinuousLinearMap.inr ℝ (PhysSpace d) (PhysSpace d)) z.2 :=
-        hasFDerivAt_prodMk_right z.1 z.2
-      exact (h1.comp z.2 h2).fderiv
-  have heqV : gradVφ = fun z => gradient (fun v => φ (z.1, v)) z.2 :=
-    funext hgradVφ
-  rw [heqV]
-  simp_rw [gradient, hfderiv_V]
-  exact (InnerProductSpace.toDual ℝ (PhysSpace d)).symm.continuous.comp
-    ((ContinuousLinearMap.isBoundedLinearMap_comp_right
-      (ContinuousLinearMap.inr ℝ (PhysSpace d) (PhysSpace d))).continuous.comp
-      (hφ_smooth.continuous_fderiv (by simp)))
+private alias vlasovGlue_gradφ_bound :=
+  _root_.Vlasov.vlasovGlue_gradφ_bound
 
-/-- Uniform sup-bound on both gradient components of a compactly supported
-smooth test function: `‖∇_x φ‖, ‖∇_v φ‖ ≤ M_φ := sup ‖fderiv φ‖`. -/
-private lemma vlasovGlue_gradφ_bound
-    {d : ℕ}
-    (φ : PhaseSpace d → ℝ) (hφ_smooth : ContDiff ℝ (⊤ : ℕ∞) φ)
-    (hφ_compact : HasCompactSupport φ)
-    (gradXφ gradVφ : PhaseSpace d → PhysSpace d)
-    (hgradXφ : ∀ z : PhaseSpace d, gradXφ z = gradient (fun x => φ (x, z.2)) z.1)
-    (hgradVφ : ∀ z : PhaseSpace d, gradVφ z = gradient (fun v => φ (z.1, v)) z.2) :
-    ∃ M_φ : ℝ, (∀ z : PhaseSpace d, ‖gradXφ z‖ ≤ M_φ) ∧
-      (∀ z : PhaseSpace d, ‖gradVφ z‖ ≤ M_φ) := by
-  have hfderiv_cont : Continuous (fderiv ℝ φ) :=
-    hφ_smooth.continuous_fderiv (by norm_num)
-  have hfderiv_compact : HasCompactSupport (fderiv ℝ φ) :=
-    HasCompactSupport.fderiv (𝕜 := ℝ) hφ_compact
-  obtain ⟨M_φ, hM_φ⟩ := hfderiv_cont.bounded_above_of_compact_support hfderiv_compact
-  refine ⟨M_φ, fun z => ?_, fun z => ?_⟩
-  · have hfd : fderiv ℝ (fun x => φ (x, z.2)) z.1 =
-        (fderiv ℝ φ z).comp
-          (ContinuousLinearMap.inl ℝ (PhysSpace d) (PhysSpace d)) := by
-      have h1 : HasFDerivAt φ (fderiv ℝ φ z) z :=
-        (hφ_smooth.differentiable (by simp) z).hasFDerivAt
-      have h2 : HasFDerivAt (fun x : PhysSpace d => (x, z.2))
-          (ContinuousLinearMap.inl ℝ (PhysSpace d) (PhysSpace d)) z.1 :=
-        hasFDerivAt_prodMk_left z.1 z.2
-      exact (h1.comp z.1 h2).fderiv
-    rw [hgradXφ z, gradient, hfd,
-      (InnerProductSpace.toDual ℝ (PhysSpace d)).symm.norm_map]
-    refine le_trans (ContinuousLinearMap.opNorm_comp_le _ _) ?_
-    refine le_trans (mul_le_mul_of_nonneg_left
-      (ContinuousLinearMap.norm_inl_le_one (𝕜 := ℝ)
-        (E := PhysSpace d) (F := PhysSpace d)) (norm_nonneg _)) ?_
-    rw [mul_one]; exact hM_φ z
-  · have hfd : fderiv ℝ (fun v => φ (z.1, v)) z.2 =
-        (fderiv ℝ φ z).comp
-          (ContinuousLinearMap.inr ℝ (PhysSpace d) (PhysSpace d)) := by
-      have h1 : HasFDerivAt φ (fderiv ℝ φ z) z :=
-        (hφ_smooth.differentiable (by simp) z).hasFDerivAt
-      have h2 : HasFDerivAt (fun v : PhysSpace d => (z.1, v))
-          (ContinuousLinearMap.inr ℝ (PhysSpace d) (PhysSpace d)) z.2 :=
-        hasFDerivAt_prodMk_right z.1 z.2
-      exact (h1.comp z.2 h2).fderiv
-    rw [hgradVφ z, gradient, hfd,
-      (InnerProductSpace.toDual ℝ (PhysSpace d)).symm.norm_map]
-    refine le_trans (ContinuousLinearMap.opNorm_comp_le _ _) ?_
-    refine le_trans (mul_le_mul_of_nonneg_left
-      (ContinuousLinearMap.norm_inr_le_one (𝕜 := ℝ)
-        (E := PhysSpace d) (F := PhysSpace d)) (norm_nonneg _)) ?_
-    rw [mul_one]; exact hM_φ z
+private alias vlasovGlue_intCont_left :=
+  _root_.Vlasov.vlasovGlue_intCont_left
 
-/-- Convolution force bound from a first-moment envelope:
-`‖(gradW ⋆ ρ) x‖ ≤ ‖gradW 0‖ + L·‖x‖ + L·M` for a probability measure `ρ`
-with `∫ ‖y‖ ∂ρ ≤ M`. -/
-private lemma vlasovGlue_conv_force_bound
-    {d : ℕ}
-    (gradW : PhysSpace d → PhysSpace d)
-    (L : NNReal) (hL : LipschitzWith L gradW)
-    (ρ : Measure (PhysSpace d)) [IsProbabilityMeasure ρ]
-    (M : ℝ) (hM : ∫ y, ‖y‖ ∂ρ ≤ M)
-    (h_y_int : Integrable (fun y : PhysSpace d => ‖y‖) ρ)
-    (h_int : ∀ x : PhysSpace d, Integrable (fun y => gradW (x - y)) ρ)
-    (x : PhysSpace d) :
-    ‖convolveFunctionMeasure gradW ρ x‖
-      ≤ ‖gradW 0‖ + (L : ℝ) * ‖x‖ + (L : ℝ) * M := by
-  unfold convolveFunctionMeasure
-  have h_sub_int : Integrable (fun y => ‖x - y‖) ρ :=
-    Integrable.mono' ((integrable_const ‖x‖).add h_y_int)
-      ((aestronglyMeasurable_const (b := x)).sub aestronglyMeasurable_id |>.norm)
-      (Filter.Eventually.of_forall fun y => by
-        simp only [Real.norm_of_nonneg (norm_nonneg _)]; exact norm_sub_le x y)
-  have h_pt : ∀ y : PhysSpace d,
-      ‖gradW (x - y)‖ ≤ ‖gradW 0‖ + (L : ℝ) * ‖x - y‖ := by
-    intro y
-    have hd := hL.dist_le_mul (x - y) 0
-    simp only [dist_eq_norm, sub_zero] at hd
-    have h_tri : ‖gradW (x - y)‖ ≤ ‖gradW 0‖ + ‖gradW (x - y) - gradW 0‖ := by
-      have := norm_add_le (gradW (x - y) - gradW 0) (gradW 0)
-      simp only [sub_add_cancel] at this; linarith
-    linarith
-  have h_bnd_int :
-      Integrable (fun y => ‖gradW 0‖ + (L : ℝ) * ‖x - y‖) ρ :=
-    (integrable_const _).add (h_sub_int.const_mul _)
-  calc ‖∫ y, gradW (x - y) ∂ρ‖
-      ≤ ∫ y, ‖gradW (x - y)‖ ∂ρ :=
-        norm_integral_le_integral_norm _
-    _ ≤ ∫ y, (‖gradW 0‖ + (L : ℝ) * ‖x - y‖) ∂ρ :=
-        integral_mono (h_int x).norm h_bnd_int h_pt
-    _ = ‖gradW 0‖ + (L : ℝ) * ∫ y, ‖x - y‖ ∂ρ := by
-        rw [integral_add (integrable_const _) (h_sub_int.const_mul _)]
-        simp [integral_const, measureReal_def, measure_univ, integral_const_mul]
-    _ ≤ ‖gradW 0‖ + (L : ℝ) * ‖x‖ + (L : ℝ) * M := by
-        have h_int_le : ∫ y, ‖x - y‖ ∂ρ ≤ ‖x‖ + M := by
-          calc ∫ y, ‖x - y‖ ∂ρ
-              ≤ ∫ y, (‖x‖ + ‖y‖) ∂ρ :=
-                integral_mono h_sub_int ((integrable_const _).add h_y_int)
-                  (fun y => norm_sub_le x y)
-            _ = ‖x‖ + ∫ y, ‖y‖ ∂ρ := by
-                rw [integral_add (integrable_const _) h_y_int]
-                simp [integral_const, measureReal_def, measure_univ]
-            _ ≤ ‖x‖ + M := by linarith
-        nlinarith [mul_le_mul_of_nonneg_left h_int_le L.coe_nonneg]
+private alias vlasovGlue_intCont_right :=
+  _root_.Vlasov.vlasovGlue_intCont_right
 
-/-- Window growth bound for a characteristic flow given boundary regularity:
-clamps the marginal curve into `[0, T]` (for the universal probability
-instance), derives the interior `IsCharacteristicFlowOn` from the boundary
-bundle, and applies `characteristicFlow_boundary_regularity` +
-`flow_distance_growth_bound_on`.  Returns the linear growth constant `C`
-together with per-`z` window continuity of the joint flow curve. -/
-private lemma vlasovGlue_flow_growthBound
-    {d : ℕ}
-    (gradW : PhysSpace d → PhysSpace d)
-    (L : NNReal) (hL : LipschitzWith L gradW)
-    (μ : ℝ → Measure (PhaseSpace d))
-    (charX charV : ℝ → PhaseSpace d → PhysSpace d)
-    (T : ℝ) (hT_pos : 0 < T)
-    (hμ_mom : ∀ t ∈ Set.Icc (0 : ℝ) T, HasFiniteFirstMoment (μ t))
-    (hM : ∃ M : ℝ, 0 ≤ M ∧
-        ∀ t ∈ Set.Icc (0 : ℝ) T, ∫ y, ‖y‖ ∂(spatialMarginal (μ t)) ≤ M)
-    (h_ic : ∀ z : PhaseSpace d, charX 0 z = z.1 ∧ charV 0 z = z.2)
-    (h_boundary : ∀ (z : PhaseSpace d) (t : ℝ), t ∈ Set.Icc (0 : ℝ) T →
-        HasDerivWithinAt (fun s => charX s z) (charV t z) (Set.Icc 0 T) t ∧
-        HasDerivWithinAt (fun s => charV s z)
-          (-(convolveFunctionMeasure gradW (spatialMarginal (μ t)) (charX t z)))
-          (Set.Icc 0 T) t) :
-    ∃ C : ℝ, 0 ≤ C ∧
-      (∀ s ∈ Set.Icc (0 : ℝ) T, ∀ z : PhaseSpace d,
-        ‖(charX s z, charV s z)‖ ≤ C * (‖z‖ + 1)) ∧
-      (∀ z : PhaseSpace d,
-        ContinuousOn (fun s => (charX s z, charV s z)) (Set.Icc (0 : ℝ) T)) := by
-  obtain ⟨M, hM_nn, hM_bd⟩ := hM
-  set clampT : ℝ → ℝ := fun t => max 0 (min t T) with hclampT_def
-  have hclampT_mem : ∀ t, clampT t ∈ Set.Icc (0 : ℝ) T := by
-    intro t
-    simp only [hclampT_def, Set.mem_Icc]
-    exact ⟨le_max_left _ _, max_le hT_pos.le (min_le_right _ _)⟩
-  have hclampT_id : ∀ t ∈ Set.Icc (0 : ℝ) T, clampT t = t := by
-    intro t ht
-    simp only [hclampT_def, min_eq_left ht.2, max_eq_right ht.1]
-  set ρc : ℝ → Measure (PhysSpace d) :=
-    fun t => spatialMarginal (μ (clampT t)) with hρc_def
-  have hρc_isProb : ∀ t, IsProbabilityMeasure (ρc t) := by
-    intro t
-    have : IsProbabilityMeasure (μ (clampT t)) :=
-      (hμ_mom (clampT t) (hclampT_mem t)).1
-    exact (Measure.isProbabilityMeasure_map_iff measurable_fst.aemeasurable).mpr inferInstance
-  have hM_ρ : ∀ t ∈ Set.Icc (0 : ℝ) T, ∫ y, ‖y‖ ∂(ρc t) ≤ M := by
-    intro t _ht
-    rw [hρc_def]
-    exact hM_bd (clampT t) (hclampT_mem t)
-  have h_y_int_ρc : ∀ t ∈ Set.Icc (0 : ℝ) T,
-      Integrable (fun y : PhysSpace d => ‖y‖) (ρc t) := by
-    intro t ht
-    have h_eq : ρc t = spatialMarginal (μ t) := by
-      simp only [hρc_def, hclampT_id t ht]
-    rw [h_eq]
-    exact vlasovGlue_marginal_norm_integrable (μ t) (hμ_mom t ht)
-  have h_int_ρc : ∀ t (x : PhysSpace d),
-      Integrable (fun y => gradW (x - y)) (ρc t) :=
-    fun t x => by
-      have := dobrushinFlow_marginal_gradW_integrable gradW L hL T μ hμ_mom
-        (clampT t) (hclampT_mem t) x
-      simpa only [hρc_def] using this
-  have h_bdry_ρc : ∀ z : PhaseSpace d, ∀ t ∈ Set.Icc (0 : ℝ) T,
-      HasDerivWithinAt (fun s => charX s z) (charV t z) (Set.Icc 0 T) t ∧
-      HasDerivWithinAt (fun s => charV s z)
-        (-(convolveFunctionMeasure gradW (ρc t) (charX t z)))
-        (Set.Icc 0 T) t := by
-    intro z t ht
-    have h_eq : ρc t = spatialMarginal (μ t) := by
-      simp only [hρc_def, hclampT_id t ht]
-    rw [h_eq]
-    exact h_boundary z t ht
-  have h_flow_ρc : IsCharacteristicFlowOn gradW ρc charX charV
-      (Set.Ioo 0 T) Set.univ := by
-    refine ⟨fun z _ => h_ic z, fun t ht z _ => ?_, fun t ht z _ => ?_⟩
-    · have ht_Icc : t ∈ Set.Icc (0 : ℝ) T := ⟨ht.1.le, ht.2.le⟩
-      exact ((h_bdry_ρc z t ht_Icc).1).hasDerivAt (Icc_mem_nhds ht.1 ht.2)
-    · have ht_Icc : t ∈ Set.Icc (0 : ℝ) T := ⟨ht.1.le, ht.2.le⟩
-      exact ((h_bdry_ρc z t ht_Icc).2).hasDerivAt (Icc_mem_nhds ht.1 ht.2)
-  obtain ⟨h_init_ρc, h_cont_Icc_ρc, h_deriv_Ico_ρc⟩ :=
-    characteristicFlow_boundary_regularity gradW ρc charX charV T hT_pos.le
-      h_flow_ρc h_bdry_ρc
-  obtain ⟨C, hC_nn, hC_pair⟩ :=
-    flow_distance_growth_bound_on gradW L hL ρc charX charV T hT_pos.le
-      h_init_ρc h_cont_Icc_ρc h_deriv_Ico_ρc M hM_nn hM_ρ h_y_int_ρc h_int_ρc
-  exact ⟨C, hC_nn, hC_pair, h_cont_Icc_ρc⟩
+private alias vlasovGlue_marginal_norm_integrable :=
+  _root_.Vlasov.vlasovGlue_marginal_norm_integrable
 
-/-- Generic seam continuity of the force-integral functional
-`s ↦ ∫ ⟪V s z, ∇ₓφ(Φ s z)⟫ − ⟪(gradW ⋆ ρ s)(X s z), ∇ᵥφ(Φ s z)⟫ ∂f₀`
-at a window endpoint, by dominated convergence.  `S` is the one-sided
-neighborhood filter set (`Iic T` or `Ici T`), `W` the compact window
-(`Icc 0 T` or `Icc T (T+T₀)`) carrying the uniform data: a linear growth
-bound `C` on the flow, a moment envelope `M` on the marginal curve `ρ`, and
-kernel integrability.  Instantiated on the LEFT by `f_prev`'s window flow and
-on the RIGHT by the composed flow off `g`. -/
-private lemma vlasovGlue_seam_forceIntegral_cont
-    {d : ℕ}
-    (gradW : PhysSpace d → PhysSpace d)
-    (L : NNReal) (hL : LipschitzWith L gradW)
-    (f₀ : Measure (PhaseSpace d)) [IsProbabilityMeasure f₀]
-    (hf₀_int : Integrable (fun z : PhaseSpace d => ‖z‖) f₀)
-    (gradXφ gradVφ : PhaseSpace d → PhysSpace d)
-    (hgradXφ_cont : Continuous gradXφ) (hgradVφ_cont : Continuous gradVφ)
-    (M_φ : ℝ)
-    (hgradXφ_bd : ∀ z : PhaseSpace d, ‖gradXφ z‖ ≤ M_φ)
-    (hgradVφ_bd : ∀ z : PhaseSpace d, ‖gradVφ z‖ ≤ M_φ)
-    (ρ : ℝ → Measure (PhysSpace d))
-    (X V : ℝ → PhaseSpace d → PhysSpace d)
-    (T₀ : ℝ) (S : Set ℝ) (W : Set ℝ)
-    (hW_nhd : W ∈ nhdsWithin T₀ S)
-    (hρ_prob : ∀ s ∈ W, IsProbabilityMeasure (ρ s))
-    (M : ℝ) (hM : ∀ s ∈ W, ∫ y, ‖y‖ ∂(ρ s) ≤ M)
-    (h_y_int : ∀ s ∈ W, Integrable (fun y : PhysSpace d => ‖y‖) (ρ s))
-    (h_int : ∀ s ∈ W, ∀ x : PhysSpace d, Integrable (fun y => gradW (x - y)) (ρ s))
-    (C : ℝ)
-    (hC_pair : ∀ s ∈ W, ∀ z : PhaseSpace d, ‖(X s z, V s z)‖ ≤ C * (‖z‖ + 1))
-    (h_aemeas : ∀ s ∈ W, AEMeasurable (fun z : PhaseSpace d => (X s z, V s z)) f₀)
-    (h_X_cont : ∀ z : PhaseSpace d, ContinuousWithinAt (fun s => X s z) S T₀)
-    (h_V_cont : ∀ z : PhaseSpace d, ContinuousWithinAt (fun s => V s z) S T₀)
-    (h_conv_cwn : ∀ z : PhaseSpace d, ContinuousWithinAt
-        (fun s => convolveFunctionMeasure gradW (ρ s) (X s z)) S T₀) :
-    ContinuousWithinAt
-      (fun s => ∫ z, (@inner ℝ (PhysSpace d) _ (V s z) (gradXφ (X s z, V s z)) -
-          @inner ℝ (PhysSpace d) _
-            (convolveFunctionMeasure gradW (ρ s) (X s z))
-            (gradVφ (X s z, V s z))) ∂f₀) S T₀ := by
-  set bound_fn : PhaseSpace d → ℝ := fun z =>
-    M_φ * (C * (‖z‖ + 1))
-    + (‖gradW 0‖ + (L : ℝ) * (C * (‖z‖ + 1)) + (L : ℝ) * M) * M_φ
-    with hbound_def
-  have hbound_int : Integrable bound_fn f₀ := by
-    have ha : Integrable
-        (fun z : PhaseSpace d =>
-          (M_φ * C + L * M_φ * C) * ‖z‖
-          + (M_φ * C + (‖gradW 0‖ + L * C + L * M) * M_φ)) f₀ :=
-      (hf₀_int.const_mul _).add (integrable_const _)
-    refine ha.congr (Filter.Eventually.of_forall fun z => ?_)
-    simp only [hbound_def]; ring
-  have h_conv_force : ∀ s ∈ W, ∀ x : PhysSpace d,
-      ‖convolveFunctionMeasure gradW (ρ s) x‖
-        ≤ ‖gradW 0‖ + (L : ℝ) * ‖x‖ + (L : ℝ) * M := by
-    intro s hs x
-    have := hρ_prob s hs
-    exact vlasovGlue_conv_force_bound gradW L hL (ρ s) M (hM s hs)
-      (h_y_int s hs) (h_int s hs) x
-  have hB : ∀ s ∈ W, ∀ z : PhaseSpace d,
-      ‖@inner ℝ (PhysSpace d) _ (V s z) (gradXφ (X s z, V s z)) -
-          @inner ℝ (PhysSpace d) _
-            (convolveFunctionMeasure gradW (ρ s) (X s z))
-            (gradVφ (X s z, V s z))‖ ≤ bound_fn z := by
-    intro s hs z
-    have hV : ‖V s z‖ ≤ C * (‖z‖ + 1) :=
-      le_trans (norm_snd_le (X s z, V s z)) (hC_pair s hs z)
-    have hX : ‖X s z‖ ≤ C * (‖z‖ + 1) :=
-      le_trans (norm_fst_le (X s z, V s z)) (hC_pair s hs z)
-    have ht1 : ‖@inner ℝ (PhysSpace d) _ (V s z) (gradXφ (X s z, V s z))‖
-        ≤ M_φ * (C * (‖z‖ + 1)) := by
-      refine le_trans (norm_inner_le_norm _ _) ?_
-      have := mul_le_mul hV (hgradXφ_bd (X s z, V s z))
-        (norm_nonneg _) (le_trans (norm_nonneg _) hV)
-      calc ‖V s z‖ * ‖gradXφ (X s z, V s z)‖
-          ≤ (C * (‖z‖ + 1)) * M_φ := this
-        _ = M_φ * (C * (‖z‖ + 1)) := by ring
-    have ht2 : ‖@inner ℝ (PhysSpace d) _
-          (convolveFunctionMeasure gradW (ρ s) (X s z))
-          (gradVφ (X s z, V s z))‖
-        ≤ (‖gradW 0‖ + (L : ℝ) * (C * (‖z‖ + 1)) + (L : ℝ) * M) * M_φ := by
-      refine le_trans (norm_inner_le_norm _ _) ?_
-      have hc : ‖convolveFunctionMeasure gradW (ρ s) (X s z)‖
-          ≤ ‖gradW 0‖ + (L : ℝ) * (C * (‖z‖ + 1)) + (L : ℝ) * M := by
-        refine le_trans (h_conv_force s hs (X s z)) ?_
-        have := mul_le_mul_of_nonneg_left hX L.coe_nonneg
-        linarith
-      have hcnn : 0 ≤ ‖gradW 0‖ + (L : ℝ) * (C * (‖z‖ + 1)) + (L : ℝ) * M :=
-        le_trans (norm_nonneg _) hc
-      exact mul_le_mul hc (hgradVφ_bd (X s z, V s z)) (norm_nonneg _) hcnn
-    calc ‖_ - _‖
-        ≤ ‖@inner ℝ (PhysSpace d) _ (V s z) (gradXφ (X s z, V s z))‖
-          + ‖@inner ℝ (PhysSpace d) _
-              (convolveFunctionMeasure gradW (ρ s) (X s z))
-              (gradVφ (X s z, V s z))‖ := norm_sub_le _ _
-      _ ≤ bound_fn z := by simp only [hbound_def]; linarith
-  apply continuousWithinAt_of_dominated (bound := bound_fn)
-  · -- AEStronglyMeasurable in z, eventually in s
-    apply Filter.Eventually.mono hW_nhd
-    intro s hs
-    have h_aem_pair := h_aemeas s hs
-    have h_aem_X : AEMeasurable (fun z : PhaseSpace d => X s z) f₀ :=
-      measurable_fst.comp_aemeasurable h_aem_pair
-    have h_aem_V : AEMeasurable (fun z : PhaseSpace d => V s z) f₀ :=
-      measurable_snd.comp_aemeasurable h_aem_pair
-    have h1 : AEStronglyMeasurable
-        (fun z : PhaseSpace d => @inner ℝ (PhysSpace d) _ (V s z)
-          (gradXφ (X s z, V s z))) f₀ := by
-      have hg : AEMeasurable (fun z : PhaseSpace d => gradXφ (X s z, V s z)) f₀ :=
-        hgradXφ_cont.measurable.comp_aemeasurable (h_aem_X.prodMk h_aem_V)
-      exact (continuous_inner.measurable.comp_aemeasurable
-        (h_aem_V.prodMk hg)).aestronglyMeasurable
-    have h2 : AEStronglyMeasurable
-        (fun z : PhaseSpace d => @inner ℝ (PhysSpace d) _
-          (convolveFunctionMeasure gradW (ρ s) (X s z))
-          (gradVφ (X s z, V s z))) f₀ := by
-      have hconv_aem : AEMeasurable
-          (fun z : PhaseSpace d => convolveFunctionMeasure gradW (ρ s) (X s z)) f₀ := by
-        have hconv_cont' : Continuous (fun x : PhysSpace d =>
-            convolveFunctionMeasure gradW (ρ s) x) := by
-          have := hρ_prob s hs
-          exact (convolveFunctionMeasure_lipschitz_in_x gradW L hL
-            (ρ s) (h_int s hs)).continuous
-        exact hconv_cont'.measurable.comp_aemeasurable h_aem_X
-      have hg : AEMeasurable (fun z : PhaseSpace d => gradVφ (X s z, V s z)) f₀ :=
-        hgradVφ_cont.measurable.comp_aemeasurable (h_aem_X.prodMk h_aem_V)
-      exact (continuous_inner.measurable.comp_aemeasurable
-        (hconv_aem.prodMk hg)).aestronglyMeasurable
-    exact h1.sub h2
-  · -- dominator bound, eventually in s
-    apply Filter.Eventually.mono hW_nhd
-    intro s hs
-    exact Filter.Eventually.of_forall fun z => hB s hs z
-  · exact hbound_int
-  · -- pointwise continuity in s, for every z
-    apply Filter.Eventually.of_forall
-    intro z
-    have h_pair_cwn : ContinuousWithinAt (fun s => (X s z, V s z)) S T₀ :=
-      (h_X_cont z).prodMk (h_V_cont z)
-    have h_gX_cwn : ContinuousWithinAt
-        (fun s => gradXφ (X s z, V s z)) S T₀ :=
-      hgradXφ_cont.continuousAt.comp_continuousWithinAt h_pair_cwn
-    have h_gV_cwn : ContinuousWithinAt
-        (fun s => gradVφ (X s z, V s z)) S T₀ :=
-      hgradVφ_cont.continuousAt.comp_continuousWithinAt h_pair_cwn
-    have h_term1 : ContinuousWithinAt
-        (fun s => @inner ℝ (PhysSpace d) _ (V s z)
-          (gradXφ (X s z, V s z))) S T₀ :=
-      (h_V_cont z).inner h_gX_cwn
-    have h_term2 : ContinuousWithinAt
-        (fun s => @inner ℝ (PhysSpace d) _
-          (convolveFunctionMeasure gradW (ρ s) (X s z))
-          (gradVφ (X s z, V s z))) S T₀ :=
-      (h_conv_cwn z).inner h_gV_cwn
-    exact h_term1.sub h_term2
+private alias vlasovGlue_moment :=
+  _root_.Vlasov.vlasovGlue_moment
 
-/-- LEFT seam continuity of the force-integral functional at `T`: on `Iic T`
-the glued solution agrees with `f_prev` (via `hf_next_le`), whose window
-pushforward representation reduces the claim to the generic seam DCT lemma
-`vlasovGlue_seam_forceIntegral_cont` on `f_prev`'s window flow. -/
-private lemma vlasovGlue_seam_contLeft
-    {d : ℕ}
-    (gradW : PhysSpace d → PhysSpace d)
-    (L : NNReal) (hL : LipschitzWith L gradW)
-    (f₀ : Measure (PhaseSpace d)) [IsProbabilityMeasure f₀]
-    (hf₀_int : Integrable (fun z : PhaseSpace d => ‖z‖) f₀)
-    {T : ℝ} (hT_pos : 0 < T)
-    (f_prev : ℝ → Measure (PhaseSpace d))
-    (h_prev_init : f_prev 0 = f₀)
-    (h_prev_mom : ∀ t ∈ Set.Icc (0 : ℝ) T, HasFiniteFirstMoment (f_prev t))
-    (hM_prev : ∃ M : ℝ, 0 ≤ M ∧
-        ∀ t ∈ Set.Icc (0 : ℝ) T, ∫ y, ‖y‖ ∂(spatialMarginal (f_prev t)) ≤ M)
-    (charX_prev charV_prev : ℝ → PhaseSpace d → PhysSpace d)
-    (h_prev_push : ∀ t ∈ Set.Icc (0 : ℝ) T,
-        f_prev t =
-          Measure.map (fun z : PhaseSpace d => (charX_prev t z, charV_prev t z)) (f_prev 0))
-    (h_prev_aemeas : ∀ s ∈ Set.Icc (0 : ℝ) T,
-        AEMeasurable (fun z : PhaseSpace d => (charX_prev s z, charV_prev s z)) (f_prev 0))
-    (h_prev_boundary : ∀ (z : PhaseSpace d) (t : ℝ), t ∈ Set.Icc (0 : ℝ) T →
-        HasDerivWithinAt (fun s => charX_prev s z) (charV_prev t z) (Set.Icc 0 T) t ∧
-        HasDerivWithinAt (fun s => charV_prev s z)
-          (-(convolveFunctionMeasure gradW (spatialMarginal (f_prev t)) (charX_prev t z)))
-          (Set.Icc 0 T) t)
-    (h_prev_ic : ∀ z : PhaseSpace d, charX_prev 0 z = z.1 ∧ charV_prev 0 z = z.2)
-    (f_next : ℝ → Measure (PhaseSpace d))
-    (hf_next_le : ∀ s, s ≤ T → f_next s = f_prev s)
-    (φ : PhaseSpace d → ℝ)
-    (hφ_smooth : ContDiff ℝ (⊤ : ℕ∞) φ) (hφ_compact : HasCompactSupport φ)
-    (gradXφ gradVφ : PhaseSpace d → PhysSpace d)
-    (hgradXφ : ∀ z : PhaseSpace d, gradXφ z = gradient (fun x => φ (x, z.2)) z.1)
-    (hgradVφ : ∀ z : PhaseSpace d, gradVφ z = gradient (fun v => φ (z.1, v)) z.2) :
-    ContinuousWithinAt
-      (fun s => ∫ z, (@inner ℝ (PhysSpace d) _ z.2 (gradXφ z) -
-              @inner ℝ (PhysSpace d) _
-                (convolveFunctionMeasure gradW (spatialMarginal (f_next s)) z.1)
-                (gradVφ z)) ∂(f_next s)) (Set.Iic T) T := by
-  have h_nhd_L : Set.Icc (0 : ℝ) T ∈ nhdsWithin T (Set.Iic T) :=
-    Icc_mem_nhdsLE hT_pos
-  have hgradXφ_cont : Continuous gradXφ :=
-    vlasovGlue_gradXφ_continuous φ hφ_smooth gradXφ hgradXφ
-  have hgradVφ_cont : Continuous gradVφ :=
-    vlasovGlue_gradVφ_continuous φ hφ_smooth gradVφ hgradVφ
-  have h_int_marg := dobrushinFlow_marginal_gradW_integrable gradW L hL T
-    f_prev h_prev_mom
-  have h_push_marg : ∀ s ∈ Set.Icc (0 : ℝ) T,
-      spatialMarginal (f_prev s)
-        = Measure.map (fun z : PhaseSpace d => charX_prev s z) f₀ := by
-    intro s hs
-    have h_pair_aem : AEMeasurable
-        (fun z : PhaseSpace d => (charX_prev s z, charV_prev s z)) f₀ :=
-      h_prev_init ▸ h_prev_aemeas s hs
-    unfold spatialMarginal
-    rw [h_prev_push s hs, h_prev_init,
-        AEMeasurable.map_map_of_aemeasurable measurable_fst.aemeasurable h_pair_aem]
-    rfl
-  have h_aemeas_marg : ∀ s ∈ Set.Icc (0 : ℝ) T,
-      AEMeasurable (fun z : PhaseSpace d => charX_prev s z) f₀ := by
-    intro s hs
-    have h_pair_aem : AEMeasurable
-        (fun z : PhaseSpace d => (charX_prev s z, charV_prev s z)) f₀ :=
-      h_prev_init ▸ h_prev_aemeas s hs
-    exact measurable_fst.comp_aemeasurable h_pair_aem
-  obtain ⟨M_ρ, hM_ρ_nn, hM_ρ⟩ := hM_prev
-  have h_y_int_marg : ∀ t ∈ Set.Icc (0 : ℝ) T,
-      Integrable (fun y : PhysSpace d => ‖y‖) (spatialMarginal (f_prev t)) :=
-    fun t ht => vlasovGlue_marginal_norm_integrable (f_prev t) (h_prev_mom t ht)
-  obtain ⟨C_T, hC_T_nn, hC_T_pair, h_cont_Icc_prev⟩ :=
-    vlasovGlue_flow_growthBound gradW L hL f_prev charX_prev charV_prev
-      T hT_pos h_prev_mom ⟨M_ρ, hM_ρ_nn, hM_ρ⟩ h_prev_ic h_prev_boundary
-  have hC_T : ∀ s ∈ Set.Icc (0 : ℝ) T, ∀ z : PhaseSpace d,
-      ‖charX_prev s z‖ ≤ C_T * (‖z‖ + 1) := by
-    intro s hs z
-    exact le_trans (norm_fst_le (charX_prev s z, charV_prev s z))
-      (hC_T_pair s hs z)
-  have h_conv_z_cont : ∀ s ∈ Set.Icc (0 : ℝ) T,
-      Continuous (fun z : PhaseSpace d =>
-        convolveFunctionMeasure gradW (spatialMarginal (f_prev s)) z.1) := by
-    intro s hs
-    have : IsProbabilityMeasure (f_prev s) := (h_prev_mom s hs).1
-    have : IsProbabilityMeasure (spatialMarginal (f_prev s)) :=
-      (Measure.isProbabilityMeasure_map_iff measurable_fst.aemeasurable).mpr inferInstance
-    exact (convolveFunctionMeasure_lipschitz_in_x gradW L hL
-      (spatialMarginal (f_prev s)) (h_int_marg s hs)).continuous.comp continuous_fst
-  have h_integrand_cont : ∀ s ∈ Set.Icc (0 : ℝ) T,
-      Continuous (fun z : PhaseSpace d =>
-        @inner ℝ (PhysSpace d) _ z.2 (gradXφ z) -
-        @inner ℝ (PhysSpace d) _
-          (convolveFunctionMeasure gradW (spatialMarginal (f_prev s)) z.1)
-          (gradVφ z)) := by
-    intro s hs
-    exact (continuous_snd.inner hgradXφ_cont).sub
-      ((h_conv_z_cont s hs).inner hgradVφ_cont)
-  have h_eq_L : (fun s => ∫ z, (@inner ℝ (PhysSpace d) _ z.2 (gradXφ z) -
-          @inner ℝ (PhysSpace d) _
-            (convolveFunctionMeasure gradW (spatialMarginal (f_next s)) z.1)
-            (gradVφ z)) ∂(f_next s))
-      =ᶠ[nhdsWithin T (Set.Iic T)]
-      (fun s => ∫ z, (@inner ℝ (PhysSpace d) _ (charV_prev s z)
-            (gradXφ (charX_prev s z, charV_prev s z)) -
-          @inner ℝ (PhysSpace d) _
-            (convolveFunctionMeasure gradW (spatialMarginal (f_prev s))
-              (charX_prev s z))
-            (gradVφ (charX_prev s z, charV_prev s z))) ∂f₀) := by
-    apply Filter.Eventually.mono h_nhd_L
-    intro s hs
-    have h_fnext : f_next s = f_prev s := hf_next_le s hs.2
-    have h_marg : spatialMarginal (f_next s) = spatialMarginal (f_prev s) :=
-      congrArg spatialMarginal h_fnext
-    have h_aemeas_f₀ : AEMeasurable
-        (fun z : PhaseSpace d => (charX_prev s z, charV_prev s z)) f₀ :=
-      h_prev_init ▸ h_prev_aemeas s hs
-    change (∫ z, (@inner ℝ (PhysSpace d) _ z.2 (gradXφ z) -
-            @inner ℝ (PhysSpace d) _
-              (convolveFunctionMeasure gradW (spatialMarginal (f_next s)) z.1)
-              (gradVφ z)) ∂(f_next s))
-        = ∫ z, (@inner ℝ (PhysSpace d) _ (charV_prev s z)
-              (gradXφ (charX_prev s z, charV_prev s z)) -
-            @inner ℝ (PhysSpace d) _
-              (convolveFunctionMeasure gradW (spatialMarginal (f_prev s))
-                (charX_prev s z))
-              (gradVφ (charX_prev s z, charV_prev s z))) ∂f₀
-    have h_meq : f_next s
-        = Measure.map
-            (fun z : PhaseSpace d => (charX_prev s z, charV_prev s z)) f₀ := by
-      rw [h_fnext, h_prev_push s hs, h_prev_init]
-    rw [h_marg, h_meq,
-        integral_map h_aemeas_f₀
-          (h_integrand_cont s hs).aestronglyMeasurable]
-  obtain ⟨M_φ, hgradXφ_bd, hgradVφ_bd⟩ :=
-    vlasovGlue_gradφ_bound φ hφ_smooth hφ_compact gradXφ gradVφ hgradXφ hgradVφ
-  have h_X_cont : ∀ z : PhaseSpace d,
-      ContinuousWithinAt (fun s => charX_prev s z) (Set.Iic T) T := fun z =>
-    ((h_prev_boundary z T
-        ⟨hT_pos.le, le_refl T⟩).1.continuousWithinAt).mono_of_mem_nhdsWithin h_nhd_L
-  have h_V_cont : ∀ z : PhaseSpace d,
-      ContinuousWithinAt (fun s => charV_prev s z) (Set.Iic T) T := fun z =>
-    ((h_prev_boundary z T
-        ⟨hT_pos.le, le_refl T⟩).2.continuousWithinAt).mono_of_mem_nhdsWithin h_nhd_L
-  have h_conv_cwn : ∀ z : PhaseSpace d, ContinuousWithinAt
-      (fun s => convolveFunctionMeasure gradW (spatialMarginal (f_prev s))
-        (charX_prev s z)) (Set.Iic T) T := fun z =>
-    flowConv_continuousWithinAt_Iic_seam gradW L hL charX_prev f₀
-      hf₀_int hT_pos (fun s => spatialMarginal (f_prev s))
-      h_push_marg h_aemeas_marg
-      (fun z' => (h_cont_Icc_prev z').continuousWithinAt
-        (Set.right_mem_Icc.mpr hT_pos.le) |>.fst) C_T hC_T_nn hC_T z
-  have h_cont_pf : ContinuousWithinAt
-      (fun s => ∫ z, (@inner ℝ (PhysSpace d) _ (charV_prev s z)
-            (gradXφ (charX_prev s z, charV_prev s z)) -
-          @inner ℝ (PhysSpace d) _
-            (convolveFunctionMeasure gradW (spatialMarginal (f_prev s))
-              (charX_prev s z))
-            (gradVφ (charX_prev s z, charV_prev s z))) ∂f₀)
-      (Set.Iic T) T :=
-    vlasovGlue_seam_forceIntegral_cont gradW L hL f₀ hf₀_int gradXφ gradVφ
-      hgradXφ_cont hgradVφ_cont M_φ hgradXφ_bd hgradVφ_bd
-      (fun s => spatialMarginal (f_prev s)) charX_prev charV_prev
-      T (Set.Iic T) (Set.Icc 0 T) h_nhd_L
-      (fun s hs => by
-        have : IsProbabilityMeasure (f_prev s) := (h_prev_mom s hs).1
-        exact (Measure.isProbabilityMeasure_map_iff measurable_fst.aemeasurable).mpr inferInstance)
-      M_ρ hM_ρ h_y_int_marg h_int_marg C_T hC_T_pair
-      (fun s hs => h_prev_init ▸ h_prev_aemeas s hs)
-      h_X_cont h_V_cont h_conv_cwn
-  have h_val_T : (∫ z, (@inner ℝ (PhysSpace d) _ z.2 (gradXφ z) -
-          @inner ℝ (PhysSpace d) _
-            (convolveFunctionMeasure gradW (spatialMarginal (f_next T)) z.1)
-            (gradVφ z)) ∂(f_next T))
-      = ∫ z, (@inner ℝ (PhysSpace d) _ (charV_prev T z)
-            (gradXφ (charX_prev T z, charV_prev T z)) -
-          @inner ℝ (PhysSpace d) _
-            (convolveFunctionMeasure gradW (spatialMarginal (f_prev T))
-              (charX_prev T z))
-            (gradVφ (charX_prev T z, charV_prev T z))) ∂f₀ := by
-    have hT_Icc : T ∈ Set.Icc (0 : ℝ) T := ⟨hT_pos.le, le_refl T⟩
-    have h_fnext_T : f_next T = f_prev T := hf_next_le T (le_refl T)
-    have h_marg : spatialMarginal (f_next T) = spatialMarginal (f_prev T) :=
-      congrArg spatialMarginal h_fnext_T
-    have h_aemeas_f₀_T : AEMeasurable
-        (fun z : PhaseSpace d => (charX_prev T z, charV_prev T z)) f₀ :=
-      h_prev_init ▸ h_prev_aemeas T hT_Icc
-    have h_meq : f_next T
-        = Measure.map
-            (fun z : PhaseSpace d => (charX_prev T z, charV_prev T z)) f₀ := by
-      rw [h_fnext_T, h_prev_push T hT_Icc, h_prev_init]
-    rw [h_marg, h_meq,
-        integral_map h_aemeas_f₀_T (h_integrand_cont T hT_Icc).aestronglyMeasurable]
-  exact h_cont_pf.congr_of_eventuallyEq h_eq_L h_val_T
+private alias vlasovGlue_moment_flat :=
+  _root_.Vlasov.vlasovGlue_moment_flat
 
-/-- A shifted flow curve `s ↦ Φ (s − T) w` is continuous within `Ici T` at `T`
-when the unshifted curve has a one-sided derivative at `0` on `[0, T_0]`. -/
-private lemma vlasovGlue_shifted_flow_contWithin
-    {d : ℕ}
-    (charW : ℝ → PhaseSpace d → PhysSpace d) (w : PhaseSpace d) {v₀ : PhysSpace d}
-    (T : ℝ) {T_0 : ℝ} (hT_0_pos : 0 < T_0)
-    (hb : HasDerivWithinAt (fun s => charW s w) v₀ (Set.Icc 0 T_0) 0) :
-    ContinuousWithinAt (fun s => charW (s - T) w) (Set.Ici T) T := by
-  have h_nhdsW_0 : Set.Icc (0 : ℝ) T_0 ∈ nhdsWithin 0 (Set.Ici 0) :=
-    Icc_mem_nhdsGE hT_0_pos
-  have h_cont : ContinuousWithinAt (fun s => charW s w) (Set.Ici 0) 0 :=
-    hb.continuousWithinAt.mono_of_mem_nhdsWithin h_nhdsW_0
-  have h_sub_cont : ContinuousWithinAt (fun s : ℝ => s - T) (Set.Ici T) T :=
-    ((continuous_id.sub continuous_const).continuousAt).continuousWithinAt
-  have h_sub_maps : Set.MapsTo (fun s : ℝ => s - T) (Set.Ici T) (Set.Ici 0) :=
-    fun s hs => Set.mem_Ici.mpr (by linarith [Set.mem_Ici.mp hs])
-  exact ContinuousWithinAt.comp_of_eq h_cont h_sub_cont h_sub_maps (sub_self T)
+private alias vlasovGlue_pushforward_eq :=
+  _root_.Vlasov.vlasovGlue_pushforward_eq
 
-/-- Composed-pushforward infrastructure on the glued window `[T, T+T_0]`:
-`g (s−T)` is the pushforward of `f₀` by the composed phase-space flow
-(`g`'s window flow after the outer time-`T` map `(XT, VT)`), its spatial
-marginal is the pushforward by the composed position map, and both composed
-maps are a.e.-measurable. -/
-private lemma vlasovGlue_composed_pushforward
-    {d : ℕ}
-    (f₀ : Measure (PhaseSpace d))
-    (g : ℝ → Measure (PhaseSpace d))
-    (f_prevT : Measure (PhaseSpace d))
-    (charX_g charV_g : ℝ → PhaseSpace d → PhysSpace d)
-    (XT VT : PhaseSpace d → PhysSpace d)
-    {T T_0 : ℝ}
-    (h_outer_aemeas : AEMeasurable (fun z : PhaseSpace d => (XT z, VT z)) f₀)
-    (h_prevT_push : f_prevT = Measure.map (fun z : PhaseSpace d => (XT z, VT z)) f₀)
-    (hg_init : g 0 = f_prevT)
-    (hg_push_ex : ∀ t ∈ Set.Icc (0 : ℝ) T_0,
-        g t = Measure.map (fun z : PhaseSpace d => (charX_g t z, charV_g t z)) (g 0))
-    (hg_aemeas_ex : ∀ s ∈ Set.Icc (0 : ℝ) T_0,
-        AEMeasurable (fun z : PhaseSpace d => (charX_g s z, charV_g s z)) (g 0)) :
-    (∀ τ ∈ Set.Icc (0 : ℝ) T_0,
-        AEMeasurable (fun z : PhaseSpace d =>
-          (charX_g τ (XT z, VT z), charV_g τ (XT z, VT z))) f₀) ∧
-    (∀ s ∈ Set.Icc T (T + T_0),
-        g (s - T) = Measure.map (fun z : PhaseSpace d =>
-          (charX_g (s - T) (XT z, VT z), charV_g (s - T) (XT z, VT z))) f₀) ∧
-    (∀ s ∈ Set.Icc T (T + T_0),
-        spatialMarginal (g (s - T)) = Measure.map (fun z : PhaseSpace d =>
-          charX_g (s - T) (XT z, VT z)) f₀) ∧
-    (∀ s ∈ Set.Icc T (T + T_0),
-        AEMeasurable (fun z : PhaseSpace d => charX_g (s - T) (XT z, VT z)) f₀) := by
-  have h_g_at_aemeas : ∀ τ ∈ Set.Icc (0 : ℝ) T_0,
-      AEMeasurable (fun z : PhaseSpace d => (charX_g τ z, charV_g τ z))
-        (Measure.map (fun z : PhaseSpace d => (XT z, VT z)) f₀) := by
-    intro τ hτ
-    have := hg_aemeas_ex τ hτ
-    rw [hg_init, h_prevT_push] at this
-    exact this
-  have h_comp_aemeas : ∀ τ ∈ Set.Icc (0 : ℝ) T_0,
-      AEMeasurable (fun z : PhaseSpace d =>
-        (charX_g τ (XT z, VT z), charV_g τ (XT z, VT z))) f₀ := by
-    intro τ hτ
-    exact (h_g_at_aemeas τ hτ).comp_aemeasurable h_outer_aemeas
-  have h_push_comp : ∀ s ∈ Set.Icc T (T + T_0),
-      g (s - T) = Measure.map (fun z : PhaseSpace d =>
-        (charX_g (s - T) (XT z, VT z), charV_g (s - T) (XT z, VT z))) f₀ := by
-    intro s hs
-    have hsT_Icc : s - T ∈ Set.Icc (0 : ℝ) T_0 :=
-      ⟨by linarith [hs.1], by linarith [hs.2]⟩
-    rw [hg_push_ex (s - T) hsT_Icc, hg_init, h_prevT_push,
-        AEMeasurable.map_map_of_aemeasurable
-          (h_g_at_aemeas (s - T) hsT_Icc) h_outer_aemeas]
-    rfl
-  refine ⟨h_comp_aemeas, h_push_comp, fun s hs => ?_, fun s hs => ?_⟩
-  · have hsT_Icc : s - T ∈ Set.Icc (0 : ℝ) T_0 :=
-      ⟨by linarith [hs.1], by linarith [hs.2]⟩
-    unfold spatialMarginal
-    rw [h_push_comp s hs,
-        AEMeasurable.map_map_of_aemeasurable measurable_fst.aemeasurable
-          (h_comp_aemeas (s - T) hsT_Icc)]
-    rfl
-  · have hsT_Icc : s - T ∈ Set.Icc (0 : ℝ) T_0 :=
-      ⟨by linarith [hs.1], by linarith [hs.2]⟩
-    exact measurable_fst.comp_aemeasurable (h_comp_aemeas (s - T) hsT_Icc)
+private alias vlasovGlue_seam_contLeft :=
+  _root_.Vlasov.vlasovGlue_seam_contLeft
 
-/-- Pointwise composed-pushforward rewrite of the force integral on the glued
-window: for `s ∈ [T, T+T_0]` the integral of the force integrand against
-`f_next s` equals the integral of the flow-composed integrand against `f₀`.
-Serves both the eventually-equal rewrite and the value-at-`T` bridge of the
-RIGHT seam close. -/
-private lemma vlasovGlue_composed_integral_eq
-    {d : ℕ}
-    (gradW : PhysSpace d → PhysSpace d)
-    (f₀ : Measure (PhaseSpace d))
-    {T T_0 : ℝ} (hT_pos : 0 < T)
-    (f_prev g : ℝ → Measure (PhaseSpace d))
-    (h_prev_init : f_prev 0 = f₀)
-    (charX_prev charV_prev charX_g charV_g : ℝ → PhaseSpace d → PhysSpace d)
-    (h_prev_push : ∀ t ∈ Set.Icc (0 : ℝ) T,
-        f_prev t =
-          Measure.map (fun z : PhaseSpace d => (charX_prev t z, charV_prev t z)) (f_prev 0))
-    (hg_init : g 0 = f_prev T)
-    (hg_init_cond : ∀ z : PhaseSpace d, charX_g 0 z = z.1 ∧ charV_g 0 z = z.2)
-    (f_next : ℝ → Measure (PhaseSpace d))
-    (hf_next_T : f_next T = f_prev T)
-    (hf_next_gt : ∀ s, T < s → f_next s = g (s - T))
-    (gradXφ gradVφ : PhaseSpace d → PhysSpace d)
-    (h_comp_aemeas : ∀ τ ∈ Set.Icc (0 : ℝ) T_0,
-        AEMeasurable (fun z : PhaseSpace d =>
-          (charX_g τ (charX_prev T z, charV_prev T z),
-           charV_g τ (charX_prev T z, charV_prev T z))) f₀)
-    (h_g_push_comp : ∀ s ∈ Set.Icc T (T + T_0),
-        g (s - T) = Measure.map (fun z : PhaseSpace d =>
-          (charX_g (s - T) (charX_prev T z, charV_prev T z),
-           charV_g (s - T) (charX_prev T z, charV_prev T z))) f₀)
-    (h_integrand_cont : ∀ τ ∈ Set.Icc (0 : ℝ) T_0,
-        Continuous (fun z : PhaseSpace d =>
-          @inner ℝ (PhysSpace d) _ z.2 (gradXφ z) -
-          @inner ℝ (PhysSpace d) _
-            (convolveFunctionMeasure gradW (spatialMarginal (g τ)) z.1)
-            (gradVφ z)))
-    (s : ℝ) (hs : s ∈ Set.Icc T (T + T_0)) :
-    (∫ z, (@inner ℝ (PhysSpace d) _ z.2 (gradXφ z) -
-        @inner ℝ (PhysSpace d) _
-          (convolveFunctionMeasure gradW (spatialMarginal (f_next s)) z.1)
-          (gradVφ z)) ∂(f_next s))
-      = ∫ z, (@inner ℝ (PhysSpace d) _
-            (charV_g (s - T) (charX_prev T z, charV_prev T z))
-            (gradXφ (charX_g (s - T) (charX_prev T z, charV_prev T z),
-                     charV_g (s - T) (charX_prev T z, charV_prev T z))) -
-          @inner ℝ (PhysSpace d) _
-            (convolveFunctionMeasure gradW (spatialMarginal (g (s - T)))
-              (charX_g (s - T) (charX_prev T z, charV_prev T z)))
-            (gradVφ (charX_g (s - T) (charX_prev T z, charV_prev T z),
-                     charV_g (s - T) (charX_prev T z, charV_prev T z)))) ∂f₀ := by
-  have hT_Icc : T ∈ Set.Icc (0 : ℝ) T := ⟨hT_pos.le, le_refl T⟩
-  have hsT_Icc : s - T ∈ Set.Icc (0 : ℝ) T_0 :=
-    ⟨by linarith [hs.1], by linarith [hs.2]⟩
-  by_cases hs_eq : s = T
-  · -- s = T: f_next T = f_prev T = composed pushforward (collapse g at 0 = id)
-    have hs_T_zero : s - T = 0 := by rw [hs_eq]; exact sub_self T
-    have h_fnext_s : f_next s = f_prev T := by
-      rw [hs_eq]; exact hf_next_T
-    have h_marg_eq : spatialMarginal (f_next s) = spatialMarginal (g (s - T)) := by
-      rw [h_fnext_s, hs_T_zero, hg_init]
-    have h_meq : f_next s = Measure.map
-        (fun z : PhaseSpace d =>
-          (charX_g (s - T) (charX_prev T z, charV_prev T z),
-           charV_g (s - T) (charX_prev T z, charV_prev T z))) f₀ := by
-      rw [h_fnext_s, h_prev_push T hT_Icc, h_prev_init]
-      apply Measure.map_congr
-      apply Filter.Eventually.of_forall
-      intro z
-      simp only [hs_T_zero, (hg_init_cond _).1, (hg_init_cond _).2]
-    rw [h_marg_eq, h_meq,
-        integral_map (h_comp_aemeas (s - T) hsT_Icc)
-          (h_integrand_cont (s - T) hsT_Icc).aestronglyMeasurable]
-  · -- s > T: f_next s = g (s − T) = composed pushforward
-    have hs_gt : T < s := lt_of_le_of_ne hs.1 (Ne.symm hs_eq)
-    have h_fnext_s : f_next s = g (s - T) := hf_next_gt s hs_gt
-    have h_marg_eq : spatialMarginal (f_next s) = spatialMarginal (g (s - T)) :=
-      congrArg spatialMarginal h_fnext_s
-    have h_meq : f_next s = Measure.map
-        (fun z : PhaseSpace d =>
-          (charX_g (s - T) (charX_prev T z, charV_prev T z),
-           charV_g (s - T) (charX_prev T z, charV_prev T z))) f₀ := by
-      rw [h_fnext_s]; exact h_g_push_comp s hs
-    rw [h_marg_eq, h_meq,
-        integral_map (h_comp_aemeas (s - T) hsT_Icc)
-          (h_integrand_cont (s - T) hsT_Icc).aestronglyMeasurable]
+private alias vlasovGlue_seam_contRight :=
+  _root_.Vlasov.vlasovGlue_seam_contRight
 
-/-- RIGHT seam continuity of the force-integral functional at `T`: on `Ici T`
-the glued solution is `g (·−T)` (via `hf_next_T`/`hf_next_gt`), represented as
-the composed pushforward of `f₀` by `g`'s window flow after `f_prev`'s time-`T`
-flow; the claim reduces to the generic seam DCT lemma
-`vlasovGlue_seam_forceIntegral_cont` on the composed flow. -/
-private lemma vlasovGlue_seam_contRight
-    {d : ℕ}
-    (gradW : PhysSpace d → PhysSpace d)
-    (L : NNReal) (hL : LipschitzWith L gradW)
-    (f₀ : Measure (PhaseSpace d)) [IsProbabilityMeasure f₀]
-    (hf₀_int : Integrable (fun z : PhaseSpace d => ‖z‖) f₀)
-    {T : ℝ} (hT_pos : 0 < T) {T_0 : ℝ} (hT_0_pos : 0 < T_0)
-    (f_prev : ℝ → Measure (PhaseSpace d))
-    (h_prev_init : f_prev 0 = f₀)
-    (h_prev_mom : ∀ t ∈ Set.Icc (0 : ℝ) T, HasFiniteFirstMoment (f_prev t))
-    (hM_prev : ∃ M : ℝ, 0 ≤ M ∧
-        ∀ t ∈ Set.Icc (0 : ℝ) T, ∫ y, ‖y‖ ∂(spatialMarginal (f_prev t)) ≤ M)
-    (charX_prev charV_prev : ℝ → PhaseSpace d → PhysSpace d)
-    (h_prev_push : ∀ t ∈ Set.Icc (0 : ℝ) T,
-        f_prev t =
-          Measure.map (fun z : PhaseSpace d => (charX_prev t z, charV_prev t z)) (f_prev 0))
-    (h_prev_aemeas : ∀ s ∈ Set.Icc (0 : ℝ) T,
-        AEMeasurable (fun z : PhaseSpace d => (charX_prev s z, charV_prev s z)) (f_prev 0))
-    (h_prev_boundary : ∀ (z : PhaseSpace d) (t : ℝ), t ∈ Set.Icc (0 : ℝ) T →
-        HasDerivWithinAt (fun s => charX_prev s z) (charV_prev t z) (Set.Icc 0 T) t ∧
-        HasDerivWithinAt (fun s => charV_prev s z)
-          (-(convolveFunctionMeasure gradW (spatialMarginal (f_prev t)) (charX_prev t z)))
-          (Set.Icc 0 T) t)
-    (h_prev_ic : ∀ z : PhaseSpace d, charX_prev 0 z = z.1 ∧ charV_prev 0 z = z.2)
-    (g : ℝ → Measure (PhaseSpace d))
-    (charX_g charV_g : ℝ → PhaseSpace d → PhysSpace d)
-    (hg_init : g 0 = f_prev T)
-    (hg_mom : ∀ t ∈ Set.Icc (0 : ℝ) T_0, HasFiniteFirstMoment (g t))
-    (hg_mom_unif : ∃ M : ℝ, 0 ≤ M ∧
-        ∀ t ∈ Set.Icc (0 : ℝ) T_0, ∫ y, ‖y‖ ∂(spatialMarginal (g t)) ≤ M)
-    (hg_push_ex : ∀ t ∈ Set.Icc (0 : ℝ) T_0,
-        g t = Measure.map (fun z : PhaseSpace d => (charX_g t z, charV_g t z)) (g 0))
-    (hg_aemeas_ex : ∀ s ∈ Set.Icc (0 : ℝ) T_0,
-        AEMeasurable (fun z : PhaseSpace d => (charX_g s z, charV_g s z)) (g 0))
-    (hg_boundary : ∀ z : PhaseSpace d, ∀ t ∈ Set.Icc (0 : ℝ) T_0,
-        HasDerivWithinAt (fun s => charX_g s z) (charV_g t z) (Set.Icc 0 T_0) t ∧
-        HasDerivWithinAt (fun s => charV_g s z)
-          (-(convolveFunctionMeasure gradW (spatialMarginal (g t)) (charX_g t z)))
-          (Set.Icc 0 T_0) t)
-    (hg_init_cond : ∀ z : PhaseSpace d, charX_g 0 z = z.1 ∧ charV_g 0 z = z.2)
-    (f_next : ℝ → Measure (PhaseSpace d))
-    (hf_next_T : f_next T = f_prev T)
-    (hf_next_gt : ∀ s, T < s → f_next s = g (s - T))
-    (φ : PhaseSpace d → ℝ)
-    (hφ_smooth : ContDiff ℝ (⊤ : ℕ∞) φ) (hφ_compact : HasCompactSupport φ)
-    (gradXφ gradVφ : PhaseSpace d → PhysSpace d)
-    (hgradXφ : ∀ z : PhaseSpace d, gradXφ z = gradient (fun x => φ (x, z.2)) z.1)
-    (hgradVφ : ∀ z : PhaseSpace d, gradVφ z = gradient (fun v => φ (z.1, v)) z.2) :
-    ContinuousWithinAt
-      (fun s => ∫ z, (@inner ℝ (PhysSpace d) _ z.2 (gradXφ z) -
-              @inner ℝ (PhysSpace d) _
-                (convolveFunctionMeasure gradW (spatialMarginal (f_next s)) z.1)
-                (gradVφ z)) ∂(f_next s)) (Set.Ici T) T := by
-  have hT_Icc : T ∈ Set.Icc (0 : ℝ) T := ⟨hT_pos.le, le_refl T⟩
-  have h_nhd_R : Set.Icc T (T + T_0) ∈ nhdsWithin T (Set.Ici T) :=
-    Icc_mem_nhdsGE (by linarith : T < T + T_0)
-  have h_outer_aemeas : AEMeasurable
-      (fun z : PhaseSpace d => (charX_prev T z, charV_prev T z)) f₀ :=
-    h_prev_init ▸ h_prev_aemeas T hT_Icc
-  set Zpos : ℝ → PhaseSpace d → PhysSpace d :=
-    fun s z => charX_g (s - T) (charX_prev T z, charV_prev T z) with hZpos_def
-  set Zvel : ℝ → PhaseSpace d → PhysSpace d :=
-    fun s z => charV_g (s - T) (charX_prev T z, charV_prev T z) with hZvel_def
-  have hgradXφ_cont : Continuous gradXφ :=
-    vlasovGlue_gradXφ_continuous φ hφ_smooth gradXφ hgradXφ
-  have hgradVφ_cont : Continuous gradVφ :=
-    vlasovGlue_gradVφ_continuous φ hφ_smooth gradVφ hgradVφ
-  have h_int_marg_g := dobrushinFlow_marginal_gradW_integrable gradW L hL T_0
-    g hg_mom
-  -- Composed pushforward of g's spatial marginal (hoisted helper), bridged to
-  -- the Zpos/Zvel forms.
-  have h_prevT_push : f_prev T
-      = Measure.map (fun z : PhaseSpace d => (charX_prev T z, charV_prev T z)) f₀ := by
-    rw [h_prev_push T hT_Icc, h_prev_init]
-  obtain ⟨h_comp_aemeas, h_g_push_comp', h_push_marg', h_aemeas_marg'⟩ :=
-    vlasovGlue_composed_pushforward f₀ g (f_prev T) charX_g charV_g
-      (charX_prev T) (charV_prev T) h_outer_aemeas h_prevT_push hg_init
-      hg_push_ex hg_aemeas_ex
-  have h_g_push_comp : ∀ s ∈ Set.Icc T (T + T_0),
-      g (s - T) = Measure.map
-        (fun z : PhaseSpace d => (Zpos s z, Zvel s z)) f₀ := by
-    intro s hs
-    simpa only [hZpos_def, hZvel_def] using h_g_push_comp' s hs
-  have h_push_marg : ∀ s ∈ Set.Icc T (T + T_0),
-      spatialMarginal (g (s - T))
-        = Measure.map (fun z : PhaseSpace d => Zpos s z) f₀ := by
-    intro s hs
-    simpa only [hZpos_def] using h_push_marg' s hs
-  have h_aemeas_marg : ∀ s ∈ Set.Icc T (T + T_0),
-      AEMeasurable (fun z : PhaseSpace d => Zpos s z) f₀ := by
-    intro s hs
-    simpa only [hZpos_def] using h_aemeas_marg' s hs
-  -- Composed growth bound: Piece A on g over [0,T_0] composed with Piece A on
-  -- prev at T (both via the hoisted clamp construction).
-  obtain ⟨C_prev, hC_prev_nn, hC_prev_pair, _h_cont_Icc_prev⟩ :=
-    vlasovGlue_flow_growthBound gradW L hL f_prev charX_prev charV_prev
-      T hT_pos h_prev_mom hM_prev h_prev_ic h_prev_boundary
-  obtain ⟨C_g, hC_g_nn, hC_g_pair, _h_cont_Icc_g⟩ :=
-    vlasovGlue_flow_growthBound gradW L hL g charX_g charV_g
-      T_0 hT_0_pos hg_mom hg_mom_unif hg_init_cond hg_boundary
-  obtain ⟨M_g, _hM_g_nn, hM_g_bd⟩ := hg_mom_unif
-  have h_y_int_marg_g : ∀ τ ∈ Set.Icc (0 : ℝ) T_0,
-      Integrable (fun y : PhysSpace d => ‖y‖) (spatialMarginal (g τ)) :=
-    fun τ hτ => vlasovGlue_marginal_norm_integrable (g τ) (hg_mom τ hτ)
-  set C_comp : ℝ := C_g * C_prev + C_g with hC_comp_def
-  have hC_comp_nn : 0 ≤ C_comp := by positivity
-  have hC_comp_pair : ∀ s ∈ Set.Icc T (T + T_0), ∀ z : PhaseSpace d,
-      ‖(Zpos s z, Zvel s z)‖ ≤ C_comp * (‖z‖ + 1) := by
-    intro s hs z
-    have hsT_Icc : s - T ∈ Set.Icc (0 : ℝ) T_0 :=
-      ⟨by linarith [hs.1], by linarith [hs.2]⟩
-    have h_prev : ‖(charX_prev T z, charV_prev T z)‖ ≤ C_prev * (‖z‖ + 1) :=
-      hC_prev_pair T hT_Icc z
-    have h_g : ‖(charX_g (s - T) (charX_prev T z, charV_prev T z),
-                 charV_g (s - T) (charX_prev T z, charV_prev T z))‖
-        ≤ C_g * (‖(charX_prev T z, charV_prev T z)‖ + 1) :=
-      hC_g_pair (s - T) hsT_Icc (charX_prev T z, charV_prev T z)
-    have hz1 : (0 : ℝ) ≤ ‖z‖ + 1 := by positivity
-    calc ‖(Zpos s z, Zvel s z)‖
-        = ‖(charX_g (s - T) (charX_prev T z, charV_prev T z),
-            charV_g (s - T) (charX_prev T z, charV_prev T z))‖ := by
-          simp only [hZpos_def, hZvel_def]
-      _ ≤ C_g * (‖(charX_prev T z, charV_prev T z)‖ + 1) := h_g
-      _ ≤ C_g * (C_prev * (‖z‖ + 1) + 1) := by
-          apply mul_le_mul_of_nonneg_left _ hC_g_nn; linarith
-      _ ≤ C_comp * (‖z‖ + 1) := by
-          simp only [hC_comp_def]
-          nlinarith [mul_nonneg hC_g_nn (norm_nonneg z),
-            mul_nonneg (mul_nonneg hC_g_nn hC_prev_nn) hz1]
-  have hC_comp_X : ∀ s ∈ Set.Icc T (T + T_0), ∀ z : PhaseSpace d,
-      ‖Zpos s z‖ ≤ C_comp * (‖z‖ + 1) := by
-    intro s hs z
-    exact le_trans (norm_fst_le (Zpos s z, Zvel s z)) (hC_comp_pair s hs z)
-  -- Seam continuity of the composed flow at T (hoisted shift helper).
-  have h_Zpos_cont : ∀ z : PhaseSpace d,
-      ContinuousWithinAt (fun s => Zpos s z) (Set.Ici T) T := by
-    intro z
-    have := vlasovGlue_shifted_flow_contWithin charX_g
-      (charX_prev T z, charV_prev T z) T hT_0_pos
-      (hg_boundary (charX_prev T z, charV_prev T z) 0 ⟨le_refl 0, hT_0_pos.le⟩).1
-    simpa only [hZpos_def] using this
-  have h_Zvel_cont : ∀ z : PhaseSpace d,
-      ContinuousWithinAt (fun s => Zvel s z) (Set.Ici T) T := by
-    intro z
-    have := vlasovGlue_shifted_flow_contWithin charV_g
-      (charX_prev T z, charV_prev T z) T hT_0_pos
-      (hg_boundary (charX_prev T z, charV_prev T z) 0 ⟨le_refl 0, hT_0_pos.le⟩).2
-    simpa only [hZvel_def] using this
-  -- Continuity of the un-pushed integrand in z (for integral_map's
-  -- AEStronglyMeasurable side).
-  have h_conv_z_cont : ∀ τ ∈ Set.Icc (0 : ℝ) T_0,
-      Continuous (fun z : PhaseSpace d =>
-        convolveFunctionMeasure gradW (spatialMarginal (g τ)) z.1) := by
-    intro τ hτ
-    have : IsProbabilityMeasure (g τ) := (hg_mom τ hτ).1
-    have : IsProbabilityMeasure (spatialMarginal (g τ)) :=
-      (Measure.isProbabilityMeasure_map_iff measurable_fst.aemeasurable).mpr inferInstance
-    exact (convolveFunctionMeasure_lipschitz_in_x gradW L hL
-      (spatialMarginal (g τ)) (h_int_marg_g τ hτ)).continuous.comp continuous_fst
-  have h_integrand_cont : ∀ τ ∈ Set.Icc (0 : ℝ) T_0,
-      Continuous (fun z : PhaseSpace d =>
-        @inner ℝ (PhysSpace d) _ z.2 (gradXφ z) -
-        @inner ℝ (PhysSpace d) _
-          (convolveFunctionMeasure gradW (spatialMarginal (g τ)) z.1)
-          (gradVφ z)) := by
-    intro τ hτ
-    exact (continuous_snd.inner hgradXφ_cont).sub
-      ((h_conv_z_cont τ hτ).inner hgradVφ_cont)
-  -- Eventually-equal rewrite to the composed-pushforward form (pointwise helper).
-  have h_intg_eq := vlasovGlue_composed_integral_eq gradW f₀ hT_pos f_prev g
-    h_prev_init charX_prev charV_prev charX_g charV_g h_prev_push hg_init
-    hg_init_cond f_next hf_next_T hf_next_gt gradXφ gradVφ h_comp_aemeas
-    h_g_push_comp' h_integrand_cont
-  have h_eq_R : (fun s => ∫ z, (@inner ℝ (PhysSpace d) _ z.2 (gradXφ z) -
-          @inner ℝ (PhysSpace d) _
-            (convolveFunctionMeasure gradW (spatialMarginal (f_next s)) z.1)
-            (gradVφ z)) ∂(f_next s))
-      =ᶠ[nhdsWithin T (Set.Ici T)]
-      (fun s => ∫ z, (@inner ℝ (PhysSpace d) _ (Zvel s z)
-            (gradXφ (Zpos s z, Zvel s z)) -
-          @inner ℝ (PhysSpace d) _
-            (convolveFunctionMeasure gradW (spatialMarginal (g (s - T)))
-              (Zpos s z))
-            (gradVφ (Zpos s z, Zvel s z))) ∂f₀) := by
-    apply Filter.Eventually.mono h_nhd_R
-    intro s hs
-    simpa only [hZpos_def, hZvel_def] using h_intg_eq s hs
-  obtain ⟨M_φ, hgradXφ_bd, hgradVφ_bd⟩ :=
-    vlasovGlue_gradφ_bound φ hφ_smooth hφ_compact gradXφ gradVφ hgradXφ hgradVφ
-  -- DCT via the generic seam lemma on the composed flow.
-  have h_conv_cwn : ∀ z : PhaseSpace d, ContinuousWithinAt
-      (fun s => convolveFunctionMeasure gradW (spatialMarginal (g (s - T)))
-        (Zpos s z)) (Set.Ici T) T := fun z =>
-    flowConv_continuousWithinAt_Ici_seam gradW L hL Zpos f₀
-      hf₀_int (by linarith : T < T + T_0)
-      (fun s => spatialMarginal (g (s - T)))
-      h_push_marg h_aemeas_marg h_Zpos_cont C_comp hC_comp_nn hC_comp_X z
-  have h_aemeas_W : ∀ s ∈ Set.Icc T (T + T_0),
-      AEMeasurable (fun z : PhaseSpace d => (Zpos s z, Zvel s z)) f₀ := by
-    intro s hs
-    have hsT_Icc : s - T ∈ Set.Icc (0 : ℝ) T_0 :=
-      ⟨by linarith [hs.1], by linarith [hs.2]⟩
-    simpa only [hZpos_def, hZvel_def] using h_comp_aemeas (s - T) hsT_Icc
-  have h_cont_pf : ContinuousWithinAt
-      (fun s => ∫ z, (@inner ℝ (PhysSpace d) _ (Zvel s z)
-            (gradXφ (Zpos s z, Zvel s z)) -
-          @inner ℝ (PhysSpace d) _
-            (convolveFunctionMeasure gradW (spatialMarginal (g (s - T)))
-              (Zpos s z))
-            (gradVφ (Zpos s z, Zvel s z))) ∂f₀)
-      (Set.Ici T) T :=
-    vlasovGlue_seam_forceIntegral_cont gradW L hL f₀ hf₀_int gradXφ gradVφ
-      hgradXφ_cont hgradVφ_cont M_φ hgradXφ_bd hgradVφ_bd
-      (fun s => spatialMarginal (g (s - T))) Zpos Zvel
-      T (Set.Ici T) (Set.Icc T (T + T_0)) h_nhd_R
-      (fun s hs => by
-        have hsT_Icc : s - T ∈ Set.Icc (0 : ℝ) T_0 :=
-          ⟨by linarith [hs.1], by linarith [hs.2]⟩
-        have : IsProbabilityMeasure (g (s - T)) := (hg_mom (s - T) hsT_Icc).1
-        exact (Measure.isProbabilityMeasure_map_iff measurable_fst.aemeasurable).mpr inferInstance)
-      M_g
-      (fun s hs => hM_g_bd (s - T) ⟨by linarith [hs.1], by linarith [hs.2]⟩)
-      (fun s hs => h_y_int_marg_g (s - T) ⟨by linarith [hs.1], by linarith [hs.2]⟩)
-      (fun s hs => h_int_marg_g (s - T) ⟨by linarith [hs.1], by linarith [hs.2]⟩)
-      C_comp hC_comp_pair h_aemeas_W h_Zpos_cont h_Zvel_cont h_conv_cwn
-  -- Value at T bridge (pointwise helper at s = T).
-  have h_val_T : (∫ z, (@inner ℝ (PhysSpace d) _ z.2 (gradXφ z) -
-          @inner ℝ (PhysSpace d) _
-            (convolveFunctionMeasure gradW (spatialMarginal (f_next T)) z.1)
-            (gradVφ z)) ∂(f_next T))
-      = ∫ z, (@inner ℝ (PhysSpace d) _ (Zvel T z)
-            (gradXφ (Zpos T z, Zvel T z)) -
-          @inner ℝ (PhysSpace d) _
-            (convolveFunctionMeasure gradW (spatialMarginal (g (T - T)))
-              (Zpos T z))
-            (gradVφ (Zpos T z, Zvel T z))) ∂f₀ := by
-    simpa only [hZpos_def, hZvel_def] using
-      h_intg_eq T ⟨le_refl T, by linarith⟩
-  exact h_cont_pf.congr_of_eventuallyEq h_eq_R h_val_T
+private alias vlasovGlue_seam_forceIntegral_cont :=
+  _root_.Vlasov.vlasovGlue_seam_forceIntegral_cont
 
-/-- `HasDerivAt` of the glued position flow at interior times of the extended
-window: piecewise from `f_prev`'s flow (`t < T`), the two-sided union of the
-boundary bundles (`t = T`), and `g`'s shifted flow (`t > T`).  Pure ODE gluing —
-takes only the position projections of the flow hypotheses. -/
-private lemma vlasovGlue_flowX_hasDerivAt
-    {d : ℕ}
-    (charX_prev charV_prev charX_g charV_g : ℝ → PhaseSpace d → PhysSpace d)
-    {T T_0 : ℝ} (hT_pos : 0 < T) (hT_0_pos : 0 < T_0)
-    (h_prev_flowX : ∀ t ∈ Set.Ioo (0 : ℝ) T, ∀ z : PhaseSpace d,
-        HasDerivAt (fun s => charX_prev s z) (charV_prev t z) t)
-    (h_prev_boundaryX : ∀ (z : PhaseSpace d) (t : ℝ), t ∈ Set.Icc (0 : ℝ) T →
-        HasDerivWithinAt (fun s => charX_prev s z) (charV_prev t z) (Set.Icc 0 T) t)
-    (hg_boundaryX : ∀ z : PhaseSpace d, ∀ t ∈ Set.Icc (0 : ℝ) T_0,
-        HasDerivWithinAt (fun s => charX_g s z) (charV_g t z) (Set.Icc 0 T_0) t)
-    (hg_init_cond : ∀ z : PhaseSpace d, charX_g 0 z = z.1 ∧ charV_g 0 z = z.2)
-    (t : ℝ) (ht : t ∈ Set.Ioo (0 : ℝ) (T + T_0)) (z : PhaseSpace d) :
-    HasDerivAt (fun s => if s ≤ T then charX_prev s z
-        else charX_g (s - T) (charX_prev T z, charV_prev T z))
-      (if t ≤ T then charV_prev t z
-        else charV_g (t - T) (charX_prev T z, charV_prev T z)) t := by
-  by_cases ht_le : t ≤ T
-  · simp only [ite_eq_left ht_le]
-    -- Sub-case: t < T (strict interior) vs t = T (boundary)
-    by_cases ht_lt : t < T
-    · -- t < T strict: piecewise function = charX_prev · z near t
-      have h_ev : (fun s => if s ≤ T then charX_prev s z
-          else charX_g (s - T) (charX_prev T z, charV_prev T z)) =ᶠ[nhds t]
-          (fun s => charX_prev s z) := by
-        apply Filter.Eventually.mono (eventually_lt_nhds ht_lt)
-        intro s hs; simp [le_of_lt hs]
-      exact ((h_prev_flowX t ⟨ht.1, ht_lt⟩ z).congr_of_eventuallyEq h_ev)
-    · -- t = T: boundary HasDerivAt via HasDerivWithinAt.union (Iic T ∪ Ici T = univ)
-      push Not at ht_lt
-      have h_t_eq : t = T := le_antisymm ht_le ht_lt
-      have hT_in : T ∈ Set.Icc (0 : ℝ) T := ⟨hT_pos.le, le_refl T⟩
-      have h_bX := h_prev_boundaryX z T hT_in
-      have h0_T0_in : (0 : ℝ) ∈ Set.Icc (0 : ℝ) T_0 := ⟨le_refl 0, hT_0_pos.le⟩
-      have h_g_bX := hg_boundaryX (charX_prev T z, charV_prev T z) 0 h0_T0_in
-      have h_nhd_L : Set.Icc 0 T ∈ nhdsWithin T (Set.Iic T) := Icc_mem_nhdsLE hT_pos
-      have h_nhd_R : Set.Icc 0 T_0 ∈ nhdsWithin (0 : ℝ) (Set.Ici 0) :=
-        Icc_mem_nhdsGE hT_0_pos
-      -- LEFT: HasDerivWithinAt charX_prev on Iic T at T
-      have hX_Lic := h_bX.mono_of_mem_nhdsWithin h_nhd_L
-      have hX_left : HasDerivWithinAt
-          (fun s => if s ≤ T then charX_prev s z
-            else charX_g (s - T) (charX_prev T z, charV_prev T z))
-          (charV_prev T z) (Set.Iic T) T :=
-        hX_Lic.congr_of_mem (fun s hs => by simp [Set.mem_Iic.mp hs]) Set.self_mem_Iic
-      -- RIGHT: chain rule from g's boundary at 0
-      have hX_Ici0 := h_g_bX.mono_of_mem_nhdsWithin h_nhd_R
-      have h_sub_R : HasDerivWithinAt (· - T) 1 (Set.Ici T) T :=
-        ((hasDerivAt_id' T).sub_const T).hasDerivWithinAt
-      have h_mapR : Set.MapsTo (· - T) (Set.Ici T) (Set.Ici 0) :=
-        fun s hs => Set.mem_Ici.mpr (by linarith [Set.mem_Ici.mp hs])
-      have h_chainX : HasDerivWithinAt
-          (fun s => charX_g (s - T) (charX_prev T z, charV_prev T z))
-          (charV_g 0 (charX_prev T z, charV_prev T z)) (Set.Ici T) T := by
-        have := HasDerivWithinAt.scomp_of_eq T hX_Ici0 h_sub_R h_mapR (sub_self T).symm
-        simpa [Function.comp_def, one_smul] using this
-      have hVg0_eq : charV_g 0 (charX_prev T z, charV_prev T z) = charV_prev T z :=
-        (hg_init_cond (charX_prev T z, charV_prev T z)).2
-      rw [hVg0_eq] at h_chainX
-      have hX_right : HasDerivWithinAt
-          (fun s => if s ≤ T then charX_prev s z
-            else charX_g (s - T) (charX_prev T z, charV_prev T z))
-          (charV_prev T z) (Set.Ici T) T :=
-        h_chainX.congr_of_mem
-          (fun s hs => by
-            by_cases hle : s ≤ T
-            · have heq : s = T := le_antisymm hle (Set.mem_Ici.mp hs)
-              simp [heq, sub_self,
-                (hg_init_cond (charX_prev T z, charV_prev T z)).1]
-            · simp [hle])
-          Set.self_mem_Ici
-      have hX_union := hX_left.union hX_right
-      rw [Set.Iic_union_Ici] at hX_union
-      rw [h_t_eq]
-      exact hX_union.hasDerivAt Filter.univ_mem
-  · simp only [ite_eq_right ht_le]
-    push Not at ht_le
-    -- t > T: use hg_boundaryX at (t - T) with chain rule for (s ↦ s - T)
-    have htT_mem : t - T ∈ Set.Ioo (0 : ℝ) T_0 := ⟨by linarith, by linarith [ht.2]⟩
-    have h_g_deriv : HasDerivAt (fun s => charX_g s (charX_prev T z, charV_prev T z))
-        (charV_g (t - T) (charX_prev T z, charV_prev T z)) (t - T) :=
-      (hg_boundaryX (charX_prev T z, charV_prev T z) (t - T)
-          (Set.Ioo_subset_Icc_self htT_mem)).hasDerivAt
-        (Icc_mem_nhds htT_mem.1 htT_mem.2)
-    have h_sub : HasDerivAt (· - T) 1 t := (hasDerivAt_id' t).sub_const T
-    have h_chain : HasDerivAt (fun s => charX_g (s - T) (charX_prev T z, charV_prev T z))
-        (charV_g (t - T) (charX_prev T z, charV_prev T z)) t := by
-      have := HasDerivAt.scomp_of_eq t h_g_deriv h_sub rfl
-      simpa [Function.comp_def, one_smul] using this
-    have h_ev : (fun s => if s ≤ T then charX_prev s z
-        else charX_g (s - T) (charX_prev T z, charV_prev T z)) =ᶠ[nhds t]
-        (fun s => charX_g (s - T) (charX_prev T z, charV_prev T z)) := by
-      apply Filter.Eventually.mono (eventually_gt_nhds ht_le)
-      intro s hs; simp [not_le.mpr hs]
-    exact h_chain.congr_of_eventuallyEq h_ev
+private alias vlasovGlue_shifted_flow_contWithin :=
+  _root_.Vlasov.vlasovGlue_shifted_flow_contWithin
 
-/-- `HasDerivAt` of the glued velocity flow at interior times of the extended
-window, with the force term against the glued measure `f_next` (consumed only
-through its value hypotheses).  Mirrors `vlasovGlue_flowX_hasDerivAt` with the
-velocity projections and the marginal bridges. -/
-private lemma vlasovGlue_flowV_hasDerivAt
-    {d : ℕ}
-    (gradW : PhysSpace d → PhysSpace d)
-    (f_prev g : ℝ → Measure (PhaseSpace d))
-    (charX_prev charV_prev charX_g charV_g : ℝ → PhaseSpace d → PhysSpace d)
-    {T T_0 : ℝ} (hT_pos : 0 < T) (hT_0_pos : 0 < T_0)
-    (h_prev_flowV : ∀ t ∈ Set.Ioo (0 : ℝ) T, ∀ z : PhaseSpace d,
-        HasDerivAt (fun s => charV_prev s z)
-          (-(convolveFunctionMeasure gradW (spatialMarginal (f_prev t))
-              (charX_prev t z))) t)
-    (h_prev_boundaryV : ∀ (z : PhaseSpace d) (t : ℝ), t ∈ Set.Icc (0 : ℝ) T →
-        HasDerivWithinAt (fun s => charV_prev s z)
-          (-(convolveFunctionMeasure gradW (spatialMarginal (f_prev t)) (charX_prev t z)))
-          (Set.Icc 0 T) t)
-    (hg_boundaryV : ∀ z : PhaseSpace d, ∀ t ∈ Set.Icc (0 : ℝ) T_0,
-        HasDerivWithinAt (fun s => charV_g s z)
-          (-(convolveFunctionMeasure gradW (spatialMarginal (g t)) (charX_g t z)))
-          (Set.Icc 0 T_0) t)
-    (hg_init : g 0 = f_prev T)
-    (hg_init_cond : ∀ z : PhaseSpace d, charX_g 0 z = z.1 ∧ charV_g 0 z = z.2)
-    (f_next : ℝ → Measure (PhaseSpace d))
-    (hf_next_le : ∀ s, s ≤ T → f_next s = f_prev s)
-    (hf_next_gt : ∀ s, T < s → f_next s = g (s - T))
-    (t : ℝ) (ht : t ∈ Set.Ioo (0 : ℝ) (T + T_0)) (z : PhaseSpace d) :
-    HasDerivAt (fun s => if s ≤ T then charV_prev s z
-        else charV_g (s - T) (charX_prev T z, charV_prev T z))
-      (-(convolveFunctionMeasure gradW (spatialMarginal (f_next t))
-          (if t ≤ T then charX_prev t z
-            else charX_g (t - T) (charX_prev T z, charV_prev T z)))) t := by
-  by_cases ht_le : t ≤ T
-  · simp only [ite_eq_left ht_le]
-    -- Sub-case: t < T (strict interior) vs t = T (boundary)
-    by_cases ht_lt : t < T
-    · -- t < T strict: piecewise function = charV_prev · z near t
-      have h_ev : (fun s => if s ≤ T then charV_prev s z
-          else charV_g (s - T) (charX_prev T z, charV_prev T z)) =ᶠ[nhds t]
-          (fun s => charV_prev s z) := by
-        apply Filter.Eventually.mono (eventually_lt_nhds ht_lt)
-        intro s hs; simp [le_of_lt hs]
-      have h_fnext_t : f_next t = f_prev t := hf_next_le t ht_le
-      have h_prev_deriv := h_prev_flowV t ⟨ht.1, ht_lt⟩ z
-      have h_eq_marg : spatialMarginal (f_prev t) = spatialMarginal (f_next t) :=
-        congrArg spatialMarginal h_fnext_t.symm
-      simp only [h_eq_marg] at h_prev_deriv
-      exact h_prev_deriv.congr_of_eventuallyEq h_ev
-    · -- t = T: boundary HasDerivAt via HasDerivWithinAt.union (same as charX case)
-      push Not at ht_lt
-      have h_t_eq : t = T := le_antisymm ht_le ht_lt
-      have hT_in : T ∈ Set.Icc (0 : ℝ) T := ⟨hT_pos.le, le_refl T⟩
-      have h_bV := h_prev_boundaryV z T hT_in
-      have h0_T0_in : (0 : ℝ) ∈ Set.Icc (0 : ℝ) T_0 := ⟨le_refl 0, hT_0_pos.le⟩
-      have h_g_bV := hg_boundaryV (charX_prev T z, charV_prev T z) 0 h0_T0_in
-      have h_nhd_L : Set.Icc 0 T ∈ nhdsWithin T (Set.Iic T) := Icc_mem_nhdsLE hT_pos
-      have h_nhd_R : Set.Icc 0 T_0 ∈ nhdsWithin (0 : ℝ) (Set.Ici 0) :=
-        Icc_mem_nhdsGE hT_0_pos
-      -- Bridge f_prev T ↔ f_next T (for spatial marginal in goal vs h_bV)
-      have hfnextT : f_next T = f_prev T := hf_next_le T (le_refl T)
-      have hfnextT_spat : spatialMarginal (f_next T) = spatialMarginal (f_prev T) :=
-        congrArg spatialMarginal hfnextT
-      -- LEFT: HasDerivWithinAt charV_prev on Iic T at T
-      have hV_Lic := h_bV.mono_of_mem_nhdsWithin h_nhd_L
-      have hV_left : HasDerivWithinAt
-          (fun s => if s ≤ T then charV_prev s z
-            else charV_g (s - T) (charX_prev T z, charV_prev T z))
-          (-(convolveFunctionMeasure gradW (spatialMarginal (f_next T))
-              (charX_prev T z)))
-          (Set.Iic T) T := by
-        rw [hfnextT_spat]
-        exact hV_Lic.congr_of_mem (fun s hs => by simp [Set.mem_Iic.mp hs])
-          Set.self_mem_Iic
-      -- RIGHT: chain rule from g's boundary at 0
-      have hV_Ici0 := h_g_bV.mono_of_mem_nhdsWithin h_nhd_R
-      have h_sub_R : HasDerivWithinAt (· - T) 1 (Set.Ici T) T :=
-        ((hasDerivAt_id' T).sub_const T).hasDerivWithinAt
-      have h_mapR : Set.MapsTo (· - T) (Set.Ici T) (Set.Ici 0) :=
-        fun s hs => Set.mem_Ici.mpr (by linarith [Set.mem_Ici.mp hs])
-      have h_chainV : HasDerivWithinAt
-          (fun s => charV_g (s - T) (charX_prev T z, charV_prev T z))
-          (-(convolveFunctionMeasure gradW
-            (spatialMarginal (g 0))
-            (charX_g 0 (charX_prev T z, charV_prev T z))))
-          (Set.Ici T) T := by
-        have := HasDerivWithinAt.scomp_of_eq T hV_Ici0 h_sub_R h_mapR (sub_self T).symm
-        simpa [Function.comp_def, one_smul] using this
-      have hXg0_eq : charX_g 0 (charX_prev T z, charV_prev T z) = charX_prev T z :=
-        (hg_init_cond (charX_prev T z, charV_prev T z)).1
-      have hg0_spat : spatialMarginal (g 0) = spatialMarginal (f_prev T) :=
-        congrArg spatialMarginal hg_init
-      rw [hXg0_eq, hg0_spat, ← hfnextT_spat] at h_chainV
-      have hV_right : HasDerivWithinAt
-          (fun s => if s ≤ T then charV_prev s z
-            else charV_g (s - T) (charX_prev T z, charV_prev T z))
-          (-(convolveFunctionMeasure gradW (spatialMarginal (f_next T))
-              (charX_prev T z)))
-          (Set.Ici T) T :=
-        h_chainV.congr_of_mem
-          (fun s hs => by
-            by_cases hle : s ≤ T
-            · have heq : s = T := le_antisymm hle (Set.mem_Ici.mp hs)
-              simp [heq, sub_self,
-                (hg_init_cond (charX_prev T z, charV_prev T z)).2]
-            · simp [hle])
-          Set.self_mem_Ici
-      have hV_union := hV_left.union hV_right
-      rw [Set.Iic_union_Ici] at hV_union
-      rw [h_t_eq]
-      exact hV_union.hasDerivAt Filter.univ_mem
-  · simp only [ite_eq_right ht_le]
-    push Not at ht_le
-    -- t > T: use hg_boundaryV at (t - T)
-    have htT_mem : t - T ∈ Set.Ioo (0 : ℝ) T_0 := ⟨by linarith, by linarith [ht.2]⟩
-    have h_g_deriv : HasDerivAt (fun s => charV_g s (charX_prev T z, charV_prev T z))
-        (-(convolveFunctionMeasure gradW (spatialMarginal (g (t - T)))
-            (charX_g (t - T) (charX_prev T z, charV_prev T z)))) (t - T) :=
-      (hg_boundaryV (charX_prev T z, charV_prev T z) (t - T)
-          (Set.Ioo_subset_Icc_self htT_mem)).hasDerivAt
-        (Icc_mem_nhds htT_mem.1 htT_mem.2)
-    have h_sub : HasDerivAt (· - T) 1 t := (hasDerivAt_id' t).sub_const T
-    have h_chain : HasDerivAt (fun s => charV_g (s - T) (charX_prev T z, charV_prev T z))
-        (-(convolveFunctionMeasure gradW (spatialMarginal (g (t - T)))
-            (charX_g (t - T) (charX_prev T z, charV_prev T z)))) t := by
-      have := HasDerivAt.scomp_of_eq t h_g_deriv h_sub rfl
-      simpa [Function.comp_def, one_smul] using this
-    -- f_next t = g (t - T) when t > T
-    have h_fnext_t : f_next t = g (t - T) := hf_next_gt t ht_le
-    -- Rewrite derivative value: g (t-T) → f_next t
-    rw [← congrArg spatialMarginal h_fnext_t] at h_chain
-    have h_ev : (fun s => if s ≤ T then charV_prev s z
-        else charV_g (s - T) (charX_prev T z, charV_prev T z)) =ᶠ[nhds t]
-        (fun s => charV_g (s - T) (charX_prev T z, charV_prev T z)) := by
-      apply Filter.Eventually.mono (eventually_gt_nhds ht_le)
-      intro s hs; simp [not_le.mpr hs]
-    exact h_chain.congr_of_eventuallyEq h_ev
+private alias vlasovWellPosedness_glue_boundary :=
+  _root_.Vlasov.vlasovWellPosedness_glue_boundary
 
-/-- The weak PDE holds at every time `t' ≠ T` near the seam: to the left the
-glued solution is `f_prev` (use its weak PDE), to the right it is `g (·−T)`
-(use `g`'s weak PDE with the shift chain rule). -/
-private lemma vlasovGlue_diff_ne
-    {d : ℕ}
-    (gradW : PhysSpace d → PhysSpace d)
-    (f_prev g : ℝ → Measure (PhaseSpace d))
-    {T T_0 : ℝ}
-    (h_prev_vlasov : IsVlasovSolutionOn gradW f_prev T)
-    (h_g_vlasov : IsVlasovSolutionOn gradW g T_0)
-    (f_next : ℝ → Measure (PhaseSpace d))
-    (hf_next_le : ∀ s, s ≤ T → f_next s = f_prev s)
-    (hf_next_gt : ∀ s, T < s → f_next s = g (s - T))
-    (φ : PhaseSpace d → ℝ)
-    (hφ_smooth : ContDiff ℝ (⊤ : ℕ∞) φ) (hφ_compact : HasCompactSupport φ)
-    (gradXφ gradVφ : PhaseSpace d → PhysSpace d)
-    (hgradXφ : ∀ z : PhaseSpace d, gradXφ z = gradient (fun x => φ (x, z.2)) z.1)
-    (hgradVφ : ∀ z : PhaseSpace d, gradVφ z = gradient (fun v => φ (z.1, v)) z.2) :
-    ∀ t' ∈ Set.Ioo (0 : ℝ) (T + T_0), t' ≠ T → HasDerivAt
-      (fun s => ∫ z, φ z ∂f_next s)
-      ((∫ z, (@inner ℝ (PhysSpace d) _ z.2 (gradXφ z) -
-              @inner ℝ (PhysSpace d) _
-                (convolveFunctionMeasure gradW (spatialMarginal (f_next t')) z.1)
-                (gradVφ z)) ∂(f_next t')) + 0) t' := by
-  intro t' ht' ht'_ne
-  rcases lt_or_gt_of_ne ht'_ne with ht'_lt | ht'_gt
-  · -- t' < T: use h_prev_vlasov + bridge f_next = f_prev on left of T
-    have ht'_prev : t' ∈ Set.Ioo (0 : ℝ) T := ⟨ht'.1, ht'_lt⟩
-    have h_ev : (fun s => ∫ z, φ z ∂f_next s) =ᶠ[nhds t']
-        (fun s => ∫ z, φ z ∂f_prev s) := by
-      apply Filter.Eventually.mono (eventually_lt_nhds ht'_lt)
-      intro s hs; simp [hf_next_le s (le_of_lt hs)]
-    have h_fnext_t' : f_next t' = f_prev t' := hf_next_le t' (le_of_lt ht'_lt)
-    have h_deriv := h_prev_vlasov φ hφ_smooth hφ_compact gradXφ gradVφ
-        hgradXφ hgradVφ t' ht'_prev
-    rw [show (fun _ => (0 : ℝ)) t' = 0 from rfl, add_zero] at h_deriv
-    have h_marg : spatialMarginal (f_next t') = spatialMarginal (f_prev t') :=
-      congrArg spatialMarginal h_fnext_t'
-    rw [add_zero, h_marg, h_fnext_t']
-    exact h_deriv.congr_of_eventuallyEq h_ev
-  · -- t' > T: use h_g_vlasov + chain rule + bridge f_next = g (·-T)
-    have ht'_g : t' - T ∈ Set.Ioo (0 : ℝ) T_0 := ⟨by linarith, by linarith [ht'.2]⟩
-    have h_ev : (fun s => ∫ z, φ z ∂f_next s) =ᶠ[nhds t']
-        (fun s => ∫ z, φ z ∂g (s - T)) := by
-      apply Filter.Eventually.mono (eventually_gt_nhds ht'_gt)
-      intro s hs; simp [hf_next_gt s hs]
-    have h_fnext_t' : f_next t' = g (t' - T) := hf_next_gt t' ht'_gt
-    have h_g_deriv := h_g_vlasov φ hφ_smooth hφ_compact gradXφ gradVφ
-        hgradXφ hgradVφ (t' - T) ht'_g
-    rw [show (fun _ => (0 : ℝ)) (t' - T) = 0 from rfl, add_zero] at h_g_deriv
-    have h_sub : HasDerivAt (· - T) 1 t' := (hasDerivAt_id' t').sub_const T
-    have h_chain : HasDerivAt (fun s => ∫ z, φ z ∂g (s - T))
-        (∫ z, (@inner ℝ (PhysSpace d) _ z.2 (gradXφ z) -
-          @inner ℝ (PhysSpace d) _
-            (convolveFunctionMeasure gradW (spatialMarginal (g (t' - T))) z.1)
-            (gradVφ z)) ∂g (t' - T)) t' := by
-      have := HasDerivAt.comp_of_eq t' h_g_deriv h_sub rfl
-      simpa [Function.comp_def, mul_one] using this
-    have h_marg : spatialMarginal (f_next t') = spatialMarginal (g (t' - T)) :=
-      congrArg spatialMarginal h_fnext_t'
-    rw [add_zero, h_marg, h_fnext_t']
-    exact h_chain.congr_of_eventuallyEq h_ev
-
-/-- LEFT seam continuity of the plain test-function integral at `T`: on `Iic T`
-the glued solution agrees with `f_prev`; DCT with the constant dominator `Cφ`
-against the window pushforward. -/
-private lemma vlasovGlue_intCont_left
-    {d : ℕ}
-    (gradW : PhysSpace d → PhysSpace d)
-    (f₀ : Measure (PhaseSpace d)) [IsProbabilityMeasure f₀]
-    {T : ℝ} (hT_pos : 0 < T)
-    (f_prev : ℝ → Measure (PhaseSpace d))
-    (h_prev_init : f_prev 0 = f₀)
-    (charX_prev charV_prev : ℝ → PhaseSpace d → PhysSpace d)
-    (h_prev_push : ∀ t ∈ Set.Icc (0 : ℝ) T,
-        f_prev t =
-          Measure.map (fun z : PhaseSpace d => (charX_prev t z, charV_prev t z)) (f_prev 0))
-    (h_prev_aemeas : ∀ s ∈ Set.Icc (0 : ℝ) T,
-        AEMeasurable (fun z : PhaseSpace d => (charX_prev s z, charV_prev s z)) (f_prev 0))
-    (h_prev_boundary : ∀ (z : PhaseSpace d) (t : ℝ), t ∈ Set.Icc (0 : ℝ) T →
-        HasDerivWithinAt (fun s => charX_prev s z) (charV_prev t z) (Set.Icc 0 T) t ∧
-        HasDerivWithinAt (fun s => charV_prev s z)
-          (-(convolveFunctionMeasure gradW (spatialMarginal (f_prev t)) (charX_prev t z)))
-          (Set.Icc 0 T) t)
-    (f_next : ℝ → Measure (PhaseSpace d))
-    (hf_next_le : ∀ s, s ≤ T → f_next s = f_prev s)
-    (φ : PhaseSpace d → ℝ) (hφ_cont : Continuous φ)
-    (Cφ : ℝ) (hCφ : ∀ z : PhaseSpace d, ‖φ z‖ ≤ Cφ) :
-    ContinuousWithinAt (fun s => ∫ z, φ z ∂f_next s) (Set.Iic T) T := by
-  have h_nhd_L : Set.Icc (0 : ℝ) T ∈ nhdsWithin T (Set.Iic T) :=
-    Icc_mem_nhdsLE hT_pos
-  -- Equation: f_next = f_prev = pushforward of f₀ on Icc 0 T
-  have h_eq_L : (fun s => ∫ z, φ z ∂f_next s) =ᶠ[nhdsWithin T (Set.Iic T)]
-      (fun s => ∫ z, φ (charX_prev s z, charV_prev s z) ∂f₀) := by
-    apply Filter.Eventually.mono h_nhd_L
-    intro s hs
-    change ∫ z, φ z ∂f_next s = ∫ z, φ (charX_prev s z, charV_prev s z) ∂f₀
-    have h_fnext : f_next s = f_prev s := hf_next_le s hs.2
-    have h_aemeas_f₀ : AEMeasurable
-        (fun z : PhaseSpace d => (charX_prev s z, charV_prev s z)) f₀ :=
-      h_prev_init ▸ h_prev_aemeas s hs
-    rw [h_fnext, h_prev_push s hs, h_prev_init]
-    exact integral_map h_aemeas_f₀ hφ_cont.aestronglyMeasurable
-  -- DCT for the pushforward-composed form
-  have h_cont_pf : ContinuousWithinAt
-      (fun s => ∫ z, φ (charX_prev s z, charV_prev s z) ∂f₀) (Set.Iic T) T := by
-    apply continuousWithinAt_of_dominated (bound := fun _ => Cφ)
-    · apply Filter.Eventually.mono h_nhd_L
-      intro s hs
-      have h_pair_aem : AEMeasurable
-          (fun z : PhaseSpace d => (charX_prev s z, charV_prev s z)) f₀ :=
-        h_prev_init ▸ h_prev_aemeas s hs
-      exact (hφ_cont.measurable.comp_aemeasurable h_pair_aem).aestronglyMeasurable
-    · apply Filter.Eventually.mono h_nhd_L
-      intro s _
-      exact Filter.Eventually.of_forall fun z => hCφ _
-    · exact integrable_const _
-    · apply Filter.Eventually.of_forall
-      intro z
-      have hT_Icc : T ∈ Set.Icc (0 : ℝ) T := ⟨hT_pos.le, le_refl T⟩
-      have h_bX := (h_prev_boundary z T hT_Icc).1
-      have h_bV := (h_prev_boundary z T hT_Icc).2
-      have h_pair_Icc : ContinuousWithinAt
-          (fun s => (charX_prev s z, charV_prev s z)) (Set.Icc 0 T) T :=
-        h_bX.continuousWithinAt.prodMk h_bV.continuousWithinAt
-      have h_pair_Iic : ContinuousWithinAt
-          (fun s => (charX_prev s z, charV_prev s z)) (Set.Iic T) T :=
-        h_pair_Icc.mono_of_mem_nhdsWithin h_nhd_L
-      exact hφ_cont.continuousAt.comp_continuousWithinAt h_pair_Iic
-  -- Value at T: bridge via the pushforward formula
-  have h_val_T : (∫ z, φ z ∂f_next T)
-      = ∫ z, φ (charX_prev T z, charV_prev T z) ∂f₀ := by
-    have hT_Icc : T ∈ Set.Icc (0 : ℝ) T := ⟨hT_pos.le, le_refl T⟩
-    have h_fnext_T : f_next T = f_prev T := hf_next_le T (le_refl T)
-    have h_aemeas_f₀_T : AEMeasurable
-        (fun z : PhaseSpace d => (charX_prev T z, charV_prev T z)) f₀ :=
-      h_prev_init ▸ h_prev_aemeas T hT_Icc
-    rw [h_fnext_T, h_prev_push T hT_Icc, h_prev_init]
-    exact integral_map h_aemeas_f₀_T hφ_cont.aestronglyMeasurable
-  exact h_cont_pf.congr_of_eventuallyEq h_eq_L h_val_T
-
-/-- RIGHT seam continuity of the plain test-function integral at `T`: on
-`Ici T` the glued solution is the composed pushforward off `g`; DCT with the
-constant dominator `Cφ`. -/
-private lemma vlasovGlue_intCont_right
-    {d : ℕ}
-    (gradW : PhysSpace d → PhysSpace d)
-    (f₀ : Measure (PhaseSpace d)) [IsProbabilityMeasure f₀]
-    {T : ℝ} (hT_pos : 0 < T) {T_0 : ℝ} (hT_0_pos : 0 < T_0)
-    (f_prev : ℝ → Measure (PhaseSpace d))
-    (h_prev_init : f_prev 0 = f₀)
-    (charX_prev charV_prev : ℝ → PhaseSpace d → PhysSpace d)
-    (h_prev_push : ∀ t ∈ Set.Icc (0 : ℝ) T,
-        f_prev t =
-          Measure.map (fun z : PhaseSpace d => (charX_prev t z, charV_prev t z)) (f_prev 0))
-    (h_prev_aemeas : ∀ s ∈ Set.Icc (0 : ℝ) T,
-        AEMeasurable (fun z : PhaseSpace d => (charX_prev s z, charV_prev s z)) (f_prev 0))
-    (g : ℝ → Measure (PhaseSpace d))
-    (charX_g charV_g : ℝ → PhaseSpace d → PhysSpace d)
-    (hg_init : g 0 = f_prev T)
-    (hg_push_ex : ∀ t ∈ Set.Icc (0 : ℝ) T_0,
-        g t = Measure.map (fun z : PhaseSpace d => (charX_g t z, charV_g t z)) (g 0))
-    (hg_aemeas_ex : ∀ s ∈ Set.Icc (0 : ℝ) T_0,
-        AEMeasurable (fun z : PhaseSpace d => (charX_g s z, charV_g s z)) (g 0))
-    (hg_boundary : ∀ z : PhaseSpace d, ∀ t ∈ Set.Icc (0 : ℝ) T_0,
-        HasDerivWithinAt (fun s => charX_g s z) (charV_g t z) (Set.Icc 0 T_0) t ∧
-        HasDerivWithinAt (fun s => charV_g s z)
-          (-(convolveFunctionMeasure gradW (spatialMarginal (g t)) (charX_g t z)))
-          (Set.Icc 0 T_0) t)
-    (hg_init_cond : ∀ z : PhaseSpace d, charX_g 0 z = z.1 ∧ charV_g 0 z = z.2)
-    (f_next : ℝ → Measure (PhaseSpace d))
-    (hf_next_T : f_next T = f_prev T)
-    (hf_next_gt : ∀ s, T < s → f_next s = g (s - T))
-    (φ : PhaseSpace d → ℝ) (hφ_cont : Continuous φ)
-    (Cφ : ℝ) (hCφ : ∀ z : PhaseSpace d, ‖φ z‖ ≤ Cφ) :
-    ContinuousWithinAt (fun s => ∫ z, φ z ∂f_next s) (Set.Ici T) T := by
-  have h_nhd_R : Set.Icc T (T + T_0) ∈ nhdsWithin T (Set.Ici T) :=
-    Icc_mem_nhdsGE (by linarith : T < T + T_0)
-  have hT_Icc : T ∈ Set.Icc (0 : ℝ) T := ⟨hT_pos.le, le_refl T⟩
-  have h_outer_aemeas : AEMeasurable
-      (fun z : PhaseSpace d => (charX_prev T z, charV_prev T z)) f₀ :=
-    h_prev_init ▸ h_prev_aemeas T hT_Icc
-  -- Eventually-equal: f_next s = composed pushforward on Icc T (T+T_0)
-  have h_eq_R : (fun s => ∫ z, φ z ∂f_next s) =ᶠ[nhdsWithin T (Set.Ici T)]
-      (fun s => ∫ z, φ
-        (charX_g (s - T) (charX_prev T z, charV_prev T z),
-         charV_g (s - T) (charX_prev T z, charV_prev T z)) ∂f₀) := by
-    apply Filter.Eventually.mono h_nhd_R
-    intro s hs
-    change ∫ z, φ z ∂f_next s = ∫ z, φ
-        (charX_g (s - T) (charX_prev T z, charV_prev T z),
-         charV_g (s - T) (charX_prev T z, charV_prev T z)) ∂f₀
-    have hs_T : T ≤ s := hs.1
-    have hsT_Icc : s - T ∈ Set.Icc (0 : ℝ) T_0 :=
-      ⟨by linarith, by linarith [hs.2]⟩
-    by_cases hs_eq : s = T
-    · -- s = T: f_next s = f_next T = f_prev T = (charX_prev T, charV_prev T)#f₀
-      --   RHS at s = T uses hg_init_cond to collapse (charX_g 0, charV_g 0) = id
-      have hs_T_zero : s - T = 0 := by rw [hs_eq]; exact sub_self T
-      have h_fnext_s : f_next s = f_prev T := by
-        rw [hs_eq]; exact hf_next_T
-      rw [h_fnext_s, h_prev_push T hT_Icc, h_prev_init,
-          integral_map h_outer_aemeas hφ_cont.aestronglyMeasurable]
-      congr 1
-      funext z
-      rw [hs_T_zero, (hg_init_cond _).1, (hg_init_cond _).2]
-    · -- s > T: f_next s = g (s - T) = composed pushforward
-      have hs_gt : T < s := lt_of_le_of_ne hs_T (Ne.symm hs_eq)
-      have h_fnext_s : f_next s = g (s - T) := hf_next_gt s hs_gt
-      rw [h_fnext_s, hg_push_ex (s - T) hsT_Icc, hg_init,
-          h_prev_push T hT_Icc, h_prev_init]
-      have h_g_at_sT : AEMeasurable
-          (fun z : PhaseSpace d => (charX_g (s - T) z, charV_g (s - T) z))
-          (Measure.map (fun z : PhaseSpace d =>
-            (charX_prev T z, charV_prev T z)) f₀) := by
-        have := hg_aemeas_ex (s - T) hsT_Icc
-        rw [hg_init, h_prev_push T hT_Icc, h_prev_init] at this
-        exact this
-      have h_comp_aem : AEMeasurable
-          (fun z : PhaseSpace d =>
-            (charX_g (s - T) (charX_prev T z, charV_prev T z),
-             charV_g (s - T) (charX_prev T z, charV_prev T z))) f₀ :=
-        h_g_at_sT.comp_aemeasurable h_outer_aemeas
-      rw [AEMeasurable.map_map_of_aemeasurable h_g_at_sT h_outer_aemeas]
-      exact integral_map h_comp_aem hφ_cont.aestronglyMeasurable
-  -- DCT for the composed-pushforward form
-  have h_cont_pf : ContinuousWithinAt
-      (fun s => ∫ z, φ
-        (charX_g (s - T) (charX_prev T z, charV_prev T z),
-         charV_g (s - T) (charX_prev T z, charV_prev T z)) ∂f₀)
-      (Set.Ici T) T := by
-    apply continuousWithinAt_of_dominated (bound := fun _ => Cφ)
-    · apply Filter.Eventually.mono h_nhd_R
-      intro s hs
-      have hsT_Icc : s - T ∈ Set.Icc (0 : ℝ) T_0 :=
-        ⟨by linarith [hs.1], by linarith [hs.2]⟩
-      have h_g_at_sT : AEMeasurable
-          (fun z : PhaseSpace d => (charX_g (s - T) z, charV_g (s - T) z))
-          (Measure.map (fun z : PhaseSpace d =>
-            (charX_prev T z, charV_prev T z)) f₀) := by
-        have := hg_aemeas_ex (s - T) hsT_Icc
-        rw [hg_init, h_prev_push T hT_Icc, h_prev_init] at this
-        exact this
-      have h_comp_aem : AEMeasurable
-          (fun z : PhaseSpace d =>
-            (charX_g (s - T) (charX_prev T z, charV_prev T z),
-             charV_g (s - T) (charX_prev T z, charV_prev T z))) f₀ :=
-        h_g_at_sT.comp_aemeasurable h_outer_aemeas
-      exact (hφ_cont.measurable.comp_aemeasurable h_comp_aem).aestronglyMeasurable
-    · apply Filter.Eventually.mono h_nhd_R
-      intro s _
-      exact Filter.Eventually.of_forall fun z => hCφ _
-    · exact integrable_const _
-    · -- Pointwise continuity: chain rule for (· - T) at T with charX_g/charV_g at 0
-      apply Filter.Eventually.of_forall
-      intro z
-      have h0_Icc : (0 : ℝ) ∈ Set.Icc (0 : ℝ) T_0 := ⟨le_refl 0, hT_0_pos.le⟩
-      have h_g_bX := (hg_boundary (charX_prev T z, charV_prev T z) 0 h0_Icc).1
-      have h_g_bV := (hg_boundary (charX_prev T z, charV_prev T z) 0 h0_Icc).2
-      have h_nhdsW_0 : Set.Icc (0 : ℝ) T_0 ∈ nhdsWithin 0 (Set.Ici 0) :=
-        Icc_mem_nhdsGE hT_0_pos
-      have h_g_bX_cont : ContinuousWithinAt
-          (fun s' => charX_g s' (charX_prev T z, charV_prev T z))
-          (Set.Ici 0) 0 :=
-        h_g_bX.continuousWithinAt.mono_of_mem_nhdsWithin h_nhdsW_0
-      have h_g_bV_cont : ContinuousWithinAt
-          (fun s' => charV_g s' (charX_prev T z, charV_prev T z))
-          (Set.Ici 0) 0 :=
-        h_g_bV.continuousWithinAt.mono_of_mem_nhdsWithin h_nhdsW_0
-      have h_sub_cont : ContinuousWithinAt (fun s : ℝ => s - T) (Set.Ici T) T :=
-        ((continuous_id.sub continuous_const).continuousAt).continuousWithinAt
-      have h_sub_maps : Set.MapsTo (fun s : ℝ => s - T) (Set.Ici T) (Set.Ici 0) :=
-        fun s hs => Set.mem_Ici.mpr (by linarith [Set.mem_Ici.mp hs])
-      have h_chainX : ContinuousWithinAt
-          (fun s => charX_g (s - T) (charX_prev T z, charV_prev T z))
-          (Set.Ici T) T :=
-        ContinuousWithinAt.comp_of_eq h_g_bX_cont h_sub_cont h_sub_maps (sub_self T)
-      have h_chainV : ContinuousWithinAt
-          (fun s => charV_g (s - T) (charX_prev T z, charV_prev T z))
-          (Set.Ici T) T :=
-        ContinuousWithinAt.comp_of_eq h_g_bV_cont h_sub_cont h_sub_maps (sub_self T)
-      have h_pair : ContinuousWithinAt
-          (fun s => (charX_g (s - T) (charX_prev T z, charV_prev T z),
-                     charV_g (s - T) (charX_prev T z, charV_prev T z)))
-          (Set.Ici T) T :=
-        h_chainX.prodMk h_chainV
-      exact hφ_cont.continuousAt.comp_continuousWithinAt h_pair
-  -- Value at T: integrate the s = T case
-  have h_val_T : (∫ z, φ z ∂f_next T) = ∫ z, φ
-      (charX_g (T - T) (charX_prev T z, charV_prev T z),
-       charV_g (T - T) (charX_prev T z, charV_prev T z)) ∂f₀ := by
-    rw [hf_next_T, h_prev_push T hT_Icc, h_prev_init,
-        integral_map h_outer_aemeas hφ_cont.aestronglyMeasurable]
-    congr 1; funext z
-    rw [show T - T = (0 : ℝ) from sub_self T,
-        (hg_init_cond _).1, (hg_init_cond _).2]
-  exact h_cont_pf.congr_of_eventuallyEq h_eq_R h_val_T
-
-/-- Pushforward equation for the glued solution against the glued piecewise
-flow, on the extended window.  Serves both `IsLagrangianVlasovSolutionOn`'s
-pushforward conjunct and the explicit conjunct (v). -/
-private lemma vlasovGlue_pushforward_eq
-    {d : ℕ}
-    (f_prev g : ℝ → Measure (PhaseSpace d))
-    (charX_prev charV_prev charX_g charV_g : ℝ → PhaseSpace d → PhysSpace d)
-    {T T_0 : ℝ} (hT_pos : 0 < T)
-    (h_prev_push : ∀ t ∈ Set.Icc (0 : ℝ) T,
-        f_prev t =
-          Measure.map (fun z : PhaseSpace d => (charX_prev t z, charV_prev t z)) (f_prev 0))
-    (h_prev_aemeas : ∀ s ∈ Set.Icc (0 : ℝ) T,
-        AEMeasurable (fun z : PhaseSpace d => (charX_prev s z, charV_prev s z)) (f_prev 0))
-    (hg_init : g 0 = f_prev T)
-    (hg_push_ex : ∀ t ∈ Set.Icc (0 : ℝ) T_0,
-        g t = Measure.map (fun z : PhaseSpace d => (charX_g t z, charV_g t z)) (g 0))
-    (hg_aemeas_ex : ∀ s ∈ Set.Icc (0 : ℝ) T_0,
-        AEMeasurable (fun z : PhaseSpace d => (charX_g s z, charV_g s z)) (g 0))
-    (f_next : ℝ → Measure (PhaseSpace d))
-    (hf_next_le : ∀ s, s ≤ T → f_next s = f_prev s)
-    (hf_next_gt : ∀ s, T < s → f_next s = g (s - T))
-    (t : ℝ) (ht : t ∈ Set.Icc (0 : ℝ) (T + T_0)) :
-    f_next t = Measure.map (fun z : PhaseSpace d =>
-      ((if t ≤ T then charX_prev t z
-         else charX_g (t - T) (charX_prev T z, charV_prev T z)),
-       (if t ≤ T then charV_prev t z
-         else charV_g (t - T) (charX_prev T z, charV_prev T z)))) (f_next 0) := by
-  rw [hf_next_le 0 hT_pos.le]
-  by_cases ht_le : t ≤ T
-  · simp only [ite_eq_left ht_le]
-    rw [hf_next_le t ht_le]
-    exact h_prev_push t ⟨ht.1, ht_le⟩
-  · simp only [ite_eq_right ht_le]
-    push Not at ht_le
-    rw [hf_next_gt t ht_le]
-    have hT_mem : T ∈ Set.Icc (0 : ℝ) T := ⟨hT_pos.le, le_refl T⟩
-    have htT_mem : t - T ∈ Set.Icc (0 : ℝ) T_0 := ⟨by linarith, by linarith [ht.2]⟩
-    rw [hg_push_ex (t - T) htT_mem, hg_init, h_prev_push T hT_mem]
-    have h_prev_T_aemeas := h_prev_aemeas T hT_mem
-    have h_g_at_tT := hg_aemeas_ex (t - T) htT_mem
-    rw [hg_init, h_prev_push T hT_mem] at h_g_at_tT
-    rw [AEMeasurable.map_map_of_aemeasurable h_g_at_tT h_prev_T_aemeas]
-    rfl
-
-/-- AEMeasurability of the glued piecewise flow against `f_next 0` on the
-extended window.  Serves both `IsLagrangianVlasovSolutionOn`'s conjunct and
-the explicit conjunct (vi). -/
-private lemma vlasovGlue_flow_aemeasurable
-    {d : ℕ}
-    (f_prev g : ℝ → Measure (PhaseSpace d))
-    (charX_prev charV_prev charX_g charV_g : ℝ → PhaseSpace d → PhysSpace d)
-    {T T_0 : ℝ} (hT_pos : 0 < T)
-    (h_prev_push : ∀ t ∈ Set.Icc (0 : ℝ) T,
-        f_prev t =
-          Measure.map (fun z : PhaseSpace d => (charX_prev t z, charV_prev t z)) (f_prev 0))
-    (h_prev_aemeas : ∀ s ∈ Set.Icc (0 : ℝ) T,
-        AEMeasurable (fun z : PhaseSpace d => (charX_prev s z, charV_prev s z)) (f_prev 0))
-    (hg_init : g 0 = f_prev T)
-    (hg_aemeas_ex : ∀ s ∈ Set.Icc (0 : ℝ) T_0,
-        AEMeasurable (fun z : PhaseSpace d => (charX_g s z, charV_g s z)) (g 0))
-    (f_next : ℝ → Measure (PhaseSpace d))
-    (hf_next_le : ∀ s, s ≤ T → f_next s = f_prev s)
-    (s : ℝ) (hs : s ∈ Set.Icc (0 : ℝ) (T + T_0)) :
-    AEMeasurable (fun z : PhaseSpace d =>
-      ((if s ≤ T then charX_prev s z
-         else charX_g (s - T) (charX_prev T z, charV_prev T z)),
-       (if s ≤ T then charV_prev s z
-         else charV_g (s - T) (charX_prev T z, charV_prev T z)))) (f_next 0) := by
-  rw [hf_next_le 0 hT_pos.le]
-  by_cases hs_le : s ≤ T
-  · simp only [ite_eq_left hs_le]
-    exact h_prev_aemeas s ⟨hs.1, hs_le⟩
-  · simp only [ite_eq_right hs_le]
-    push Not at hs_le
-    have hT_mem : T ∈ Set.Icc (0 : ℝ) T := ⟨hT_pos.le, le_refl T⟩
-    have hsT_mem : s - T ∈ Set.Icc (0 : ℝ) T_0 := ⟨by linarith, by linarith [hs.2]⟩
-    have h_g_at_sT := hg_aemeas_ex (s - T) hsT_mem
-    rw [hg_init, h_prev_push T hT_mem] at h_g_at_sT
-    exact h_g_at_sT.comp_aemeasurable (h_prev_aemeas T hT_mem)
-
-/-- Finite first moment of the glued solution on the extended window,
-piecewise from the two window moment hypotheses. -/
-private lemma vlasovGlue_moment
-    {d : ℕ}
-    (f_prev g : ℝ → Measure (PhaseSpace d))
-    {T T_0 : ℝ}
-    (h_prev_mom : ∀ t ∈ Set.Icc (0 : ℝ) T, HasFiniteFirstMoment (f_prev t))
-    (hg_mom : ∀ t ∈ Set.Icc (0 : ℝ) T_0, HasFiniteFirstMoment (g t))
-    (f_next : ℝ → Measure (PhaseSpace d))
-    (hf_next_le : ∀ s, s ≤ T → f_next s = f_prev s)
-    (hf_next_gt : ∀ s, T < s → f_next s = g (s - T)) :
-    ∀ t ∈ Set.Icc (0 : ℝ) (T + T_0), HasFiniteFirstMoment (f_next t) := by
-  intro t ht
-  by_cases ht_le : t ≤ T
-  · rw [hf_next_le t ht_le]
-    exact h_prev_mom t ⟨ht.1, ht_le⟩
-  · push Not at ht_le
-    rw [hf_next_gt t ht_le]
-    exact hg_mom (t - T) ⟨by linarith, by linarith [ht.2]⟩
-
-/-- FLAT uniform first-moment bound on the glued solution's spatial marginal:
-`max` of the two window envelopes, no cross-term. -/
-private lemma vlasovGlue_moment_flat
-    {d : ℕ}
-    (f_prev g : ℝ → Measure (PhaseSpace d))
-    {T T_0 : ℝ}
-    (hM_prev : ∃ M : ℝ, 0 ≤ M ∧
-        ∀ t ∈ Set.Icc (0 : ℝ) T, ∫ y, ‖y‖ ∂(spatialMarginal (f_prev t)) ≤ M)
-    (hg_mom_unif : ∃ M : ℝ, 0 ≤ M ∧
-        ∀ t ∈ Set.Icc (0 : ℝ) T_0, ∫ y, ‖y‖ ∂(spatialMarginal (g t)) ≤ M)
-    (f_next : ℝ → Measure (PhaseSpace d))
-    (hf_next_le : ∀ s, s ≤ T → f_next s = f_prev s)
-    (hf_next_gt : ∀ s, T < s → f_next s = g (s - T)) :
-    ∃ M : ℝ, 0 ≤ M ∧
-      ∀ t ∈ Set.Icc (0 : ℝ) (T + T_0),
-        ∫ y, ‖y‖ ∂(spatialMarginal (f_next t)) ≤ M := by
-  obtain ⟨M_prev, hM_prev_nn, hM_prev_bd⟩ := hM_prev
-  obtain ⟨M_g, _hM_g_nn, hM_g_bd⟩ := hg_mom_unif
-  refine ⟨max M_prev M_g, le_trans hM_prev_nn (le_max_left _ _), fun t ht => ?_⟩
-  by_cases ht_le : t ≤ T
-  · rw [hf_next_le t ht_le]
-    exact le_trans (hM_prev_bd t ⟨ht.1, ht_le⟩) (le_max_left _ _)
-  · push Not at ht_le
-    rw [hf_next_gt t ht_le]
-    exact le_trans (hM_g_bd (t - T) ⟨by linarith, by linarith [ht.2]⟩) (le_max_right _ _)
-
-/-- **One-window glue step.**
-
-Given a solution `f_prev : ℝ → Measure (PhaseSpace d)` on `[0, T]`
-satisfying the local-existence conjuncts (initial condition + finite first
-moment + `IsLagrangianVlasovSolutionOn`), and a window length `T_0`
-satisfying the smallness constraints `LocalSmallnessPLBuffer L T_0` +
-`LocalSmallnessContraction L T_0`, produces a glued solution
-`f_next : ℝ → Measure (PhaseSpace d)` on `[0, T + T_0]` that agrees with
-`f_prev` on `[0, T]`.
-
-**Proof strategy**:
-
-1. Shift the initial condition: apply `vlasovWellPosedness_local` to
-   `f_prev T` (which has finite first moment by `h_prev_mom T`) with
-   window length `T_0`.  Gives a solution `g : ℝ → Measure (PhaseSpace d)`
-   on `[0, T_0]` with `g 0 = f_prev T`.
-
-2. Glue: define `f_next t := if t ≤ T then f_prev t else g (t - T)`.
-   Agreement at `t = T` is by `g 0 = f_prev T`.
-
-3. Verify the four output conjuncts:
-   - Initial: `f_next 0 = f_prev 0 = f₀`.
-   - Moment: piecewise from `h_prev_mom` and `g`'s moment bound.
-   - `IsLagrangianVlasovSolutionOn` on `[0, T + T_0]`:
-     * `IsVlasovSolutionOn`: weak PDE on `Ioo 0 (T + T_0)` — split at `T`,
-       use `h_prev_lag.1` for `Ioo 0 T` part and `g`'s for `Ioo T (T+T_0)`,
-       continuity at `T` from the integral being continuous.
-     * Flow: glue the per-window flows via standard ODE composition
-       (charX_next(t, z) := if t ≤ T then charX_prev(t, z) else
-       charX_g(t - T, (charX_prev(T, z), charV_prev(T, z)))).
-     * Pushforward equation: holds piecewise.
-     * AEMeasurable witness: composition of AEMeasurable maps. -/
-theorem vlasovWellPosedness_glue
-    {d : ℕ} [NeZero d]
-    (W : PhysSpace d → ℝ)
-    (gradW : PhysSpace d → PhysSpace d)
-    (hgradW : ∀ x, gradW x = gradient W x)
-    (L : NNReal) (hL : LipschitzWith L gradW)
-    (f₀ : Measure (PhaseSpace d))
-    (hf₀ : HasFiniteFirstMoment f₀)
-    {T : ℝ} (hT_pos : 0 < T)
-    (f_prev : ℝ → Measure (PhaseSpace d))
-    (h_prev_init : f_prev 0 = f₀)
-    (h_prev_mom : ∀ t ∈ Set.Icc (0 : ℝ) T, HasFiniteFirstMoment (f_prev t))
-    -- FLAT (window-constant) uniform first-moment bound on f_prev's spatial marginal.
-    (hM_prev : ∃ M : ℝ, 0 ≤ M ∧
-        ∀ t ∈ Set.Icc (0 : ℝ) T, ∫ y, ‖y‖ ∂(spatialMarginal (f_prev t)) ≤ M)
-    -- Explicit flow witnesses for f_prev (avoids witness-identity issues with
-    -- IsLagrangianVlasovSolutionOn)
-    (charX_prev charV_prev : ℝ → PhaseSpace d → PhysSpace d)
-    (h_prev_vlasov : IsVlasovSolutionOn gradW f_prev T)
-    (h_prev_flow : IsCharacteristicFlowOn gradW (fun t => spatialMarginal (f_prev t))
-        charX_prev charV_prev (Set.Ioo 0 T) Set.univ)
-    (h_prev_push : ∀ t ∈ Set.Icc (0 : ℝ) T,
-        f_prev t =
-          Measure.map (fun z : PhaseSpace d => (charX_prev t z, charV_prev t z)) (f_prev 0))
-    (h_prev_aemeas : ∀ s ∈ Set.Icc (0 : ℝ) T,
-        AEMeasurable (fun z : PhaseSpace d => (charX_prev s z, charV_prev s z)) (f_prev 0))
-    (h_prev_boundary : ∀ (z : PhaseSpace d) (t : ℝ), t ∈ Set.Icc (0 : ℝ) T →
-        HasDerivWithinAt (fun s => charX_prev s z) (charV_prev t z) (Set.Icc 0 T) t ∧
-        HasDerivWithinAt (fun s => charV_prev s z)
-          (-(convolveFunctionMeasure gradW (spatialMarginal (f_prev t)) (charX_prev t z)))
-          (Set.Icc 0 T) t)
-    (h_prev_ic : ∀ z : PhaseSpace d, charX_prev 0 z = z.1 ∧ charV_prev 0 z = z.2)
-    {T_0 : ℝ} (hT_0_pos : 0 < T_0)
-    (hT_0_small_PL : LocalSmallnessPLBuffer L T_0)
-    (hT_0_small_con : LocalSmallnessContraction L T_0)
-    (hT_0_small_B : (L : ℝ) / (1 + (L : ℝ)) * (Real.exp ((1 + (L : ℝ)) * T_0) - 1) < 1) :
-    ∃ (f_next : ℝ → Measure (PhaseSpace d))
-      (charX_next charV_next : ℝ → PhaseSpace d → PhysSpace d),
-      (∀ t ∈ Set.Icc (0 : ℝ) T, f_next t = f_prev t) ∧
-      f_next 0 = f₀ ∧
-      (∀ t ∈ Set.Icc (0 : ℝ) (T + T_0), HasFiniteFirstMoment (f_next t)) ∧
-      -- FLAT (window-constant) uniform first-moment bound on the spatial marginal.
-      (∃ M : ℝ, 0 ≤ M ∧
-        ∀ t ∈ Set.Icc (0 : ℝ) (T + T_0), ∫ y, ‖y‖ ∂(spatialMarginal (f_next t)) ≤ M) ∧
-      IsLagrangianVlasovSolutionOn gradW f_next (T + T_0) ∧
-      (∀ t ∈ Set.Icc (0 : ℝ) (T + T_0),
-          f_next t =
-            Measure.map (fun z : PhaseSpace d => (charX_next t z, charV_next t z)) (f_next 0)) ∧
-      (∀ s ∈ Set.Icc (0 : ℝ) (T + T_0),
-          AEMeasurable (fun z : PhaseSpace d => (charX_next s z, charV_next s z)) (f_next 0)) ∧
-      (∀ (z : PhaseSpace d) (t : ℝ), t ∈ Set.Icc (0 : ℝ) (T + T_0) →
-          HasDerivWithinAt (fun s => charX_next s z) (charV_next t z) (Set.Icc 0 (T + T_0)) t ∧
-          HasDerivWithinAt (fun s => charV_next s z)
-            (-(convolveFunctionMeasure gradW (spatialMarginal (f_next t)) (charX_next t z)))
-            (Set.Icc 0 (T + T_0)) t) ∧
-      (∀ z : PhaseSpace d, charX_next 0 z = z.1 ∧ charV_next 0 z = z.2) := by
-  -- The gluing closes the boundary at `t = T` by combining the boundary
-  -- regularity bundles from both windows: HasDerivWithinAt at T from the
-  -- LEFT (via f_prev's boundary bundle at endpoint T) and HasDerivWithinAt
-  -- at 0 from the RIGHT (via g's boundary bundle at endpoint 0), giving
-  -- HasDerivAt at t = T in `f_next`'s frame.
-  --
-  -- Step 1: invoke vlasovWellPosedness_local on f_prev T to get g on [0, T_0]
-  have h_prev_T_mom : HasFiniteFirstMoment (f_prev T) :=
-    h_prev_mom T (Set.right_mem_Icc.mpr hT_pos.le)
-  obtain ⟨g, charX_g, charV_g, hg_init, hg_mom, hg_mom_unif, hg_lag, hg_push_ex, hg_aemeas_ex,
-          hg_boundary, hg_init_cond⟩ :=
-    vlasovWellPosedness_local W gradW hgradW L hL
-      (f_prev T) h_prev_T_mom hT_0_pos hT_0_small_PL hT_0_small_con hT_0_small_B
-  -- Step 2: define the glued solution piecewise
-  let f_next : ℝ → Measure (PhaseSpace d) :=
-    fun t => if t ≤ T then f_prev t else g (t - T)
-  -- Step 3: verify the output conjuncts
-  -- Piecewise flow: for t ≤ T use charX_prev, for t > T compose with charX_g shifted
-  let charX_next : ℝ → PhaseSpace d → PhysSpace d := fun t z =>
-    if t ≤ T then charX_prev t z else charX_g (t - T) (charX_prev T z, charV_prev T z)
-  let charV_next : ℝ → PhaseSpace d → PhysSpace d := fun t z =>
-    if t ≤ T then charV_prev t z else charV_g (t - T) (charX_prev T z, charV_prev T z)
-  have h_g_vlasov : IsVlasovSolutionOn gradW g T_0 := hg_lag.1
-  refine ⟨f_next, charX_next, charV_next, ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_⟩
-  · -- Conjunct (i): agreement on [0, T]
-    intro t ht
-    simp only [f_next]
-    have ht_le : t ≤ T := ht.2
-    simp [ht_le]
-  · -- Conjunct (ii): initial condition f_next 0 = f₀
-    simp only [f_next]
-    have h0_le : (0 : ℝ) ≤ T := hT_pos.le
-    simp [h0_le, h_prev_init]
-  · -- Conjunct (iii): HasFiniteFirstMoment on [0, T + T_0] (hoisted helper)
-    exact vlasovGlue_moment f_prev g h_prev_mom hg_mom f_next
-      (fun s hs => ite_eq_left hs) (fun s hs => ite_eq_right (not_le.mpr hs))
-  · -- Conjunct (iii′): FLAT uniform first-moment bound (hoisted helper)
-    exact vlasovGlue_moment_flat f_prev g hM_prev hg_mom_unif f_next
-      (fun s hs => ite_eq_left hs) (fun s hs => ite_eq_right (not_le.mpr hs))
-  · -- Conjunct (iv): IsLagrangianVlasovSolutionOn gradW f_next (T + T_0)
-    refine ⟨?_, charX_next, charV_next, ?_, ?_, ?_⟩
-    · -- IsVlasovSolutionOn gradW f_next (T + T_0)
-      -- Sub-sorry: PDE gluing — on Ioo 0 (T + T_0), piecewise from h_prev_vlasov and h_g_vlasov
-      -- Sub-sorry (a): IsVlasovSolutionOn for the glued solution.
-      -- Strategy: for t ∈ Ioo 0 T use h_prev_vlasov (with f_next = f_prev near t);
-      -- for t ∈ Ioo T (T+T_0) use h_g_vlasov shifted (f_next t = g (t-T));
-      -- at t = T use continuity of t ↦ ∫ φ ∂f_next t from both sides.
-      have h_vlasov_glue : IsVlasovSolutionOn gradW f_next (T + T_0) := by
-        intro φ hφ_smooth hφ_compact gradXφ gradVφ hgradXφ hgradVφ t ht
-        -- Off-seam weak PDE at every t' ≠ T (hoisted helper); the two strict
-        -- branches consume it directly, the seam derives its eventual form.
-        have h_diff_ne := vlasovGlue_diff_ne gradW f_prev g
-          h_prev_vlasov h_g_vlasov f_next (fun s hs => ite_eq_left hs)
-          (fun s hs => ite_eq_right (not_le.mpr hs)) φ hφ_smooth hφ_compact
-          gradXφ gradVφ hgradXφ hgradVφ
-        by_cases ht_lt : t < T
-        · -- t ∈ Ioo 0 T: off-seam weak PDE
-          rw [show (fun _ => (0 : ℝ)) t = 0 from rfl]
-          exact h_diff_ne t ht (ne_of_lt ht_lt)
-        · by_cases ht_gt : T < t
-          · -- t ∈ Ioo T (T + T_0): off-seam weak PDE
-            rw [show (fun _ => (0 : ℝ)) t = 0 from rfl]
-            exact h_diff_ne t ht (ne_of_gt ht_gt)
-          · -- t = T: boundary case via `hasDerivAt_of_hasDerivAt_of_ne_in_nhds`.
-            -- Three sub-arguments: (1) HasDerivAt at every nearby t' ≠ T from the
-            -- off-seam helper; (2) ContinuousAt of the integral function at T;
-            -- (3) ContinuousAt of the derivative function at T.
-            push Not at ht_gt
-            have h_t_eq : t = T := le_antisymm ht_gt (not_lt.mp ht_lt)
-            -- Step 1: HasDerivAt at every nearby t' ≠ T, in eventual form.
-            have h_diff_ne_ev : ∀ᶠ t' in nhds T, t' ≠ T → HasDerivAt
-                (fun s => ∫ z, φ z ∂f_next s)
-                ((∫ z, (@inner ℝ (PhysSpace d) _ z.2 (gradXφ z) -
-                        @inner ℝ (PhysSpace d) _
-                          (convolveFunctionMeasure gradW (spatialMarginal (f_next t')) z.1)
-                          (gradVφ z)) ∂(f_next t')) + 0) t' := by
-              have hU_mem : Set.Ioo (0 : ℝ) (T + T_0) ∈ nhds T :=
-                Ioo_mem_nhds hT_pos (by linarith)
-              exact Filter.Eventually.mono hU_mem (fun t' ht' => h_diff_ne t' ht')
-            -- Step 2: ContinuousAt of integral function at T.
-            -- Decomposed into LEFT (Iic T) + RIGHT (Ici T) closes, joined via
-            -- `Iic_union_Ici = univ`.
-            have hφ_cont : Continuous φ := hφ_smooth.continuous
-            obtain ⟨Cφ, hCφ⟩ := hφ_cont.bounded_above_of_compact_support hφ_compact
-            obtain ⟨hf₀_prob, hf₀_int⟩ := hf₀
-            have : IsProbabilityMeasure f₀ := hf₀_prob
-            -- LEFT side: substantive close via DCT on f_prev's pushforward.
-            have h_cont_f_left : ContinuousWithinAt (fun s => ∫ z, φ z ∂f_next s)
-                (Set.Iic T) T :=
-              vlasovGlue_intCont_left gradW f₀ hT_pos f_prev h_prev_init
-                charX_prev charV_prev h_prev_push h_prev_aemeas h_prev_boundary
-                f_next (fun s hs => ite_eq_left hs) φ hφ_cont Cφ hCφ
-            -- RIGHT side: substantive close via DCT on the composed pushforward
-            -- (charX_g (s-T), charV_g (s-T)) ∘ (charX_prev T, charV_prev T).
-            -- At s = T, hg_init_cond bridges (charX_g 0, charV_g 0) = id, matching f_prev T.
-            have h_cont_f_right : ContinuousWithinAt (fun s => ∫ z, φ z ∂f_next s)
-                (Set.Ici T) T :=
-              vlasovGlue_intCont_right gradW f₀ hT_pos hT_0_pos f_prev h_prev_init
-                charX_prev charV_prev h_prev_push h_prev_aemeas g charX_g charV_g
-                hg_init hg_push_ex hg_aemeas_ex hg_boundary hg_init_cond
-                f_next (ite_eq_left (le_refl T)) (fun s hs => ite_eq_right (not_le.mpr hs))
-                φ hφ_cont Cφ hCφ
-            -- Combine via union
-            have h_cont_f : ContinuousAt (fun s => ∫ z, φ z ∂f_next s) T := by
-              have h_union := h_cont_f_left.union h_cont_f_right
-              rw [Set.Iic_union_Ici] at h_union
-              exact h_union.continuousAt Filter.univ_mem
-            -- Step 3: ContinuousAt of the derivative functional at the seam T.
-            -- Mirror `h_cont_f`'s one-sided-union structure (Iic/Ici +
-            -- `Set.Iic_union_Ici`).  Each side discharges by push-to-f₀ +
-            -- DCT; the integrand's force term carries
-            -- `convolveFunctionMeasure gradW (spatialMarginal (f_next ·)) z.1`, whose
-            -- seam continuity closes from PROVEN TOOLS via the pushforward
-            -- representation: `f_prev`/`g` are flow-pushforwards of `f₀`, so the
-            -- convolution rewrites by `integral_map` to a fixed-`f₀` integral, closed
-            -- by the inner kernels `flowConv_continuousWithinAt_{Iic,Ici}_seam`
-            -- (Piece-A-dominated DCT).  LEFT uses `spatialMarginal (f_prev ·)`,
-            -- RIGHT the composed flow off `g`.
-            have h_cont_g : ContinuousAt (fun t' =>
-                (∫ z, (@inner ℝ (PhysSpace d) _ z.2 (gradXφ z) -
-                        @inner ℝ (PhysSpace d) _
-                          (convolveFunctionMeasure gradW (spatialMarginal (f_next t')) z.1)
-                          (gradVφ z)) ∂(f_next t')) + 0) T := by
-              simp only [add_zero]
-              -- LEFT side (s ≤ T): f_next = f_prev = pushforward of f₀; force term
-              -- uses `spatialMarginal (f_prev ·)`.  Discharge: push-to-f₀ + DCT.
-              have h_left : ContinuousWithinAt
-                  (fun s => ∫ z, (@inner ℝ (PhysSpace d) _ z.2 (gradXφ z) -
-                          @inner ℝ (PhysSpace d) _
-                            (convolveFunctionMeasure gradW (spatialMarginal (f_next s)) z.1)
-                            (gradVφ z)) ∂(f_next s)) (Set.Iic T) T :=
-                vlasovGlue_seam_contLeft gradW L hL f₀ hf₀_int hT_pos f_prev h_prev_init
-                  h_prev_mom hM_prev charX_prev charV_prev h_prev_push h_prev_aemeas
-                  h_prev_boundary h_prev_ic f_next (fun s hs => ite_eq_left hs)
-                  φ hφ_smooth hφ_compact gradXφ gradVφ hgradXφ hgradVφ
-              -- RIGHT side (s ≥ T): f_next = g (·−T) = composed pushforward; symmetric
-              -- to `h_left`.  The flow is the COMPOSED phase-space flow
-              -- `Φ_s z = (charX_g (s−T) (charX_prev T z, charV_prev T z),
-              --           charV_g (s−T) (charX_prev T z, charV_prev T z))`, and the
-              -- position part `Z_s z = charX_g (s−T) (charX_prev T z, charV_prev T z)`
-              -- is what the force-term convolution sees.  Pushforward, AEMeasurability,
-              -- and seam continuity are copied/adapted from the PROVEN
-              -- `h_cont_f_right` (composed-pushforward machinery); the growth bound is
-              -- the composed Piece A (g over [0,T_0] ∘ prev at T); the force-term seam
-              -- continuity uses the `Ici` sibling kernel `flowConv_continuousWithinAt_Ici_seam`.
-              have h_right : ContinuousWithinAt
-                  (fun s => ∫ z, (@inner ℝ (PhysSpace d) _ z.2 (gradXφ z) -
-                          @inner ℝ (PhysSpace d) _
-                            (convolveFunctionMeasure gradW (spatialMarginal (f_next s)) z.1)
-                            (gradVφ z)) ∂(f_next s)) (Set.Ici T) T :=
-                vlasovGlue_seam_contRight gradW L hL f₀ hf₀_int hT_pos hT_0_pos
-                  f_prev h_prev_init h_prev_mom hM_prev charX_prev charV_prev
-                  h_prev_push h_prev_aemeas h_prev_boundary h_prev_ic
-                  g charX_g charV_g hg_init hg_mom hg_mom_unif hg_push_ex
-                  hg_aemeas_ex hg_boundary hg_init_cond f_next
-                  (ite_eq_left (le_refl T)) (fun s hs => ite_eq_right (not_le.mpr hs))
-                  φ hφ_smooth hφ_compact gradXφ gradVφ hgradXφ hgradVφ
-              have h_union := h_left.union h_right
-              rw [Set.Iic_union_Ici] at h_union
-              exact h_union.continuousAt Filter.univ_mem
-            -- Step 4: Apply the localized helper.
-            rw [h_t_eq]
-            exact hasDerivAt_of_hasDerivAt_of_ne_in_nhds h_diff_ne_ev h_cont_f h_cont_g
-      exact h_vlasov_glue
-    · -- IsCharacteristicFlowOn for the glued flow
-      -- Sub-sorry: flow initial condition + HasDerivAt for piecewise flow
-      have h_flow_glue : IsCharacteristicFlowOn gradW
-          (fun t => spatialMarginal (f_next t)) charX_next charV_next
-          (Set.Ioo 0 (T + T_0)) Set.univ := by
-        refine ⟨?_, ?_, ?_⟩
-        · -- Initial condition: charX_next 0 z = z.1 ∧ charV_next 0 z = z.2
-          intro z _
-          simp only [charX_next, charV_next, ite_eq_left hT_pos.le]
-          exact h_prev_flow.1 z (Set.mem_univ z)
-        · -- HasDerivAt charX_next at t for t ∈ Ioo 0 (T + T_0) (hoisted helper)
-          intro t ht z _
-          simp only [charX_next, charV_next]
-          exact vlasovGlue_flowX_hasDerivAt charX_prev charV_prev charX_g charV_g
-            hT_pos hT_0_pos
-            (fun t' ht' z' => h_prev_flow.2.1 t' ht' z' (Set.mem_univ z'))
-            (fun z' t' ht' => (h_prev_boundary z' t' ht').1)
-            (fun z' t' ht' => (hg_boundary z' t' ht').1)
-            hg_init_cond t ht z
-        · -- HasDerivAt charV_next at t for t ∈ Ioo 0 (T + T_0) (hoisted helper)
-          intro t ht z _
-          simp only [charX_next, charV_next]
-          exact vlasovGlue_flowV_hasDerivAt gradW f_prev g charX_prev charV_prev
-            charX_g charV_g hT_pos hT_0_pos
-            (fun t' ht' z' => h_prev_flow.2.2 t' ht' z' (Set.mem_univ z'))
-            (fun z' t' ht' => (h_prev_boundary z' t' ht').2)
-            (fun z' t' ht' => (hg_boundary z' t' ht').2)
-            hg_init hg_init_cond f_next (fun s hs => ite_eq_left hs)
-            (fun s hs => ite_eq_right (not_le.mpr hs)) t ht z
-      exact h_flow_glue
-    · -- Pushforward equation for f_next on Icc 0 (T + T_0) (hoisted helper)
-      intro t ht
-      simp only [charX_next, charV_next]
-      exact vlasovGlue_pushforward_eq f_prev g charX_prev charV_prev charX_g charV_g
-        hT_pos h_prev_push h_prev_aemeas hg_init hg_push_ex hg_aemeas_ex f_next
-        (fun s hs => ite_eq_left hs) (fun s hs => ite_eq_right (not_le.mpr hs)) t ht
-    · -- AEMeasurability ∧ boundary ContinuousOn on Icc 0 (T + T_0).
-      refine ⟨?_, ?_⟩
-      · -- AEMeasurability of the glued flow (hoisted helper).
-        intro s hs
-        simp only [charX_next, charV_next]
-        exact vlasovGlue_flow_aemeasurable f_prev g charX_prev charV_prev
-          charX_g charV_g hT_pos h_prev_push h_prev_aemeas hg_init hg_aemeas_ex
-          f_next (fun s' hs' => ite_eq_left hs') s hs
-      · -- Boundary ContinuousOn on Icc 0 (T + T_0): project the boundary bundle.
-        intro z s hs
-        exact ((vlasovWellPosedness_glue_boundary gradW hT_pos hT_0_pos f_prev g f_next
-          charX_prev charV_prev charX_g charV_g charX_next charV_next rfl rfl rfl
-          h_prev_boundary hg_boundary hg_init hg_init_cond z s hs).1.continuousWithinAt.prodMk
-          (vlasovWellPosedness_glue_boundary gradW hT_pos hT_0_pos f_prev g f_next
-            charX_prev charV_prev charX_g charV_g charX_next charV_next rfl rfl rfl
-            h_prev_boundary hg_boundary hg_init hg_init_cond z s hs).2.continuousWithinAt)
-  · -- Conjunct (v): explicit pushforward for charX_next charV_next (hoisted helper)
-    intro t ht
-    simp only [charX_next, charV_next]
-    exact vlasovGlue_pushforward_eq f_prev g charX_prev charV_prev charX_g charV_g
-      hT_pos h_prev_push h_prev_aemeas hg_init hg_push_ex hg_aemeas_ex f_next
-      (fun s hs => ite_eq_left hs) (fun s hs => ite_eq_right (not_le.mpr hs)) t ht
-  · -- Conjunct (vi): AEMeasurable for charX_next charV_next (hoisted helper)
-    intro s hs
-    simp only [charX_next, charV_next]
-    exact vlasovGlue_flow_aemeasurable f_prev g charX_prev charV_prev
-      charX_g charV_g hT_pos h_prev_push h_prev_aemeas hg_init hg_aemeas_ex
-      f_next (fun s' hs' => ite_eq_left hs') s hs
-  · -- Conjunct (vii): boundary bundle for charX_next charV_next on Icc 0 (T + T_0)
-    exact vlasovWellPosedness_glue_boundary gradW hT_pos hT_0_pos f_prev g f_next
-      charX_prev charV_prev charX_g charV_g charX_next charV_next rfl rfl rfl
-      h_prev_boundary hg_boundary hg_init hg_init_cond
-  · -- Conjunct (viii): initial condition for charX_next charV_next
-    intro z
-    simp only [charX_next, charV_next, ite_eq_left hT_pos.le]
-    exact h_prev_ic z
-
-/-- For every positive Lipschitz constant there is a window length satisfying all
-three per-window smallness constraints — the PL buffer, the contraction, and the
-envelope closure.  Pure threshold arithmetic: `T_0 := min(1/√L, T_0_con, T_0_env)/2`
-with each threshold positive for every `L > 0` (no `L < 1` restriction). -/
-lemma exists_localSmallness_window (L : NNReal) (hL_pos : (0 : ℝ) < L) :
-    ∃ T_0 : ℝ, 0 < T_0 ∧ LocalSmallnessPLBuffer L T_0 ∧ LocalSmallnessContraction L T_0 ∧
-      (L : ℝ) / (1 + (L : ℝ)) * (Real.exp ((1 + (L : ℝ)) * T_0) - 1) < 1 := by
-  let T_0_PL : ℝ := 1 / Real.sqrt L
-  let T_0_con : ℝ := Real.log (max 1 (L : ℝ) / (L : ℝ) + 1) / max 1 (L : ℝ)
-  let T_0_env : ℝ := Real.log (1 + (1 + (L : ℝ)) / (L : ℝ)) / (1 + (L : ℝ))
-  let T_0 : ℝ := min (min T_0_PL T_0_con) T_0_env / 2
-  have hL_nn : (0 : ℝ) ≤ L := NNReal.coe_nonneg L
-  have hL_ne : (L : ℝ) ≠ 0 := ne_of_gt hL_pos
-  have hsqrtL_pos : 0 < Real.sqrt (L : ℝ) := Real.sqrt_pos.mpr hL_pos
-  have hs_eq : (Real.sqrt (L : ℝ)) ^ 2 = (L : ℝ) := Real.sq_sqrt hL_nn
-  have hK_pos : (0 : ℝ) < max 1 (L : ℝ) := lt_of_lt_of_le one_pos (le_max_left _ _)
-  have hT_0_PL_pos : 0 < T_0_PL := by
-    change 0 < 1 / Real.sqrt (L : ℝ); positivity
-  have hKL_gt1 : 1 < max 1 (L : ℝ) / (L : ℝ) + 1 := by
-    have : 0 < max 1 (L : ℝ) / (L : ℝ) := div_pos hK_pos hL_pos
-    linarith
-  have hT_0_con_pos : 0 < T_0_con :=
-    div_pos (Real.log_pos hKL_gt1) hK_pos
-  have h_1L_pos : (0 : ℝ) < 1 + (L : ℝ) := by linarith [hL_pos]
-  have hT_0_env_pos : 0 < T_0_env := by
-    change 0 < Real.log (1 + (1 + (L : ℝ)) / (L : ℝ)) / (1 + (L : ℝ))
-    have h_arg_gt1 : 1 < 1 + (1 + (L : ℝ)) / (L : ℝ) := by
-      have : 0 < (1 + (L : ℝ)) / (L : ℝ) := by positivity
-      linarith
-    exact div_pos (Real.log_pos h_arg_gt1) h_1L_pos
-  have hT_0_min_pos : 0 < min (min T_0_PL T_0_con) T_0_env :=
-    lt_min (lt_min hT_0_PL_pos hT_0_con_pos) hT_0_env_pos
-  have hT0_pos : 0 < T_0 := by
-    change 0 < min (min T_0_PL T_0_con) T_0_env / 2; linarith
-  have hTL_T0_PL : LocalSmallnessPLBuffer L T_0 := by
-    change (L : ℝ) * T_0 ^ 2 < 1
-    have h_T_0_le : T_0 ≤ 1 / (2 * Real.sqrt (L : ℝ)) := by
-      change min (min T_0_PL T_0_con) T_0_env / 2 ≤ 1 / (2 * Real.sqrt (L : ℝ))
-      have h_min_le : min (min T_0_PL T_0_con) T_0_env ≤ T_0_PL :=
-        le_trans (min_le_left _ _) (min_le_left _ _)
-      have hrw : (1 : ℝ) / (2 * Real.sqrt (L : ℝ)) = (1 / Real.sqrt (L : ℝ)) / 2 := by
-        rw [div_div, mul_comm (2 : ℝ) (Real.sqrt (L : ℝ))]
-      rw [hrw]
-      have hTPL : T_0_PL = 1 / Real.sqrt (L : ℝ) := rfl
-      rw [hTPL] at h_min_le; linarith
-    have h_T_0_nn : 0 ≤ T_0 := le_of_lt hT0_pos
-    have h_sq_le : T_0 ^ 2 ≤ (1 / (2 * Real.sqrt (L : ℝ))) ^ 2 :=
-      pow_le_pow_left₀ h_T_0_nn h_T_0_le 2
-    have h_mul_le : (L : ℝ) * T_0 ^ 2 ≤ (L : ℝ) * (1 / (2 * Real.sqrt (L : ℝ))) ^ 2 :=
-      mul_le_mul_of_nonneg_left h_sq_le hL_nn
-    have h_eq : (L : ℝ) * (1 / (2 * Real.sqrt (L : ℝ))) ^ 2 = 1 / 4 := by
-      rw [div_pow, one_pow, mul_pow, hs_eq]; field_simp; ring
-    rw [h_eq] at h_mul_le; linarith
-  have hTL_T0_con : LocalSmallnessContraction L T_0 := by
-    change (L : ℝ) * (Real.exp ((max 1 (L : ℝ)) * T_0) - 1) / (max 1 (L : ℝ)) < 1
-    set K : ℝ := max 1 (L : ℝ) with hK_def
-    have h_T_0_lt : T_0 < T_0_con := by
-      change min (min T_0_PL T_0_con) T_0_env / 2 < T_0_con
-      have h_min_le : min (min T_0_PL T_0_con) T_0_env ≤ T_0_con :=
-        le_trans (min_le_left _ _) (min_le_right _ _)
-      linarith
-    have hKL1_pos : (0 : ℝ) < K / (L : ℝ) + 1 := by
-      have : 0 < K / (L : ℝ) := div_pos hK_pos hL_pos
-      linarith
-    have h_KT0_lt : K * T_0 < Real.log (K / (L : ℝ) + 1) := by
-      have hTcon : T_0_con = Real.log (K / (L : ℝ) + 1) / K := rfl
-      rw [hTcon] at h_T_0_lt
-      have hh := (lt_div_iff₀ hK_pos).mp h_T_0_lt
-      nlinarith [hh]
-    have h_exp_lt : Real.exp (K * T_0) < K / (L : ℝ) + 1 := by
-      have := Real.exp_lt_exp.mpr h_KT0_lt
-      rwa [Real.exp_log hKL1_pos] at this
-    have h_sub_lt : Real.exp (K * T_0) - 1 < K / (L : ℝ) := by linarith
-    have h_num_lt : (L : ℝ) * (Real.exp (K * T_0) - 1) < K := by
-      have := mul_lt_mul_of_pos_left h_sub_lt hL_pos
-      rwa [mul_div_cancel₀ _ hL_ne] at this
-    rw [div_lt_one hK_pos]
-    exact h_num_lt
-  have hTL_T0_B :
-      (L : ℝ) / (1 + (L : ℝ)) * (Real.exp ((1 + (L : ℝ)) * T_0) - 1) < 1 := by
-    have hL_ne : (L : ℝ) ≠ 0 := ne_of_gt hL_pos
-    have h_1L_ne : (1 + (L : ℝ)) ≠ 0 := ne_of_gt h_1L_pos
-    have h_ratio_pos : (0 : ℝ) < (1 + (L : ℝ)) / (L : ℝ) := div_pos h_1L_pos hL_pos
-    have h_arg_pos : (0 : ℝ) < 1 + (1 + (L : ℝ)) / (L : ℝ) := by linarith
-    have h_T_0_lt_env : T_0 < T_0_env := by
-      change min (min T_0_PL T_0_con) T_0_env / 2 < T_0_env
-      have h_min_le : min (min T_0_PL T_0_con) T_0_env ≤ T_0_env := min_le_right _ _
-      linarith
-    have h_lin_lt : (1 + (L : ℝ)) * T_0
-        < Real.log (1 + (1 + (L : ℝ)) / (L : ℝ)) := by
-      have h_env_eq : (1 + (L : ℝ)) * T_0_env
-          = Real.log (1 + (1 + (L : ℝ)) / (L : ℝ)) := by
-        change (1 + (L : ℝ)) *
-            (Real.log (1 + (1 + (L : ℝ)) / (L : ℝ)) / (1 + (L : ℝ)))
-          = Real.log (1 + (1 + (L : ℝ)) / (L : ℝ))
-        field_simp
-      calc (1 + (L : ℝ)) * T_0
-          < (1 + (L : ℝ)) * T_0_env := mul_lt_mul_of_pos_left h_T_0_lt_env h_1L_pos
-        _ = Real.log (1 + (1 + (L : ℝ)) / (L : ℝ)) := h_env_eq
-    have h_exp_lt : Real.exp ((1 + (L : ℝ)) * T_0)
-        < 1 + (1 + (L : ℝ)) / (L : ℝ) := by
-      calc Real.exp ((1 + (L : ℝ)) * T_0)
-          < Real.exp (Real.log (1 + (1 + (L : ℝ)) / (L : ℝ))) :=
-            Real.exp_lt_exp.mpr h_lin_lt
-        _ = 1 + (1 + (L : ℝ)) / (L : ℝ) := Real.exp_log h_arg_pos
-    have h_diff_lt : Real.exp ((1 + (L : ℝ)) * T_0) - 1 < (1 + (L : ℝ)) / (L : ℝ) := by
-      linarith
-    have hcoef_pos : (0 : ℝ) < (L : ℝ) / (1 + (L : ℝ)) := div_pos hL_pos h_1L_pos
-    calc (L : ℝ) / (1 + (L : ℝ)) * (Real.exp ((1 + (L : ℝ)) * T_0) - 1)
-        < (L : ℝ) / (1 + (L : ℝ)) * ((1 + (L : ℝ)) / (L : ℝ)) :=
-          mul_lt_mul_of_pos_left h_diff_lt hcoef_pos
-      _ = 1 := by field_simp
-  exact ⟨T_0, hT0_pos, hTL_T0_PL, hTL_T0_con, hTL_T0_B⟩
-
-/-- **Forward iteration to arbitrary `T_target`.**
-
-Extends the local-existence theorem from its small-`T` smallness window
-to any `T_target > 0`, by iterating the local theorem with shifted initial
-data at a fixed step `T_0` depending only on `L` (no `L < 1` hypothesis).
-
-**Proof strategy**:
-
-1. Pick `T_0 := min(T_0_PL, T_0_con, T_0_env) / 2`, with `T_0_PL := 1/√L`
-   (the PL-buffer threshold for `L · T_0² < 1`), `T_0_con`/`T_0_env` the
-   contraction/envelope thresholds.  Each is positive for every `L > 0`, so
-   `T_0 > 0` and all three smallness constraints hold.
-
-2. Pick `N := ⌈T_target / T_0⌉₊` so that `N · T_0 ≥ T_target`.
-
-3. `Nat.rec` construction: a solution holding the conjuncts at `T = n·T_0`.
-   - Base case: apply `vlasovWellPosedness_local` directly.
-   - Step case (`n → n+1`): apply `vlasovWellPosedness_glue` to extend.
-
-4. Take `f := f_N` and verify the conjuncts for `T_target ≤ N · T_0` via
-   `IsLagrangianVlasovSolutionOn`'s monotonicity in `T` (project down). -/
-theorem vlasovWellPosedness_forward
-    {d : ℕ} [NeZero d]
-    (W : PhysSpace d → ℝ)
-    (gradW : PhysSpace d → PhysSpace d)
-    (hgradW : ∀ x, gradW x = gradient W x)
-    (L : NNReal) (hL : LipschitzWith L gradW)
-    (hL_pos : (0 : ℝ) < L)
-    (f₀ : Measure (PhaseSpace d))
-    (hf₀ : HasFiniteFirstMoment f₀)
-    {T_target : ℝ} (hT_target : 0 < T_target) :
-    ∃ f : ℝ → Measure (PhaseSpace d),
-      f 0 = f₀ ∧
-      (∀ t ∈ Set.Icc (0 : ℝ) T_target, HasFiniteFirstMoment (f t)) ∧
-      IsLagrangianVlasovSolutionOn gradW f T_target := by
-  -- T_0 must satisfy the PL-buffer, contraction, and envelope constraints —
-  -- all supplied by the pure-arithmetic `exists_localSmallness_window`.
-  obtain ⟨T_0, hT0_pos, hTL_T0_PL, hTL_T0_con, hTL_T0_B⟩ :=
-    exists_localSmallness_window L hL_pos
-  -- Step 2: N = ⌈T_target / T_0⌉₊ windows of size T_0 cover T_target.
-  let N : ℕ := ⌈T_target / T_0⌉₊
-  have hN_pos : 0 < N := by
-    change 0 < ⌈T_target / T_0⌉₊
-    rw [Nat.ceil_pos]
-    exact div_pos hT_target hT0_pos
-  have hN_covers : T_target ≤ (N : ℝ) * T_0 := by
-    have hle := Nat.le_ceil (T_target / T_0)
-    have hT0_pos' := hT0_pos
-    calc T_target = T_target / T_0 * T_0 := by field_simp
-         _ ≤ (⌈T_target / T_0⌉₊ : ℝ) * T_0 :=
-              mul_le_mul_of_nonneg_right hle (le_of_lt hT0_pos)
-  -- Step 3: Induction on n : ℕ — solution exists on [0, (n+1)·T_0].
-  -- The induction carries explicit flow witnesses (charX, charV) and the full
-  -- 7-component bundle to enable vlasovWellPosedness_glue calls without witness-identity issues.
-  let T_n := fun n : ℕ => ((n + 1 : ℕ) : ℝ) * T_0
-  have h_ind : ∀ n : ℕ,
-      ∃ (f : ℝ → Measure (PhaseSpace d))
-        (charX charV : ℝ → PhaseSpace d → PhysSpace d),
-        f 0 = f₀ ∧
-        (∀ t ∈ Set.Icc (0 : ℝ) (T_n n), HasFiniteFirstMoment (f t)) ∧
-        -- FLAT (window-constant) uniform first-moment bound on the spatial marginal.
-        (∃ M : ℝ, 0 ≤ M ∧
-          ∀ t ∈ Set.Icc (0 : ℝ) (T_n n), ∫ y, ‖y‖ ∂(spatialMarginal (f t)) ≤ M) ∧
-        IsVlasovSolutionOn gradW f (T_n n) ∧
-        (∀ t ∈ Set.Icc (0 : ℝ) (T_n n),
-            f t = Measure.map (fun z : PhaseSpace d => (charX t z, charV t z)) (f 0)) ∧
-        (∀ s ∈ Set.Icc (0 : ℝ) (T_n n),
-            AEMeasurable (fun z : PhaseSpace d => (charX s z, charV s z)) (f 0)) ∧
-        (∀ (z : PhaseSpace d) (t : ℝ), t ∈ Set.Icc (0 : ℝ) (T_n n) →
-            HasDerivWithinAt (fun s => charX s z) (charV t z) (Set.Icc 0 (T_n n)) t ∧
-            HasDerivWithinAt (fun s => charV s z)
-              (-(convolveFunctionMeasure gradW (spatialMarginal (f t)) (charX t z)))
-              (Set.Icc 0 (T_n n)) t) ∧
-        (∀ z : PhaseSpace d, charX 0 z = z.1 ∧ charV 0 z = z.2) := by
-    intro n
-    induction n with
-    | zero =>
-      -- Base: n = 0, need solution on [0, 1·T_0] = [0, T_0].
-      simp only [T_n, zero_add, Nat.cast_one, one_mul]
-      obtain ⟨f, charX, charV, hf_init, hf_mom, hf_mom_unif, hf_lag, hf_push, hf_aemeas,
-        hf_boundary, hf_ic⟩ :=
-        vlasovWellPosedness_local W gradW hgradW L hL f₀ hf₀ hT0_pos hTL_T0_PL hTL_T0_con hTL_T0_B
-      exact ⟨f, charX, charV, hf_init, hf_mom, hf_mom_unif, hf_lag.1, hf_push, hf_aemeas,
-        hf_boundary, hf_ic⟩
-    | succ n ih =>
-      -- Step: n+1 → (n+2)·T_0.  Use vlasovWellPosedness_glue with T = (n+1)·T_0 > 0.
-      obtain ⟨f_n, charX_n, charV_n, hfn_init, hfn_mom, hfn_mom_unif, hfn_vlasov,
-              hfn_push, hfn_aemeas, hfn_boundary, hfn_ic⟩ := ih
-      simp only [T_n] at hfn_mom hfn_mom_unif hfn_vlasov hfn_push hfn_aemeas hfn_boundary
-      have hT_n_pos : (0 : ℝ) < ((n + 1 : ℕ) : ℝ) * T_0 :=
-        mul_pos (by exact_mod_cast Nat.succ_pos n) hT0_pos
-      -- Derive IsCharacteristicFlowOn from h_prev_boundary + hasDerivAt
-      -- (interior points t ∈ Ioo 0 T_n have Icc 0 T_n ∈ 𝓝 t, so HasDerivWithinAt → HasDerivAt)
-      have hfn_flow : IsCharacteristicFlowOn gradW (fun t => spatialMarginal (f_n t))
-          charX_n charV_n (Set.Ioo 0 (((n + 1 : ℕ) : ℝ) * T_0)) Set.univ := by
-        refine ⟨fun z _ => hfn_ic z, ?_, ?_⟩
-        · intro t ht z _
-          exact ((hfn_boundary z t (Set.Ioo_subset_Icc_self ht)).1).hasDerivAt
-            (Icc_mem_nhds ht.1 ht.2)
-        · intro t ht z _
-          exact ((hfn_boundary z t (Set.Ioo_subset_Icc_self ht)).2).hasDerivAt
-            (Icc_mem_nhds ht.1 ht.2)
-      obtain ⟨f_next, charX_next, charV_next, _h_agree, h_init, h_mom, h_mom_unif, h_lag,
-              h_push, h_aemeas, h_boundary, h_ic⟩ :=
-        vlasovWellPosedness_glue W gradW hgradW L hL f₀ hf₀ hT_n_pos
-          f_n hfn_init hfn_mom hfn_mom_unif
-          charX_n charV_n hfn_vlasov hfn_flow
-          hfn_push hfn_aemeas hfn_boundary hfn_ic
-          hT0_pos hTL_T0_PL hTL_T0_con hTL_T0_B
-      -- Need: T_n (n+1) = T_n n + T_0
-      have h_T_eq : T_n (n + 1) = T_n n + T_0 := by
-        simp only [T_n]; push_cast; ring
-      refine ⟨f_next, charX_next, charV_next, h_init, ?_, ?_, ?_, ?_, ?_, ?_, ?_⟩
-      · rw [h_T_eq]; exact h_mom
-      · rw [h_T_eq]; exact h_mom_unif
-      · rw [h_T_eq]; exact h_lag.1
-      · rw [h_T_eq]; exact h_push
-      · rw [h_T_eq]; exact h_aemeas
-      · rw [h_T_eq]; exact h_boundary
-      · exact h_ic
-  -- Step 4: Apply h_ind at n = N - 1 (since N ≥ 1).
-  have hN_pred : N - 1 + 1 = N := Nat.succ_pred_eq_of_pos hN_pos
-  obtain ⟨f, charX_f, charV_f, hf_init, hf_mom, _hf_mom_unif, hf_vlasov,
-          hf_push, hf_aemeas, hf_boundary, hf_ic⟩ := h_ind (N - 1)
-  simp only [T_n] at hf_mom hf_vlasov hf_push hf_aemeas hf_boundary
-  rw [hN_pred] at hf_mom hf_vlasov hf_push hf_aemeas hf_boundary
-  -- Step 5: Restrict from [0, N·T_0] down to [0, T_target].
-  refine ⟨f, hf_init, ?_, ?_⟩
-  · -- Moment bound on [0, T_target] ⊆ [0, N·T_0].
-    intro t ht
-    exact hf_mom t ⟨ht.1, le_trans ht.2 hN_covers⟩
-  · -- IsLagrangianVlasovSolutionOn on [0, T_target] ≤ [0, N·T_0].
-    -- Derive IsCharacteristicFlowOn for T_target from hf_boundary (restrict to Ioo 0 T_target).
-    have hf_flow : IsCharacteristicFlowOn gradW (fun t => spatialMarginal (f t))
-        charX_f charV_f (Set.Ioo 0 T_target) Set.univ := by
-      refine ⟨fun z _ => hf_ic z, ?_, ?_⟩
-      · intro t ht z _
-        have ht_lt_NT0 : t < (N : ℝ) * T_0 := lt_of_lt_of_le ht.2 hN_covers
-        exact ((hf_boundary z t ⟨le_of_lt ht.1, le_of_lt ht_lt_NT0⟩).1).hasDerivAt
-          (Icc_mem_nhds ht.1 ht_lt_NT0)
-      · intro t ht z _
-        have ht_lt_NT0 : t < (N : ℝ) * T_0 := lt_of_lt_of_le ht.2 hN_covers
-        exact ((hf_boundary z t ⟨le_of_lt ht.1, le_of_lt ht_lt_NT0⟩).2).hasDerivAt
-          (Icc_mem_nhds ht.1 ht_lt_NT0)
-    refine ⟨?_, charX_f, charV_f, ?_, ?_, ?_⟩
-    · -- IsVlasovSolutionOn: restrict Ioo 0 T_target ⊆ Ioo 0 (N·T_0)
-      intro φ hφ_smooth hφ_compact gradXφ gradVφ hgradXφ hgradVφ t ht
-      exact hf_vlasov φ hφ_smooth hφ_compact gradXφ gradVφ hgradXφ hgradVφ t
-        ⟨ht.1, lt_of_lt_of_le ht.2 hN_covers⟩
-    · exact hf_flow
-    · -- pushforward eq: restrict Icc 0 T_target ⊆ Icc 0 (N·T_0)
-      intro t ht
-      exact hf_push t ⟨ht.1, le_trans ht.2 hN_covers⟩
-    · -- AEMeasurable ∧ boundary ContinuousOn, restricted to Icc 0 T_target.
-      refine ⟨?_, ?_⟩
-      · intro s hs
-        exact hf_aemeas s ⟨hs.1, le_trans hs.2 hN_covers⟩
-      · intro z
-        have h_big : ContinuousOn (fun s => (charX_f s z, charV_f s z))
-            (Set.Icc 0 ((N : ℝ) * T_0)) := fun t ht =>
-          ((hf_boundary z t ht).1.continuousWithinAt).prodMk
-            ((hf_boundary z t ht).2.continuousWithinAt)
-        exact h_big.mono (fun t ht => ⟨ht.1, le_trans ht.2 hN_covers⟩)
+private alias vlasovWellPosedness_glue_boundary_seam :=
+  _root_.Vlasov.vlasovWellPosedness_glue_boundary_seam
 
 /-! ## Uniqueness over `IsLagrangianVlasovSolutionOn` per window -/
 -- Two Lagrangian solutions on `[0, T_target]` with the same initial measure