lean/OAI/Geometry/BallPacking/Models/DisjointClocks.lean

import Mathlib
import OAI.Geometry.BallPacking.Hamiltonian.LiftedCompact

namespace OAI

noncomputable section

namespace PackingSufficiencySupport.Hamiltonian
open scoped ContDiff Topology
open Set Function

def firstClock (t : ℝ) : ℝ := Real.smoothTransition (3*t)
def secondClock (t : ℝ) : ℝ := Real.smoothTransition (3*t-2)

@[fun_prop] theorem firstClock_smooth : ContDiff ℝ ∞ firstClock := by
  exact Real.smoothTransition.contDiff.comp (contDiff_const.mul contDiff_id)
@[fun_prop] theorem secondClock_smooth : ContDiff ℝ ∞ secondClock := by
  exact Real.smoothTransition.contDiff.comp ((contDiff_const.mul contDiff_id).sub contDiff_const)

@[simp] theorem firstClock_zero : firstClock 0 = 0 := by
  exact Real.smoothTransition.zero_of_nonpos (by norm_num)
@[simp] theorem secondClock_zero : secondClock 0 = 0 := by
  exact Real.smoothTransition.zero_of_nonpos (by norm_num)
@[simp] theorem firstClock_one : firstClock 1 = 1 := by
  exact Real.smoothTransition.one_of_one_le (by norm_num)
@[simp] theorem secondClock_one : secondClock 1 = 1 := by
  exact Real.smoothTransition.one_of_one_le (by norm_num)

theorem secondClock_locally_zero {t : ℝ} (ht : t < 2/3) :
    secondClock =ᶠ[𝓝 t] fun _ => 0 := by
  filter_upwards [Iio_mem_nhds ht] with s hs
  change s < 2/3 at hs
  exact Real.smoothTransition.zero_of_nonpos (by linarith)

theorem firstClock_locally_one {t : ℝ} (ht : 1/3 < t) :
    firstClock =ᶠ[𝓝 t] fun _ => 1 := by
  filter_upwards [Ioi_mem_nhds ht] with s hs
  change 1/3 < s at hs
  exact Real.smoothTransition.one_of_one_le (by linarith)

theorem secondClock_deriv_zero {t : ℝ} (ht : t < 2/3) : deriv secondClock t = 0 :=
  ((hasDerivAt_const t (0:ℝ)).congr_of_eventuallyEq (secondClock_locally_zero ht)).deriv

theorem firstClock_deriv_zero {t : ℝ} (ht : 1/3 < t) : deriv firstClock t = 0 :=
  ((hasDerivAt_const t (1:ℝ)).congr_of_eventuallyEq (firstClock_locally_one ht)).deriv

theorem firstClock_deriv_compact : HasCompactSupport (deriv firstClock) := by
  apply HasCompactSupport.intro (isCompact_Icc (a := (0:ℝ)) (b := 1))
  intro t ht
  have hor : t < 0 ∨ 1 < t := by simpa only [mem_Icc,not_and_or,not_le] using ht
  rcases hor with ht | ht
  · have he : firstClock =ᶠ[𝓝 t] fun _ => (0:ℝ) := by
      filter_upwards [Iio_mem_nhds ht] with s hs
      change s < 0 at hs
      exact Real.smoothTransition.zero_of_nonpos (by linarith)
    exact ((hasDerivAt_const t (0:ℝ)).congr_of_eventuallyEq he).deriv
  · exact firstClock_deriv_zero (by linarith)

theorem secondClock_deriv_compact : HasCompactSupport (deriv secondClock) := by
  apply HasCompactSupport.intro (isCompact_Icc (a := (0:ℝ)) (b := 1))
  intro t ht
  have hor : t < 0 ∨ 1 < t := by simpa only [mem_Icc,not_and_or,not_le] using ht
  rcases hor with ht | ht
  · exact secondClock_deriv_zero (by linarith)
  · have he : secondClock =ᶠ[𝓝 t] fun _ => (1:ℝ) := by
      filter_upwards [Ioi_mem_nhds ht] with s hs
      change 1 < s at hs
      exact Real.smoothTransition.one_of_one_le (by linarith)
    exact ((hasDerivAt_const t (1:ℝ)).congr_of_eventuallyEq he).deriv

variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
variable {A : E →L[ℝ] E →L[ℝ] ℝ}
namespace CompactHamiltonianIsotopy

def concatMap (Φ Ψ : CompactHamiltonianIsotopy A) (t : ℝ) : E ≃ₜ E :=
  (Ψ.map (firstClock t)).trans (Φ.map (secondClock t))

def concatHamiltonian (Φ Ψ : CompactHamiltonianIsotopy A) : ℝ × E → ℝ :=
  reparamHamiltonian Ψ.hamiltonian firstClock + reparamHamiltonian Φ.hamiltonian secondClock

theorem concatHamiltonian_smooth (Φ Ψ : CompactHamiltonianIsotopy A) :
    ContDiff ℝ ∞ (concatHamiltonian Φ Ψ) :=
  (reparamHamiltonian_smooth Ψ.hamiltonian_smooth firstClock_smooth).add
    (reparamHamiltonian_smooth Φ.hamiltonian_smooth secondClock_smooth)

theorem concatHamiltonian_compact (Φ Ψ : CompactHamiltonianIsotopy A) :
    HasCompactSupport (concatHamiltonian Φ Ψ) :=
  (reparamHamiltonian_compact Ψ.compact firstClock firstClock_deriv_compact).add
    (reparamHamiltonian_compact Φ.compact secondClock secondClock_deriv_compact)

theorem concatMap_smooth (Φ Ψ : CompactHamiltonianIsotopy A) :
    ContDiff ℝ ∞ (fun p : ℝ × E => concatMap Φ Ψ p.1 p.2) :=
  Φ.smooth.comp ((secondClock_smooth.comp contDiff_fst).prodMk
    (Ψ.smooth.comp ((firstClock_smooth.comp contDiff_fst).prodMk contDiff_snd)))

theorem concatMap_inverse_smooth (Φ Ψ : CompactHamiltonianIsotopy A) :
    ContDiff ℝ ∞ (fun p : ℝ × E => (concatMap Φ Ψ p.1).symm p.2) :=
  Ψ.inverse_smooth.comp ((firstClock_smooth.comp contDiff_fst).prodMk
    (Φ.inverse_smooth.comp ((secondClock_smooth.comp contDiff_fst).prodMk contDiff_snd)))

@[simp] theorem concatMap_zero (Φ Ψ : CompactHamiltonianIsotopy A) :
    concatMap Φ Ψ 0 = Homeomorph.refl E := by
  simp only [concatMap,firstClock_zero,secondClock_zero,Φ.zero,Ψ.zero]
  rfl

@[simp] theorem concatMap_one (Φ Ψ : CompactHamiltonianIsotopy A) (x : E) :
    concatMap Φ Ψ 1 x = Φ.map 1 (Ψ.map 1 x) := by
  simp only [concatMap,firstClock_one,secondClock_one,Homeomorph.trans_apply]

theorem concatMap_flow (Φ Ψ : CompactHamiltonianIsotopy A) (t : ℝ) (x : E) :
    HasDerivAt (fun s => concatMap Φ Ψ s x)
      (hamiltonianField A (concatHamiltonian Φ Ψ) (t,concatMap Φ Ψ t x)) t := by
  rw [concatHamiltonian,hamiltonianField_add
    (A := A) (reparamHamiltonian_smooth Ψ.hamiltonian_smooth firstClock_smooth)
    (reparamHamiltonian_smooth Φ.hamiltonian_smooth secondClock_smooth),
    hamiltonianField_reparam A Ψ.hamiltonian_smooth firstClock_smooth,
    hamiltonianField_reparam A Φ.hamiltonian_smooth secondClock_smooth]
  by_cases ht : t ≤ 1/2
  · have ht' : t < 2/3 := by linarith
    have he : (fun s => concatMap Φ Ψ s x) =ᶠ[𝓝 t]
        (fun s => Ψ.map (firstClock s) x) := by
      filter_upwards [secondClock_locally_zero ht'] with s hs
      simp only [concatMap,Homeomorph.trans_apply,hs,Φ.zero,Homeomorph.refl_apply,id_eq]
    rw [secondClock_deriv_zero ht',zero_smul,add_zero,he.eq_of_nhds]
    exact ((Ψ.flow (firstClock t) x).scomp t
      ((firstClock_smooth.differentiable (by simp) t).hasDerivAt)).congr_of_eventuallyEq he
  · have ht' : 1/3 < t := by linarith
    have he : (fun s => concatMap Φ Ψ s x) =ᶠ[𝓝 t]
        (fun s => Φ.map (secondClock s) (Ψ.map 1 x)) := by
      filter_upwards [firstClock_locally_one ht'] with s hs
      simp only [concatMap,Homeomorph.trans_apply,hs]
    rw [firstClock_deriv_zero ht',zero_smul,zero_add,he.eq_of_nhds]
    exact ((Φ.flow (secondClock t) (Ψ.map 1 x)).scomp t
      ((secondClock_smooth.differentiable (by simp) t).hasDerivAt)).congr_of_eventuallyEq he

theorem concatMap_symplectic (Φ Ψ : CompactHamiltonianIsotopy A) (t : ℝ) (x v w : E) :
    A (fderiv ℝ (concatMap Φ Ψ t) x v) (fderiv ℝ (concatMap Φ Ψ t) x w) = A v w := by
  change A (fderiv ℝ ((Φ.map (secondClock t)) ∘ (Ψ.map (firstClock t))) x v)
    (fderiv ℝ ((Φ.map (secondClock t)) ∘ (Ψ.map (firstClock t))) x w) = _
  rw [fderiv_comp x ((Φ.map_smooth _).differentiable (by simp) _)
    ((Ψ.map_smooth _).differentiable (by simp) x)]
  simp only [ContinuousLinearMap.comp_apply,Φ.symplectic,Ψ.symplectic]

variable [CompleteSpace E] [FiniteDimensional ℝ E]

def after (hA : A.IsInvertible) (hskew : ∀ v w, A v w = -A w v)
    (Φ Ψ : CompactHamiltonianIsotopy A) : CompactHamiltonianIsotopy A where
  map := concatMap Φ Ψ
  smooth := concatMap_smooth Φ Ψ
  inverse_smooth := concatMap_inverse_smooth Φ Ψ
  zero := concatMap_zero Φ Ψ
  hamiltonian := concatHamiltonian Φ Ψ
  hamiltonian_smooth := concatHamiltonian_smooth Φ Ψ
  compact := concatHamiltonian_compact Φ Ψ
  flow := concatMap_flow Φ Ψ
  symplectic := concatMap_symplectic Φ Ψ
  fixed := by
    intro t x hx
    have hx' : concatMap Φ Ψ 0 x ∉ Prod.snd '' tsupport (concatHamiltonian Φ Ψ) := by
      simpa only [concatMap_zero,Homeomorph.refl_apply,id_eq] using hx
    have he := hamiltonian_trajectory_fixed hA hskew (concatHamiltonian_smooth Φ Ψ)
      (concatHamiltonian_compact Φ Ψ)
      ((concatMap_smooth Φ Ψ).continuous.comp (continuous_id.prodMk continuous_const))
      (fun t => concatMap_flow Φ Ψ t x) hx' t
    change concatMap Φ Ψ t x = concatMap Φ Ψ 0 x at he
    simpa only [concatMap_zero,Homeomorph.refl_apply,id_eq] using he

omit [CompleteSpace E] [FiniteDimensional ℝ E] in
theorem concatMap_preserves (Φ Ψ : CompactHamiltonianIsotopy A) {S : Set E}
    (hΦ : ∀ t x, Φ.map t x ∈ S ↔ x ∈ S) (hΨ : ∀ t x, Ψ.map t x ∈ S ↔ x ∈ S)
    (t : ℝ) (x : E) : concatMap Φ Ψ t x ∈ S ↔ x ∈ S := by
  exact (hΦ _ _).trans (hΨ _ _)

omit [CompleteSpace E] [FiniteDimensional ℝ E] in
theorem concatHamiltonian_face (Φ Ψ : CompactHamiltonianIsotopy A) (q : E → ℝ)
    {c ρ : ℝ}
    (hΦ : ∀ t x, c-q x < ρ → fderiv ℝ q x (hamiltonianField A Φ.hamiltonian (t,x)) = 0)
    (hΨ : ∀ t x, c-q x < ρ → fderiv ℝ q x (hamiltonianField A Ψ.hamiltonian (t,x)) = 0)
    (t : ℝ) (x : E) (hx : c-q x < ρ) :
    fderiv ℝ q x (hamiltonianField A (concatHamiltonian Φ Ψ) (t,x)) = 0 := by
  rw [concatHamiltonian,hamiltonianField_add A
    (reparamHamiltonian_smooth Ψ.hamiltonian_smooth firstClock_smooth)
    (reparamHamiltonian_smooth Φ.hamiltonian_smooth secondClock_smooth),
    hamiltonianField_reparam A Ψ.hamiltonian_smooth firstClock_smooth,
    hamiltonianField_reparam A Φ.hamiltonian_smooth secondClock_smooth,map_add,map_smul,map_smul,
    hΦ _ _ hx,hΨ _ _ hx,smul_zero,smul_zero,zero_add]

end CompactHamiltonianIsotopy

end PackingSufficiencySupport.Hamiltonian

namespace PackingSufficiencySupport.Hamiltonian.CompactHamiltonianIsotopy
open scoped ContDiff Topology BigOperators
open Set Function

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

def refl (A : E →L[ℝ] E →L[ℝ] ℝ) : CompactHamiltonianIsotopy A where
  map := fun _ => Homeomorph.refl E
  smooth := contDiff_snd
  inverse_smooth := contDiff_snd
  zero := rfl
  hamiltonian := 0
  hamiltonian_smooth := contDiff_const
  compact := by simp [HasCompactSupport]
  flow := by
    intro t x
    simpa only [hamiltonianField,formMoserField,spatialDifferential,
      fderiv_zero,Pi.zero_apply,ContinuousLinearMap.zero_comp,map_zero,neg_zero,
      Homeomorph.refl_apply,id_eq] using hasDerivAt_const t x
  symplectic := by intro t x v w; simp
  fixed := fun _ _ _ => rfl

end PackingSufficiencySupport.Hamiltonian.CompactHamiltonianIsotopy

namespace PackingSufficiencySupport.MomentPolytope
open scoped ContDiff Topology BigOperators
open Set Function
open Hamiltonian Comparison
open scoped Pointwise
open MeasureTheory
section

variable {m N : ℕ} (b : Fin N → Moments m) (c : Fin N → ℝ)

theorem exists_lifted_rearrangement_convex (j : Fin m) [Nonempty (Active b j)]
    (hb : ∀ ν i, 0 ≤ b ν i) (hK : IsCompact (region b c))
    (F : ConvexMaps (region b c) (convex_region b c)) {ε : ℝ} (he : 0 < ε) :
    ∃ Φ : CompactHamiltonianIsotopy (@phaseArea (Fin m) _),
      (∀ t z, Φ.map t z ∈ planeRegion b c ↔ z ∈ planeRegion b c) ∧
      (∀ z (hz : z ∈ planeRegion b c), ∀ hz',
        F.val ⟨planeMoments (Φ.map 1 z),hz'⟩ ≤
          (coordOperator b c j hb F).val ⟨planeMoments z,hz⟩+ε) ∧
      (∀ ν, ∃ ρ > 0, ∀ t z, c ν-weightedMoment (b ν) z < ρ →
        fderiv ℝ (weightedMoment (b ν)) z (hamiltonianField phaseArea Φ.hamiltonian (t,z)) = 0) := by
  obtain ⟨f,hf⟩ := ContinuousMap.exists_extension hK.isClosed.isClosedEmbedding_subtypeVal F.val
  have heq (p : region b c) : f p.val = F.val p := congrArg (fun H : C(region b c,ℝ) => H p) hf
  have hconv : ConvexOn ℝ (region b c) f := by
    refine ⟨convex_region b c,?_⟩
    intro p hp q hq a d ha hd had
    simpa only [←heq,smul_eq_mul] using! F.property ⟨p,hp⟩ ⟨q,hq⟩ a d ha hd had
  obtain ⟨Φ,hmem,hest,hface⟩ := exists_cartesian_lifted_rearrangement b c j hb hK f hconv he
  refine ⟨Φ,hmem,?_,hface⟩
  intro z hz hz'
  have hext : f.restrict (region b c) = F.val := hf
  have hh := hest z hz
  rw [hext,heq ⟨_,hz'⟩] at hh
  exact hh

variable [∀ j, Nonempty (Active b j)]

theorem exists_successive_rearrangement (hb : ∀ ν i, 0 ≤ b ν i)
    (hK : IsCompact (region b c)) (js : List (Fin m))
    (F : ConvexMaps (region b c) (convex_region b c)) {ε : ℝ} (he : 0 < ε) :
    ∃ Φ : CompactHamiltonianIsotopy (@phaseArea (Fin m) _),
      (∀ t z, Φ.map t z ∈ planeRegion b c ↔ z ∈ planeRegion b c) ∧
      (∀ z (hz : z ∈ planeRegion b c), ∀ hz',
        F.val ⟨planeMoments (Φ.map 1 z),hz'⟩ ≤
          (successive b c hb js F).val ⟨planeMoments z,hz⟩+ε) ∧
      (∀ ν, ∃ ρ > 0, ∀ t z, c ν-weightedMoment (b ν) z < ρ →
        fderiv ℝ (weightedMoment (b ν)) z (hamiltonianField phaseArea Φ.hamiltonian (t,z)) = 0) := by
  induction js generalizing F ε with
  | nil =>
    refine ⟨CompactHamiltonianIsotopy.refl (@phaseArea (Fin m) _),?_,?_,?_⟩
    · intro t z
      rfl
    · intro z hz hz'
      change F.val ⟨planeMoments z,hz'⟩ ≤ F.val ⟨planeMoments z,hz⟩+ε
      exact le_add_of_nonneg_right he.le
    · intro ν
      refine ⟨1,zero_lt_one,fun _ _ _ => ?_⟩
      simp [CompactHamiltonianIsotopy.refl,hamiltonianField,formMoserField,spatialDifferential]
  | cons j js ih =>
    obtain ⟨Φ,hΦ,hΦest,hΦface⟩ := exists_lifted_rearrangement_convex b c j hb hK F (half_pos he)
    obtain ⟨Ψ,hΨ,hΨest,hΨface⟩ := ih (coordOperator b c j hb F) (half_pos he)
    let Γ := Φ.after phaseArea_isInvertible phaseArea_skew Ψ
    have hΓ (t : ℝ) (z : PlanePhase (Fin m)) : Γ.map t z ∈ planeRegion b c ↔ z ∈ planeRegion b c :=
      Φ.concatMap_preserves Ψ hΦ hΨ t z
    refine ⟨Γ,hΓ,?_,?_⟩
    · intro z hz hz'
      have hy := (hΨ 1 z).mpr hz
      have hfirst := hΦest (Ψ.map 1 z) hy ((hΦ 1 _).mpr hy)
      have hsecond := hΨest z hz hy
      have hend : Γ.map 1 z = Φ.map 1 (Ψ.map 1 z) := Φ.concatMap_one Ψ z
      have hval : F.val ⟨planeMoments (Γ.map 1 z),hz'⟩ =
          F.val ⟨planeMoments (Φ.map 1 (Ψ.map 1 z)),(hΦ 1 _).mpr hy⟩ := by
        apply congrArg F.val
        apply Subtype.ext
        exact congrArg planeMoments hend
      rw [hval]
      change _ ≤ (successive b c hb js (coordOperator b c j hb F)).val ⟨planeMoments z,hz⟩+ε
      linarith
    · intro ν
      obtain ⟨a,ha,haf⟩ := hΦface ν
      obtain ⟨d,hd,hdf⟩ := hΨface ν
      refine ⟨min a d,lt_min ha hd,?_⟩
      intro t z hz
      exact Φ.concatHamiltonian_face Ψ (weightedMoment (b ν))
        (fun t z hz => haf t z (hz.trans_le (min_le_left _ _)))
        (fun t z hz => hdf t z (hz.trans_le (min_le_right _ _))) t z hz

end
section

variable {m N : ℕ} (b : Fin N → Moments m) (c : Fin N → ℝ)

theorem hamiltonian_comparison (hb : ∀ ν i, 0 ≤ b ν i) (hc : ∀ ν, 0 < c ν)
    (hcomp : IsCompact (region b c))
    (Q : ConvexMaps (region b c) (convex_region b c))
    {τ a : ℝ} (hτ : 0 < τ) (hτ1 : τ < 1) (ha : 0 < a)
    (hmean : averageMap (region b c) hcomp Q.val < 0)
    (houter : ∀ p : region b c, p.val ∉ τ • region b c → Q.val p ≤ -a) :
    ∃ (K : Moments m → ℝ) (Φ : CompactHamiltonianIsotopy (@phaseArea (Fin m) _)),
      ContDiff ℝ ∞ K ∧
      (∀ t z, Φ.map t z ∈ planeRegion b c ↔ z ∈ planeRegion b c) ∧
      (∀ z (_hz : z ∈ planeRegion b c), ∀ hz',
        K (planeMoments (Φ.map 1 z))+Q.val ⟨planeMoments (Φ.map 1 z),hz'⟩ < K (planeMoments z)) ∧
      (∀ ν, ∃ ρ > 0, ∀ t z, c ν-weightedMoment (b ν) z < ρ →
        fderiv ℝ (weightedMoment (b ν)) z (hamiltonianField phaseArea Φ.hamiltonian (t,z)) = 0) := by
  let : ∀ j, Nonempty (Active b j) := fun j => active_nonempty b c hb hc hcomp j
  obtain ⟨K,d,hd,hgap⟩ := analytic_gap b c hb hc hcomp Q hτ hτ1 ha hmean houter
  obtain ⟨Φ,hmem,hest,hface⟩ := exists_successive_rearrangement b c hb hcomp (List.finRange m)
    (affineStep 1 (by norm_num) Q K) (show 0 < d/4 by positivity)
  obtain ⟨k,hk,happrox⟩ := smooth_approximation (region b c) hcomp K.val (show 0 < d/4 by positivity)
  refine ⟨k,Φ,hk,hmem,?_,hface⟩
  intro z hz hz'
  have hout := happrox ⟨planeMoments (Φ.map 1 z),hz'⟩
  have hin := happrox ⟨planeMoments z,hz⟩
  rw [Real.dist_eq] at hout hin
  have ho := (abs_lt.mp hout).2
  have hi := (abs_lt.mp hin).1
  have he := hest z hz hz'
  have hg := hgap ⟨planeMoments z,hz⟩
  change (affineStep 1 (by norm_num) Q K).val ⟨planeMoments (Φ.map 1 z),hz'⟩ ≤
    (fullRearrangement b c hb (affineStep 1 (by norm_num) Q K)).val ⟨planeMoments z,hz⟩+d/4 at he
  simp only [affineStep, ContinuousMap.add_apply, ContinuousMap.smul_apply, smul_eq_mul, one_mul] at he hg
  linarith only [hd,ho,hi,he,hg]

end

theorem positive_hamiltonian_comparison {m N : ℕ}
    (b : Fin N → Moments m) (c : Fin N → ℝ)
    (hb : ∀ ν i, 0 ≤ b ν i) (hc : ∀ ν, 0 < c ν)
    (hcomp : IsCompact (region b c))
    (P : Moments m → ℝ) (hP : ContinuousOn P (region b c))
    (hconc : ConcaveOn ℝ (region b c) P)
    (hmean : 0 < ∫ p in region b c, P p)
    {τ a : ℝ} (hτ : 0 < τ) (hτ1 : τ < 1) (ha : 0 < a)
    (houter : ∀ p ∈ region b c, p ∉ τ • region b c → a ≤ P p) :
    ∃ (K : Moments m → ℝ) (Φ : CompactHamiltonianIsotopy (@phaseArea (Fin m) _)),
      ContDiff ℝ ∞ K ∧
      (∀ t z, Φ.map t z ∈ planeRegion b c ↔ z ∈ planeRegion b c) ∧
      (∀ z ∈ planeRegion b c,
        K (planeMoments (Φ.map 1 z))-P (planeMoments (Φ.map 1 z)) < K (planeMoments z)) ∧
      (∀ ν, ∃ ρ > 0, ∀ t z, c ν-weightedMoment (b ν) z < ρ →
        fderiv ℝ (weightedMoment (b ν)) z (hamiltonianField phaseArea Φ.hamiltonian (t,z)) = 0) := by
  let Q : ConvexMaps (region b c) (convex_region b c) :=
    ⟨⟨fun p => -P p, hP.domRestrict.neg⟩,by
      intro x y r s hr hs hrs
      change -P (r • (x : Moments m)+s • (y : Moments m)) ≤ r*(-P x)+s*(-P y)
      simpa only [Pi.neg_apply,smul_eq_mul] using
        (hconc.neg.2 x.property y.property hr hs hrs)⟩
  have he : zeroExtend (region b c) Q.val = (region b c).indicator (fun p => -P p) := by
    funext p
    by_cases hp : p ∈ region b c
    · simp only [zeroExtend,dite_eq_left hp,indicator_of_mem hp]
      rfl
    · simp [zeroExtend,hp]
  have hm : averageMap (region b c) hcomp Q.val < 0 := by
    change (volume (region b c)).toReal⁻¹ * (∫ p, zeroExtend (region b c) Q.val p) < 0
    rw [he,integral_indicator hcomp.measurableSet,integral_neg]
    exact mul_neg_of_pos_of_neg (inv_pos.2 (volume_region_toReal_pos b c hc hcomp))
      (neg_neg_of_pos hmean)
  obtain ⟨K,Φ,hK,hmem,hgap,hface⟩ := hamiltonian_comparison b c hb hc hcomp Q
    hτ hτ1 ha hm (fun p hp => neg_le_neg (houter p p.property hp))
  refine ⟨K,Φ,hK,hmem,?_,hface⟩
  intro z hz
  have hg := hgap z hz ((hmem 1 z).2 hz)
  change K (planeMoments (Φ.map 1 z))+(-P (planeMoments (Φ.map 1 z))) < K (planeMoments z) at hg
  simpa only [sub_eq_add_neg] using hg

end PackingSufficiencySupport.MomentPolytope

namespace PackingSufficiencySupport.Hamiltonian
open scoped ContDiff BigOperators
open Set Function

variable {ι : Type*} [Fintype ι]

theorem isCompact_preimage_planeMoments {D : Set (ι → ℝ)} (hD : IsCompact D) :
    IsCompact (planeMoments ⁻¹' D) := by
  obtain ⟨R,hR⟩ := hD.isBounded.exists_norm_le
  have hp : (1:ℝ) ≤ Real.pi := by linarith [Real.pi_gt_three]
  have hclosed : IsClosed (planeMoments ⁻¹' D) :=
    hD.isClosed.preimage planeMoments_smooth.continuous
  apply (isCompact_closedBall (0 : PlanePhase ι) (|R|+1)).of_isClosed_subset hclosed
  intro z hz
  rw [Metric.mem_closedBall,dist_zero_right]
  apply (pi_norm_le_iff_of_nonneg (by positivity : (0:ℝ) ≤ |R|+1)).2
  intro i
  have hm : planeMoments z i ≤ |R| :=
    (le_abs_self _).trans ((norm_le_pi_norm (planeMoments z) i).trans ((hR _ hz).trans (le_abs_self R)))
  have hs : (z i).1^2+(z i).2^2 ≤ planeMoments z i := by
    change (z i).1^2+(z i).2^2 ≤ Real.pi*((z i).1^2+(z i).2^2)
    simpa only [one_mul] using mul_le_mul_of_nonneg_right hp
      (add_nonneg (sq_nonneg _) (sq_nonneg _))
  rw [Prod.norm_def,Real.norm_eq_abs,Real.norm_eq_abs]
  apply max_le
  · nlinarith [sq_abs (z i).1,abs_nonneg (z i).1,sq_nonneg (z i).2,abs_nonneg R]
  · nlinarith [sq_abs (z i).2,abs_nonneg (z i).2,sq_nonneg (z i).1,abs_nonneg R]

end PackingSufficiencySupport.Hamiltonian

namespace PackingSufficiencySupport.MomentPolytope
open scoped ContDiff BigOperators
open Set Function
open Hamiltonian

theorem planeRegion_isCompact {m N : ℕ} (b : Fin N → Moments m) (c : Fin N → ℝ)
    (hC : IsCompact (region b c)) : IsCompact (planeRegion b c) :=
  isCompact_preimage_planeMoments hC

theorem planeRegion_nonempty {m N : ℕ} (b : Fin N → Moments m) (c : Fin N → ℝ)
    (hc : ∀ ν,0 ≤ c ν) : (planeRegion b c).Nonempty := by
  refine ⟨0,?_,⟩
  change (∀ j,0 ≤ planeMoments (0 : PlanePhase (Fin m)) j) ∧
    ∀ ν,∑ j,b ν j*planeMoments (0 : PlanePhase (Fin m)) j ≤ c ν
  refine ⟨fun j => planeMoments_nonneg _ _,fun ν => ?_⟩
  simpa [planeMoments,radialArea,radiusSq] using hc ν

end PackingSufficiencySupport.MomentPolytope

namespace PackingSufficiencySupport.Hamiltonian
open scoped ContDiff
open Set Function

def smoothUpperPositivePart (δ x : ℝ) : ℝ := (x+Real.sqrt (x^2+δ^2))/2

theorem smoothUpperPositivePart_smooth {δ : ℝ} (hδ : 0<δ) :
    ContDiff ℝ ∞ (smoothUpperPositivePart δ) := by
  have hpos (x : ℝ) : 0<x^2+δ^2 := add_pos_of_nonneg_of_pos (sq_nonneg x) (sq_pos_of_pos hδ)
  apply (contDiff_id.add ((contDiff_id.pow 2).add contDiff_const |>.sqrt (fun x => ne_of_gt (hpos x)))).div_const

theorem smoothUpperPositivePart_bounds {δ : ℝ} (hδ : 0<δ) (x : ℝ) :
    max x 0 < smoothUpperPositivePart δ x ∧
      smoothUpperPositivePart δ x - max x 0 ≤ δ/2 := by
  have hp : 0 ≤ x^2+δ^2 := add_nonneg (sq_nonneg x) (sq_nonneg δ)
  have hroot := Real.sq_sqrt hp
  have hrootpos := Real.sqrt_nonneg (x^2+δ^2)
  have habs := sq_abs x
  have hgt : |x| < Real.sqrt (x^2+δ^2) := by nlinarith [sq_pos_of_pos hδ]
  have hle : Real.sqrt (x^2+δ^2) ≤ |x|+δ := by
    nlinarith [abs_nonneg x]
  rcases le_total 0 x with hx|hx
  · rw [max_eq_left hx,abs_of_nonneg hx] at *
    dsimp [smoothUpperPositivePart]
    constructor <;> linarith
  · rw [max_eq_right hx,abs_of_nonpos hx] at *
    dsimp [smoothUpperPositivePart]
    constructor <;> linarith

theorem exists_smooth_positive_caps {ι κ : Type*} [Fintype ι] [Nonempty ι] [Fintype κ]
    (r : ι → ℝ) {ε : ℝ} (hε : 0<ε) :
    ∃ h : ι → (κ → ℝ) → ℝ,
      (∀ i, ContDiff ℝ ∞ (h i)) ∧
      (∀ i p, max (r i-∑ j, p j) 0 < h i p) ∧
      (∀ p, 0 < (∑ i, h i p)-(∑ i, max (r i-∑ j, p j) 0) ∧
        (∑ i, h i p)-(∑ i, max (r i-∑ j, p j) 0) < ε) := by
  classical
  let N : ℝ := Fintype.card ι
  have hN : 0<N := by dsimp [N]; exact_mod_cast Fintype.card_pos
  let δ := ε/N
  have hδ : 0<δ := div_pos hε hN
  let h : ι → (κ → ℝ) → ℝ := fun i p => smoothUpperPositivePart δ (r i-∑ j, p j)
  refine ⟨h,?_,?_,?_⟩
  · intro i
    exact (smoothUpperPositivePart_smooth hδ).comp (contDiff_const.sub (by fun_prop))
  · intro i p
    exact (smoothUpperPositivePart_bounds hδ _).1
  · intro p
    rw [←Finset.sum_sub_distrib]
    have hsum : (∑ i, (h i p-max (r i-∑ j, p j) 0)) ≤ N*(δ/2) := by
      calc
        _ ≤ ∑ _i : ι, δ/2 := Finset.sum_le_sum (fun i _ => (smoothUpperPositivePart_bounds hδ _).2)
        _ = N*(δ/2) := by simp [N]
    have hc : N*(δ/2)=ε/2 := by dsimp [δ]; field_simp
    refine ⟨Finset.sum_pos (fun i _ => sub_pos.mpr (smoothUpperPositivePart_bounds hδ _).1) Finset.univ_nonempty,?_⟩
    rw [hc] at hsum
    exact hsum.trans_lt (half_lt_self hε)

end PackingSufficiencySupport.Hamiltonian
end

end OAI