| import Mathlib |
| import OAI.Geometry.BallPacking.Holder.MarkedFrame |
|
|
| namespace OAI |
|
|
| noncomputable section |
| namespace HigherDimensionalBallPacking.Rigidity |
|
|
| section |
| open Set Function |
| open scoped LinearMap.FiniteRangeSetoid |
| variable {E F G T : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| [NormedAddCommGroup F] [NormedSpace ℝ F] [NormedAddCommGroup G] [NormedSpace ℝ G] |
| [NormedAddCommGroup T] [NormedSpace ℝ T] [FiniteDimensional ℝ T] |
|
|
| lemma fredholm_comp (A : E →L[ℝ] F) (B : F →L[ℝ] G) (hA : A.IsFredholm) (hB : B.IsFredholm) : |
| (B.comp A).IsFredholm := by |
| obtain ⟨S,hS⟩ := hA.exists_isQuasiInverse |
| obtain ⟨U,hU⟩ := hB.exists_isQuasiInverse |
| exact ContinuousLinearMap.IsFredholm.of_isQuasiInverse (v := S.comp U) (hS.comp hU) |
|
|
| lemma fredholm_snd_finite : (ContinuousLinearMap.snd ℝ T E).IsFredholm := by |
| apply ContinuousLinearMap.IsFredholm.of_isQuasiInverse (v := ContinuousLinearMap.inr ℝ T E) |
| constructor |
| · change (LinearMap.inr ℝ T E ∘ₗ LinearMap.snd ℝ T E) ≈ LinearMap.id |
| apply LinearMap.FiniteRangeSetoid.equiv_iff_hasFiniteRange.mpr |
| have he : (LinearMap.inr ℝ T E ∘ₗ LinearMap.snd ℝ T E)-LinearMap.id = |
| -(LinearMap.inl ℝ T E ∘ₗ LinearMap.fst ℝ T E) := by ext x <;> simp |
| rw [he] |
| exact (LinearMap.HasFiniteRange.of_finite_dom (f := LinearMap.inl ℝ T E)).comp_right _ |>.neg |
| · change (LinearMap.snd ℝ T E ∘ₗ LinearMap.inr ℝ T E) ≈ LinearMap.id |
| simp |
|
|
| lemma fredholm_add_finite (D : E →L[ℝ] F) (hD : D.IsFredholm) (Q : E →L[ℝ] F) |
| (hQ : Q.toLinearMap.HasFiniteRange) : (D+Q).IsFredholm := by |
| obtain ⟨S,hS⟩ := hD.exists_isQuasiInverse |
| apply ContinuousLinearMap.IsFredholm.of_isQuasiInverse (v := S) |
| apply hS.congr (Setoid.refl _) ?_ |
| apply LinearMap.FiniteRangeSetoid.equiv_iff_hasFiniteRange.mpr |
| simpa only [ContinuousLinearMap.toLinearMap_add,add_sub_cancel_left] using hQ |
|
|
| lemma fredholm_finite_extension (D : E →L[ℝ] F) (hD : D.IsFredholm) (Q : T →L[ℝ] F) : |
| (D.comp (ContinuousLinearMap.snd ℝ T E)+Q.comp (ContinuousLinearMap.fst ℝ T E)).IsFredholm := |
| fredholm_add_finite _ (fredholm_comp _ D fredholm_snd_finite hD) _ |
| ((LinearMap.HasFiniteRange.of_finite_dom (f := Q.toLinearMap)).comp_right _) |
|
|
|
|
| end |
| section |
| open scoped ContDiff Topology BoundedContinuousFunction |
| open Set Function Filter |
| namespace HolderCompletion |
| variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E] [completeSpaceE : CompleteSpace E] |
| local instance freeInst1 : NormedAddCommGroup (COne ℂ E) := inferInstance |
| local instance freeInst2 : NormedSpace ℝ (COne ℂ E) := inferInstance |
| local instance freeInst3 : NormedAddCommGroup (HMap ℂ E) := inferInstance |
| local instance freeInst4 : NormedSpace ℝ (HMap ℂ E) := inferInstance |
|
|
| def freeModel (K : Set ℂ) : Submodule ℝ (COne ℂ E) := |
| (supportedHolder K).comap standardJetCR.toLinearMap |
|
|
| omit completeSpaceE in |
| lemma freeModel_closed [CompleteSpace E] (K : Set ℂ) : |
| IsClosed (freeModel (E := E) K : Set (COne ℂ E)) := |
| (supportedHolder_closed K).preimage standardJetCR.continuous |
|
|
| instance (K : Set ℂ) : CompleteSpace (freeModel (E := E) K) := |
| (freeModel_closed K).completeSpace_coe |
|
|
| variable {K : Set ℂ} |
| local instance freeInst5 : NormedAddCommGroup (freeModel (E := E) K) := inferInstance |
| local instance freeInst6 : NormedSpace ℝ (freeModel (E := E) K) := inferInstance |
| local instance freeInst7 : NormedAddCommGroup (markedModel (E := E) K) := inferInstance |
| local instance freeInst8 : NormedSpace ℝ (markedModel (E := E) K) := inferInstance |
| local instance freeInst9 : NormedAddCommGroup (supportedHolder (E := E) K) := inferInstance |
| local instance freeInst10 : NormedSpace ℝ (supportedHolder (E := E) K) := inferInstance |
|
|
| def freeCR : freeModel (E := E) K →L[ℝ] supportedHolder (E := E) K := |
| standardJetCR.restrict (fun _ hu => hu) |
|
|
| def markedToFree : markedModel (E := E) K →L[ℝ] freeModel (E := E) K := |
| (markedModel (E := E) K).subtypeL.codRestrict _ (fun u => u.property.2) |
|
|
| def freeConst : E →L[ℝ] freeModel (E := E) K := |
| (constJetCLM (E := E)).codRestrict _ (fun c => by |
| change standardJetCR (constJet c) ∈ supportedHolder K |
| apply (mem_supportedHolder _ _).mpr |
| intro z _ |
| simp only [standardJetCR_value,constJet_deriv,zero_apply,smul_zero,sub_zero]) |
|
|
| def freeNormalize : freeModel (E := E) K →L[ℝ] markedModel (E := E) K := |
| (zeroNormalize.comp (freeModel (E := E) K).subtypeL).codRestrict _ (fun u => by |
| apply (mem_markedModel K _).mpr |
| refine ⟨?_,?_⟩ |
| · change cValue u.val 0-cValue u.val 0=0 |
| exact sub_self _ |
| · change standardJetCR (zeroNormalize u.val) ∈ supportedHolder K |
| rw [standardJetCR_zeroNormalize] |
| exact u.property) |
|
|
| def freeCoordinates : freeModel (E := E) K →L[ℝ] E × markedModel (E := E) K := |
| ((jetEval 0).comp (freeModel (E := E) K).subtypeL).prod freeNormalize |
|
|
| def freeSum : E × markedModel (E := E) K →L[ℝ] freeModel (E := E) K := |
| (freeConst (E := E) (K := K)).comp (ContinuousLinearMap.fst ℝ E (markedModel (E := E) K)) + |
| (markedToFree (E := E) (K := K)).comp (ContinuousLinearMap.snd ℝ E (markedModel (E := E) K)) |
|
|
| omit completeSpaceE in |
| @[simp] lemma freeSum_value [CompleteSpace E] (v : E × markedModel (E := E) K) (z : ℂ) : |
| cValue (freeSum (E := E) (K := K) v).val z = v.1+cValue v.2.val z := rfl |
|
|
| omit completeSpaceE in |
| @[simp] lemma freeSum_deriv [CompleteSpace E] (v : E × markedModel (E := E) K) (z : ℂ) : |
| cDeriv (freeSum (E := E) (K := K) v).val z = cDeriv v.2.val z := by |
| change (0 : ℂ →L[ℝ] E)+cDeriv v.2.val z = _ |
| exact zero_add _ |
|
|
| def freeEquiv : freeModel (E := E) K ≃L[ℝ] E × markedModel (E := E) K := |
| ContinuousLinearEquiv.equivOfInverse freeCoordinates freeSum |
| (by |
| intro v |
| apply Subtype.ext |
| apply cValue_ext |
| intro z |
| change cValue v.val 0+(cValue v.val z-cValue v.val 0)=cValue v.val z |
| abel) |
| (by |
| intro v |
| apply Prod.ext |
| · change v.1+cValue v.2.val 0=v.1 |
| have hz : cValue v.2.val 0=0 := v.2.property.1 |
| rw [hz,add_zero] |
| · apply Subtype.ext |
| apply cValue_ext |
| intro z |
| change (v.1+cValue v.2.val z)-(v.1+cValue v.2.val 0)=cValue v.2.val z |
| have hz : cValue v.2.val 0=0 := v.2.property.1 |
| rw [hz,add_zero] |
| abel) |
|
|
| omit completeSpaceE in |
| lemma free_model_injective [CompleteSpace E] : |
| Injective (fun u : freeModel (E := E) K => cValue u.val) := by |
| intro u v h |
| apply Subtype.ext |
| apply cValue_ext |
| intro z |
| exact congrArg (fun f : ℂ →ᵇ E => f z) h |
|
|
| end HolderCompletion |
|
|
| end |
| section |
| open scoped ContDiff Topology BoundedContinuousFunction |
| open Set Filter |
| namespace HolderCompletion |
| variable {E F : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| [NormedAddCommGroup F] [NormedSpace ℝ F] |
| local instance jetSuperInst1 : NormedAddCommGroup (E →L[ℝ] F) := ContinuousLinearMap.toNormedAddCommGroup |
| local instance jetSuperInst2 : NormedSpace ℝ (E →L[ℝ] F) := ContinuousLinearMap.toNormedSpace |
| local instance jetSuperInst3 : NormedAddCommGroup (ℂ →L[ℝ] E) := ContinuousLinearMap.toNormedAddCommGroup |
| local instance jetSuperInst4 : NormedSpace ℝ (ℂ →L[ℝ] E) := ContinuousLinearMap.toNormedSpace |
| local instance jetSuperInst5 : NormedAddCommGroup (ℂ →L[ℝ] F) := ContinuousLinearMap.toNormedAddCommGroup |
| local instance jetSuperInst6 : NormedSpace ℝ (ℂ →L[ℝ] F) := ContinuousLinearMap.toNormedSpace |
| local instance jetSuperInst7 : NormedAddCommGroup (HMap ℂ F) := inferInstance |
| local instance jetSuperInst8 : NormedSpace ℝ (HMap ℂ F) := inferInstance |
| local instance jetSuperInst9 : NormedAddCommGroup (HMap ℂ (ℂ →L[ℝ] F)) := inferInstance |
| local instance jetSuperInst10 : NormedSpace ℝ (HMap ℂ (ℂ →L[ℝ] F)) := inferInstance |
|
|
| variable {P : E → F} (hP : BoundedCThree P) (hDP : BoundedCThree (fderiv ℝ P)) |
| (p : E) (a : ℂ →L[ℝ] E) (u : COne ℂ E) |
|
|
| def affineJetValue : HMap ℂ F := |
| superpose hP (affine_differentiable p a) (norm_nonneg a) (affine_fderiv_bound p a) u |
|
|
| def affineJetDeriv : HMap ℂ (ℂ →L[ℝ] F) := |
| bilinCLM (X := ℂ) (α := (1:ℝ)/3) (ContinuousLinearMap.compL ℝ ℂ E F) |
| (superpose hDP (affine_differentiable p a) (norm_nonneg a) (affine_fderiv_bound p a) u) |
| (const _ a+jetDerivCLM _ u) |
|
|
| @[simp] lemma affineJetValue_value (z : ℂ) : |
| valueCLM _ (affineJetValue hP p a u) z = P (affineCurve p a u z) := rfl |
|
|
| @[simp] lemma affineJetDeriv_value (z : ℂ) : |
| valueCLM _ (affineJetDeriv hDP p a u) z = |
| (fderiv ℝ P (affineCurve p a u z)).comp (a+cDeriv u z) := rfl |
|
|
| def affineJetSuperpose : COne ℂ F := |
| ⟨(affineJetValue hP p a u,affineJetDeriv hDP p a u), by |
| intro z |
| exact ((hP.smooth.differentiable (by simp) (affineCurve p a u z)).hasFDerivAt.comp z |
| (affineCurve_hasFDerivAt p a u z))⟩ |
|
|
| @[simp] lemma affineJetSuperpose_value (z : ℂ) : |
| cValue (affineJetSuperpose hP hDP p a u) z = P (affineCurve p a u z) := rfl |
|
|
| def compactPerturbationJet {P : E → F} (hP : ContDiff ℝ ∞ P) (c : F) |
| (hc : HasCompactSupport (fun x => P x-c)) (p : E) (a : ℂ →L[ℝ] E) (u : COne ℂ E) : COne ℂ F := |
| affineJetSuperpose (boundedCThree_of_compactPerturbation hP c hc) |
| (boundedCThree_of_compactSupport (hP.fderiv_right (by simp)) |
| (by |
| have he : fderiv ℝ (fun x => P x-c) = fderiv ℝ P := funext fun x => fderiv_sub_const c |
| rw [←he] |
| exact hc.fderiv ℝ)) p a u |
|
|
| @[simp] lemma compactPerturbationJet_value {P : E → F} (hP : ContDiff ℝ ∞ P) (c : F) |
| (hc : HasCompactSupport (fun x => P x-c)) (p : E) (a : ℂ →L[ℝ] E) (u : COne ℂ E) (z : ℂ) : |
| cValue (compactPerturbationJet hP c hc p a u) z = P (affineCurve p a u z) := rfl |
|
|
| end HolderCompletion |
|
|
| end |
| section |
| open scoped ContDiff Topology BoundedContinuousFunction |
| open Set Filter |
| namespace HolderCompletion |
| variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E] [completeSpaceE : CompleteSpace E] |
| local instance zeroOrderInst1 : NormedAddCommGroup (E →L[ℝ] E) := ContinuousLinearMap.toNormedAddCommGroup |
| local instance zeroOrderInst2 : NormedSpace ℝ (E →L[ℝ] E) := ContinuousLinearMap.toNormedSpace |
| local instance zeroOrderInst3 : NormedAddCommGroup (COne ℂ E) := inferInstance |
| local instance zeroOrderInst4 : NormedSpace ℝ (COne ℂ E) := inferInstance |
| local instance zeroOrderInst5 : NormedAddCommGroup (HMap ℂ E) := inferInstance |
| local instance zeroOrderInst6 : NormedSpace ℝ (HMap ℂ E) := inferInstance |
|
|
| def jetZeroOrder (C : HMap ℂ (E →L[ℝ] E)) : COne ℂ E →L[ℝ] HMap ℂ E := |
| (holderCoefficientAction C).comp (jetValueCLM _) |
|
|
| omit completeSpaceE in |
| @[simp] lemma jetZeroOrder_value [CompleteSpace E] |
| (C : HMap ℂ (E →L[ℝ] E)) (u : COne ℂ E) (z : ℂ) : |
| valueCLM _ (jetZeroOrder C u) z = valueCLM _ C z (cValue u z) := rfl |
|
|
| omit completeSpaceE in |
| lemma jetZeroOrder_eq_localized [CompleteSpace E] |
| (C : HMap ℂ (E →L[ℝ] E)) (b : ContDiffBump (0:ℂ)) |
| (hC : ∀ z ∉ Metric.closedBall (0:ℂ) b.rIn, valueCLM _ C z = 0) : |
| jetZeroOrder C = (holderCoefficientAction C).comp (localizedJetValue b) := by |
| apply ContinuousLinearMap.ext |
| intro u |
| apply value_ext |
| intro z |
| change valueCLM _ C z (cValue u z) = valueCLM _ C z (b z • cValue u z) |
| by_cases hz : z ∈ Metric.closedBall (0:ℂ) b.rIn |
| · rw [b.one_of_mem_closedBall hz,one_smul] |
| · rw [hC z hz,zero_apply,zero_apply] |
|
|
| lemma jetZeroOrder_isCompact [ProperSpace E] (C : HMap ℂ (E →L[ℝ] E)) |
| (b : ContDiffBump (0:ℂ)) |
| (hC : ∀ z ∉ Metric.closedBall (0:ℂ) b.rIn, valueCLM _ C z = 0) : |
| IsCompactOperator (jetZeroOrder C) := by |
| rw [jetZeroOrder_eq_localized C b hC] |
| exact (localizedJetValue_isCompact (E := E) b).clm_comp (holderCoefficientAction C) |
|
|
| variable {K : Set ℂ} |
| local instance zeroOrderInst7 : NormedAddCommGroup (markedModel (E := E) K) := inferInstance |
| local instance zeroOrderInst8 : NormedSpace ℝ (markedModel (E := E) K) := inferInstance |
| local instance zeroOrderInst9 : NormedAddCommGroup (supportedHolder (E := E) K) := inferInstance |
| local instance zeroOrderInst10 : NormedSpace ℝ (supportedHolder (E := E) K) := inferInstance |
|
|
| def markedZeroOrder (C : HMap ℂ (E →L[ℝ] E)) |
| (hC : ∀ z ∉ K, valueCLM _ C z = 0) : |
| markedModel (E := E) K →L[ℝ] supportedHolder (E := E) K := |
| ((jetZeroOrder C).comp (markedModel K).subtypeL).codRestrict _ (fun u => by |
| apply (mem_supportedHolder _ K).mpr |
| intro z hz |
| change valueCLM _ C z (cValue u.val z) = 0 |
| rw [hC z hz,zero_apply]) |
|
|
| omit completeSpaceE in |
| @[simp] lemma markedZeroOrder_value [CompleteSpace E] (C : HMap ℂ (E →L[ℝ] E)) |
| (hC : ∀ z ∉ K, valueCLM _ C z = 0) (u : markedModel (E := E) K) (z : ℂ) : |
| valueCLM _ (markedZeroOrder C hC u).val z = valueCLM _ C z (cValue u.val z) := rfl |
|
|
| lemma markedZeroOrder_isCompact [ProperSpace E] (C : HMap ℂ (E →L[ℝ] E)) |
| (hC : ∀ z ∉ K, valueCLM _ C z = 0) (b : ContDiffBump (0:ℂ)) |
| (hCb : ∀ z ∉ Metric.closedBall (0:ℂ) b.rIn, valueCLM _ C z = 0) : |
| IsCompactOperator (markedZeroOrder C hC) := by |
| have hc := (jetZeroOrder_isCompact C b hCb).comp_clm (markedModel (E := E) K).subtypeL |
| exact hc.codRestrict (fun u => by |
| apply (mem_supportedHolder _ K).mpr |
| intro z hz |
| change valueCLM _ C z (cValue u.val z) = 0 |
| rw [hC z hz,zero_apply]) (supportedHolder_closed K) |
|
|
| end HolderCompletion |
|
|
| end |
| section |
| open Set Function Filter Topology |
| variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
|
|
| theorem compactPerturbation_finite_kernel (T : E →L[ℝ] E) (hT : IsCompactOperator T) : |
| FiniteDimensional ℝ (ContinuousLinearMap.id ℝ E+T).ker := by |
| let S := ContinuousLinearMap.id ℝ E+T |
| have h : ∀ x : S.ker, T x=-(x:E) := by |
| intro x |
| have hx := x.property |
| change (x:E)+T x=0 at hx |
| exact eq_neg_of_add_eq_zero_right hx |
| have hc := (hT.comp_clm S.ker.subtypeL).neg |
| have hm : ∀ x : S.ker, -(T (x:E))∈S.ker := by |
| intro x |
| rw [h,neg_neg] |
| exact x.property |
| have hk := hc.codRestrict hm S.isClosed_ker |
| have he : Set.codRestrict (fun x : S.ker => -(T (x:E))) S.ker hm=id := by |
| funext x |
| apply Subtype.ext |
| change -(T (x:E))=(x:E) |
| rw [h,neg_neg] |
| change IsCompactOperator (Set.codRestrict (fun x : S.ker => -(T (x:E))) S.ker hm) at hk |
| rw [he] at hk |
| exact FiniteDimensional.of_isCompactOperator_id hk |
|
|
|
|
| end |
| section |
| open Set Function Filter Topology |
| open scoped NNReal |
| variable {E F : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] [CompleteSpace E] |
| [NormedAddCommGroup F] [NormedSpace ℝ F] |
|
|
| theorem compactPerturbation_antilipschitz |
| (P T : E →L[ℝ] F) {K : ℝ≥0} (hP : AntilipschitzWith K P) |
| (hT : IsCompactOperator T) (hi : Injective (P+T)) : |
| ∃ C, AntilipschitzWith C (P+T) := by |
| rw [antilipschitzWith_iff_exists_mul_le_norm] |
| by_contra! h |
| obtain ⟨φ, _, hφpos, hφ⟩ := exists_seq_strictAnti_tendsto (0:ℝ) |
| have hx : ∀ n : ℕ, ∃ x : E, ‖x‖=1 ∧ ‖(P+T) x‖<φ n := by |
| intro n |
| obtain ⟨x,hx⟩ := h (φ n) (hφpos n) |
| have hn : 0<‖x‖ := by |
| by_contra! hh |
| have hx0 : x=0 := norm_eq_zero.mp (le_antisymm hh (norm_nonneg _)) |
| subst x |
| simp at hx |
| refine ⟨‖x‖⁻¹ • x, ?_, ?_⟩ |
| · rw [norm_smul,Real.norm_of_nonneg (inv_nonneg.mpr hn.le),inv_mul_cancel₀ hn.ne'] |
| · rw [map_smul,norm_smul,Real.norm_of_nonneg (inv_nonneg.mpr hn.le)] |
| calc |
| ‖x‖⁻¹ * ‖(P+T) x‖ < ‖x‖⁻¹ * (φ n * ‖x‖) := mul_lt_mul_of_pos_left hx (inv_pos.mpr hn) |
| _=φ n := by field_simp |
| choose x hxn hxb using hx |
| have hxlim : Tendsto (fun n => (P+T) (x n)) atTop (𝓝 0) := |
| squeeze_zero_norm (fun n => (hxb n).le) hφ |
| obtain ⟨A,hA,hAT⟩ := hT.image_closedBall_subset_compact 1 |
| obtain ⟨y,_,ψ,hψ,hy⟩ := hA.tendsto_subseq |
| (fun n => hAT ⟨x n, by simp only [Metric.mem_closedBall,dist_zero_right,hxn,le_refl],rfl⟩) |
| have hp : Tendsto (fun n => P (x (ψ n))) atTop (𝓝 (-y)) := by |
| have hh := (hxlim.comp hψ.tendsto_atTop).sub hy |
| simpa only [comp_apply,add_apply,ContinuousLinearMap.coe_coe,add_sub_cancel_right,zero_sub] using hh |
| have hc : CauchySeq (x ∘ ψ) := by |
| have hh := hp.cauchySeq |
| change Cauchy (Filter.map P (Filter.map (x ∘ ψ) atTop)) at hh |
| exact (hP.isUniformInducing P.uniformContinuous).cauchy_map_iff.mp hh |
| obtain ⟨z,hz⟩ := cauchySeq_tendsto_of_complete hc |
| have hs : (P+T) z=0 := |
| tendsto_nhds_unique ((P+T).continuous.continuousAt.tendsto.comp hz) |
| (hxlim.comp hψ.tendsto_atTop) |
| have hz0 : z=0 := hi (hs.trans (map_zero (P+T)).symm) |
| have hn : ‖z‖=1 := tendsto_nhds_unique (hz.norm) |
| (by simpa only [comp_apply,hxn] using (tendsto_const_nhds : Tendsto (fun _ : ℕ => (1:ℝ)) atTop (𝓝 1))) |
| simp only [hz0,norm_zero,zero_ne_one] at hn |
|
|
|
|
| end |
| section |
| open scoped NNReal |
| open Set Function Filter Topology |
| variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] [CompleteSpace E] |
|
|
| theorem compactPerturbation_closed_range (T : E →L[ℝ] E) (hT : IsCompactOperator T) : |
| IsClosed ((ContinuousLinearMap.id ℝ E+T).range : Set E) := by |
| let S := ContinuousLinearMap.id ℝ E+T |
| have : FiniteDimensional ℝ S.ker := compactPerturbation_finite_kernel T hT |
| obtain ⟨N,hNc,hN⟩ := |
| (Submodule.ClosedComplemented.of_finiteDimensional S.ker).exists_isClosed_isCompl |
| let : IsClosed (N : Set E) := hNc |
| have hp : AntilipschitzWith 1 N.subtypeL := |
| (isometry_subtype_coe : Isometry (Subtype.val : N → E)).antilipschitzWith |
| have hi : Injective (N.subtypeL+T.comp N.subtypeL) := by |
| intro x y hxy |
| apply Subtype.ext |
| apply sub_eq_zero.mp |
| have hh : (x:E)-(y:E)∈S.ker := by |
| change S ((x:E)-(y:E))=0 |
| rw [map_sub] |
| exact sub_eq_zero.mpr hxy |
| have hh' : (x:E)-(y:E)∈(⊥ : Submodule ℝ E) := |
| hN.disjoint.le_bot ⟨hh,N.sub_mem x.property y.property⟩ |
| exact hh' |
| obtain ⟨C,hC⟩ := compactPerturbation_antilipschitz N.subtypeL (T.comp N.subtypeL) |
| hp (hT.comp_clm N.subtypeL) hi |
| have hc := hC.isClosed_range (N.subtypeL+T.comp N.subtypeL).uniformContinuous |
| have he : Set.range (N.subtypeL+T.comp N.subtypeL)=(S.range : Set E) := by |
| ext y |
| constructor |
| · rintro ⟨x,rfl⟩ |
| exact ⟨(x:E),rfl⟩ |
| · rintro ⟨x,rfl⟩ |
| have hx : x∈S.ker⊔N := by rw [hN.sup_eq_top]; exact Submodule.mem_top |
| obtain ⟨a,ha,b,hb,hab⟩ := Submodule.mem_sup.mp hx |
| refine ⟨⟨b,hb⟩,?_⟩ |
| change S b=S x |
| rw [←hab,map_add,show S a=0 from ha,zero_add] |
| rwa [he] at hc |
|
|
| theorem compactPerturbation_strict (T : E →L[ℝ] E) (hT : IsCompactOperator T) : |
| IsStrictMap (ContinuousLinearMap.id ℝ E+T) := by |
| let S := ContinuousLinearMap.id ℝ E+T |
| let : IsClosed (S.range : Set E) := compactPerturbation_closed_range T hT |
| let F : E →L[ℝ] S.range := S.codRestrict S.range (fun x => ⟨x,rfl⟩) |
| have hf : Surjective F := by |
| rintro ⟨y,x,hx⟩ |
| exact ⟨x,Subtype.ext hx⟩ |
| exact F.isQuotientMap hf |
|
|
|
|
| end |
| section |
| open Set Function Filter Topology |
| variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
|
|
| theorem compactPerturbation_finite_cokernel (T : E →L[ℝ] E) (hT : IsCompactOperator T) |
| (hc : IsClosed ((ContinuousLinearMap.id ℝ E+T).range : Set E)) : |
| FiniteDimensional ℝ (E ⧸ (ContinuousLinearMap.id ℝ E+T).range) := by |
| let S := ContinuousLinearMap.id ℝ E+T |
| let Q := S.range.mkQL |
| have he : ∀ x, -(Q (T x))=Q x := by |
| intro x |
| have hh : Q (S x)=0 := (Submodule.Quotient.mk_eq_zero _).mpr ⟨x,rfl⟩ |
| change Q (x+T x)=0 at hh |
| rw [map_add] at hh |
| exact (eq_neg_of_add_eq_zero_left hh).symm |
| have hQ : IsCompactOperator Q := by |
| have hh := (hT.clm_comp Q).neg |
| have he' : -(Q ∘ T)=Q := by funext x; exact he x |
| rwa [he'] at hh |
| obtain ⟨K,hK,hKQ⟩ := hQ |
| have hK0 : K∈𝓝 (0 : E ⧸ S.range) := by |
| have hm := S.range.isOpenMap_mkQ.map_nhds_eq (x := 0) |
| S.range.continuous_mkQ.continuousAt |
| rw [map_zero] at hm |
| rw [←hm] |
| exact hKQ |
| let : IsClosed (S.range : Set E) := hc |
| exact FiniteDimensional.of_isCompactOperator_id ⟨K,hK,hK0⟩ |
|
|
|
|
| end |
| section |
| open Set Function Filter Topology |
| variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] [CompleteSpace E] |
|
|
| theorem compactPerturbation_fredholm (T : E →L[ℝ] E) (hT : IsCompactOperator T) : |
| (ContinuousLinearMap.id ℝ E+T).IsFredholm := by |
| have : FiniteDimensional ℝ (ContinuousLinearMap.id ℝ E+T).ker := |
| compactPerturbation_finite_kernel T hT |
| exact { |
| isStrictMap := compactPerturbation_strict T hT |
| isClosed_range := compactPerturbation_closed_range T hT |
| finite_ker := this |
| finite_coker := compactPerturbation_finite_cokernel T hT (compactPerturbation_closed_range T hT) |
| closedComplemented_ker := Submodule.ClosedComplemented.of_finiteDimensional _ } |
|
|
|
|
| end |
| section |
| open Set Function Filter Topology |
| variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
|
|
| theorem compactPerturbation_filtration_stops (T : E →L[ℝ] E) (hT : IsCompactOperator T) |
| (V : ℕ → Submodule ℝ E) (hmono : Monotone V) |
| (hclosed : ∀ n, IsClosed (V n : Set E)) |
| (hstep : ∀ n x, x∈V (n+1) → x+T x∈V n) : |
| ∃ n, V n=V (n+1) := by |
| by_contra! hne |
| have hx (n : ℕ) : ∃ x∈V (n+1), ‖x‖≤3 ∧ ∀ y∈V n, 1≤‖x-y‖ := by |
| have hn : ¬ V (n+1) ≤ V n := fun h => hne n (le_antisymm (hmono (Nat.le_succ n)) h) |
| obtain ⟨x,hxs,hxn⟩ := Set.not_subset.mp hn |
| have hc : IsClosed ((V n).comap (V (n+1)).subtype : Set (V (n+1))) := |
| (hclosed n).preimage continuous_subtype_val |
| have hh : ∃ x : V (n+1), x∉(V n).comap (V (n+1)).subtype := ⟨⟨x,hxs⟩,hxn⟩ |
| obtain ⟨⟨x,hx⟩,hxn,hxy⟩ := riesz_lemma_of_norm_lt |
| (c := (2:ℝ)) (by norm_num) (R := 3) (by norm_num) hc hh |
| refine ⟨x,hx,hxn,fun y hy => ?_⟩ |
| exact hxy ⟨y,hmono (Nat.le_succ n) hy⟩ hy |
| choose x hxv hxn hxy using hx |
| have hTx {n m : ℕ} (hnm : n+1 ≤ m) : T (x n)∈V m := by |
| have hs : x n+T (x n) ∈ V m := hmono (by omega) (hstep n (x n) (hxv n)) |
| have hz : x n∈V m := hmono hnm (hxv n) |
| simpa only [add_sub_cancel_left] using (V m).sub_mem hs hz |
| have hp : Pairwise (fun m n : ℕ => 1≤‖T (x m)-T (x n)‖) := by |
| have : Std.Symm (fun m n : ℕ => 1≤‖T (x m)-T (x n)‖) := |
| ⟨fun _ _ h => by rwa [norm_sub_rev]⟩ |
| apply Pairwise.of_lt |
| intro m n hmn |
| let y := x n+T (x n)-T (x m) |
| have hy : y∈V n := (V n).sub_mem (hstep n (x n) (hxv n)) (hTx (by omega)) |
| have he : x n-y=T (x m)-T (x n) := by dsimp [y]; abel |
| simpa only [he] using hxy n y hy |
| obtain ⟨K,hK,hTK⟩ := hT.image_closedBall_subset_compact 3 |
| obtain ⟨y,_,φ,hφ,hφy⟩ := hK.tendsto_subseq (fun n => hTK ⟨x n,by simpa using hxn n,rfl⟩) |
| have hh := hφy.cauchySeq |
| rw [Metric.cauchySeq_iff'] at hh |
| obtain ⟨N,hN⟩ := hh 1 (by norm_num) |
| have hlt : ‖T (x (φ (N+1)))-T (x (φ N))‖<1 := by |
| simpa only [Function.comp_apply,dist_eq_norm_sub,ContinuousLinearMap.coe_coe] using hN (N+1) (by omega) |
| exact hlt.not_ge (hp (hφ.injective.ne (by omega))) |
|
|
| theorem compactPerturbation_kernel_stabilizes (T : E →L[ℝ] E) (hT : IsCompactOperator T) : |
| ∃ n, ((ContinuousLinearMap.id ℝ E+T : E →L[ℝ] E).toLinearMap^n).ker= |
| ((ContinuousLinearMap.id ℝ E+T : E →L[ℝ] E).toLinearMap^(n+1)).ker := by |
| let P : E →L[ℝ] E := ContinuousLinearMap.id ℝ E+T |
| apply compactPerturbation_filtration_stops T hT (fun n => (P.toLinearMap^n).ker) |
| P.toLinearMap.iterateKer.monotone |
| · intro n |
| rw [←ContinuousLinearMap.toLinearMap_pow] |
| exact (P^n).isClosed_ker |
| · intro n x hx |
| change (P.toLinearMap^n) (P.toLinearMap x)=0 |
| change (P.toLinearMap^(n+1)) x=0 at hx |
| simpa only [pow_succ,Module.End.mul_apply] using hx |
|
|
| theorem compactPerturbation_injective_of_surjective (T : E →L[ℝ] E) (hT : IsCompactOperator T) |
| (hs : Surjective (ContinuousLinearMap.id ℝ E+T)) : |
| Injective (ContinuousLinearMap.id ℝ E+T) := by |
| let P : E →L[ℝ] E := ContinuousLinearMap.id ℝ E+T |
| obtain ⟨n,hn⟩ := compactPerturbation_kernel_stabilizes T hT |
| change (P.toLinearMap^n).ker=(P.toLinearMap^(n+1)).ker at hn |
| apply (LinearMap.ker_eq_bot (f := P.toLinearMap)).mp |
| apply LinearMap.ker_eq_bot'.mpr |
| intro x hx |
| have hp : ∀ n : ℕ, Surjective (P.toLinearMap^n) := by |
| intro m |
| induction m with |
| | zero => exact fun y => ⟨y,rfl⟩ |
| | succ m hm => |
| intro y |
| obtain ⟨z,hz⟩ := hm y |
| obtain ⟨x,hx⟩ := hs z |
| refine ⟨x,?_⟩ |
| rw [pow_succ,Module.End.mul_apply] |
| exact (congrArg (P.toLinearMap^m) hx).trans hz |
| obtain ⟨y,rfl⟩ := hp n x |
| have hy : y∈(P.toLinearMap^(n+1)).ker := by |
| change (P.toLinearMap^(n+1)) y=0 |
| simpa only [pow_succ',Module.End.mul_apply] using hx |
| rw [←hn] at hy |
| exact hy |
|
|
|
|
| end |
|
|
| end HigherDimensionalBallPacking.Rigidity |
| end |
|
|
| end OAI |
|
|
