import Mathlib
import OAI.Geometry.BallPacking.Normal.QuadricMovingCone

namespace OAI

noncomputable section

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

 theorem actual_large_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) {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 d t : ℝ,b<1-a₀ ∧ 0<d ∧ d<1/2 ∧ 0<t ∧
      ∃ f : Fin N → Ambient (m+4) → Affine (m+2) × Plane,
        (∀ i,FormNeighborhoodEmbedding (closedBall (m+4) (r' i))
          (fun _ => successorStandardForm (m+3))
          (euclideanExteriorOneForm (firstLinePrimitive
            (normalAmbientPrimitive (parameters m) (1/Real.pi) d t))) (f i)) ∧
        (∀ i,∀ x∈closedBall (m+4) (r' i),radialArea (f i x).2<b) ∧
        Pairwise (fun i j => Disjoint (f i '' closedBall (m+4) (r' i))
          (f j '' closedBall (m+4) (r' j))) := by
  classical
  obtain ⟨h₁,h₂,d₁,d₂,_hr₁,hhd₁,hd₁,hr₂,hhd₂,hd₂,ℓ,φ,hφ,hφK,hdisj⟩ :=
    actual_large_normal_packing m r r' hr hr' hrr ha₀ ha₁ hrs hhalf hvol
  let K : Set (LargeNormalSpace (parameters m)) := ⋃ i,φ i '' closedBall (m+4) (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+4) (r' i)).image_of_continuousOn (hs.continuousOn.mono hKU)
  have hh₁d₁ : (h₁:ℝ)<d₁ := by exact_mod_cast hhd₁
  have hh₂d₂ : (h₂:ℝ)<d₂ := by exact_mod_cast hhd₂
  have hd : 0<(d₂:ℝ) := by
    obtain ⟨i⟩ := ‹Nonempty (Fin N)›
    exact ((hr i).trans (hr₂ i)).trans hh₂d₂
  have hKb (x : LargeNormalSpace (parameters m)) (hx : x∈K) :
      radialArea (normalHead (m+2) x.2)<(d₁:ℝ) := by
    obtain ⟨i,y,hy,rfl⟩ := mem_iUnion.mp hx
    have hm := (interior_subset (hφK i hy)).2.2 0
    simp only [largeModelBounds,Fin.sum_univ_succ,Matrix.cons_val_zero,
      Fin.cons_zero,Fin.cons_succ,zero_mul,Finset.sum_const_zero,
      add_zero,one_mul] at hm
    exact hm.trans_lt hh₁d₁
  have hKd (x : LargeNormalSpace (parameters m)) (hx : x∈K) :
      Real.pi*phaseSq (normalTail (m+2) x.2)<(d₂:ℝ)*(1-radialArea (normalHead (m+2) x.2)) := by
    have hu := hKb x hx
    have hu1 : radialArea (normalHead (m+2) x.2)<1 := hu.trans (by linarith)
    obtain ⟨i,y,hy,rfl⟩ := mem_iUnion.mp hx
    have hm := (interior_subset (hφK i hy)).2.2 1
    rw [Fin.sum_univ_succ] at hm
    simp only [largeModelBounds,Matrix.cons_val_one,
      Matrix.cons_val_zero,Fin.cons_zero,Fin.cons_succ,one_mul] at hm
    have he : (∑ j : Fin (m+2),planeMoments (φ i y).2 j.succ)=
        Real.pi*phaseSq (normalTail (m+2) (φ i y).2) := by
      simp only [planeMoments,radialArea,radiusSq,phaseSq,phaseDot_apply,
        normalTail,ContinuousLinearMap.pi_apply,ContinuousLinearMap.proj_apply,
        pow_two,← Finset.mul_sum]
    rw [he] at hm
    have hmul := mul_lt_mul_of_pos_right hh₂d₂ (sub_pos.mpr hu1)
    change (h₂:ℝ)*radialArea (normalHead (m+2) (φ i y).2)+_≤(h₂:ℝ) at hm
    linarith
  obtain ⟨t,ht,g,W,hW,hKW,hg,hgemb,hginto,hgform⟩ :=
    exists_actual_large_normal_transfer (parameters m) (by linarith : (d₁:ℝ)<1)
      hd hd₂ hK hKb hKd
  obtain ⟨hf,hdj⟩ := postcompose_form_packing (fun i => closedBall (m+4) (r' i))
    (fun _ => successorStandardForm (m+3))
    (globalHorizontalCoupling phaseArea (largeHorizontalPrimitive (q := m+2) (parameters m) ∘ planeMoments))
    (euclideanExteriorOneForm (firstLinePrimitive
      (normalAmbientPrimitive (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₁,d₂,t,hd₁,hd,hd₂,ht,fun i => g ∘ φ i,hf,
    fun i x hx => hginto _ (hKW (mem_iUnion.mpr ⟨i,x,hx,rfl⟩)),hdj⟩

end PackingSufficiencySupport.DiagonalQuadrics.Explicit

namespace PackingSufficiencySupport.Hamiltonian
open scoped ContDiff Manifold Topology
open Function Filter
open Set
open Manifold
section

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

 theorem primitivePullback_exterior_at {α : F → F →L[ℝ] ℝ} {g : E → F} {x : E}
    (hα : ContDiffAt ℝ ∞ α (g x)) (hg : ContDiffAt ℝ ∞ g x) :
    euclideanExteriorOneForm (primitivePullback α g) x=
      (euclideanExteriorOneForm α (g x)).bilinearComp (fderiv ℝ g x) (fderiv ℝ g x) := by
  have hs : ContDiffAt ℝ ∞ (chartOneForm α (g x)) (extChartAt 𝓘(ℝ,F) (g x) (g x)) := by
    rw [show chartOneForm α (g x)=α from funext (vector_chartOneForm α (g x))]
    simpa only [extChartAt_model_space_eq_id,PartialEquiv.refl_coe,id_eq] using hα
  have hh := manifold_pullback_exterior_at (α := α) (g := g) hs hg.contMDiffAt
  have he : manifoldPullbackOneForm (fun _ => α) g 0=primitivePullback α g := by
    funext z
    simp [manifoldPullbackOneForm,manifoldMapDifferential,mfderiv_eq_fderiv,primitivePullback]
  rw [he] at hh
  simpa only [vector_exteriorOneForm,manifoldPullbackOneForm,manifoldPullbackTwoForm,
    manifoldMapDifferential,mfderiv_eq_fderiv,primitivePullback] using hh

 theorem euclideanExteriorOneForm_congr_nhds {α β : E → E →L[ℝ] ℝ} {x : E}
    (he : α =ᶠ[𝓝 x] β) : euclideanExteriorOneForm α x=euclideanExteriorOneForm β x := by
  simp only [euclideanExteriorOneForm,he.fderiv_eq]

end
section

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

 def firstDiskDomain : Set (V × Plane) := {x | radialArea x.2<1}
omit [NormedSpace ℝ V] in
 theorem firstDiskDomain_open : IsOpen (firstDiskDomain (V := V)) :=
  isOpen_lt (radialArea_smooth.continuous.comp continuous_snd) continuous_const

 def firstDiskScale (x : V × Plane) : V × Plane :=
  (Real.sqrt (1-radialArea x.2) • x.1,x.2)
 def firstDiskUnscale (x : V × Plane) : V × Plane :=
  ((Real.sqrt (1-radialArea x.2))⁻¹ • x.1,x.2)

 theorem firstDiskScale_smoothOn :
    ContDiffOn ℝ ∞ (firstDiskScale (V := V)) firstDiskDomain :=
  (((contDiffOn_const.sub (radialArea_smooth.comp contDiff_snd).contDiffOn).sqrt
    (fun _ hx => (sub_pos.mpr hx).ne')).smul contDiffOn_fst).prodMk contDiffOn_snd

 theorem firstDiskUnscale_smoothOn :
    ContDiffOn ℝ ∞ (firstDiskUnscale (V := V)) firstDiskDomain :=
  ((((contDiffOn_const.sub (radialArea_smooth.comp contDiff_snd).contDiffOn).sqrt
    (fun _ hx => (sub_pos.mpr hx).ne')).inv
      (fun _ hx => (Real.sqrt_pos.mpr (sub_pos.mpr hx)).ne')).smul contDiffOn_fst).prodMk contDiffOn_snd

 def firstDiskScaleHomeomorph : firstDiskDomain (V := V) ≃ₜ firstDiskDomain (V := V) where
  toEquiv :=
    { toFun := fun x => ⟨firstDiskScale x.val,x.property⟩
      invFun := fun x => ⟨firstDiskUnscale x.val,x.property⟩
      left_inv := by
        intro x
        apply Subtype.ext
        apply Prod.ext
        · change (Real.sqrt (1-radialArea x.val.2))⁻¹ •
            (Real.sqrt (1-radialArea x.val.2) • x.val.1)=x.val.1
          rw [smul_smul,inv_mul_cancel₀ (Real.sqrt_pos.mpr (sub_pos.mpr x.property)).ne',one_smul]
        · rfl
      right_inv := by
        intro x
        apply Subtype.ext
        apply Prod.ext
        · change Real.sqrt (1-radialArea x.val.2) •
            ((Real.sqrt (1-radialArea x.val.2))⁻¹ • x.val.1)=x.val.1
          rw [smul_smul,mul_inv_cancel₀ (Real.sqrt_pos.mpr (sub_pos.mpr x.property)).ne',one_smul]
        · rfl }
  continuous_toFun := (firstDiskScale_smoothOn.continuousOn.comp_continuous
    continuous_subtype_val (fun x => x.property)).subtype_mk _
  continuous_invFun := (firstDiskUnscale_smoothOn.continuousOn.comp_continuous
    continuous_subtype_val (fun x => x.property)).subtype_mk _

 theorem firstDiskScale_isEmbedding :
    Topology.IsEmbedding (fun x : firstDiskDomain (V := V) => firstDiskScale x.val) :=
  Topology.IsEmbedding.subtypeVal.comp firstDiskScaleHomeomorph.isEmbedding

variable {ι : Type} [Fintype ι]
 def phasePlusPlanePrimitive (x : PlanePhase ι × Plane) : (PlanePhase ι × Plane) →L[ℝ] ℝ :=
  (standardLiouville x.1).comp (ContinuousLinearMap.fst ℝ _ _)+
    (linearLiouville planarArea x.2).comp (ContinuousLinearMap.snd ℝ _ _)

 theorem phasePlusPlanePrimitive_smooth : ContDiff ℝ ∞ (phasePlusPlanePrimitive (ι := ι)) :=
  (((standardLiouville_smooth (ι := ι)).comp contDiff_fst).clm_comp contDiff_const).add
    (((linearLiouville_smooth planarArea).comp contDiff_snd).clm_comp contDiff_const)

 def firstDiskRadial (c : ℝ) (x : PlanePhase ι × Plane) : PlanePhase ι × Plane :=
  firstDiskScale (fsBallMap c x.1,x.2)

 theorem firstDiskRadial_smoothOn (c : ℝ) :
    ContDiffOn ℝ ∞ (firstDiskRadial (ι := ι) c) firstDiskDomain :=
  firstDiskScale_smoothOn.comp
    (((fsBallMap_smooth c).comp contDiff_fst).prodMk contDiff_snd).contDiffOn (fun _ hx => hx)

 theorem firstDiskRadial_isEmbedding {c : ℝ} (hc : 0<c) :
    Topology.IsEmbedding (fun x : firstDiskDomain (V := PlanePhase ι) => firstDiskRadial c x.val) := by
  have he : Topology.IsEmbedding (fun x : PlanePhase ι × Plane => (fsBallMap c x.1,x.2)) :=
    (fsBallMap_isEmbedding hc).prodMap Topology.IsEmbedding.id
  exact firstDiskScale_isEmbedding.comp
    ((he.comp Topology.IsEmbedding.subtypeVal).codRestrict firstDiskDomain (fun x => x.property))

 theorem firstDiskRadial_primitive {c : ℝ} (hc : 0≤c) {x : PlanePhase ι × Plane}
    (hx : x∈firstDiskDomain) :
    primitivePullback phasePlusPlanePrimitive (firstDiskRadial c) x=
      firstLinePrimitive (affineFSPrimitive c) x := by
  apply ContinuousLinearMap.ext
  intro u
  let s : PlanePhase ι × Plane → ℝ := fun y => Real.sqrt (1-radialArea y.2)
  let w : PlanePhase ι × Plane → PlanePhase ι := fun y => fsBallMap c y.1
  have hs : ContDiffAt ℝ ∞ s x :=
    ((contDiff_const.sub (radialArea_smooth.comp contDiff_snd)).contDiffAt).sqrt (sub_pos.mpr hx).ne'
  have hw : ContDiff ℝ ∞ w := (fsBallMap_smooth c).comp contDiff_fst
  have hD := (((hs.differentiableAt (by simp)).smul (hw.differentiable (by simp) x)).hasFDerivAt.prodMk
    (hasFDerivAt_snd (𝕜 := ℝ) (p := x))).fderiv
  change fderiv ℝ (firstDiskRadial c) x=_ at hD
  change phasePlusPlanePrimitive (firstDiskRadial c x) (fderiv ℝ (firstDiskRadial c) x u)=_
  rw [hD]
  change linearLiouville phaseArea (s x • w x) (fderiv ℝ (fun y => s y • w y) x u)+
    linearLiouville planarArea x.2 u.2=_
  rw [linearLiouville_variable_smul phaseArea phaseArea_self (hs.differentiableAt (by simp))
    (hw.differentiable (by simp) x)]
  have hwD := ((fsBallMap_hasFDerivAt c x.1).comp x (hasFDerivAt_fst (𝕜 := ℝ) (p := x))).fderiv
  change fderiv ℝ w x=_ at hwD
  rw [hwD]
  rw [← (fsBallMap_hasFDerivAt c x.1).fderiv]
  change (Real.sqrt (1-radialArea x.2))^2*
    standardLiouville (fsBallMap c x.1) (fderiv ℝ (fsBallMap c) x.1 u.1)+
      linearLiouville planarArea x.2 u.2=_
  rw [Real.sq_sqrt (sub_pos.mpr hx).le,fsBallMap_primitive hc,firstLinePrimitive_apply]
  ring

 theorem firstDiskRadial_exterior {c : ℝ} (hc : 0≤c) {x : PlanePhase ι × Plane}
    (hx : x∈firstDiskDomain) :
    (euclideanExteriorOneForm phasePlusPlanePrimitive (firstDiskRadial c x)).bilinearComp
      (fderiv ℝ (firstDiskRadial c) x) (fderiv ℝ (firstDiskRadial c) x)=
        euclideanExteriorOneForm (firstLinePrimitive (affineFSPrimitive c)) x := by
  rw [← primitivePullback_exterior_at (phasePlusPlanePrimitive_smooth (ι := ι)).contDiffAt
    ((firstDiskRadial_smoothOn c).contDiffAt (firstDiskDomain_open.mem_nhds hx))]
  exact euclideanExteriorOneForm_congr_nhds
    (Filter.eventually_of_mem (firstDiskDomain_open.mem_nhds hx) (fun _ hy => firstDiskRadial_primitive hc hy))

end
section

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

theorem euclideanTimeField_smooth {V : ℝ × E → E} (hV : ContDiff ℝ ∞ V) :
    ContMDiff ((𝓘(ℝ,ℝ)).prod 𝓘(ℝ,E)) (𝓘(ℝ,E)).tangent ∞
      (fun p => (⟨p.2,V p⟩ : TangentBundle 𝓘(ℝ,E) E)) := by
  rw [← modelWithCornersSelf_prod, chartedSpaceSelf_prod]
  have h := (contDiff_snd.prodMk hV).contMDiff
  have hh := contMDiff_tangentBundleModelSpaceHomeomorph_symm (I := 𝓘(ℝ,E)) (n := ∞)
  rw [ModelWithCorners.tangent, ← modelWithCornersSelf_prod] at hh
  exact hh.comp h

theorem euclidean_nonautonomous_curve_eqOn_Icc
    {V : ℝ × E → E} (hV : ContDiff ℝ ∞ V) {γ δ : ℝ → E}
    (hγ : ∀ s∈Icc (0:ℝ) 1,HasDerivAt γ (V (s,γ s)) s)
    (hδ : ∀ s∈Icc (0:ℝ) 1,HasDerivAt δ (V (s,δ s)) s)
    (h0 : γ 0=δ 0) : EqOn γ δ (Icc (0:ℝ) 1) := by
  exact nonautonomous_curve_eqOn_Icc (euclideanTimeField_smooth hV)
    (fun s hs => hasMFDerivAt_iff_hasFDerivAt.mpr (hγ s hs).hasFDerivAt)
    (fun s hs => hasMFDerivAt_iff_hasFDerivAt.mpr (hδ s hs).hasFDerivAt) h0

theorem closed_flow_linear_equivariant_on
    {V Φ : ℝ × E → E} (hV : ContDiff ℝ ∞ V)
    (hODE : ∀ x s,s∈Icc (0:ℝ) 1 → HasDerivAt (fun r => Φ (r,x)) (V (s,Φ (s,x))) s)
    (hΦ0 : ∀ x,Φ (0,x)=x) {K : Set E}
    (hstay : ∀ s∈Icc (0:ℝ) 1,∀ x∈K,Φ (s,x)∈K)
    (U : E →L[ℝ] E)
    (hrel : ∀ s∈Icc (0:ℝ) 1,∀ x∈K,V (s,U x)=U (V (s,x))) :
    ∀ s∈Icc (0:ℝ) 1,∀ x∈K,Φ (s,U x)=U (Φ (s,x)) := by
  intro s hs x hx
  apply euclidean_nonautonomous_curve_eqOn_Icc hV
    (fun r hr => hODE (U x) r hr) ?_ ?_ hs
  · intro r hr
    have hd := U.hasFDerivAt.comp_hasDerivAt r (hODE x r hr)
    simpa only [Function.comp_def, hrel r hr _ (hstay r hr x hx)] using hd
  · simp only [hΦ0]

theorem closed_flow_linear_fixed_on
    {V Φ : ℝ × E → E} (hV : ContDiff ℝ ∞ V)
    (hODE : ∀ x s,s∈Icc (0:ℝ) 1 → HasDerivAt (fun r => Φ (r,x)) (V (s,Φ (s,x))) s)
    (hΦ0 : ∀ x,Φ (0,x)=x) {K : Set E}
    (hstay : ∀ s∈Icc (0:ℝ) 1,∀ x∈K,Φ (s,x)∈K)
    (U : E →L[ℝ] E)
    (hrel : ∀ s∈Icc (0:ℝ) 1,∀ x∈K,V (s,U x)=U (V (s,x)))
    {x : E} (hx : x∈K) (hUx : U x=x) {s : ℝ} (hs : s∈Icc (0:ℝ) 1) :
    U (Φ (s,x))=Φ (s,x) := by
  simpa only [hUx] using (closed_flow_linear_equivariant_on hV hODE hΦ0 hstay U hrel s hs x hx).symm

end

variable {ι κ : Type*} [Fintype ι] [Fintype κ]

theorem homogeneousCone_shell_flow_linear_equivariant
    {F : PlanePhase ι → PlanePhase κ} (hF : ContDiff ℝ ∞ F)
    (hF0 : ∀ z,z≠0 → F z≠0)
    (hD : ∀ z,fderiv ℝ F z z=(2:ℝ)•F z)
    (hJ : ∀ z v,fderiv ℝ F z (phaseJ v)=phaseJ (fderiv ℝ F z v))
    {c d a b : ℝ} (hc : 0<c) (hd : 0≤d) (hdhalf : d<1/2) (ha : 0<a)
    {Φ V : ℝ × PlanePhase ι → PlanePhase ι}
    (hΦ0 : ∀ x,Φ (0,x)=x)
    (hΦr : ∀ s∈Icc (0:ℝ) 1,∀ x,phaseSq (Φ (s,x))=phaseSq x)
    (hV : ContDiff ℝ ∞ V)
    (hODE : ∀ x s,s∈Ioo (-2:ℝ) 2 → HasDerivAt (fun r => Φ (r,x)) (V (s,Φ (s,x))) s)
    (hVe : ∀ s∈Icc (0:ℝ) 1,∀ x∈phaseShell a b,V (s,x)=homogeneousConeField F c d s x)
    (U : PlanePhase ι ≃L[ℝ] PlanePhase ι) (T : PlanePhase κ →L[ℝ] PlanePhase κ)
    (hFT : ∀ z,F (U z)=T (F z))
    (hUD : ∀ z v,phaseDot (U z) (U v)=phaseDot z v)
    (hUA : ∀ z v,phaseArea (U z) (U v)=phaseArea z v)
    (hTD : ∀ z v,phaseDot (T z) (T v)=phaseDot z v)
    (hTA : ∀ z v,phaseArea (T z) (T v)=phaseArea z v) :
    ∀ s∈Icc (0:ℝ) 1,∀ x∈phaseShell a b,Φ (s,U x)=U (Φ (s,x)) := by
  apply closed_flow_linear_equivariant_on hV
    (fun x s hs => hODE x s ⟨by linarith [hs.1],by linarith [hs.2]⟩) hΦ0
    (fun s hs x hx => phaseShell_radial a b hx (hΦr s hs x)) U.toContinuousLinearMap
  intro s hs x hx
  have hUx : U x∈phaseShell a b :=
    phaseShell_radial a b hx (hUD x x)
  change V (s,U x)=U (V (s,x))
  rw [hVe s hs _ hUx,hVe s hs x hx]
  exact homogeneousConeField_linear_invariant hF hF0 hD hJ U T hFT hUD hUA hTD hTA
    hc (mul_nonneg hs.1 hd) (lt_of_le_of_lt (by nlinarith [hs.2]) hdhalf)
    (phaseShell_nonzero ha hx)

end PackingSufficiencySupport.Hamiltonian

namespace PackingSufficiencySupport.DiagonalQuadrics
open scoped ContDiff
open Hamiltonian

variable {m : ℕ}

abbrev HomogeneousInput (m : ℕ) := Option (Option (Fin m)) → ℂ
abbrev HomogeneousOutput (m : ℕ) := Option (NormalPolynomialIndex m) → ℂ

def homogeneousPolynomial (a : Fin m → ℂ) (t : ℝ) (z : HomogeneousInput m) :
    HomogeneousOutput m
  | none => z none^2
  | some (.inl (.inl i)) => z none*z (some i.2)
  | some (.inl (.inr i)) => z (some i.1)*z (some i.2)
  | some (.inr j) => (t:ℂ)⁻¹*(z (some (some j))^2-z (some none)^2+a j*z none^2)

theorem homogeneousPolynomial_smooth (a : Fin m → ℂ) (t : ℝ) :
    ContDiff ℂ ∞ (homogeneousPolynomial a t) := by
  apply contDiff_pi.mpr
  rintro (_|((⟨b,i⟩|⟨i,j⟩)|j))
  · exact (contDiff_apply ℂ ℂ none).pow 2
  · exact (contDiff_apply ℂ ℂ none).mul (contDiff_apply ℂ ℂ (some i))
  · exact (contDiff_apply ℂ ℂ (some i)).mul (contDiff_apply ℂ ℂ (some j))
  · exact contDiff_const.mul (((contDiff_apply ℂ ℂ (some (some j))).pow 2).sub
      ((contDiff_apply ℂ ℂ (some none)).pow 2) |>.add
      (contDiff_const.mul ((contDiff_apply ℂ ℂ none).pow 2)))

theorem homogeneousPolynomial_homogeneous (a : Fin m → ℂ) (t : ℝ)
    (b : ℂ) (z : HomogeneousInput m) :
    homogeneousPolynomial a t (b•z)=b^2•homogeneousPolynomial a t z := by
  funext i
  rcases i with _|((⟨e,i⟩|⟨i,j⟩)|j)
  all_goals simp only [homogeneousPolynomial,Pi.smul_apply,smul_eq_mul]; ring

theorem homogeneousPolynomial_zero_iff (a : Fin m → ℂ) (t : ℝ) (z : HomogeneousInput m) :
    homogeneousPolynomial a t z=0 ↔ z=0 := by
  constructor
  · intro h
    funext i
    cases i with
    | none =>
      have hh := congrFun h none
      change z none^2=0 at hh
      exact eq_zero_of_pow_eq_zero hh
    | some i =>
      have hh := congrFun h (some (.inl (.inr (i,i))))
      change z (some i)*z (some i)=0 at hh
      exact (mul_self_eq_zero.mp hh)
  · rintro rfl
    funext i
    rcases i with _|((⟨e,i⟩|⟨i,j⟩)|j)
    all_goals simp [homogeneousPolynomial]

theorem homogeneousPolynomial_nonzero (a : Fin m → ℂ) (t : ℝ)
    {z : HomogeneousInput m} (hz : z≠0) : homogeneousPolynomial a t z≠0 :=
  fun h => hz ((homogeneousPolynomial_zero_iff a t z).mp h)

theorem homogeneousPolynomial_affine (a : Fin m → ℂ) (t : ℝ) (z : Affine m) :
    homogeneousPolynomial a t (fun i => match i with
      | none => 1 | some j => affineComplex m z j)=
    (fun i => match i with | none => 1 | some j => normalPolynomial a t z j) := by
  funext i
  rcases i with _|((⟨e,i⟩|⟨i,j⟩)|j)
  · simp [homogeneousPolynomial]
  · simp [homogeneousPolynomial,normalPolynomial,veronese]
  · rfl
  · simp [homogeneousPolynomial,normalPolynomial,equations,affineComplex]

theorem homogeneousPolynomial_euler (a : Fin m → ℂ) (t : ℝ) (z : HomogeneousInput m) :
    fderiv ℂ (homogeneousPolynomial a t) z z= (2:ℂ)•homogeneousPolynomial a t z := by
  have hf := (homogeneousPolynomial_smooth a t).differentiable (by simp) z
  have hf' : HasFDerivAt (homogeneousPolynomial a t)
      (fderiv ℂ (homogeneousPolynomial a t) z) ((1:ℂ)•z) := by
    simpa only [one_smul] using hf.hasFDerivAt
  have hd := hf'.comp_hasDerivAt (1:ℂ) ((hasDerivAt_id (1:ℂ)).smul_const z)
  have he : (fun b : ℂ => homogeneousPolynomial a t (b•z))=
      (fun b : ℂ => b^2•homogeneousPolynomial a t z) :=
    funext (fun b => homogeneousPolynomial_homogeneous a t b z)
  have hd' : HasDerivAt (fun b : ℂ => b^2•homogeneousPolynomial a t z)
      ((2:ℂ)•homogeneousPolynomial a t z) 1 := by
    convert! (((hasDerivAt_id (1:ℂ)).pow 2).smul_const (homogeneousPolynomial a t z)) using 1; simp
  simp only [Function.comp_def,id_eq] at hd
  rw [he] at hd
  simpa only [one_smul] using hd.unique hd'

def homogeneousCartesian (a : Fin m → ℂ) (t : ℝ) :
    PlanePhase (Option (Option (Fin m))) → PlanePhase (Option (NormalPolynomialIndex m)) :=
  fun z => complexCartesian (homogeneousPolynomial a t (complexCartesian.symm z))

theorem homogeneousCartesian_smooth (a : Fin m → ℂ) (t : ℝ) :
    ContDiff ℝ ∞ (homogeneousCartesian a t) :=
  (complexCartesian (ι := Option (NormalPolynomialIndex m))).contDiff.comp
    (((homogeneousPolynomial_smooth a t).restrict_scalars ℝ).comp
      (complexCartesian (ι := Option (Option (Fin m)))).symm.contDiff)

theorem homogeneousCartesian_nonzero (a : Fin m → ℂ) (t : ℝ)
    {z : PlanePhase (Option (Option (Fin m)))} (hz : z≠0) : homogeneousCartesian a t z≠0 := by
  intro h
  have hP : homogeneousPolynomial a t (complexCartesian.symm z)=0 :=
    complexCartesian.injective (h.trans (map_zero _).symm)
  have hh := (homogeneousPolynomial_zero_iff a t _).mp hP
  exact hz (by simpa only [ContinuousLinearEquiv.apply_symm_apply,map_zero] using congrArg complexCartesian hh)

theorem homogeneousCartesian_fderiv (a : Fin m → ℂ) (t : ℝ)
    (z v : PlanePhase (Option (Option (Fin m)))) :
    fderiv ℝ (homogeneousCartesian a t) z v=complexCartesian
      (fderiv ℂ (homogeneousPolynomial a t) (complexCartesian.symm z) (complexCartesian.symm v)) := by
  have hh := ((homogeneousPolynomial_smooth a t).differentiable (by simp)
    (complexCartesian.symm z)).hasFDerivAt.restrictScalars ℝ
  have hd := complexCartesian.toContinuousLinearMap.hasFDerivAt.comp z
    (hh.comp z (complexCartesian (ι := Option (Option (Fin m)))).symm.hasFDerivAt)
  exact congrArg (fun L => L v) hd.fderiv

theorem homogeneousCartesian_euler (a : Fin m → ℂ) (t : ℝ)
    (z : PlanePhase (Option (Option (Fin m)))) :
    fderiv ℝ (homogeneousCartesian a t) z z=(2:ℝ)•homogeneousCartesian a t z := by
  rw [homogeneousCartesian_fderiv,homogeneousPolynomial_euler]
  rw [show (2:ℂ)•homogeneousPolynomial a t (complexCartesian.symm z)=
    (2:ℝ)•homogeneousPolynomial a t (complexCartesian.symm z) by
      ext i; simp [Pi.smul_apply,Complex.real_smul]]
  exact map_smul _ _ _

theorem homogeneousCartesian_J (a : Fin m → ℂ) (t : ℝ)
    (z v : PlanePhase (Option (Option (Fin m)))) :
    fderiv ℝ (homogeneousCartesian a t) z (phaseJ v)=
      phaseJ (fderiv ℝ (homogeneousCartesian a t) z v) := by
  have hJ : complexCartesian.symm (phaseJ v)=Complex.I•complexCartesian.symm v := by
    apply complexCartesian.injective
    simp only [ContinuousLinearEquiv.apply_symm_apply,complexCartesian_I]
  rw [homogeneousCartesian_fderiv,homogeneousCartesian_fderiv,hJ,map_smul,complexCartesian_I]

theorem homogeneousQuadricCone_isInvertible (a : Fin m → ℂ) (t : ℝ)
    {c d : ℝ} (hc : 0<c) (hd : 0≤d) (hdhalf : d<1/2)
    {z : PlanePhase (Option (Option (Fin m)))} (hz : z≠0) :
    (euclideanExteriorOneForm (homogeneousConePrimitive (homogeneousCartesian a t) c d) z).IsInvertible :=
  homogeneousConePrimitive_nondegenerate (homogeneousCartesian_smooth a t).contDiffAt hz
    (homogeneousCartesian_nonzero a t hz) (homogeneousCartesian_euler a t z)
    (homogeneousCartesian_J a t z) hc hd hdhalf

end PackingSufficiencySupport.DiagonalQuadrics

namespace PackingSufficiencySupport.Hamiltonian
open scoped ContDiff BigOperators

variable {ι : Type*} [Fintype ι]

def infinitySign : Option ι → ℂ
  | none => -1
  | some _ => 1

omit [Fintype ι] in
theorem infinitySign_unit (i : Option ι) : Complex.normSq (infinitySign i)=1 := by
  cases i <;> norm_num [infinitySign]

omit [Fintype ι] in
theorem complexDiagonal_infinity_fixed (z : Option ι → ℂ) :
    complexDiagonal infinitySign z=z ↔ z none=0 := by
  constructor
  · intro h
    have h₀ := congrFun h none
    change (-1:ℂ)*z none=z none at h₀
    have hh : (2:ℂ)*z none=0 := by linear_combination -h₀
    exact (mul_eq_zero.mp hh).resolve_left (by norm_num)
  · intro h
    ext i
    cases i <;> simp [complexDiagonal_apply,infinitySign,h]

theorem phaseUnitDiagonal_infinity_fixed (z : PlanePhase (Option ι)) :
    phaseUnitDiagonal infinitySign infinitySign_unit z=z ↔
      complexCartesian.symm z none=0 := by
  obtain ⟨z,rfl⟩ := complexCartesian.surjective z
  simp only [phaseUnitDiagonal_apply,phaseDiagonal_cartesian,
    ContinuousLinearEquiv.symm_apply_apply,complexCartesian.injective.eq_iff,
    complexDiagonal_infinity_fixed]

end PackingSufficiencySupport.Hamiltonian

namespace PackingSufficiencySupport.DiagonalQuadrics
open scoped ContDiff BigOperators
open Hamiltonian

variable {m : ℕ}

def homogeneousInfinityOutputSign : Option (NormalPolynomialIndex m) → ℂ
  | some (.inl (.inl _)) => -1
  | _ => 1

theorem homogeneousInfinityOutputSign_unit (i : Option (NormalPolynomialIndex m)) :
    Complex.normSq (homogeneousInfinityOutputSign i)=1 := by
  rcases i with _|((_ |_)|_)
  all_goals norm_num [homogeneousInfinityOutputSign]

theorem homogeneousPolynomial_infinity (a : Fin m → ℂ) (t : ℝ) (z : HomogeneousInput m) :
    homogeneousPolynomial a t (complexDiagonal infinitySign z)=
      complexDiagonal homogeneousInfinityOutputSign (homogeneousPolynomial a t z) := by
  ext i
  rcases i with _|((⟨e,i⟩|⟨i,j⟩)|j)
  all_goals simp [homogeneousPolynomial,complexDiagonal_apply,infinitySign,
    homogeneousInfinityOutputSign]

theorem homogeneousCartesian_diagonal (a : Fin m → ℂ) (t : ℝ)
    (u : Option (Option (Fin m)) → ℂ) (hu : ∀ i,Complex.normSq (u i)=1)
    (v : Option (NormalPolynomialIndex m) → ℂ)
    (he : ∀ z,homogeneousPolynomial a t (complexDiagonal u z)=
      complexDiagonal v (homogeneousPolynomial a t z))
    (z : PlanePhase (Option (Option (Fin m)))) :
    homogeneousCartesian a t (phaseUnitDiagonal u hu z)=
      phaseDiagonal v (homogeneousCartesian a t z) := by
  obtain ⟨z,rfl⟩ := complexCartesian.surjective z
  simp only [homogeneousCartesian,phaseUnitDiagonal_apply,phaseDiagonal_cartesian,
    ContinuousLinearEquiv.symm_apply_apply,he]

theorem homogeneousCartesian_circle (a : Fin m → ℂ) (t : ℝ) (ζ : ℂ)
    (hζ : Complex.normSq ζ=1) (z : PlanePhase (Option (Option (Fin m)))) :
    homogeneousCartesian a t (phaseUnitDiagonal (fun _ => ζ) (fun _ => hζ) z)=
      phaseDiagonal (fun _ => ζ^2) (homogeneousCartesian a t z) := by
  apply homogeneousCartesian_diagonal
  intro z
  change homogeneousPolynomial a t (ζ•z)=ζ^2•homogeneousPolynomial a t z
  exact homogeneousPolynomial_homogeneous a t ζ z

theorem homogeneousCartesian_infinity (a : Fin m → ℂ) (t : ℝ)
    (z : PlanePhase (Option (Option (Fin m)))) :
    homogeneousCartesian a t (phaseUnitDiagonal infinitySign infinitySign_unit z)=
      phaseDiagonal homogeneousInfinityOutputSign (homogeneousCartesian a t z) :=
  homogeneousCartesian_diagonal a t infinitySign infinitySign_unit homogeneousInfinityOutputSign
    (homogeneousPolynomial_infinity a t) z

end PackingSufficiencySupport.DiagonalQuadrics
end

end OAI