Blame for lean/OAI/Geometry/BallPacking/Necessity/FiniteReduction.lean

import Mathlib
import OAI.Geometry.BallPacking.Fredholm.CompactFredholmAlternative
import OAI.Geometry.BallPacking.Necessity.LocalCharts

namespace OAI

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

open scoped ContDiff Topology BoundedContinuousFunction
open Set Function Filter
namespace HigherDimensionalBallPacking.Rigidity
section
variable {E : Type} [NormedAddCommGroup E] [NormedSpace ℂ E] [CompleteSpace E]
  [FiniteDimensional ℂ E]
local instance finiteReductionInst1 : NormedAddCommGroup (HolderSpace ℂ E ((1:ℝ)/3)) := inferInstance
local instance finiteReductionInst2 : NormedSpace ℝ (HolderSpace ℂ E ((1:ℝ)/3)) := inferInstance
local instance finiteReductionInst3 : NormedAddCommGroup (HolderSpace ℂ (E →L[ℝ] E) ((1:ℝ)/3)) := inferInstance
local instance finiteReductionInst4 : NormedSpace ℝ (HolderSpace ℂ (E →L[ℝ] E) ((1:ℝ)/3)) := inferInstance
local instance finiteReductionInst5 (R : ℝ) : NormedAddCommGroup (CompactHolderSpace E R) := inferInstance
local instance finiteReductionInst6 (R : ℝ) : NormedSpace ℝ (CompactHolderSpace E R) := inferInstance

 

def compactHolderMul (R : ℝ) (A : HolderSpace ℂ (E →L[ℝ] E) ((1:ℝ)/3)) :
    CompactHolderSpace E R →L[ℝ] CompactHolderSpace E R :=
  ((holderCLM ((1:ℝ)/3) A).comp (compactHolderSubmodule R).subtypeL).codRestrict
    (compactHolderSubmodule R) (by
      intro g z hz
      change holderValue ((1:ℝ)/3) A z (holderValue ((1:ℝ)/3) g.val z)=0
      rw [g.property z hz,map_zero])

omit [CompleteSpace E] [FiniteDimensional ℂ E] in
@[simp] lemma compactHolderMul_value (R : ℝ)
    (A : HolderSpace ℂ (E →L[ℝ] E) ((1:ℝ)/3)) (g : CompactHolderSpace E R) (z : ℂ) :
    compactHolderValue R (compactHolderMul R A g) z =
      holderValue ((1:ℝ)/3) A z (compactHolderValue R g z) := rfl

lemma frameInverse_smooth {η : E → E →L[ℝ] E →L[ℝ] ℝ}
    {B : E →L[ℝ] E} {J : E → E →L[ℝ] E} {u : ℂ → E}
    (hB : ∀ x, CompatibleWith (η x) B) (hJc : ∀ x, CompatibleWith (η x) (J x))
    (hJ : ContDiff ℝ ∞ J) (hu : ContDiff ℝ ∞ u) :
    ContDiff ℝ ∞ (fun z => (crFrame B J u z).inverse) := by
  apply contDiff_iff_contDiffAt.mpr
  intro z
  exact (crFrame_invertible hB hJc u z).contDiffAt_map_inverse.comp z
    (crFrame_smooth hJ hu).contDiffAt

omit [CompleteSpace E] in
lemma frameInverse_compact_difference {η : E → E →L[ℝ] E →L[ℝ] ℝ}
    {B : E →L[ℝ] E} {J : E → E →L[ℝ] E} {u : ℂ → E}
    (hB : ∀ x, CompatibleWith (η x) B) (hJc : ∀ x, CompatibleWith (η x) (J x))
    (hc : HasCompactSupport (fun x => J x-B)) (hup : IsProperMap u) :
    HasCompactSupport (fun z => (crFrame B J u z).inverse-
      (1/2:ℝ) • ContinuousLinearMap.id ℝ E) := by
  have hh := crFrame_compact_difference (hB 0).1 hc hup
  rw [hasCompactSupport_iff_eventuallyEq] at hh ⊢
  filter_upwards [hh] with z hz
  have hA : crFrame B J u z=2 • ContinuousLinearMap.id ℝ E := sub_eq_zero.mp hz
  apply sub_eq_zero.mpr
  ext v
  have hv : crFrame B J u z ((1/2:ℝ) • v)=v := by
    rw [hA]
    simp only [smul_apply,ContinuousLinearMap.id_apply]
    module
  have hd := (crFrame_invertible hB hJc u z).inverse_apply_self ((1/2:ℝ) • v)
  rw [hv] at hd
  exact hd

 

def inverseFrameHolder {η : E → E →L[ℝ] E →L[ℝ] ℝ}
    {B : E →L[ℝ] E} {J : E → E →L[ℝ] E} {u : ℂ → E}
    (hB : ∀ x, CompatibleWith (η x) B) (hJc : ∀ x, CompatibleWith (η x) (J x))
    (hJ : ContDiff ℝ ∞ J) (hu : ContDiff ℝ ∞ u)
    (hc : HasCompactSupport (fun x => J x-B)) (hup : IsProperMap u) :
    HolderSpace ℂ (E →L[ℝ] E) ((1:ℝ)/3) :=
  holderConst ((1:ℝ)/3) ((1/2:ℝ) • ContinuousLinearMap.id ℝ E)+
    smoothHolderField (fun z => (crFrame B J u z).inverse-(1/2:ℝ) • ContinuousLinearMap.id ℝ E)
      ((frameInverse_smooth hB hJc hJ hu).sub contDiff_const)
      (frameInverse_compact_difference hB hJc hc hup)

@[simp] lemma inverseFrameHolder_value {η : E → E →L[ℝ] E →L[ℝ] ℝ}
    {B : E →L[ℝ] E} {J : E → E →L[ℝ] E} {u : ℂ → E}
    (hB : ∀ x, CompatibleWith (η x) B) (hJc : ∀ x, CompatibleWith (η x) (J x))
    (hJ : ContDiff ℝ ∞ J) (hu : ContDiff ℝ ∞ u)
    (hc : HasCompactSupport (fun x => J x-B)) (hup : IsProperMap u) (z : ℂ) :
    holderValue ((1:ℝ)/3) (inverseFrameHolder hB hJc hJ hu hc hup) z =
      (crFrame B J u z).inverse := by
  simp only [inverseFrameHolder,map_add,BoundedContinuousFunction.add_apply,
    smoothHolderField_value]
  change (1/2:ℝ) • ContinuousLinearMap.id ℝ E+
    ((crFrame B J u z).inverse-(1/2:ℝ) • ContinuousLinearMap.id ℝ E)=_
  abel

end

open scoped ContDiff Topology BoundedContinuousFunction
open Set Function Filter
section
variable {E : Type} [NormedAddCommGroup E] [NormedSpace ℂ E] [CompleteSpace E]
  [FiniteDimensional ℂ E]
local instance finiteReductionInst7 (α : ℝ) : NormedAddCommGroup (HolderSpace ℂ E α) := inferInstance
local instance finiteReductionInst8 (α : ℝ) : NormedSpace ℝ (HolderSpace ℂ E α) := inferInstance
local instance finiteReductionInst9 (α : ℝ) : NormedAddCommGroup (C1HolderSpace E α) := inferInstance
local instance finiteReductionInst10 (α : ℝ) : NormedSpace ℝ (C1HolderSpace E α) := inferInstance
local instance finiteReductionInst11 (R : ℝ) : NormedAddCommGroup (CompactHolderSpace E R) := inferInstance
local instance finiteReductionInst12 (R : ℝ) : NormedSpace ℝ (CompactHolderSpace E R) := inferInstance

 

theorem exists_normalized_nonlinear_chart
    {η : E → E →L[ℝ] E →L[ℝ] ℝ} {J : E → E →L[ℝ] E}
    (hB : ∀ x, CompatibleWith (η x) ((ContinuousLinearMap.lsmul ℝ ℂ) Complex.I))
    (hJc : ∀ x, CompatibleWith (η x) (J x)) (hJ : ContDiff ℝ ∞ J)
    (hc : HasCompactSupport (fun x => J x-(ContinuousLinearMap.lsmul ℝ ℂ) Complex.I))
    (p : (E × (ℂ →L[ℝ] E)) × C1HolderSpace E ((1:ℝ)/3))
    (hu : ContDiff ℝ ∞ (c1HolderAffineCurve ((1:ℝ)/3) p.1.1 p.1.2 p.2))
    (hup : IsProperMap (c1HolderAffineCurve ((1:ℝ)/3) p.1.1 p.1.2 p.2))
    (m : ℝ) (hm : 0 < m) (hA : ∀ z, m*‖z‖ ≤ ‖p.1.2 z‖)
    (hsol : ∀ z, crOperator J (c1HolderAffineCurve ((1:ℝ)/3) p.1.1 p.1.2 p.2) z=0) :
    let u := c1HolderAffineCurve ((1:ℝ)/3) p.1.1 p.1.2 p.2
    let B : E →L[ℝ] E := (ContinuousLinearMap.lsmul ℝ ℂ) Complex.I
    ∃ S : ℝ, 0 < S ∧ (∀ z : ℂ, S < ‖z‖ → normalizedFrameCoefficient B J u z=0) ∧
      ∀ R : ℝ, S ≤ R → ∃ F : CompactHolderSpace E R → CompactHolderSpace E R,
        ContDiffAt ℝ ∞ F 0 ∧ F 0=0 ∧ (fderiv ℝ F 0).IsFredholm ∧
        (∀ᶠ g in 𝓝 (0 : CompactHolderSpace E R), ∀ z,
          compactHolderValue R (F g) z=(crFrame B J u z).inverse
            (crOperator J (fun w => u w+framedMarkedVariation J u R g w) z)) ∧
        (∀ g z, compactHolderValue R (fderiv ℝ F 0 g) z=
          compactHolderValue R g z+normalizedFrameCoefficient B J u z (markedCRInverse R g z)) := by
  dsimp only
  let u := c1HolderAffineCurve ((1:ℝ)/3) p.1.1 p.1.2 p.2
  let B : E →L[ℝ] E := (ContinuousLinearMap.lsmul ℝ ℂ) Complex.I
  let Ainf : E →L[ℝ] E := 2 • ContinuousLinearMap.id ℝ E
  let P := fun z => crFrame B J u z-Ainf
  have hP : ContDiff ℝ ∞ P := (crFrame_smooth hJ hu).sub contDiff_const
  have hPc : HasCompactSupport P := crFrame_compact_difference (hB 0).1 hc hup
  have hAinf : ∀ v, Ainf (Complex.I • v)=Complex.I • Ainf v := by
    intro v
    simp only [Ainf,two_smul,add_apply,ContinuousLinearMap.id_apply,smul_add]
  have hPF (w : ℂ) : Ainf+P w=crFrame B J u w := by dsimp only [P]; abel
  obtain ⟨S₀,hS₀,hS₀R⟩ := compactMarkedCR_local_chart Ainf hAinf P hP hPc J hJ hc p m hm hA hsol
  let M := normalizedFrameCoefficient B J u
  have hMs : ContDiff ℝ ∞ M := normalizedFrameCoefficient_smooth hB hJc hJ hu
  have hMc : HasCompactSupport M := normalizedFrameCoefficient_compact (hB 0).1 hc hup
  obtain ⟨S₁,hS₁,hM₁⟩ := compactCoefficient_zero_outside hMc
  let S := max S₀ S₁
  have hM : ∀ z : ℂ, S < ‖z‖ → M z=0 := fun z hz =>
    hM₁ z ((le_max_right _ _).trans hz.le)
  refine ⟨S,lt_of_lt_of_le hS₀ (le_max_left _ _),hM,?_⟩
  intro R hR
  obtain ⟨hC,hCe,hCD⟩ := hS₀R R ((le_max_left _ _).trans hR)
  let C := compactMarkedCR R Ainf P hP hPc J hJ hc p
  let U := compactHolderMul R (inverseFrameHolder hB hJc hJ hu hc hup)
  let F := U ∘ C
  have hFs : ContDiffAt ℝ ∞ F 0 := U.contDiff.contDiffAt.comp 0 hC
  have hFD : HasFDerivAt F (U.comp (fderiv ℝ C 0)) 0 :=
    U.hasFDerivAt.comp 0 (hC.differentiableAt (by simp)).hasFDerivAt
  have hMv : ∀ z : ℂ, R < ‖z‖ → M z=0 := fun z hz => hM z (lt_of_le_of_lt hR hz)
  let T := markedCRLinear R M hMs hMc hMv
  have hDF : fderiv ℝ F 0=T := by
    rw [hFD.fderiv]
    apply ContinuousLinearMap.ext
    intro g
    apply Subtype.ext
    apply holderValue_injective ((1:ℝ)/3)
    ext z
    change compactHolderValue R (U (fderiv ℝ C 0 g)) z=compactHolderValue R (T g) z
    rw [compactHolderMul_value,inverseFrameHolder_value,hCD g z]
    simp only [hPF]
    rw [linearizedCR_normalizedFrame hB hJc
      ((crFrame_smooth hJ hu).differentiable (by simp))
      (markedCRInverse_differentiable R g) z,
      (crFrame_invertible hB hJc u z).inverse_apply_self]
    symm
    exact markedCRLinear_differential R M hMs hMc hMv g z
  have hFe : ∀ᶠ g in 𝓝 (0 : CompactHolderSpace E R), ∀ z,
      compactHolderValue R (F g) z=(crFrame B J u z).inverse
        (crOperator J (fun w => u w+framedMarkedVariation J u R g w) z) := by
    filter_upwards [hCe] with g hg
    intro z
    change compactHolderValue R (U (C g)) z=_
    rw [compactHolderMul_value,inverseFrameHolder_value,hg z]
    simp only [hPF]
    rfl
  have hF0 : F 0=0 := by
    apply Subtype.ext
    apply holderValue_injective ((1:ℝ)/3)
    ext z
    change compactHolderValue R (F 0) z=0
    rw [hFe.self_of_nhds z]
    have he : (fun w => u w+framedMarkedVariation J u R 0 w)=u := by
      funext w
      simp only [framedMarkedVariation,markedCRInverse,compactCRInverseValue,map_zero,
        BoundedContinuousFunction.coe_zero,Pi.zero_apply,sub_self,smul_zero,add_zero]
    rw [he,hsol z,map_zero]
  refine ⟨F,hFs,hF0,?_,hFe,?_⟩
  · rw [hDF]
    exact markedCRLinear_fredholm R M hMs hMc hMv
  · intro g z
    rw [hDF]
    change compactHolderValue R (markedCRLinear R M hMs hMc hMv g) z=_
    change compactHolderValue R g z+compactHolderValue R (markedCRLower R M hMs hMc hMv g) z=_
    rw [markedCRLower_value]

end
 

open scoped ContDiff Topology
open Set Function Filter

open scoped ContDiff Topology BoundedContinuousFunction
open Set Function Filter

 

theorem AffineLineCurve.exists_holder_profile {n : ℕ} {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)) :
    ∃ (b v : Phase n) (h : C1HolderSpace (Phase n) ((1:ℝ)/3)), v ≠ 0 ∧
      u = c1HolderAffineCurve ((1:ℝ)/3) b
        (((ContinuousLinearMap.id ℂ ℂ).smulRight v).restrictScalars ℝ) h := by
  obtain ⟨v,hv,hlim⟩ := hu.2.2.2.2
  let V := infinityGerm u v
  have hV : AnalyticAt ℂ V 0 := infinityGerm_analyticAt (hu.holomorphic_at_infinity hJc) hlim
  have hV0 : V 0=v := by simp [V,infinityGerm]
  have hi : Tendsto (fun z : ℂ => z⁻¹) (cocompact ℂ) (𝓝[≠] (0:ℂ)) := by
    rw [←Metric.cobounded_eq_cocompact]
    exact tendsto_inv₀_cobounded'
  have hconst : Tendsto (fun z => u z-z • v) (cocompact ℂ) (𝓝 (deriv V 0)) := by
    have hd := hV.differentiableAt.hasDerivAt.tendsto_slope.comp hi
    apply hd.congr'
    filter_upwards [(isCompact_singleton (x := (0:ℂ))).compl_mem_cocompact] with z hz
    have hz0 : z ≠ 0 := by simpa using hz
    simp only [Function.comp_apply,slope_def_module,sub_zero,inv_inv,hV0]
    simp only [V,infinityGerm,inv_ne_zero hz0,ite_false,inv_inv,smul_sub,smul_smul,
      mul_inv_cancel₀ hz0,one_smul]
  let g := crOperator (fun _ => standardJ n) u
  have hgs : ContDiff ℝ ∞ g := by
    have hd := hu.1.fderiv_right (show (∞ : WithTop ℕ∞)+1≤∞ by simp)
    exact (hd.clm_apply contDiff_const).sub
      (contDiff_const.clm_apply (hd.clm_apply contDiff_const))
  have hgc : HasCompactSupport g := by
    rw [hasCompactSupport_iff_eventuallyEq,coclosedCompact_eq_cocompact]
    filter_upwards [hu.holomorphic_at_infinity hJc] with z hz
    exact sub_eq_zero.mpr (differentiableAt_complex_iff_differentiableAt_real.mp hz).2
  obtain ⟨R,hR,hgR⟩ := compactCoefficient_zero_outside hgc
  let G : CompactHolderSpace (Phase n) R :=
    ⟨compactSmoothHolder ((1:ℝ)/3) (by positivity) (by norm_num) g hgs hgc,
      fun z hz => hgR z hz.le⟩
  have hG (z : ℂ) : compactHolderValue R G z=g z := rfl
  let h := compactCRInverse R G
  let f := compactCRInverseValue R G
  have hf : Differentiable ℝ f := (compactCRInverse_contDiff R G).differentiable (by simp)
  have hholo : Differentiable ℂ (fun z => u z-f z) := by
    intro z
    have hd := ((hu.1.differentiable (by simp) z).hasFDerivAt).sub ((hf z).hasFDerivAt)
    apply differentiableAt_complex_iff_differentiableAt_real.mpr
    refine ⟨hd.differentiableAt,?_⟩
    change fderiv ℝ (u-(f : ℂ → Phase n)) z Complex.I =
      Complex.I • fderiv ℝ (u-(f : ℂ → Phase n)) z 1
    rw [hd.fderiv]
    simp only [sub_apply,smul_sub]
    have he := compactCRInverse_rightInverse R G z
    rw [hG] at he
    change fderiv ℝ f z Complex.I-Complex.I • fderiv ℝ f z 1 =
      fderiv ℝ u z Complex.I-Complex.I • fderiv ℝ u z 1 at he
    exact sub_eq_sub_iff_sub_eq_sub.mp he.symm
  have hl : Tendsto (fun z => (u z-f z)-z • v) (cocompact ℂ) (𝓝 (deriv V 0)) := by
    have ht := hconst.sub (compactCRInverse_tendsto_zero R G)
    simpa only [sub_zero,sub_right_comm] using ht
  have he (z : ℂ) : (u z-f z)-z • v=deriv V 0 :=
    (hholo.sub (differentiable_id.smul_const v)).apply_eq_of_tendsto_cocompact z hl
  refine ⟨deriv V 0,v,h,hv,?_⟩
  funext z
  change u z=deriv V 0+z • v+f z
  rw [←he z]
  abel


open scoped ContDiff Topology BoundedContinuousFunction
open Set Function Filter
section
local instance finiteReductionInst13 (n : ℕ) (R : ℝ) : NormedAddCommGroup (CompactHolderSpace (Phase n) R) := inferInstance
local instance finiteReductionInst14 (n : ℕ) (R : ℝ) : NormedSpace ℝ (CompactHolderSpace (Phase n) R) := inferInstance

 

theorem AffineLineCurve.exists_nonlinear_fredholm_section {n : ℕ}
    {η : Phase n → Phase n →L[ℝ] Phase n →L[ℝ] ℝ} {J : Phase n → End n}
    (hB : ∀ x, CompatibleWith (η x) (standardJ n))
    (hJc : ∀ x, CompatibleWith (η x) (J x)) (hJ : ContDiff ℝ ∞ J)
    (hc : HasCompactSupport (fun x => J x-standardJ n))
    {p q : Phase n} {u : ℂ → Phase n} (hu : AffineLineCurve J p q u) :
    ∃ S : ℝ, 0 < S ∧
      (∀ z : ℂ, S < ‖z‖ → normalizedFrameCoefficient (standardJ n) J u z=0) ∧
      ∀ R : ℝ, S ≤ R → ∃ F : CompactHolderSpace (Phase n) R → CompactHolderSpace (Phase n) R,
        ContDiffAt ℝ ∞ F 0 ∧ F 0=0 ∧ (fderiv ℝ F 0).IsFredholm ∧
        (∀ᶠ g in 𝓝 (0 : CompactHolderSpace (Phase n) R), ∀ z,
          compactHolderValue R (F g) z=(crFrame (standardJ n) J u z).inverse
            (crOperator J (fun w => u w+framedMarkedVariation J u R g w) z)) ∧
        (∀ g z, compactHolderValue R (fderiv ℝ F 0 g) z=
          compactHolderValue R g z+normalizedFrameCoefficient (standardJ n) J u z (markedCRInverse R g z)) := by
  obtain ⟨b,v,h,hv,he⟩ := hu.exists_holder_profile hc
  let A := ((ContinuousLinearMap.id ℂ ℂ).smulRight v).restrictScalars ℝ
  let P : (Phase n × (ℂ →L[ℝ] Phase n)) × C1HolderSpace (Phase n) ((1:ℝ)/3) := ((b,A),h)
  have hA (z : ℂ) : ‖v‖*‖z‖≤‖A z‖ := by
    change ‖v‖*‖z‖≤‖z • v‖
    rw [norm_smul,mul_comm]
  have hs (z : ℂ) : crOperator J u z=0 := by
    have hh := (hu.2.1 z).2 1
    simp only [mul_one] at hh
    exact sub_eq_zero.mpr hh
  have hu' : u=c1HolderAffineCurve ((1:ℝ)/3) P.1.1 P.1.2 P.2 := he
  have hh := exists_normalized_nonlinear_chart hB hJc hJ hc P
    (hu' ▸ hu.1) (hu' ▸ hu.isProperMap) ‖v‖ (norm_pos_iff.mpr hv) hA (hu' ▸ hs)
  simpa only [←hu',standardJ] using hh

 

theorem local_section_zero_iff {n : ℕ}
    {η : Phase n → Phase n →L[ℝ] Phase n →L[ℝ] ℝ} {J : Phase n → End n}
    (hB : ∀ x, CompatibleWith (η x) (standardJ n))
    (hJc : ∀ x, CompatibleWith (η x) (J x)) {u : ℂ → Phase n} {R : ℝ}
    {F : CompactHolderSpace (Phase n) R → CompactHolderSpace (Phase n) R}
    {g : CompactHolderSpace (Phase n) R}
    (hF : ∀ z, compactHolderValue R (F g) z=(crFrame (standardJ n) J u z).inverse
      (crOperator J (fun w => u w+framedMarkedVariation J u R g w) z)) :
    F g=0 ↔ ∀ z, crOperator J (fun w => u w+framedMarkedVariation J u R g w) z=0 := by
  constructor
  · intro hg z
    have hh := hF z
    rw [hg,map_zero,BoundedContinuousFunction.coe_zero,Pi.zero_apply] at hh
    have hi := (crFrame_invertible hB hJc u z).self_apply_inverse
      (crOperator J (fun w => u w+framedMarkedVariation J u R g w) z)
    rw [←hh,map_zero] at hi
    exact hi.symm
  · intro hg
    apply Subtype.ext
    apply holderValue_injective ((1:ℝ)/3)
    apply BoundedContinuousFunction.ext
    intro z
    change compactHolderValue R (F g) z=0
    rw [hF z,hg z,map_zero]

end

 

open scoped ContDiff Topology
open Set Function Filter
section
variable {E F : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] [CompleteSpace E]
  [NormedAddCommGroup F] [NormedSpace ℝ F] [CompleteSpace F]
local instance finiteReductionInst15 (S : Submodule ℝ E) : NormedAddCommGroup S := inferInstance
local instance finiteReductionInst16 (S : Submodule ℝ E) : NormedSpace ℝ S := inferInstance
local instance finiteReductionInst17 (S : Submodule ℝ F) : NormedAddCommGroup S := inferInstance
local instance finiteReductionInst18 (S : Submodule ℝ F) : NormedSpace ℝ S := inferInstance
local instance finiteReductionInst19 (S T : Submodule ℝ E) : NormedAddCommGroup (S × T) := inferInstance
local instance finiteReductionInst20 (S T : Submodule ℝ E) : NormedSpace ℝ (S × T) := inferInstance

 

theorem fredholm_local_finite_reduction {f : E → F}
    (hf : ContDiffAt ℝ ∞ f 0) (hf0 : f 0=0)
    (pkg : (fderiv ℝ f 0).FredholmPackage) :
    ∃ (φ : pkg.decDom.X₀ → pkg.decDom.X₁)
      (κ : pkg.decDom.X₀ → pkg.decCodom.X₀),
      ContDiffAt ℝ ∞ φ 0 ∧ φ 0=0 ∧ ContDiffAt ℝ ∞ κ 0 ∧ κ 0=0 ∧
      (∀ᶠ x : pkg.decDom.X₀ in 𝓝 0,
        f ((x : E)+(φ x : E))=0 ↔ κ x=0) ∧
      (∀ᶠ x : E in 𝓝 0,
        f x=0 ↔ ∃ k : pkg.decDom.X₀, x=(k : E)+(φ k : E) ∧ κ k=0) := by
  let : FiniteDimensional ℝ pkg.decDom.X₀ := pkg.decDom.finite_X₀
  let : FiniteDimensional ℝ pkg.decCodom.X₀ := pkg.decCodom.finite_X₀
  let : CompleteSpace pkg.decDom.X₁ := pkg.decDom.isTopCompl.isClosed.completeSpace_coe
  let : CompleteSpace pkg.decCodom.X₁ := pkg.decCodom.isTopCompl.isClosed.completeSpace_coe
  let D : (pkg.decDom.X₀ × pkg.decDom.X₁) ≃L[ℝ] E :=
    Submodule.prodEquivOfIsTopCompl _ _ pkg.decDom.isTopCompl.symm
  let P : F →L[ℝ] pkg.decCodom.X₁ := pkg.decCodom.proj
  let Q : F →L[ℝ] pkg.decCodom.X₀ :=
    pkg.decCodom.X₀.projectionOntoL _ pkg.decCodom.isTopCompl.symm
  let H : pkg.decDom.X₀ × pkg.decDom.X₁ → pkg.decCodom.X₁ := fun v => P (f (D v))
  have hD0 : D 0=0 := map_zero D
  have hH : ContDiffAt ℝ ∞ H 0 :=
    P.contDiff.contDiffAt.comp 0 ((show ContDiffAt ℝ ∞ f (D 0) by simpa using hf).comp 0 D.contDiff.contDiffAt)
  have hH0 : H 0=0 := by simp [H,hf0]
  have hd : HasFDerivAt H (P.comp ((fderiv ℝ f 0).comp D.toContinuousLinearMap)) 0 := by
    simpa only [H,Function.comp_def] using P.hasFDerivAt.comp 0
      ((show HasFDerivAt f (fderiv ℝ f 0) (D 0) by simpa using (hf.differentiableAt (by simp)).hasFDerivAt).comp 0 D.hasFDerivAt)
  have heq : (fderiv ℝ H 0).comp (ContinuousLinearMap.inr ℝ pkg.decDom.X₀ pkg.decDom.X₁)=
      pkg.equiv.toContinuousLinearMap := by
    rw [hd.fderiv]
    apply ContinuousLinearMap.ext
    intro x
    change P (fderiv ℝ f 0 (D (0,x)))=pkg.equiv x
    have hDx : D (0,x)=(x : E) := by simp [D,Submodule.prodEquivOfIsTopCompl_apply]
    have hx : fderiv ℝ f 0 (x : E)=(pkg.equiv x : F) := by
      simpa [FredholmDecomposition.proj] using congrArg (fun A : E →L[ℝ] F => A (x : E)) pkg.eq_equiv
    rw [hDx,hx]
    simp [P,FredholmDecomposition.proj]
  have hi : ((fderiv ℝ H 0).comp
      (ContinuousLinearMap.inr ℝ pkg.decDom.X₀ pkg.decDom.X₁)).IsInvertible := by
    rw [heq]
    exact ContinuousLinearMap.isInvertible_equiv
  let φ := hH.implicitFunction (by simp) hi
  have hφ0 : φ 0=0 := hH.implicitFunction_apply_self (by simp) hi
  have hφ : ContDiffAt ℝ ∞ φ 0 := hH.contDiffAt_implicitFunction (by simp) hi
  let κ : pkg.decDom.X₀ → pkg.decCodom.X₀ := fun k => Q (f (D (k,φ k)))
  have hκ : ContDiffAt ℝ ∞ κ 0 := by
    apply Q.contDiff.contDiffAt.comp 0
    have hfD : ContDiffAt ℝ ∞ f (D (0,φ 0)) := by simpa [hφ0,←Prod.zero_eq_mk] using hf
    exact hfD.comp 0 (D.contDiff.contDiffAt.comp 0 (contDiffAt_id.prodMk hφ))
  have hκ0 : κ 0=0 := by simp [κ,hφ0,←Prod.zero_eq_mk,hf0]
  have hPH : ∀ᶠ k in 𝓝 (0 : pkg.decDom.X₀), H (k,φ k)=0 := by
    simpa only [hH0,Prod.fst_zero] using hH.eventually_apply_implicitFunction (by simp) hi
  have hHe : ∀ᶠ v in 𝓝 (0 : pkg.decDom.X₀ × pkg.decDom.X₁),
      H v=0 ↔ φ v.1=v.2 := by
    simpa only [hH0] using hH.eventually_apply_eq_iff_implicitFunction (by simp) hi
  have hpq (y : F) : y=0 ↔ P y=0 ∧ Q y=0 := by
    let C := (Submodule.prodEquivOfIsTopCompl _ _ pkg.decCodom.isTopCompl).symm
    have hc : C y=(P y,Q y) := by
      simp [C,P,Q,FredholmDecomposition.proj,Submodule.prodEquivOfIsTopCompl_symm_apply]
    constructor
    · rintro rfl; simp
    · intro hy
      apply C.injective
      rw [hc,map_zero,hy.1,hy.2]
      rfl
  have hDe (k : pkg.decDom.X₀) : D (k,φ k)=(k : E)+(φ k : E) := rfl
  refine ⟨φ,κ,hφ,hφ0,hκ,hκ0,?_,?_⟩
  · filter_upwards [hPH] with k hk
    rw [←hDe,hpq]
    change (H (k,φ k)=0 ∧ κ k=0) ↔ κ k=0
    simp [hk]
  · have hDinv : Tendsto D.symm (𝓝 (0:E)) (𝓝 (0 : pkg.decDom.X₀ × pkg.decDom.X₁)) := by
      simpa using D.symm.continuous.tendsto (0:E)
    have hfirst : Tendsto (fun x : E => (D.symm x).1) (𝓝 0) (𝓝 (0 : pkg.decDom.X₀)) :=
      continuous_fst.continuousAt.tendsto.comp hDinv
    filter_upwards [hDinv.eventually hHe,hfirst.eventually hPH] with x hx hxP
    constructor
    · intro hfx
      have hHx : H (D.symm x)=0 := by simp [H,hfx]
      have hes : φ (D.symm x).1=(D.symm x).2 := hx.mp hHx
      refine ⟨(D.symm x).1,?_,?_⟩
      · rw [←hDe,hes]
        exact (D.apply_symm_apply x).symm
      · change Q (f (D ((D.symm x).1,φ (D.symm x).1)))=0
        rw [hes,Prod.mk.eta,ContinuousLinearEquiv.apply_symm_apply,hfx,map_zero]
    · rintro ⟨k,hxk,hκk⟩
      have hc : D.symm x=(k,φ k) := by
        rw [hxk,←hDe,ContinuousLinearEquiv.symm_apply_apply]
      apply (hpq (f x)).mpr
      constructor
      · have hkk : (D.symm x).1=k := congrArg Prod.fst hc
        rw [hkk] at hxP
        simpa only [H,hDe,←hxk] using hxP
      · simpa only [κ,hDe,←hxk] using hκk

end

open scoped ContDiff Topology BoundedContinuousFunction
open Set Function Filter
section
local instance finiteReductionInst21 (n : ℕ) (R : ℝ) : NormedAddCommGroup (CompactHolderSpace (Phase n) R) := inferInstance
local instance finiteReductionInst22 (n : ℕ) (R : ℝ) : NormedSpace ℝ (CompactHolderSpace (Phase n) R) := inferInstance

 

theorem AffineLineCurve.exists_finite_reduction {n : ℕ}
    {η : Phase n → Phase n →L[ℝ] Phase n →L[ℝ] ℝ} {J : Phase n → End n}
    (hB : ∀ x, CompatibleWith (η x) (standardJ n))
    (hJc : ∀ x, CompatibleWith (η x) (J x)) (hJ : ContDiff ℝ ∞ J)
    (hc : HasCompactSupport (fun x => J x-standardJ n))
    {p q : Phase n} {u : ℂ → Phase n} (hu : AffineLineCurve J p q u) :
    ∃ S : ℝ, 0 < S ∧ ∀ R : ℝ, S ≤ R →
      ∃ (F : CompactHolderSpace (Phase n) R → CompactHolderSpace (Phase n) R)
        (pkg : (fderiv ℝ F 0).FredholmPackage)
        (φ : pkg.decDom.X₀ → pkg.decDom.X₁)
        (κ : pkg.decDom.X₀ → pkg.decCodom.X₀),
        ContDiffAt ℝ ∞ F 0 ∧ F 0=0 ∧
        ContDiffAt ℝ ∞ φ 0 ∧ φ 0=0 ∧ ContDiffAt ℝ ∞ κ 0 ∧ κ 0=0 ∧
        (∀ᶠ g : CompactHolderSpace (Phase n) R in 𝓝 0,
          (∀ z, crOperator J (fun w => u w+framedMarkedVariation J u R g w) z=0) ↔
            ∃ k : pkg.decDom.X₀, g=(k : CompactHolderSpace (Phase n) R)+
              (φ k : CompactHolderSpace (Phase n) R) ∧ κ k=0) := by
  obtain ⟨S,hS,hM,hSection⟩ := hu.exists_nonlinear_fredholm_section hB hJc hJ hc
  refine ⟨S,hS,?_⟩
  intro R hR
  obtain ⟨F,hF,hF0,hFred,hFe,hDF⟩ := hSection R hR
  obtain ⟨pkg⟩ := hFred.nonempty_fredholmPackage
  obtain ⟨φ,κ,hφ,hφ0,hκ,hκ0,_,hred⟩ := fredholm_local_finite_reduction hF hF0 pkg
  refine ⟨F,pkg,φ,κ,hF,hF0,hφ,hφ0,hκ,hκ0,?_⟩
  filter_upwards [hFe,hred] with g hg hgr
  exact (local_section_zero_iff hB hJc hg).symm.trans hgr

end

 

 

open Set Function Filter Topology

 

open Set Function

 

open Set Function

 

open Function

 

open Set Function

open scoped ContDiff Topology BoundedContinuousFunction
open Set Function Filter
local instance finiteReductionInst23 (n : ℕ) (R : ℝ) : NormedAddCommGroup (CompactHolderSpace (Phase n) R) := inferInstance
local instance finiteReductionInst24 (n : ℕ) (R : ℝ) : NormedSpace ℝ (CompactHolderSpace (Phase n) R) := inferInstance

 

theorem normalized_section_package_finrank {n : ℕ}
    {η : Phase n → Phase n →L[ℝ] Phase n →L[ℝ] ℝ} {J : Phase n → End n}
    (hB : ∀ x, CompatibleWith (η x) (standardJ n))
    (hJc : ∀ x, CompatibleWith (η x) (J x)) (hJ : ContDiff ℝ ∞ J)
    (hc : HasCompactSupport (fun x => J x-standardJ n))
    {u : ℂ → Phase n} (hu : ContDiff ℝ ∞ u) (hup : IsProperMap u) {R : ℝ}
    (hR : ∀ z : ℂ, R < ‖z‖ → normalizedFrameCoefficient (standardJ n) J u z=0)
    {F : CompactHolderSpace (Phase n) R → CompactHolderSpace (Phase n) R}
    (hDF : ∀ g z, compactHolderValue R (fderiv ℝ F 0 g) z=
      compactHolderValue R g z+normalizedFrameCoefficient (standardJ n) J u z (markedCRInverse R g z))
    (pkg : (fderiv ℝ F 0).FredholmPackage) :
    Module.finrank ℝ pkg.decDom.X₀=Module.finrank ℝ pkg.decCodom.X₀ := by
  let E := CompactHolderSpace (Phase n) R
  let M := normalizedFrameCoefficient (standardJ n) J u
  have hMs : ContDiff ℝ ∞ M := normalizedFrameCoefficient_smooth hB hJc hJ hu
  have hMc : HasCompactSupport M := normalizedFrameCoefficient_compact (hB 0).1 hc hup
  let T : E →L[ℝ] E := markedCRLower R M hMs hMc hR
  have hT : IsCompactOperator T := markedCRLower_compact R M hMs hMc hR
  have he : fderiv ℝ F 0 = ContinuousLinearMap.id ℝ E+T := by
    apply ContinuousLinearMap.ext
    intro g
    apply Subtype.ext
    apply holderValue_injective ((1:ℝ)/3)
    apply BoundedContinuousFunction.ext
    intro z
    change compactHolderValue R (fderiv ℝ F 0 g) z=compactHolderValue R (g+T g) z
    rw [map_add,BoundedContinuousFunction.add_apply,hDF]
    rw [show compactHolderValue R (T g) z=M z (markedCRInverse R g z) from markedCRLower_value R M hMs hMc hR g z]
  have hidx := compactPerturbation_index_zero T hT
  rw [←he,pkg.ker_eq,pkg.range_eq] at hidx
  exact hidx.trans (Submodule.quotientEquivOfIsCompl _ _ pkg.decCodom.isTopCompl.isCompl).finrank_eq

end HigherDimensionalBallPacking.Rigidity

end

namespace ContinuousLinearMap.FredholmPackage
open scoped _root_.ContinuousLinearMap _root_.ContinuousLinearMap.FredholmPackage
-- Preserve the namespace exported by this module.
end ContinuousLinearMap.FredholmPackage

end OAI