lean/OAI/Geometry/BallPacking/DiskMaps/NormalizedRoundedBoxes.lean

import Mathlib
import OAI.Geometry.BallPacking.DiskMaps.CompactEmbeddingIsotopy

namespace OAI

noncomputable section
namespace PackingSufficiencySupport.Hamiltonian

section
open scoped ContDiff Topology
open Set Function MeasureTheory

def normalizedRoundedMap (k : ℝ) (c : Plane) (a b r : ℝ) : Plane → Plane :=
  roundedMap k c a b ∘ diagonalScale r⁻¹ r⁻¹

@[fun_prop] theorem normalizedRoundedMap_smooth (k : ℝ) (c : Plane) (a b r : ℝ) :
    ContDiff ℝ ∞ (normalizedRoundedMap k c a b r) :=
  (roundedMap_smooth k c a b).comp (diagonalScale r⁻¹ r⁻¹).contDiff

theorem normalizedRoundedMap_injective {k a b r : ℝ} (hk : 0 < k) (ha : 0 < a)
    (hb : 0 < b) (hr : 0 < r) (c : Plane) :
    Injective (normalizedRoundedMap k c a b r) :=
  (roundedMap_injective hk.ne' ha.ne' hb.ne' c).comp
    (diagonalScale_injective (inv_ne_zero hr.ne') (inv_ne_zero hr.ne'))

theorem normalizedRoundedMap_det_pos {k a b r : ℝ} (hk : 0 < k) (ha : 0 < a)
    (hb : 0 < b) (hr : 0 < r) (c : Plane) (x : Plane) :
    0 < (fderiv ℝ (normalizedRoundedMap k c a b r) x).det := by
  rw [normalizedRoundedMap,fderiv_comp x
    ((roundedMap_smooth k c a b).differentiable (by simp) _)
    ((diagonalScale r⁻¹ r⁻¹).differentiable _), (diagonalScale r⁻¹ r⁻¹).fderiv,
    ContinuousLinearMap.det,ContinuousLinearMap.toLinearMap_comp,LinearMap.det_comp]
  change 0 < (fderiv ℝ (roundedMap k c a b) _).det * (diagonalScale r⁻¹ r⁻¹).det
  rw [diagonalScale_det]
  exact mul_pos (roundedMap_det_pos hk ha hb c _) (mul_pos (inv_pos.mpr hr) (inv_pos.mpr hr))

theorem normalizedRoundedMap_image {r : ℝ} (hr : 0 < r) (k : ℝ) (c : Plane) (a b : ℝ) :
    normalizedRoundedMap k c a b r '' closedRoundDisk r = roundedBox k c a b := by
  rw [normalizedRoundedMap,image_comp,diagonalScale_inv_image_closedRoundDisk hr]
  rfl

theorem roundedBox_volume_eq {a b : ℝ} (ha : 0 ≤ a) (hb : 0 ≤ b)
    (k : ℝ) (c : Plane) :
    volume (roundedBox k c a b) = ENNReal.ofReal (a*b*squeezedArea k) := by
  exact (ENNReal.toReal_eq_toReal_iff' (roundedBox_compact k c a b).measure_ne_top
    ENNReal.ofReal_ne_top).mp (by
      rw [roundedBox_volume ha hb k c,ENNReal.toReal_ofReal
        (mul_nonneg (mul_nonneg ha hb) (squeezedArea_nonneg k))])


end

section
open scoped ContDiff Topology
open Set Function

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

namespace SupportedSmoothIsotopyFamily

def cutoff {W : Set E} (Φ : SupportedSmoothIsotopyFamily P E W)
    (ρ : P → ℝ) (hρ : ContDiff ℝ ∞ ρ) : SupportedSmoothIsotopyFamily P E W where
  map := fun y t => Φ.map y (ρ y*t)
  smooth := Φ.smooth.comp ((contDiff_fst.fst.prodMk
    (((hρ.comp contDiff_fst.fst).mul contDiff_fst.snd))).prodMk contDiff_snd)
  inverse_smooth := Φ.inverse_smooth.comp ((contDiff_fst.fst.prodMk
    (((hρ.comp contDiff_fst.fst).mul contDiff_fst.snd))).prodMk contDiff_snd)
  zero := fun y => by simp only [mul_zero,Φ.zero]
  support := Φ.support
  compact_support := Φ.compact_support
  support_subset := Φ.support_subset
  fixed := fun y t x hx => Φ.fixed y (ρ y*t) x hx

theorem endpoint_support {W : Set E} (Φ : SupportedSmoothIsotopyFamily P E W) :
    tsupport (fun p : P × E => Φ.map p.1 1 p.2-p.2) ⊆ univ ×ˢ Φ.support := by
  apply closure_minimal _ (isClosed_univ.prod Φ.compact_support.isClosed)
  intro p hp
  refine ⟨mem_univ _,?_⟩
  by_contra hn
  exact hp (sub_eq_zero.mpr (Φ.fixed p.1 1 p.2 hn))

theorem cutoff_compact {W : Set E} (Φ : SupportedSmoothIsotopyFamily P E W)
    (ρ : P → ℝ) (hρ : ContDiff ℝ ∞ ρ) (hρc : HasCompactSupport ρ) :
    HasCompactSupport (fun p : P × E => (Φ.cutoff ρ hρ).map p.1 1 p.2-p.2) := by
  apply HasCompactSupport.intro (hρc.prod Φ.compact_support)
  intro p hp
  by_cases h : p.1 ∈ tsupport ρ
  · have hn : p.2 ∉ Φ.support := fun hx => hp ⟨h,hx⟩
    exact sub_eq_zero.mpr (Φ.fixed p.1 (ρ p.1*1) p.2 hn)
  · have hz := image_eq_zero_of_notMem_tsupport h
    simp only [cutoff,hz,zero_mul,Φ.zero,Homeomorph.refl_apply,id_eq,sub_self]

variable [FiniteDimensional ℝ P]

theorem exists_compact_parameterization {W : Set E}
    (Φ : SupportedSmoothIsotopyFamily P E W) (Y : Set P) (hY : IsCompact Y) :
    ∃ Ψ : SupportedSmoothIsotopyFamily P E W,
      HasCompactSupport (fun p : P × E => Ψ.map p.1 1 p.2-p.2) ∧
      (∀ y ∈ Y, ∀ t, Ψ.map y t = Φ.map y t) := by
  obtain ⟨ρ,hρ,hρc,_,hρ1,_⟩ := exists_smooth_cutoff hY isOpen_univ (subset_univ Y)
  refine ⟨Φ.cutoff ρ hρ,Φ.cutoff_compact ρ hρ hρc,?_⟩
  intro y hy t
  have hh : ρ y = 1 := (Filter.Eventually.self_of_nhdsSet hρ1) y hy
  change Φ.map y (ρ y*t) = Φ.map y t
  rw [hh,one_mul]

end SupportedSmoothIsotopyFamily


namespace SupportedSmoothIsotopyFamily

def timeCutoff {W : Set E} (Φ : SupportedSmoothIsotopyFamily P E W)
    (ρ : P × ℝ → ℝ) (hρ : ContDiff ℝ ∞ ρ) : SupportedSmoothIsotopyFamily P E W where
  map := fun y t => Φ.map y (ρ (y,t)*t)
  smooth := Φ.smooth.comp ((contDiff_fst.fst.prodMk
    ((hρ.comp contDiff_fst).mul contDiff_fst.snd)).prodMk contDiff_snd)
  inverse_smooth := Φ.inverse_smooth.comp ((contDiff_fst.fst.prodMk
    ((hρ.comp contDiff_fst).mul contDiff_fst.snd)).prodMk contDiff_snd)
  zero := fun y => by simp only [mul_zero,Φ.zero]
  support := Φ.support
  compact_support := Φ.compact_support
  support_subset := Φ.support_subset
  fixed := fun y t x hx => Φ.fixed y (ρ (y,t)*t) x hx

theorem joint_support {W : Set E} (Φ : SupportedSmoothIsotopyFamily P E W) :
    tsupport (fun p : (P × ℝ) × E => Φ.map p.1.1 p.1.2 p.2-p.2) ⊆
      univ ×ˢ Φ.support := by
  apply closure_minimal _ (isClosed_univ.prod Φ.compact_support.isClosed)
  intro p hp
  refine ⟨mem_univ _,?_⟩
  by_contra hn
  exact hp (sub_eq_zero.mpr (Φ.fixed p.1.1 p.1.2 p.2 hn))

theorem timeCutoff_hasCompactSupport {W : Set E} (Φ : SupportedSmoothIsotopyFamily P E W)
    (ρ : P × ℝ → ℝ) (hρ : ContDiff ℝ ∞ ρ) (hρc : HasCompactSupport ρ) :
    HasCompactSupport (fun p : (P × ℝ) × E =>
      (Φ.timeCutoff ρ hρ).map p.1.1 p.1.2 p.2-p.2) := by
  apply HasCompactSupport.intro (hρc.prod Φ.compact_support)
  intro p hp
  by_cases h : p.1 ∈ tsupport ρ
  · have hn : p.2 ∉ Φ.support := fun hx => hp ⟨h,hx⟩
    exact sub_eq_zero.mpr (Φ.fixed p.1.1 (ρ p.1*p.1.2) p.2 hn)
  · have hz := image_eq_zero_of_notMem_tsupport h
    simp only [timeCutoff,Prod.eta,hz,zero_mul,Φ.zero,Homeomorph.refl_apply,id_eq,sub_self]

variable [FiniteDimensional ℝ P]

theorem exists_joint_compact {W : Set E} (Φ : SupportedSmoothIsotopyFamily P E W)
    (Y : Set P) (hY : IsCompact Y) :
    ∃ Ψ : SupportedSmoothIsotopyFamily P E W,
      HasCompactSupport (fun p : (P × ℝ) × E => Ψ.map p.1.1 p.1.2 p.2-p.2) ∧
      (∀ y ∈ Y, ∀ t ∈ Icc (0:ℝ) 1, Ψ.map y t = Φ.map y t) := by
  obtain ⟨ρ,hρ,hρc,_,hρ1,_⟩ := exists_smooth_cutoff (hY.prod isCompact_Icc)
    isOpen_univ (subset_univ (Y ×ˢ Icc (0:ℝ) 1))
  refine ⟨Φ.timeCutoff ρ hρ,Φ.timeCutoff_hasCompactSupport ρ hρ hρc,?_⟩
  intro y hy t ht
  have hh : ρ (y,t) = 1 := (Filter.Eventually.self_of_nhdsSet hρ1) (y,t) ⟨hy,ht⟩
  change Φ.map y (ρ (y,t)*t) = Φ.map y t
  rw [hh,one_mul]

end SupportedSmoothIsotopyFamily

end

section
open scoped ContDiff Topology
open Set Function MeasureTheory

variable {P : Type} [NormedAddCommGroup P] [NormedSpace ℝ P] [FiniteDimensional ℝ P]

theorem exists_parameter_relative_circle_primitive
    {alpha : P × Plane → Plane →L[ℝ] ℝ}
    (ha : ContDiff ℝ ∞ alpha) (hac : HasCompactSupport alpha) {R delta : ℝ}
    (hR : 0 < R) (hd : 0 < delta) (hdR : delta < R^2) (Y : Set P)
    (hz : ∀ y ∈ Y, (∫ p in roundDisk R, planarCurl (fun x => alpha (y,x)) p) = 0) :
    ∃ H : P × Plane → ℝ, ContDiff ℝ ∞ H ∧ HasCompactSupport H ∧
      (∀ y p, delta ≤ |radiusSq p-R^2| → H (y,p) = 0) ∧
      (∀ y ∈ Y, ∀ t, fderiv ℝ (fun x => H (y,x)) (polarCoord.symm (R,t))
        (-R*Real.sin t,R*Real.cos t) = circlePullback (fun x => alpha (y,x)) R t) ∧
      ∀ y, (∀ x, alpha (y,x) = 0) → ∀ x, H (y,x) = 0 := by
  let a : P × ℝ → ℝ := fun p => circlePullback (fun x => alpha (p.1,x)) R p.2
  have has : ContDiff ℝ ∞ a := circlePullback_parameter_smooth ha R
  let m : P → ℝ := fun y => (∫ t in -Real.pi..Real.pi, a (y,t))/(2*Real.pi)
  have hms : ContDiff ℝ ∞ m :=
    ((contDiff_parameter_segment_integral has (-Real.pi)).comp
      (contDiff_id.prodMk contDiff_const)).div_const _
  let b : P × ℝ → ℝ := fun p => a p-m p.1
  have hbs : ContDiff ℝ ∞ b := has.sub (hms.comp contDiff_fst)
  have hby (y : P) : ContDiff ℝ ∞ (fun t => b (y,t)) :=
    hbs.comp (contDiff_const.prodMk contDiff_id)
  have hmY (y : P) (hy : y ∈ Y) : m y = 0 := by
    have hai : ContDiff ℝ ∞ (fun x : Plane => alpha (y,x)) :=
      ha.comp (contDiff_const.prodMk contDiff_id)
    have hz' := (integral_curl_roundDisk hai hR).symm.trans (hz y hy)
    change (∫ t in -Real.pi..Real.pi, circlePullback (fun x => alpha (y,x)) R t) / (2*Real.pi) = 0
    exact div_eq_zero_iff.mpr (Or.inl hz')
  have hb0 (y : P) : (∫ t in -Real.pi..Real.pi, b (y,t)) = 0 := by
    have hai : IntervalIntegrable (fun t => a (y,t)) volume (-Real.pi) Real.pi :=
      (has.continuous.comp (continuous_const.prodMk continuous_id)).intervalIntegrable _ _
    simp only [b]
    rw [intervalIntegral.integral_sub hai intervalIntegrable_const,intervalIntegral.integral_const]
    dsimp [m]
    field_simp
    ring
  have hbp (y : P) : Periodic (fun t => b (y,t)) (2*Real.pi) := by
    intro t
    dsimp [b,a]
    rw [circlePullback_periodic (fun x => alpha (y,x)) R t]
  have hp (y : P) := periodicPrimitive_periodic (hby y).continuous (hbp y) (hb0 y)
  let H : P × Plane → ℝ := fun p =>
    angularExtension R delta hd (periodicPrimitive (fun t => b (p.1,t))) p.2
  have hH : ContDiff ℝ ∞ H := angularExtension_parameter_smooth hd hdR
    (contDiff_parameter_segment_integral hbs (-Real.pi)) hp
  have hbzero (y : P) (hy : ∀ x, alpha (y,x) = 0) : (fun t => b (y,t)) = fun _ => (0:ℝ) := by
    have ha0 : (fun t => a (y,t)) = fun _ => (0:ℝ) := by
      funext t
      simp only [a,circlePullback,hy,zero_apply]
    funext t
    change a (y,t) - (∫ t in -Real.pi..Real.pi, a (y,t))/(2*Real.pi) = 0
    rw [ha0,congrFun ha0 t]
    simp only [intervalIntegral.integral_zero,zero_div,sub_self]
  have hHc : HasCompactSupport H := by
    have hK : IsCompact (Prod.fst '' tsupport alpha) := hac.image continuous_fst
    apply angularExtension_parameter_compact (h := fun p =>
      periodicPrimitive (fun t => b (p.1,t)) p.2) (K := Prod.fst '' tsupport alpha) hd hK
    intro y hy t
    have he := hbzero y (fun x => image_eq_zero_of_notMem_tsupport
      (fun h => hy ⟨(y,x),h,rfl⟩))
    change periodicPrimitive (fun t => b (y,t)) t = 0
    rw [he]
    simp only [periodicPrimitive,intervalIntegral.integral_zero]
  refine ⟨H,hH,hHc,fun _ p hp => angularExtension_zero hd _ p hp,?_,?_⟩
  · intro y hy t
    have hc : HasDerivAt (fun t => polarCoord.symm (R,t)) (-R*Real.sin t,R*Real.cos t) t := by
      change HasDerivAt (fun t => (R*Real.cos t,R*Real.sin t)) _ t
      exact (((Real.hasDerivAt_cos t).const_mul R).prodMk
        ((Real.hasDerivAt_sin t).const_mul R)).congr_deriv (by ext <;> simp [neg_mul])
    have hHy : ContDiff ℝ ∞ (fun x => H (y,x)) := hH.comp (contDiff_const.prodMk contDiff_id)
    have hdH := ((hHy.differentiable (by simp)) (polarCoord.symm (R,t))).hasFDerivAt.comp_hasDerivAt t hc
    have he : (fun t => H (y,polarCoord.symm (R,t))) = periodicPrimitive (fun t => b (y,t)) :=
      funext fun t => angularExtension_polar hR hd (hp y) t
    change HasDerivAt (fun t => H (y,polarCoord.symm (R,t))) _ t at hdH
    rw [he] at hdH
    simpa only [b,hmY y hy,sub_zero,a] using
      hdH.unique (periodicPrimitive_hasDerivAt (hby y).continuous t)
  · intro y hy x
    change angularExtension R delta hd (periodicPrimitive (fun t => b (y,t))) x = 0
    rw [hbzero y hy]
    simp only [angularExtension,periodicPrimitive,intervalIntegral.integral_zero,mul_zero]

omit [FiniteDimensional ℝ P] in
theorem parameter_relative_finite_potential_correction {ι : Type*} [Fintype ι]
    {alpha : P × Plane → Plane →L[ℝ] ℝ} (ha : ContDiff ℝ ∞ alpha)
    (hac : HasCompactSupport alpha) (Y : Set P) (R : ι → ℝ)
    (H : ι → P × Plane → ℝ) (hHs : ∀ i, ContDiff ℝ ∞ (H i))
    (hHc : ∀ i, HasCompactSupport (H i))
    (hself : ∀ i y, y ∈ Y → ∀ p, radiusSq p = (R i)^2 →
      fderiv ℝ (fun x => H i (y,x)) p (-p.2,p.1) = alpha (y,p) (-p.2,p.1))
    (hother : ∀ i j, j ≠ i → ∀ y p, radiusSq p = (R i)^2 →
      fderiv ℝ (fun x => H j (y,x)) p = 0)
    (hHzero : ∀ i y, (∀ x, alpha (y,x) = 0) → ∀ x, H i (y,x) = 0) :
    ∃ beta : P × Plane → Plane →L[ℝ] ℝ, ContDiff ℝ ∞ beta ∧ HasCompactSupport beta ∧
      (∀ y p, planarCurl (fun x => beta (y,x)) p = planarCurl (fun x => alpha (y,x)) p) ∧
      (∀ i y, y ∈ Y → ∀ p, radiusSq p = (R i)^2 → beta (y,p) (-p.2,p.1) = 0) ∧
      ∀ y, (∀ x, alpha (y,x) = 0) → ∀ x, beta (y,x) = 0 := by
  classical
  let F : P × Plane → ℝ := fun p => ∑ i, H i p
  have hFs : ContDiff ℝ ∞ F := ContDiff.sum (fun i _ => hHs i)
  have hFc : HasCompactSupport F := by
    have he : (∑ i, H i) = F := by funext p; simp [F]
    rw [← he]
    exact HasCompactSupport.finset_sum (s := Finset.univ) (f := H) (fun i _ => hHc i)
  have hFd (y : P) (p v : Plane) :
      fderiv ℝ (fun x => F (y,x)) p v = ∑ i, fderiv ℝ (fun x => H i (y,x)) p v := by
    change fderiv ℝ (fun x => ∑ i, H i (y,x)) p v = _
    have hHyi (i : ι) : DifferentiableAt ℝ (fun x : Plane => H i (y,x)) p :=
      (((hHs i).comp (contDiff_const.prodMk contDiff_id)).differentiable (by simp)) p
    rw [fderiv_fun_sum (fun i _ => hHyi i)]
    simp only [sum_apply]
  let beta : P × Plane → Plane →L[ℝ] ℝ := fun p => alpha p - fderiv ℝ (fun x => F (p.1,x)) p.2
  refine ⟨beta,ha.sub (fiber_fderiv_smooth hFs),hac.sub (fiber_fderiv_compact hFs hFc),?_,?_,?_⟩
  · intro y p
    exact planarCurl_sub_differential (ha.comp (contDiff_const.prodMk contDiff_id))
      (hFs.comp (contDiff_const.prodMk contDiff_id)) p
  · intro i y hy p hp
    change alpha (y,p) (-p.2,p.1) - fderiv ℝ (fun x => F (y,x)) p (-p.2,p.1) = 0
    rw [hFd,Finset.sum_eq_single i,hself i y hy p hp,sub_self]
    · intro j _ hj
      rw [hother i j hj y p hp]
      rfl
    · simp

  · intro y hy x
    have he : (fun x => F (y,x)) = fun _ => (0:ℝ) := by
      funext q
      exact Finset.sum_eq_zero (fun i _ => hHzero i y hy q)
    change alpha (y,x) - fderiv ℝ (fun x => F (y,x)) x = 0
    rw [hy x,he,fderiv_const_apply,sub_self]

theorem exists_parameter_relative_finite_circle_correction {ι : Type*} [Fintype ι]
    {alpha : P × Plane → Plane →L[ℝ] ℝ} (ha : ContDiff ℝ ∞ alpha)
    (hac : HasCompactSupport alpha) (Y : Set P) (R : ι → ℝ) (hR : ∀ i, 0 < R i)
    (hRi : Injective R)
    (hz : ∀ i y, y ∈ Y → (∫ p in roundDisk (R i), planarCurl (fun x => alpha (y,x)) p) = 0) :
    ∃ beta : P × Plane → Plane →L[ℝ] ℝ, ContDiff ℝ ∞ beta ∧ HasCompactSupport beta ∧
      (∀ y p, planarCurl (fun x => beta (y,x)) p = planarCurl (fun x => alpha (y,x)) p) ∧
      (∀ i y, y ∈ Y → ∀ p, radiusSq p = (R i)^2 → beta (y,p) (-p.2,p.1) = 0) ∧
      ∀ y, (∀ x, alpha (y,x) = 0) → ∀ x, beta (y,x) = 0 := by
  classical
  choose d hd hdR hdsep using exists_disjoint_radial_collars R hR hRi
  choose H hHs hHc hHspt hHt hHzero using fun i =>
    exists_parameter_relative_circle_primitive ha hac (hR i) (hd i) (hdR i) Y (hz i)
  apply parameter_relative_finite_potential_correction ha hac Y R H hHs hHc
      (hHzero := hHzero)
  · intro i y hy p hp
    obtain ⟨t,rfl⟩ := polar_surjective_circle (hR i) hp
    simpa only [circlePullback,polarCoord_symm_apply,neg_mul] using hHt i y hy t
  · intro i j hj y p hp
    apply fderiv_zero_outside_collar (hHspt j y)
    rw [hp]
    exact hdsep j i hj.symm


end

open scoped ContDiff Topology NNReal
open Set Function MeasureTheory
variable {P : Type} [NormedAddCommGroup P] [NormedSpace ℝ P] [FiniteDimensional ℝ P]

theorem exists_parameter_relative_density_transport {ι : Type*} {L : ℝ≥0}
    (X : C(ℝ × (P × Plane),Plane)) (hX : LipschitzWith L X)
    (hXs : ContDiff ℝ ∞ X) (hXc : HasCompactSupport X)
    (ρ : P → ℝ × Plane → ℝ) (hρ : ∀ y, ContDiff ℝ ∞ (ρ y))
    (B : Plane →L[ℝ] Plane →L[ℝ] ℝ)
    (hPDE : ∀ y p v w, fderiv ℝ (ρ y) p (1,fiberField X y p) * B v w +
      ρ y p * (B (fderiv ℝ (fiberField X y) p (0,v)) w +
        B v (fderiv ℝ (fiberField X y) p (0,w))) = 0)
    (Y : Set P) (R : ι → ℝ) (hR : ∀ i, 0 < R i)
    (htan : ∀ i y, y ∈ Y → ∀ t x, radiusSq x = (R i)^2 → radialDrift (fiberField X y) (t,x) = 0)
    (t T : ℝ) : ∃ Φ : P → Plane ≃ₜ Plane,
      ContDiff ℝ ∞ (fun p : P × Plane => Φ p.1 p.2) ∧
      ContDiff ℝ ∞ (fun p : P × Plane => (Φ p.1).symm p.2) ∧
      HasCompactSupport (fun p : P × Plane => Φ p.1 p.2 - p.2) ∧
      (∀ y x v w, ρ y (t+T,Φ y x) * B (fderiv ℝ (Φ y) x v) (fderiv ℝ (Φ y) x w) =
        ρ y (t,x) * B v w) ∧
      (∀ i y, y ∈ Y → Φ y '' closedRoundDisk (R i) = closedRoundDisk (R i)) ∧
      ∀ y, (∀ t x, X (t,(y,x)) = 0) → ∀ x, Φ y x = x := 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 Φ (y : P) := timeSteps (fiberField X y) (fiberField_lipschitz X hX y)
    (fiberField_smooth X hXs y) hh t N
  have hK : IsCompact (Prod.snd '' tsupport X) := hXc.image continuous_snd
  have hfix (p : P × Plane) (hp : p ∉ Prod.snd '' tsupport X) : Φ p.1 p.2 = p.2 := by
    apply timeSteps_of_stationary
    intro s
    change X (s,p) = 0
    exact image_eq_zero_of_notMem_tsupport (fun h => hp ⟨(s,p),h,rfl⟩)
  refine ⟨Φ,(timeSteps_fiber_smooth X hX hXs hh t N).1,
    (timeSteps_fiber_smooth X hX hXs hh t N).2,
    HasCompactSupport.intro hK (fun p hp => sub_eq_zero.mpr (hfix p hp)),?_,?_,?_⟩
  · intro y x v w
    simpa only [he] using timeSteps_preserves_density (fiberField X y)
      (fiberField_lipschitz X hX y) (fiberField_smooth X hXs y)
      (ρ y) (hρ y) B (hPDE y) hh t N x v w
  · intro i y hy
    apply homeomorph_image_closedRoundDisk
    intro x
    exact timeSteps_preserves_circle_iff (fiberField X y) (fiberField_lipschitz X hX y)
      (fiberField_smooth X hXs y) (fiberField_compact X hXc y) (hR i) (htan i y hy) hh t N x

  · intro y hy x
    apply timeSteps_of_stationary
    intro s
    exact hy s x

theorem exists_parameter_relative_primitive {ι : Type*} [Fintype ι]
    {f : P × Plane → ℝ} (hf : ContDiff ℝ ∞ f) (hfc : HasCompactSupport f)
    (hf0 : ∀ y, (∫ p, f (y,p)) = 0)
    (Y : Set P) (R : ι → ℝ) (hR : ∀ i, 0 < R i) (hRi : Injective R)
    (hz : ∀ i y, y ∈ Y → (∫ p in roundDisk (R i), f (y,p)) = 0) :
    ∃ U V : P × Plane → ℝ, ContDiff ℝ ∞ U ∧ ContDiff ℝ ∞ V ∧
      HasCompactSupport U ∧ HasCompactSupport V ∧
      (∀ y p, deriv (fun x => V (y,(x,p.2))) p.1 -
        deriv (fun t => U (y,(p.1,t))) p.2 = f (y,p)) ∧
      (∀ i y, y ∈ Y → ∀ p, radiusSq p = (R i)^2 → -p.2*U (y,p)+p.1*V (y,p) = 0) ∧
      ∀ y, (∀ x, f (y,x) = 0) → ∀ x, U (y,x) = 0 ∧ V (y,x) = 0 := by
  obtain ⟨U,V,hU,hV,hUc,hVc,hcurl,huvzero⟩ := exists_parametric_compact_primitive hf hfc hf0
  let alpha : P × Plane → Plane →L[ℝ] ℝ := fun p =>
    coordinateForm (fun x => U (p.1,x)) (fun x => V (p.1,x)) p.2
  have has : ContDiff ℝ ∞ alpha :=
    (hU.smul contDiff_const).add (hV.smul contDiff_const)
  have hac : HasCompactSupport alpha := by
    apply HasCompactSupport.intro (hUc.union hVc)
    intro p hp
    have hu : U p = 0 := image_eq_zero_of_notMem_tsupport (fun h => hp (Or.inl h))
    have hv : V p = 0 := image_eq_zero_of_notMem_tsupport (fun h => hp (Or.inr h))
    change U p • _ + V p • _ = 0
    rw [hu,hv,zero_smul,zero_smul,zero_add]
  have hc (y : P) (p : Plane) : planarCurl (fun x => alpha (y,x)) p = f (y,p) :=
    (coordinateForm_curl (hU.comp (contDiff_const.prodMk contDiff_id))
      (hV.comp (contDiff_const.prodMk contDiff_id)) p).trans (hcurl y p)
  have hz' (i : ι) (y : P) (hy : y ∈ Y) : (∫ p in roundDisk (R i), planarCurl (fun x => alpha (y,x)) p) = 0 := by
    simp_rw [hc]
    exact hz i y hy
  obtain ⟨beta,hbs,hbc,hcurlb,hbt,hbzero⟩ :=
    exists_parameter_relative_finite_circle_correction has hac Y R hR hRi hz'
  let U' : P × Plane → ℝ := fun p => beta p (1,0)
  let V' : P × Plane → ℝ := fun p => beta p (0,1)
  have hUs : ContDiff ℝ ∞ U' := hbs.clm_apply contDiff_const
  have hVs : ContDiff ℝ ∞ V' := hbs.clm_apply contDiff_const
  have hU'c : HasCompactSupport U' := by
    apply HasCompactSupport.intro hbc
    intro p hp
    simp only [U',image_eq_zero_of_notMem_tsupport hp,zero_apply]
  have hV'c : HasCompactSupport V' := by
    apply HasCompactSupport.intro hbc
    intro p hp
    simp only [V',image_eq_zero_of_notMem_tsupport hp,zero_apply]
  have hUy (y : P) : ContDiff ℝ ∞ (fun x => U' (y,x)) := hUs.comp (contDiff_const.prodMk contDiff_id)
  have hVy (y : P) : ContDiff ℝ ∞ (fun x => V' (y,x)) := hVs.comp (contDiff_const.prodMk contDiff_id)
  have hby (y : P) : ContDiff ℝ ∞ (fun x => beta (y,x)) := hbs.comp (contDiff_const.prodMk contDiff_id)
  refine ⟨U',V',hUs,hVs,hU'c,hV'c,?_,?_,?_⟩
  · intro y p
    rw [plane_deriv_first ((hVy y).differentiable (by simp)),
      plane_deriv_second ((hUy y).differentiable (by simp))]
    change fderiv ℝ (fun q => beta (y,q) (0,1)) p (1,0) -
      fderiv ℝ (fun q => beta (y,q) (1,0)) p (0,1) = f (y,p)
    rw [form_eval_fderiv (hby y),form_eval_fderiv (hby y)]
    exact (hcurlb y p).trans (hc y p)
  · intro i y hy p hp
    have he : (-p.2,p.1) = (-p.2) • ((1:ℝ),(0:ℝ)) + p.1 • ((0:ℝ),(1:ℝ)) := by
      ext <;> simp
    have ht := hbt i y hy p hp
    rw [he,map_add,map_smul,map_smul] at ht
    exact ht

  · intro y hy x
    have ha0 (q : Plane) : alpha (y,q) = 0 := by
      obtain ⟨hu,hv⟩ := huvzero y hy q
      simp only [alpha,coordinateForm,hu,hv,zero_smul,zero_add]
    have hb0 := hbzero y ha0 x
    simp only [U',V',hb0,zero_apply,and_self]

theorem exists_parameter_relative_background_moser {ι : Type*} [Fintype ι]
    {g f : P × Plane → ℝ} (hg : ContDiff ℝ ∞ g) (hf : ContDiff ℝ ∞ f)
    (hfc : HasCompactSupport f) (hf0 : ∀ y, (∫ p, f (y,p)) = 0)
    (hgpos : ∀ p, 0 < g p) (hpos : ∀ p, 0 < g p+f p)
    (Y : Set P) (R : ι → ℝ) (hR : ∀ i, 0 < R i) (hRi : Injective R)
    (hz : ∀ i y, y ∈ Y → (∫ p in roundDisk (R i), f (y,p)) = 0) :
    ∃ Φ : P → Plane ≃ₜ Plane,
      ContDiff ℝ ∞ (fun p : P × Plane => Φ p.1 p.2) ∧
      ContDiff ℝ ∞ (fun p : P × Plane => (Φ p.1).symm p.2) ∧
      HasCompactSupport (fun p : P × Plane => Φ p.1 p.2-p.2) ∧
      (∀ y x v w, (g (y,Φ y x)+f (y,Φ y x)) *
        planarArea (fderiv ℝ (Φ y) x v) (fderiv ℝ (Φ y) x w) = g (y,x)*planarArea v w) ∧
      (∀ i y, y ∈ Y → Φ y '' closedRoundDisk (R i) = closedRoundDisk (R i)) ∧
      ∀ y, (∀ x, f (y,x) = 0) → ∀ x, Φ y x = x := by
  obtain ⟨U,V,hU,hV,hUc,hVc,hcurl,htan,huvzero⟩ :=
    exists_parameter_relative_primitive hf hfc hf0 Y R hR hRi hz
  let field : ℝ × (P × Plane) → Plane := fun p =>
    backgroundField (fun x => g (p.2.1,x)) (fun x => f (p.2.1,x))
      (fun x => U (p.2.1,x)) (fun x => V (p.2.1,x)) (p.1,p.2.2)
  have hXs : ContDiff ℝ ∞ field := parametric_backgroundField_smooth hg hf hU hV hgpos hpos
  have hXc : HasCompactSupport field := parametric_backgroundField_compact hUc hVc
  obtain ⟨L,hL⟩ := ContDiff.lipschitzWith_of_hasCompactSupport hXc hXs (by simp)
  let X : C(ℝ × (P × Plane),Plane) := ⟨field,hXs.continuous⟩
  have hgy (y : P) : ContDiff ℝ ∞ (fun x => g (y,x)) := hg.comp (contDiff_const.prodMk contDiff_id)
  have hfy (y : P) : ContDiff ℝ ∞ (fun x => f (y,x)) := hf.comp (contDiff_const.prodMk contDiff_id)
  have hUy (y : P) : ContDiff ℝ ∞ (fun x => U (y,x)) := hU.comp (contDiff_const.prodMk contDiff_id)
  have hVy (y : P) : ContDiff ℝ ∞ (fun x => V (y,x)) := hV.comp (contDiff_const.prodMk contDiff_id)
  obtain ⟨Φ,hΦ,hΦi,hΦc,hΦarea,hΦdisk,hΦfix⟩ := exists_parameter_relative_density_transport X hL hXs hXc
    (fun y => backgroundDensity (fun x => g (y,x)) (fun x => f (y,x)))
    (fun y => backgroundDensity_smooth (hgy y) (hfy y)) planarArea
    (fun y => backgroundField_transport (hgy y) (hfy y) (hUy y) (hVy y)
      (fun x => hgpos (y,x)) (fun x => hpos (y,x)) (hcurl y)) Y R hR
    (fun i y hy => backgroundField_tangent (g := fun x => g (y,x))
      (f := fun x => f (y,x)) (htan i y hy)) 0 1
  refine ⟨Φ,hΦ,hΦi,hΦc,?_,hΦdisk,?_⟩
  · intro y x v w
    simpa only [zero_add,backgroundDensity,Real.smoothTransition.one,Real.smoothTransition.zero,
      one_mul,zero_mul,add_zero] using hΦarea y x v w
  · intro y hy x
    apply hΦfix y _ x
    intro t q
    obtain ⟨hu,hv⟩ := huvzero y hy q
    change backgroundField (fun x => g (y,x)) (fun x => f (y,x))
      (fun x => U (y,x)) (fun x => V (y,x)) (t,q) = 0
    simp only [backgroundField,hu,hv,mul_zero,zero_div]
    rfl



end PackingSufficiencySupport.Hamiltonian
end

end OAI