import Mathlib
import OAI.Geometry.BallPacking.Moser.ManifoldMoserField

namespace OAI

noncomputable section

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

theorem exists_parametric_relative_primitive {ι : Type*} [Fintype ι]
    {f : P × Plane → ℝ} (hf : ContDiff ℝ ∞ f) (hfc : HasCompactSupport f)
    (hf0 : ∀ y, (∫ p, f (y,p)) = 0)
    (R : ι → ℝ) (hR : ∀ i, 0 < R i) (hRi : Injective R)
    (hz : ∀ i 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 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) : (∫ p in roundDisk (R i), planarCurl (fun x => alpha (y,x)) p) = 0 := by
    simp_rw [hc]
    exact hz i y
  obtain ⟨beta,hbs,hbc,hcurlb,hbt,hbzero⟩ :=
    exists_parametric_finite_circle_correction has hac 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 p hp
    have he : (-p.2,p.1) = (-p.2) • ((1:ℝ),(0:ℝ)) + p.1 • ((0:ℝ),(1:ℝ)) := by
      ext <;> simp
    have ht := hbt i y 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]

omit [FiniteDimensional ℝ P] in

theorem parametric_backgroundField_smooth {g f U V : P × Plane → ℝ}
    (hg : ContDiff ℝ ∞ g) (hf : ContDiff ℝ ∞ f)
    (hU : ContDiff ℝ ∞ U) (hV : ContDiff ℝ ∞ V)
    (hgpos : ∀ p, 0 < g p) (hpos : ∀ p, 0 < g p+f p) :
    ContDiff ℝ ∞ (fun p : ℝ × (P × Plane) =>
      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)) := by
  have hb : ContDiff ℝ ∞ Real.smoothTransition := Real.smoothTransition.contDiff
  have hβ : ContDiff ℝ ∞ (deriv Real.smoothTransition) := (contDiff_infty_iff_deriv.mp hb).2
  have hd : ContDiff ℝ ∞ (fun p : ℝ × (P × Plane) =>
      g p.2 + Real.smoothTransition p.1 * f p.2) :=
    (hg.comp contDiff_snd).add ((hb.comp contDiff_fst).mul (hf.comp contDiff_snd))
  have hdpos (p : ℝ × (P × Plane)) : 0 < g p.2 + Real.smoothTransition p.1 * f p.2 :=
    backgroundDensity_positive (fun x => hgpos (p.2.1,x)) (fun x => hpos (p.2.1,x)) (p.1,p.2.2)
  exact (((hβ.comp contDiff_fst).neg.mul (hV.comp contDiff_snd)).div hd (fun p => (hdpos p).ne')).prodMk
    (((hβ.comp contDiff_fst).mul (hU.comp contDiff_snd)).div hd (fun p => (hdpos p).ne'))

omit [NormedSpace ℝ P] [FiniteDimensional ℝ P] in
theorem parametric_backgroundField_compact {g f U V : P × Plane → ℝ}
    (hU : HasCompactSupport U) (hV : HasCompactSupport V) :
    HasCompactSupport (fun p : ℝ × (P × Plane) =>
      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)) := by
  apply HasCompactSupport.intro (smoothTransition_deriv_compact.prod (hU.union hV))
  intro p hp
  have hn : p.1 ∉ tsupport (deriv Real.smoothTransition) ∨ p.2 ∉ tsupport U ∪ tsupport V := by
    simpa only [mem_prod,not_and_or] using hp
  rcases hn with ht | hx
  · simp [backgroundField,image_eq_zero_of_notMem_tsupport ht]
  · have hu : U p.2 = 0 := image_eq_zero_of_notMem_tsupport (fun h => hx (Or.inl h))
    have hv : V p.2 = 0 := image_eq_zero_of_notMem_tsupport (fun h => hx (Or.inr h))
    simp [backgroundField,hu,hv]

theorem exists_parametric_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)
    (R : ι → ℝ) (hR : ∀ i, 0 < R i) (hRi : Injective R)
    (hz : ∀ i 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 '' 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_parametric_relative_primitive hf hfc hf0 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_parametric_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)) R hR
    (fun i y => backgroundField_tangent (g := fun x => g (y,x))
      (f := fun x => f (y,x)) (htan i y)) 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

def radialDiskChart (R : ℝ) : OpenPartialHomeomorph Plane Plane :=
  (Complex.equivRealProdCLM.symm.toHomeomorph.toOpenPartialHomeomorph.trans
    (OpenPartialHomeomorph.univBall (0:ℂ) R)).trans
    Complex.equivRealProdCLM.toHomeomorph.toOpenPartialHomeomorph

@[simp] theorem radialDiskChart_source (R : ℝ) : (radialDiskChart R).source = univ := by
  simp only [radialDiskChart,OpenPartialHomeomorph.trans_source,
    Homeomorph.toOpenPartialHomeomorph_source,OpenPartialHomeomorph.univBall_source,
    preimage_univ,inter_self]

theorem radialDiskChart_target {R : ℝ} (hR : 0 < R) :
    (radialDiskChart R).target = roundDisk R := by
  simp only [radialDiskChart,OpenPartialHomeomorph.trans_target,
    Homeomorph.toOpenPartialHomeomorph_target,OpenPartialHomeomorph.univBall_target _ hR,
    preimage_univ,inter_univ,univ_inter]
  ext p
  simp only [mem_preimage,Metric.mem_ball,dist_zero_right]
  change ‖Complex.equivRealProdCLM.symm p‖ < R ↔ radiusSq p < R^2
  rw [← complex_normSq_plane]
  exact (sq_lt_sq₀ (norm_nonneg _) hR.le).symm

theorem radialDiskChart_apply {R : ℝ} (hR : 0 < R) (p : Plane) :
    radialDiskChart R p = (R / Real.sqrt (1+radiusSq p)) • p := by
  change Complex.equivRealProdCLM
    (OpenPartialHomeomorph.univBall (0:ℂ) R (Complex.equivRealProdCLM.symm p)) = _
  simp only [OpenPartialHomeomorph.univBall,dite_eq_left hR]
  change Complex.equivRealProdCLM
    (R • ((Real.sqrt (1+‖Complex.equivRealProdCLM.symm p‖^2))⁻¹ •
      Complex.equivRealProdCLM.symm p) + 0) = _
  rw [add_zero,map_smul,map_smul,ContinuousLinearEquiv.apply_symm_apply,
    complex_normSq_plane,smul_smul,div_eq_mul_inv]

theorem radialDiskChart_smooth (R : ℝ) : ContDiff ℝ ∞ (radialDiskChart R) :=
  Complex.equivRealProdCLM.contDiff.comp
    (OpenPartialHomeomorph.contDiff_univBall.comp Complex.equivRealProdCLM.symm.contDiff)

theorem radialDiskChart_symm_smooth {R : ℝ} (hR : 0 < R) :
    ContDiffOn ℝ ∞ (radialDiskChart R).symm (roundDisk R) := by
  apply Complex.equivRealProdCLM.contDiff.comp_contDiffOn
  apply OpenPartialHomeomorph.contDiffOn_univBall_symm.comp
    Complex.equivRealProdCLM.symm.contDiff.contDiffOn
  intro p hp
  rw [Metric.mem_ball,dist_zero_right]
  have hs : ‖Complex.equivRealProdCLM.symm p‖^2 < R^2 := by
    rw [complex_normSq_plane]
    exact hp
  exact (sq_lt_sq₀ (norm_nonneg _) hR.le).mp hs

@[simp] theorem radiusSq_nonneg (p : Plane) : 0 ≤ radiusSq p :=
  add_nonneg (sq_nonneg _) (sq_nonneg _)

theorem radialDiskChart_fderiv {R : ℝ} (hR : 0 < R) (p v : Plane) :
    fderiv ℝ (radialDiskChart R) p v =
      (R / Real.sqrt (1+radiusSq p)) • v -
        (R / (Real.sqrt (1+radiusSq p))^3 * (p.1*v.1+p.2*v.2)) • p := by
  have hp : 0 < 1+radiusSq p := by have := radiusSq_nonneg p; linarith
  have hs : Real.sqrt (1+radiusSq p) ≠ 0 := (Real.sqrt_pos.mpr hp).ne'
  have hq := (hasFDerivAt_fst (𝕜 := ℝ) (p := p)).pow 2
  have hr := (hasFDerivAt_snd (𝕜 := ℝ) (p := p)).pow 2
  have hd := HasFDerivAt.const_add 1 (hq.add hr)
  have hds := hd.sqrt hp.ne'
  have hdi := (hasDerivAt_inv hs).comp_hasFDerivAt p hds
  have hdc := hdi.const_mul R
  have he := hdc.smul (hasFDerivAt_id p)
  have hfun : (fun q : Plane => (R * (Real.sqrt (1+(q.1^2+q.2^2)))⁻¹) • q) =
      radialDiskChart R := by
    funext q
    rw [radialDiskChart_apply hR]
    rfl
  change HasFDerivAt (fun q : Plane => (R * (Real.sqrt (1+(q.1^2+q.2^2)))⁻¹) • q) _ p at he
  rw [hfun] at he
  rw [he.fderiv]
  ext <;> simp [add_apply,smul_apply,ContinuousLinearMap.smulRight_apply,
    Prod.smul_def,smul_eq_mul,radiusSq] <;> field_simp <;> ring

def radialDiskDensity (R : ℝ) (p : Plane) : ℝ := R^2/(1+radiusSq p)^2

theorem radialDiskDensity_pos {R : ℝ} (hR : 0 < R) (p : Plane) :
    0 < radialDiskDensity R p := by
  exact div_pos (sq_pos_of_pos hR) (sq_pos_of_pos (by have := radiusSq_nonneg p; linarith))

theorem radialDiskDensity_smooth (R : ℝ) : ContDiff ℝ ∞ (radialDiskDensity R) := by
  apply contDiff_const.div ((contDiff_const.add radiusSq_smooth).pow 2)
  intro p
  exact pow_ne_zero _ (by have := radiusSq_nonneg p; positivity)

theorem planarArea_radial_rank_one (a b : ℝ) (p v w : Plane) :
    planarArea (a • v - (b * (p.1*v.1+p.2*v.2)) • p)
      (a • w - (b * (p.1*w.1+p.2*w.2)) • p) =
      (a^2-a*b*radiusSq p)*planarArea v w := by
  change (a*v.1-b*(p.1*v.1+p.2*v.2)*p.1)*(a*w.2-b*(p.1*w.1+p.2*w.2)*p.2) -
    (a*v.2-b*(p.1*v.1+p.2*v.2)*p.2)*(a*w.1-b*(p.1*w.1+p.2*w.2)*p.1) =
      (a^2-a*b*(p.1^2+p.2^2))*(v.1*w.2-v.2*w.1)
  ring

theorem radialDiskChart_area {R : ℝ} (hR : 0 < R) (p v w : Plane) :
    planarArea (fderiv ℝ (radialDiskChart R) p v)
      (fderiv ℝ (radialDiskChart R) p w) = radialDiskDensity R p * planarArea v w := by
  rw [radialDiskChart_fderiv hR,radialDiskChart_fderiv hR,planarArea_radial_rank_one]
  congr 1
  have hp : 0 < 1+radiusSq p := by have := radiusSq_nonneg p; linarith
  have hs : Real.sqrt (1+radiusSq p) ≠ 0 := (Real.sqrt_pos.mpr hp).ne'
  have hs2 := Real.sq_sqrt hp.le
  unfold radialDiskDensity
  generalize Real.sqrt (1+radiusSq p) = s at *
  rw [show radiusSq p = s^2-1 by linarith]
  field_simp
  ring

theorem radiusSq_smul (a : ℝ) (p : Plane) : radiusSq (a • p) = a^2*radiusSq p := by
  change (a*p.1)^2+(a*p.2)^2 = a^2*(p.1^2+p.2^2)
  ring

theorem radialDiskChart_radiusSq {R : ℝ} (hR : 0 < R) (p : Plane) :
    radiusSq (radialDiskChart R p) = R^2*radiusSq p/(1+radiusSq p) := by
  rw [radialDiskChart_apply hR,radiusSq_smul,div_pow,Real.sq_sqrt]
  · ring
  · have := radiusSq_nonneg p
    linarith

def diskChartRadius (R r : ℝ) : ℝ := r / Real.sqrt (R^2-r^2)

theorem diskChartRadius_pos {R r : ℝ} (hr : 0 < r) (hrR : r < R) :
    0 < diskChartRadius R r := by
  apply div_pos hr
  apply Real.sqrt_pos.mpr
  nlinarith

theorem radialDiskChart_closed_iff {R r : ℝ} (hR : 0 < R) (hr : 0 ≤ r) (hrR : r < R)
    (p : Plane) : radialDiskChart R p ∈ closedRoundDisk r ↔
      p ∈ closedRoundDisk (diskChartRadius R r) := by
  change radiusSq (radialDiskChart R p) ≤ r^2 ↔ radiusSq p ≤ _
  have hd : 0 < R^2-r^2 := by nlinarith
  have hp : 0 < 1+radiusSq p := by have := radiusSq_nonneg p; linarith
  rw [radialDiskChart_radiusSq hR,div_le_iff₀ hp]
  change _ ↔ radiusSq p ≤ (r/Real.sqrt (R^2-r^2))^2
  rw [div_pow,Real.sq_sqrt hd.le,le_div_iff₀ hd]
  constructor <;> intro h <;> nlinarith

theorem radialDiskChart_open_iff {R r : ℝ} (hR : 0 < R) (hr : 0 ≤ r) (hrR : r < R)
    (p : Plane) : radialDiskChart R p ∈ roundDisk r ↔
      p ∈ roundDisk (diskChartRadius R r) := by
  change radiusSq (radialDiskChart R p) < r^2 ↔ radiusSq p < _
  have hd : 0 < R^2-r^2 := by nlinarith
  have hp : 0 < 1+radiusSq p := by have := radiusSq_nonneg p; linarith
  rw [radialDiskChart_radiusSq hR,div_lt_iff₀ hp]
  change _ ↔ radiusSq p < (r/Real.sqrt (R^2-r^2))^2
  rw [div_pow,Real.sq_sqrt hd.le,lt_div_iff₀ hd]
  constructor <;> intro h <;> nlinarith

theorem radialDiskChart_image_closed {R r : ℝ} (hR : 0 < R) (hr : 0 ≤ r) (hrR : r < R) :
    radialDiskChart R '' closedRoundDisk (diskChartRadius R r) = closedRoundDisk r := by
  ext p
  constructor
  · rintro ⟨q,hq,rfl⟩
    exact (radialDiskChart_closed_iff hR hr hrR q).mpr hq
  · intro hp
    have ht : p ∈ (radialDiskChart R).target := by
      rw [radialDiskChart_target hR]
      change radiusSq p < R^2
      change radiusSq p ≤ r^2 at hp
      nlinarith
    refine ⟨(radialDiskChart R).symm p,?_,(radialDiskChart R).right_inv ht⟩
    apply (radialDiskChart_closed_iff hR hr hrR _).mp
    rw [(radialDiskChart R).right_inv ht]
    exact hp

theorem radialDiskChart_image_open {R r : ℝ} (hR : 0 < R) (hr : 0 ≤ r) (hrR : r < R) :
    radialDiskChart R '' roundDisk (diskChartRadius R r) = roundDisk r := by
  ext p
  constructor
  · rintro ⟨q,hq,rfl⟩
    exact (radialDiskChart_open_iff hR hr hrR q).mpr hq
  · intro hp
    have ht : p ∈ (radialDiskChart R).target := by
      rw [radialDiskChart_target hR]
      change radiusSq p < R^2
      change radiusSq p < r^2 at hp
      nlinarith
    refine ⟨(radialDiskChart R).symm p,?_,(radialDiskChart R).right_inv ht⟩
    apply (radialDiskChart_open_iff hR hr hrR _).mp
    rw [(radialDiskChart R).right_inv ht]
    exact hp

theorem diskChartRadius_strictMonoOn {R : ℝ} (hR : 0 < R) :
    StrictMonoOn (diskChartRadius R) (Ico 0 R) := by
  intro r hr s hs hrs
  have hdr : 0 < R^2-r^2 := by nlinarith [hr.1,hr.2]
  have hds : 0 < R^2-s^2 := by nlinarith [hs.1,hs.2]
  have hnr : 0 ≤ diskChartRadius R r := div_nonneg hr.1 (Real.sqrt_nonneg _)
  have hns : 0 ≤ diskChartRadius R s := div_nonneg hs.1 (Real.sqrt_nonneg _)
  apply (sq_lt_sq₀ hnr hns).mp
  change (r/Real.sqrt (R^2-r^2))^2 < (s/Real.sqrt (R^2-s^2))^2
  rw [div_pow,div_pow,Real.sq_sqrt hdr.le,Real.sq_sqrt hds.le,div_lt_div_iff₀ hdr hds]
  nlinarith [mul_pos (sq_pos_of_pos hR) (show 0 < s^2-r^2 by nlinarith [hr.1])]

theorem planar_det (A : Plane →L[ℝ] Plane) :
    A.det = planarArea (A (1,0)) (A (0,1)) := by
  let b : Module.Basis (Fin 2) ℝ Plane :=
    Module.Basis.ofEquivFun (LinearEquiv.finTwoArrow ℝ ℝ).symm
  change LinearMap.det A.toLinearMap = _
  rw [← LinearMap.det_toMatrix b,Matrix.det_fin_two]
  simp [LinearMap.toMatrix_apply,b,Module.Basis.coe_ofEquivFun,
    LinearEquiv.finTwoArrow,planarArea_apply]
  ring

theorem radialDiskChart_det {R : ℝ} (hR : 0 < R) (p : Plane) :
    (fderiv ℝ (radialDiskChart R) p).det = radialDiskDensity R p := by
  rw [planar_det,radialDiskChart_area hR]
  simp [planarArea_apply]

theorem radialDiskChart_integral {R : ℝ} (hR : 0 < R) (f : Plane → ℝ) :
    (∫ x in roundDisk R, f x) = ∫ x, radialDiskDensity R x*f (radialDiskChart R x) := by
  have he := integral_target_eq_integral_abs_det_fderiv_smul volume
    (f := radialDiskChart R) (f' := fderiv ℝ (radialDiskChart R))
    (fun x _ => (((radialDiskChart_smooth R).differentiable (by simp)) x).hasFDerivAt) f
  simpa only [radialDiskChart_target hR,radialDiskChart_source,setIntegral_univ,
    radialDiskChart_det hR,abs_of_pos (radialDiskDensity_pos hR _),smul_eq_mul] using he

theorem radialDiskChart_integral_inner {R r : ℝ} (hR : 0 < R)
    (hr : 0 ≤ r) (hrR : r < R) (f : Plane → ℝ) :
    (∫ x in roundDisk r, f x) = ∫ x in roundDisk (diskChartRadius R r),
      radialDiskDensity R x*f (radialDiskChart R x) := by
  have hm : MeasurableSet (roundDisk (diskChartRadius R r)) :=
    (isOpen_lt radiusSq_smooth.continuous continuous_const).measurableSet
  have hinj : InjOn (radialDiskChart R) (roundDisk (diskChartRadius R r)) :=
    (radialDiskChart R).injOn.mono (by rw [radialDiskChart_source]; exact subset_univ _)
  have he := integral_image_eq_integral_abs_det_fderiv_smul volume hm
    (f' := fderiv ℝ (radialDiskChart R))
    (fun x _ => (((radialDiskChart_smooth R).differentiable (by simp)) x).hasFDerivAt.hasFDerivWithinAt)
    hinj f
  simpa only [radialDiskChart_image_open hR hr hrR,radialDiskChart_det hR,
    abs_of_pos (radialDiskDensity_pos hR _),smul_eq_mul] using he

end PackingSufficiencySupport.Hamiltonian

namespace PackingSufficiencySupport.Chart
open scoped ContDiff Topology
open Set Function

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

def conjugate (c : OpenPartialHomeomorph E F) (φ : E → E) (x : F) : F := by
  classical
  exact if x ∈ c.target then c (φ (c.symm x)) else x

omit [NormedSpace ℝ E] [NormedSpace ℝ F] in
@[simp] theorem conjugate_of_mem (c : OpenPartialHomeomorph E F) (φ : E → E)
    {x : F} (hx : x ∈ c.target) : conjugate c φ x = c (φ (c.symm x)) := by
  simp [conjugate,hx]

omit [NormedSpace ℝ E] [NormedSpace ℝ F] in
@[simp] theorem conjugate_of_notMem (c : OpenPartialHomeomorph E F) (φ : E → E)
    {x : F} (hx : x ∉ c.target) : conjugate c φ x = x := by
  simp [conjugate,hx]

omit [NormedSpace ℝ E] [NormedSpace ℝ F] in
theorem conjugate_apply (c : OpenPartialHomeomorph E F) (hc : c.source = univ)
    (φ : E → E) (x : E) : conjugate c φ (c x) = c (φ x) := by
  have hx : x ∈ c.source := by rw [hc]; trivial
  rw [conjugate_of_mem c φ (c.map_source hx),c.left_inv hx]

omit [NormedSpace ℝ E] [NormedSpace ℝ F] in
theorem conjugate_comp (c : OpenPartialHomeomorph E F) (hc : c.source = univ)
    (φ ψ : E → E) (x : F) :
    conjugate c φ (conjugate c ψ x) = conjugate c (φ ∘ ψ) x := by
  by_cases hx : x ∈ c.target
  · rw [conjugate_of_mem c ψ hx,conjugate_apply c hc,
      conjugate_of_mem c (φ ∘ ψ) hx]
    rfl
  · simp only [conjugate_of_notMem c _ hx]

omit [NormedSpace ℝ E] [NormedSpace ℝ F] in
@[simp] theorem conjugate_id (c : OpenPartialHomeomorph E F) (x : F) :
    conjugate c id x = x := by
  by_cases hx : x ∈ c.target
  · rw [conjugate_of_mem c id hx]
    exact c.right_inv hx
  · exact conjugate_of_notMem c id hx

def conjugateEquiv (c : OpenPartialHomeomorph E F) (hc : c.source = univ)
    (φ : E ≃ E) : F ≃ F where
  toFun := conjugate c φ
  invFun := conjugate c φ.symm
  left_inv x := by
    rw [conjugate_comp c hc]
    have he : ((φ.symm : E → E) ∘ (φ : E → E)) = id := funext φ.symm_apply_apply
    rw [he,conjugate_id]
  right_inv x := by
    rw [conjugate_comp c hc]
    have he : ((φ : E → E) ∘ (φ.symm : E → E)) = id := funext φ.apply_symm_apply
    rw [he,conjugate_id]

omit [NormedSpace ℝ E] [NormedSpace ℝ F] [NormedAddCommGroup P] [NormedSpace ℝ P] in

theorem conjugate_eq_of_notMem_image (c : OpenPartialHomeomorph E F)
    (φ : P → E → E) {K : Set (P × E)}
    (hK : ∀ p : P × E, p ∉ K → φ p.1 p.2 = p.2)
    {p : P × F} (hp : p ∉ (fun q : P × E => (q.1,c q.2)) '' K) :
    conjugate c (φ p.1) p.2 = p.2 := by
  by_cases hx : p.2 ∈ c.target
  · rw [conjugate_of_mem c _ hx]
    have hq : (p.1,c.symm p.2) ∉ K := by
      intro h
      apply hp
      exact ⟨(p.1,c.symm p.2),h,by simp only [c.right_inv hx]⟩
    rw [hK _ hq,c.right_inv hx]
  · exact conjugate_of_notMem c _ hx

theorem conjugate_smooth_compact (c : OpenPartialHomeomorph E F)
    (hcs : c.source = univ) (hc : ContDiff ℝ ∞ c)
    (hci : ContDiffOn ℝ ∞ c.symm c.target)
    (φ : P → E → E) (hφ : ContDiff ℝ ∞ (fun p : P × E => φ p.1 p.2))
    (hφc : HasCompactSupport (fun p : P × E => φ p.1 p.2-p.2)) :
    ContDiff ℝ ∞ (fun p : P × F => conjugate c (φ p.1) p.2) ∧
      HasCompactSupport (fun p : P × F => conjugate c (φ p.1) p.2-p.2) ∧
      tsupport (fun p : P × F => conjugate c (φ p.1) p.2-p.2) ⊆
        (fun q : P × E => (q.1,c q.2)) '' tsupport (fun p : P × E => φ p.1 p.2-p.2) := by
  let K : Set (P × F) := (fun q : P × E => (q.1,c q.2)) ''
    tsupport (fun p : P × E => φ p.1 p.2-p.2)
  have hK : IsCompact K := hφc.image (continuous_fst.prodMk (hc.continuous.comp continuous_snd))
  have he (p : P × F) (hp : p ∉ K) : conjugate c (φ p.1) p.2 = p.2 := by
    apply conjugate_eq_of_notMem_image c φ (K := tsupport (fun p : P × E => φ p.1 p.2-p.2)) _ hp
    intro q hq
    exact sub_eq_zero.mp (image_eq_zero_of_notMem_tsupport (f := fun p : P × E => φ p.1 p.2-p.2) hq)
  have hsupport : tsupport (fun p : P × F => conjugate c (φ p.1) p.2-p.2) ⊆ K := by
    apply closure_minimal _ hK.isClosed
    intro p hp
    by_contra h
    exact hp (sub_eq_zero.mpr (he p h))
  refine ⟨?_,hK.of_isClosed_subset (isClosed_tsupport _) hsupport,hsupport⟩
  rw [contDiff_iff_contDiffAt]
  intro p
  by_cases hp : p.2 ∈ c.target
  · have hi := (hci p.2 hp).contDiffAt (c.open_target.mem_nhds hp)
    have hd := hc.contDiffAt.comp p (hφ.contDiffAt.comp p
      (contDiffAt_fst.prodMk (hi.comp p contDiffAt_snd)))
    apply hd.congr_of_eventuallyEq
    filter_upwards [(c.open_target.preimage continuous_snd).mem_nhds hp] with q hq
    exact conjugate_of_mem c _ hq
  · have hn : p ∉ K := by
      rintro ⟨q,hq,rfl⟩
      exact hp (c.map_source (by rw [hcs]; trivial))
    apply contDiffAt_snd.congr_of_eventuallyEq
    filter_upwards [hK.isClosed.isOpen_compl.mem_nhds hn] with q hq
    exact he q hq

omit [NormedSpace ℝ E] [NormedSpace ℝ P] in
theorem inverse_displacement_compact (φ : P → E ≃ₜ E)
    (hφ : HasCompactSupport (fun p : P × E => φ p.1 p.2-p.2)) :
    HasCompactSupport (fun p : P × E => (φ p.1).symm p.2-p.2) := by
  apply HasCompactSupport.intro hφ
  intro p hp
  have he : φ p.1 p.2 = p.2 := sub_eq_zero.mp (image_eq_zero_of_notMem_tsupport (f := fun p : P × E => φ p.1 p.2-p.2) hp)
  rw [sub_eq_zero]
  apply (φ p.1).injective
  rw [(φ p.1).apply_symm_apply,he]

def conjugateHomeomorph (c : OpenPartialHomeomorph E F)
    (hcs : c.source = univ) (hc : ContDiff ℝ ∞ c)
    (hci : ContDiffOn ℝ ∞ c.symm c.target)
    (φ : E ≃ₜ E) (hφ : ContDiff ℝ ∞ φ) (hφi : ContDiff ℝ ∞ φ.symm)
    (hφc : HasCompactSupport (fun p : E => φ p-p)) : F ≃ₜ F where
  toEquiv := conjugateEquiv c hcs φ.toEquiv
  continuous_toFun := by
    have hj : ContDiff ℝ ∞ (fun p : (Fin 0 → ℝ) × E => φ p.2) := hφ.comp contDiff_snd
    have hk : HasCompactSupport (fun p : (Fin 0 → ℝ) × E => φ p.2-p.2) := by
      apply HasCompactSupport.intro ((isCompact_univ : IsCompact (univ : Set (Fin 0 → ℝ))).prod hφc)
      intro p hp
      exact image_eq_zero_of_notMem_tsupport (f := fun q : E => φ q-q)
        (fun h => hp ⟨mem_univ _,h⟩)
    have hs := (conjugate_smooth_compact c hcs hc hci (fun _ : Fin 0 → ℝ => φ) hj hk).1
    exact (hs.comp ((contDiff_const (c := (0 : Fin 0 → ℝ))).prodMk contDiff_id)).continuous
  continuous_invFun := by
    have hj : ContDiff ℝ ∞ (fun p : (Fin 0 → ℝ) × E => φ.symm p.2) := hφi.comp contDiff_snd
    have hk : HasCompactSupport (fun p : (Fin 0 → ℝ) × E => φ p.2-p.2) := by
      apply HasCompactSupport.intro ((isCompact_univ : IsCompact (univ : Set (Fin 0 → ℝ))).prod hφc)
      intro p hp
      exact image_eq_zero_of_notMem_tsupport (f := fun q : E => φ q-q)
        (fun h => hp ⟨mem_univ _,h⟩)
    have hki := inverse_displacement_compact (fun _ : Fin 0 → ℝ => φ) hk
    have hs := (conjugate_smooth_compact c hcs hc hci (fun _ : Fin 0 → ℝ => φ.symm) hj hki).1
    exact (hs.comp ((contDiff_const (c := (0 : Fin 0 → ℝ))).prodMk contDiff_id)).continuous

omit [NormedSpace ℝ E] [NormedSpace ℝ F] in
theorem conjugate_image (c : OpenPartialHomeomorph E F) (hc : c.source = univ)
    (φ : E → E) (A : Set E) : conjugate c φ '' (c '' A) = c '' (φ '' A) := by
  rw [image_image,image_image]
  apply image_congr
  intro x _
  exact conjugate_apply c hc φ x

theorem conjugate_contDiffAt_of_mem (c : OpenPartialHomeomorph E F)
    (hc : ContDiff ℝ ∞ c) (hci : ContDiffOn ℝ ∞ c.symm c.target)
    (φ : E → E) (hφ : ContDiff ℝ ∞ φ) {x : F} (hx : x ∈ c.target) :
    ContDiffAt ℝ ∞ (conjugate c φ) x := by
  have hi := (hci x hx).contDiffAt (c.open_target.mem_nhds hx)
  have hd := hc.contDiffAt.comp x (hφ.contDiffAt.comp x hi)
  apply hd.congr_of_eventuallyEq
  filter_upwards [c.open_target.mem_nhds hx] with q hq
  exact conjugate_of_mem c φ hq

theorem chart_fderiv_right_inverse (c : OpenPartialHomeomorph E F)
    (hc : ContDiff ℝ ∞ c) (hci : ContDiffOn ℝ ∞ c.symm c.target)
    {x : F} (hx : x ∈ c.target) (v : F) :
    fderiv ℝ c (c.symm x) (fderiv ℝ c.symm x v) = v := by
  have hi := ((hci x hx).contDiffAt (c.open_target.mem_nhds hx)).differentiableAt (by simp)
  have hd := ((hc.differentiable (by simp)) _).hasFDerivAt.comp x hi.hasFDerivAt
  have he : (id : F → F) =ᶠ[𝓝 x] (c ∘ c.symm) := by
    filter_upwards [c.open_target.mem_nhds hx] with q hq
    exact (c.right_inv hq).symm
  have hder := (hd.congr_of_eventuallyEq he).fderiv
  have hv := congrArg (fun L : F →L[ℝ] F => L v) hder
  simpa only [fderiv_id,ContinuousLinearMap.id_apply,ContinuousLinearMap.comp_apply] using hv.symm

theorem conjugate_fderiv_chart (c : OpenPartialHomeomorph E F)
    (hcs : c.source = univ) (hc : ContDiff ℝ ∞ c)
    (hci : ContDiffOn ℝ ∞ c.symm c.target)
    (φ : E → E) (hφ : ContDiff ℝ ∞ φ) (x v : E) :
    fderiv ℝ (conjugate c φ) (c x) (fderiv ℝ c x v) =
      fderiv ℝ c (φ x) (fderiv ℝ φ x v) := by
  have hx : c x ∈ c.target := c.map_source (by rw [hcs]; trivial)
  have hd := (conjugate_contDiffAt_of_mem c hc hci φ hφ hx).differentiableAt (by simp)
  have hl := hd.hasFDerivAt.comp x (((hc.differentiable (by simp)) x).hasFDerivAt)
  have hr := (((hc.differentiable (by simp)) (φ x)).hasFDerivAt).comp x
    (((hφ.differentiable (by simp)) x).hasFDerivAt)
  have he : (conjugate c φ ∘ c) = (c ∘ φ) := funext (conjugate_apply c hcs φ)
  rw [he] at hl
  have hder := hl.unique hr
  exact congrArg (fun L : E →L[ℝ] F => L v) hder

omit [NormedSpace ℝ E] [NormedSpace ℝ P] in
theorem fiber_displacement_compact (φ : P → E → E)
    (hφ : HasCompactSupport (fun p : P × E => φ p.1 p.2-p.2)) (y : P) :
    HasCompactSupport (fun p : E => φ y p-p) := by
  apply HasCompactSupport.intro (hφ.image continuous_snd)
  intro x hx
  exact image_eq_zero_of_notMem_tsupport (f := fun p : P × E => φ p.1 p.2-p.2)
    (fun h => hx ⟨(y,x),h,rfl⟩)

theorem exists_conjugate_family (c : OpenPartialHomeomorph E F)
    (hcs : c.source = univ) (hc : ContDiff ℝ ∞ c)
    (hci : ContDiffOn ℝ ∞ c.symm c.target)
    (Φ : P → E ≃ₜ E) (hΦ : ContDiff ℝ ∞ (fun p : P × E => Φ p.1 p.2))
    (hΦi : ContDiff ℝ ∞ (fun p : P × E => (Φ p.1).symm p.2))
    (hΦc : HasCompactSupport (fun p : P × E => Φ p.1 p.2-p.2)) :
    ∃ Ψ : P → F ≃ₜ F,
      (∀ y x, Ψ y x = conjugate c (Φ y) x) ∧
      ContDiff ℝ ∞ (fun p : P × F => Ψ p.1 p.2) ∧
      ContDiff ℝ ∞ (fun p : P × F => (Ψ p.1).symm p.2) ∧
      HasCompactSupport (fun p : P × F => Ψ p.1 p.2-p.2) ∧
      tsupport (fun p : P × F => Ψ p.1 p.2-p.2) ⊆
        univ ×ˢ c.target := by
  let Ψ : P → F ≃ₜ F := fun y => conjugateHomeomorph c hcs hc hci (Φ y)
    (hΦ.comp (contDiff_const.prodMk contDiff_id))
    (hΦi.comp (contDiff_const.prodMk contDiff_id))
    (fiber_displacement_compact (fun y => Φ y) hΦc y)
  have hs := conjugate_smooth_compact c hcs hc hci (fun y => Φ y) hΦ hΦc
  have hsi := conjugate_smooth_compact c hcs hc hci (fun y => (Φ y).symm) hΦi
    (inverse_displacement_compact Φ hΦc)
  refine ⟨Ψ,fun _ _ => rfl,hs.1,hsi.1,hs.2.1,?_⟩
  intro p hp
  obtain ⟨q,_,rfl⟩ := hs.2.2 hp
  exact ⟨mem_univ _,c.map_source (by rw [hcs]; trivial)⟩

end PackingSufficiencySupport.Chart
end

end OAI