import Mathlib
import OAI.Geometry.BallPacking.Compactness.AffineCorrectionInfinity
import OAI.Geometry.BallPacking.Fredholm.PointwiseMarkedCR

namespace OAI

noncomputable section
namespace HigherDimensionalBallPacking.Rigidity

section
open scoped ContDiff Topology BoundedContinuousFunction
open Set Function Filter
namespace HolderCompletion
variable {n : ℕ}
local instance afInst1 : NormedAddCommGroup (End n) := ContinuousLinearMap.toNormedAddCommGroup
local instance afInst2 : NormedSpace ℝ (End n) := ContinuousLinearMap.toNormedSpace
local instance afInst3 : NormedAddCommGroup (COne ℂ (Phase n)) := inferInstance
local instance afInst4 : NormedSpace ℝ (COne ℂ (Phase n)) := inferInstance
local instance afInst5 : NormedAddCommGroup (HMap ℂ (Phase n)) := inferInstance
local instance afInst6 : 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) (p q : Phase n) (u : COne ℂ (Phase n))
  {K : Set ℂ} (hK : IsCompact K) (he : ∀ z ∉ K, B < ‖markedCurve p q u z‖)
local instance afInst7 : NormedAddCommGroup (freeModel (E := Phase n) K) := inferInstance
local instance afInst8 : NormedSpace ℝ (freeModel (E := Phase n) K) := inferInstance
local instance afInst9 : AddCommGroup (freeModel (E := Phase n) K) := (afInst7 (n := n) (K := K)).toAddCommGroup
local instance afInst10 : Module ℝ (freeModel (E := Phase n) K) := (afInst8 (n := n) (K := K)).toModule
local instance afInst11 : NormedAddCommGroup (markedModel (E := Phase n) K) := inferInstance
local instance afInst12 : NormedSpace ℝ (markedModel (E := Phase n) K) := inferInstance
local instance afInst13 : AddCommGroup (markedModel (E := Phase n) K) := (afInst11 (n := n) (K := K)).toAddCommGroup
local instance afInst14 : Module ℝ (markedModel (E := Phase n) K) := (afInst12 (n := n) (K := K)).toModule
local instance afInst15 : NormedAddCommGroup (supportedHolder (E := Phase n) K) := inferInstance
local instance afInst16 : NormedSpace ℝ (supportedHolder (E := Phase n) K) := inferInstance
local instance afInst17 : AddCommGroup (supportedHolder (E := Phase n) K) := (afInst15 (n := n) (K := K)).toAddCommGroup
local instance afInst18 : Module ℝ (supportedHolder (E := Phase n) K) := (afInst16 (n := n) (K := K)).toModule

def completedFreePrincipal : freeModel (E := Phase n) K →L[ℝ] supportedHolder (E := Phase n) K :=
  freePrincipal (jetValueCLM _ (completedStructureJet hJ hstd p q u))
    (fun z hz => hstd _ (he z hz))

def completedFreeLinearized : freeModel (E := Phase n) K →L[ℝ] supportedHolder (E := Phase n) K :=
  freeLinearized (jetValueCLM _ (completedStructureJet hJ hstd p q u)) (completedQ hJ hstd p q u)
    (fun z hz => hstd _ (he z hz)) (completedQ_zero_outside hJ hstd p q u he)

include hc hK in
lemma completedFreePrincipal_fredholm : (completedFreePrincipal hJ hstd p q u he).IsFredholm := by
  have hP := (completedPrincipal_add_compact_fredholm hJ hc hstd p q u hK he 0 isCompactOperator_zero).1
  have hP' : (completedPrincipal hJ hstd p q u he).IsFredholm := by
    simpa only [add_zero] using hP
  exact freePrincipal_fredholm (E := Phase n) (K := K) (jetValueCLM _ (completedStructureJet hJ hstd p q u))
    (fun z hz => hstd _ (he z hz)) hP'

include hc hK in
lemma completedFreeLinearized_fredholm : (completedFreeLinearized hJ hstd p q u he).IsFredholm := by
  have hP := (completedPrincipal_add_compact_fredholm hJ hc hstd p q u hK he
    (-completedZeroOrder hJ hstd p q u he) (completedZeroOrder_compact hJ hstd p q u hK he).neg).1
  have hP' : (completedPrincipal hJ hstd p q u he-completedZeroOrder hJ hstd p q u he).IsFredholm := by
    simpa only [sub_eq_add_neg] using hP
  exact freeLinearized_fredholm (E := Phase n) (K := K) (jetValueCLM _ (completedStructureJet hJ hstd p q u))
    (completedQ hJ hstd p q u) (fun z hz => hstd _ (he z hz))
    (completedQ_zero_outside hJ hstd p q u he) hP'

lemma completedFreeLinearized_value (v : freeModel (E := Phase n) K) (z : ℂ) :
    valueCLM _ (completedFreeLinearized hJ hstd p q u he v).val z =
      cDeriv v.val z Complex.I-J (markedCurve p q u z) (cDeriv v.val z 1)-
      fderiv ℝ J (markedCurve p q u z) (cValue v.val z) (fderiv ℝ (markedCurve p q u) z 1) := by
  have hp := freePrincipal_value (E := Phase n) (K := K) (jetValueCLM _ (completedStructureJet hJ hstd p q u))
    (fun z hz => hstd _ (he z hz)) v z
  have hq := freeZeroOrder_value (E := Phase n) (K := K) (completedQ hJ hstd p q u)
    (completedQ_zero_outside hJ hstd p q u he) v z
  have hq' := hq.trans (completedQ_value hJ hstd p q u z (cValue v.val z))
  exact congrArg₂ (fun x y : Phase n => x-y) hp hq'

include hJ hstd in
theorem actualStructureBound : BoundedCThree J :=
  boundedCThree_of_compactPerturbation hJ (standardJ n) (compactPerturbation_of_outside_constant _ hstd)

variable (b : ContDiffBump (0:ℂ))
local instance afInst19 : NormedAddCommGroup (freeModel (E := Phase n) (Metric.closedBall (0:ℂ) b.rOut)) := inferInstance
local instance afInst20 : NormedSpace ℝ (freeModel (E := Phase n) (Metric.closedBall (0:ℂ) b.rOut)) := inferInstance
local instance afInst21 : AddCommGroup (freeModel (E := Phase n) (Metric.closedBall (0:ℂ) b.rOut)) := (afInst19 (n := n) b).toAddCommGroup
local instance afInst22 : Module ℝ (freeModel (E := Phase n) (Metric.closedBall (0:ℂ) b.rOut)) := (afInst20 (n := n) b).toModule
local instance afInst23 : TopologicalSpace (freeModel (E := Phase n) (Metric.closedBall (0:ℂ) b.rOut)) := (afInst19 (n := n) b).toPseudoMetricSpace.toUniformSpace.toTopologicalSpace
local instance afInst24 : ContinuousSMul ℝ
    (freeModel (E := Phase n) (Metric.closedBall (0:ℂ) b.rOut)) :=
  IsBoundedSMul.continuousSMul
variable (w : freeModel (E := Phase n) (Metric.closedBall (0:ℂ) b.rOut))
  (hesc : ∀ᶠ v in 𝓝 (0 : freeModel (E := Phase n) (Metric.closedBall (0:ℂ) b.rOut)),
    ∀ z, b.rIn ≤ ‖z‖ → B < ‖affineCurve p (complexSlope (markedSlope p q w.val)) (w.val+v.val) z‖)

def actualFreeChart := freeChart (actualStructureBound hJ hstd) b p (markedSlope p q w.val) w

lemma actualFreeChart_contDiff : ContDiff ℝ ∞ (actualFreeChart hJ hstd p q b w) :=
  freeChart_contDiff (actualStructureBound hJ hstd) b p (markedSlope p q w.val) w
    (compactPerturbation_of_outside_constant _ hstd)

include hesc in
lemma free_escape_base : ∀ z ∉ Metric.closedBall (0:ℂ) b.rOut, B < ‖markedCurve p q w.val z‖ := by
  intro z hz
  have hz' : b.rIn ≤ ‖z‖ := by
    have ht : b.rOut < ‖z‖ := by simpa only [Metric.mem_closedBall,dist_zero_right,not_le] using hz
    exact (b.rIn_lt_rOut.trans ht).le
  have hh := hesc.self_of_nhds z hz'
  simpa only [Submodule.coe_zero,add_zero,affineCurve,affine,complexSlope_apply,markedCurve] using hh

include hesc in
lemma actualFreeChart_crSection_fderiv_eval (z : ℂ) :
    (supportedEval (E := Phase n) (K := Metric.closedBall (0:ℂ) b.rOut) z).comp
      (fderiv ℝ (actualFreeChart hJ hstd p q b w) 0) =
    (((BoundedContinuousFunction.evalCLM ℝ z).comp (valueCLM _)).comp
      ((crSectionDeriv (actualStructureBound hJ hstd) p (complexSlope (markedSlope p q w.val)) w.val).comp
        (freeModel (E := Phase n) (Metric.closedBall (0:ℂ) b.rOut)).subtypeL)) := by
  have hd := ((actualFreeChart_contDiff hJ hstd p q b w).differentiable (by simp) 0).hasFDerivAt
  have hdE := (supportedEval (E := Phase n) (K := Metric.closedBall (0:ℂ) b.rOut) z).hasFDerivAt.comp 0 hd
  have hdP := freeChart_hasFDerivAt_eval (actualStructureBound hJ hstd) b p (markedSlope p q w.val) w hstd hesc z
  exact hdE.unique hdP

lemma completedFreeLinearized_crSection (z : ℂ) :
    (((BoundedContinuousFunction.evalCLM ℝ z).comp (valueCLM _)).comp
      ((crSectionDeriv (actualStructureBound hJ hstd) p (complexSlope (markedSlope p q w.val)) w.val).comp
        (freeModel (E := Phase n) (Metric.closedBall (0:ℂ) b.rOut)).subtypeL)) =
    (supportedEval (E := Phase n) (K := Metric.closedBall (0:ℂ) b.rOut) z).comp
      (completedFreeLinearized hJ hstd p q w.val (free_escape_base p q b w hesc)) := by
  apply ContinuousLinearMap.ext
  intro v
  have hval := crSectionDeriv_value (actualStructureBound hJ hstd) p (complexSlope (markedSlope p q w.val)) w.val v.val z
  have hh := congrArg (fun d : ℂ →L[ℝ] Phase n =>
    d Complex.I-J (markedCurve p q w.val z) (d 1)-
      fderiv ℝ J (markedCurve p q w.val z) (cValue v.val z) (fderiv ℝ (markedCurve p q w.val) z 1))
    (c_fderiv v.val z)
  exact hval.trans (hh.trans (completedFreeLinearized_value hJ hstd p q w.val (free_escape_base p q b w hesc) v z).symm)

lemma actualFreeChart_fderiv_eval (z : ℂ) :
    (supportedEval (E := Phase n) (K := Metric.closedBall (0:ℂ) b.rOut) z).comp
      (fderiv ℝ (actualFreeChart hJ hstd p q b w) 0) =
    (supportedEval (E := Phase n) (K := Metric.closedBall (0:ℂ) b.rOut) z).comp
      (completedFreeLinearized hJ hstd p q w.val (free_escape_base p q b w hesc)) :=
  (actualFreeChart_crSection_fderiv_eval hJ hstd p q b w hesc z).trans
    (completedFreeLinearized_crSection hJ hstd p q b w hesc z)

lemma actualFreeChart_fderiv_eq : fderiv ℝ (actualFreeChart hJ hstd p q b w) 0 =
    completedFreeLinearized hJ hstd p q w.val (free_escape_base p q b w hesc) := by
  apply ContinuousLinearMap.ext
  intro v
  apply Subtype.ext
  apply value_ext
  intro z
  exact congrArg (fun L : freeModel (E := Phase n) (Metric.closedBall (0:ℂ) b.rOut) →L[ℝ] Phase n => L v)
    (actualFreeChart_fderiv_eval hJ hstd p q b w hesc z)

include hc hesc in
lemma actualFreeChart_fderiv_fredholm : (fderiv ℝ (actualFreeChart hJ hstd p q b w) 0).IsFredholm := by
  rw [actualFreeChart_fderiv_eq hJ hstd p q b w hesc]
  exact completedFreeLinearized_fredholm hJ hc hstd p q w.val (isCompact_closedBall (0:ℂ) b.rOut)
    (free_escape_base p q b w hesc)

end HolderCompletion

end
section
open scoped Topology BoundedContinuousFunction ContDiff
open Set Function Filter MeasureTheory
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
 theorem compact_test_translation_smooth {g : ℂ → ℝ} (hg : ContDiff ℝ ∞ g)
    (hgc : HasCompactSupport g) {v : ℂ → E} (hv : LocallyIntegrable v) :
    ContDiff ℝ ∞ (fun t : ℂ => ∫ z : ℂ, g z • v (z+t)) := by
  let L : ℝ →L[ℝ] E →L[ℝ] E := ContinuousLinearMap.lsmul ℝ ℝ
  have hs : ContDiff ℝ ∞ (fun z : ℂ => g (-z)) := hg.comp contDiff_neg
  have hc : HasCompactSupport (fun z : ℂ => g (-z)) := hgc.comp_homeomorph (Homeomorph.neg ℂ)
  have hh := hc.contDiff_convolution_left (𝕜 := ℝ) (μ := (volume : Measure ℂ)) L hs hv
  convert hh using 1
  funext t
  rw [convolution_def,←integral_neg_eq_self]
  congr 1
  funext z
  change g (-z) • v (-z+t)=g (-z) • v (t-z)
  rw [neg_add_eq_sub]


end
section
open Set Function
variable {E F I : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
  [FiniteDimensional ℝ E] [NormedAddCommGroup F] [NormedSpace ℝ F]

 theorem finite_separating_family (L : I → E →L[ℝ] F)
    (hL : ∀ v : E, (∀ i, L i v=0) → v=0) :
    ∃ s : Finset I, ∀ v : E, (∀ i ∈ s, L i v=0) → v=0 := by
  classical
  let U : I → Set E := fun i => {v | L i v≠0}
  have hU : ∀ i, IsOpen (U i) := fun i =>
    (isClosed_singleton.preimage (L i).continuous).isOpen_compl
  have hcov : Metric.sphere (0:E) 1 ⊆ ⋃ i, U i := by
    intro v hv
    by_contra hn
    have hz : ∀ i, L i v=0 := by
      intro i
      by_contra hi
      exact hn (mem_iUnion.mpr ⟨i,hi⟩)
    have hv0 := hL v hz
    simp [hv0] at hv
  obtain ⟨s,hs⟩ := (isCompact_sphere (0:E) 1).elim_finite_subcover U hU hcov
  refine ⟨s,fun v hv => ?_⟩
  by_contra hne
  have hn : ‖v‖≠0 := norm_ne_zero_iff.mpr hne
  have hw : ‖v‖⁻¹ • v ∈ Metric.sphere (0:E) 1 := by
    rw [Metric.mem_sphere,dist_zero_right,norm_smul,Real.norm_of_nonneg (inv_nonneg.mpr (norm_nonneg v)),inv_mul_cancel₀ hn]
  obtain ⟨i,hi⟩ := mem_iUnion.mp (hs hw)
  obtain ⟨his,hh⟩ := mem_iUnion.mp hi
  have hzi : L i (‖v‖⁻¹ • v)=0 := by rw [map_smul,hv i his,smul_zero]
  exact hh hzi


end
section
open Set Function
variable {E F D : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
  [NormedAddCommGroup F] [NormedSpace ℝ F]
  [NormedAddCommGroup D] [NormedSpace ℝ D] [FiniteDimensional ℝ D]

 theorem fredholm_stabilized_leftInverse (P : E →L[ℝ] F) (hP : P.IsFredholm)
    (Q : E →L[ℝ] D) (hQ : Injective (Q.comp P.ker.subtypeL)) :
    (P.prod Q).HasLeftInverse := by
  obtain ⟨pkg⟩ := hP.nonempty_fredholmPackage
  let S : F →L[ℝ] E := pkg.quasiInverse
  have hPSP (v : E) : P (S (P v))=P v := by
    rw [pkg.eq_equiv]
    simp [S,ContinuousLinearMap.FredholmPackage.quasiInverse,Submodule.projectionOnto_projection]
  let QK : P.ker →L[ℝ] D := Q.comp P.ker.subtypeL
  obtain ⟨U,hU⟩ := ContinuousLinearMap.HasLeftInverse.of_injective_of_finiteDimensional hQ
  let T : F × D →L[ℝ] E := S.comp (ContinuousLinearMap.fst ℝ F D)
  let L : F × D →L[ℝ] E := T + P.ker.subtypeL.comp
    (U.comp (ContinuousLinearMap.snd ℝ F D-Q.comp T))
  refine ⟨L,fun v => ?_⟩
  have hr : v-S (P v)∈P.ker := by
    change P (v-S (P v))=0
    rw [map_sub,hPSP,sub_self]
  have hu := congrArg (fun z : P.ker => (z:E)) (hU ⟨v-S (P v),hr⟩)
  change (U (Q (v-S (P v))) : E)=v-S (P v) at hu
  change S (P v)+(U (Q v-Q (S (P v))) : E)=v
  rw [←map_sub,hu]
  abel


end
section
open scoped Topology BoundedContinuousFunction ContDiff
open Set Function Filter MeasureTheory
namespace HolderCompletion
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] [CompleteSpace E]

abbrev PlaneTest := {g : ℂ → ℝ // ContDiff ℝ ∞ g ∧ HasCompactSupport g}

omit [CompleteSpace E] in
lemma planeTest_integrable [CompleteSpace E] (g : PlaneTest) (v : ℂ →ᵇ E) :
    Integrable (fun z => g.val z • v z) :=
  v.continuous.locallyIntegrable.integrable_smul_left_of_hasCompactSupport
    g.property.1.continuous g.property.2

lemma planeTest_norm_bound (g : PlaneTest) (v : ℂ →ᵇ E) :
    ‖∫ z, g.val z • v z‖ ≤ (∫ z, ‖g.val z‖)*‖v‖ := by
  have hi : Integrable g.val := g.property.1.continuous.integrable_of_hasCompactSupport g.property.2
  calc
    _ ≤ ∫ z, ‖g.val z • v z‖ := norm_integral_le_integral_norm _
    _ ≤ ∫ z, ‖g.val z‖*‖v‖ := by
      apply integral_mono (planeTest_integrable g v).norm (hi.norm.mul_const _)
      intro z
      change ‖g.val z • v z‖ ≤ ‖g.val z‖*‖v‖
      rw [norm_smul]
      exact mul_le_mul_of_nonneg_left (BoundedContinuousFunction.norm_coe_le_norm v z) (norm_nonneg _)
    _ = _ := integral_mul_const _ _

def planeTestCLM (g : PlaneTest) : (ℂ →ᵇ E) →L[ℝ] E :=
  LinearMap.mkContinuous
    { toFun := fun v => ∫ z, g.val z • v z
      map_add' := fun u v => by
        simp only [BoundedContinuousFunction.add_apply,smul_add]
        exact integral_add (planeTest_integrable g u) (planeTest_integrable g v)
      map_smul' := fun c v => by
        simp only [BoundedContinuousFunction.smul_apply]
        simp_rw [smul_comm (g.val _) c]
        exact integral_smul c _ }
    (∫ z, ‖g.val z‖) (planeTest_norm_bound g)

lemma planeTest_separates (v : ℂ →ᵇ E) (hv : ∀ g : PlaneTest, planeTestCLM g v=0) : v=0 := by
  have hz := isOpen_univ.ae_eq_zero_of_integral_contDiff_smul_eq_zero
    (μ := (volume : Measure ℂ))
    (v.continuous.locallyIntegrable.locallyIntegrableOn univ)
    (fun g hg hgc _ => hv ⟨g,hg,hgc⟩)
  have he : EqOn v (fun _ => 0) univ :=
    Measure.eqOn_open_of_ae_eq ((ae_restrict_iff' MeasurableSet.univ).mpr hz)
      isOpen_univ v.continuous.continuousOn continuousOn_const
  ext z
  exact he (mem_univ z)

local instance testInst1 : NormedAddCommGroup (COne ℂ E) := inferInstance
local instance testInst2 : NormedSpace ℝ (COne ℂ E) := inferInstance

def jetTestCLM (g : PlaneTest) : COne ℂ E →L[ℝ] E :=
  (planeTestCLM g).comp ((valueCLM _).comp (jetValueCLM _))

@[simp] lemma jetTest_value (g : PlaneTest) (u : COne ℂ E) :
    jetTestCLM g u = ∫ z, g.val z • cValue u z := rfl

lemma jetTest_separates (u : COne ℂ E) (hu : ∀ g : PlaneTest, jetTestCLM g u=0) : u=0 := by
  have hv : cValue u = 0 := planeTest_separates _ hu
  apply cValue_ext
  intro z
  exact congrArg (fun v : ℂ →ᵇ E => v z) hv

lemma jetTest_translation_smooth (g : PlaneTest) (u : COne ℂ E) :
    ContDiff ℝ ∞ (fun t => jetTestCLM g (jetTranslate t u)) := by
  simp only [jetTest_value,jetTranslate_value]
  exact compact_test_translation_smooth g.property.1 g.property.2 (cValue u).continuous.locallyIntegrable

lemma jetTest_translation_difference_smooth (g : PlaneTest) (u : COne ℂ E) :
    ContDiff ℝ ∞ (fun t => jetTestCLM g (jetTranslate t u-u)) := by
  simp_rw [map_sub]
  exact (jetTest_translation_smooth g u).sub contDiff_const

lemma finite_jet_tests {V : Type*} [NormedAddCommGroup V] [NormedSpace ℝ V]
    [FiniteDimensional ℝ V] (L : V →L[ℝ] COne ℂ E) (hL : Injective L) :
    ∃ s : Finset PlaneTest, ∀ v : V, (∀ g ∈ s, jetTestCLM g (L v)=0) → v=0 := by
  apply finite_separating_family (fun g : PlaneTest => (jetTestCLM g).comp L)
  intro v hv
  apply hL
  rw [map_zero]
  exact jetTest_separates _ hv

end HolderCompletion

end
section
open scoped Topology BoundedContinuousFunction ContDiff
open Set Function Filter
namespace HolderCompletion
variable {E F : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] [CompleteSpace E]
  [FiniteDimensional ℝ E] [NormedAddCommGroup F] [NormedSpace ℝ F]
section Generic
variable {X I : Type*} [NormedAddCommGroup X] [NormedSpace ℝ X]
omit [CompleteSpace E] in
lemma observed_fredholm_leftInverse [CompleteSpace E] (P : X →L[ℝ] F) (hP : P.IsFredholm)
    (O : I → X →L[ℝ] E) (hO : ∀ x, (∀ i, O i x=0) → x=0) :
    ∃ (s : Finset I) (L : F × (s → E) →L[ℝ] X),
      LeftInverse L (P.prod (ContinuousLinearMap.pi (fun i : s => O i.val))) := by
  let := hP.finite_ker
  obtain ⟨s,hs⟩ := finite_separating_family (fun i => (O i).comp P.ker.subtypeL)
    (by
      intro v hv
      apply Subtype.ext
      exact hO v.val hv)
  let Q : X →L[ℝ] (s → E) := ContinuousLinearMap.pi (fun i : s => O i.val)
  have hQ : Injective (Q.comp P.ker.subtypeL) := by
    intro u v huv
    apply sub_eq_zero.mp
    apply hs (u-v)
    intro i hi
    have hh := congrArg (fun f : s → E => f ⟨i,hi⟩) huv
    change O i u.val=O i v.val at hh
    change O i (u.val-v.val)=0
    rw [map_sub,hh,sub_self]
  obtain ⟨L,hL⟩ := fredholm_stabilized_leftInverse P hP Q hQ
  exact ⟨s,L,hL⟩
end Generic

local instance jetObsInst1 : NormedAddCommGroup (COne ℂ E) := inferInstance
local instance jetObsInst2 : NormedSpace ℝ (COne ℂ E) := inferInstance

def jetObservations (s : Finset PlaneTest) : COne ℂ E →L[ℝ] (s → E) :=
  ContinuousLinearMap.pi (fun g => jetTestCLM g.val)

omit [FiniteDimensional ℝ E] in
lemma jetObservations_translation_smooth [FiniteDimensional ℝ E] (s : Finset PlaneTest) (u : COne ℂ E) :
    ContDiff ℝ ∞ (fun t => jetObservations s (jetTranslate t u-u)) :=
  contDiff_pi.mpr (fun g => jetTest_translation_difference_smooth g.val u)

variable (S : Submodule ℝ (COne ℂ E))
local instance jetObsInst3 : NormedAddCommGroup S := inferInstance
local instance jetObsInst4 : NormedSpace ℝ S := inferInstance
local instance jetObsInst5 : AddCommGroup S := (jetObsInst3 S).toAddCommGroup
local instance jetObsInst6 : Module ℝ S := (jetObsInst4 S).toModule

def subspaceObservations (s : Finset PlaneTest) : S →L[ℝ] (s → E) :=
  (jetObservations s).comp S.subtypeL

lemma exists_jet_fredholm_observations (P : S →L[ℝ] F) (hP : P.IsFredholm) :
    ∃ (s : Finset PlaneTest) (L : F × (s → E) →L[ℝ] S),
      LeftInverse L (P.prod (subspaceObservations S s)) := by
  let O : PlaneTest → S →L[ℝ] E := fun g => (jetTestCLM g).comp S.subtypeL
  have hO : ∀ u : S, (∀ g, O g u=0) → u=0 := by
    intro u hu
    apply Subtype.ext
    exact jetTest_separates u.val hu
  have hh := observed_fredholm_leftInverse P hP O hO
  obtain ⟨s,L,hL⟩ := hh
  exact ⟨s,L,hL⟩

end HolderCompletion

end
section
open scoped ContDiff Topology BoundedContinuousFunction
open Set Function Filter
namespace HolderCompletion
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E] [CompleteSpace E]
local instance freeTransInst1 : NormedAddCommGroup (COne ℂ E) := inferInstance
local instance freeTransInst2 : NormedSpace ℝ (COne ℂ E) := inferInstance
local instance freeTransInst3 : NormedAddCommGroup (HMap ℂ E) := inferInstance
local instance freeTransInst4 : NormedSpace ℝ (HMap ℂ E) := inferInstance

def translationVariation (a : E) (u : COne ℂ E) (t : ℂ) : COne ℂ E :=
  constJet (t • a)+jetTranslate t u-u

omit [CompleteSpace E] in
@[simp] lemma translationVariation_value [CompleteSpace E] (a : E) (u : COne ℂ E) (t z : ℂ) :
    cValue (translationVariation a u t) z = t • a+cValue u (z+t)-cValue u z := rfl

omit [CompleteSpace E] in
@[simp] lemma translationVariation_deriv [CompleteSpace E] (a : E) (u : COne ℂ E) (t z : ℂ) :
    cDeriv (translationVariation a u t) z = cDeriv u (z+t)-cDeriv u z := by
  change (0 + cDeriv u (z+t))-cDeriv u z = _
  rw [zero_add]

omit [CompleteSpace E] in
lemma translationVariation_zero [CompleteSpace E] (a : E) (u : COne ℂ E) : translationVariation a u 0=0 := by
  apply cValue_ext
  intro z
  simp only [translationVariation_value,zero_smul,zero_add,add_zero,sub_self]
  rfl

lemma translationVariation_CR (a : E) (u : COne ℂ E) (t z : ℂ) :
    valueCLM _ (standardJetCR (translationVariation a u t)) z =
      valueCLM _ (standardJetCR u) (z+t)-valueCLM _ (standardJetCR u) z := by
  simp only [standardJetCR_value,translationVariation_deriv,sub_apply,smul_sub]
  abel

lemma translationVariation_mem {R S : ℝ} (hRS : R+1 ≤ S)
    (a : E) (u : freeModel (E := E) (Metric.closedBall (0:ℂ) R))
    {t : ℂ} (ht : ‖t‖≤1) : translationVariation a u.val t∈freeModel (E := E) (Metric.closedBall (0:ℂ) S) := by
  apply (mem_supportedHolder _ _).mpr
  intro z hz
  have hzS : S < ‖z‖ := by simpa only [Metric.mem_closedBall,dist_zero_right,not_le] using hz
  have hzR : z∉Metric.closedBall (0:ℂ) R := by
    simp only [Metric.mem_closedBall,dist_zero_right,not_le]
    linarith
  have hztR : z+t∉Metric.closedBall (0:ℂ) R := by
    simp only [Metric.mem_closedBall,dist_zero_right,not_le]
    have hnorm : ‖z‖ ≤ ‖z+t‖+‖t‖ := by
      simpa only [add_sub_cancel_right] using norm_sub_le (z+t) t
    linarith
  change valueCLM _ (standardJetCR (translationVariation a u.val t)) z = 0
  have h0 : valueCLM _ (standardJetCR u.val) z=0 := (mem_supportedHolder _ _).mp u.property z hzR
  have h1 : valueCLM _ (standardJetCR u.val) (z+t)=0 := (mem_supportedHolder _ _).mp u.property (z+t) hztR
  rw [translationVariation_CR,h1,h0,sub_self]

variable {R S : ℝ} (hRS : R+1 ≤ S) (a : E)
  (u : freeModel (E := E) (Metric.closedBall (0:ℂ) R))
local instance freeTransInst5 : NormedAddCommGroup (freeModel (E := E) (Metric.closedBall (0:ℂ) S)) := inferInstance
local instance freeTransInst6 : NormedSpace ℝ (freeModel (E := E) (Metric.closedBall (0:ℂ) S)) := inferInstance

def freeTranslation (t : ℂ) : freeModel (E := E) (Metric.closedBall (0:ℂ) S) :=
  if ht : ‖t‖≤1 then ⟨translationVariation a u.val t,translationVariation_mem hRS a u ht⟩ else 0

lemma freeTranslation_near : ∀ᶠ t in 𝓝 (0:ℂ), (freeTranslation hRS a u t).val=translationVariation a u.val t := by
  filter_upwards [Metric.ball_mem_nhds (0:ℂ) (show (0:ℝ)<1 by norm_num)] with t ht
  have ht' : ‖t‖≤1 := (show ‖t‖<1 by simpa only [Metric.mem_ball,dist_zero_right] using ht).le
  simp only [freeTranslation,dite_eq_left ht']

@[simp] lemma freeTranslation_zero : freeTranslation hRS a u 0=0 := by
  apply Subtype.ext
  exact freeTranslation_near hRS a u |>.self_of_nhds |>.trans (translationVariation_zero a u.val)

variable [FiniteDimensional ℝ E]

lemma translationVariation_observation_smooth (s : Finset PlaneTest) :
    ContDiff ℝ ∞ (fun t => jetObservations s (translationVariation a u.val t)) := by
  have he : (fun t => jetObservations s (translationVariation a u.val t)) =
      (fun t => jetObservations s (constJetCLM (complexSlope a t))+
        jetObservations s (jetTranslate t u.val-u.val)) := by
    funext t
    rw [←map_add]
    apply congrArg (jetObservations s)
    change constJet (t • a)+jetTranslate t u.val-u.val = constJet (t • a)+(jetTranslate t u.val-u.val)
    abel
  rw [he]
  exact ((jetObservations s).contDiff.comp ((constJetCLM (E := E)).contDiff.comp
    (complexSlope a).contDiff)).add (jetObservations_translation_smooth s u.val)

lemma freeTranslation_observation_smoothAt (s : Finset PlaneTest) :
    ContDiffAt ℝ ∞ (fun t => subspaceObservations (freeModel (E := E) (Metric.closedBall (0:ℂ) S)) s
      (freeTranslation hRS a u t)) 0 := by
  apply (translationVariation_observation_smooth a u s).contDiffAt.congr_of_eventuallyEq
  filter_upwards [freeTranslation_near hRS a u] with t ht
  exact congrArg (jetObservations s) ht

end HolderCompletion

end

end HigherDimensionalBallPacking.Rigidity
end

end OAI