lean/OAI/Geometry/BallPacking/Flows/TimeSteps.lean

import Mathlib
import OAI.Geometry.BallPacking.Moser.RelativeForms

namespace OAI

noncomputable section
open scoped ContDiff Topology NNReal
open scoped ContDiff Topology
open Set Metric
open scoped ContDiff Topology
open Set Metric
namespace PackingSufficiencySupport.Hamiltonian
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] [CompleteSpace E]
def stepHomeomorph {L : ℝ≥0} (X : C(E,E)) (hX : LipschitzWith L X)
    [FiniteDimensional ℝ E] (hXs : ContDiff ℝ ∞ X) {h : ℝ} (hh : ‖h‖ * L < 1) : E ≃ₜ E where
  toFun := stepEndpoint X hX h
  invFun := stepEndpoint X hX (-h)
  left_inv := stepEndpoint_neg_leftInverse X hX hh
  right_inv := by
    have hh' : ‖-h‖ * L < 1 := by simpa using hh
    intro x
    simpa using stepEndpoint_neg_leftInverse X hX hh' x
  continuous_toFun := (stepEndpoint_smooth X hX hXs hh).continuous
  continuous_invFun := (stepEndpoint_smooth X hX hXs (h := -h) (by simpa using hh)).continuous


theorem fixedStep_of_zero {L : ℝ≥0} (X : C(E,E)) (hX : LipschitzWith L X)
    {h : ℝ} (hh : ‖h‖ * L < 1) {x : E} (hx : X x = 0) :
    fixedStep X hX h x = constantPath x := by
  apply (picard_contracts X hX (p := (x,h)) hh).fixedPoint_unique'
    (localPath_fixed X hX (p := (x,h)) hh)
  change constantPath x + h • pathIntegral (X.comp (constantPath x)) = constantPath x
  have hz : X.comp (constantPath x) = 0 := by ext t; exact hx
  rw [hz, map_zero, smul_zero, add_zero]

theorem stepEndpoint_of_zero {L : ℝ≥0} (X : C(E,E)) (hX : LipschitzWith L X)
    {h : ℝ} (hh : ‖h‖ * L < 1) {x : E} (hx : X x = 0) :
    stepEndpoint X hX h x = x := by
  simp only [stepEndpoint, fixedStep_of_zero X hX hh hx, constantPath_apply]

theorem stepEndpoint_hasCompactSupport {L : ℝ≥0} (X : C(E,E)) (hX : LipschitzWith L X)
    (hXc : HasCompactSupport X) {h : ℝ} (hh : ‖h‖ * L < 1) :
    HasCompactSupport (fun x => stepEndpoint X hX h x - x) := by
  apply hXc.mono
  intro x hx
  contrapose! hx
  simp only [Function.mem_support, not_not] at hx ⊢
  exact sub_eq_zero.mpr (stepEndpoint_of_zero X hX hh hx)


def clockField (X : C(ℝ × E,E)) : C(ℝ × E,ℝ × E) :=
  ⟨fun p => (1,X p), continuous_const.prodMk X.continuous⟩

omit [NormedSpace ℝ E] [CompleteSpace E] in
@[simp] theorem clockField_apply (X : C(ℝ × E,E)) (p : ℝ × E) :
    clockField X p = (1,X p) := rfl

omit [NormedSpace ℝ E] [CompleteSpace E] in
theorem clockField_lipschitz {L : ℝ≥0} (X : C(ℝ × E,E)) (hX : LipschitzWith L X) :
    LipschitzWith L (clockField X) := by
  apply LipschitzWith.of_dist_le_mul
  intro p q
  simpa only [clockField_apply, Prod.dist_eq, dist_self, max_eq_right dist_nonneg] using hX.dist_le_mul p q

omit [CompleteSpace E] in
theorem clockField_smooth (X : C(ℝ × E,E)) (hX : ContDiff ℝ ∞ X) :
    ContDiff ℝ ∞ (clockField X) := contDiff_const.prodMk hX

theorem fixedStep_clock {L : ℝ≥0} (X : C(ℝ × E,E)) (hX : LipschitzWith L X)
    {h : ℝ} (hh : ‖h‖ * L < 1) (p : ℝ × E) (s : Time) :
    (fixedStep (clockField X) (clockField_lipschitz X hX) h p s).1 = p.1 + h * (s : ℝ) := by
  let u := fixedStep (clockField X) (clockField_lipschitz X hX) h p
  have he := congrArg (fun v : C(Time,ℝ × E) => (v s).1)
    (fixedStep_equation (clockField X) (clockField_lipschitz X hX) hh p)
  have hi := (ContinuousLinearMap.fst ℝ ℝ E).intervalIntegral_comp_comm (μ := MeasureTheory.volume)
    ((extendPath ((clockField X).comp u)).continuous.intervalIntegrable 0 (s:ℝ))
  have hc : (fun t : ℝ => (extendPath ((clockField X).comp u) t).1) = fun _ => (1:ℝ) := by
    funext t
    rfl
  change (∫ t in 0..(s:ℝ), (extendPath ((clockField X).comp u) t).1) =
    (∫ t in 0..(s:ℝ), extendPath ((clockField X).comp u) t).1 at hi
  rw [hc] at hi
  change (u s).1 = p.1 + h * (∫ t in 0..(s:ℝ), extendPath ((clockField X).comp u) t).1 at he
  rw [← hi] at he
  simpa using he

@[simp] theorem stepEndpoint_clock {L : ℝ≥0} (X : C(ℝ × E,E)) (hX : LipschitzWith L X)
    {h : ℝ} (hh : ‖h‖ * L < 1) (p : ℝ × E) :
    (stepEndpoint (clockField X) (clockField_lipschitz X hX) h p).1 = p.1 + h := by
  simpa only [stepEndpoint,mul_one] using fixedStep_clock X hX hh p ⟨1,by simp⟩

def timeStep {L : ℝ≥0} (X : C(ℝ × E,E)) (hX : LipschitzWith L X) (h t : ℝ) (x : E) : E :=
  (stepEndpoint (clockField X) (clockField_lipschitz X hX) h (t,x)).2

theorem timeStep_smooth [FiniteDimensional ℝ E] {L : ℝ≥0}
    (X : C(ℝ × E,E)) (hX : LipschitzWith L X) (hXs : ContDiff ℝ ∞ X)
    {h : ℝ} (hh : ‖h‖ * L < 1) (t : ℝ) : ContDiff ℝ ∞ (timeStep X hX h t) :=
  ((stepEndpoint_smooth (clockField X) (clockField_lipschitz X hX)
    (clockField_smooth X hXs) hh).comp (contDiff_const.prodMk contDiff_id)).snd

theorem timeStep_inverse {L : ℝ≥0} (X : C(ℝ × E,E)) (hX : LipschitzWith L X)
    {h : ℝ} (hh : ‖h‖ * L < 1) (t : ℝ) :
    Function.LeftInverse (timeStep X hX (-h) (t+h)) (timeStep X hX h t) := by
  intro x
  have he := congrArg Prod.snd (stepEndpoint_neg_leftInverse (clockField X)
    (clockField_lipschitz X hX) hh (t,x))
  have hp : stepEndpoint (clockField X) (clockField_lipschitz X hX) h (t,x) =
      (t+h,timeStep X hX h t x) := by
    apply Prod.ext
    · exact stepEndpoint_clock X hX hh (t,x)
    · rfl
  rw [hp] at he
  exact he

def timeStepHomeomorph [FiniteDimensional ℝ E] {L : ℝ≥0}
    (X : C(ℝ × E,E)) (hX : LipschitzWith L X) (hXs : ContDiff ℝ ∞ X)
    {h : ℝ} (hh : ‖h‖ * L < 1) (t : ℝ) : E ≃ₜ E where
  toFun := timeStep X hX h t
  invFun := timeStep X hX (-h) (t+h)
  left_inv := timeStep_inverse X hX hh t
  right_inv := by
    intro x
    simpa only [neg_neg, add_neg_cancel_right] using
      timeStep_inverse X hX (h := -h) (by simpa using hh) (t+h) x
  continuous_toFun := (timeStep_smooth X hX hXs hh t).continuous
  continuous_invFun := (timeStep_smooth X hX hXs (h := -h) (by simpa using hh) (t+h)).continuous

end PackingSufficiencySupport.Hamiltonian

namespace PackingSufficiencySupport.Hamiltonian
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] [CompleteSpace E]
  [FiniteDimensional ℝ E]

theorem fixedStep_variation_clock {L : ℝ≥0} (X : C(ℝ × E,E))
    (hX : LipschitzWith L X) (hXs : ContDiff ℝ ∞ X) {h : ℝ} (hh : ‖h‖ * L < 1)
    (p : ℝ × E) (v : E) (s : Time) :
    ((fderiv ℝ (fixedStep (clockField X) (clockField_lipschitz X hX) h) p (0,v)) s).1 = 0 := by
  let u := fixedStep (clockField X) (clockField_lipschitz X hX) h
  have hu := ((fixedStep_smooth (clockField X) (clockField_lipschitz X hX)
    (clockField_smooth X hXs) hh).differentiable (by simp) p).hasFDerivAt
  have hd := (ContinuousLinearMap.fst ℝ ℝ E).hasFDerivAt.comp p
    ((ContinuousMap.evalCLM (M := ℝ × E) ℝ s).hasFDerivAt.comp p hu)
  have he : (fun q => (u q s).1) = fun q : ℝ × E => q.1 + h * (s:ℝ) := by
    funext q
    exact fixedStep_clock X hX hh q s
  change HasFDerivAt (fun q => (u q s).1) _ p at hd
  rw [he] at hd
  have hd' := (ContinuousLinearMap.fst ℝ ℝ E).hasFDerivAt.add_const (h * (s:ℝ)) (x := p)
  have huniq := congrArg (fun A : (ℝ × E) →L[ℝ] ℝ => A (0,v)) (hd.unique hd')
  exact huniq

theorem timeStep_fderiv {L : ℝ≥0} (X : C(ℝ × E,E)) (hX : LipschitzWith L X)
    (hXs : ContDiff ℝ ∞ X) {h : ℝ} (hh : ‖h‖ * L < 1) (t : ℝ) (x v : E) :
    fderiv ℝ (timeStep X hX h t) x v =
      (fderiv ℝ (stepEndpoint (clockField X) (clockField_lipschitz X hX) h) (t,x) (0,v)).2 := by
  have hs := ((stepEndpoint_smooth (clockField X) (clockField_lipschitz X hX)
    (clockField_smooth X hXs) hh).differentiable (by simp) (t,x)).hasFDerivAt
  have hp : HasFDerivAt (fun x : E => (t,x)) (ContinuousLinearMap.inr ℝ ℝ E) x :=
    (hasFDerivAt_const t x).prodMk (hasFDerivAt_id x)
  have hd := (ContinuousLinearMap.snd ℝ ℝ E).hasFDerivAt.comp x (hs.comp x hp)
  exact congrArg (fun A : E →L[ℝ] E => A v) hd.fderiv


omit [CompleteSpace E] [FiniteDimensional ℝ E] in
theorem clockField_fderiv {X : C(ℝ × E,E)} (hXs : ContDiff ℝ ∞ X) (p v : ℝ × E) :
    fderiv ℝ (clockField X) p v = (0, fderiv ℝ X p v) := by
  have hd := (hasFDerivAt_const (1:ℝ) p).prodMk
    ((hXs.differentiable (by simp) p).hasFDerivAt)
  exact congrArg (fun A : (ℝ × E) →L[ℝ] (ℝ × E) => A v) hd.fderiv

theorem timeStep_preserves_density {L : ℝ≥0} (X : C(ℝ × E,E))
    (hX : LipschitzWith L X) (hXs : ContDiff ℝ ∞ X)
    (ρ : ℝ × E → ℝ) (hρ : ContDiff ℝ ∞ ρ) (B : E →L[ℝ] E →L[ℝ] ℝ)
    (hPDE : ∀ p v w, fderiv ℝ ρ p (1,X p) * B v w +
      ρ p * (B (fderiv ℝ X p (0,v)) w + B v (fderiv ℝ X p (0,w))) = 0)
    {h : ℝ} (hh : ‖h‖ * L < 1) (t : ℝ) (x v w : E) :
    ρ (t+h,timeStep X hX h t x) *
      B (fderiv ℝ (timeStep X hX h t) x v) (fderiv ℝ (timeStep X hX h t) x w) =
      ρ (t,x) * B v w := by
  let Y := clockField X
  let hY := clockField_lipschitz X hX
  let u := fixedStep Y hY h (t,x)
  let A := fderiv ℝ (fixedStep Y hY h) (t,x)
  let D : C(Time,(ℝ × E) →L[ℝ] (ℝ × E)) :=
    ⟨fun s => fderiv ℝ Y (u s),
      ((clockField_smooth X hXs).continuous_fderiv (by simp)).comp u.continuous⟩
  have hA (z : ℝ × E) : A z = constantPath z + h • pathIntegral (pathLinear D (A z)) :=
    congrArg (fun T : (ℝ × E) →L[ℝ] C(Time,ℝ × E) => T z)
      (fixedStep_variation Y hY (clockField_smooth X hXs) hh (t,x))
  have hA0 (z : ℝ × E) : extendPath (A z) 0 = z := by
    have he := congrArg (fun V : C(Time,ℝ × E) => V ⟨0,by simp⟩) (hA z)
    exact (extendPath_coe (A z) ⟨0,by simp⟩).trans (by simpa using he)
  let V : E → ℝ → E := fun z s => (extendPath (A (0,z)) s).2
  have hhor (z : E) (s : ℝ) (hs : s ∈ Icc (0:ℝ) 1) :
      extendPath (A (0,z)) s = (0,V z s) := by
    apply Prod.ext
    · rw [show extendPath (A (0,z)) s = A (0,z) ⟨s,hs⟩ from extendPath_coe _ ⟨s,hs⟩]
      exact fixedStep_variation_clock X hX hXs hh (t,x) z ⟨s,hs⟩
    · rfl
  have hVd (z : E) (s : ℝ) (hs : s ∈ Icc (0:ℝ) 1) :
      HasDerivWithinAt (V z) (h • fderiv ℝ X (extendPath u s) (0,V z s)) (Icc (0:ℝ) 1) s := by
    have hd := (path_equation_derivative _ _ (0,z) h (hA (0,z)) hs).snd
    change HasDerivWithinAt (V z)
      (h • (fderiv ℝ Y (extendPath u s) (extendPath (A (0,z)) s)).2) _ s at hd
    rw [hhor z s hs,clockField_fderiv hXs] at hd
    exact hd
  let F : ℝ → ℝ := fun s => ρ (extendPath u s) * B (V v s) (V w s)
  have hFc : Continuous F := (hρ.continuous.comp (extendPath u).continuous).mul
    ((B.continuous.comp (extendPath (A (0,v))).continuous.snd).clm_apply
      (extendPath (A (0,w))).continuous.snd)
  have hFd (s : ℝ) (hs : s ∈ Ioo (0:ℝ) 1) : HasDerivAt F 0 s := by
    have hs' : s ∈ Icc (0:ℝ) 1 := ⟨hs.1.le,hs.2.le⟩
    have hUd := fixedStep_derivative Y hY hh (t,x) hs'
    have hρd := ((hρ.differentiable (by simp) (extendPath u s)).hasFDerivAt).comp_hasDerivWithinAt s hUd
    have hBd := ContinuousLinearMap.hasDerivWithinAt_of_bilinear (B := B)
      (hVd v s hs') (hVd w s hs')
    have hd := hρd.mul hBd
    have hz : fderiv ℝ ρ (extendPath u s) (h • Y (extendPath u s)) *
          B (V v s) (V w s) + ρ (extendPath u s) *
          (B (V v s) (h • fderiv ℝ X (extendPath u s) (0,V w s)) +
            B (h • fderiv ℝ X (extendPath u s) (0,V v s)) (V w s)) = 0 := by
      simp only [map_smul,smul_apply, smul_eq_mul]
      have he := hPDE (extendPath u s) (V v s) (V w s)
      change fderiv ℝ ρ (extendPath u s) (Y (extendPath u s)) * B (V v s) (V w s) +
        ρ (extendPath u s) * _ = 0 at he
      linear_combination h * he
    have hd0 : HasDerivWithinAt F 0 (Icc (0:ℝ) 1) s := hd.congr_deriv hz
    exact hd0.hasDerivAt (Icc_mem_nhds hs.1 hs.2)
  have hi := intervalIntegral.integral_eq_sub_of_hasDerivAt_of_le (by norm_num : (0:ℝ) ≤ 1)
    hFc.continuousOn hFd (intervalIntegrable_const (c := (0:ℝ)))
  have hend : F 1 = F 0 := sub_eq_zero.mp (by simpa using hi.symm)
  have hzero : F 0 = ρ (t,x) * B v w := by
    change ρ (extendPath u 0) * B (extendPath (A (0,v)) 0).2 (extendPath (A (0,w)) 0).2 = _
    rw [hA0,hA0,show extendPath u 0 = (t,x) from
      (extendPath_coe u ⟨0,by simp⟩).trans (fixedStep_initial Y hY hh (t,x))]
  have hfinal : extendPath u 1 = (t+h,timeStep X hX h t x) := by
    rw [show extendPath u 1 = u ⟨1,by simp⟩ from extendPath_coe u ⟨1,by simp⟩]
    exact Prod.ext (stepEndpoint_clock X hX hh (t,x)) rfl
  have hfinalV (z : E) : V z 1 = fderiv ℝ (timeStep X hX h t) x z := by
    rw [timeStep_fderiv X hX hXs hh, stepEndpoint_fderiv Y hY (clockField_smooth X hXs) hh]
    exact congrArg Prod.snd (extendPath_coe (A (0,z)) ⟨1,by simp⟩)
  have hone : F 1 = ρ (t+h,timeStep X hX h t x) *
      B (fderiv ℝ (timeStep X hX h t) x v) (fderiv ℝ (timeStep X hX h t) x w) := by
    change ρ (extendPath u 1) * B (V v 1) (V w 1) = _
    rw [hfinal,hfinalV,hfinalV]
  exact hone.symm.trans (hend.trans hzero)

end PackingSufficiencySupport.Hamiltonian

namespace PackingSufficiencySupport.Hamiltonian
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] [CompleteSpace E]

theorem timeStep_of_stationary {L : ℝ≥0} (X : C(ℝ × E,E)) (hX : LipschitzWith L X)
    {h : ℝ} (hh : ‖h‖ * L < 1) (t : ℝ) {x : E} (hx : ∀ s, X (s,x) = 0) :
    timeStep X hX h t x = x := by
  let q : C(Time,ℝ × E) := constantPath (t,x) + h • pathIntegral (constantPath (1,0))
  have hq (s : Time) : q s = (t+h*(s:ℝ),x) := by
    change (t,x) + h • (∫ a in (0:ℝ)..(s:ℝ), extendPath (constantPath (1,0)) a) = _
    have he : (fun a : ℝ => extendPath (constantPath ((1:ℝ),(0:E))) a) = fun _ => ((1:ℝ),(0:E)) := rfl
    rw [he,intervalIntegral.integral_const]
    simp
  have hy : (clockField X).comp q = constantPath (1,0) := by
    apply ContinuousMap.ext
    intro s
    change clockField X (q s) = (1,0)
    rw [hq,clockField_apply,hx]
  have hu : fixedStep (clockField X) (clockField_lipschitz X hX) h (t,x) = q := by
    apply (picard_contracts (clockField X) (clockField_lipschitz X hX) (p := ((t,x),h)) hh).fixedPoint_unique'
      (localPath_fixed (clockField X) (clockField_lipschitz X hX) (p := ((t,x),h)) hh)
    change constantPath (t,x) + h • pathIntegral ((clockField X).comp q) = q
    rw [hy]
  change (fixedStep (clockField X) (clockField_lipschitz X hX) h (t,x) ⟨1,by simp⟩).2 = x
  rw [hu,hq]

end PackingSufficiencySupport.Hamiltonian

namespace PackingSufficiencySupport.Hamiltonian
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] [CompleteSpace E]
  [FiniteDimensional ℝ E]

def timeSteps {L : ℝ≥0} (X : C(ℝ × E,E)) (hX : LipschitzWith L X)
    (hXs : ContDiff ℝ ∞ X) {h : ℝ} (hh : ‖h‖ * L < 1) (t : ℝ) : ℕ → E ≃ₜ E
  | 0 => Homeomorph.refl E
  | N+1 => (timeSteps X hX hXs hh t N).trans (timeStepHomeomorph X hX hXs hh (t+N*h))

theorem timeSteps_smooth {L : ℝ≥0} (X : C(ℝ × E,E)) (hX : LipschitzWith L X)
    (hXs : ContDiff ℝ ∞ X) {h : ℝ} (hh : ‖h‖ * L < 1) (t : ℝ) (N : ℕ) :
    ContDiff ℝ ∞ (timeSteps X hX hXs hh t N) ∧
      ContDiff ℝ ∞ (timeSteps X hX hXs hh t N).symm := by
  induction N with
  | zero => exact ⟨contDiff_id,contDiff_id⟩
  | succ N ih =>
    constructor
    · exact (timeStep_smooth X hX hXs hh (t+N*h)).comp ih.1
    · exact ih.2.comp (timeStep_smooth X hX hXs (h := -h) (by simpa using hh) ((t+N*h)+h))

theorem timeSteps_of_stationary {L : ℝ≥0} (X : C(ℝ × E,E)) (hX : LipschitzWith L X)
    (hXs : ContDiff ℝ ∞ X) {h : ℝ} (hh : ‖h‖ * L < 1) (t : ℝ) (N : ℕ)
    {x : E} (hx : ∀ s, X (s,x) = 0) : timeSteps X hX hXs hh t N x = x := by
  induction N with
  | zero => rfl
  | succ N ih =>
    change timeStep X hX h (t+N*h) (timeSteps X hX hXs hh t N x) = x
    rw [ih,timeStep_of_stationary X hX hh _ hx]

theorem timeSteps_preserves_density {L : ℝ≥0} (X : C(ℝ × E,E))
    (hX : LipschitzWith L X) (hXs : ContDiff ℝ ∞ X)
    (ρ : ℝ × E → ℝ) (hρ : ContDiff ℝ ∞ ρ) (B : E →L[ℝ] E →L[ℝ] ℝ)
    (hPDE : ∀ p v w, fderiv ℝ ρ p (1,X p) * B v w +
      ρ p * (B (fderiv ℝ X p (0,v)) w + B v (fderiv ℝ X p (0,w))) = 0)
    {h : ℝ} (hh : ‖h‖ * L < 1) (t : ℝ) (N : ℕ) (x v w : E) :
    ρ (t+N*h,timeSteps X hX hXs hh t N x) *
      B (fderiv ℝ (timeSteps X hX hXs hh t N) x v)
        (fderiv ℝ (timeSteps X hX hXs hh t N) x w) = ρ (t,x) * B v w := by
  induction N with
  | zero => simp [timeSteps]
  | succ N ih =>
    let F := timeSteps X hX hXs hh t N
    let G := timeStep X hX h (t+N*h)
    have hF : Differentiable ℝ F := (timeSteps_smooth X hX hXs hh t N).1.differentiable (by simp)
    have hG : Differentiable ℝ G := (timeStep_smooth X hX hXs hh (t+N*h)).differentiable (by simp)
    change ρ (t+(N+1:ℕ)*h,G (F x)) *
      B (fderiv ℝ (G ∘ F) x v) (fderiv ℝ (G ∘ F) x w) = _
    rw [fderiv_comp x (hG (F x)) (hF x)]
    have ht : t + (N+1:ℕ)*h = (t+N*h)+h := by push_cast; ring
    rw [ht]
    exact (timeStep_preserves_density X hX hXs ρ hρ B hPDE hh (t+N*h) (F x)
      (fderiv ℝ F x v) (fderiv ℝ F x w)).trans ih

theorem exists_density_transport {L : ℝ≥0} (X : C(ℝ × E,E))
    (hX : LipschitzWith L X) (hXs : ContDiff ℝ ∞ X)
    (ρ : ℝ × E → ℝ) (hρ : ContDiff ℝ ∞ ρ) (B : E →L[ℝ] E →L[ℝ] ℝ)
    (hPDE : ∀ p v w, fderiv ℝ ρ p (1,X p) * B v w +
      ρ p * (B (fderiv ℝ X p (0,v)) w + B v (fderiv ℝ X p (0,w))) = 0)
    (K : Set E) (hK : IsCompact K) (hXspt : ∀ s x, x ∉ K → X (s,x) = 0)
    (t T : ℝ) : ∃ Φ : E ≃ₜ E, ContDiff ℝ ∞ Φ ∧ ContDiff ℝ ∞ Φ.symm ∧
      (∀ x, x ∉ K → Φ x = x) ∧ HasCompactSupport (fun x => Φ x - x) ∧
      (∀ x v w, ρ (t+T,Φ x) * B (fderiv ℝ Φ x v) (fderiv ℝ Φ x w) = ρ (t,x) * B v w) := by
  obtain ⟨N,hN⟩ := exists_nat_gt (‖T‖ * L)
  have hN0 : (0:ℝ) < N := (mul_nonneg (norm_nonneg _) L.coe_nonneg).trans_lt hN
  let h := T / N
  have hh : ‖h‖ * L < 1 := by
    change ‖T / (N:ℝ)‖ * L < 1
    rw [norm_div,Real.norm_of_nonneg hN0.le, div_mul_eq_mul_div]
    exact (div_lt_one hN0).mpr hN
  have he : (N:ℝ) * h = T := by dsimp [h]; field_simp
  let Φ := timeSteps X hX hXs hh t N
  have hfix (x : E) (hx : x ∉ K) : Φ x = x :=
    timeSteps_of_stationary X hX hXs hh t N (fun s => hXspt s x hx)
  refine ⟨Φ,(timeSteps_smooth X hX hXs hh t N).1,
    (timeSteps_smooth X hX hXs hh t N).2,hfix,?_,?_⟩
  · exact HasCompactSupport.intro hK (fun x hx => sub_eq_zero.mpr (hfix x hx))
  · intro x v w
    simpa only [he] using timeSteps_preserves_density X hX hXs ρ hρ B hPDE hh t N x v w

end PackingSufficiencySupport.Hamiltonian

namespace PackingSufficiencySupport.Hamiltonian

def segmentLinear : (ℝ × ℝ) →L[ℝ] C(Time,ℝ × ℝ) :=
  LinearMap.mkContinuous {
    toFun := fun p => ⟨fun s => ((s : ℝ) * p.1,p.2),
      (continuous_subtype_val.mul continuous_const).prodMk continuous_const⟩
    map_add' := by intros; ext s <;> simp [mul_add]
    map_smul' := by intros; ext s <;> simp [mul_left_comm] }
    1 (by
      intro p
      rw [one_mul]
      apply (ContinuousMap.norm_le _ (norm_nonneg p)).mpr
      intro s
      change ‖((s:ℝ)*p.1,p.2)‖ ≤ ‖p‖
      simp only [Prod.norm_def, norm_mul, Real.norm_eq_abs, abs_of_nonneg s.property.1]
      apply max_le
      · exact (mul_le_of_le_one_left (abs_nonneg p.1)
          (by simpa only [abs_of_nonneg s.property.1] using s.property.2)).trans (le_max_left _ _)
      · exact le_max_right _ _)

def segmentPath (a : ℝ) (p : ℝ × ℝ) : C(Time,ℝ × ℝ) :=
  constantPath (a,0) + segmentLinear (p - (a,0))

@[simp] theorem segmentPath_apply (a : ℝ) (p : ℝ × ℝ) (s : Time) :
    segmentPath a p s = (a + (s : ℝ) * (p.1-a),p.2) := by
  change (a + (s:ℝ)*(p.1-a),0+(p.2-0)) = _
  simp

theorem segmentPath_smooth (a : ℝ) : ContDiff ℝ ∞ (segmentPath a) :=
  contDiff_const.add (segmentLinear.contDiff.comp (contDiff_id.sub contDiff_const))

def pathAverage : C(Time,ℝ) →L[ℝ] ℝ :=
  (ContinuousMap.evalCLM ℝ (⟨1,by simp⟩ : Time)).comp pathIntegral

theorem segment_integral_eq (f : ℝ × ℝ → ℝ) (hf : Continuous f) (a : ℝ) (p : ℝ × ℝ) :
    (∫ x in a..p.1, f (x,p.2)) =
      (p.1-a) * pathAverage ((⟨f,hf⟩ : C(ℝ × ℝ,ℝ)).comp (segmentPath a p)) := by
  let u := (⟨f,hf⟩ : C(ℝ × ℝ,ℝ)).comp (segmentPath a p)
  have he : (∫ s in (0:ℝ)..1, extendPath u s) = ∫ s in (0:ℝ)..1, f (a+s*(p.1-a),p.2) := by
    apply intervalIntegral.integral_congr
    intro s hs
    rw [uIcc_of_le (by norm_num : (0:ℝ) ≤ 1)] at hs
    change extendPath u s = f (a+s*(p.1-a),p.2)
    rw [show extendPath u s = u ⟨s,hs⟩ from extendPath_coe u ⟨s,hs⟩]
    change f (segmentPath a p ⟨s,hs⟩) = _
    rw [segmentPath_apply]
  change _ = (p.1-a) * (∫ s in (0:ℝ)..1, extendPath u s)
  rw [he]
  have hi := intervalIntegral.smul_integral_comp_add_mul (fun x => f (x,p.2))
    (a := (0:ℝ)) (b := 1) (p.1-a) a
  simpa only [smul_eq_mul, mul_zero, mul_one, add_zero, add_sub_cancel, mul_comm] using hi.symm

theorem contDiff_segment_integral {f : ℝ × ℝ → ℝ} (hf : ContDiff ℝ ∞ f) (a : ℝ) :
    ContDiff ℝ ∞ (fun p : ℝ × ℝ => ∫ x in a..p.1, f (x,p.2)) := by
  have he : (fun p : ℝ × ℝ => ∫ x in a..p.1, f (x,p.2)) =
      fun p => (p.1-a) * pathAverage ((⟨f,hf.continuous⟩ : C(ℝ × ℝ,ℝ)).comp (segmentPath a p)) := by
    funext p
    exact segment_integral_eq f hf.continuous a p
  rw [he]
  exact (contDiff_fst.sub contDiff_const).mul
    (pathAverage.contDiff.comp ((postcomp_contDiff hf).comp (segmentPath_smooth a)))

def planarMarginal (A : ℝ) (f : ℝ × ℝ → ℝ) (t : ℝ) : ℝ :=
  ∫ x in -A..A, f (x,t)

def planarPrimitiveX (A : ℝ) (f : ℝ × ℝ → ℝ) (ρ : ℝ → ℝ) (p : ℝ × ℝ) : ℝ :=
  -ρ p.1 * ∫ t in -A..p.2, planarMarginal A f t

def planarPrimitiveY (A : ℝ) (f : ℝ × ℝ → ℝ) (ρ : ℝ → ℝ) (p : ℝ × ℝ) : ℝ :=
  ∫ x in -A..p.1, f (x,p.2) - ρ x * planarMarginal A f p.2

theorem planarMarginal_smooth {f : ℝ × ℝ → ℝ} (hf : ContDiff ℝ ∞ f) (A : ℝ) :
    ContDiff ℝ ∞ (planarMarginal A f) :=
  (contDiff_segment_integral hf (-A)).comp (contDiff_const.prodMk contDiff_id)

theorem planarPrimitive_smooth {f : ℝ × ℝ → ℝ} (hf : ContDiff ℝ ∞ f)
    {ρ : ℝ → ℝ} (hρ : ContDiff ℝ ∞ ρ) (A : ℝ) :
    ContDiff ℝ ∞ (planarPrimitiveX A f ρ) ∧ ContDiff ℝ ∞ (planarPrimitiveY A f ρ) := by
  have hg := planarMarginal_smooth hf A
  have hG : ContDiff ℝ ∞ (fun p : ℝ × ℝ => ∫ t in -A..p.2, planarMarginal A f t) := by
    exact (contDiff_segment_integral (hg.comp contDiff_fst) (-A)).comp
      (contDiff_snd.prodMk contDiff_fst)
  exact ⟨(hρ.comp contDiff_fst).neg.mul hG,
    contDiff_segment_integral (hf.sub ((hρ.comp contDiff_fst).mul (hg.comp contDiff_snd))) (-A)⟩

theorem planarPrimitive_curl {A : ℝ} {f : ℝ × ℝ → ℝ} (hf : Continuous f)
    {ρ : ℝ → ℝ} (hρ : Continuous ρ) (hg : Continuous (planarMarginal A f)) (p : ℝ × ℝ) :
    deriv (fun x => planarPrimitiveY A f ρ (x,p.2)) p.1 -
      deriv (fun t => planarPrimitiveX A f ρ (p.1,t)) p.2 = f p := by
  have hc : Continuous (fun x => f (x,p.2) - ρ x * planarMarginal A f p.2) :=
    (hf.comp (continuous_id.prodMk continuous_const)).sub (hρ.mul continuous_const)
  have hY := intervalIntegral.integral_hasDerivAt_right (hc.intervalIntegrable (-A) p.1)
    hc.aestronglyMeasurable.stronglyMeasurableAtFilter hc.continuousAt
  have hG := intervalIntegral.integral_hasDerivAt_right (hg.intervalIntegrable (-A) p.2)
    hg.aestronglyMeasurable.stronglyMeasurableAtFilter hg.continuousAt
  have hX := hG.const_mul (-ρ p.1)
  change deriv (fun x => ∫ v in -A..x, f (v,p.2) - ρ v * planarMarginal A f p.2) p.1 -
    deriv (fun t => -ρ p.1 * ∫ v in -A..t, planarMarginal A f v) p.2 = _
  rw [hY.deriv, hX.deriv]
  ring

theorem interval_primitive_zero_outside {A : ℝ} (hA : 0 ≤ A) {g : ℝ → ℝ}
    (hg : Continuous g) (hgs : ∀ x, A ≤ |x| → g x = 0)
    (hg0 : (∫ x in -A..A, g x) = 0) {t : ℝ} (ht : A ≤ |t|) :
    (∫ x in -A..t, g x) = 0 := by
  rcases le_abs.mp ht with ht | ht
  · have hi := intervalIntegral.integral_add_adjacent_intervals (μ := MeasureTheory.volume)
      (hg.intervalIntegrable (-A) A) (hg.intervalIntegrable A t)
    have hz : (∫ x in A..t, g x) = 0 := by
      have he : (∫ x in A..t, g x) = ∫ x in A..t, (0:ℝ) := by
        apply intervalIntegral.integral_congr
        intro x hx
        rw [uIcc_of_le ht] at hx
        exact hgs x (hx.1.trans (le_abs_self x))
      simpa using he
    rw [hg0,hz,zero_add] at hi
    exact hi.symm
  · have hta : t ≤ -A := by linarith
    have hz : (∫ x in -A..t, g x) = ∫ x in -A..t, (0:ℝ) := by
      apply intervalIntegral.integral_congr
      intro x hx
      rw [uIcc_of_ge hta] at hx
      apply hgs x
      rw [abs_of_nonpos (hx.2.trans (neg_nonpos.mpr hA))]
      linarith [hx.2]
    simpa using hz

theorem planarPrimitive_support {A : ℝ} (hA : 0 ≤ A) {f : ℝ × ℝ → ℝ}
    (hf : Continuous f) {ρ : ℝ → ℝ} (hρ : Continuous ρ)
    (hfs : ∀ x t, A ≤ |x| ∨ A ≤ |t| → f (x,t) = 0)
    (hρs : ∀ x, A ≤ |x| → ρ x = 0)
    (hρ1 : (∫ x in -A..A, ρ x) = 1)
    (hg : Continuous (planarMarginal A f))
    (hf0 : (∫ t in -A..A, planarMarginal A f t) = 0) :
    HasCompactSupport (planarPrimitiveX A f ρ) ∧
      HasCompactSupport (planarPrimitiveY A f ρ) := by
  have hgt (t : ℝ) (ht : A ≤ |t|) : planarMarginal A f t = 0 := by
    unfold planarMarginal
    have he : (fun x => f (x,t)) = fun _ => (0:ℝ) := by
      funext x
      exact hfs x t (Or.inr ht)
    rw [he,intervalIntegral.integral_zero]
  have hF (t : ℝ) : (∫ x in -A..A, f (x,t) - ρ x * planarMarginal A f t) = 0 := by
    have hc : Continuous (fun x => f (x,t)) := hf.comp (continuous_id.prodMk continuous_const)
    have hd : Continuous (fun x => ρ x * planarMarginal A f t) := hρ.mul continuous_const
    rw [intervalIntegral.integral_sub (hc.intervalIntegrable (-A) A)
      (hd.intervalIntegrable (-A) A)]
    rw [intervalIntegral.integral_mul_const, hρ1, one_mul]
    exact sub_self _
  have hzero (p : ℝ × ℝ) (hp : A ≤ |p.1| ∨ A ≤ |p.2|) :
      planarPrimitiveX A f ρ p = 0 ∧ planarPrimitiveY A f ρ p = 0 := by
    rcases hp with hp | hp
    · constructor
      · simp [planarPrimitiveX, hρs _ hp]
      · apply interval_primitive_zero_outside hA
          ((hf.comp (continuous_id.prodMk continuous_const)).sub (hρ.mul continuous_const))
          (fun x hx => by
            change f (x,p.2) - ρ x * planarMarginal A f p.2 = 0
            rw [hfs x p.2 (Or.inl hx),hρs x hx]; ring) (hF p.2) hp
    · constructor
      · unfold planarPrimitiveX
        rw [interval_primitive_zero_outside hA hg hgt hf0 hp, mul_zero]
      · unfold planarPrimitiveY
        have he : (fun x => f (x,p.2) - ρ x * planarMarginal A f p.2) = fun _ => (0:ℝ) := by
          funext x
          rw [hfs x p.2 (Or.inr hp), hgt p.2 hp]
          ring
        rw [he,intervalIntegral.integral_zero]
  have hK : IsCompact (Icc (-A,-A) (A,A) : Set (ℝ × ℝ)) := isCompact_Icc
  have hout (p : ℝ × ℝ) (hp : p ∉ Icc (-A,-A) (A,A)) : A ≤ |p.1| ∨ A ≤ |p.2| := by
    by_contra! ht
    apply hp
    have hx := abs_lt.mp ht.1
    have hy := abs_lt.mp ht.2
    exact ⟨⟨hx.1.le,hy.1.le⟩,⟨hx.2.le,hy.2.le⟩⟩
  exact ⟨HasCompactSupport.intro hK (fun p hp => (hzero p (hout p hp)).1),
    HasCompactSupport.intro hK (fun p hp => (hzero p (hout p hp)).2)⟩

open MeasureTheory Function

theorem integral_eq_full_of_box_support {A : ℝ} {g : ℝ → ℝ}
    (hgs : ∀ x, A ≤ |x| → g x = 0) : (∫ x in -A..A, g x) = ∫ x, g x := by
  apply intervalIntegral.integral_eq_integral_of_support_subset
  intro x hx
  have hx' : |x| < A := by
    by_contra! ha
    exact hx (hgs x ha)
  exact ⟨(abs_lt.mp hx').1,(abs_lt.mp hx').2.le⟩

end PackingSufficiencySupport.Hamiltonian
end

end OAI