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