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