import Mathlib
import OAI.Geometry.BallPacking.Continuation.ParameterizedImplicit

namespace OAI

open _root_.OAI.ContinuousLinearMap.FredholmPackage

noncomputable section

namespace HigherDimensionalBallPacking.Rigidity
open scoped ContDiff Topology
open Set Function Filter
variable {E F : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] [CompleteSpace E]
  [NormedAddCommGroup F] [NormedSpace ℝ F]
variable {D : E →L[ℝ] F} (pkg : D.FredholmPackage)

omit [CompleteSpace E] in
lemma fredholm_original_coords [CompleteSpace E] (x : E) :
    (codCoords pkg) (D x) = (pkg.equiv ((domCoords pkg) x).1,0) := by
  have hz : finitePerturbation pkg (0 : pkg.decDom.X₀ →L[ℝ] pkg.decCodom.X₀) = 0 := by
    apply ContinuousLinearMap.ext
    intro v
    simp only [_root_.OAI.ContinuousLinearMap.FredholmPackage.finitePerturbation,
      ContinuousLinearMap.comp_apply,zero_apply,map_zero]
  have hh := finitePerturbation_coords pkg (0 : pkg.decDom.X₀ →L[ℝ] pkg.decCodom.X₀) x
  simpa only [hz,add_zero,zero_apply] using hh

def fredholmNonlinearCoords (f : E → F) (x : E) : pkg.decCodom.X₁ × pkg.decDom.X₀ :=
  (((codCoords pkg) (f x)).1,((domCoords pkg) x).2)

def fredholmCoordEquiv : E ≃L[ℝ] (pkg.decCodom.X₁ × pkg.decDom.X₀) :=
  (domCoords pkg).trans (pkg.equiv.prodCongr (ContinuousLinearEquiv.refl ℝ pkg.decDom.X₀))

omit [CompleteSpace E] in
lemma fredholmNonlinearCoords_contDiff [CompleteSpace E] {f : E → F} (hf : ContDiff ℝ ∞ f) :
    ContDiff ℝ ∞ (fredholmNonlinearCoords pkg f) :=
  ((((codCoords pkg).contDiff.comp hf).fst).prodMk (domCoords pkg).contDiff.snd)

lemma fredholmNonlinearCoords_hasFDerivAt {f : E → F} {a : E} (hf : HasFDerivAt f D a) :
    HasFDerivAt (fredholmNonlinearCoords pkg f) (fredholmCoordEquiv pkg).toContinuousLinearMap a := by
  have h₁ := ((ContinuousLinearMap.fst ℝ pkg.decCodom.X₁ pkg.decCodom.X₀).comp
    (codCoords pkg).toContinuousLinearMap).hasFDerivAt.comp a hf
  have h₂ := ((ContinuousLinearMap.snd ℝ pkg.decDom.X₁ pkg.decDom.X₀).comp
    (domCoords pkg).toContinuousLinearMap).hasFDerivAt (x := a)
  have he : (((ContinuousLinearMap.fst ℝ pkg.decCodom.X₁ pkg.decCodom.X₀).comp
        (codCoords pkg).toContinuousLinearMap).comp D).prod
      ((ContinuousLinearMap.snd ℝ pkg.decDom.X₁ pkg.decDom.X₀).comp
        (domCoords pkg).toContinuousLinearMap) = (fredholmCoordEquiv pkg).toContinuousLinearMap := by
    apply ContinuousLinearMap.ext
    intro x
    apply Prod.ext
    · change ((codCoords pkg) (D x)).1 = pkg.equiv ((domCoords pkg) x).1
      exact congrArg Prod.fst (fredholm_original_coords pkg x)
    · rfl
  exact he ▸ h₁.prodMk h₂

variable {f : E → F} (hf : ContDiff ℝ ∞ f) {a : E} (hD : HasFDerivAt f D a)

def fredholmCoordChart : OpenPartialHomeomorph E (pkg.decCodom.X₁ × pkg.decDom.X₀) :=
  (fredholmNonlinearCoords_contDiff pkg hf).contDiffAt.toOpenPartialHomeomorph
    (fredholmNonlinearCoords pkg f) (fredholmNonlinearCoords_hasFDerivAt pkg hD) (by simp)

lemma fredholmCoordChart_value (x : E) :
    fredholmCoordChart pkg hf hD x = fredholmNonlinearCoords pkg f x := rfl

lemma fredholmCoordChart_base_mem : a ∈ (fredholmCoordChart pkg hf hD).source :=
  ContDiffAt.mem_toOpenPartialHomeomorph_source
    (fredholmNonlinearCoords_contDiff pkg hf).contDiffAt
    (fredholmNonlinearCoords_hasFDerivAt pkg hD) (by simp)

lemma fredholmCoordChart_inverse_smooth :
    ContDiffAt ℝ ∞ (fredholmCoordChart pkg hf hD).symm (fredholmNonlinearCoords pkg f a) :=
  ContDiffAt.to_localInverse (fredholmNonlinearCoords_contDiff pkg hf).contDiffAt
    (fredholmNonlinearCoords_hasFDerivAt pkg hD) (by simp)

def fredholmObstruction (k : pkg.decDom.X₀) : pkg.decCodom.X₀ :=
  ((codCoords pkg) (f ((fredholmCoordChart pkg hf hD).symm (0,k)))).2

def fredholmSolutionParam (k : pkg.decDom.X₀) : E :=
  (fredholmCoordChart pkg hf hD).symm (0,k)

lemma fredholmSolutionParam_base {ha : f a = 0} :
    fredholmSolutionParam pkg hf hD ((domCoords pkg) a).2 = a := by
  have he : fredholmNonlinearCoords pkg f a = (0,((domCoords pkg) a).2) := by
    change (((codCoords pkg) (f a)).1,_) = _
    rw [ha,map_zero]; rfl
  have hx := (fredholmCoordChart pkg hf hD).left_inv (fredholmCoordChart_base_mem pkg hf hD)
  change (fredholmCoordChart pkg hf hD).symm (fredholmNonlinearCoords pkg f a) = a at hx
  unfold fredholmSolutionParam
  rw [←he]
  exact hx

lemma fredholmSolutionParam_smooth {ha : f a = 0} :
    ContDiffAt ℝ ∞ (fredholmSolutionParam pkg hf hD) ((domCoords pkg) a).2 := by
  have he : fredholmNonlinearCoords pkg f a = (0,((domCoords pkg) a).2) := by
    change (((codCoords pkg) (f a)).1,_) = _
    rw [ha,map_zero]; rfl
  have hs := fredholmCoordChart_inverse_smooth pkg hf hD
  rw [he] at hs
  exact hs.comp _ (contDiffAt_const.prodMk contDiffAt_id)

lemma fredholmObstruction_smooth {ha : f a = 0} :
    ContDiffAt ℝ ∞ (fredholmObstruction pkg hf hD) ((domCoords pkg) a).2 := by
  exact (((codCoords pkg).contDiff.contDiffAt.comp _
    (hf.contDiffAt.comp _ (fredholmSolutionParam_smooth pkg hf hD (ha := ha)))).snd)

lemma fredholmParam_zero_iff (k : pkg.decDom.X₀)
    (hk : (0,k) ∈ (fredholmCoordChart pkg hf hD).target) :
    f (fredholmSolutionParam pkg hf hD k) = 0 ↔ fredholmObstruction pkg hf hD k = 0 := by
  have he := (fredholmCoordChart pkg hf hD).right_inv hk
  change fredholmNonlinearCoords pkg f (fredholmSolutionParam pkg hf hD k) = (0,k) at he
  have hfirst := congrArg Prod.fst he
  constructor
  · intro hz
    change ((codCoords pkg) (f (fredholmSolutionParam pkg hf hD k))).2 = 0
    rw [hz,map_zero]; rfl
  · intro hz
    apply (codCoords pkg).injective
    rw [map_zero]
    exact Prod.ext hfirst hz

lemma fredholm_zero_coord_iff (x : E) (hx : x ∈ (fredholmCoordChart pkg hf hD).source) :
    f x = 0 ↔ ((codCoords pkg) (f x)).1 = 0 ∧
      fredholmObstruction pkg hf hD ((domCoords pkg) x).2 = 0 := by
  constructor
  · intro hz
    have h1 : ((codCoords pkg) (f x)).1 = 0 := by rw [hz,map_zero]; rfl
    have he : fredholmSolutionParam pkg hf hD ((domCoords pkg) x).2 = x := by
      have hh := (fredholmCoordChart pkg hf hD).left_inv hx
      change (fredholmCoordChart pkg hf hD).symm (((codCoords pkg) (f x)).1,((domCoords pkg) x).2)=x at hh
      rw [h1] at hh
      exact hh
    refine ⟨h1,?_⟩
    change ((codCoords pkg) (f (fredholmSolutionParam pkg hf hD ((domCoords pkg) x).2))).2 = 0
    rw [he,hz,map_zero]; rfl
  · rintro ⟨h1,h2⟩
    have he : fredholmSolutionParam pkg hf hD ((domCoords pkg) x).2 = x := by
      have hh := (fredholmCoordChart pkg hf hD).left_inv hx
      change (fredholmCoordChart pkg hf hD).symm (((codCoords pkg) (f x)).1,((domCoords pkg) x).2)=x at hh
      rw [h1] at hh
      exact hh
    apply (codCoords pkg).injective
    rw [map_zero]
    apply Prod.ext h1
    change ((codCoords pkg) (f (fredholmSolutionParam pkg hf hD ((domCoords pkg) x).2))).2=0 at h2
    rw [he] at h2
    exact h2

end HigherDimensionalBallPacking.Rigidity

namespace HigherDimensionalBallPacking.Rigidity.HolderCompletion
open scoped ContDiff Topology BoundedContinuousFunction
open Set Filter
section Generic
variable {X Y : Type*} [NormedAddCommGroup X] [NormedSpace ℝ X]
  [NormedAddCommGroup Y] [NormedSpace ℝ Y] {D : X →L[ℝ] Y}
lemma fredholmPackage_balanced (pkg : D.FredholmPackage) (hi : IsIndexZeroFredholm D) :
    Module.finrank ℝ pkg.decDom.X₀ = Module.finrank ℝ pkg.decCodom.X₀ := by
  have h := hi.2
  rw [pkg.ker_eq,pkg.range_eq] at h
  exact h.trans (Submodule.quotientEquivOfIsCompl pkg.decCodom.X₁ pkg.decCodom.X₀
    pkg.decCodom.isTopCompl.isCompl).finrank_eq

lemma fredholmObstruction_smooth_zero [CompleteSpace X] (pkg : D.FredholmPackage)
    {f : X → Y} (hf : ContDiff ℝ ∞ f) (hD : HasFDerivAt f D 0) (hz : f 0 = 0) :
    ContDiffAt ℝ ∞ (fredholmObstruction pkg hf hD) 0 := by
  have hh := fredholmObstruction_smooth pkg hf hD (ha := hz)
  simpa only [map_zero,Prod.snd_zero] using hh
end Generic

variable {n : ℕ}
local instance actRedInst1 : NormedAddCommGroup (End n) := ContinuousLinearMap.toNormedAddCommGroup
local instance actRedInst2 : NormedSpace ℝ (End n) := ContinuousLinearMap.toNormedSpace
local instance actRedInst3 : NormedAddCommGroup (COne ℂ (Phase n)) := inferInstance
local instance actRedInst4 : NormedSpace ℝ (COne ℂ (Phase n)) := inferInstance
local instance actRedInst5 : NormedAddCommGroup (HMap ℂ (Phase n)) := inferInstance
local instance actRedInst6 : NormedSpace ℝ (HMap ℂ (Phase n)) := inferInstance
variable {J : Phase n → End n} (hJ : ContDiff ℝ ∞ J) (hc : ∀ x, Compatible (J x)) {B : ℝ}
  (hstd : ∀ x, B < ‖x‖ → J x=standardJ n) (b : ContDiffBump (0:ℂ)) (p q : Phase n)
local instance actRedInst7 : NormedAddCommGroup (markedModel (E := Phase n) (Metric.closedBall (0:ℂ) b.rOut)) := inferInstance
local instance actRedInst8 : NormedSpace ℝ (markedModel (E := Phase n) (Metric.closedBall (0:ℂ) b.rOut)) := inferInstance
local instance actRedInst9 : AddCommGroup (markedModel (E := Phase n) (Metric.closedBall (0:ℂ) b.rOut)) := (actRedInst7 (n := n) b).toAddCommGroup
local instance actRedInst10 : Module ℝ (markedModel (E := Phase n) (Metric.closedBall (0:ℂ) b.rOut)) := (actRedInst8 (n := n) b).toModule
local instance actRedInst11 : TopologicalSpace (markedModel (E := Phase n) (Metric.closedBall (0:ℂ) b.rOut)) :=
  (actRedInst7 (n := n) b).toPseudoMetricSpace.toUniformSpace.toTopologicalSpace
local instance actRedInst12 : NormedAddCommGroup (supportedHolder (E := Phase n) (Metric.closedBall (0:ℂ) b.rOut)) := inferInstance
local instance actRedInst13 : NormedSpace ℝ (supportedHolder (E := Phase n) (Metric.closedBall (0:ℂ) b.rOut)) := inferInstance
local instance actRedInst14 : AddCommGroup (supportedHolder (E := Phase n) (Metric.closedBall (0:ℂ) b.rOut)) := (actRedInst12 (n := n) b).toAddCommGroup
local instance actRedInst15 : Module ℝ (supportedHolder (E := Phase n) (Metric.closedBall (0:ℂ) b.rOut)) := (actRedInst13 (n := n) b).toModule
variable (u : markedModel (E := Phase n) (Metric.closedBall (0:ℂ) b.rOut))
  (he : ∀ᶠ h in 𝓝 (0 : markedModel (E := Phase n) (Metric.closedBall (0:ℂ) b.rOut)),
    ∀ z : ℂ, b.rIn ≤ ‖z‖ → B < ‖markedCurve p q (u.val+h.val) z‖ ∧
      B < ‖truncatedCurve b p q u.val h.val z‖)

def actualMarkedPackage := Classical.choice
  (actualMarkedChart_derivative_fredholm hJ hc hstd b p q u he).1.nonempty_fredholmPackage

lemma actualMarked_package_balanced :
    Module.finrank ℝ (actualMarkedPackage hJ hc hstd b p q u he).decDom.X₀ =
      Module.finrank ℝ (actualMarkedPackage hJ hc hstd b p q u he).decCodom.X₀ :=
  fredholmPackage_balanced _ (actualMarkedChart_derivative_fredholm hJ hc hstd b p q u he)

def actualMarkedLocalChart := fredholmCoordChart
  (actualMarkedPackage hJ hc hstd b p q u he)
  (actualMarkedChart_contDiff hJ hstd b p q u)
  ((actualMarkedChart_contDiff hJ hstd b p q u).differentiable (by simp) 0).hasFDerivAt

def actualMarkedFiniteObstruction := fredholmObstruction
  (actualMarkedPackage hJ hc hstd b p q u he)
  (actualMarkedChart_contDiff hJ hstd b p q u)
  ((actualMarkedChart_contDiff hJ hstd b p q u).differentiable (by simp) 0).hasFDerivAt

def actualMarkedLocalParam := fredholmSolutionParam
  (actualMarkedPackage hJ hc hstd b p q u he)
  (actualMarkedChart_contDiff hJ hstd b p q u)
  ((actualMarkedChart_contDiff hJ hstd b p q u).differentiable (by simp) 0).hasFDerivAt

lemma actualMarkedLocalChart_base_mem :
    0 ∈ (actualMarkedLocalChart hJ hc hstd b p q u he).source :=
  fredholmCoordChart_base_mem _ _ _

lemma actualMarked_reduced_zero_iff
    (k : (actualMarkedPackage hJ hc hstd b p q u he).decDom.X₀)
    (hk : (0,k) ∈ (actualMarkedLocalChart hJ hc hstd b p q u he).target) :
    actualMarkedChart hJ hstd b p q u (actualMarkedLocalParam hJ hc hstd b p q u he k) = 0 ↔
      actualMarkedFiniteObstruction hJ hc hstd b p q u he k = 0 :=
  fredholmParam_zero_iff _ _ _ k hk

lemma actualMarked_reduced_smooth (hz : actualMarkedChart hJ hstd b p q u 0 = 0) :
    ContDiffAt ℝ ∞ (actualMarkedFiniteObstruction hJ hc hstd b p q u he) 0 :=
  fredholmObstruction_smooth_zero _ _ _ hz

end HigherDimensionalBallPacking.Rigidity.HolderCompletion

namespace HigherDimensionalBallPacking.Rigidity
open scoped ContDiff Topology
open Set Function Filter
open HolderCompletion
section
variable {X Y : Type*} [NormedAddCommGroup X] [NormedSpace ℝ X] [CompleteSpace X]
  [NormedAddCommGroup Y] [NormedSpace ℝ Y] [CompleteSpace Y]

lemma indexZero_finite_stabilizer {D : X →L[ℝ] Y} (hD : IsIndexZeroFredholm D) :
    ∃ E : Submodule ℝ Y,FiniteDimensional ℝ E ∧
      ∃ P : X →L[ℝ] E,(D+E.subtypeL.comp P).IsInvertible := by
  obtain ⟨pkg⟩ := hD.1.nonempty_fredholmPackage
  let : FiniteDimensional ℝ pkg.decDom.X₀ := pkg.decDom.finite_X₀
  let : FiniteDimensional ℝ pkg.decCodom.X₀ := pkg.decCodom.finite_X₀
  let L : pkg.decDom.X₀ ≃L[ℝ] pkg.decCodom.X₀ :=
    ContinuousLinearEquiv.ofFinrankEq (fredholmPackage_balanced pkg hD)
  let P : X →L[ℝ] pkg.decCodom.X₀ := L.toContinuousLinearMap.comp
    (pkg.decDom.X₀.projectionOntoL _ pkg.decDom.isTopCompl.symm)
  have hinj : Injective (D+finitePerturbation pkg L.toContinuousLinearMap) :=
    (finitePerturbation_injective pkg L.toContinuousLinearMap).mpr L.injective
  have hsurj : Surjective (D+finitePerturbation pkg L.toContinuousLinearMap) :=
    (finitePerturbation_surjective pkg L.toContinuousLinearMap).mpr L.surjective
  refine ⟨pkg.decCodom.X₀,inferInstance,P,?_⟩
  let e := ContinuousLinearEquiv.ofBijective (D+finitePerturbation pkg L.toContinuousLinearMap)
    (LinearMap.ker_eq_bot.mpr hinj) (LinearMap.range_eq_top.mpr hsurj)
  exact ⟨e,ContinuousLinearEquiv.coe_ofBijective _ _ _⟩

lemma local_indexZero_supplement {Z : Type*} [TopologicalSpace Z]
    {D : Z → X →L[ℝ] Y} (hD : Continuous D) {z : Z} (hDz : IsIndexZeroFredholm (D z)) :
    ∃ E : Submodule ℝ Y,FiniteDimensional ℝ E ∧
      ∃ V : Set Z,IsOpen V ∧ z∈V ∧ ∀ v∈V,Surjective ((D v).coprod E.subtypeL) := by
  obtain ⟨E,hE,P,hP⟩ := indexZero_finite_stabilizer hDz
  let V := {v : Z | (D v+E.subtypeL.comp P).IsInvertible}
  have hVo : IsOpen V :=
    (ContinuousLinearEquiv.isOpen (𝕜 := ℝ) (E := X) (F := Y)).preimage (hD.add continuous_const)
  refine ⟨E,hE,V,hVo,hP,?_⟩
  intro v hv y
  obtain ⟨x,hx⟩ := hv.surjective y
  exact ⟨(x,P x),hx⟩

theorem compact_indexZero_supplement {Z : Type*} [TopologicalSpace Z]
    {D : Z → X →L[ℝ] Y} (hD : Continuous D) {K : Set Z} (hK : IsCompact K)
    (hDK : ∀ z∈K,IsIndexZeroFredholm (D z)) :
    ∃ E : Submodule ℝ Y,FiniteDimensional ℝ E ∧
      ∃ V : Set Z,IsOpen V ∧ K⊆V ∧ ∀ v∈V,Surjective ((D v).coprod E.subtypeL) := by
  classical
  choose E hE V hVo hVz hVS using fun z : K => local_indexZero_supplement hD (hDK z.val z.property)
  let (z : K) : FiniteDimensional ℝ (E z) := hE z
  obtain ⟨s,hs⟩ := hK.elim_finite_subcover V hVo (by
    intro z hz
    exact mem_iUnion.mpr ⟨⟨z,hz⟩,hVz ⟨z,hz⟩⟩)
  let W := s.sup E
  refine ⟨W,inferInstance,⋃ z∈s,V z,isOpen_biUnion (fun z hz => hVo z),hs,?_⟩
  intro v hv y
  obtain ⟨z,hzs,hvz⟩ := mem_iUnion₂.mp hv
  obtain ⟨⟨x,e⟩,hxe⟩ := hVS z v hvz y
  have hEW : E z≤W := Finset.le_sup hzs
  refine ⟨(x,⟨(e:Y),hEW e.property⟩),?_⟩
  exact hxe

def pathSpatialDerivative (F : ℝ × X → Y) (v : ℝ × X) : X →L[ℝ] Y :=
  (fderiv ℝ F v).comp (ContinuousLinearMap.inr ℝ ℝ X)

omit [CompleteSpace X] [CompleteSpace Y] in
lemma pathSpatialDerivative_eq [CompleteSpace X] [CompleteSpace Y] {F : ℝ × X → Y} (hF : ContDiff ℝ ∞ F) (v : ℝ × X) :
    pathSpatialDerivative F v=fderiv ℝ (fun y => F (v.1,y)) v.2 := by
  have hD := (hF.differentiable (by simp) v).hasFDerivAt
  have hi : HasFDerivAt (fun y : X => (v.1,y)) (ContinuousLinearMap.inr ℝ ℝ X) v.2 :=
    (hasFDerivAt_const _ _).prodMk (hasFDerivAt_id _)
  have hh := hD.comp v.2 hi
  exact hh.fderiv.symm

omit [CompleteSpace X] [CompleteSpace Y] in
lemma pathSpatialDerivative_continuous [CompleteSpace X] [CompleteSpace Y] {F : ℝ × X → Y} (hF : ContDiff ℝ ∞ F) :
    Continuous (pathSpatialDerivative F) :=
  ((hF.fderiv_right (m := ∞) (by simp)).continuous).clm_comp continuous_const

def finiteTargetAugment (F : ℝ × X → Y) (E : Submodule ℝ Y) (v : ℝ × (X × E)) : Y :=
  F (v.1,v.2.1)+(v.2.2:Y)

omit [CompleteSpace X] [CompleteSpace Y] in
lemma finiteTargetAugment_smooth [CompleteSpace X] [CompleteSpace Y] {F : ℝ × X → Y} (hF : ContDiff ℝ ∞ F) (E : Submodule ℝ Y) :
    ContDiff ℝ ∞ (finiteTargetAugment F E) :=
  (hF.comp (contDiff_fst.prodMk contDiff_snd.fst)).add
    (E.subtypeL.contDiff.comp contDiff_snd.snd)

omit [CompleteSpace X] [CompleteSpace Y] in
lemma finiteTargetAugment_spatial_derivative [CompleteSpace X] [CompleteSpace Y] {F : ℝ × X → Y} (hF : ContDiff ℝ ∞ F)
    (E : Submodule ℝ Y) (t : ℝ) (x : X) (e : E) :
    fderiv ℝ (fun v : X × E => finiteTargetAugment F E (t,v)) (x,e)=
      (pathSpatialDerivative F (t,x)).coprod E.subtypeL := by
  have hi : HasFDerivAt (fun v : X × E => (t,v.1))
      ((0 : X × E →L[ℝ] ℝ).prod (ContinuousLinearMap.fst ℝ X E)) (x,e) :=
    (hasFDerivAt_const _ _).prodMk hasFDerivAt_fst
  have hD := ((hF.differentiable (by simp) (t,x)).hasFDerivAt.comp (x,e) hi).add
      (E.subtypeL.hasFDerivAt.comp (x,e) hasFDerivAt_snd)
  change fderiv ℝ ((F ∘ fun v : X × E => (t,v.1)) + E.subtypeL ∘ Prod.snd) (x,e)=_
  rw [hD.fderiv]
  apply ContinuousLinearMap.ext
  intro v
  rfl

theorem ProperIndexZeroPath.finite_target_supplement {F : ℝ × X → Y} {U : Set X}
    (h : ProperIndexZeroPath F U) :
    ∃ E : Submodule ℝ Y,FiniteDimensional ℝ E ∧
      ∃ V : Set (ℝ × X),IsOpen V ∧
        {v : ℝ × X | v.1∈Icc (0:ℝ) 1 ∧ v.2∈U ∧ F v=0}⊆V ∧
        ∀ t x,(t,x)∈V → ∀ e : E,
          Surjective (fderiv ℝ (fun v : X × E => finiteTargetAugment F E (t,v)) (x,e)) := by
  obtain ⟨E,hE,V,hVo,hZ,hV⟩ := compact_indexZero_supplement
    (pathSpatialDerivative_continuous h.smooth) h.zeroSet_compact (by
      intro v hv
      rw [pathSpatialDerivative_eq h.smooth]
      exact h.fredholm v.1 hv.1 v.2 hv.2.1)
  refine ⟨E,hE,V,hVo,hZ,?_⟩
  intro t x hv e
  rw [finiteTargetAugment_spatial_derivative h.smooth]
  exact hV (t,x) hv

variable {D : X →L[ℝ] Y} (pkg : D.FredholmPackage)
local instance pfrK : FiniteDimensional ℝ pkg.decDom.X₀ := pkg.decDom.finite_X₀
local instance pfrC : FiniteDimensional ℝ pkg.decCodom.X₀ := pkg.decCodom.finite_X₀
local instance pfrX : CompleteSpace pkg.decDom.X₁ := pkg.decDom.isTopCompl.isClosed.completeSpace_coe
local instance pfrY : CompleteSpace pkg.decCodom.X₁ := pkg.decCodom.isTopCompl.isClosed.completeSpace_coe

def parametricEssential (F : ℝ × X → Y) (v : (ℝ × pkg.decDom.X₀) × pkg.decDom.X₁) : pkg.decCodom.X₁ :=
  ((codCoords pkg) (F (v.1.1,(domCoords pkg).symm (v.2,v.1.2)))).1

def parametricBase (t : ℝ) (x : X) : (ℝ × pkg.decDom.X₀) × pkg.decDom.X₁ :=
  ((t,((domCoords pkg) x).2),((domCoords pkg) x).1)

omit [CompleteSpace X] [CompleteSpace Y] in
lemma parametricEssential_smooth [CompleteSpace X] [CompleteSpace Y] {F : ℝ × X → Y} (hF : ContDiff ℝ ∞ F) :
    ContDiff ℝ ∞ (parametricEssential pkg F) :=
  ((codCoords pkg).contDiff.comp (hF.comp (contDiff_fst.fst.prodMk
    ((domCoords pkg).symm.contDiff.comp (contDiff_snd.prodMk contDiff_fst.snd))))).fst

variable {F : ℝ × X → Y} (hF : ContDiff ℝ ∞ F) {t : ℝ} {x : X}
  (hD : HasFDerivAt (fun y => F (t,y)) D x)

include hD in
omit [CompleteSpace Y] in
lemma parametricEssential_vertical_derivative [CompleteSpace Y] :
    HasFDerivAt (fun y : pkg.decDom.X₁ => parametricEssential pkg F ((t,((domCoords pkg) x).2),y))
      pkg.equiv.toContinuousLinearMap ((domCoords pkg) x).1 := by
  have hi : HasFDerivAt (fun y : pkg.decDom.X₁ => (domCoords pkg).symm (y,((domCoords pkg) x).2))
      ((domCoords pkg).symm.toContinuousLinearMap.comp (ContinuousLinearMap.inl ℝ pkg.decDom.X₁ pkg.decDom.X₀))
      ((domCoords pkg) x).1 :=
    (domCoords pkg).symm.hasFDerivAt.comp _ (hasFDerivAt_id _ |>.prodMk (hasFDerivAt_const _ _))
  have hx : (domCoords pkg).symm (((domCoords pkg) x).1,((domCoords pkg) x).2)=x :=
    (domCoords pkg).symm_apply_apply x
  have hD' : HasFDerivAt (fun y => F (t,y)) D
      ((domCoords pkg).symm (((domCoords pkg) x).1,((domCoords pkg) x).2)) := hx.symm ▸ hD
  have hd := hD'.comp (((domCoords pkg) x).1) hi
  have ho := ((codCoords pkg).hasFDerivAt.comp _ hd).fst
  have he : (ContinuousLinearMap.fst ℝ pkg.decCodom.X₁ pkg.decCodom.X₀).comp
      ((codCoords pkg).toContinuousLinearMap.comp (D.comp
        ((domCoords pkg).symm.toContinuousLinearMap.comp (ContinuousLinearMap.inl ℝ pkg.decDom.X₁ pkg.decDom.X₀))))=
        pkg.equiv.toContinuousLinearMap := by
    apply ContinuousLinearMap.ext
    intro y
    change ((codCoords pkg) (D ((domCoords pkg).symm (y,0)))).1=pkg.equiv y
    rw [fredholm_original_coords,(domCoords pkg).apply_symm_apply]
  exact he ▸ ho

include hF hD in
lemma parametricEssential_invertible :
    ((fderiv ℝ (parametricEssential pkg F) (parametricBase pkg t x)).comp
      (ContinuousLinearMap.inr ℝ (ℝ × pkg.decDom.X₀) pkg.decDom.X₁)).IsInvertible := by
  have hd := ((parametricEssential_smooth pkg hF).differentiable (by simp) (parametricBase pkg t x)).hasFDerivAt
  have hi : HasFDerivAt (fun y : pkg.decDom.X₁ => ((t,((domCoords pkg) x).2),y))
      (ContinuousLinearMap.inr ℝ (ℝ × pkg.decDom.X₀) pkg.decDom.X₁) ((domCoords pkg) x).1 :=
    (hasFDerivAt_const _ _).prodMk (hasFDerivAt_id _)
  have hh := hd.comp (((domCoords pkg) x).1) hi
  have he := hh.unique (parametricEssential_vertical_derivative pkg hD)
  rw [he]
  exact ⟨pkg.equiv,rfl⟩

def parametricInfiniteSolution : ℝ × pkg.decDom.X₀ → pkg.decDom.X₁ :=
  (parametricEssential_smooth pkg hF).contDiffAt.implicitFunction (by simp)
    (parametricEssential_invertible pkg hF hD)

def parametricSolution (v : ℝ × pkg.decDom.X₀) : X :=
  (domCoords pkg).symm (parametricInfiniteSolution pkg hF hD v,v.2)

def parametricObstruction (v : ℝ × pkg.decDom.X₀) : pkg.decCodom.X₀ :=
  ((codCoords pkg) (F (v.1,parametricSolution pkg hF hD v))).2

lemma parametricInfiniteSolution_base :
    parametricInfiniteSolution pkg hF hD (t,((domCoords pkg) x).2)=((domCoords pkg) x).1 :=
  (parametricEssential_smooth pkg hF).contDiffAt.implicitFunction_apply_self (by simp)
    (parametricEssential_invertible pkg hF hD)

lemma parametricSolution_base : parametricSolution pkg hF hD (t,((domCoords pkg) x).2)=x := by
  rw [parametricSolution,parametricInfiniteSolution_base]
  exact (domCoords pkg).symm_apply_apply x

lemma parametricSolution_smooth :
    ContDiffAt ℝ ∞ (parametricSolution pkg hF hD) (t,((domCoords pkg) x).2) :=
  (domCoords pkg).symm.contDiff.contDiffAt.comp _
    (((parametricEssential_smooth pkg hF).contDiffAt.contDiffAt_implicitFunction (by simp)
      (parametricEssential_invertible pkg hF hD)).prodMk contDiffAt_snd)

lemma parametricObstruction_smooth :
    ContDiffAt ℝ ∞ (parametricObstruction pkg hF hD) (t,((domCoords pkg) x).2) :=
  ((codCoords pkg).contDiff.contDiffAt.comp _ (hF.contDiffAt.comp _
    (contDiffAt_fst.prodMk (parametricSolution_smooth pkg hF hD)))).snd

include hD in
lemma parametricSolution_zero_iff (hz : F (t,x)=0) :
    ∀ᶠ v in 𝓝 (t,((domCoords pkg) x).2),
      F (v.1,parametricSolution pkg hF hD v)=0 ↔ parametricObstruction pkg hF hD v=0 := by
  have hh := (parametricEssential_smooth pkg hF).contDiffAt.eventually_apply_implicitFunction
    (by simp) (parametricEssential_invertible pkg hF hD)
  have hb : parametricEssential pkg F (parametricBase pkg t x)=0 := by
    change ((codCoords pkg) (F (t,(domCoords pkg).symm (((domCoords pkg) x).1,((domCoords pkg) x).2)))).1=0
    rw [(domCoords pkg).symm_apply_apply,hz,map_zero]; rfl
  filter_upwards [hh] with v hv
  have hfirst : ((codCoords pkg) (F (v.1,parametricSolution pkg hF hD v))).1=0 := hv.trans hb
  constructor
  · intro he
    change ((codCoords pkg) (F (v.1,parametricSolution pkg hF hD v))).2=0
    rw [he,map_zero]; rfl
  · intro he
    apply (codCoords pkg).injective
    rw [map_zero]
    exact Prod.ext hfirst he

include hD in
lemma parametric_zero_is_solution (hz : F (t,x)=0) :
    ∀ᶠ v in 𝓝 (t,x),F v=0 →
      parametricSolution pkg hF hD (v.1,((domCoords pkg) v.2).2)=v.2 := by
  have hh := (parametricEssential_smooth pkg hF).contDiffAt.eventually_apply_eq_iff_implicitFunction
    (by simp) (parametricEssential_invertible pkg hF hD)
  have hm : Continuous (fun v : ℝ × X => parametricBase pkg v.1 v.2) := by
    exact (continuous_fst.prodMk ((domCoords pkg).continuous.comp continuous_snd).snd).prodMk
      ((domCoords pkg).continuous.comp continuous_snd).fst
  have hb : parametricEssential pkg F (parametricBase pkg t x)=0 := by
    change ((codCoords pkg) (F (t,(domCoords pkg).symm (((domCoords pkg) x).1,((domCoords pkg) x).2)))).1=0
    rw [(domCoords pkg).symm_apply_apply,hz,map_zero]; rfl
  filter_upwards [(hm.tendsto (t,x)).eventually hh] with v hv hv0
  have he : parametricEssential pkg F (parametricBase pkg v.1 v.2)=0 := by
    change ((codCoords pkg) (F (v.1,(domCoords pkg).symm (((domCoords pkg) v.2).1,((domCoords pkg) v.2).2)))).1=0
    rw [(domCoords pkg).symm_apply_apply,hv0,map_zero]; rfl
  have hu := hv.mp (he.trans hb.symm)
  change parametricInfiniteSolution pkg hF hD (v.1,((domCoords pkg) v.2).2)=((domCoords pkg) v.2).1 at hu
  rw [parametricSolution,hu]
  exact (domCoords pkg).symm_apply_apply v.2

end
variable {X Y : Type*} [NormedAddCommGroup X] [NormedSpace ℝ X] [CompleteSpace X]
  [NormedAddCommGroup Y] [NormedSpace ℝ Y] [CompleteSpace Y]
variable {D : X →L[ℝ] Y} (hD : D.IsFredholm)
  (E : Submodule ℝ Y) [FiniteDimensional ℝ E]

include hD in
omit [CompleteSpace Y] in
lemma finite_ker_augment [CompleteSpace Y] : FiniteDimensional ℝ (D.coprod E.subtypeL).ker := by
  obtain ⟨pkg⟩ := hD.nonempty_fredholmPackage
  let : FiniteDimensional ℝ pkg.decDom.X₀ := pkg.decDom.finite_X₀
  let G := D.coprod E.subtypeL
  let A : X × E →L[ℝ] pkg.decDom.X₀ × E :=
    ((ContinuousLinearMap.snd ℝ pkg.decDom.X₁ pkg.decDom.X₀).comp
      ((domCoords pkg).toContinuousLinearMap.comp (ContinuousLinearMap.fst ℝ X E))).prod
        (ContinuousLinearMap.snd ℝ X E)
  let AK := A.comp G.ker.subtypeL
  have hAK : Injective AK := by
    intro v w he
    change (((domCoords pkg) v.val.1).2,v.val.2)=(((domCoords pkg) w.val.1).2,w.val.2) at he
    have hk : ((domCoords pkg) v.val.1).2=((domCoords pkg) w.val.1).2 := congrArg (Prod.fst : pkg.decDom.X₀ × E → pkg.decDom.X₀) he
    have hee : v.val.2=w.val.2 := congrArg (Prod.snd : pkg.decDom.X₀ × E → E) he
    have hv : D v.val.1+(v.val.2:Y)=0 := v.property
    have hw : D w.val.1+(w.val.2:Y)=0 := w.property
    have hxx : D v.val.1=D w.val.1 := add_right_cancel (hv.trans hw.symm |>.trans (by rw [hee]))
    have hc := congrArg (fun y => ((codCoords pkg) y).1) hxx
    simp only [fredholm_original_coords] at hc
    have hx1 := pkg.equiv.injective hc
    apply Subtype.ext
    exact Prod.ext ((domCoords pkg).injective (Prod.ext hx1 hk)) hee
  exact FiniteDimensional.of_injective AK.toLinearMap hAK

include hD in
lemma augment_fredholm (hG : Surjective (D.coprod E.subtypeL)) :
    (D.coprod E.subtypeL).IsFredholm := by
  let G := D.coprod E.subtypeL
  let : FiniteDimensional ℝ G.ker := finite_ker_augment hD E
  have htop : G.range=⊤ := LinearMap.range_eq_top.mpr hG
  refine ⟨(G.isOpenMap hG).isStrictMap G.continuous,?_,inferInstance,?_,?_⟩
  · rw [htop]
    exact isClosed_univ
  · rw [htop]
    infer_instance
  · exact Submodule.ClosedComplemented.of_finiteDimensional _

end HigherDimensionalBallPacking.Rigidity
end

end OAI