lean/OAI/Geometry/BallPacking/Compactness/AffineCorrectionInfinity.lean

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

namespace OAI

noncomputable section
open scoped ContDiff Topology
open Set Function Filter
open SymplecticBallPacking.Hamiltonian (Plane)
namespace HigherDimensionalBallPacking.Rigidity
variable {n : ℕ}

lemma analyticAt_dslope_zero {h : ℂ → Phase n} (hh : AnalyticAt ℂ h 0) :
    AnalyticAt ℂ (dslope h 0) 0 := by
  obtain ⟨P,hP⟩ := hh
  exact ⟨P.fslope,hP.has_fpower_series_dslope_fslope⟩

lemma infinityGerm_affine_reconstruction (u : ℂ → Phase n) (a : Phase n) {z : ℂ} (hz : z≠0) :
    u z=z • a+dslope (infinityGerm u a) 0 z⁻¹ := by
  rw [dslope_of_ne _ (inv_ne_zero hz),slope,sub_zero]
  simp only [infinityGerm,inv_ne_zero hz,ite_false,inv_inv,ite_true,vsub_eq_sub]
  rw [smul_sub,smul_smul,mul_inv_cancel₀ hz,one_smul]
  abel

lemma analytic_inverse_angular_fderiv_limit {h : ℂ → Phase n} (hh : AnalyticAt ℂ h 0) :
    Tendsto (fun z : ℂ => fderiv ℝ (fun w : ℂ => h w⁻¹) z (Complex.I*z))
      (cocompact ℂ) (𝓝 0) := by
  have hi : Tendsto (fun z : ℂ => z⁻¹) (cocompact ℂ) (𝓝 0) := by
    simpa only [←Metric.cobounded_eq_cocompact] using (tendsto_inv₀_cobounded (α := ℂ))
  have hc : ContDiffAt ℝ ∞ h 0 := hh.contDiffAt.restrict_scalars ℝ
  have hdh : Tendsto (fun z : ℂ => fderiv ℝ h z⁻¹) (cocompact ℂ) (𝓝 (fderiv ℝ h 0)) :=
    (hc.fderiv_right (m := 0) (by simp)).continuousAt.tendsto.comp hi
  have harg : Tendsto (fun z : ℂ => -Complex.I*z⁻¹) (cocompact ℂ) (𝓝 0) := by
    simpa using hi.const_mul (-Complex.I)
  have hvec : Tendsto (fun z : ℂ => fderiv ℝ h z⁻¹ (-Complex.I*z⁻¹))
      (cocompact ℂ) (𝓝 0) := by
    simpa only [Function.comp_def,map_zero] using
      (continuous_fst.clm_apply continuous_snd).continuousAt.tendsto.comp (hdh.prodMk_nhds harg)
  have hd : ∀ᶠ w in 𝓝 (0:ℂ), DifferentiableAt ℝ h w :=
    hh.eventually_analyticAt.mono fun _ hx => hx.differentiableAt.restrictScalars ℝ
  apply hvec.congr'
  filter_upwards [hi.eventually hd,(isCompact_singleton (x := (0:ℂ))).compl_mem_cocompact] with z hz hz0
  have hid := (hasDerivAt_inv hz0).hasFDerivAt.restrictScalars ℝ
  have hder := hz.hasFDerivAt.comp z hid
  change HasFDerivAt (fun w : ℂ => h w⁻¹) _ z at hder
  rw [hder.fderiv]
  change fderiv ℝ h z⁻¹ (-Complex.I*z⁻¹)=
    fderiv ℝ h z⁻¹ ((Complex.I*z) • (-(z^2)⁻¹))
  rw [smul_eq_mul]
  congr 1
  field_simp

theorem AffineLineCurve.affine_correction_at_infinity {J : Phase n → End n}
    {p q : Phase n} {u : ℂ → Phase n} (hu : AffineLineCurve J p q u)
    (hJc : HasCompactSupport (fun x => J x-standardJ n)) :
    ∃ (a : Phase n) (h : ℂ → Phase n), a≠0 ∧ AnalyticAt ℂ h 0 ∧
      (∀ z : ℂ, z≠0 → u z=z • a+h z⁻¹) := by
  obtain ⟨a,ha,hh,_⟩ := hu.analytic_at_infinity hJc
  exact ⟨a,dslope (infinityGerm u a) 0,ha,analyticAt_dslope_zero hh,
    fun _ hz => infinityGerm_affine_reconstruction u a hz⟩

def affineCorrection (u : ℂ → Phase n) (a : Phase n) (z : ℂ) : Phase n := u z-z • a

lemma affineCorrection_smooth {u : ℂ → Phase n} (hu : ContDiff ℝ ∞ u) (a : Phase n) :
    ContDiff ℝ ∞ (affineCorrection u a) := hu.sub (contDiff_id.smul contDiff_const)

lemma affineCorrection_locally_inverse {u : ℂ → Phase n} {a : Phase n} {h : ℂ → Phase n}
    (he : ∀ z : ℂ, z≠0 → u z=z • a+h z⁻¹) {z : ℂ} (hz : z≠0) :
    affineCorrection u a =ᶠ[𝓝 z] fun w : ℂ => h w⁻¹ := by
  filter_upwards [isClosed_singleton.isOpen_compl.mem_nhds hz] with w hw
  rw [affineCorrection,he w hw]
  abel

lemma affineCorrection_limit {u : ℂ → Phase n} {a : Phase n} {h : ℂ → Phase n}
    (hh : AnalyticAt ℂ h 0) (he : ∀ z : ℂ, z≠0 → u z=z • a+h z⁻¹) :
    Tendsto (affineCorrection u a) (cocompact ℂ) (𝓝 (h 0)) := by
  have hi : Tendsto (fun z : ℂ => z⁻¹) (cocompact ℂ) (𝓝 0) := by
    simpa only [←Metric.cobounded_eq_cocompact] using (tendsto_inv₀_cobounded (α := ℂ))
  apply (hh.continuousAt.tendsto.comp hi).congr'
  filter_upwards [(isCompact_singleton (x := (0:ℂ))).compl_mem_cocompact] with z hz
  exact ((affineCorrection_locally_inverse he hz).self_of_nhds).symm

lemma affineCorrection_angular_fderiv_limit {u : ℂ → Phase n} {a : Phase n} {h : ℂ → Phase n}
    (hh : AnalyticAt ℂ h 0) (he : ∀ z : ℂ, z≠0 → u z=z • a+h z⁻¹) :
    Tendsto (fun z : ℂ => fderiv ℝ (affineCorrection u a) z (Complex.I*z))
      (cocompact ℂ) (𝓝 0) := by
  apply (analytic_inverse_angular_fderiv_limit hh).congr'
  filter_upwards [(isCompact_singleton (x := (0:ℂ))).compl_mem_cocompact] with z hz
  rw [(affineCorrection_locally_inverse he hz).fderiv_eq]

lemma affineCorrection_primitive_flux_zero {u : ℂ → Phase n} {a : Phase n} {h : ℂ → Phase n}
    (hh : AnalyticAt ℂ h 0) (he : ∀ z : ℂ, z≠0 → u z=z • a+h z⁻¹) :
    Tendsto (fun z : ℂ => stdOmega n (affineCorrection u a z)
      (fderiv ℝ (affineCorrection u a) z (Complex.I*z))) (cocompact ℂ) (𝓝 0) := by
  have hv := affineCorrection_limit hh he
  have hd := affineCorrection_angular_fderiv_limit hh he
  have ho : Tendsto (fun z => stdOmega n (affineCorrection u a z))
      (cocompact ℂ) (𝓝 (stdOmega n (h 0))) := (stdOmega n).continuous.continuousAt.tendsto.comp hv
  simpa only [Function.comp_def,map_zero] using
    (continuous_fst.clm_apply continuous_snd).continuousAt.tendsto.comp (ho.prodMk_nhds hd)

end HigherDimensionalBallPacking.Rigidity

end
noncomputable section
open scoped ContDiff Topology
open Set Filter
namespace HigherDimensionalBallPacking.Rigidity
variable {n : ℕ}
local instance ceInst1 : NormedAddCommGroup (End n) := ContinuousLinearMap.toNormedAddCommGroup
local instance ceInst2 : NormedSpace ℝ (End n) := ContinuousLinearMap.toNormedSpace

def defectEnergy (A : End n) (v : Phase n) : ℝ :=
  stdDot n ((A-standardJ n) v) ((A-standardJ n) v)

def symplecticEnergy (A : End n) (v : Phase n) : ℝ := stdOmega n v (A v)

lemma defectEnergy_nonneg (A : End n) (v : Phase n) : 0≤defectEnergy A v := stdDot_nonneg _

lemma defectEnergy_standard (v : Phase n) : defectEnergy (standardJ n) v=0 := by
  simp only [defectEnergy,sub_self,zero_apply,map_zero]

lemma defectEnergy_smul (A : End n) (r : ℝ) (v : Phase n) :
    defectEnergy A (r • v)=r^2*defectEnergy A v := by
  simp only [defectEnergy,map_smul,smul_apply,smul_eq_mul]
  ring

lemma symplecticEnergy_smul (A : End n) (r : ℝ) (v : Phase n) :
    symplecticEnergy A (r • v)=r^2*symplecticEnergy A v := by
  simp only [symplecticEnergy,map_smul,smul_apply,smul_eq_mul]
  ring

lemma symplecticEnergy_pos {A : End n} (hA : Compatible A) {v : Phase n} (hv : v≠0) :
    0<symplecticEnergy A v := by
  rw [symplecticEnergy,stdOmega_apply]
  exact hA.2.2 v hv

lemma defectEnergy_continuous : Continuous (fun z : End n × Phase n => defectEnergy z.1 z.2) := by
  have h : Continuous (fun z : End n × Phase n => (z.1-standardJ n) z.2) :=
    (continuous_fst.sub continuous_const).clm_apply continuous_snd
  exact (((stdDot n).continuous.comp h).clm_apply h)

lemma symplecticEnergy_continuous : Continuous (fun z : End n × Phase n => symplecticEnergy z.1 z.2) := by
  exact ((stdOmega n).continuous.comp continuous_snd).clm_apply (continuous_fst.clm_apply continuous_snd)

lemma energyRatio_continuousOn {X : Type*} [TopologicalSpace X]
    {K : Set X} {A : X → End n} (hAc : ContinuousOn A K)
    (hA : ∀ x∈K, Compatible (A x)) :
    ContinuousOn (fun z : X × Phase n => defectEnergy (A z.1) z.2 / symplecticEnergy (A z.1) z.2)
      (K ×ˢ Metric.sphere (0:Phase n) 1) := by
  have hpair : ContinuousOn (fun z : X × Phase n => (A z.1,z.2))
      (K ×ˢ Metric.sphere (0:Phase n) 1) :=
    (hAc.comp continuous_fst.continuousOn (fun _ h => h.1)).prodMk continuous_snd.continuousOn
  apply (defectEnergy_continuous.comp_continuousOn hpair).div
    (symplecticEnergy_continuous.comp_continuousOn hpair)
  intro z hz
  apply (symplecticEnergy_pos (hA z.1 hz.1) ?_).ne'
  have hn : ‖z.2‖=1 := by simpa only [Metric.mem_sphere,dist_zero_right] using hz.2
  exact norm_ne_zero_iff.mp (by rw [hn]; norm_num)

lemma energyRatio_bounded_on_sphere {X : Type*} [TopologicalSpace X]
    {K : Set X} (hK : IsCompact K) {A : X → End n} (hAc : ContinuousOn A K)
    (hA : ∀ x∈K, Compatible (A x)) :
    ∃ B : ℝ, 0<B ∧ ∀ x∈K, ∀ v : Phase n, ‖v‖=1 →
      defectEnergy (A x) v≤B*symplecticEnergy (A x) v := by
  let f (z : X × Phase n) : ℝ := defectEnergy (A z.1) z.2 / symplecticEnergy (A z.1) z.2
  have hf : ContinuousOn f (K ×ˢ Metric.sphere (0:Phase n) 1) := energyRatio_continuousOn hAc hA
  have hL : IsCompact (K ×ˢ Metric.sphere (0:Phase n) 1) := hK.prod (isCompact_sphere _ _)
  obtain ⟨B,hB,hbound⟩ := (hL.image_of_continuousOn hf).isBounded.exists_pos_norm_le
  refine ⟨B,hB,?_⟩
  intro x hx v hv
  have hwL : (x,v)∈K ×ˢ Metric.sphere (0:Phase n) 1 :=
    ⟨hx,by simpa only [Metric.mem_sphere,dist_zero_right] using hv⟩
  have hnorm := hbound (f (x,v)) ⟨(x,v),hwL,rfl⟩
  have hb : f (x,v)≤B := (le_abs_self _).trans (by simpa only [Real.norm_eq_abs] using hnorm)
  have hv0 : v≠0 := norm_ne_zero_iff.mp (by rw [hv]; norm_num)
  exact (div_le_iff₀ (symplecticEnergy_pos (hA x hx) hv0)).mp hb

lemma energyRatio_extend_from_sphere {A : End n} {B : ℝ}
    (hB : ∀ w : Phase n, ‖w‖=1 → defectEnergy A w≤B*symplecticEnergy A w)
    (v : Phase n) : defectEnergy A v≤B*symplecticEnergy A v := by
  by_cases hv : v=0
  · subst v
    simp [defectEnergy,symplecticEnergy]
  let w : Phase n := ‖v‖⁻¹ • v
  have hnv : ‖v‖≠0 := norm_ne_zero_iff.mpr hv
  have hw : ‖w‖=1 := by
    simp only [w,norm_smul,Real.norm_eq_abs,abs_inv,abs_norm,inv_mul_cancel₀ hnv]
  have hratio := hB w hw
  rw [show w=‖v‖⁻¹ • v from rfl,defectEnergy_smul,symplecticEnergy_smul] at hratio
  have hp : 0<(‖v‖⁻¹)^2 := sq_pos_of_ne_zero (inv_ne_zero hnv)
  apply (mul_le_mul_iff_right₀ hp).mp
  calc
    (‖v‖⁻¹)^2*defectEnergy A v ≤ B*((‖v‖⁻¹)^2*symplecticEnergy A v) := hratio
    _ = (‖v‖⁻¹)^2*(B*symplecticEnergy A v) := by ring

lemma exists_defectEnergy_bound {X : Type*} [TopologicalSpace X]
    {K : Set X} (hK : IsCompact K) {A : X → End n} (hAc : ContinuousOn A K)
    (hA : ∀ x∈K, Compatible (A x)) :
    ∃ C : ℝ, 0<C ∧ ∀ x∈K, ∀ v : Phase n,
      defectEnergy (A x) v≤C*symplecticEnergy (A x) v := by
  obtain ⟨B,hB,hbound⟩ := energyRatio_bounded_on_sphere hK hAc hA
  exact ⟨B,hB,fun x hx v => energyRatio_extend_from_sphere (hbound x hx) v⟩

end HigherDimensionalBallPacking.Rigidity

end
noncomputable section
open scoped ContDiff Topology
open Set Function Filter MeasureTheory
open SymplecticBallPacking.Hamiltonian
namespace HigherDimensionalBallPacking.Rigidity

lemma outerProfile_one_before {A t : ℝ} (ht : 0≤t) (htA : t≤A) (hA : 0<A) :
    outerProfile A t=1 := by
  have h1 : 1≤t+2 := by linarith
  have h2 : (t-A)/A≤0 := div_nonpos_of_nonpos_of_nonneg (sub_nonpos.mpr htA) hA.le
  simp only [outerProfile,Real.smoothTransition.one_of_one_le h1,
    Real.smoothTransition.zero_of_nonpos h2,sub_zero,mul_one]

lemma radiusSq_pos_bound_of_compact {K : Set Plane} (hK : IsCompact K) :
    ∃ A : ℝ, 0<A ∧ ∀ z∈K, radiusSq z<A := by
  obtain ⟨B,hB,hb⟩ := (hK.image radiusSq_smooth.continuous).isBounded.exists_pos_norm_le
  refine ⟨B+1,by linarith,?_⟩
  intro z hz
  have hh := hb (radiusSq z) ⟨z,hz,rfl⟩
  rw [Real.norm_eq_abs,abs_of_nonneg (radiusSq_nonneg z)] at hh
  linarith

lemma integral_compact_le_infinity_flux {β : Plane → Plane →L[ℝ] ℝ}
    (hβ : ContDiff ℝ ∞ β) (hcurl : ∀ z, 0≤planarCurl β z) {k : ℝ}
    (hlim : Tendsto (fun z => β z (planeRotation z)) (cocompact Plane) (𝓝 k))
    {e : Plane → ℝ} (he : Continuous e) (hc : HasCompactSupport e)
    (hle : ∀ z, e z≤planarCurl β z) : (∫ z, e z)≤2*Real.pi*k := by
  apply le_of_forall_pos_le_add
  intro ε hε
  have hp : 0<2*Real.pi := by positivity
  have heps : k<k+ε/(2*Real.pi) := lt_add_of_pos_right _ (div_pos hε hp)
  have hev : ∀ᶠ z in cocompact Plane, β z (planeRotation z)≤k+ε/(2*Real.pi) :=
    (hlim.eventually (eventually_lt_nhds heps)).mono fun _ h => h.le
  obtain ⟨K,hK,hKb⟩ := mem_cocompact.mp hev
  obtain ⟨A,hA,hbound⟩ := radiusSq_pos_bound_of_compact (hK.union hc)
  let g := outerProfile A
  have hg : ContDiff ℝ ∞ g := outerProfile_smooth A
  have hgc : HasCompactSupport g := outerProfile_compact hA
  have hdom (z : Plane) : e z≤g (radiusSq z)*planarCurl β z := by
    by_cases hz : z∈tsupport e
    · have hga : g (radiusSq z)=1 :=
        outerProfile_one_before (radiusSq_nonneg z) (hbound z (Or.inr hz)).le hA
      rw [hga,one_mul]
      exact hle z
    · rw [image_eq_zero_of_notMem_tsupport hz]
      exact mul_nonneg (outerProfile_nonneg A _) (hcurl z)
  have hcomp (z : Plane) :
      2*deriv g (radiusSq z)*(k+ε/(2*Real.pi))≤
        cutoffWedge (fun y => g (radiusSq y)) β z := by
    rw [cutoffWedge_radial_rotation hg]
    by_cases hd : deriv g (radiusSq z)=0
    · simp only [hd,mul_zero,zero_mul,le_refl]
    have hzA : A≤radiusSq z := by
      by_contra! h
      exact hd (outerProfile_deriv_zero_before hA (radiusSq_nonneg z) h)
    have hzK : z∉K := by
      intro hz
      exact (not_lt_of_ge hzA) (hbound z (Or.inl hz))
    exact mul_le_mul_of_nonpos_left (hKb hzK)
      (mul_nonpos_of_nonneg_of_nonpos (by norm_num) (outerProfile_deriv_nonpos hA (radiusSq_nonneg z)))
  have hdi : Integrable (fun z : Plane => 2*deriv g (radiusSq z)*(k+ε/(2*Real.pi))) :=
    ((((hg.continuous_deriv (by simp)).comp radiusSq_smooth.continuous).integrable_of_hasCompactSupport
      (HasCompactSupport.comp_radiusSq hgc.deriv)).const_mul 2).mul_const _
  have hwi := cutoffWedge_integrable (hg.comp radiusSq_smooth) (HasCompactSupport.comp_radiusSq hgc) hβ
  have hgi : Integrable (fun z => g (radiusSq z)*planarCurl β z) :=
    ((hg.continuous.comp radiusSq_smooth.continuous).mul
      (planarCurl_contDiff hβ).continuous).integrable_of_hasCompactSupport
        ((HasCompactSupport.comp_radiusSq hgc).mul_right)
  have hmass := integral_mono (he.integrable_of_hasCompactSupport hc) hgi hdom
  have hflux := integral_mono hdi hwi hcomp
  have hg0 : g 0=1 := outerProfile_zero_value hA
  rw [integral_mul_const,integral_radial_derivative hg hgc,hg0,mul_one] at hflux
  rw [integral_cutoffWedge (hg.comp radiusSq_smooth) (HasCompactSupport.comp_radiusSq hgc) hβ] at hflux
  dsimp only [Function.comp_def] at hflux
  have heq : (2*Real.pi)*(k+ε/(2*Real.pi))=2*Real.pi*k+ε := by
    field_simp
  nlinarith only [hmass,hflux,heq]

theorem AffineLineCurve.compact_density_mass_le_one {n : ℕ} {J : Phase n → End n}
    (hJ : ∀ x, Compatible (J x))
    (hJc : HasCompactSupport (fun x => J x-standardJ n))
    {S T : ℝ} (hST : S<T) (hT : T<1)
    (hout : ∀ x, S<capacity x → J x=standardJ n)
    {p q : Phase n} {u : ℂ → Phase n} (hu : AffineLineCurve J p q u)
    {e : Plane → ℝ} (he : Continuous e) (hc : HasCompactSupport e)
    (hle : ∀ z, e z≤curveDensity S T u z) : (∫ z, e z)≤1 := by
  have hh := integral_compact_le_infinity_flux (curvePrimitive_smooth hST hu.1)
    (fun z => (curvePrimitive_curl hST hu.1 z).symm ▸ curveDensity_nonneg hST hT hJ hout hu.2.1 z)
    (hu.radial_infinity_limit hJc hST) he hc
    (fun z => (curvePrimitive_curl hST hu.1 z).symm ▸ hle z)
  have heq : 2*Real.pi*(1/(2*Real.pi))=1 := by field_simp
  exact heq ▸ hh

end HigherDimensionalBallPacking.Rigidity

end
noncomputable section
open scoped Topology
open Set Filter
namespace HigherDimensionalBallPacking.Rigidity.HolderCompletion
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E] [CompleteSpace E]

lemma entire_affine_of_asymptote {f : ℂ → E} (hf : Differentiable ℂ f) {a : E}
    (ha : Tendsto (fun z : ℂ => z⁻¹ • f z) (cocompact ℂ) (𝓝 a)) (z : ℂ) :
    f z=f 0+z • a := by
  have hs : Differentiable ℂ (dslope f 0) :=
    differentiableOn_univ.mp ((Complex.differentiableOn_dslope (s := univ) (c := (0:ℂ))
      univ_mem).mpr hf.differentiableOn)
  have hi : Tendsto (fun w : ℂ => w⁻¹) (cocompact ℂ) (𝓝 0) := by
    simpa only [←Metric.cobounded_eq_cocompact] using (tendsto_inv₀_cobounded (α := ℂ))
  have ht : Tendsto (dslope f 0) (cocompact ℂ) (𝓝 a) := by
    have hsub := ha.sub (hi.smul_const (f 0))
    simp only [zero_smul,sub_zero] at hsub
    apply hsub.congr'
    filter_upwards [(isCompact_singleton (x := (0:ℂ))).compl_mem_cocompact] with w hw
    have hw0 : w≠0 := by simpa only [mem_compl_iff,mem_singleton_iff] using hw
    rw [dslope_of_ne f hw0,slope_def_module,sub_zero,smul_sub]
  have hvalue := sub_smul_dslope f 0 z
  rw [sub_zero,hs.apply_eq_of_tendsto_cocompact z ht] at hvalue
  exact (sub_eq_iff_eq_add.mp hvalue.symm).trans (add_comm _ _)

end HigherDimensionalBallPacking.Rigidity.HolderCompletion

end
noncomputable section
open scoped ContDiff Topology BoundedContinuousFunction
open Set Filter
namespace HigherDimensionalBallPacking.Rigidity.HolderCompletion
variable {D E : Type*} [NormedAddCommGroup D] [NormedSpace ℝ D]
  [NormedAddCommGroup E] [NormedSpace ℝ E]
local instance transInst1 : NormedAddCommGroup (HMap D E) := inferInstance
local instance transInst2 : NormedSpace ℝ (HMap D E) := inferInstance
local instance transInst3 : NormedAddCommGroup (COne D E) := inferInstance
local instance transInst4 : NormedSpace ℝ (COne D E) := inferInstance

def holderTranslate (t : D) (u : HMap D E) : HMap D E :=
  ofBound (fun z => valueCLM _ u (z+t))
    ((valueCLM _ u).continuous.comp (continuous_id.add continuous_const))
    ‖u‖ ‖u‖ (fun z => norm_value_le u _) (norm_nonneg u) (by
      intro x y
      simpa only [dist_add_right] using norm_sub_value_le u (x+t) (y+t))

omit [NormedSpace ℝ D] in
@[simp] lemma holderTranslate_value [NormedSpace ℝ D] (t : D) (u : HMap D E) (z : D) :
    valueCLM _ (holderTranslate t u) z = valueCLM _ u (z+t) := rfl

omit [NormedSpace ℝ D] in
lemma holderTranslate_norm_le [NormedSpace ℝ D] (t : D) (u : HMap D E) : ‖holderTranslate t u‖ ≤ ‖u‖ := by
  apply (norm_le_of_bounds _ (norm_nonneg u) (norm_nonneg u) ?_ ?_).trans (max_self _).le
  · intro z; exact norm_value_le u _
  · intro x y
    simpa only [holderTranslate_value,dist_add_right] using norm_sub_value_le u (x+t) (y+t)

def jetTranslate (t : D) (u : COne D E) : COne D E :=
  ⟨(holderTranslate t (jetValueCLM _ u),holderTranslate t (jetDerivCLM _ u)),by
    intro z
    have h := (c_hasFDerivAt u (z+t)).comp z ((hasFDerivAt_id z).add_const t)
    change HasFDerivAt (fun x => cValue u (x+t)) (cDeriv u (z+t)) z
    simpa only [ContinuousLinearMap.comp_id,Function.comp_def,id_eq] using h⟩

@[simp] lemma jetTranslate_value (t : D) (u : COne D E) (z : D) :
    cValue (jetTranslate t u) z = cValue u (z+t) := rfl

@[simp] lemma jetTranslate_deriv (t : D) (u : COne D E) (z : D) :
    cDeriv (jetTranslate t u) z = cDeriv u (z+t) := rfl

lemma jetTranslate_norm_le (t : D) (u : COne D E) : ‖jetTranslate t u‖ ≤ ‖u‖ := by
  change max ‖holderTranslate t (jetValueCLM _ u)‖ ‖holderTranslate t (jetDerivCLM _ u)‖ ≤ _
  exact max_le ((holderTranslate_norm_le _ _).trans (jetValue_norm_le u))
    ((holderTranslate_norm_le _ _).trans (jetDeriv_norm_le u))

lemma cValue_norm_diff_le (u : COne D E) (x y : D) :
    ‖cValue u x-cValue u y‖ ≤ ‖u‖*dist x y := by
  rw [dist_eq_norm]
  exact norm_sub_le_of_deriv_bound (c_differentiable u)
    (fun z => by rw [c_fderiv]; exact c_deriv_bound u z) x y

lemma translate_value_norm (u : COne D E) (t z : D) :
    ‖valueCLM _ (holderTranslate t (jetValueCLM _ u)-jetValueCLM _ u) z‖ ≤ ‖u‖*‖t‖ := by
  change ‖cValue u (z+t)-cValue u z‖ ≤ _
  simpa only [dist_eq_norm,add_sub_cancel_left] using cValue_norm_diff_le u (z+t) z

lemma translate_value_lipschitz (u : COne D E) (t x y : D) :
    ‖valueCLM _ (holderTranslate t (jetValueCLM _ u)-jetValueCLM _ u) x-
      valueCLM _ (holderTranslate t (jetValueCLM _ u)-jetValueCLM _ u) y‖ ≤ 2*‖u‖*dist x y := by
  change ‖(cValue u (x+t)-cValue u x)-(cValue u (y+t)-cValue u y)‖ ≤ _
  rw [show (cValue u (x+t)-cValue u x)-(cValue u (y+t)-cValue u y) =
    (cValue u (x+t)-cValue u (y+t))-(cValue u x-cValue u y) by abel]
  have h₁ := cValue_norm_diff_le u (x+t) (y+t)
  rw [dist_add_right] at h₁
  exact (norm_sub_le _ _).trans (by linarith [cValue_norm_diff_le u x y])

lemma jetValue_translate_tendsto (u : COne D E) :
    Tendsto (fun t => holderTranslate t (jetValueCLM _ u)) (𝓝 0) (𝓝 (jetValueCLM _ u)) := by
  apply Metric.tendsto_nhds.mpr
  intro ε hε
  obtain ⟨δ,hδ,hd⟩ := holder_small_of_small_value (X := D) (E := E)
    (show 0 ≤ 2*‖u‖ by positivity) hε
  have ht : Tendsto (fun t : D => ‖u‖*‖t‖) (𝓝 0) (𝓝 0) := by
    have h : Continuous (fun t : D => ‖u‖*‖t‖) := continuous_const.mul continuous_norm
    simpa only [norm_zero,mul_zero] using h.tendsto (0:D)
  filter_upwards [ht.eventually (gt_mem_nhds hδ)] with t ht
  rw [dist_eq_norm]
  exact hd _ (fun z => (translate_value_norm u t z).trans ht.le) (translate_value_lipschitz u t)

end HigherDimensionalBallPacking.Rigidity.HolderCompletion

end

end OAI