Download data/lean/OAI/Geometry/BallPacking/Fredholm/FreeLinearization.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 25.4 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/BallPacking/Fredholm/FreeLinearization.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Geometry/BallPacking/Fredholm/FreeLinearization.lean
-
curl -L -o FreeLinearization.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/BallPacking/Fredholm/FreeLinearization.lean
25.4 kB
| import Mathlib | |
| import OAI.Geometry.BallPacking.Compactness.AffineCorrectionInfinity | |
| import OAI.Geometry.BallPacking.Fredholm.PointwiseMarkedCR | |
| namespace OAI | |
| noncomputable section | |
| namespace HigherDimensionalBallPacking.Rigidity | |
| section | |
| open scoped ContDiff Topology BoundedContinuousFunction | |
| open Set Function Filter | |
| namespace HolderCompletion | |
| variable {n : β} | |
| local instance afInst1 : NormedAddCommGroup (End n) := ContinuousLinearMap.toNormedAddCommGroup | |
| local instance afInst2 : NormedSpace β (End n) := ContinuousLinearMap.toNormedSpace | |
| local instance afInst3 : NormedAddCommGroup (COne β (Phase n)) := inferInstance | |
| local instance afInst4 : NormedSpace β (COne β (Phase n)) := inferInstance | |
| local instance afInst5 : NormedAddCommGroup (HMap β (Phase n)) := inferInstance | |
| local instance afInst6 : NormedSpace β (HMap β (Phase n)) := inferInstance | |
| variable {J : Phase n β End n} (hJ : ContDiff β β J) (hc : β x, Compatible (J x)) {B : β} | |
| (hstd : β x, B < βxβ β J x=standardJ n) (p q : Phase n) (u : COne β (Phase n)) | |
| {K : Set β} (hK : IsCompact K) (he : β z β K, B < βmarkedCurve p q u zβ) | |
| local instance afInst7 : NormedAddCommGroup (freeModel (E := Phase n) K) := inferInstance | |
| local instance afInst8 : NormedSpace β (freeModel (E := Phase n) K) := inferInstance | |
| local instance afInst9 : AddCommGroup (freeModel (E := Phase n) K) := (afInst7 (n := n) (K := K)).toAddCommGroup | |
| local instance afInst10 : Module β (freeModel (E := Phase n) K) := (afInst8 (n := n) (K := K)).toModule | |
| local instance afInst11 : NormedAddCommGroup (markedModel (E := Phase n) K) := inferInstance | |
| local instance afInst12 : NormedSpace β (markedModel (E := Phase n) K) := inferInstance | |
| local instance afInst13 : AddCommGroup (markedModel (E := Phase n) K) := (afInst11 (n := n) (K := K)).toAddCommGroup | |
| local instance afInst14 : Module β (markedModel (E := Phase n) K) := (afInst12 (n := n) (K := K)).toModule | |
| local instance afInst15 : NormedAddCommGroup (supportedHolder (E := Phase n) K) := inferInstance | |
| local instance afInst16 : NormedSpace β (supportedHolder (E := Phase n) K) := inferInstance | |
| local instance afInst17 : AddCommGroup (supportedHolder (E := Phase n) K) := (afInst15 (n := n) (K := K)).toAddCommGroup | |
| local instance afInst18 : Module β (supportedHolder (E := Phase n) K) := (afInst16 (n := n) (K := K)).toModule | |
| def completedFreePrincipal : freeModel (E := Phase n) K βL[β] supportedHolder (E := Phase n) K := | |
| freePrincipal (jetValueCLM _ (completedStructureJet hJ hstd p q u)) | |
| (fun z hz => hstd _ (he z hz)) | |
| def completedFreeLinearized : freeModel (E := Phase n) K βL[β] supportedHolder (E := Phase n) K := | |
| freeLinearized (jetValueCLM _ (completedStructureJet hJ hstd p q u)) (completedQ hJ hstd p q u) | |
| (fun z hz => hstd _ (he z hz)) (completedQ_zero_outside hJ hstd p q u he) | |
| include hc hK in | |
| lemma completedFreePrincipal_fredholm : (completedFreePrincipal hJ hstd p q u he).IsFredholm := by | |
| have hP := (completedPrincipal_add_compact_fredholm hJ hc hstd p q u hK he 0 isCompactOperator_zero).1 | |
| have hP' : (completedPrincipal hJ hstd p q u he).IsFredholm := by | |
| simpa only [add_zero] using hP | |
| exact freePrincipal_fredholm (E := Phase n) (K := K) (jetValueCLM _ (completedStructureJet hJ hstd p q u)) | |
| (fun z hz => hstd _ (he z hz)) hP' | |
| include hc hK in | |
| lemma completedFreeLinearized_fredholm : (completedFreeLinearized hJ hstd p q u he).IsFredholm := by | |
| have hP := (completedPrincipal_add_compact_fredholm hJ hc hstd p q u hK he | |
| (-completedZeroOrder hJ hstd p q u he) (completedZeroOrder_compact hJ hstd p q u hK he).neg).1 | |
| have hP' : (completedPrincipal hJ hstd p q u he-completedZeroOrder hJ hstd p q u he).IsFredholm := by | |
| simpa only [sub_eq_add_neg] using hP | |
| exact freeLinearized_fredholm (E := Phase n) (K := K) (jetValueCLM _ (completedStructureJet hJ hstd p q u)) | |
| (completedQ hJ hstd p q u) (fun z hz => hstd _ (he z hz)) | |
| (completedQ_zero_outside hJ hstd p q u he) hP' | |
| lemma completedFreeLinearized_value (v : freeModel (E := Phase n) K) (z : β) : | |
| valueCLM _ (completedFreeLinearized hJ hstd p q u he v).val z = | |
| cDeriv v.val z Complex.I-J (markedCurve p q u z) (cDeriv v.val z 1)- | |
| fderiv β J (markedCurve p q u z) (cValue v.val z) (fderiv β (markedCurve p q u) z 1) := by | |
| have hp := freePrincipal_value (E := Phase n) (K := K) (jetValueCLM _ (completedStructureJet hJ hstd p q u)) | |
| (fun z hz => hstd _ (he z hz)) v z | |
| have hq := freeZeroOrder_value (E := Phase n) (K := K) (completedQ hJ hstd p q u) | |
| (completedQ_zero_outside hJ hstd p q u he) v z | |
| have hq' := hq.trans (completedQ_value hJ hstd p q u z (cValue v.val z)) | |
| exact congrArgβ (fun x y : Phase n => x-y) hp hq' | |
| include hJ hstd in | |
| theorem actualStructureBound : BoundedCThree J := | |
| boundedCThree_of_compactPerturbation hJ (standardJ n) (compactPerturbation_of_outside_constant _ hstd) | |
| variable (b : ContDiffBump (0:β)) | |
| local instance afInst19 : NormedAddCommGroup (freeModel (E := Phase n) (Metric.closedBall (0:β) b.rOut)) := inferInstance | |
| local instance afInst20 : NormedSpace β (freeModel (E := Phase n) (Metric.closedBall (0:β) b.rOut)) := inferInstance | |
| local instance afInst21 : AddCommGroup (freeModel (E := Phase n) (Metric.closedBall (0:β) b.rOut)) := (afInst19 (n := n) b).toAddCommGroup | |
| local instance afInst22 : Module β (freeModel (E := Phase n) (Metric.closedBall (0:β) b.rOut)) := (afInst20 (n := n) b).toModule | |
| local instance afInst23 : TopologicalSpace (freeModel (E := Phase n) (Metric.closedBall (0:β) b.rOut)) := (afInst19 (n := n) b).toPseudoMetricSpace.toUniformSpace.toTopologicalSpace | |
| local instance afInst24 : ContinuousSMul β | |
| (freeModel (E := Phase n) (Metric.closedBall (0:β) b.rOut)) := | |
| IsBoundedSMul.continuousSMul | |
| variable (w : freeModel (E := Phase n) (Metric.closedBall (0:β) b.rOut)) | |
| (hesc : βαΆ v in π (0 : freeModel (E := Phase n) (Metric.closedBall (0:β) b.rOut)), | |
| β z, b.rIn β€ βzβ β B < βaffineCurve p (complexSlope (markedSlope p q w.val)) (w.val+v.val) zβ) | |
| def actualFreeChart := freeChart (actualStructureBound hJ hstd) b p (markedSlope p q w.val) w | |
| lemma actualFreeChart_contDiff : ContDiff β β (actualFreeChart hJ hstd p q b w) := | |
| freeChart_contDiff (actualStructureBound hJ hstd) b p (markedSlope p q w.val) w | |
| (compactPerturbation_of_outside_constant _ hstd) | |
| include hesc in | |
| lemma free_escape_base : β z β Metric.closedBall (0:β) b.rOut, B < βmarkedCurve p q w.val zβ := by | |
| intro z hz | |
| have hz' : b.rIn β€ βzβ := by | |
| have ht : b.rOut < βzβ := by simpa only [Metric.mem_closedBall,dist_zero_right,not_le] using hz | |
| exact (b.rIn_lt_rOut.trans ht).le | |
| have hh := hesc.self_of_nhds z hz' | |
| simpa only [Submodule.coe_zero,add_zero,affineCurve,affine,complexSlope_apply,markedCurve] using hh | |
| include hesc in | |
| lemma actualFreeChart_crSection_fderiv_eval (z : β) : | |
| (supportedEval (E := Phase n) (K := Metric.closedBall (0:β) b.rOut) z).comp | |
| (fderiv β (actualFreeChart hJ hstd p q b w) 0) = | |
| (((BoundedContinuousFunction.evalCLM β z).comp (valueCLM _)).comp | |
| ((crSectionDeriv (actualStructureBound hJ hstd) p (complexSlope (markedSlope p q w.val)) w.val).comp | |
| (freeModel (E := Phase n) (Metric.closedBall (0:β) b.rOut)).subtypeL)) := by | |
| have hd := ((actualFreeChart_contDiff hJ hstd p q b w).differentiable (by simp) 0).hasFDerivAt | |
| have hdE := (supportedEval (E := Phase n) (K := Metric.closedBall (0:β) b.rOut) z).hasFDerivAt.comp 0 hd | |
| have hdP := freeChart_hasFDerivAt_eval (actualStructureBound hJ hstd) b p (markedSlope p q w.val) w hstd hesc z | |
| exact hdE.unique hdP | |
| lemma completedFreeLinearized_crSection (z : β) : | |
| (((BoundedContinuousFunction.evalCLM β z).comp (valueCLM _)).comp | |
| ((crSectionDeriv (actualStructureBound hJ hstd) p (complexSlope (markedSlope p q w.val)) w.val).comp | |
| (freeModel (E := Phase n) (Metric.closedBall (0:β) b.rOut)).subtypeL)) = | |
| (supportedEval (E := Phase n) (K := Metric.closedBall (0:β) b.rOut) z).comp | |
| (completedFreeLinearized hJ hstd p q w.val (free_escape_base p q b w hesc)) := by | |
| apply ContinuousLinearMap.ext | |
| intro v | |
| have hval := crSectionDeriv_value (actualStructureBound hJ hstd) p (complexSlope (markedSlope p q w.val)) w.val v.val z | |
| have hh := congrArg (fun d : β βL[β] Phase n => | |
| d Complex.I-J (markedCurve p q w.val z) (d 1)- | |
| fderiv β J (markedCurve p q w.val z) (cValue v.val z) (fderiv β (markedCurve p q w.val) z 1)) | |
| (c_fderiv v.val z) | |
| exact hval.trans (hh.trans (completedFreeLinearized_value hJ hstd p q w.val (free_escape_base p q b w hesc) v z).symm) | |
| lemma actualFreeChart_fderiv_eval (z : β) : | |
| (supportedEval (E := Phase n) (K := Metric.closedBall (0:β) b.rOut) z).comp | |
| (fderiv β (actualFreeChart hJ hstd p q b w) 0) = | |
| (supportedEval (E := Phase n) (K := Metric.closedBall (0:β) b.rOut) z).comp | |
| (completedFreeLinearized hJ hstd p q w.val (free_escape_base p q b w hesc)) := | |
| (actualFreeChart_crSection_fderiv_eval hJ hstd p q b w hesc z).trans | |
| (completedFreeLinearized_crSection hJ hstd p q b w hesc z) | |
| lemma actualFreeChart_fderiv_eq : fderiv β (actualFreeChart hJ hstd p q b w) 0 = | |
| completedFreeLinearized hJ hstd p q w.val (free_escape_base p q b w hesc) := by | |
| apply ContinuousLinearMap.ext | |
| intro v | |
| apply Subtype.ext | |
| apply value_ext | |
| intro z | |
| exact congrArg (fun L : freeModel (E := Phase n) (Metric.closedBall (0:β) b.rOut) βL[β] Phase n => L v) | |
| (actualFreeChart_fderiv_eval hJ hstd p q b w hesc z) | |
| include hc hesc in | |
| lemma actualFreeChart_fderiv_fredholm : (fderiv β (actualFreeChart hJ hstd p q b w) 0).IsFredholm := by | |
| rw [actualFreeChart_fderiv_eq hJ hstd p q b w hesc] | |
| exact completedFreeLinearized_fredholm hJ hc hstd p q w.val (isCompact_closedBall (0:β) b.rOut) | |
| (free_escape_base p q b w hesc) | |
| end HolderCompletion | |
| end | |
| section | |
| open scoped Topology BoundedContinuousFunction ContDiff | |
| open Set Function Filter MeasureTheory | |
| variable {E : Type*} [NormedAddCommGroup E] [NormedSpace β E] | |
| theorem compact_test_translation_smooth {g : β β β} (hg : ContDiff β β g) | |
| (hgc : HasCompactSupport g) {v : β β E} (hv : LocallyIntegrable v) : | |
| ContDiff β β (fun t : β => β« z : β, g z β’ v (z+t)) := by | |
| let L : β βL[β] E βL[β] E := ContinuousLinearMap.lsmul β β | |
| have hs : ContDiff β β (fun z : β => g (-z)) := hg.comp contDiff_neg | |
| have hc : HasCompactSupport (fun z : β => g (-z)) := hgc.comp_homeomorph (Homeomorph.neg β) | |
| have hh := hc.contDiff_convolution_left (π := β) (ΞΌ := (volume : Measure β)) L hs hv | |
| convert hh using 1 | |
| funext t | |
| rw [convolution_def,βintegral_neg_eq_self] | |
| congr 1 | |
| funext z | |
| change g (-z) β’ v (-z+t)=g (-z) β’ v (t-z) | |
| rw [neg_add_eq_sub] | |
| end | |
| section | |
| open Set Function | |
| variable {E F I : Type*} [NormedAddCommGroup E] [NormedSpace β E] | |
| [FiniteDimensional β E] [NormedAddCommGroup F] [NormedSpace β F] | |
| theorem finite_separating_family (L : I β E βL[β] F) | |
| (hL : β v : E, (β i, L i v=0) β v=0) : | |
| β s : Finset I, β v : E, (β i β s, L i v=0) β v=0 := by | |
| classical | |
| let U : I β Set E := fun i => {v | L i vβ 0} | |
| have hU : β i, IsOpen (U i) := fun i => | |
| (isClosed_singleton.preimage (L i).continuous).isOpen_compl | |
| have hcov : Metric.sphere (0:E) 1 β β i, U i := by | |
| intro v hv | |
| by_contra hn | |
| have hz : β i, L i v=0 := by | |
| intro i | |
| by_contra hi | |
| exact hn (mem_iUnion.mpr β¨i,hiβ©) | |
| have hv0 := hL v hz | |
| simp [hv0] at hv | |
| obtain β¨s,hsβ© := (isCompact_sphere (0:E) 1).elim_finite_subcover U hU hcov | |
| refine β¨s,fun v hv => ?_β© | |
| by_contra hne | |
| have hn : βvββ 0 := norm_ne_zero_iff.mpr hne | |
| have hw : βvββ»ΒΉ β’ v β Metric.sphere (0:E) 1 := by | |
| rw [Metric.mem_sphere,dist_zero_right,norm_smul,Real.norm_of_nonneg (inv_nonneg.mpr (norm_nonneg v)),inv_mul_cancelβ hn] | |
| obtain β¨i,hiβ© := mem_iUnion.mp (hs hw) | |
| obtain β¨his,hhβ© := mem_iUnion.mp hi | |
| have hzi : L i (βvββ»ΒΉ β’ v)=0 := by rw [map_smul,hv i his,smul_zero] | |
| exact hh hzi | |
| end | |
| section | |
| open Set Function | |
| variable {E F D : Type*} [NormedAddCommGroup E] [NormedSpace β E] | |
| [NormedAddCommGroup F] [NormedSpace β F] | |
| [NormedAddCommGroup D] [NormedSpace β D] [FiniteDimensional β D] | |
| theorem fredholm_stabilized_leftInverse (P : E βL[β] F) (hP : P.IsFredholm) | |
| (Q : E βL[β] D) (hQ : Injective (Q.comp P.ker.subtypeL)) : | |
| (P.prod Q).HasLeftInverse := by | |
| obtain β¨pkgβ© := hP.nonempty_fredholmPackage | |
| let S : F βL[β] E := pkg.quasiInverse | |
| have hPSP (v : E) : P (S (P v))=P v := by | |
| rw [pkg.eq_equiv] | |
| simp [S,ContinuousLinearMap.FredholmPackage.quasiInverse,Submodule.projectionOnto_projection] | |
| let QK : P.ker βL[β] D := Q.comp P.ker.subtypeL | |
| obtain β¨U,hUβ© := ContinuousLinearMap.HasLeftInverse.of_injective_of_finiteDimensional hQ | |
| let T : F Γ D βL[β] E := S.comp (ContinuousLinearMap.fst β F D) | |
| let L : F Γ D βL[β] E := T + P.ker.subtypeL.comp | |
| (U.comp (ContinuousLinearMap.snd β F D-Q.comp T)) | |
| refine β¨L,fun v => ?_β© | |
| have hr : v-S (P v)βP.ker := by | |
| change P (v-S (P v))=0 | |
| rw [map_sub,hPSP,sub_self] | |
| have hu := congrArg (fun z : P.ker => (z:E)) (hU β¨v-S (P v),hrβ©) | |
| change (U (Q (v-S (P v))) : E)=v-S (P v) at hu | |
| change S (P v)+(U (Q v-Q (S (P v))) : E)=v | |
| rw [βmap_sub,hu] | |
| abel | |
| end | |
| section | |
| open scoped Topology BoundedContinuousFunction ContDiff | |
| open Set Function Filter MeasureTheory | |
| namespace HolderCompletion | |
| variable {E : Type*} [NormedAddCommGroup E] [NormedSpace β E] [CompleteSpace E] | |
| abbrev PlaneTest := {g : β β β // ContDiff β β g β§ HasCompactSupport g} | |
| omit [CompleteSpace E] in | |
| lemma planeTest_integrable [CompleteSpace E] (g : PlaneTest) (v : β βα΅ E) : | |
| Integrable (fun z => g.val z β’ v z) := | |
| v.continuous.locallyIntegrable.integrable_smul_left_of_hasCompactSupport | |
| g.property.1.continuous g.property.2 | |
| lemma planeTest_norm_bound (g : PlaneTest) (v : β βα΅ E) : | |
| ββ« z, g.val z β’ v zβ β€ (β« z, βg.val zβ)*βvβ := by | |
| have hi : Integrable g.val := g.property.1.continuous.integrable_of_hasCompactSupport g.property.2 | |
| calc | |
| _ β€ β« z, βg.val z β’ v zβ := norm_integral_le_integral_norm _ | |
| _ β€ β« z, βg.val zβ*βvβ := by | |
| apply integral_mono (planeTest_integrable g v).norm (hi.norm.mul_const _) | |
| intro z | |
| change βg.val z β’ v zβ β€ βg.val zβ*βvβ | |
| rw [norm_smul] | |
| exact mul_le_mul_of_nonneg_left (BoundedContinuousFunction.norm_coe_le_norm v z) (norm_nonneg _) | |
| _ = _ := integral_mul_const _ _ | |
| def planeTestCLM (g : PlaneTest) : (β βα΅ E) βL[β] E := | |
| LinearMap.mkContinuous | |
| { toFun := fun v => β« z, g.val z β’ v z | |
| map_add' := fun u v => by | |
| simp only [BoundedContinuousFunction.add_apply,smul_add] | |
| exact integral_add (planeTest_integrable g u) (planeTest_integrable g v) | |
| map_smul' := fun c v => by | |
| simp only [BoundedContinuousFunction.smul_apply] | |
| simp_rw [smul_comm (g.val _) c] | |
| exact integral_smul c _ } | |
| (β« z, βg.val zβ) (planeTest_norm_bound g) | |
| lemma planeTest_separates (v : β βα΅ E) (hv : β g : PlaneTest, planeTestCLM g v=0) : v=0 := by | |
| have hz := isOpen_univ.ae_eq_zero_of_integral_contDiff_smul_eq_zero | |
| (ΞΌ := (volume : Measure β)) | |
| (v.continuous.locallyIntegrable.locallyIntegrableOn univ) | |
| (fun g hg hgc _ => hv β¨g,hg,hgcβ©) | |
| have he : EqOn v (fun _ => 0) univ := | |
| Measure.eqOn_open_of_ae_eq ((ae_restrict_iff' MeasurableSet.univ).mpr hz) | |
| isOpen_univ v.continuous.continuousOn continuousOn_const | |
| ext z | |
| exact he (mem_univ z) | |
| local instance testInst1 : NormedAddCommGroup (COne β E) := inferInstance | |
| local instance testInst2 : NormedSpace β (COne β E) := inferInstance | |
| def jetTestCLM (g : PlaneTest) : COne β E βL[β] E := | |
| (planeTestCLM g).comp ((valueCLM _).comp (jetValueCLM _)) | |
| @[simp] lemma jetTest_value (g : PlaneTest) (u : COne β E) : | |
| jetTestCLM g u = β« z, g.val z β’ cValue u z := rfl | |
| lemma jetTest_separates (u : COne β E) (hu : β g : PlaneTest, jetTestCLM g u=0) : u=0 := by | |
| have hv : cValue u = 0 := planeTest_separates _ hu | |
| apply cValue_ext | |
| intro z | |
| exact congrArg (fun v : β βα΅ E => v z) hv | |
| lemma jetTest_translation_smooth (g : PlaneTest) (u : COne β E) : | |
| ContDiff β β (fun t => jetTestCLM g (jetTranslate t u)) := by | |
| simp only [jetTest_value,jetTranslate_value] | |
| exact compact_test_translation_smooth g.property.1 g.property.2 (cValue u).continuous.locallyIntegrable | |
| lemma jetTest_translation_difference_smooth (g : PlaneTest) (u : COne β E) : | |
| ContDiff β β (fun t => jetTestCLM g (jetTranslate t u-u)) := by | |
| simp_rw [map_sub] | |
| exact (jetTest_translation_smooth g u).sub contDiff_const | |
| lemma finite_jet_tests {V : Type*} [NormedAddCommGroup V] [NormedSpace β V] | |
| [FiniteDimensional β V] (L : V βL[β] COne β E) (hL : Injective L) : | |
| β s : Finset PlaneTest, β v : V, (β g β s, jetTestCLM g (L v)=0) β v=0 := by | |
| apply finite_separating_family (fun g : PlaneTest => (jetTestCLM g).comp L) | |
| intro v hv | |
| apply hL | |
| rw [map_zero] | |
| exact jetTest_separates _ hv | |
| end HolderCompletion | |
| end | |
| section | |
| open scoped Topology BoundedContinuousFunction ContDiff | |
| open Set Function Filter | |
| namespace HolderCompletion | |
| variable {E F : Type*} [NormedAddCommGroup E] [NormedSpace β E] [CompleteSpace E] | |
| [FiniteDimensional β E] [NormedAddCommGroup F] [NormedSpace β F] | |
| section Generic | |
| variable {X I : Type*} [NormedAddCommGroup X] [NormedSpace β X] | |
| omit [CompleteSpace E] in | |
| lemma observed_fredholm_leftInverse [CompleteSpace E] (P : X βL[β] F) (hP : P.IsFredholm) | |
| (O : I β X βL[β] E) (hO : β x, (β i, O i x=0) β x=0) : | |
| β (s : Finset I) (L : F Γ (s β E) βL[β] X), | |
| LeftInverse L (P.prod (ContinuousLinearMap.pi (fun i : s => O i.val))) := by | |
| let := hP.finite_ker | |
| obtain β¨s,hsβ© := finite_separating_family (fun i => (O i).comp P.ker.subtypeL) | |
| (by | |
| intro v hv | |
| apply Subtype.ext | |
| exact hO v.val hv) | |
| let Q : X βL[β] (s β E) := ContinuousLinearMap.pi (fun i : s => O i.val) | |
| have hQ : Injective (Q.comp P.ker.subtypeL) := by | |
| intro u v huv | |
| apply sub_eq_zero.mp | |
| apply hs (u-v) | |
| intro i hi | |
| have hh := congrArg (fun f : s β E => f β¨i,hiβ©) huv | |
| change O i u.val=O i v.val at hh | |
| change O i (u.val-v.val)=0 | |
| rw [map_sub,hh,sub_self] | |
| obtain β¨L,hLβ© := fredholm_stabilized_leftInverse P hP Q hQ | |
| exact β¨s,L,hLβ© | |
| end Generic | |
| local instance jetObsInst1 : NormedAddCommGroup (COne β E) := inferInstance | |
| local instance jetObsInst2 : NormedSpace β (COne β E) := inferInstance | |
| def jetObservations (s : Finset PlaneTest) : COne β E βL[β] (s β E) := | |
| ContinuousLinearMap.pi (fun g => jetTestCLM g.val) | |
| omit [FiniteDimensional β E] in | |
| lemma jetObservations_translation_smooth [FiniteDimensional β E] (s : Finset PlaneTest) (u : COne β E) : | |
| ContDiff β β (fun t => jetObservations s (jetTranslate t u-u)) := | |
| contDiff_pi.mpr (fun g => jetTest_translation_difference_smooth g.val u) | |
| variable (S : Submodule β (COne β E)) | |
| local instance jetObsInst3 : NormedAddCommGroup S := inferInstance | |
| local instance jetObsInst4 : NormedSpace β S := inferInstance | |
| local instance jetObsInst5 : AddCommGroup S := (jetObsInst3 S).toAddCommGroup | |
| local instance jetObsInst6 : Module β S := (jetObsInst4 S).toModule | |
| def subspaceObservations (s : Finset PlaneTest) : S βL[β] (s β E) := | |
| (jetObservations s).comp S.subtypeL | |
| lemma exists_jet_fredholm_observations (P : S βL[β] F) (hP : P.IsFredholm) : | |
| β (s : Finset PlaneTest) (L : F Γ (s β E) βL[β] S), | |
| LeftInverse L (P.prod (subspaceObservations S s)) := by | |
| let O : PlaneTest β S βL[β] E := fun g => (jetTestCLM g).comp S.subtypeL | |
| have hO : β u : S, (β g, O g u=0) β u=0 := by | |
| intro u hu | |
| apply Subtype.ext | |
| exact jetTest_separates u.val hu | |
| have hh := observed_fredholm_leftInverse P hP O hO | |
| obtain β¨s,L,hLβ© := hh | |
| exact β¨s,L,hLβ© | |
| end HolderCompletion | |
| end | |
| section | |
| open scoped ContDiff Topology BoundedContinuousFunction | |
| open Set Function Filter | |
| namespace HolderCompletion | |
| variable {E : Type*} [NormedAddCommGroup E] [NormedSpace β E] [CompleteSpace E] | |
| local instance freeTransInst1 : NormedAddCommGroup (COne β E) := inferInstance | |
| local instance freeTransInst2 : NormedSpace β (COne β E) := inferInstance | |
| local instance freeTransInst3 : NormedAddCommGroup (HMap β E) := inferInstance | |
| local instance freeTransInst4 : NormedSpace β (HMap β E) := inferInstance | |
| def translationVariation (a : E) (u : COne β E) (t : β) : COne β E := | |
| constJet (t β’ a)+jetTranslate t u-u | |
| omit [CompleteSpace E] in | |
| @[simp] lemma translationVariation_value [CompleteSpace E] (a : E) (u : COne β E) (t z : β) : | |
| cValue (translationVariation a u t) z = t β’ a+cValue u (z+t)-cValue u z := rfl | |
| omit [CompleteSpace E] in | |
| @[simp] lemma translationVariation_deriv [CompleteSpace E] (a : E) (u : COne β E) (t z : β) : | |
| cDeriv (translationVariation a u t) z = cDeriv u (z+t)-cDeriv u z := by | |
| change (0 + cDeriv u (z+t))-cDeriv u z = _ | |
| rw [zero_add] | |
| omit [CompleteSpace E] in | |
| lemma translationVariation_zero [CompleteSpace E] (a : E) (u : COne β E) : translationVariation a u 0=0 := by | |
| apply cValue_ext | |
| intro z | |
| simp only [translationVariation_value,zero_smul,zero_add,add_zero,sub_self] | |
| rfl | |
| lemma translationVariation_CR (a : E) (u : COne β E) (t z : β) : | |
| valueCLM _ (standardJetCR (translationVariation a u t)) z = | |
| valueCLM _ (standardJetCR u) (z+t)-valueCLM _ (standardJetCR u) z := by | |
| simp only [standardJetCR_value,translationVariation_deriv,sub_apply,smul_sub] | |
| abel | |
| lemma translationVariation_mem {R S : β} (hRS : R+1 β€ S) | |
| (a : E) (u : freeModel (E := E) (Metric.closedBall (0:β) R)) | |
| {t : β} (ht : βtββ€1) : translationVariation a u.val tβfreeModel (E := E) (Metric.closedBall (0:β) S) := by | |
| apply (mem_supportedHolder _ _).mpr | |
| intro z hz | |
| have hzS : S < βzβ := by simpa only [Metric.mem_closedBall,dist_zero_right,not_le] using hz | |
| have hzR : zβMetric.closedBall (0:β) R := by | |
| simp only [Metric.mem_closedBall,dist_zero_right,not_le] | |
| linarith | |
| have hztR : z+tβMetric.closedBall (0:β) R := by | |
| simp only [Metric.mem_closedBall,dist_zero_right,not_le] | |
| have hnorm : βzβ β€ βz+tβ+βtβ := by | |
| simpa only [add_sub_cancel_right] using norm_sub_le (z+t) t | |
| linarith | |
| change valueCLM _ (standardJetCR (translationVariation a u.val t)) z = 0 | |
| have h0 : valueCLM _ (standardJetCR u.val) z=0 := (mem_supportedHolder _ _).mp u.property z hzR | |
| have h1 : valueCLM _ (standardJetCR u.val) (z+t)=0 := (mem_supportedHolder _ _).mp u.property (z+t) hztR | |
| rw [translationVariation_CR,h1,h0,sub_self] | |
| variable {R S : β} (hRS : R+1 β€ S) (a : E) | |
| (u : freeModel (E := E) (Metric.closedBall (0:β) R)) | |
| local instance freeTransInst5 : NormedAddCommGroup (freeModel (E := E) (Metric.closedBall (0:β) S)) := inferInstance | |
| local instance freeTransInst6 : NormedSpace β (freeModel (E := E) (Metric.closedBall (0:β) S)) := inferInstance | |
| def freeTranslation (t : β) : freeModel (E := E) (Metric.closedBall (0:β) S) := | |
| if ht : βtββ€1 then β¨translationVariation a u.val t,translationVariation_mem hRS a u htβ© else 0 | |
| lemma freeTranslation_near : βαΆ t in π (0:β), (freeTranslation hRS a u t).val=translationVariation a u.val t := by | |
| filter_upwards [Metric.ball_mem_nhds (0:β) (show (0:β)<1 by norm_num)] with t ht | |
| have ht' : βtββ€1 := (show βtβ<1 by simpa only [Metric.mem_ball,dist_zero_right] using ht).le | |
| simp only [freeTranslation,dite_eq_left ht'] | |
| @[simp] lemma freeTranslation_zero : freeTranslation hRS a u 0=0 := by | |
| apply Subtype.ext | |
| exact freeTranslation_near hRS a u |>.self_of_nhds |>.trans (translationVariation_zero a u.val) | |
| variable [FiniteDimensional β E] | |
| lemma translationVariation_observation_smooth (s : Finset PlaneTest) : | |
| ContDiff β β (fun t => jetObservations s (translationVariation a u.val t)) := by | |
| have he : (fun t => jetObservations s (translationVariation a u.val t)) = | |
| (fun t => jetObservations s (constJetCLM (complexSlope a t))+ | |
| jetObservations s (jetTranslate t u.val-u.val)) := by | |
| funext t | |
| rw [βmap_add] | |
| apply congrArg (jetObservations s) | |
| change constJet (t β’ a)+jetTranslate t u.val-u.val = constJet (t β’ a)+(jetTranslate t u.val-u.val) | |
| abel | |
| rw [he] | |
| exact ((jetObservations s).contDiff.comp ((constJetCLM (E := E)).contDiff.comp | |
| (complexSlope a).contDiff)).add (jetObservations_translation_smooth s u.val) | |
| lemma freeTranslation_observation_smoothAt (s : Finset PlaneTest) : | |
| ContDiffAt β β (fun t => subspaceObservations (freeModel (E := E) (Metric.closedBall (0:β) S)) s | |
| (freeTranslation hRS a u t)) 0 := by | |
| apply (translationVariation_observation_smooth a u s).contDiffAt.congr_of_eventuallyEq | |
| filter_upwards [freeTranslation_near hRS a u] with t ht | |
| exact congrArg (jetObservations s) ht | |
| end HolderCompletion | |
| end | |
| end HigherDimensionalBallPacking.Rigidity | |
| end | |
| end OAI | |