import Mathlib
import OAI.Geometry.BallPacking.Holder.MarkedFrame

namespace OAI

noncomputable section
namespace HigherDimensionalBallPacking.Rigidity.HolderCompletion

section
open scoped ContDiff Topology BoundedContinuousFunction
open Set Filter
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E] [CompleteSpace E]
local instance scsInst1 : NormedAddCommGroup (E →L[ℝ] E) := ContinuousLinearMap.toNormedAddCommGroup
local instance scsInst2 : NormedSpace ℝ (E →L[ℝ] E) := ContinuousLinearMap.toNormedSpace
local instance scsInst3 : NormedAddCommGroup (COne ℂ E) := inferInstance
local instance scsInst4 : NormedSpace ℝ (COne ℂ E) := inferInstance
local instance scsInst5 : NormedAddCommGroup (HMap ℂ E) := inferInstance
local instance scsInst6 : NormedSpace ℝ (HMap ℂ E) := inferInstance
local instance scsInst7 : NormedAddCommGroup (HMap ℂ (E →L[ℝ] E)) := inferInstance
local instance scsInst8 : NormedSpace ℝ (HMap ℂ (E →L[ℝ] E)) := inferInstance

def jetDirectional (z : ℂ) : COne ℂ E →L[ℝ] HMap ℂ E :=
  (mapCLM _ (ContinuousLinearMap.apply ℝ E z)).comp (jetDerivCLM _)

omit [CompleteSpace E] in
@[simp] lemma jetDirectional_value (z : ℂ) (v : COne ℂ E) (w : ℂ) :
    valueCLM _ (jetDirectional z v) w=cDeriv v w z := rfl

omit [CompleteSpace E] in
lemma holderCoefficientAction_norm_le (A : HMap ℂ (E →L[ℝ] E)) (v : HMap ℂ E) :
    ‖holderCoefficientAction A v‖≤
      ‖bilinCLM (X := ℂ) (α := (1:ℝ)/3) (ContinuousLinearMap.apply (E := E) ℝ E).flip‖*‖A‖*‖v‖ :=
  (bilinCLM (X := ℂ) (α := (1:ℝ)/3) (ContinuousLinearMap.apply (E := E) ℝ E).flip).le_opNorm₂ A v

lemma compact_zeroMarked_schauder {K : Set ℂ} (hK : IsCompact K) (v : COne ℂ E)
    (hv : cValue v 0=0) (hs : standardJetCR v∈supportedHolder K) :
    ‖v‖≤‖standardHolderInverse (E := E) hK‖*‖standardJetCR v‖ := by
  let g : supportedHolder (E := E) K := ⟨standardJetCR v,hs⟩
  have he : standardHolderInverse hK g=v := standardJetCR_injective_zeroMarked
    (standardHolderInverse_zero hK g) hv (standardHolderInverse_residual hK g)
  have hh := (standardHolderInverse hK).le_opNorm g
  rw [he] at hh
  exact hh

lemma scalar_absorption {D B N a v f : ℝ} (hD : 0≤D) (hB : 0≤B) (hN : 0≤N)
    (hf : 0≤f) (hv : 0≤v) (ha : a≤(2*(D*B*N+1))⁻¹)
    (hb : v≤D*((B*a*N)*v+f)) : v≤(2*D+1)*f := by
  have ht : D*B*N*(2*(D*B*N+1))⁻¹≤(1:ℝ)/2 := by
    rw [←div_eq_mul_inv]
    apply (div_le_iff₀ (by positivity : 0<2*(D*B*N+1))).mpr
    nlinarith
  have hs : D*B*N*a≤(1:ℝ)/2 :=
    (mul_le_mul_of_nonneg_left ha (by positivity)).trans ht
  have hh := mul_le_mul_of_nonneg_right hs hv
  nlinarith

lemma small_coefficient_schauder {K : Set ℂ} (hK : IsCompact K) :
    ∃ ε C : ℝ,0<ε ∧ 0<C ∧ ∀ (v : COne ℂ E),cValue v 0=0 →
      standardJetCR v∈supportedHolder K →∀ (A : HMap ℂ (E →L[ℝ] E)),‖A‖≤ε →
      ∀ f : HMap ℂ E,standardJetCR v=holderCoefficientAction A (jetDirectional 1 v)+f →
        ‖v‖≤C*‖f‖ := by
  let D := ‖standardHolderInverse (E := E) hK‖
  let B := ‖bilinCLM (X := ℂ) (α := (1:ℝ)/3) (ContinuousLinearMap.apply (E := E) ℝ E).flip‖
  let N := ‖jetDirectional (E := E) 1‖
  have hD : 0≤D := norm_nonneg (standardHolderInverse (E := E) hK)
  have hB : 0≤B := norm_nonneg (bilinCLM (X := ℂ) (α := (1:ℝ)/3)
    (ContinuousLinearMap.apply (E := E) ℝ E).flip)
  have hN : 0≤N := norm_nonneg (jetDirectional (E := E) 1)
  have hpos : 0<(2*(D*B*N+1))⁻¹ := by positivity
  refine ⟨(2*(D*B*N+1))⁻¹,2*D+1,hpos,by positivity,?_⟩
  intro v hv hs A hA f he
  have hi := compact_zeroMarked_schauder hK v hv hs
  have hp := holderCoefficientAction_norm_le A (jetDirectional 1 v)
  have hd := (jetDirectional (E := E) 1).le_opNorm v
  have hm := mul_le_mul_of_nonneg_left hd (by positivity : 0≤B*‖A‖)
  have hb : ‖holderCoefficientAction A (jetDirectional 1 v)‖≤(B*‖A‖*N)*‖v‖ :=
    hp.trans (hm.trans_eq (by ring))
  have hres : ‖standardJetCR v‖≤(B*‖A‖*N)*‖v‖+‖f‖ := by
    rw [he]
    exact (norm_add_le _ _).trans (add_le_add hb (le_refl _))
  exact scalar_absorption hD hB hN (norm_nonneg f) (norm_nonneg v) hA
    (hi.trans (mul_le_mul_of_nonneg_left hres hD))


end
section
open scoped ContDiff Topology BoundedContinuousFunction
open Set Filter
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E] [CompleteSpace E]
local instance csInst1 : NormedAddCommGroup (E →L[ℝ] E) := ContinuousLinearMap.toNormedAddCommGroup
local instance csInst2 : NormedSpace ℝ (E →L[ℝ] E) := ContinuousLinearMap.toNormedSpace
local instance csInst9 : NormedAddCommGroup (ℂ →L[ℝ] E) := ContinuousLinearMap.toNormedAddCommGroup
local instance csInst10 : NormedSpace ℝ (ℂ →L[ℝ] E) := ContinuousLinearMap.toNormedSpace
local instance csInst11 : NormedAddCommGroup (HMap ℂ (ℂ →L[ℝ] E)) := inferInstance
local instance csInst12 : NormedSpace ℝ (HMap ℂ (ℂ →L[ℝ] E)) := inferInstance
local instance csInst3 : NormedAddCommGroup (COne ℂ E) := inferInstance
local instance csInst4 : NormedSpace ℝ (COne ℂ E) := inferInstance
local instance csInst5 : NormedAddCommGroup (HMap ℂ E) := inferInstance
local instance csInst6 : NormedSpace ℝ (HMap ℂ E) := inferInstance
local instance csInst7 : NormedAddCommGroup (HMap ℂ (E →L[ℝ] E)) := inferInstance
local instance csInst8 : NormedSpace ℝ (HMap ℂ (E →L[ℝ] E)) := inferInstance

omit [CompleteSpace E] in
lemma standardJetCR_sub_explicit (v w : COne ℂ E) :
    standardJetCR (v-w)=standardJetCR v-standardJetCR w := by
  apply value_ext
  intro z
  rw [(valueCLM ((1:ℝ)/3)).map_sub]
  simp only [BoundedContinuousFunction.sub_apply,standardJetCR_value]
  change ((cDeriv v z Complex.I-cDeriv w z Complex.I)-
      Complex.I • (cDeriv v z 1-cDeriv w z 1))=
      (cDeriv v z Complex.I-Complex.I • cDeriv v z 1)-
      (cDeriv w z Complex.I-Complex.I • cDeriv w z 1)
  rw [smul_sub]
  abel

omit [CompleteSpace E] in
lemma clm_principal_sub_algebra (A B : E →L[ℝ] E) (x y f g : E) :
    (A x+f)-(B y+g)=A (x-y)+((A-B) y+(f-g)) := by
  simp only [map_sub,sub_apply]
  abel

omit [CompleteSpace E] in
lemma principal_difference_identity (v w : COne ℂ E) (A B : HMap ℂ (E →L[ℝ] E))
    (f g : HMap ℂ E)
    (hv : standardJetCR v=holderCoefficientAction A (jetDirectional 1 v)+f)
    (hw : standardJetCR w=holderCoefficientAction B (jetDirectional 1 w)+g) :
    standardJetCR (v-w)=holderCoefficientAction A (jetDirectional 1 (v-w))+
      (holderCoefficientAction (A-B) (jetDirectional 1 w)+(f-g)) := by
  rw [standardJetCR_sub_explicit,hv,hw]
  apply value_ext
  intro z
  change (valueCLM _ A z (cDeriv v z 1)+valueCLM _ f z)-
      (valueCLM _ B z (cDeriv w z 1)+valueCLM _ g z)=
      valueCLM _ A z (cDeriv v z 1-cDeriv w z 1)+
        ((valueCLM _ A z-valueCLM _ B z) (cDeriv w z 1)+(valueCLM _ f z-valueCLM _ g z))
  exact clm_principal_sub_algebra (valueCLM _ A z) (valueCLM _ B z)
    (cDeriv v z 1) (cDeriv w z 1) (valueCLM _ f z) (valueCLM _ g z)

omit [CompleteSpace E] in
lemma holderCoefficientAction_jet_norm_le (A : HMap ℂ (E →L[ℝ] E)) (w : COne ℂ E) :
    ‖holderCoefficientAction A (jetDirectional 1 w)‖≤
      (‖bilinCLM (X := ℂ) (α := (1:ℝ)/3) (ContinuousLinearMap.apply (E := E) ℝ E).flip‖*
      ‖jetDirectional (E := E) 1‖)*‖A‖*‖w‖ := by
  have hp := holderCoefficientAction_norm_le A (jetDirectional 1 w)
  have hd := (jetDirectional (E := E) 1).le_opNorm w
  exact hp.trans ((mul_le_mul_of_nonneg_left hd (by positivity)).trans_eq (by ring))

omit [CompleteSpace E] in
lemma zeroMarked_sub (v w : COne ℂ E) (hv : cValue v 0=0) (hw : cValue w 0=0) :
    cValue (v-w) 0=0 := by
  change cValue v 0-cValue w 0=0
  rw [hv,hw,sub_self]

omit [CompleteSpace E] in
lemma jet_residual_sub_supported {K : Set ℂ} (v w : COne ℂ E)
    (hv : standardJetCR v∈supportedHolder K) (hw : standardJetCR w∈supportedHolder K) :
    standardJetCR (v-w)∈supportedHolder K := by
  rw [standardJetCR_sub_explicit]
  exact (supportedHolder (E := E) K).sub_mem hv hw

lemma small_coefficient_difference_estimate {K : Set ℂ} (hK : IsCompact K) :
    ∃ ε C D : ℝ,0<ε ∧ 0<C ∧ 0≤D ∧
    ∀ (v w : COne ℂ E),cValue v 0=0 →cValue w 0=0 →
      standardJetCR v∈supportedHolder K →standardJetCR w∈supportedHolder K →
    ∀ (A B : HMap ℂ (E →L[ℝ] E)),‖A‖≤ε →‖B‖≤ε →
    ∀ (f g : HMap ℂ E),
      standardJetCR v=holderCoefficientAction A (jetDirectional 1 v)+f →
      standardJetCR w=holderCoefficientAction B (jetDirectional 1 w)+g →
      ‖v‖≤C*‖f‖ ∧ ‖v-w‖≤C*(D*‖A-B‖*‖w‖+‖f-g‖) := by
  obtain ⟨ε,C,hε,hC,he⟩ := small_coefficient_schauder (E := E) hK
  let D := ‖bilinCLM (X := ℂ) (α := (1:ℝ)/3) (ContinuousLinearMap.apply (E := E) ℝ E).flip‖*
    ‖jetDirectional (E := E) 1‖
  have hD : 0≤D := by dsimp [D]; positivity
  refine ⟨ε,C,D,hε,hC,hD,?_⟩
  intro v w hv hw hvs hws A B hA hB f g hve hwe
  refine ⟨he v hv hvs A hA f hve,?_⟩
  have hest := he (v-w) (zeroMarked_sub v w hv hw) (jet_residual_sub_supported v w hvs hws)
    A hA _ (principal_difference_identity v w A B f g hve hwe)
  have hp' : ‖holderCoefficientAction (A-B) (jetDirectional 1 w)‖≤D*‖A-B‖*‖w‖ :=
    holderCoefficientAction_jet_norm_le (A-B) w
  exact hest.trans (mul_le_mul_of_nonneg_left
    ((norm_add_le _ _).trans (add_le_add hp' (le_refl _))) hC.le)

lemma cauchySeq_of_pair_distance_bound {X Y Z : Type*} [PseudoMetricSpace X]
    [PseudoMetricSpace Y] [PseudoMetricSpace Z] {u : ℕ →X} {a : ℕ →Y} {b : ℕ →Z}
    {P Q : ℝ} (hP : 0≤P) (hQ : 0≤Q) (ha : CauchySeq a) (hb : CauchySeq b)
    (hu : ∀ i j,dist (u i) (u j)≤P*dist (a i) (a j)+Q*dist (b i) (b j)) :
    CauchySeq u := by
  rw [Metric.cauchySeq_iff] at ha hb ⊢
  intro ε hε
  have hp : 0<P+Q+1 := by linarith
  obtain ⟨N,hN⟩ := ha (ε/(P+Q+1)) (div_pos hε hp)
  obtain ⟨M,hM⟩ := hb (ε/(P+Q+1)) (div_pos hε hp)
  refine ⟨max N M,fun i hi j hj => ?_⟩
  have h1 := hN i (le_trans (le_max_left _ _) hi) j (le_trans (le_max_left _ _) hj)
  have h2 := hM i (le_trans (le_max_right _ _) hi) j (le_trans (le_max_right _ _) hj)
  have hh := add_le_add (mul_le_mul_of_nonneg_left h1.le hP) (mul_le_mul_of_nonneg_left h2.le hQ)
  have he : P*(ε/(P+Q+1))+Q*(ε/(P+Q+1))<ε := by
    have hδ := div_pos hε hp
    have hid : (P+Q+1)*(ε/(P+Q+1))=ε := mul_div_cancel₀ ε (ne_of_gt hp)
    nlinarith
  exact (hu i j).trans_lt (hh.trans_lt he)

theorem small_coefficient_cauchy {K : Set ℂ} (hK : IsCompact K) :
    ∃ ε : ℝ,0<ε ∧ ∀ (v : ℕ → COne ℂ E) (A : ℕ → HMap ℂ (E →L[ℝ] E))
      (f : ℕ → HMap ℂ E),
      (∀ i,cValue (v i) 0=0) →(∀ i,standardJetCR (v i)∈supportedHolder K) →
      (∀ i,‖A i‖≤ε) →
      (∀ i,standardJetCR (v i)=holderCoefficientAction (A i) (jetDirectional 1 (v i))+f i) →
      CauchySeq A → CauchySeq f → CauchySeq v := by
  obtain ⟨ε,C,D,hε,hC,hD,he⟩ := small_coefficient_difference_estimate (E := E) hK
  refine ⟨ε,hε,?_⟩
  intro v A f hv hs hA hres hAc hfc
  obtain ⟨M,hM,hMf'⟩ := hfc.isBounded_range.exists_pos_norm_le
  have hMf : ∀ i,‖f i‖≤M := fun i => hMf' (f i) ⟨i,rfl⟩
  have hbound : ∀ j,‖v j‖≤C*M := fun j =>
    ((he (v j) (v j) (hv j) (hv j) (hs j) (hs j) (A j) (A j) (hA j) (hA j)
      (f j) (f j) (hres j) (hres j)).1).trans (mul_le_mul_of_nonneg_left (hMf j) hC.le)
  apply cauchySeq_of_pair_distance_bound (P := C*D*(C*M)) (Q := C)
    (by positivity) hC.le hAc hfc
  intro i j
  simp only [dist_eq_norm]
  have hh := (he (v i) (v j) (hv i) (hv j) (hs i) (hs j) (A i) (A j) (hA i) (hA j)
    (f i) (f j) (hres i) (hres j)).2
  have hb := mul_le_mul_of_nonneg_left (hbound j) (by positivity : 0≤D*‖A i-A j‖)
  exact hh.trans ((mul_le_mul_of_nonneg_left (add_le_add hb (le_refl _)) hC.le).trans_eq (by ring))


end
section
open scoped ContDiff Topology BoundedContinuousFunction
open Set Filter
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E] [CompleteSpace E]
local instance ccInst1 : NormedAddCommGroup (E →L[ℝ] E) := ContinuousLinearMap.toNormedAddCommGroup
local instance ccInst2 : NormedSpace ℝ (E →L[ℝ] E) := ContinuousLinearMap.toNormedSpace
local instance ccInst3 : NormedAddCommGroup (COne ℂ E) := inferInstance
local instance ccInst4 : NormedSpace ℝ (COne ℂ E) := inferInstance
local instance ccInst5 : NormedAddCommGroup (HMap ℂ E) := inferInstance
local instance ccInst6 : NormedSpace ℝ (HMap ℂ E) := inferInstance
local instance ccInst7 : NormedAddCommGroup (HMap ℂ (E →L[ℝ] E)) := inferInstance
local instance ccInst8 : NormedSpace ℝ (HMap ℂ (E →L[ℝ] E)) := inferInstance

variable (b : ContDiffBump (0:ℂ)) {u : ℂ → E} (hu : ContDiff ℝ ∞ u)

def cutoffCurveJet : COne ℂ E :=
  ofBoundedCThree (boundedCThree_of_compactSupport (b.contDiff.smul hu) b.hasCompactSupport.smul_right)

omit [CompleteSpace E] in
@[simp] lemma cutoffCurveJet_value (z : ℂ) : cValue (cutoffCurveJet b hu) z=b z • u z := rfl

omit [CompleteSpace E] in
lemma cutoffCurveJet_deriv (z h : ℂ) :
    cDeriv (cutoffCurveJet b hu) z h=
      (fderiv ℝ b z h) • u z+b z • fderiv ℝ u z h := by
  rw [←c_fderiv]
  change fderiv ℝ (fun z => b z • u z) z h=_
  rw [fderiv_fun_smul (b.contDiff.differentiable (by simp : (∞ : WithTop ℕ∞) ≠ 0) z) (hu.differentiable (by simp : (∞ : WithTop ℕ∞) ≠ 0) z)]
  simp only [add_apply,smul_apply,ContinuousLinearMap.smulRight_apply]
  exact add_comm _ _

omit [CompleteSpace E] in
lemma cutoffCurveJet_zero (h0 : u 0=0) : cValue (cutoffCurveJet b hu) 0=0 := by
  rw [cutoffCurveJet_value,h0,smul_zero]

omit [CompleteSpace E] in
lemma cutoffCurveJet_supported : standardJetCR (cutoffCurveJet b hu)∈
    supportedHolder (Metric.closedBall (0:ℂ) b.rOut) := by
  apply (mem_supportedHolder _ _).mpr
  intro z hz
  have hb : z∉tsupport b := by
    rw [b.tsupport_eq]
    exact hz
  have hb0 := image_eq_zero_of_notMem_tsupport hb
  have hbd := fderiv_of_notMem_tsupport ℝ hb
  rw [standardJetCR_value]
  change cDeriv (cutoffCurveJet b hu) z Complex.I-Complex.I • cDeriv (cutoffCurveJet b hu) z 1=0
  rw [cutoffCurveJet_deriv,cutoffCurveJet_deriv,hbd,hb0]
  simp

omit [CompleteSpace E] in
lemma cutoffCurveJet_CR {A : ℂ → E →L[ℝ] E}
    (hcr : ∀ z,b z≠0 → fderiv ℝ u z Complex.I-Complex.I • fderiv ℝ u z 1=A z (fderiv ℝ u z 1))
    (ac : HMap ℂ (E →L[ℝ] E)) (hac : ∀ z,b z≠0 → valueCLM _ ac z=A z)
    (f : HMap ℂ E) (hf : ∀ z,valueCLM _ f z=
      (fderiv ℝ b z Complex.I) • u z-Complex.I • ((fderiv ℝ b z 1) • u z)-
        valueCLM _ ac z ((fderiv ℝ b z 1) • u z)) :
    standardJetCR (cutoffCurveJet b hu)=
      holderCoefficientAction ac (jetDirectional 1 (cutoffCurveJet b hu))+f := by
  apply value_ext
  intro z
  rw [standardJetCR_value]
  change cDeriv (cutoffCurveJet b hu) z Complex.I-Complex.I • cDeriv (cutoffCurveJet b hu) z 1=
    valueCLM _ ac z (cDeriv (cutoffCurveJet b hu) z 1)+valueCLM _ f z
  rw [cutoffCurveJet_deriv,cutoffCurveJet_deriv,hf]
  have he : b z • (fderiv ℝ u z Complex.I-Complex.I • fderiv ℝ u z 1)=
      valueCLM _ ac z (b z • fderiv ℝ u z 1) := by
    by_cases hb : b z=0
    · simp [hb]
    · rw [hac z hb,hcr z hb,map_smul]
  rw [map_add]
  simp only [smul_add,smul_sub] at *
  rw [smul_comm Complex.I (b z)]
  rw [←he]
  abel

lemma small_value_elliptic_estimate {K : Set ℂ} (hK : IsCompact K)
    {L M η : ℝ} (hL : 0≤L) (hM : 0≤M) (hη : 0<η) :
    ∃ δ : ℝ,0<δ ∧ ∀ (v : COne ℂ E),cValue v 0=0 →
      standardJetCR v∈supportedHolder K → ∀ (A : HMap ℂ (E →L[ℝ] E)) (f : HMap ℂ E),
      (∀ z,‖valueCLM _ A z‖≤δ) → (∀ x y,‖valueCLM _ A x-valueCLM _ A y‖≤L*dist x y) →
      (∀ z,‖valueCLM _ f z‖≤δ) → (∀ x y,‖valueCLM _ f x-valueCLM _ f y‖≤M*dist x y) →
      standardJetCR v=holderCoefficientAction A (jetDirectional 1 v)+f → ‖v‖<η := by
  obtain ⟨ε,C,hε,hC,hest⟩ := small_coefficient_schauder (E := E) hK
  obtain ⟨d,hd,hda⟩ := holder_small_of_small_value (E := E →L[ℝ] E) (X := ℂ) hL hε
  obtain ⟨e,he,hef⟩ := holder_small_of_small_value (E := E) (X := ℂ) hM (div_pos hη hC)
  refine ⟨min d e,lt_min hd he,?_⟩
  intro v hv hs A f hA hAL hf hfL hres
  have hAn : ‖A‖<ε := hda A (fun z => (hA z).trans (min_le_left _ _)) hAL
  have hfn : ‖f‖<η/C := hef f (fun z => (hf z).trans (min_le_right _ _)) hfL
  have hh := hest v hv hs A hAn.le f hres
  have ht : C*‖f‖<η := by
    have h := (lt_div_iff₀ hC).mp hfn
    simpa only [mul_comm] using h
  exact hh.trans_lt ht


end
section
open scoped ContDiff Topology BoundedContinuousFunction
open Set Filter
variable {X E F : Type*} [MetricSpace X] [NormedAddCommGroup E] [NormedSpace ℝ E]
  [NormedAddCommGroup F] [NormedSpace ℝ F]

def ofBoundedLipschitz (f : X → E) (hf : Continuous f) (M L : ℝ)
    (hM : 0≤M) (hL : 0≤L) (hb : ∀ x,‖f x‖≤M)
    (hl : ∀ x y,‖f x-f y‖≤L*dist x y) : HMap X E :=
  ofBound f hf M (2*M+L) hb (by positivity) (by
    apply third_interpolation hM hL (by positivity) (show (0:ℝ)<1 by norm_num) hb hl
    · simp only [Real.one_rpow,mul_one]; linarith
    · simp only [Real.one_rpow,mul_one]; linarith)

@[simp] lemma ofBoundedLipschitz_value (f : X → E) (hf : Continuous f) (M L : ℝ)
    (hM : 0≤M) (hL : 0≤L) (hb : ∀ x,‖f x‖≤M)
    (hl : ∀ x y,‖f x-f y‖≤L*dist x y) (x : X) :
    valueCLM _ (ofBoundedLipschitz f hf M L hM hL hb hl) x=f x := rfl

lemma clm_pair_difference (A B : E →L[ℝ] F) (u v : E) :
    ‖A u-B v‖≤‖A‖*‖u-v‖+‖A-B‖*‖v‖ := by
  have he : A u-B v=A (u-v)+(A-B) v := by simp only [map_sub,sub_apply]; abel
  rw [he]
  exact (norm_add_le _ _).trans (add_le_add (A.le_opNorm _) ((A-B).le_opNorm _))

lemma clm_pair_bounds {A : X → E →L[ℝ] F} {u : X → E} {B C L M : ℝ}
    (hB : 0≤B) (_hC : 0≤C) (hL : 0≤L) (_hM : 0≤M)
    (hA : ∀ z,‖A z‖≤B) (hu : ∀ z,‖u z‖≤C)
    (hAL : ∀ x y,‖A x-A y‖≤L*dist x y)
    (huL : ∀ x y,‖u x-u y‖≤M*dist x y) :
    (∀ z,‖A z (u z)‖≤B*C) ∧
    (∀ x y,‖A x (u x)-A y (u y)‖≤(B*M+L*C)*dist x y) := by
  constructor
  · intro z
    exact ((A z).le_opNorm _).trans (mul_le_mul (hA z) (hu z) (norm_nonneg _) hB)
  · intro x y
    apply (clm_pair_difference _ _ _ _).trans
    have h1 := mul_le_mul (hA x) (huL x y) (norm_nonneg _) hB
    have h2 := mul_le_mul (hAL x y) (hu y) (norm_nonneg _) (by positivity : 0≤L*dist x y)
    exact (add_le_add h1 h2).trans_eq (by ring)

local instance bcpInst1 : NormedAddCommGroup (E →L[ℝ] E) := ContinuousLinearMap.toNormedAddCommGroup
local instance bcpInst2 : NormedSpace ℝ (E →L[ℝ] E) := ContinuousLinearMap.toNormedSpace

lemma cutoff_forcing_bounds {u : X → E} {A C D : X → E →L[ℝ] E}
    {δ H L B : ℝ} (hδ : 0≤δ) (hδ1 : δ≤1) (hH : 0≤H) (hL : 0≤L) (hB : 0≤B)
    (hu : ∀ z,‖u z‖≤δ) (huL : ∀ x y,‖u x-u y‖≤H*dist x y)
    (hA : ∀ z,‖A z‖≤L*δ) (hAL : ∀ x y,‖A x-A y‖≤(L*H)*dist x y)
    (hC : ∀ z,‖C z‖≤B) (hCL : ∀ x y,‖C x-C y‖≤B*dist x y)
    (hD : ∀ z,‖D z‖≤B) (hDL : ∀ x y,‖D x-D y‖≤B*dist x y) :
    (∀ z,‖C z (u z)-A z (D z (u z))‖≤((1+L)*B)*δ) ∧
    (∀ x y,‖(C x (u x)-A x (D x (u x)))-(C y (u y)-A y (D y (u y)))‖≤
      (B*(H+1)+L*(B*(H+1))+L*H*B)*dist x y) := by
  have hHL : 0≤B*(H+1) := by positivity
  have hbδ : B*δ≤B := by nlinarith
  have hstep : B*H+B*δ≤B*(H+1) := by nlinarith
  obtain ⟨hc,hcl⟩ := clm_pair_bounds hB hδ hB hH hC hu hCL huL
  obtain ⟨hd,hdl⟩ := clm_pair_bounds hB hδ hB hH hD hu hDL huL
  have hAu : ∀ z,‖A z‖≤L := fun z => (hA z).trans (by nlinarith)
  have hDu : ∀ z,‖D z (u z)‖≤B := fun z => (hd z).trans hbδ
  have hDul : ∀ x y,‖D x (u x)-D y (u y)‖≤B*(H+1)*dist x y :=
    fun x y => (hdl x y).trans (mul_le_mul_of_nonneg_right hstep (dist_nonneg))
  obtain ⟨ _,hal⟩ := clm_pair_bounds hL hB (mul_nonneg hL hH) hHL hAu hDu hAL hDul
  refine ⟨?_,?_⟩
  · intro z
    have hh : ‖A z (D z (u z))‖≤L*(B*δ) :=
      ((A z).le_opNorm _).trans (mul_le_mul (hAu z) (hd z) (norm_nonneg _) hL)
    exact (norm_sub_le _ _).trans ((add_le_add (hc z) hh).trans_eq (by ring))
  · intro x y
    have he : (C x (u x)-A x (D x (u x)))-(C y (u y)-A y (D y (u y)))=
        (C x (u x)-C y (u y))-(A x (D x (u x))-A y (D y (u y))) := by abel
    rw [he]
    have hc' := (hcl x y).trans (mul_le_mul_of_nonneg_right hstep (dist_nonneg))
    exact (norm_sub_le _ _).trans ((add_le_add hc' (hal x y)).trans_eq (by ring))


end
section
open scoped ContDiff Topology BoundedContinuousFunction
open Set Filter
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E] [CompleteSpace E]
local instance ctInst1 : NormedAddCommGroup (E →L[ℝ] E) := ContinuousLinearMap.toNormedAddCommGroup
local instance ctInst2 : NormedSpace ℝ (E →L[ℝ] E) := ContinuousLinearMap.toNormedSpace
variable (b : ContDiffBump (0:ℂ))

def cutoffTransport (h z : ℂ) : E →L[ℝ] E :=
  (fderiv ℝ b z h) • ContinuousLinearMap.id ℝ E

def cutoffCommute (z : ℂ) : E →L[ℝ] E :=
  cutoffTransport b Complex.I z-(ContinuousLinearMap.lsmul ℝ ℂ (E := E) Complex.I).comp (cutoffTransport b 1 z)

omit [CompleteSpace E] in
@[simp] lemma cutoffTransport_apply (h z : ℂ) (v : E) : cutoffTransport b h z v=(fderiv ℝ b z h) • v := rfl
omit [CompleteSpace E] in
@[simp] lemma cutoffCommute_apply (z : ℂ) (v : E) :
    cutoffCommute b z v=(fderiv ℝ b z Complex.I) • v-Complex.I • ((fderiv ℝ b z 1) • v) := rfl

omit [CompleteSpace E] in
lemma cutoffTransport_smooth (h : ℂ) : ContDiff ℝ ∞ (cutoffTransport (E := E) b h) := by
  exact ((b.contDiff.fderiv_right (by simp : (∞ : WithTop ℕ∞)+1≤∞)).clm_apply contDiff_const).smul contDiff_const

omit [CompleteSpace E] in
lemma cutoffTransport_compact (h : ℂ) : HasCompactSupport (cutoffTransport (E := E) b h) :=
  (b.hasCompactSupport.fderiv_apply ℝ h).smul_right

omit [CompleteSpace E] in
lemma cutoffCommute_smooth : ContDiff ℝ ∞ (cutoffCommute (E := E) b) :=
  (cutoffTransport_smooth b Complex.I).sub (contDiff_const.clm_comp (cutoffTransport_smooth b 1))

omit [CompleteSpace E] in
lemma cutoffCommute_compact : HasCompactSupport (cutoffCommute (E := E) b) := by
  apply HasCompactSupport.of_support_subset_isCompact b.hasCompactSupport
  intro z hz
  by_contra hn
  apply hz
  have hd := fderiv_of_notMem_tsupport ℝ hn
  simp only [cutoffCommute,cutoffTransport,hd,zero_apply,zero_smul,
    ContinuousLinearMap.comp_zero,sub_zero]

omit [CompleteSpace E] in
lemma cutoff_transport_bounds : ∃ B : ℝ,0<B ∧
    (∀ z,‖cutoffTransport (E := E) b 1 z‖≤B) ∧
    (∀ x y,‖cutoffTransport (E := E) b 1 x-cutoffTransport b 1 y‖≤B*dist x y) ∧
    (∀ z,‖cutoffCommute (E := E) b z‖≤B) ∧
    (∀ x y,‖cutoffCommute (E := E) b x-cutoffCommute b y‖≤B*dist x y) := by
  have hd := boundedCThree_of_compactSupport (cutoffTransport_smooth (E := E) b 1) (cutoffTransport_compact b 1)
  have hc := boundedCThree_of_compactSupport (cutoffCommute_smooth (E := E) b) (cutoffCommute_compact b)
  let B := hd.bound+hc.bound+1
  have hB : 0<B := by dsimp [B]; linarith [hd.bound_nonneg,hc.bound_nonneg]
  have hdb : hd.bound≤B := by dsimp [B]; linarith [hc.bound_nonneg]
  have hcb : hc.bound≤B := by dsimp [B]; linarith [hd.bound_nonneg]
  refine ⟨B,hB,fun z => (hd.norm_le z).trans hdb,?_,fun z => (hc.norm_le z).trans hcb,?_⟩
  · intro x y
    exact (hd.norm_sub_le x y).trans (by rw [dist_eq_norm]; exact mul_le_mul_of_nonneg_right hdb (norm_nonneg _))
  · intro x y
    exact (hc.norm_sub_le x y).trans (by rw [dist_eq_norm]; exact mul_le_mul_of_nonneg_right hcb (norm_nonneg _))


end
open scoped Topology BoundedContinuousFunction
open Set Filter
variable {X E : Type*} [MetricSpace X] [NormedAddCommGroup E] [NormedSpace ℝ E]
local instance uhcInst1 : NormedAddCommGroup (HMap X E) := inferInstance
local instance uhcInst2 : NormedSpace ℝ (HMap X E) := inferInstance

lemma holder_cauchy_of_uniform_values {v : ℕ → HMap X E} {L : ℝ} (hL : 0≤L)
    (hl : ∀ i x y,‖valueCLM _ (v i) x-valueCLM _ (v i) y‖≤L*dist x y)
    (hv : ∀ ε : ℝ,0<ε →∃ N : ℕ,∀ i≥N,∀ j≥N,∀ x,
      ‖valueCLM _ (v i) x-valueCLM _ (v j) x‖≤ε) : CauchySeq v := by
  rw [Metric.cauchySeq_iff]
  intro ε hε
  obtain ⟨δ,hδ,hd⟩ := holder_small_of_small_value (X := X) (E := E) (by linarith : 0≤2*L) hε
  obtain ⟨N,hN⟩ := hv δ hδ
  refine ⟨N,fun i hi j hj => ?_⟩
  rw [dist_eq_norm]
  apply hd (v i-v j)
  · intro x
    exact hN i hi j hj x
  · intro x y
    change ‖(valueCLM _ (v i) x-valueCLM _ (v j) x)-
      (valueCLM _ (v i) y-valueCLM _ (v j) y)‖≤2*L*dist x y
    have he : (valueCLM _ (v i) x-valueCLM _ (v j) x)-
        (valueCLM _ (v i) y-valueCLM _ (v j) y)=
        (valueCLM _ (v i) x-valueCLM _ (v i) y)-
        (valueCLM _ (v j) x-valueCLM _ (v j) y) := by abel
    rw [he]
    exact (norm_sub_le _ _).trans ((add_le_add (hl i x y) (hl j x y)).trans_eq (by ring))

omit [MetricSpace X] [NormedSpace ℝ E] in
lemma uniform_cauchy_of_tendstoUniformly {v : ℕ → X → E} {w : X → E}
    (hv : TendstoUniformly v w atTop) :
    ∀ ε : ℝ,0<ε →∃ N : ℕ,∀ i≥N,∀ j≥N,∀ x,‖v i x-v j x‖≤ε := by
  intro ε hε
  have hh := (Metric.tendstoUniformly_iff.mp hv) (ε/2) (half_pos hε)
  obtain ⟨N,hN⟩ := eventually_atTop.mp hh
  refine ⟨N,fun i hi j hj x => ?_⟩
  have h1 := hN i hi x
  have h2 := hN j hj x
  rw [dist_comm,dist_eq_norm] at h1 h2
  have he : v i x-v j x=(v i x-w x)-(v j x-w x) := by abel
  rw [he]
  exact (norm_sub_le _ _).trans (by linarith)

lemma holder_cauchy_of_tendstoUniformly {v : ℕ → HMap X E} {w : X → E}
    {L : ℝ} (hL : 0≤L)
    (hl : ∀ i x y,‖valueCLM _ (v i) x-valueCLM _ (v i) y‖≤L*dist x y)
    (hv : TendstoUniformly (fun i => valueCLM _ (v i)) w atTop) : CauchySeq v :=
  holder_cauchy_of_uniform_values hL hl (uniform_cauchy_of_tendstoUniformly hv)



end HigherDimensionalBallPacking.Rigidity.HolderCompletion
end

end OAI