lean/OAI/Geometry/BallPacking/Rigidity/CompatibleStructures.lean

import Mathlib

namespace OAI

namespace HigherDimensionalBallPacking
open scoped ContDiff

abbrev Phase (n : ℕ) := Fin n → ℂ

noncomputable def capacity {n : ℕ} (z : Phase n) : ℝ :=
  Real.pi * ∑ j, Complex.normSq (z j)

def closedBall (n : ℕ) (r : ℝ) : Set (Phase n) := {z | capacity z ≤ r}

def openBall (n : ℕ) (r : ℝ) : Set (Phase n) := {z | capacity z < r}

noncomputable def standardForm {n : ℕ} (u v : Phase n) : ℝ :=
  ∑ j, ((u j).re * (v j).im - (u j).im * (v j).re)

def SymplecticOn {n : ℕ} (U : Set (Phase n)) (f : Phase n → Phase n) : Prop :=
  IsOpen U ∧ ContDiffOn ℝ ∞ f U ∧
    Topology.IsEmbedding (fun x : U => f x) ∧
    ∀ x ∈ U, ∀ u v : Phase n,
      standardForm (fderiv ℝ f x u) (fderiv ℝ f x v) = standardForm u v

def HasPacking (n k : ℕ) (R : ℝ) (r : Fin k → ℝ) : Prop :=
  ∃ (U : Fin k → Set (Phase n)) (f : Fin k → Phase n → Phase n),
    (∀ i, closedBall n (r i) ⊆ U i ∧ SymplecticOn (U i) (f i) ∧
      Set.MapsTo (f i) (closedBall n (r i)) (openBall n R)) ∧
    (∀ i j, i ≠ j →
      Disjoint (f i '' closedBall n (r i)) (f j '' closedBall n (r j)))

def PackingInequalities (n k : ℕ) (R : ℝ) (r : Fin k → ℝ) : Prop :=
  (∑ i, r i ^ n) < R ^ n ∧ ∀ i j, i ≠ j → r i + r j < R

noncomputable section
open scoped Topology
open Set Function Filter

namespace Rigidity

abbrev End (n : ℕ) := Phase n →L[ℝ] Phase n

def standardJ (n : ℕ) : End n :=
  (ContinuousLinearMap.lsmul ℝ ℂ) Complex.I

@[simp] theorem standardJ_apply (n : ℕ) (v : Phase n) (i : Fin n) :
    standardJ n v i = Complex.I * v i := rfl

@[simp] theorem standardJ_sq (n : ℕ) (v : Phase n) :
    standardJ n (standardJ n v) = -v := by
  funext i
  simp only [standardJ_apply, ← mul_assoc, Complex.I_mul_I, neg_one_mul, Pi.neg_apply]

@[simp] theorem standardForm_J_J {n : ℕ} (v w : Phase n) :
    standardForm (standardJ n v) (standardJ n w) = standardForm v w := by
  unfold standardForm
  apply Finset.sum_congr rfl
  intro i _
  simp [standardJ_apply, Complex.mul_re, Complex.mul_im]
  ring

@[simp] theorem standardForm_J_self {n : ℕ} (v : Phase n) :
    standardForm v (standardJ n v) = ∑ i, Complex.normSq (v i) := by
  unfold standardForm
  apply Finset.sum_congr rfl
  intro i _
  simp [standardJ_apply, Complex.mul_re, Complex.mul_im, Complex.normSq_apply]

theorem standardForm_J_pos {n : ℕ} {v : Phase n} (hv : v ≠ 0) :
    0 < standardForm v (standardJ n v) := by
  rw [standardForm_J_self]
  have hi : ∃ i, v i ≠ 0 := by
    by_contra! h
    exact hv (funext h)
  obtain ⟨i, hi⟩ := hi
  have hpos : 0 < Complex.normSq (v i) := Complex.normSq_pos.mpr hi
  exact hpos.trans_le (Finset.single_le_sum (fun j _ => Complex.normSq_nonneg (v j))
    (Finset.mem_univ i))

def Compatible {n : ℕ} (J : End n) : Prop :=
  (∀ v, J (J v) = -v) ∧
  (∀ v w, standardForm (J v) (J w) = standardForm v w) ∧
  (∀ v, v ≠ 0 → 0 < standardForm v (J v))

theorem compatible_standardJ (n : ℕ) : Compatible (standardJ n) :=
  ⟨standardJ_sq n, standardForm_J_J, fun _ hv => standardForm_J_pos hv⟩

def conjugateJ {n : ℕ} (e : Phase n ≃L[ℝ] Phase n) : End n :=
  e.toContinuousLinearMap.comp ((standardJ n).comp e.symm.toContinuousLinearMap)

@[simp] theorem conjugateJ_apply {n : ℕ} (e : Phase n ≃L[ℝ] Phase n) (v : Phase n) :
    conjugateJ e v = e (standardJ n (e.symm v)) := rfl

theorem compatible_conjugateJ {n : ℕ} (e : Phase n ≃L[ℝ] Phase n)
    (he : ∀ v w, standardForm (e v) (e w) = standardForm v w) :
    Compatible (conjugateJ e) := by
  refine ⟨?_, ?_, ?_⟩
  · intro v
    simp
  · intro v w
    simp only [conjugateJ_apply, he, standardForm_J_J]
    simpa using (he (e.symm v) (e.symm w)).symm
  · intro v hv
    have hv' : e.symm v ≠ 0 := by
      intro h
      apply hv
      simpa using congrArg e h
    have h := he (e.symm v) (standardJ n (e.symm v))
    rw [e.apply_symm_apply] at h
    change 0 < standardForm v (e (standardJ n (e.symm v)))
    rw [h]
    exact standardForm_J_pos hv'

theorem symplectic_linear_injective {n : ℕ} {A : End n}
    (hA : ∀ v w, standardForm (A v) (A w) = standardForm v w) :
    Injective A := by
  apply (injective_iff_map_eq_zero A).mpr
  intro v hv
  by_contra hne
  have hp := standardForm_J_pos hne
  have he := hA v (standardJ n v)
  rw [hv, show standardForm (0 : Phase n) (A (standardJ n v)) = 0 by
    simp [standardForm]] at he
  exact (ne_of_gt hp) he.symm

theorem symplectic_linear_invertible {n : ℕ} {A : End n}
    (hA : ∀ v w, standardForm (A v) (A w) = standardForm v w) : A.IsInvertible := by
  have hi := symplectic_linear_injective hA
  have hs := (LinearMap.injective_iff_surjective (f := A.toLinearMap)).mp hi
  exact ⟨ContinuousLinearEquiv.ofBijective A (LinearMap.ker_eq_bot.mpr hi)
    (LinearMap.range_eq_top.mpr hs), rfl⟩

theorem symplecticOn_fderiv_invertible {n : ℕ} {U : Set (Phase n)}
    {f : Phase n → Phase n} (h : SymplecticOn U f) {x : Phase n} (hx : x ∈ U) :
    (fderiv ℝ f x).IsInvertible :=
  symplectic_linear_invertible (h.2.2.2 x hx)

theorem symplecticOn_injOn {n : ℕ} {U : Set (Phase n)}
    {f : Phase n → Phase n} (h : SymplecticOn U f) : InjOn f U := by
  intro x hx y hy hxy
  exact congrArg Subtype.val (h.2.2.1.injective (a₁ := ⟨x,hx⟩) (a₂ := ⟨y,hy⟩) hxy)

theorem symplecticOn_open_image {n : ℕ} {U : Set (Phase n)}
    {f : Phase n → Phase n} (h : SymplecticOn U f) : IsOpen (f '' U) := by
  rw [isOpen_iff_mem_nhds]
  rintro y ⟨x,hx,rfl⟩
  have hs := h.2.1.contDiffAt (h.1.mem_nhds hx)
  obtain ⟨e,he⟩ := symplecticOn_fderiv_invertible h hx
  have hd : HasStrictFDerivAt f (e : End n) x := by
    rw [he]
    exact hs.hasStrictFDerivAt (by simp)
  have hi := Filter.image_mem_map (m := f) (h.1.mem_nhds hx)
  rwa [hd.map_nhds_eq_of_equiv] at hi

theorem symplecticOn_inverse_smooth {n : ℕ} {U : Set (Phase n)}
    {f : Phase n → Phase n} (h : SymplecticOn U f) :
    ContDiffOn ℝ ∞ (invFunOn f U) (f '' U) := by
  rintro y ⟨x,hx,rfl⟩
  apply ContDiffAt.contDiffWithinAt
  have hs := h.2.1.contDiffAt (h.1.mem_nhds hx)
  obtain ⟨e,he⟩ := symplecticOn_fderiv_invertible h hx
  have hd : HasFDerivAt f (e : End n) x := by
    rw [he]
    exact hs.differentiableAt (by simp) |>.hasFDerivAt
  let q := hs.toOpenPartialHomeomorph f hd (by simp)
  have hqx : x ∈ q.source := hs.mem_toOpenPartialHomeomorph_source hd (by simp)
  have hqy : f x ∈ q.target := hs.image_mem_toOpenPartialHomeomorph_target hd (by simp)
  have hqg : q.symm (f x) = x := q.left_inv hqx
  have hqs : ContDiffAt ℝ ∞ q.symm (f x) := hs.to_localInverse hd (by simp)
  have hUevent : ∀ᶠ z in 𝓝 (f x), q.symm z ∈ U :=
    hqs.continuousAt.eventually (h.1.mem_nhds (by rw [hqg]; exact hx))
  apply hqs.congr_of_eventuallyEq
  filter_upwards [q.open_target.mem_nhds hqy, hUevent] with z hz hUz
  have hj := (symplecticOn_injOn h).leftInvOn_invFunOn hUz
  have hqz : f (q.symm z) = z := q.right_inv hz
  rwa [hqz] at hj

def imageJ {n : ℕ} (U : Set (Phase n)) (f : Phase n → Phase n) (y : Phase n) : End n :=
  let D := fderiv ℝ f (invFunOn f U y)
  D.comp ((standardJ n).comp D.inverse)

@[simp] theorem imageJ_at_image {n : ℕ} {U : Set (Phase n)}
    {f : Phase n → Phase n} (h : SymplecticOn U f) {x : Phase n} (hx : x ∈ U) :
    imageJ U f (f x) = (fderiv ℝ f x).comp
      ((standardJ n).comp (fderiv ℝ f x).inverse) := by
  unfold imageJ
  rw [(symplecticOn_injOn h).leftInvOn_invFunOn hx]

theorem imageJ_compatible {n : ℕ} {U : Set (Phase n)}
    {f : Phase n → Phase n} (h : SymplecticOn U f) {y : Phase n} (hy : y ∈ f '' U) :
    Compatible (imageJ U f y) := by
  obtain ⟨x,hx,rfl⟩ := hy
  rw [imageJ_at_image h hx]
  obtain ⟨e,he⟩ := symplecticOn_fderiv_invertible h hx
  rw [←he]
  have heω : ∀ v w, standardForm (e v) (e w) = standardForm v w := by
    intro v w
    change standardForm ((e : End n) v) ((e : End n) w) = _
    rw [he]
    exact h.2.2.2 x hx v w
  convert compatible_conjugateJ e heω using 1
  simp [conjugateJ]

theorem imageJ_smooth {n : ℕ} {U : Set (Phase n)}
    {f : Phase n → Phase n} (h : SymplecticOn U f) :
    ContDiffOn ℝ ∞ (imageJ U f) (f '' U) := by
  intro y hy
  apply ContDiffAt.contDiffWithinAt
  have hg := (symplecticOn_inverse_smooth h).contDiffAt
    ((symplecticOn_open_image h).mem_nhds hy)
  have hx : invFunOn f U y ∈ U := invFunOn_mem hy
  have hf := h.2.1.contDiffAt (h.1.mem_nhds hx)
  have hD : ContDiffAt ℝ ∞ (fun z => fderiv ℝ f (invFunOn f U z)) y :=
    (hf.fderiv_right (by simp)).comp y hg
  have hI := (symplecticOn_fderiv_invertible h hx).contDiffAt_map_inverse.comp y hD
  exact hD.clm_comp (contDiffAt_const.clm_comp hI)

theorem imageJ_intertwines {n : ℕ} {U : Set (Phase n)}
    {f : Phase n → Phase n} (h : SymplecticOn U f) {x : Phase n} (hx : x ∈ U)
    (v : Phase n) :
    imageJ U f (f x) (fderiv ℝ f x v) = fderiv ℝ f x (standardJ n v) := by
  rw [imageJ_at_image h hx]
  obtain ⟨e,he⟩ := symplecticOn_fderiv_invertible h hx
  rw [←he]
  simp

theorem symplecticOn_inverse_fderiv {n : ℕ} {U : Set (Phase n)}
    {f : Phase n → Phase n} (h : SymplecticOn U f) {y : Phase n} (hy : y ∈ f '' U) :
    fderiv ℝ (invFunOn f U) y = (fderiv ℝ f (invFunOn f U y)).inverse := by
  let g := invFunOn f U
  have hx : g y ∈ U := invFunOn_mem hy
  have hg := (symplecticOn_inverse_smooth h).contDiffAt
    ((symplecticOn_open_image h).mem_nhds hy)
  have hf := h.2.1.contDiffAt (h.1.mem_nhds hx)
  have hc : f ∘ g =ᶠ[𝓝 y] id := by
    filter_upwards [(symplecticOn_open_image h).mem_nhds hy] with z hz
    exact invFunOn_eq hz
  have hcomp : (fderiv ℝ f (g y)).comp (fderiv ℝ g y) = ContinuousLinearMap.id ℝ (Phase n) := by
    rw [←fderiv_comp y (hf.differentiableAt (by simp)) (hg.differentiableAt (by simp))]
    rw [hc.fderiv_eq, fderiv_id]
  obtain ⟨e,he⟩ := symplecticOn_fderiv_invertible h hx
  change fderiv ℝ g y = _
  rw [←he]
  rw [←he] at hcomp
  simp only [ContinuousLinearMap.inverse_equiv]
  apply ContinuousLinearMap.ext
  intro v
  apply e.injective
  have hv := congrArg (fun A : End n => A v) hcomp
  simpa only [ContinuousLinearMap.comp_apply, ContinuousLinearMap.id_apply,
    ContinuousLinearEquiv.coe_coe, ContinuousLinearEquiv.apply_symm_apply] using hv

def PseudoHolomorphicAt {n : ℕ} (J : Phase n → End n) (u : ℂ → Phase n) (z : ℂ) : Prop :=
  DifferentiableAt ℝ u z ∧ ∀ w : ℂ,
    fderiv ℝ u z (Complex.I * w) = J (u z) (fderiv ℝ u z w)

theorem complex_differentiable_of_CR {n : ℕ} {u : ℂ → Phase n} {z : ℂ}
    (hu : DifferentiableAt ℝ u z)
    (hCR : ∀ w : ℂ, fderiv ℝ u z (Complex.I * w) = standardJ n (fderiv ℝ u z w)) :
    DifferentiableAt ℂ u z := by
  let A := fderiv ℝ u z
  let L : ℂ →L[ℂ] Phase n := (ContinuousLinearMap.id ℂ ℂ).smulRight (A 1)
  have hL : L.restrictScalars ℝ = A := by
    ext w i
    have hw : w = w.re • (1 : ℂ) + w.im • Complex.I := by
      simpa only [Complex.real_smul, Complex.ofReal_mul, Complex.ofReal_one, mul_one]
        using (Complex.re_add_im w).symm
    have hI : A Complex.I = standardJ n (A 1) := by
      simpa only [mul_one] using hCR 1
    have hAw : A w = w.re • A 1 + w.im • standardJ n (A 1) := by
      conv_lhs => rw [hw]
      simp only [map_add, map_smul, hI]
    rw [hAw]
    change w * A 1 i = _
    simp only [Pi.add_apply, Pi.smul_apply, Complex.real_smul, standardJ_apply]
    rw [←mul_assoc, ←add_mul]
    congr 1
    exact (Complex.re_add_im w).symm
  exact (hasFDerivAt_of_restrictScalars ℝ hu.hasFDerivAt hL).differentiableAt

theorem inverse_chart_holomorphic {n : ℕ} {U : Set (Phase n)}
    {f : Phase n → Phase n} (h : SymplecticOn U f) {u : ℂ → Phase n} {z : ℂ}
    (hu : PseudoHolomorphicAt (imageJ U f) u z) (hz : u z ∈ f '' U) :
    DifferentiableAt ℂ (invFunOn f U ∘ u) z := by
  let g := invFunOn f U
  have hg := ((symplecticOn_inverse_smooth h).contDiffAt
    ((symplecticOn_open_image h).mem_nhds hz)).differentiableAt (by simp)
  apply complex_differentiable_of_CR (hg.comp z hu.1)
  intro w
  rw [fderiv_comp z hg hu.1]
  simp only [ContinuousLinearMap.comp_apply]
  rw [hu.2]
  rw [symplecticOn_inverse_fderiv h hz]
  change (fderiv ℝ f (g (u z))).inverse
    ((fderiv ℝ f (g (u z))) (standardJ n
      ((fderiv ℝ f (g (u z))).inverse (fderiv ℝ u z w)))) = _
  obtain ⟨e,he⟩ := symplecticOn_fderiv_invertible h (invFunOn_mem hz)
  rw [←he]
  simp

end Rigidity
end
end HigherDimensionalBallPacking

noncomputable section
open scoped ContDiff Topology
open Set Function Filter
namespace HigherDimensionalBallPacking.Rigidity

def stdDot (n : ℕ) : Phase n →L[ℝ] Phase n →L[ℝ] ℝ :=
  ∑ i, ((ContinuousLinearMap.mul ℝ ℝ).bilinearComp
    (Complex.reCLM.comp (ContinuousLinearMap.proj i))
    (Complex.reCLM.comp (ContinuousLinearMap.proj i)) +
    (ContinuousLinearMap.mul ℝ ℝ).bilinearComp
    (Complex.imCLM.comp (ContinuousLinearMap.proj i))
    (Complex.imCLM.comp (ContinuousLinearMap.proj i)))

@[simp] theorem stdDot_apply {n : ℕ} (v w : Phase n) :
    stdDot n v w = ∑ i, ((v i).re * (w i).re + (v i).im * (w i).im) := by
  simp [stdDot]

theorem stdDot_symm {n : ℕ} (v w : Phase n) : stdDot n v w = stdDot n w v := by
  simp only [stdDot_apply]
  apply Finset.sum_congr rfl
  intro i _
  ring

@[simp] theorem standardForm_J_right {n : ℕ} (v w : Phase n) :
    standardForm v (standardJ n w) = stdDot n v w := by
  simp [standardForm, stdDot_apply, standardJ_apply, Complex.mul_re, Complex.mul_im]

theorem stdDot_pos {n : ℕ} {v : Phase n} (hv : v ≠ 0) : 0 < stdDot n v v := by
  rw [← standardForm_J_right]
  exact standardForm_J_pos hv

theorem stdDot_nonneg {n : ℕ} (v : Phase n) : 0 ≤ stdDot n v v := by
  by_cases hv : v = 0
  · subst v
    simp
  · exact (stdDot_pos hv).le

theorem standardForm_skew {n : ℕ} (v w : Phase n) :
    standardForm v w = -standardForm w v := by
  unfold standardForm
  rw [←Finset.sum_neg_distrib]
  apply Finset.sum_congr rfl
  intro i _
  ring

@[simp] theorem standardForm_neg_right {n : ℕ} (v w : Phase n) :
    standardForm v (-w) = -standardForm v w := by
  unfold standardForm
  rw [←Finset.sum_neg_distrib]
  apply Finset.sum_congr rfl
  intro i _
  simp only [Pi.neg_apply, Complex.neg_re, Complex.neg_im]
  ring

theorem compatible_metric_symm {n : ℕ} {J : End n} (hJ : Compatible J)
    (v w : Phase n) : standardForm v (J w) = standardForm w (J v) := by
  calc
    standardForm v (J w) = standardForm (J v) (J (J w)) := (hJ.2.1 v (J w)).symm
    _ = -standardForm (J v) w := by rw [hJ.1, standardForm_neg_right]
    _ = standardForm w (J v) := by rw [standardForm_skew, neg_neg]

theorem compatible_of_sq_symmetric_positive {n : ℕ} {J : End n}
    (hJsq : ∀ v, J (J v) = -v)
    (hsym : ∀ v w, standardForm v (J w) = standardForm w (J v))
    (hpos : ∀ v, v ≠ 0 → 0 < standardForm v (J v)) : Compatible J := by
  refine ⟨hJsq, ?_, hpos⟩
  intro v w
  rw [hsym, hJsq, standardForm_neg_right, standardForm_skew, neg_neg]

def relativeOperator {n : ℕ} (J : End n) : End n := -(standardJ n).comp J

@[simp] theorem relativeOperator_apply {n : ℕ} (J : End n) (v : Phase n) :
    relativeOperator J v = -standardJ n (J v) := rfl

@[simp] theorem standardJ_relativeOperator {n : ℕ} (J : End n) (v : Phase n) :
    standardJ n (relativeOperator J v) = J v := by simp

@[simp] theorem relativeOperator_J_relativeOperator {n : ℕ} {J : End n}
    (hJ : Compatible J) (v : Phase n) :
    relativeOperator J (standardJ n (relativeOperator J v)) = standardJ n v := by
  rw [standardJ_relativeOperator, relativeOperator_apply, hJ.1]
  simp

@[simp] theorem stdDot_relativeOperator {n : ℕ} (J : End n) (v w : Phase n) :
    stdDot n v (relativeOperator J w) = standardForm v (J w) := by
  rw [←standardForm_J_right, standardJ_relativeOperator]

theorem relativeOperator_selfadjoint {n : ℕ} {J : End n} (hJ : Compatible J)
    (v w : Phase n) :
    stdDot n (relativeOperator J v) w = stdDot n v (relativeOperator J w) := by
  rw [stdDot_symm, stdDot_relativeOperator, stdDot_relativeOperator]
  exact compatible_metric_symm hJ w v

theorem relativeOperator_positive {n : ℕ} {J : End n} (hJ : Compatible J)
    {v : Phase n} (hv : v ≠ 0) : 0 < stdDot n v (relativeOperator J v) := by
  rw [stdDot_relativeOperator]
  exact hJ.2.2 v hv

def cayleyP {n : ℕ} (J : End n) (a b : ℝ) : End n :=
  a • relativeOperator J + b • ContinuousLinearMap.id ℝ (Phase n)

@[simp] theorem cayleyP_apply {n : ℕ} (J : End n) (a b : ℝ) (v : Phase n) :
    cayleyP J a b v = a • relativeOperator J v + b • v := rfl

theorem cayleyP_invertible {n : ℕ} {J : End n} (hJ : Compatible J)
    {a b : ℝ} (ha : 0 < a) (hb : 0 ≤ b) : (cayleyP J b a).IsInvertible := by
  have hi : Injective (cayleyP J b a) := by
    apply (injective_iff_map_eq_zero (cayleyP J b a)).mpr
    intro v hv
    by_contra hne
    have hp := stdDot_pos hne
    have hA := relativeOperator_positive hJ hne
    have he : stdDot n v (cayleyP J b a v) =
        b * stdDot n v (relativeOperator J v) + a * stdDot n v v := by
      simp only [cayleyP_apply, map_add, map_smul, smul_eq_mul]
    rw [hv] at he
    simp only [map_zero] at he
    have hn := mul_nonneg hb hA.le
    have hh := mul_pos ha hp
    linarith
  have hs := (LinearMap.injective_iff_surjective (f := (cayleyP J b a).toLinearMap)).mp hi
  exact ⟨ContinuousLinearEquiv.ofBijective (cayleyP J b a)
    (LinearMap.ker_eq_bot.mpr hi) (LinearMap.range_eq_top.mpr hs), rfl⟩

theorem cayleyP_commute {n : ℕ} (J : End n) (a b : ℝ) (v : Phase n) :
    cayleyP J b a (cayleyP J a b v) = cayleyP J a b (cayleyP J b a v) := by
  simp only [cayleyP_apply, map_add, map_smul]
  module

theorem cayleyP_J_identity {n : ℕ} {J : End n} (hJ : Compatible J)
    (a b : ℝ) (v : Phase n) :
    cayleyP J a b (standardJ n (cayleyP J a b v)) =
      cayleyP J b a (standardJ n (cayleyP J b a v)) := by
  simp only [cayleyP_apply, map_add, map_smul, relativeOperator_J_relativeOperator hJ]
  module

theorem cayleyP_stdDot_identity {n : ℕ} {J : End n} (hJ : Compatible J)
    (a b : ℝ) (v w : Phase n) :
    stdDot n (cayleyP J b a v) (cayleyP J a b w) =
      stdDot n (cayleyP J a b v) (cayleyP J b a w) := by
  simp only [cayleyP_apply, map_add, map_smul,
    add_apply, smul_apply, smul_eq_mul]
  rw [relativeOperator_selfadjoint hJ v w]
  ring

theorem cayleyP_stdDot_positive {n : ℕ} {J : End n} (hJ : Compatible J)
    {a b : ℝ} (ha : 0 < a) (hb : 0 ≤ b) {v : Phase n} (hv : v ≠ 0) :
    0 < stdDot n (cayleyP J b a v) (cayleyP J a b v) := by
  have he : stdDot n (cayleyP J b a v) (cayleyP J a b v) =
      a * b * (stdDot n (relativeOperator J v) (relativeOperator J v) + stdDot n v v) +
      (a ^ 2 + b ^ 2) * stdDot n v (relativeOperator J v) := by
    simp only [cayleyP_apply, map_add, map_smul,
      add_apply, smul_apply, smul_eq_mul]
    rw [relativeOperator_selfadjoint hJ v v]
    ring
  rw [he]
  have hfirst : 0 ≤ a * b *
      (stdDot n (relativeOperator J v) (relativeOperator J v) + stdDot n v v) :=
    mul_nonneg (mul_nonneg ha.le hb) (add_nonneg (stdDot_nonneg _) (stdDot_nonneg _))
  have hcoeff : 0 < a ^ 2 + b ^ 2 := by nlinarith [sq_pos_of_pos ha, sq_nonneg b]
  exact add_pos_of_nonneg_of_pos hfirst (mul_pos hcoeff (relativeOperator_positive hJ hv))

def cayleyOperator {n : ℕ} (J : End n) (a b : ℝ) : End n :=
  (cayleyP J a b).comp (cayleyP J b a).inverse

theorem cayleyOperator_on_denominator {n : ℕ} {J : End n} {a b : ℝ}
    (hQ : (cayleyP J b a).IsInvertible) (v : Phase n) :
    cayleyOperator J a b (cayleyP J b a v) = cayleyP J a b v := by
  obtain ⟨e,he⟩ := hQ
  simp only [cayleyOperator, ←he, ContinuousLinearMap.comp_apply,
    ContinuousLinearMap.inverse_equiv, ContinuousLinearEquiv.coe_coe,
    ContinuousLinearEquiv.symm_apply_apply]

theorem denominator_cayleyOperator {n : ℕ} {J : End n} {a b : ℝ}
    (hQ : (cayleyP J b a).IsInvertible) (v : Phase n) :
    cayleyP J b a (cayleyOperator J a b v) = cayleyP J a b v := by
  change cayleyP J b a (cayleyP J a b ((cayleyP J b a).inverse v)) = _
  rw [cayleyP_commute]
  obtain ⟨e,he⟩ := hQ
  simp [←he]

theorem cayleyOperator_selfadjoint {n : ℕ} {J : End n} (hJ : Compatible J)
    {a b : ℝ} (hQ : (cayleyP J b a).IsInvertible) (v w : Phase n) :
    stdDot n (cayleyOperator J a b v) w = stdDot n v (cayleyOperator J a b w) := by
  obtain ⟨e,he⟩ := hQ
  obtain ⟨x,rfl⟩ := e.surjective v
  obtain ⟨y,rfl⟩ := e.surjective w
  change stdDot n (cayleyOperator J a b ((e : End n) x)) ((e : End n) y) =
    stdDot n ((e : End n) x) (cayleyOperator J a b ((e : End n) y))
  rw [he, cayleyOperator_on_denominator ⟨e,he⟩,
    cayleyOperator_on_denominator ⟨e,he⟩]
  exact (cayleyP_stdDot_identity hJ a b x y).symm

theorem cayleyOperator_positive {n : ℕ} {J : End n} (hJ : Compatible J)
    {a b : ℝ} (ha : 0 < a) (hb : 0 ≤ b) {v : Phase n} (hv : v ≠ 0) :
    0 < stdDot n v (cayleyOperator J a b v) := by
  obtain ⟨e,he⟩ := cayleyP_invertible hJ ha hb
  obtain ⟨x,rfl⟩ := e.surjective v
  have hx : x ≠ 0 := by simpa using hv
  change 0 < stdDot n ((e : End n) x) (cayleyOperator J a b ((e : End n) x))
  rw [he, cayleyOperator_on_denominator ⟨e,he⟩]
  exact cayleyP_stdDot_positive hJ ha hb hx

theorem cayleyOperator_J_identity {n : ℕ} {J : End n} (hJ : Compatible J)
    {a b : ℝ} (hQ : (cayleyP J b a).IsInvertible) (v : Phase n) :
    cayleyOperator J a b (standardJ n (cayleyOperator J a b v)) = standardJ n v := by
  obtain ⟨e,he⟩ := hQ
  obtain ⟨x,rfl⟩ := e.surjective v
  apply e.injective
  change (e : End n) (cayleyOperator J a b (standardJ n (cayleyOperator J a b ((e : End n) x)))) =
    (e : End n) (standardJ n ((e : End n) x))
  rw [he, denominator_cayleyOperator ⟨e,he⟩, cayleyOperator_on_denominator ⟨e,he⟩]
  exact cayleyP_J_identity hJ a b x

def interpolateJ {n : ℕ} (J : End n) (t : ℝ) : End n :=
  (standardJ n).comp (cayleyOperator J (1 + t) (1 - t))

theorem compatible_interpolateJ {n : ℕ} {J : End n} (hJ : Compatible J)
    {t : ℝ} (ht : t ∈ Icc (0 : ℝ) 1) : Compatible (interpolateJ J t) := by
  have ha : 0 < 1 + t := by linarith [ht.1]
  have hb : 0 ≤ 1 - t := by linarith [ht.2]
  have hQ := cayleyP_invertible hJ ha hb
  apply compatible_of_sq_symmetric_positive
  · intro v
    change standardJ n (cayleyOperator J (1+t) (1-t)
      (standardJ n (cayleyOperator J (1+t) (1-t) v))) = -v
    rw [cayleyOperator_J_identity hJ hQ, standardJ_sq]
  · intro v w
    change standardForm v (standardJ n (cayleyOperator J (1+t) (1-t) w)) =
      standardForm w (standardJ n (cayleyOperator J (1+t) (1-t) v))
    rw [standardForm_J_right, standardForm_J_right,
      ←cayleyOperator_selfadjoint hJ hQ, stdDot_symm]
  · intro v hv
    change 0 < standardForm v (standardJ n (cayleyOperator J (1+t) (1-t) v))
    rw [standardForm_J_right]
    exact cayleyOperator_positive hJ ha hb hv

@[simp] theorem interpolateJ_zero {n : ℕ} {J : End n} (hJ : Compatible J) :
    interpolateJ J 0 = standardJ n := by
  have hQ := cayleyP_invertible hJ (a := 1) (b := 1) (by norm_num) (by norm_num)
  obtain ⟨e,he⟩ := hQ
  apply ContinuousLinearMap.ext
  intro v
  obtain ⟨x,rfl⟩ := e.surjective v
  change standardJ n (cayleyOperator J (1+0) (1-0) ((e : End n) x)) = standardJ n ((e : End n) x)
  simp only [add_zero, sub_zero, he, cayleyOperator_on_denominator ⟨e,he⟩]

@[simp] theorem interpolateJ_one {n : ℕ} {J : End n} (hJ : Compatible J) :
    interpolateJ J 1 = J := by
  have hQ := cayleyP_invertible hJ (a := 2) (b := 0) (by norm_num) (by norm_num)
  obtain ⟨e,he⟩ := hQ
  apply ContinuousLinearMap.ext
  intro v
  obtain ⟨x,rfl⟩ := e.surjective v
  change standardJ n (cayleyOperator J (1+1) (1-1) ((e : End n) x)) = J ((e : End n) x)
  norm_num only [he, show (1:ℝ)+1=2 by norm_num, sub_self,
    cayleyOperator_on_denominator ⟨e,he⟩]
  simp

theorem contDiffAt_interpolateJ {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
    {n : ℕ} {J : E → End n} {t : E → ℝ} {x : E}
    (hJs : ContDiffAt ℝ ∞ J x) (hts : ContDiffAt ℝ ∞ t x)
    (hJ : Compatible (J x)) (ht : t x ∈ Icc (0 : ℝ) 1) :
    ContDiffAt ℝ ∞ (fun y => interpolateJ (J y) (t y)) x := by
  have hA : ContDiffAt ℝ ∞ (fun y => relativeOperator (J y)) x :=
    (contDiffAt_const.clm_comp hJs).neg
  have ha : ContDiffAt ℝ ∞ (fun y => 1 + t y) x := contDiffAt_const.add hts
  have hb : ContDiffAt ℝ ∞ (fun y => 1 - t y) x := contDiffAt_const.sub hts
  have hP : ContDiffAt ℝ ∞ (fun y => cayleyP (J y) (1+t y) (1-t y)) x :=
    (ha.smul hA).add (hb.smul contDiffAt_const)
  have hQ : ContDiffAt ℝ ∞ (fun y => cayleyP (J y) (1-t y) (1+t y)) x :=
    (hb.smul hA).add (ha.smul contDiffAt_const)
  have hQi := cayleyP_invertible hJ (show 0 < 1 + t x by linarith [ht.1])
    (show 0 ≤ 1 - t x by linarith [ht.2])
  have hI : ContDiffAt ℝ ∞ (fun y => (cayleyP (J y) (1-t y) (1+t y)).inverse) x :=
    ContDiffAt.comp x (g := ContinuousLinearMap.inverse)
      (ContinuousLinearMap.IsInvertible.contDiffAt_map_inverse (n := ∞) hQi) hQ
  exact contDiffAt_const.clm_comp (hP.clm_comp hI)

end HigherDimensionalBallPacking.Rigidity

end

end OAI