Download data/lean/OAI/Geometry/BallPacking/Fredholm/FiniteExtensions.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 25 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/BallPacking/Fredholm/FiniteExtensions.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Geometry/BallPacking/Fredholm/FiniteExtensions.lean
-
curl -L -o FiniteExtensions.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/BallPacking/Fredholm/FiniteExtensions.lean
25 kB
| 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 | |