import Mathlib
import OAI.Geometry.BallPacking.Necessity.FrozenOperators
import OAI.Geometry.BallPacking.Necessity.EqualDimension

namespace OAI

noncomputable section
open scoped ContDiff Topology
open Set Function Filter
open scoped ContDiff Topology Manifold
open Set Function Filter MeasureTheory
open Set Function MeasureTheory
open Set Function
open SymplecticBallPacking.Hamiltonian (Plane planarCurl)
open SymplecticBallPacking.Hamiltonian (Plane planarCurl angularOneForm radiusSq planarArea planarArea_apply)
open SymplecticBallPacking.Hamiltonian (Plane planarCurl angularOneForm)
open SymplecticBallPacking.Hamiltonian (Plane angularOneForm)
open SymplecticBallPacking.Hamiltonian
open SymplecticBallPacking.Hamiltonian (Plane)
open Set Filter Function
open Set Filter MeasureTheory
open scoped Topology
open Set Filter Finset
open scoped ContDiff Topology Classical
open Set Filter
open scoped BoundedContinuousFunction ContDiff Topology
open Set Function Filter Topology
open scoped NNReal
open scoped ContDiff Topology BoundedContinuousFunction
open Function
open scoped Topology ContDiff
open scoped ContDiff Topology Convolution
open Set Filter Function MeasureTheory _root_.ContinuousLinearMap _root_.OAI.ContinuousLinearMap
open Set Filter Function MeasureTheory

open scoped ContDiff Topology BoundedContinuousFunction
open Set Filter Function
namespace HigherDimensionalBallPacking.Rigidity
variable {E F : Type} [NormedAddCommGroup E] [NormedSpace ℝ E] [CompleteSpace E]
  [NormedAddCommGroup F] [NormedSpace ℝ F] [CompleteSpace F]
local instance holderInverseHGroup (V : Type) [NormedAddCommGroup V] [NormedSpace ℝ V] (α : ℝ) :
    NormedAddCommGroup (HolderSpace ℂ V α) := inferInstance
local instance holderInverseHSpace (V : Type) [NormedAddCommGroup V] [NormedSpace ℝ V] (α : ℝ) :
    NormedSpace ℝ (HolderSpace ℂ V α) := inferInstance
local instance holderInverseCGroup (V : Type) [NormedAddCommGroup V] [NormedSpace ℝ V] [CompleteSpace V] (α : ℝ) :
    NormedAddCommGroup (C1HolderSpace V α) := inferInstance
local instance holderInverseCSpace (V : Type) [NormedAddCommGroup V] [NormedSpace ℝ V] [CompleteSpace V] (α : ℝ) :
    NormedSpace ℝ (C1HolderSpace V α) := inferInstance

 def c1HolderMap (α : ℝ) (L : E →L[ℝ] F) : C1HolderSpace E α →L[ℝ] C1HolderSpace F α :=
  (((holderMap α L).comp (c1HolderValue α)).prod
    ((holderMap α ((ContinuousLinearMap.compL ℝ ℂ E F) L)).comp (c1HolderDeriv α))).codRestrict
      (c1HolderGraph α) (by
        intro u
        apply c1HolderGraph_mem_of_hasFDerivAt α
        intro z
        exact L.hasFDerivAt.comp z (c1Holder_hasFDerivAt α u z))

 @[simp] theorem c1HolderMap_value (α : ℝ) (L : E →L[ℝ] F) (u : C1HolderSpace E α) (z : ℂ) :
    holderValue α (c1HolderValue α (c1HolderMap α L u)) z=
      L (holderValue α (c1HolderValue α u) z) := rfl

 theorem inverseField_continuous {a : ℂ → E →L[ℝ] E} (ha : Continuous a)
    (hi : ∀ z, (a z).IsInvertible) : Continuous (fun z => (a z).inverse) := by
  rw [continuous_iff_continuousAt]
  intro z
  exact ((hi z).contDiffAt_map_inverse (n := ∞)).continuousAt.comp ha.continuousAt

 theorem inverseField_bound (R : ℝ) {a : ℂ → E →L[ℝ] E} (ha : Continuous a)
    (hi : ∀ z, (a z).IsInvertible) (hout : ∀ z, R<‖z‖ → a z=ContinuousLinearMap.id ℝ E) :
    ∃ C : ℝ, 0<C ∧ ∀ z, ‖(a z).inverse‖≤C := by
  have hc := inverseField_continuous ha hi
  obtain ⟨C,hC⟩ := (isCompact_closedBall (0:ℂ) R).exists_bound_of_continuousOn hc.continuousOn
  refine ⟨max C ‖ContinuousLinearMap.id ℝ E‖+1,by positivity,?_⟩
  intro z
  by_cases hz : ‖z‖≤R
  · exact (hC z (by simpa using hz)).trans ((le_max_left _ _).trans (by linarith))
  · rw [hout z (lt_of_not_ge hz),ContinuousLinearMap.inverse_id]
    exact (le_max_right _ _).trans (by linarith)

 omit [CompleteSpace E] in
 theorem inverseField_sub {a b : E →L[ℝ] E} (ha : a.IsInvertible) (hb : b.IsInvertible) :
    a.inverse-b.inverse=a.inverse.comp ((b-a).comp b.inverse) := by
  ext v
  simp only [sub_apply,ContinuousLinearMap.comp_apply,map_sub,
    hb.self_apply_inverse,ha.inverse_apply_self]

 omit [CompleteSpace E] in
 theorem inverseField_holder (α : ℝ) (hα : 0<α) (A : HolderSpace ℂ (E →L[ℝ] E) α)
    (hi : ∀ z, (holderValue α A z).IsInvertible) (C : ℝ) (hC : 0≤C)
    (hb : ∀ z, ‖(holderValue α A z).inverse‖≤C) (x y : ℂ) :
    ‖(holderValue α A x).inverse-(holderValue α A y).inverse‖≤
      (C*C*‖A‖)*(dist x y)^α := by
  rw [inverseField_sub (hi x) (hi y)]
  calc
    _ ≤ ‖(holderValue α A x).inverse‖*
        (‖holderValue α A y-holderValue α A x‖*‖(holderValue α A y).inverse‖) :=
      (ContinuousLinearMap.opNorm_comp_le _ _).trans
        (mul_le_mul_of_nonneg_left (ContinuousLinearMap.opNorm_comp_le _ _) (norm_nonneg _))
    _ ≤ C*((‖A‖*(dist y x)^α)*C) :=
      mul_le_mul (hb x) (mul_le_mul (holderSpace_estimate α hα A y x) (hb y)
        (norm_nonneg _) (by positivity)) (by positivity) hC
    _ = _ := by rw [dist_comm y x]; ring

 def holderInverse (α : ℝ) (hα : 0<α) (R : ℝ) (A : HolderSpace ℂ (E →L[ℝ] E) α)
    (hi : ∀ z, (holderValue α A z).IsInvertible)
    (hout : ∀ z, R<‖z‖ → holderValue α A z=ContinuousLinearMap.id ℝ E) :
    HolderSpace ℂ (E →L[ℝ] E) α := by
  let ex := inverseField_bound R (holderValue α A).continuous hi hout
  let C := Classical.choose ex
  have hC := (Classical.choose_spec ex).1
  have hb := (Classical.choose_spec ex).2
  let f : ℂ →ᵇ (E →L[ℝ] E) := BoundedContinuousFunction.ofNormedAddCommGroup
    (fun z => (holderValue α A z).inverse) (inverseField_continuous (holderValue α A).continuous hi) C hb
  exact holderSpaceMk α f (C*C*‖A‖) (by positivity) (inverseField_holder α hα A hi C hC.le hb)

 theorem holderInverse_value (α : ℝ) (hα : 0<α) (R : ℝ) (A : HolderSpace ℂ (E →L[ℝ] E) α)
    (hi : ∀ z, (holderValue α A z).IsInvertible)
    (hout : ∀ z, R<‖z‖ → holderValue α A z=ContinuousLinearMap.id ℝ E) (z : ℂ) :
    holderValue α (holderInverse α hα R A hi hout) z=(holderValue α A z).inverse := by
  rfl

end HigherDimensionalBallPacking.Rigidity

 

 

open scoped ContDiff Topology BoundedContinuousFunction
open Set Filter Function
open SymplecticBallPacking.Hamiltonian
namespace HigherDimensionalBallPacking.Rigidity
open HigherDimensionalBallPacking.Rigidity
local instance FrozenOperatorLocal1 (E : Type) [NormedAddCommGroup E] [NormedSpace ℝ E] (α : ℝ) :
    NormedAddCommGroup (HolderSpace ℂ E α) := inferInstance
local instance FrozenOperatorLocal2 (E : Type) [NormedAddCommGroup E] [NormedSpace ℝ E] (α : ℝ) :
    NormedSpace ℝ (HolderSpace ℂ E α) := inferInstance
local instance FrozenOperatorLocal3 (E : Type) [NormedAddCommGroup E] [NormedSpace ℝ E] [CompleteSpace E] (α : ℝ) :
    NormedAddCommGroup (C1HolderSpace E α) := inferInstance
local instance FrozenOperatorLocal4 (E : Type) [NormedAddCommGroup E] [NormedSpace ℝ E] [CompleteSpace E] (α : ℝ) :
    NormedSpace ℝ (C1HolderSpace E α) := inferInstance
local instance FrozenOperatorLocal5 (E : Type) [NormedAddCommGroup E] [NormedSpace ℝ E] (R : ℝ) :
    NormedAddCommGroup (CompactHolderSpace E R) := inferInstance
local instance FrozenOperatorLocal6 (E : Type) [NormedAddCommGroup E] [NormedSpace ℝ E] (R : ℝ) :
    NormedSpace ℝ (CompactHolderSpace E R) := inferInstance

 theorem frame_product_decay {n : ℕ} (R : ℝ) (a : ℂ → End n) (v : ℂ → Phase n)
    (hout : ∀ z, R<‖z‖ → a z=ContinuousLinearMap.id ℝ (Phase n))
    (hv : Tendsto v (cocompact ℂ) (𝓝 0)) :
    Tendsto (fun z => a z (v z)) (cocompact ℂ) (𝓝 0) := by
  apply hv.congr'
  filter_upwards [(isCompact_closedBall (0:ℂ) R).compl_mem_cocompact] with z hz
  have hzR : R<‖z‖ := by simpa only [mem_compl_iff,Metric.mem_closedBall,dist_zero_right,not_le] using hz
  rw [hout z hzR,ContinuousLinearMap.id_apply]

 theorem frame_product_inhomogeneous {n : ℕ} (a : ℂ → End n) (v : ℂ → Phase n)
    (ha : ContDiff ℝ 1 a) (hv : ContDiff ℝ 1 v) (K M : ℂ → End n) (d f : ℂ → Phase n)
    (hi : ∀ z, (a z).IsInvertible)
    (hint : ∀ z x, a z (Complex.I • x)=K z (a z x))
    (hM : ∀ z x, fderiv ℝ a z Complex.I x-K z (fderiv ℝ a z 1 x)=a z (M z x))
    (hCR : ∀ z, fderiv ℝ v z Complex.I-Complex.I • fderiv ℝ v z 1=d z)
    (hd : ∀ z, d z+M z (v z)=(a z).inverse (f z)) :
    ∀ z, fderiv ℝ (fun z => a z (v z)) z Complex.I-
      K z (fderiv ℝ (fun z => a z (v z)) z 1)=f z := by
  intro z
  rw [frame_product_CR (ha.differentiable one_ne_zero z)
    (hv.differentiable one_ne_zero z) (K z) (M z) (hint z) (hM z),
      hCR z,hd z,(hi z).self_apply_inverse]

 theorem unmarked_density_equation {n : ℕ} (R : ℝ)
    (M B : HolderSpace ℂ (End n) ((1:ℝ)/3))
    (hs : ∀ z : ℂ, R<‖z‖ → holderValue ((1:ℝ)/3) M z=0)
    (hsurj : Surjective (fun g : CompactHolderSpace (Phase n) R => g+unmarkedLower R M hs g))
    (f : CompactHolderSpace (Phase n) R) :
    ∃ d : CompactHolderSpace (Phase n) R, ∀ z,
      compactHolderValue R d z+holderValue ((1:ℝ)/3) M z (compactCRInverseValue R d z)=
        holderValue ((1:ℝ)/3) B z (compactHolderValue R f z) := by
  obtain ⟨d,hd⟩ := hsurj (compactHolderMul R B f)
  refine ⟨d,?_⟩
  intro z
  exact congrArg (fun g => compactHolderValue R g z) hd

 theorem framed_density_equation {n : ℕ} (R : ℝ) (K : ℂ → End n)
    (hK : ∀ z, Compatible (K z)) (hKout : ∀ z : ℂ, R<‖z‖ → K z=standardJ n)
    (A : C1HolderSpace (End n) ((1:ℝ)/3)) (M : HolderSpace ℂ (End n) ((1:ℝ)/3))
    (hs : ∀ z : ℂ, R<‖z‖ → holderValue ((1:ℝ)/3) M z=0)
    (hAout : ∀ z : ℂ, R<‖z‖ → holderValue ((1:ℝ)/3) (c1HolderValue ((1:ℝ)/3) A) z=ContinuousLinearMap.id ℝ _)
    (hi : ∀ z, (holderValue ((1:ℝ)/3) (c1HolderValue ((1:ℝ)/3) A) z).IsInvertible)
    (hint : ∀ z x, holderValue ((1:ℝ)/3) (c1HolderValue ((1:ℝ)/3) A) z (Complex.I • x)=
      K z (holderValue ((1:ℝ)/3) (c1HolderValue ((1:ℝ)/3) A) z x))
    (hM : ∀ z x, fderiv ℝ (holderValue ((1:ℝ)/3) (c1HolderValue ((1:ℝ)/3) A)) z Complex.I x-
      K z (fderiv ℝ (holderValue ((1:ℝ)/3) (c1HolderValue ((1:ℝ)/3) A)) z 1 x)=
      holderValue ((1:ℝ)/3) (c1HolderValue ((1:ℝ)/3) A) z (holderValue ((1:ℝ)/3) M z x))
    (f : CompactHolderSpace (Phase n) R) :
    ∃ d : CompactHolderSpace (Phase n) R, ∀ z,
      compactHolderValue R d z+holderValue ((1:ℝ)/3) M z (compactCRInverseValue R d z)=
        (holderValue ((1:ℝ)/3) (c1HolderValue ((1:ℝ)/3) A) z).inverse (compactHolderValue R f z) := by
  let B : HolderSpace ℂ (End n) ((1:ℝ)/3) :=
    holderInverse (E := Phase n) ((1:ℝ)/3) (by norm_num) R
      (c1HolderValue (E := End n) ((1:ℝ)/3) A) hi hAout
  have hsurj : Surjective (fun g : CompactHolderSpace (Phase n) R =>
      g+unmarkedLower R M hs g) := framed_unmarked_surjective (n := n) R K hK hKout A M hs hAout
    (fun z => (hi z).injective) hint hM
  obtain ⟨d,hd⟩ := unmarked_density_equation (n := n) R M B hs hsurj f
  refine ⟨d,?_⟩
  intro z
  exact (hd z).trans (congrArg (fun operator : End n => operator (compactHolderValue R f z))
    (holderInverse_value (E := Phase n) ((1:ℝ)/3) (by norm_num) R
      (c1HolderValue (E := End n) ((1:ℝ)/3) A) hi hAout z))

 theorem framed_frozen_solution {n : ℕ} (R : ℝ) (K : ℂ → End n)
    (hK : ∀ z, Compatible (K z)) (hKout : ∀ z : ℂ, R<‖z‖ → K z=standardJ n)
    (A : C1HolderSpace (End n) ((1:ℝ)/3)) (M : HolderSpace ℂ (End n) ((1:ℝ)/3))
    (hs : ∀ z : ℂ, R<‖z‖ → holderValue ((1:ℝ)/3) M z=0)
    (hAout : ∀ z : ℂ, R<‖z‖ → holderValue ((1:ℝ)/3) (c1HolderValue ((1:ℝ)/3) A) z=ContinuousLinearMap.id ℝ _)
    (hi : ∀ z, (holderValue ((1:ℝ)/3) (c1HolderValue ((1:ℝ)/3) A) z).IsInvertible)
    (hint : ∀ z x, holderValue ((1:ℝ)/3) (c1HolderValue ((1:ℝ)/3) A) z (Complex.I • x)=
      K z (holderValue ((1:ℝ)/3) (c1HolderValue ((1:ℝ)/3) A) z x))
    (hM : ∀ z x, fderiv ℝ (holderValue ((1:ℝ)/3) (c1HolderValue ((1:ℝ)/3) A)) z Complex.I x-
      K z (fderiv ℝ (holderValue ((1:ℝ)/3) (c1HolderValue ((1:ℝ)/3) A)) z 1 x)=
      holderValue ((1:ℝ)/3) (c1HolderValue ((1:ℝ)/3) A) z (holderValue ((1:ℝ)/3) M z x))
    (f : CompactHolderSpace (Phase n) R) :
    ∃ U : C1HolderSpace (Phase n) ((1:ℝ)/3),
      let u := holderValue ((1:ℝ)/3) (c1HolderValue ((1:ℝ)/3) U)
      (∀ z, fderiv ℝ u z Complex.I-K z (fderiv ℝ u z 1)=compactHolderValue R f z) ∧
        Tendsto u (cocompact ℂ) (𝓝 0) := by
  obtain ⟨d,hd⟩ := framed_density_equation R K hK hKout A M hs hAout hi hint hM f
  let U := c1HolderMultiply ((1:ℝ)/3) A (compactCRInverse R d)
  refine ⟨U,?_,?_⟩
  · exact frame_product_inhomogeneous
      (holderValue ((1:ℝ)/3) (c1HolderValue ((1:ℝ)/3) A)) (compactCRInverseValue R d)
      (c1Holder_contDiff _ A) (compactCRInverse_contDiff R d) K
      (holderValue ((1:ℝ)/3) M) (compactHolderValue R d) (compactHolderValue R f)
      hi hint hM (compactCRInverse_rightInverse R d) hd
  · exact frame_product_decay R _ (compactCRInverseValue R d) hAout (compactCRInverse_tendsto_zero R d)

 def frozenPrincipal {n : ℕ} (R : ℝ) (H : HolderSpace ℂ (End n) ((1:ℝ)/3))
    (hs : ∀ z : ℂ, R<‖z‖ → holderValue ((1:ℝ)/3) H z=0) :
    CompactHolderSpace (Phase n) R →L[ℝ] CompactHolderSpace (Phase n) R :=
  ContinuousLinearMap.id ℝ _-
    (((holderCLM ((1:ℝ)/3) H).comp
      (((holderJetEval ((1:ℝ)/3) 1).comp (c1HolderDeriv ((1:ℝ)/3))).comp (compactCRInverse R))).codRestrict
        (compactHolderSubmodule R) (by
          intro g z hz
          change holderValue ((1:ℝ)/3) H z (holderValue ((1:ℝ)/3)
            (c1HolderDeriv ((1:ℝ)/3) (compactCRInverse R g)) z 1)=0
          rw [hs z hz,zero_apply]))

 theorem frozenPrincipal_value {n : ℕ} (R : ℝ) (H : HolderSpace ℂ (End n) ((1:ℝ)/3))
    (hs : ∀ z : ℂ, R<‖z‖ → holderValue ((1:ℝ)/3) H z=0)
    (g : CompactHolderSpace (Phase n) R) (z : ℂ) :
    compactHolderValue R (frozenPrincipal R H hs g) z=compactHolderValue R g z-
      holderValue ((1:ℝ)/3) H z (fderiv ℝ (compactCRInverseValue R g) z 1) := by
  have hd : fderiv ℝ (compactCRInverseValue R g) z=
      holderValue ((1:ℝ)/3) (c1HolderDeriv ((1:ℝ)/3) (compactCRInverse R g)) z :=
    (c1Holder_hasFDerivAt ((1:ℝ)/3) (compactCRInverse R g) z).fderiv
  rw [hd]
  rfl

 theorem compactHolderValue_injective {n : ℕ} (R : ℝ) :
    Injective (compactHolderValue (E := Phase n) R) := by
  intro g h he
  apply Subtype.ext
  exact holderValue_injective ((1:ℝ)/3) he

 theorem c1_potential_yields_frozen_density {n : ℕ} (R : ℝ)
    (H : HolderSpace ℂ (End n) ((1:ℝ)/3))
    (hs : ∀ z : ℂ, R<‖z‖ → holderValue ((1:ℝ)/3) H z=0)
    (f : CompactHolderSpace (Phase n) R) (U : C1HolderSpace (Phase n) ((1:ℝ)/3))
    (hCR : ∀ z, fderiv ℝ (holderValue ((1:ℝ)/3) (c1HolderValue ((1:ℝ)/3) U)) z Complex.I-
      (standardJ n+holderValue ((1:ℝ)/3) H z)
        (fderiv ℝ (holderValue ((1:ℝ)/3) (c1HolderValue ((1:ℝ)/3) U)) z 1)=compactHolderValue R f z)
    (hlim : Tendsto (holderValue ((1:ℝ)/3) (c1HolderValue ((1:ℝ)/3) U)) (cocompact ℂ) (𝓝 0)) :
    ∃ g : CompactHolderSpace (Phase n) R, frozenPrincipal R H hs g=f := by
  let u := holderValue ((1:ℝ)/3) (c1HolderValue ((1:ℝ)/3) U)
  have hu : ContDiff ℝ 1 u := c1Holder_contDiff _ U
  have hc (z : ℂ) : holderValue ((1:ℝ)/3) (c1StandardCurl U) z=
      compactHolderValue R f z+holderValue ((1:ℝ)/3) H z (fderiv ℝ u z 1) := by
    rw [c1StandardCurl_value]
    have hh := hCR z
    change fderiv ℝ u z Complex.I-(Complex.I • fderiv ℝ u z 1+holderValue ((1:ℝ)/3) H z (fderiv ℝ u z 1))=_ at hh
    change fderiv ℝ u z Complex.I-Complex.I • fderiv ℝ u z 1=_
    rw [sub_add_eq_sub_sub] at hh
    exact sub_eq_iff_eq_add.mp hh
  let g : CompactHolderSpace (Phase n) R := ⟨c1StandardCurl U,by
    intro z hz
    have hf0 : compactHolderValue R f z=0 := f.property z hz
    rw [hc z,hs z hz,hf0,zero_apply,add_zero]⟩
  have hrep : (u : ℂ → Phase n)=compactCRInverseValue R g :=
    c1_decay_cauchy_representation R g hu (fun z => (c1StandardCurl_value U z).symm) hlim
  refine ⟨g,compactHolderValue_injective R ?_⟩
  apply BoundedContinuousFunction.ext
  intro z
  rw [frozenPrincipal_value]
  change holderValue ((1:ℝ)/3) (c1StandardCurl U) z-_=_
  rw [hc z,←hrep,add_sub_cancel_right]

end HigherDimensionalBallPacking.Rigidity

 

 

open scoped ContDiff Topology BoundedContinuousFunction
open Set Filter Function
open SymplecticBallPacking.Hamiltonian
namespace HigherDimensionalBallPacking.Rigidity
open HigherDimensionalBallPacking.Rigidity
local instance frameFieldInst1 (E : Type) [NormedAddCommGroup E] [NormedSpace ℝ E] (α : ℝ) :
    NormedAddCommGroup (HolderSpace ℂ E α) := inferInstance
local instance frameFieldInst2 (E : Type) [NormedAddCommGroup E] [NormedSpace ℝ E] (α : ℝ) :
    NormedSpace ℝ (HolderSpace ℂ E α) := inferInstance
local instance frameFieldInst3 (E : Type) [NormedAddCommGroup E] [NormedSpace ℝ E] [CompleteSpace E] (α : ℝ) :
    NormedAddCommGroup (C1HolderSpace E α) := inferInstance
local instance frameFieldInst4 (E : Type) [NormedAddCommGroup E] [NormedSpace ℝ E] [CompleteSpace E] (α : ℝ) :
    NormedSpace ℝ (C1HolderSpace E α) := inferInstance

 def normalizedHolderFrame {n : ℕ} (K : C1HolderSpace (End n) ((1:ℝ)/3)) :
    C1HolderSpace (End n) ((1:ℝ)/3) :=
  c1HolderConstantCLM ((1:ℝ)/3) ((1/2:ℝ) • ContinuousLinearMap.id ℝ (Phase n))-
    c1HolderMap ((1:ℝ)/3)
      ((1/2:ℝ) • (ContinuousLinearMap.compL ℝ (Phase n) (Phase n) (Phase n)).flip (standardJ n)) K

 theorem normalizedHolderFrame_value {n : ℕ} (K : C1HolderSpace (End n) ((1:ℝ)/3)) (z : ℂ) :
    holderValue ((1:ℝ)/3) (c1HolderValue ((1:ℝ)/3) (normalizedHolderFrame K)) z=
      (1/2:ℝ) • relativeTransition 1 (standardJ n) (holderValue ((1:ℝ)/3) (c1HolderValue ((1:ℝ)/3) K) z) := by
  change (1/2:ℝ) • ContinuousLinearMap.id ℝ (Phase n)-
    (1/2:ℝ) • (holderValue ((1:ℝ)/3) (c1HolderValue ((1:ℝ)/3) K) z).comp (standardJ n)=_
  simp only [relativeTransition,one_smul,smul_sub]

 theorem normalizedFrame_intertwines {n : ℕ} {K : End n} (hK : Compatible K) (x : Phase n) :
    ((1/2:ℝ) • relativeTransition 1 (standardJ n) K) (Complex.I • x)=
      K (((1/2:ℝ) • relativeTransition 1 (standardJ n) K) x) := by
  simp only [smul_apply,relativeTransition_apply,one_smul]
  change (1/2:ℝ) • (standardJ n x-K (standardJ n (standardJ n x)))=
    K ((1/2:ℝ) • (x-K (standardJ n x)))
  rw [standardJ_sq,map_neg,map_smul,map_sub,hK.1]
  module

 theorem normalizedFrame_invertible {n : ℕ} {K : End n} (hK : Compatible K) :
    ((1/2:ℝ) • relativeTransition 1 (standardJ n) K).IsInvertible := by
  have ht := relativeTransition_isInvertible (compatible_standardJ n).compatibleWith_stdOmega
    hK.compatibleWith_stdOmega (t := 1) (by norm_num)
  let A : End n := (1/2:ℝ) • relativeTransition 1 (standardJ n) K
  have hi : Injective A := by
    intro x y hxy
    apply ht.injective
    exact (smul_right_injective (Phase n) (by norm_num : (1/2:ℝ)≠0)) hxy
  exact ⟨(LinearEquiv.ofBijective A.toLinearMap ⟨hi,LinearMap.surjective_of_injective hi⟩).toContinuousLinearEquiv,rfl⟩

 theorem normalizedFrame_standard {n : ℕ} :
    (1/2:ℝ) • relativeTransition 1 (standardJ n) (standardJ n)=ContinuousLinearMap.id ℝ (Phase n) := by
  apply ContinuousLinearMap.ext
  intro x
  simp only [smul_apply,relativeTransition_apply,one_smul,ContinuousLinearMap.id_apply]
  change (1/2:ℝ) • (x-standardJ n (standardJ n x))=x
  rw [standardJ_sq]
  module

 theorem constant_outside_fderiv {E : Type} [NormedAddCommGroup E] [NormedSpace ℝ E]
    (R : ℝ) {a : ℂ → E} {c : E} (hout : ∀ z, R<‖z‖ → a z=c) {z : ℂ} (hz : R<‖z‖) :
    fderiv ℝ a z=0 := by
  have he : a=ᶠ[𝓝 z] fun _ => c := by
    filter_upwards [(isOpen_lt continuous_const continuous_norm).mem_nhds hz] with w hw
    exact hout w hw
  rw [he.fderiv_eq,fderiv_const_apply]

 def holderComp {n : ℕ} (A B : HolderSpace ℂ (End n) ((1:ℝ)/3)) :
    HolderSpace ℂ (End n) ((1:ℝ)/3) :=
  holderCLM ((1:ℝ)/3) (holderMap ((1:ℝ)/3) (ContinuousLinearMap.compL ℝ (Phase n) (Phase n) (Phase n)) A) B

 @[simp] theorem holderComp_value {n : ℕ} (A B : HolderSpace ℂ (End n) ((1:ℝ)/3)) (z : ℂ) :
    holderValue ((1:ℝ)/3) (holderComp A B) z=
      (holderValue ((1:ℝ)/3) A z).comp (holderValue ((1:ℝ)/3) B z) := rfl

 def principalFrameLower {n : ℕ} (R : ℝ) (K : HolderSpace ℂ (End n) ((1:ℝ)/3))
    (A : C1HolderSpace (End n) ((1:ℝ)/3))
    (hi : ∀ z, (holderValue ((1:ℝ)/3) (c1HolderValue ((1:ℝ)/3) A) z).IsInvertible)
    (hout : ∀ z, R<‖z‖ → holderValue ((1:ℝ)/3) (c1HolderValue ((1:ℝ)/3) A) z=ContinuousLinearMap.id ℝ (Phase n)) :
    HolderSpace ℂ (End n) ((1:ℝ)/3) :=
  holderComp (holderInverse ((1:ℝ)/3) (by norm_num) R (c1HolderValue ((1:ℝ)/3) A) hi hout)
    ((holderJetEval ((1:ℝ)/3) Complex.I (c1HolderDeriv ((1:ℝ)/3) A))-
      holderComp K (holderJetEval ((1:ℝ)/3) 1 (c1HolderDeriv ((1:ℝ)/3) A)))

 theorem principalFrameLower_value {n : ℕ} (R : ℝ) (K : HolderSpace ℂ (End n) ((1:ℝ)/3))
    (A : C1HolderSpace (End n) ((1:ℝ)/3))
    (hi : ∀ z, (holderValue ((1:ℝ)/3) (c1HolderValue ((1:ℝ)/3) A) z).IsInvertible)
    (hout : ∀ z, R<‖z‖ → holderValue ((1:ℝ)/3) (c1HolderValue ((1:ℝ)/3) A) z=ContinuousLinearMap.id ℝ (Phase n))
    (z : ℂ) (x : Phase n) :
    holderValue ((1:ℝ)/3) (principalFrameLower R K A hi hout) z x=
      (holderValue ((1:ℝ)/3) (c1HolderValue ((1:ℝ)/3) A) z).inverse
      (fderiv ℝ (holderValue ((1:ℝ)/3) (c1HolderValue ((1:ℝ)/3) A)) z Complex.I x-
        holderValue ((1:ℝ)/3) K z (fderiv ℝ (holderValue ((1:ℝ)/3) (c1HolderValue ((1:ℝ)/3) A)) z 1 x)) := by
  rw [(c1Holder_hasFDerivAt ((1:ℝ)/3) A z).fderiv]
  rfl

 theorem principalFrameLower_support {n : ℕ} (R : ℝ) (K : HolderSpace ℂ (End n) ((1:ℝ)/3))
    (A : C1HolderSpace (End n) ((1:ℝ)/3))
    (hi : ∀ z, (holderValue ((1:ℝ)/3) (c1HolderValue ((1:ℝ)/3) A) z).IsInvertible)
    (hout : ∀ z, R<‖z‖ → holderValue ((1:ℝ)/3) (c1HolderValue ((1:ℝ)/3) A) z=ContinuousLinearMap.id ℝ (Phase n))
    (z : ℂ) (hz : R<‖z‖) : holderValue ((1:ℝ)/3) (principalFrameLower R K A hi hout) z=0 := by
  apply ContinuousLinearMap.ext
  intro x
  rw [principalFrameLower_value,constant_outside_fderiv R hout hz]
  simp

end HigherDimensionalBallPacking.Rigidity

 

 

open scoped ContDiff Topology BoundedContinuousFunction
open Set Filter Function
namespace HigherDimensionalBallPacking.Rigidity
open HigherDimensionalBallPacking.Rigidity
local instance FrozenIsomorphismLocal1 (E : Type) [NormedAddCommGroup E] [NormedSpace ℝ E] (α : ℝ) :
    NormedAddCommGroup (HolderSpace ℂ E α) := inferInstance
local instance FrozenIsomorphismLocal2 (E : Type) [NormedAddCommGroup E] [NormedSpace ℝ E] (α : ℝ) :
    NormedSpace ℝ (HolderSpace ℂ E α) := inferInstance
local instance FrozenIsomorphismLocal3 (E : Type) [NormedAddCommGroup E] [NormedSpace ℝ E] [CompleteSpace E] (α : ℝ) :
    NormedAddCommGroup (C1HolderSpace E α) := inferInstance
local instance FrozenIsomorphismLocal4 (E : Type) [NormedAddCommGroup E] [NormedSpace ℝ E] [CompleteSpace E] (α : ℝ) :
    NormedSpace ℝ (C1HolderSpace E α) := inferInstance
local instance FrozenIsomorphismLocal5 (E : Type) [NormedAddCommGroup E] [NormedSpace ℝ E] (R : ℝ) :
    NormedAddCommGroup (CompactHolderSpace E R) := inferInstance
local instance FrozenIsomorphismLocal6 (E : Type) [NormedAddCommGroup E] [NormedSpace ℝ E] (R : ℝ) :
    NormedSpace ℝ (CompactHolderSpace E R) := inferInstance

 theorem principalFrameLower_equation {n : ℕ} (R : ℝ) (K : HolderSpace ℂ (End n) ((1:ℝ)/3))
    (A : C1HolderSpace (End n) ((1:ℝ)/3))
    (hi : ∀ z, (holderValue ((1:ℝ)/3) (c1HolderValue ((1:ℝ)/3) A) z).IsInvertible)
    (hout : ∀ z, R<‖z‖ → holderValue ((1:ℝ)/3) (c1HolderValue ((1:ℝ)/3) A) z=ContinuousLinearMap.id ℝ (Phase n))
    (z : ℂ) (x : Phase n) :
    fderiv ℝ (holderValue ((1:ℝ)/3) (c1HolderValue ((1:ℝ)/3) A)) z Complex.I x-
      holderValue ((1:ℝ)/3) K z (fderiv ℝ (holderValue ((1:ℝ)/3) (c1HolderValue ((1:ℝ)/3) A)) z 1 x)=
        holderValue ((1:ℝ)/3) (c1HolderValue ((1:ℝ)/3) A) z
          (holderValue ((1:ℝ)/3) (principalFrameLower R K A hi hout) z x) := by
  let B := holderValue ((1:ℝ)/3) (c1HolderValue ((1:ℝ)/3) A) z
  let y := fderiv ℝ (holderValue ((1:ℝ)/3) (c1HolderValue ((1:ℝ)/3) A)) z Complex.I x-
    holderValue ((1:ℝ)/3) K z (fderiv ℝ (holderValue ((1:ℝ)/3) (c1HolderValue ((1:ℝ)/3) A)) z 1 x)
  have hh : holderValue ((1:ℝ)/3) (principalFrameLower R K A hi hout) z x=B.inverse y :=
    principalFrameLower_value R K A hi hout z x
  change y=B (holderValue ((1:ℝ)/3) (principalFrameLower R K A hi hout) z x)
  rw [hh]
  exact ((hi z).self_apply_inverse y).symm

 theorem normalizedHolderFrame_intertwines {n : ℕ} (K : C1HolderSpace (End n) ((1:ℝ)/3))
    (hK : ∀ z, Compatible (holderValue ((1:ℝ)/3) (c1HolderValue ((1:ℝ)/3) K) z)) (z : ℂ) (x : Phase n) :
    holderValue ((1:ℝ)/3) (c1HolderValue ((1:ℝ)/3) (normalizedHolderFrame K)) z (Complex.I • x)=
      holderValue ((1:ℝ)/3) (c1HolderValue ((1:ℝ)/3) K) z
        (holderValue ((1:ℝ)/3) (c1HolderValue ((1:ℝ)/3) (normalizedHolderFrame K)) z x) := by
  rw [normalizedHolderFrame_value]
  exact normalizedFrame_intertwines (hK z) x

 theorem compatible_frozen_solution {n : ℕ} (R : ℝ)
    (K : C1HolderSpace (End n) ((1:ℝ)/3))
    (hK : ∀ z, Compatible (holderValue ((1:ℝ)/3) (c1HolderValue ((1:ℝ)/3) K) z))
    (hout : ∀ z, R<‖z‖ → holderValue ((1:ℝ)/3) (c1HolderValue ((1:ℝ)/3) K) z=standardJ n)
    (f : CompactHolderSpace (Phase n) R) :
    ∃ U : C1HolderSpace (Phase n) ((1:ℝ)/3),
      let u := holderValue ((1:ℝ)/3) (c1HolderValue ((1:ℝ)/3) U)
      (∀ z, fderiv ℝ u z Complex.I-
        holderValue ((1:ℝ)/3) (c1HolderValue ((1:ℝ)/3) K) z (fderiv ℝ u z 1)=compactHolderValue R f z) ∧
        Tendsto u (cocompact ℂ) (𝓝 0) := by
  let A := normalizedHolderFrame K
  have hAout : ∀ z, R<‖z‖ → holderValue ((1:ℝ)/3) (c1HolderValue ((1:ℝ)/3) A) z=ContinuousLinearMap.id ℝ (Phase n) := by
    intro z hz
    rw [normalizedHolderFrame_value,hout z hz,normalizedFrame_standard]
  have hi : ∀ z, (holderValue ((1:ℝ)/3) (c1HolderValue ((1:ℝ)/3) A) z).IsInvertible := by
    intro z
    rw [normalizedHolderFrame_value]
    exact normalizedFrame_invertible (hK z)
  let M := principalFrameLower R (c1HolderValue ((1:ℝ)/3) K) A hi hAout
  exact framed_frozen_solution R _ hK hout A M
    (principalFrameLower_support R _ A hi hAout) hAout hi
    (normalizedHolderFrame_intertwines K hK)
    (principalFrameLower_equation R _ A hi hAout) f

 theorem frozenPrincipal_injective {n : ℕ} (R : ℝ)
    (H : HolderSpace ℂ (End n) ((1:ℝ)/3))
    (hs : ∀ z : ℂ, R<‖z‖ → holderValue ((1:ℝ)/3) H z=0)
    (hK : ∀ z, Compatible (standardJ n+holderValue ((1:ℝ)/3) H z)) :
    Injective (frozenPrincipal R H hs) := by
  apply (LinearMap.ker_eq_bot (f := (frozenPrincipal R H hs).toLinearMap)).mp
  apply LinearMap.ker_eq_bot'.mpr
  intro g hg
  apply compactCRInverse_frozen_kernel R (fun z => standardJ n+holderValue ((1:ℝ)/3) H z) hK g
  intro z
  change frozenPrincipal R H hs g=0 at hg
  have he := congrArg (fun g => compactHolderValue R g z) hg
  rw [frozenPrincipal_value] at he
  have hr := compactCRInverse_rightInverse R g z
  change fderiv ℝ (compactCRInverseValue R g) z Complex.I-
    standardJ n (fderiv ℝ (compactCRInverseValue R g) z 1)=_ at hr
  change compactHolderValue R g z-holderValue ((1:ℝ)/3) H z (fderiv ℝ (compactCRInverseValue R g) z 1)=0 at he
  rw [add_apply]
  have hh := sub_eq_zero.mp he
  rw [←hr] at hh
  exact sub_eq_iff_eq_add.mp hh |>.trans (add_comm _ _)

 theorem frozenPrincipal_surjective {n : ℕ} (R : ℝ)
    (K : C1HolderSpace (End n) ((1:ℝ)/3))
    (H : HolderSpace ℂ (End n) ((1:ℝ)/3))
    (hs : ∀ z : ℂ, R<‖z‖ → holderValue ((1:ℝ)/3) H z=0)
    (he : ∀ z, holderValue ((1:ℝ)/3) (c1HolderValue ((1:ℝ)/3) K) z=standardJ n+holderValue ((1:ℝ)/3) H z)
    (hK : ∀ z, Compatible (holderValue ((1:ℝ)/3) (c1HolderValue ((1:ℝ)/3) K) z)) :
    Surjective (frozenPrincipal R H hs) := by
  intro f
  have ho (z : ℂ) (hz : R<‖z‖) :
      holderValue ((1:ℝ)/3) (c1HolderValue ((1:ℝ)/3) K) z=standardJ n := by rw [he z,hs z hz,add_zero]
  obtain ⟨U,hU,hlim⟩ := compatible_frozen_solution R K hK ho f
  apply c1_potential_yields_frozen_density R H hs f U _ hlim
  intro z
  rw [←he z]
  exact hU z

 theorem frozenPrincipal_isInvertible {n : ℕ} (R : ℝ)
    (K : C1HolderSpace (End n) ((1:ℝ)/3))
    (H : HolderSpace ℂ (End n) ((1:ℝ)/3))
    (hs : ∀ z : ℂ, R<‖z‖ → holderValue ((1:ℝ)/3) H z=0)
    (he : ∀ z, holderValue ((1:ℝ)/3) (c1HolderValue ((1:ℝ)/3) K) z=standardJ n+holderValue ((1:ℝ)/3) H z)
    (hK : ∀ z, Compatible (holderValue ((1:ℝ)/3) (c1HolderValue ((1:ℝ)/3) K) z)) :
    (frozenPrincipal R H hs).IsInvertible := by
  have hinj := frozenPrincipal_injective R H hs (fun z => he z ▸ hK z)
  have hsurj := frozenPrincipal_surjective R K H hs he hK
  exact ⟨ContinuousLinearEquiv.ofBijective (frozenPrincipal R H hs)
    (LinearMap.ker_eq_bot.mpr hinj) (LinearMap.range_eq_top.mpr hsurj),rfl⟩

end HigherDimensionalBallPacking.Rigidity

end

end OAI