lean/OAI/Geometry/BallPacking/Packings/ComplementPacking.lean

import Mathlib
import OAI.Geometry.BallPacking.BallMaps.QuadricRelativeShellFlow

namespace OAI

noncomputable section

namespace PackingSufficiencySupport
open scoped ContDiff Manifold Topology BigOperators
open Set Function Manifold
open Hamiltonian DiagonalQuadrics DiagonalQuadrics.Explicit

 theorem actual_complement_packing (m : ℕ) {N : ℕ} [Nonempty (Fin N)]
    (r r' : Fin N → ℝ) (hr : ∀ i,0<r i) (hr' : ∀ i,0≤r' i)
    (hrr : ∀ i,r' i<r i) {a₀ : ℝ} (ha₀ : 0<a₀) (ha₁ : a₀<1)
    (hrs : ∀ i,r i<1-a₀) (hhalf : ∀ i,r i<1/2)
    (hvol : ∑ i,r i^(m+4)<1-a₀^(m+4)) :
    ∃ b : ℝ,b<1-a₀ ∧ ∃ f : Fin N → Ambient (m+4) → Ambient (m+4),
      (∀ i,IsBallEmbedding (r' i) (f i)) ∧
      (∀ i,f i '' closedBall (m+4) (r' i)⊆openBall (m+4) 1) ∧
      (∀ i,∀ x∈closedBall (m+4) (r' i),Real.pi*Complex.normSq (f i x 0)<b) ∧
      Pairwise (fun i j => Disjoint (f i '' closedBall (m+4) (r' i))
        (f j '' closedBall (m+4) (r' j))) := by
  obtain ⟨b,d,t,hb,hd,hdhalf,_ht,φ,hφ,hφb,hdisj⟩ :=
    actual_large_polynomial_packing m r r' hr hr' hrr ha₀ ha₁ hrs hhalf hvol
  obtain ⟨g,hg,hgemb,hgmem,hgfirst,hgform⟩ :=
    exists_polynomial_first_line_target (parameters m) t hd.le hdhalf
  have hφdom (i : Fin N) : MapsTo (φ i) (closedBall (m+4) (r' i)) firstDiskDomain := by
    intro x hx
    exact (hφb i x hx).trans (by linarith : b<1)
  have hform (x : Affine (m+2) × Plane) (hx : x∈firstDiskDomain) (v w) :
      successorStandardForm (m+3)
        (mfderiv 𝓘(ℝ,Affine (m+2) × Plane) 𝓘(ℝ,Ambient (m+4)) g x v)
        (mfderiv 𝓘(ℝ,Affine (m+2) × Plane) 𝓘(ℝ,Ambient (m+4)) g x w)=
      euclideanExteriorOneForm (firstLinePrimitive
        (normalAmbientPrimitive (parameters m) (1/Real.pi) d t)) x v w := by
    rw [mfderiv_eq_fderiv]
    exact (successorStandardForm_apply _ _ _).trans (hgform x hx v w)
  obtain ⟨hf,hdj⟩ := postcompose_form_packing (fun i => closedBall (m+4) (r' i))
    (fun _ => successorStandardForm (m+3))
    (euclideanExteriorOneForm (firstLinePrimitive
      (normalAmbientPrimitive (parameters m) (1/Real.pi) d t)))
    (fun _ => successorStandardForm (m+3)) firstDiskDomain_open g
    hg.contMDiffOn hgemb hform φ hφ hφdom hdisj
  refine ⟨b,hb,fun i => g ∘ φ i,
    fun i => isBallEmbedding_iff_formNeighborhoodEmbedding.mpr (hf i),?_,?_,hdj⟩
  · intro i y hy
    obtain ⟨x,hx,rfl⟩ := hy
    exact hgmem _ (hφdom i hx)
  · intro i x hx
    change Real.pi*Complex.normSq (g (φ i x) 0)<b
    rw [hgfirst]
    exact hφb i x hx

end PackingSufficiencySupport

namespace PackingSufficiencySupport.Hamiltonian
open scoped ContDiff Topology
open Set Function

 theorem exists_shifted_planar_embedding {A δ b : ℝ} (hA : 0≤A) (hδ : 0<δ) (hb : 0≤b) :
    ∃ p : Plane → Plane,
      (∀ x,radialArea x≤A → ContDiffAt ℝ ∞ p x) ∧
      InjOn p {x | radialArea x≤A} ∧
      (∀ x,radialArea x≤A → ∀ v w,
        planarArea (fderiv ℝ p x v) (fderiv ℝ p x w)=planarArea v w) ∧
      ∀ x,radialArea x≤A → b<radialArea (p x) ∧ radialArea (p x)<radialArea x+b+δ := by
  obtain ⟨q,hq,_hqi,hqform,hqbound⟩ := exists_thin_planar_embedding hA hδ
  let l : Plane → Plane := fun x => q x+(b,0)
  have hl : ContDiff ℝ ∞ l := hq.add contDiff_const
  have hlD (x v : Plane) : fderiv ℝ l x v=fderiv ℝ q x v := by
    rw [show l=(fun x => q x+(b,0)) from rfl,fderiv_add_const]
  let p : Plane → Plane := areaPolar ∘ l
  have hldom {x : Plane} (hx : radialArea x≤A) : l x∈areaPolarDomain := by
    obtain ⟨hx0,_hxu,hxθ⟩ := hqbound x hx
    exact ⟨by change 0<(q x).1+b; linarith,by simpa only [l,Prod.snd_add,add_zero] using hxθ⟩
  refine ⟨p,fun x hx => (areaPolar_smoothAt (hldom hx).1).comp x hl.contDiffAt,?_,?_,?_⟩
  · intro x hx y hy he
    have hh := areaPolar_injOn (hldom hx) (hldom hy) he
    exact q.injective (add_right_cancel hh)
  · intro x hx v w
    rw [show p=areaPolar ∘ l from rfl,
      fderiv_comp x ((areaPolar_smoothAt (hldom hx).1).differentiableAt (by simp))
        (hl.differentiable (by simp) x)]
    change planarArea (fderiv ℝ areaPolar (l x) (fderiv ℝ l x v))
      (fderiv ℝ areaPolar (l x) (fderiv ℝ l x w))=_
    rw [planarArea_map,areaPolar_det (hldom hx).1,one_mul,hlD,hlD,hqform]
  · intro x hx
    have hc : radialArea (p x)=(q x).1+b := areaPolar_capacity (hldom hx).1.le
    rw [hc]
    obtain ⟨hq0,hqδ,_⟩ := hqbound x hx
    constructor <;> linarith

 def headPlanarMap (n : ℕ) (p : Plane → Plane) : Ambient (n+1) → Ambient (n+1) :=
  headComplexAmbient n ∘ (fun x => (x.1,p x.2)) ∘ (headComplexAmbient n).symm

 theorem headComplexAmbient_split_capacity (n : ℕ) (x : Ambient (n+1)) :
    capacity ((headComplexAmbient n).symm x).1+radialArea ((headComplexAmbient n).symm x).2=capacity x := by
  rw [← headComplexAmbient_capacity,(headComplexAmbient n).apply_symm_apply]

 theorem headComplexAmbient_head_le {n : ℕ} {A : ℝ} {x : Ambient (n+1)}
    (hx : x∈closedBall (n+1) A) : radialArea ((headComplexAmbient n).symm x).2≤A := by
  have hc := capacity_nonneg ((headComplexAmbient n).symm x).1
  have hs := headComplexAmbient_split_capacity n x
  change capacity x≤A at hx
  linarith

 theorem headPlanarMap_capacity (n : ℕ) (p : Plane → Plane) (x : Ambient (n+1)) :
    capacity (headPlanarMap n p x)=
      capacity ((headComplexAmbient n).symm x).1+radialArea (p ((headComplexAmbient n).symm x).2) :=
  headComplexAmbient_capacity n _

 theorem headPlanarMap_first (n : ℕ) (p : Plane → Plane) (x : Ambient (n+1)) :
    Real.pi*Complex.normSq (headPlanarMap n p x 0)=radialArea (p ((headComplexAmbient n).symm x).2) := by
  change Real.pi*Complex.normSq (⟨(p ((headComplexAmbient n).symm x).2).1,
    (p ((headComplexAmbient n).symm x).2).2⟩ : ℂ)=_
  simp only [Complex.normSq_apply,radialArea,radiusSq,pow_two]

 theorem headPlanarMap_smoothAt {n : ℕ} {p : Plane → Plane} {x : Ambient (n+1)}
    (hp : ContDiffAt ℝ ∞ p ((headComplexAmbient n).symm x).2) :
    ContDiffAt ℝ ∞ (headPlanarMap n p) x :=
  (headComplexAmbient n).contDiff.contDiffAt.comp _
    ((contDiffAt_fst.prodMk (hp.comp _ contDiffAt_snd)).comp x
      (headComplexAmbient n).symm.contDiff.contDiffAt)

 theorem headPlanarMap_fderiv {n : ℕ} {p : Plane → Plane} {x : Ambient (n+1)}
    (hp : ContDiffAt ℝ ∞ p ((headComplexAmbient n).symm x).2) (v : Ambient (n+1)) :
    fderiv ℝ (headPlanarMap n p) x v=headComplexAmbient n
      (((headComplexAmbient n).symm v).1,
        fderiv ℝ p ((headComplexAmbient n).symm x).2 ((headComplexAmbient n).symm v).2) := by
  let e := headComplexAmbient n
  have hdF := (hasFDerivAt_fst (𝕜 := ℝ) (p := e.symm x)).prodMk
    ((hp.differentiableAt (by simp)).hasFDerivAt.comp _ (hasFDerivAt_snd (𝕜 := ℝ) (p := e.symm x)))
  have hdf := e.hasFDerivAt.comp x (hdF.comp x e.symm.hasFDerivAt)
  change HasFDerivAt (headPlanarMap n p) _ x at hdf
  rw [hdf.fderiv]
  rfl

 theorem headPlanarMap_injOn {n : ℕ} {p : Plane → Plane} {A : ℝ}
    (hp : InjOn p {x | radialArea x≤A}) : InjOn (headPlanarMap n p) (closedBall (n+1) A) := by
  intro x hx y hy he
  let e := headComplexAmbient n
  have hF : ((e.symm x).1,p (e.symm x).2)=((e.symm y).1,p (e.symm y).2) := e.injective he
  have hfst := congrArg (fun z : Ambient n × Plane => z.1) hF
  have hsnd := congrArg (fun z : Ambient n × Plane => z.2) hF
  apply e.symm.injective
  exact Prod.ext hfst (hp (headComplexAmbient_head_le hx) (headComplexAmbient_head_le hy) hsnd)

 theorem headPlanarMap_form {n : ℕ} {p : Plane → Plane} {x : Ambient (n+1)}
    (hp : ContDiffAt ℝ ∞ p ((headComplexAmbient n).symm x).2)
    (hf : ∀ v w,planarArea (fderiv ℝ p ((headComplexAmbient n).symm x).2 v)
      (fderiv ℝ p ((headComplexAmbient n).symm x).2 w)=planarArea v w) (v w : Ambient (n+1)) :
    standardForm (fderiv ℝ (headPlanarMap n p) x v) (fderiv ℝ (headPlanarMap n p) x w)=standardForm v w := by
  rw [headPlanarMap_fderiv hp,headPlanarMap_fderiv hp,headComplexAmbient_form,hf]
  change standardForm ((headComplexAmbient n).symm v).1 ((headComplexAmbient n).symm w).1+
    planarArea ((headComplexAmbient n).symm v).2 ((headComplexAmbient n).symm w).2=_
  rw [← headComplexAmbient_form]
  simp only [(headComplexAmbient n).apply_symm_apply]

end PackingSufficiencySupport.Hamiltonian

namespace PackingSufficiencySupport
open scoped ContDiff Topology
open Set Function
open Hamiltonian

 theorem exists_distinguished_ball_embedding (n : ℕ) {A b : ℝ}
    (hA : 0≤A) (hb : 0≤b) (hAb : A+b<1) :
    ∃ f : Ambient (n+1) → Ambient (n+1),IsBallEmbedding A f ∧
      f '' closedBall (n+1) A ⊆ openBall (n+1) 1 ∧
      ∀ x∈closedBall (n+1) A,b<Real.pi*Complex.normSq (f x 0) := by
  obtain ⟨A',hAA',hA'b⟩ := exists_between (show A<1-b by linarith)
  obtain ⟨δ,hδ,hδb⟩ := exists_between (show (0:ℝ)<1-b-A' by linarith)
  obtain ⟨p,hp,hpInj,hpform,hpcap⟩ := exists_shifted_planar_embedding (hA.trans hAA'.le) hδ hb
  let f := headPlanarMap n p
  have hf {x : Ambient (n+1)} (hx : x∈closedBall (n+1) A') : ContDiffAt ℝ ∞ f x :=
    headPlanarMap_smoothAt (hp _ (headComplexAmbient_head_le hx))
  have hfemb : Topology.IsEmbedding (fun x : closedBall (n+1) A' => f x.val) := by
    let : CompactSpace (closedBall (n+1) A') := isCompact_iff_compactSpace.mp (closedBall_isCompact _ _)
    have hc : ContinuousOn f (closedBall (n+1) A') := fun x hx => (hf hx).continuousAt.continuousWithinAt
    exact (hc.domRestrict.isClosedEmbedding (fun x y he =>
      Subtype.ext (headPlanarMap_injOn hpInj x.property y.property he))).isEmbedding
  refine ⟨f,⟨openBall (n+1) A',openBall_isOpen _ _,?_,?_,?_,?_⟩,?_,?_⟩
  · intro x hx
    exact (show capacity x≤A from hx).trans_lt hAA'
  · intro x hx
    exact (hf (show capacity x≤A' from le_of_lt hx)).contDiffWithinAt
  · exact hfemb.comp (Topology.IsEmbedding.inclusion (fun x hx => (show capacity x<A' from hx).le))
  · intro x hx v w
    have hh := headComplexAmbient_head_le (show capacity x≤A' from (show capacity x<A' from hx).le)
    exact headPlanarMap_form (hp _ hh) (hpform _ hh) v w
  · rintro y ⟨x,hx,rfl⟩
    have hx' : x∈closedBall (n+1) A' := (show capacity x≤A from hx).trans hAA'.le
    change capacity (headPlanarMap n p x)<1
    rw [headPlanarMap_capacity]
    have hbq := (hpcap _ (headComplexAmbient_head_le hx')).2
    have hs := headComplexAmbient_split_capacity n x
    change capacity x≤A at hx
    linarith
  · intro x hx
    have hx' : x∈closedBall (n+1) A' := (show capacity x≤A from hx).trans hAA'.le
    change b<Real.pi*Complex.normSq (headPlanarMap n p x 0)
    rw [headPlanarMap_first]
    exact (hpcap _ (headComplexAmbient_head_le hx')).1

end PackingSufficiencySupport

namespace PackingSufficiencySupport.DiagonalQuadrics
open scoped ContDiff Manifold Topology
open Set Function Manifold
open Hamiltonian

variable {m : ℕ} (a : Fin m → ℂ) [Fact (Injective a)] [Fact (∀ j,a j≠0)]

 theorem exists_actual_normal_transfer {d : ℝ} (hd : 0<d) (hdhalf : d<1/2)
    {K : Set (NormalSpace a)} (hK : IsCompact K)
    (hKd : ∀ p∈K,phaseSq p.2<d/Real.pi) :
    ∃ t : ℝ,0<t ∧ ∃ g : NormalSpace a → Affine m,∃ W : Set (NormalSpace a),
      IsOpen W ∧ K⊆W ∧ ContMDiff 𝓘(ℝ,NormalModel m) 𝓘(ℝ,Affine m) ∞ g ∧
      Topology.IsEmbedding (fun x : W => g x.val) ∧
      ∀ x∈W,∀ v w,normalAmbientForm a (1/Real.pi) d t (g x)
        (manifoldMapDifferential (E := Affine m) (F := NormalModel m) g x v)
        (manifoldMapDifferential (E := Affine m) (F := NormalModel m) g x w)=
        globalHorizontalCoupling phaseArea (normalHorizontalPrimitive (q := m) a 2 ∘ planeMoments) x v w := by
  let : SigmaCompactSpace (locus a) := IsClosed.sigmaCompactSpace (locus_isClosed a)
  obtain ⟨Ξ,hΞ,D,hD,hKD,hDd,hΞemb,hΞeq⟩ := exists_compact_radial_bridge a hd hK hKd
  have hIK : IsCompact (Ξ '' K) := hK.image hΞ.continuous
  obtain ⟨Ψ,Γ,δ,hδ,U,hU,hUK,hΨ,hΓ,hΓ0,hΨemb,hΓform⟩ :=
    exists_actual_normal_exact_family a (hIK.image continuous_fst) (hIK.image continuous_snd) (1/Real.pi) d
  have hKU : MapsTo Ξ K U := by
    intro x hx
    exact hUK ⟨⟨Ξ x,⟨x,hx,rfl⟩,rfl⟩,⟨Ξ x,⟨x,hx,rfl⟩,rfl⟩⟩
  let Δ : ℝ → ManifoldOneForm (NormalModel m) (NormalSpace a) := manifoldPullbackOneForm Γ Ξ
  have hΔ : SmoothOneFormFamily Δ := manifoldPullbackOneForm_smooth hΞ hΓ
  have hΔ0 (x : NormalSpace a) (hx : x∈D) : Δ 0 x=normalCouplingPrimitive a x := by
    change manifoldPullbackOneForm Γ Ξ 0 x=_
    have h := cone_radial_primitive a hd hΞ (hDd x hx)
      (hΞeq.eventuallyEq_of_mem (hD.mem_nhds hx))
    simpa only [manifoldPullbackOneForm,hΓ0] using h
  have hΔext (x : NormalSpace a) (hx : x∈D) :
      manifoldExteriorOneForm (Δ 0) x=manifoldExteriorOneForm (normalCouplingPrimitive a) x := by
    apply manifoldExteriorOneForm_congr_germ
    filter_upwards [hD.mem_nhds hx] with y hy
    exact hΔ0 y hy
  have hinv (x : NormalSpace a) (hx : x∈K) : (manifoldExteriorOneForm (Δ 0) x).IsInvertible := by
    rw [hΔext x (hKD hx)]
    apply normalCoupling_invertible a hdhalf
    simpa only [mul_comm] using ((lt_div_iff₀ Real.pi_pos).mp (hKd x hx)).le
  let A : ℝ × NormalSpace a → Affine m := fun p => Ψ (p.1,Ξ p.2)
  have hA : ContMDiff ((𝓘(ℝ,ℝ)).prod 𝓘(ℝ,NormalModel m)) 𝓘(ℝ,Affine m) ∞ A :=
    hΨ.comp (contMDiff_fst.prodMk (hΞ.comp contMDiff_snd))
  let V := D∩Ξ ⁻¹' U
  have hV : IsOpen V := hD.inter (hU.preimage hΞ.continuous)
  have hKV : K⊆V := fun x hx => ⟨hKD hx,hKU hx⟩
  have htI {t : ℝ} (ht : t∈Ioc (0:ℝ) δ) : t∈Icc (-δ) δ := ⟨by linarith [ht.1],ht.2⟩
  have hAemb (t : ℝ) (ht : t∈Ioc (0:ℝ) δ) : Topology.IsEmbedding (fun x : V => A (t,x.val)) := by
    exact (hΨemb t (htI ht) (ne_of_gt ht.1)).comp
      (((hΞemb.comp (Topology.IsEmbedding.inclusion inter_subset_left)).codRestrict U)
        (fun x : V => x.property.2))
  have hAform (t : ℝ) (ht : t∈Ioc (0:ℝ) δ) (x : NormalSpace a) (hx : x∈V) :
      manifoldExteriorOneForm (Δ t) x=(normalAmbientForm a (1/Real.pi) d t (A (t,x))).bilinearComp
        (manifoldMapDifferential (E := Affine m) (F := NormalModel m) (fun y => A (t,y)) x)
        (manifoldMapDifferential (E := Affine m) (F := NormalModel m) (fun y => A (t,y)) x) := by
    have hs := hΨ.comp (contMDiff_const.prodMk contMDiff_id) (f := fun y : ConeSpace a => (t,y))
    have he := manifold_pullback_exterior (fun c y hy => (hΓ.spatial_smooth t c hy).contDiffWithinAt) hΞ x
    change manifoldExteriorOneForm (Δ t) x=
      (manifoldExteriorOneForm (Γ t) (Ξ x)).bilinearComp
        (manifoldMapDifferential (E := ConeModel m) (F := NormalModel m) Ξ x)
        (manifoldMapDifferential (E := ConeModel m) (F := NormalModel m) Ξ x) at he
    rw [he,hΓform t (htI ht) (ne_of_gt ht.1) (Ξ x) hx.2]
    have hdiff := manifoldMapDifferential_comp
      (hs.mdifferentiable (by simp) (Ξ x)) (hΞ.mdifferentiable (by simp) x)
    change manifoldMapDifferential (E := Affine m) (F := NormalModel m) (fun y => A (t,y)) x=_ at hdiff
    rw [hdiff]
    rfl
  obtain ⟨t,ht,g,W,hW,hKW,hg,hgemb,hgform⟩ := exists_compact_exact_fibre_embedding
    hΔ hK hinv hV hKV hδ hA hAemb (fun t => normalAmbientForm a (1/Real.pi) d t) hAform
  refine ⟨t,ht.1,g,W∩D,hW.inter hD,fun x hx => ⟨hKW hx,hKD hx⟩,hg,
    hgemb.comp (Topology.IsEmbedding.inclusion inter_subset_left),?_⟩
  intro x hx v w
  have he := hgform x hx.1 v w
  rw [hΔext x hx.2,normalCouplingPrimitive_exterior] at he
  exact he

end PackingSufficiencySupport.DiagonalQuadrics

namespace PackingSufficiencySupport.DiagonalQuadrics.Explicit
open scoped ContDiff Manifold Topology BigOperators
open Set Function Manifold
open Hamiltonian MomentPolytope

 theorem actual_small_polynomial_packing (m : ℕ) {N : ℕ} [Nonempty (Fin N)]
    (r r' : Fin N → ℝ) (hr : ∀ i,0<r i) (hr' : ∀ i,0≤r' i)
    (hrr : ∀ i,r' i<r i) (hhalf : ∀ i,r i<1/2)
    (hvol : ∑ i,r i^(m+3)<1) :
    ∃ d t : ℝ,0<d ∧ d<1/2 ∧ 0<t ∧
      ∃ f : Fin N → Ambient (m+3) → Affine (m+2),
        (∀ i,FormNeighborhoodEmbedding (closedBall (m+3) (r' i))
          (fun _ => successorStandardForm (m+2))
          (normalAmbientForm (parameters m) (1/Real.pi) d t) (f i)) ∧
        Pairwise (fun i j => Disjoint (f i '' closedBall (m+3) (r' i))
          (f j '' closedBall (m+3) (r' j))) := by
  classical
  obtain ⟨h,d,hrh,hhd,hdhalf,ℓ,φ,hφ,hφK,hdisj⟩ :=
    actual_small_normal_packing m r r' hr hr' hrr hhalf hvol
  let K : Set (NormalSpace (parameters m)) := ⋃ i,φ i '' closedBall (m+3) (r' i)
  have hK : IsCompact K := by
    apply isCompact_iUnion
    intro i
    obtain ⟨U,_hU,hKU,hs,_he,_hf⟩ := hφ i
    exact (closedBall_isCompact (m+3) (r' i)).image_of_continuousOn (hs.continuousOn.mono hKU)
  have hhdR : (h:ℝ)<d := by exact_mod_cast hhd
  have hd : 0<(d:ℝ) := by
    obtain ⟨i⟩ := ‹Nonempty (Fin N)›
    exact ((hr i).trans (hrh i)).trans hhdR
  have hKd (p : NormalSpace (parameters m)) (hp : p∈K) : phaseSq p.2<(d:ℝ)/Real.pi := by
    obtain ⟨i,x,hx,rfl⟩ := mem_iUnion.mp hp
    have hm := (interior_subset (hφK i hx)).2.2
    have he : (∑ j,planeMoments (φ i x).2 j)=Real.pi*phaseSq (φ i x).2 := by
      simp only [planeMoments,radialArea,radiusSq,phaseSq,phaseDot_apply,pow_two,← Finset.mul_sum]
    rw [he] at hm
    exact (lt_div_iff₀ Real.pi_pos).mpr (by simpa only [mul_comm] using hm.trans_lt hhdR)
  obtain ⟨t,ht,g,W,hW,hKW,hg,hgemb,hgform⟩ :=
    exists_actual_normal_transfer (parameters m) hd hdhalf hK hKd
  obtain ⟨hf,hdj⟩ := postcompose_form_packing (fun i => closedBall (m+3) (r' i))
    (fun _ => successorStandardForm (m+2))
    (globalHorizontalCoupling phaseArea (normalHorizontalPrimitive (parameters m) 2 ∘ planeMoments))
    (normalAmbientForm (parameters m) (1/Real.pi) d t)
    hW g hg.contMDiffOn hgemb hgform φ hφ
    (fun i x hx => hKW (mem_iUnion.mpr ⟨i,x,hx,rfl⟩)) hdisj
  exact ⟨d,t,hd,hdhalf,ht,fun i => g ∘ φ i,hf,hdj⟩

end PackingSufficiencySupport.DiagonalQuadrics.Explicit

namespace PackingSufficiencySupport
open scoped ContDiff Manifold Topology BigOperators
open Set Function Manifold
open Hamiltonian DiagonalQuadrics DiagonalQuadrics.Explicit
open CubicModel

 theorem hasPacking_small_enlarged (m : ℕ) {N : ℕ} [Nonempty (Fin N)]
    (r r' : Fin N → ℝ) (hr : ∀ i,0<r i) (hr' : ∀ i,0≤r' i)
    (hrr : ∀ i,r' i<r i) (hhalf : ∀ i,r i<1/2)
    (hvol : ∑ i,r i^(m+3)<1) : HasPacking (m+3) N 1 r' := by
  obtain ⟨d,t,hd,hdhalf,_ht,φ,hφ,hdisj⟩ :=
    actual_small_polynomial_packing m r r' hr hr' hrr hhalf hvol
  obtain ⟨g,hg,hgemb,hgmem,hgform⟩ :=
    exists_polynomial_target_embedding (parameters m) t
      (one_div_pos.mpr Real.pi_pos) hd.le hdhalf
  have hform (x : Affine (m+2)) (_hx : x∈(univ : Set (Affine (m+2)))) (v w) :
      successorStandardForm (m+2) (mfderiv 𝓘(ℝ,Affine (m+2)) 𝓘(ℝ,Ambient (m+3)) g x v)
        (mfderiv 𝓘(ℝ,Affine (m+2)) 𝓘(ℝ,Ambient (m+3)) g x w)=
      normalAmbientForm (parameters m) (1/Real.pi) d t x v w := by
    rw [mfderiv_eq_fderiv]
    exact (successorStandardForm_apply _ _ _).trans (hgform x v w)
  obtain ⟨hf,hdj⟩ := postcompose_form_packing (fun i => closedBall (m+3) (r' i))
    (fun _ => successorStandardForm (m+2))
    (normalAmbientForm (parameters m) (1/Real.pi) d t)
    (fun _ => successorStandardForm (m+2)) isOpen_univ g hg.contMDiff.contMDiffOn
    (hgemb.comp Topology.IsEmbedding.subtypeVal) hform φ hφ
    (fun _ _ _ => mem_univ _) hdisj
  refine ⟨fun i => g ∘ φ i,fun i => isBallEmbedding_iff_formNeighborhoodEmbedding.mpr (hf i),?_,?_⟩
  · intro i y hy
    obtain ⟨x,_hx,rfl⟩ := hy
    simpa only [mul_one_div_cancel Real.pi_ne_zero,Function.comp_apply] using hgmem (φ i x)
  · intro i j hij
    exact hdj hij

 theorem hasPacking_small_normalized {n N : ℕ} (hn : 3≤n) (hN : 1≤N)
    (r : Fin N → ℝ) (hr : ∀ i,0<r i) (hhalf : ∀ i,r i<1/2)
    (hvol : ∑ i,r i^n<1) : HasPacking n N 1 r := by
  obtain ⟨m,rfl⟩ := Nat.exists_eq_add_of_le hn
  have hs : 3+m=m+3 := Nat.add_comm _ _
  simp only [hs] at hvol ⊢
  let : NeZero N := ⟨by omega⟩
  obtain ⟨q,hq,hqhalf,hqvol⟩ := rational_small_slack (m+3) r hhalf hvol
  exact hasPacking_small_enlarged m (fun i => (q i:ℝ)) r
    (fun i => (hr i).trans (hq i)) (fun i => (hr i).le) hq hqhalf hqvol

 theorem hasPacking_small {n N : ℕ} (hn : 3≤n) (hN : 1≤N)
    {R : ℝ} (hR : 0<R) (r : Fin N → ℝ) (hr : ∀ i,0<r i)
    (hhalf : ∀ i,r i<R/2) (hvol : ∑ i,r i^n<R^n) :
    HasPacking n N R r := by
  apply (hasPacking_normalize hR).mpr
  apply hasPacking_small_normalized hn hN (fun i => r i/R)
    (fun i => div_pos (hr i) hR)
  · intro i
    apply (div_lt_iff₀ hR).mpr
    nlinarith [hhalf i]
  · simp only [div_pow,←Finset.sum_div]
    exact (div_lt_one (pow_pos hR n)).mpr hvol

 theorem hasPacking_large_enlarged (m : ℕ) {N : ℕ} [Nonempty (Fin N)]
    (r r' : Fin (N+1) → ℝ) (hr : ∀ i,0<r i) (hr' : ∀ i,0≤r' i)
    (hrr : ∀ i,r' i<r i) (hlarge : 1/2≤r 0)
    (hvol : ∑ i,r i^(m+4)<1) (hpair : ∀ i j,i≠j → r i+r j<1) :
    HasPacking (m+4) (N+1) 1 r' := by
  have ha : r 0<1 := by
    obtain ⟨i⟩ := ‹Nonempty (Fin N)›
    have hp := hpair 0 i.succ (Fin.succ_ne_zero i).symm
    linarith [hr i.succ]
  have htail (i : Fin N) : r i.succ<1-r 0 := by
    have := hpair 0 i.succ (Fin.succ_ne_zero i).symm
    linarith
  have htvol : ∑ i : Fin N,r i.succ^(m+4)<1-r 0^(m+4) := by
    rw [Fin.sum_univ_succ] at hvol
    linarith
  obtain ⟨b,hb,f,hf,hfmem,hfb,hfd⟩ := actual_complement_packing m
    (fun i => r i.succ) (fun i => r' i.succ) (fun i => hr i.succ)
    (fun i => hr' i.succ) (fun i => hrr i.succ) (hr 0) ha htail
    (fun i => by linarith [htail i]) htvol
  have hb0 : 0≤b := by
    obtain ⟨i⟩ := ‹Nonempty (Fin N)›
    have hzero : (0 : Ambient (m+4))∈closedBall (m+4) (r' i.succ) := by
      simpa only [closedBall,mem_ofPred_eq,capacity,Pi.zero_apply,Complex.normSq_zero,
        Finset.sum_const_zero,mul_zero] using hr' i.succ
    have h := hfb i 0 hzero
    exact (mul_nonneg Real.pi_pos.le (Complex.normSq_nonneg _)).trans h.le
  obtain ⟨g,hg,hgmem,hgb⟩ := exists_distinguished_ball_embedding (m+3) (hr' 0) hb0
    (by linarith [hrr 0])
  let F : Fin (N+1) → Ambient (m+4) → Ambient (m+4) := Fin.cons g f
  refine ⟨F,?_,?_,?_⟩
  · intro i
    exact Fin.cases hg hf i
  · intro i
    exact Fin.cases hgmem hfmem i
  · have hgf (i : Fin N) : Disjoint (g '' closedBall (m+4) (r' 0))
        (f i '' closedBall (m+4) (r' i.succ)) := by
      apply Set.disjoint_left.mpr
      rintro y ⟨x,hx,rfl⟩ ⟨z,hz,he⟩
      have hl := hgb x hx
      have hu := hfb i z hz
      rw [he] at hu
      exact (not_lt_of_ge hl.le) hu
    intro i
    refine Fin.cases ?_ (fun i => ?_) i
    · intro j
      refine Fin.cases ?_ (fun j _ => hgf j) j
      intro hij
      exact False.elim (hij rfl)
    · intro j
      refine Fin.cases (fun _ => Disjoint.symm (hgf i)) (fun j hij => ?_) j
      apply hfd
      intro he
      exact hij (congrArg Fin.succ he)

 theorem HasPacking.reindex {n N : ℕ} {R : ℝ} {r : Fin N → ℝ}
    (hp : HasPacking n N R r) (e : Equiv.Perm (Fin N)) :
    HasPacking n N R (r ∘ e) := by
  obtain ⟨f,hf,hm,hd⟩ := hp
  exact ⟨f ∘ e,fun i => hf (e i),fun i => hm (e i),
    fun i j hij => hd (e i) (e j) (fun h => hij (e.injective h))⟩

 theorem hasPacking_large_normalized (m : ℕ) {N : ℕ} [Nonempty (Fin N)]
    (r : Fin (N+1) → ℝ) (hr : ∀ i,0<r i) (hlarge : 1/2≤r 0)
    (hvol : ∑ i,r i^(m+4)<1) (hpair : ∀ i j,i≠j → r i+r j<1) :
    HasPacking (m+4) (N+1) 1 r := by
  obtain ⟨q,hq,hqvol,hqpair⟩ := rational_packing_slack (m+4) 1 r (by simpa using hvol) hpair
  exact hasPacking_large_enlarged m (fun i => (q i:ℝ)) r (fun i => (hr i).trans (hq i))
    (fun i => (hr i).le) hq (hlarge.trans (hq 0).le) (by simpa using hqvol) hqpair

 theorem hasPacking_dim_ge_four_normalized {n N : ℕ} (hn : 4≤n) (hN : 1≤N)
    (r : Fin N → ℝ) (hr : ∀ i,0<r i)
    (hvol : ∑ i,r i^n<1) (hpair : ∀ i j,i≠j → r i+r j<1) : HasPacking n N 1 r := by
  classical
  by_cases hsmall : ∀ i,r i<1/2
  · exact hasPacking_small_normalized (by omega) hN r hr hsmall hvol
  obtain ⟨j,hj⟩ := not_forall.mp hsmall
  have hj : 1/2≤r j := le_of_not_gt hj
  obtain ⟨m,hm⟩ := Nat.exists_eq_add_of_le hn
  have hn' : n=m+4 := by omega
  clear hm
  subst n
  cases N with
  | zero => omega
  | succ K =>
    cases K with
    | zero =>
      have heqr : r=(fun _ => r 0) := funext fun i => congrArg r (Fin.eq_zero i)
      rw [heqr] at hvol ⊢
      apply (hasPacking_one_iff (by omega) zero_lt_one (hr 0)).mpr
      exact lt_of_pow_lt_pow_left₀ (m+4) zero_le_one (by simpa using hvol)
    | succ K =>
      let e : Equiv.Perm (Fin (K+1+1)) := Equiv.swap 0 j
      have hrvol : ∑ i,(r (e i))^(m+4)<1 := by
        rw [show (∑ i,r (e i)^(m+4))=(∑ i,r i^(m+4)) from
          Equiv.sum_comp e (fun i => r i^(m+4))]
        exact hvol
      have hrlarge : 1/2≤(r ∘ e) 0 := by
        simpa only [Function.comp_apply,e,Equiv.swap_apply_left] using hj
      have hp := hasPacking_large_normalized m (r ∘ e) (fun i => hr (e i))
        hrlarge hrvol (fun i j hij => hpair (e i) (e j) (fun h => hij (e.injective h)))
      have hh := hp.reindex e.symm
      simpa only [Function.comp_def,Equiv.apply_symm_apply] using hh

 theorem hasPacking_dim_ge_four {n N : ℕ} (hn : 4≤n) (hN : 1≤N)
    {R : ℝ} (hR : 0<R) (r : Fin N → ℝ) (hr : ∀ i,0<r i)
    (hvol : ∑ i,r i^n<R^n) (hpair : ∀ i j,i≠j → r i+r j<R) : HasPacking n N R r := by
  apply (hasPacking_normalize hR).mpr
  apply hasPacking_dim_ge_four_normalized hn hN (fun i => r i/R) (fun i => div_pos (hr i) hR)
  · simp only [div_pow,← Finset.sum_div]
    exact (div_lt_one (pow_pos hR n)).mpr hvol
  · intro i j hij
    rw [← add_div]
    exact (div_lt_one hR).mpr (hpair i j hij)

 theorem hasPacking_six_large_normalized {N : ℕ} [Nonempty (Fin N)]
    (r : Fin (N+1) → ℝ) (hr : ∀ i,0<r i) (hlarge : 1/2≤r 0)
    (hvol : ∑ i,r i^3<1) (hpair : ∀ i j,i≠j → r i+r j<1) :
    HasPacking 3 (N+1) 1 r := by
  obtain ⟨q,hq,hqvol,hqpair⟩ := rational_packing_slack 3 1 r (by simpa using hvol) hpair
  have ha : (1:ℚ)/2<q 0 := by
    have hh : (1:ℝ)/2<(q 0:ℝ) := hlarge.trans_lt (hq 0)
    apply (Rat.cast_lt (K := ℝ)).mp
    simpa using hh
  have ha1 : q 0<1 := by
    obtain ⟨i⟩ := ‹Nonempty (Fin N)›
    have hh := hqpair 0 i.succ (Fin.succ_ne_zero i).symm
    have hp := (hr i.succ).trans (hq i.succ)
    have h : (q 0:ℝ)<1 := by linarith
    exact_mod_cast h
  have htail (i : Fin N) : (q i.succ:ℝ)<1-(q 0:ℝ) := by
    have hh := hqpair 0 i.succ (Fin.succ_ne_zero i).symm
    linarith
  have htvol : ∑ i : Fin N,(q i.succ:ℝ)^3<1-(q 0:ℝ)^3 := by
    rw [Fin.sum_univ_succ] at hqvol
    norm_num at hqvol
    linarith
  have hp := actual_six_standard_packing (fun i => (q i.succ:ℝ)) (fun i => r i.succ)
    (fun i => (hr i.succ).trans (hq i.succ)) (fun i => (hr i.succ).le)
    (fun i => hq i.succ) ha ha1 htail htvol (hr 0).le (hq 0)
  have he : Fin.cons (r 0) (fun i => r i.succ)=r := by
    funext i
    exact Fin.cases rfl (fun _ => rfl) i
  rwa [he] at hp

 theorem hasPacking_six_normalized {N : ℕ} (hN : 1≤N)
    (r : Fin N → ℝ) (hr : ∀ i,0<r i)
    (hvol : ∑ i,r i^3<1) (hpair : ∀ i j,i≠j → r i+r j<1) : HasPacking 3 N 1 r := by
  classical
  by_cases hsmall : ∀ i,r i<1/2
  · exact hasPacking_small_normalized (by omega) hN r hr hsmall hvol
  obtain ⟨j,hj⟩ := not_forall.mp hsmall
  have hj : 1/2≤r j := le_of_not_gt hj
  cases N with
  | zero => omega
  | succ K =>
    cases K with
    | zero =>
      have heqr : r=(fun _ => r 0) := funext fun i => congrArg r (Fin.eq_zero i)
      rw [heqr] at hvol ⊢
      apply (hasPacking_one_iff (by omega) zero_lt_one (hr 0)).mpr
      exact lt_of_pow_lt_pow_left₀ 3 zero_le_one (by simpa using hvol)
    | succ K =>
      let e : Equiv.Perm (Fin (K+1+1)) := Equiv.swap 0 j
      have hrvol : ∑ i,(r (e i))^3<1 := by
        rw [show (∑ i,r (e i)^3)=(∑ i,r i^3) from Equiv.sum_comp e (fun i => r i^3)]
        exact hvol
      have hrlarge : 1/2≤(r ∘ e) 0 := by
        simpa only [Function.comp_apply,e,Equiv.swap_apply_left] using hj
      have hp := hasPacking_six_large_normalized (r ∘ e) (fun i => hr (e i))
        hrlarge hrvol (fun i j hij => hpair (e i) (e j) (fun h => hij (e.injective h)))
      have hh := hp.reindex e.symm
      simpa only [Function.comp_def,Equiv.apply_symm_apply] using hh

 theorem hasPacking_of_inequalities {n N : ℕ} (hn : 3≤n) (hN : 1≤N)
    {R : ℝ} (hR : 0<R) (r : Fin N → ℝ) (hr : ∀ i,0<r i)
    (hvol : ∑ i,r i^n<R^n) (hpair : ∀ i j,i≠j → r i+r j<R) : HasPacking n N R r := by
  by_cases hfour : 4≤n
  · exact hasPacking_dim_ge_four hfour hN hR r hr hvol hpair
  have hn3 : n=3 := by omega
  subst n
  apply (hasPacking_normalize hR).mpr
  apply hasPacking_six_normalized hN (fun i => r i/R) (fun i => div_pos (hr i) hR)
  · simp only [div_pow,← Finset.sum_div]
    exact (div_lt_one (pow_pos hR 3)).mpr hvol
  · intro i j hij
    rw [← add_div]
    exact (div_lt_one hR).mpr (hpair i j hij)

end PackingSufficiencySupport

namespace HigherDimensionalBallPacking
open scoped ContDiff Topology
open Set Function
open scoped BigOperators

 theorem HasPacking.subfamily {n k ℓ : ℕ} {R : ℝ} {r : Fin k → ℝ}
    (hp : HasPacking n k R r) (e : Fin ℓ ↪ Fin k) :
    HasPacking n ℓ R (r ∘ e) := by
   obtain ⟨U,f,hf,hd⟩ := hp
   exact ⟨U ∘ e,f ∘ e,fun i => hf (e i),
     fun i j hij => hd (e i) (e j) (fun he => hij (e.injective he))⟩

 theorem HasPacking.two_balls {n k : ℕ} {R : ℝ} {r : Fin k → ℝ}
    (hp : HasPacking n k R r) {i j : Fin k} (hij : i≠j) :
    HasPacking n 2 R ![r i,r j] := by
   let e : Fin 2 ↪ Fin k := ⟨![i,j],by
     intro a b he
     fin_cases a <;> fin_cases b
     · rfl
     · exact False.elim (hij he)
     · exact False.elim (hij he.symm)
     · rfl⟩
   have he : r ∘ e=![r i,r j] := by
     funext a
     fin_cases a <;> rfl
   simpa only [he] using hp.subfamily e

 theorem HasPacking.two_balls_smaller_target {n k : ℕ} {R : ℝ} {r : Fin k → ℝ}
    (hp : HasPacking n k R r) (hR : 0<R) {i j : Fin k} (hij : i≠j) :
    ∃ σ,0<σ ∧ σ<R ∧ HasPacking n 2 σ ![r i,r j] := by
   obtain ⟨σ,hσ,hσR,hpσ⟩ := (hasPacking_iff_support.mp hp).exists_smaller_target hR
   exact ⟨σ,hσ,hσR,(hasPacking_iff_support.mpr hpσ).two_balls hij⟩

 theorem HasPacking.unit_pair_counterexample {n k : ℕ} {R : ℝ} {r : Fin k → ℝ}
    (hp : HasPacking n k R r) (hR : 0<R) (hr : ∀ i,0<r i)
    {i j : Fin k} (hij : i≠j) (hbad : R≤r i+r j) :
    ∃ a b : ℝ,0<a ∧ 0<b ∧ 1<a+b ∧ HasPacking n 2 1 ![a,b] := by
   obtain ⟨σ,hσ,hσR,hpσ⟩ := hp.two_balls_smaller_target hR hij
   have hp' := (PackingSufficiencySupport.hasPacking_normalize hσ).mp
     (hasPacking_iff_support.mp hpσ)
   have he : (fun l : Fin 2 => (![r i,r j] : Fin 2 → ℝ) l/σ)=![r i/σ,r j/σ] := by
     funext l
     fin_cases l <;> rfl
   refine ⟨r i/σ,r j/σ,div_pos (hr i) hσ,div_pos (hr j) hσ,?_,?_⟩
   · rw [←add_div]
     exact (one_lt_div hσ).mpr (hσR.trans_le hbad)
   · apply hasPacking_iff_support.mpr
     simpa only [he] using hp'

theorem hasPacking_of_inequalities_dim_ge_four {n k : ℕ} (hn : 4≤n) (hk : 1≤k)
    {R : ℝ} {r : Fin k → ℝ} (hR : 0<R) (hr : ∀ i,0<r i)
    (h : PackingInequalities n k R r) : HasPacking n k R r := by
  exact hasPacking_iff_support.mpr
    (PackingSufficiencySupport.hasPacking_dim_ge_four hn hk hR r hr h.1 h.2)

theorem hasPacking_all_small {n k : ℕ} (hn : 3≤n) (hk : 1≤k)
    {R : ℝ} {r : Fin k → ℝ} (hR : 0<R) (hr : ∀ i,0<r i)
    (hsmall : ∀ i,r i<R/2) (hvol : ∑ i,r i^n<R^n) : HasPacking n k R r := by
  exact hasPacking_iff_support.mpr
    (PackingSufficiencySupport.hasPacking_small hn hk hR r hr hsmall hvol)

theorem hasPacking_of_inequalities {n k : ℕ} (hn : 3≤n) (hk : 1≤k)
    {R : ℝ} {r : Fin k → ℝ} (hR : 0<R) (hr : ∀ i,0<r i)
    (h : PackingInequalities n k R r) : HasPacking n k R r := by
  exact hasPacking_iff_support.mpr
    (PackingSufficiencySupport.hasPacking_of_inequalities hn hk hR r hr h.1 h.2)

theorem one_ball_main {n : ℕ} (hn : 3≤n) {R : ℝ} {r : Fin 1 → ℝ}
    (hR : 0<R) (hr : ∀ i,0<r i) :
    HasPacking n 1 R r ↔ PackingInequalities n 1 R r := by
  constructor
  · intro hp
    refine ⟨hp.volume_lt (by omega) hR hr,?_⟩
    intro i j hij
    exact False.elim (hij (Subsingleton.elim i j))
  · intro h
    have hn0 : 0<n := by omega
    have hrR : r 0<R := by
      apply lt_of_pow_lt_pow_left₀ n hR.le
      simpa using h.1
    have heqr : r=(fun _ => r 0) := funext (fun i => congrArg r (Fin.eq_zero i))
    apply hasPacking_iff_support.mpr
    rw [heqr]
    exact (PackingSufficiencySupport.hasPacking_one_iff hn0 hR (hr 0)).mpr hrR

end HigherDimensionalBallPacking
end

end OAI