Download data/lean/OAI/Geometry/BallPacking/Moduli/ZeroCharts.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 24.1 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/BallPacking/Moduli/ZeroCharts.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Geometry/BallPacking/Moduli/ZeroCharts.lean
-
curl -L -o ZeroCharts.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/BallPacking/Moduli/ZeroCharts.lean
24.1 kB
| import Mathlib | |
| import OAI.Geometry.BallPacking.Fredholm.ProjectionTimeGrid | |
| namespace OAI | |
| noncomputable section | |
| namespace HigherDimensionalBallPacking.Rigidity | |
| section | |
| open scoped ContDiff Topology | |
| open Set Function Filter | |
| variable {X Y E : Type*} [NormedAddCommGroup X] [NormedSpace β X] | |
| [NormedAddCommGroup Y] [NormedSpace β Y] | |
| [NormedAddCommGroup E] [NormedSpace β E] | |
| structure ZeroGraphChart (F : β Γ X β Y) (E : Type*) [NormedAddCommGroup E] [NormedSpace β E] where | |
| base : β Γ X | |
| zero_base : F base=0 | |
| coordinate : X βL[β] E | |
| reconstruct : β Γ E β X | |
| domain : Set (β Γ E) | |
| ambient : Set (β Γ X) | |
| domain_open : IsOpen domain | |
| ambient_open : IsOpen ambient | |
| base_domain : (base.1,coordinate base.2)βdomain | |
| base_ambient : baseβambient | |
| smooth : ContDiffOn β 2 reconstruct domain | |
| left_inv : β v,coordinate (reconstruct v)=v.2 | |
| zero : β vβdomain,F (v.1,reconstruct v)=0 | |
| image_ambient : β vβdomain,(v.1,reconstruct v)βambient | |
| complete : β vβambient,F v=0 β reconstruct (v.1,coordinate v.2)=v.2 | |
| omit [NormedSpace β Y] in | |
| lemma FiniteZeroGerm.graphChart [NormedSpace β Y] {F : β Γ X β Y} {t : β} {x : X} {m : β} | |
| (g : FiniteZeroGerm F t x m) (hz : F (t,x)=0) : | |
| β c : ZeroGraphChart F g.kernelSpace,c.base=(t,x) β§ c.coordinate=g.coordinate β§ c.reconstruct=g.reconstruct := by | |
| let a : β Γ g.kernelSpace := (t,g.coordinate x) | |
| let Ο : β Γ g.kernelSpace β β Γ X := fun q => (q.1,g.reconstruct q) | |
| have hΟ : ContDiffAt β β Ο a := contDiffAt_fst.prodMk g.smooth | |
| obtain β¨O,hOc,hOo,hOxβ© := mem_nhds_iff.mp g.complete | |
| obtain β¨S,hS,hSsβ© := g.smooth.contDiffOn (m := 2) (WithTop.coe_le_coe.mpr le_top) (by norm_num) | |
| have hΟa : Ο a=(t,x) := Prod.ext rfl g.base | |
| have hΟO : βαΆ q in π a,Ο qβO := hΟ.continuousAt (hΟa.symm βΈ hOo.mem_nhds hOx) | |
| obtain β¨D,hD,hDo,hDaβ© := mem_nhds_iff.mp (inter_mem hS (inter_mem g.zero hΟO)) | |
| refine β¨{ | |
| base := (t,x) | |
| zero_base := hz | |
| coordinate := g.coordinate | |
| reconstruct := g.reconstruct | |
| domain := D | |
| ambient := O | |
| domain_open := hDo | |
| ambient_open := hOo | |
| base_domain := hDa | |
| base_ambient := hOx | |
| smooth := hSs.mono (fun q hq => (hD hq).1) | |
| left_inv := g.left_inv | |
| zero := fun q hq => (hD hq).2.1 | |
| image_ambient := fun q hq => (hD hq).2.2 | |
| complete := fun v hv => hOc hv },rfl,rfl,rflβ© | |
| namespace ZeroGraphChart | |
| variable {F : β Γ X β Y} (c : ZeroGraphChart F E) | |
| def inverse (q : β Γ E) : {v : β Γ X // F v=0} := by | |
| classical | |
| exact if hq : qβc.domain then β¨(q.1,c.reconstruct q),c.zero q hqβ© else β¨c.base,c.zero_baseβ© | |
| omit [NormedSpace β Y] in | |
| lemma inverse_val [NormedSpace β Y] {q : β Γ E} (hq : qβc.domain) : (c.inverse q).val=(q.1,c.reconstruct q) := by | |
| rw [inverse,dite_eq_left hq] | |
| lemma inverse_continuousOn : ContinuousOn c.inverse c.domain := by | |
| rw [continuousOn_iff_continuous_domRestrict] | |
| apply continuous_induced_rng.mpr | |
| have hc : Continuous (fun q : c.domain => (q.val.1,c.reconstruct q.val)) := | |
| (continuous_fst.comp continuous_subtype_val).prodMk | |
| (continuousOn_iff_continuous_domRestrict.mp c.smooth.continuousOn) | |
| convert hc using 1 | |
| funext q | |
| exact c.inverse_val q.property | |
| def partialHomeomorph : OpenPartialHomeomorph {v : β Γ X // F v=0} (β Γ E) where | |
| toFun v := (v.val.1,c.coordinate v.val.2) | |
| invFun := c.inverse | |
| source := {v | v.valβc.ambient β§ (v.val.1,c.coordinate v.val.2)βc.domain} | |
| target := c.domain | |
| map_source' v hv := hv.2 | |
| map_target' q hq := by | |
| change (c.inverse q).valβc.ambient β§ ((c.inverse q).val.1,c.coordinate (c.inverse q).val.2)βc.domain | |
| rw [c.inverse_val hq] | |
| exact β¨c.image_ambient q hq,by simpa only [c.left_inv,Prod.mk.eta] using hqβ© | |
| left_inv' v hv := by | |
| apply Subtype.ext | |
| rw [c.inverse_val hv.2] | |
| exact Prod.ext rfl (c.complete v.val hv.1 v.property) | |
| right_inv' q hq := by | |
| rw [c.inverse_val hq] | |
| exact Prod.ext rfl (c.left_inv q) | |
| continuousOn_toFun := | |
| ((continuous_fst.comp continuous_subtype_val).prodMk | |
| (c.coordinate.continuous.comp (continuous_snd.comp continuous_subtype_val))).continuousOn | |
| continuousOn_invFun := c.inverse_continuousOn | |
| open_source := (c.ambient_open.preimage continuous_subtype_val).inter | |
| (c.domain_open.preimage ((continuous_fst.comp continuous_subtype_val).prodMk | |
| (c.coordinate.continuous.comp (continuous_snd.comp continuous_subtype_val)))) | |
| open_target := c.domain_open | |
| lemma base_mem_source : (β¨c.base,c.zero_baseβ© : {v : β Γ X // F v=0})βc.partialHomeomorph.source := | |
| β¨c.base_ambient,c.base_domainβ© | |
| lemma partialHomeomorph_apply (v : {v : β Γ X // F v=0}) : | |
| c.partialHomeomorph v=(v.val.1,c.coordinate v.val.2) := rfl | |
| lemma partialHomeomorph_symm_val {q : β Γ E} (hq : qβc.partialHomeomorph.target) : | |
| (c.partialHomeomorph.symm q).val=(q.1,c.reconstruct q) := c.inverse_val hq | |
| omit [NormedSpace β Y] in | |
| lemma transition_smooth [NormedSpace β Y] {E' : Type*} [NormedAddCommGroup E'] [NormedSpace β E'] | |
| (d : ZeroGraphChart F E') : ContDiffOn β 2 (fun q : β Γ E => (q.1,d.coordinate (c.reconstruct q))) c.domain := contDiffOn_fst.prodMk (d.coordinate.contDiff.comp_contDiffOn c.smooth)lemma transition_eq {E' : Type*} [NormedAddCommGroup E'] [NormedSpace β E'] | |
| (d : ZeroGraphChart F E') {q : β Γ E} (hq : qβc.domain) : d.partialHomeomorph (c.partialHomeomorph.symm q)=(q.1,d.coordinate (c.reconstruct q)) := by rw [d.partialHomeomorph_apply,c.partialHomeomorph_symm_val hq] | |
| end ZeroGraphChart | |
| end | |
| section | |
| open scoped ContDiff Topology | |
| open Set Function Filter | |
| variable {X Y : Type*} [NormedAddCommGroup X] [NormedSpace β X] [CompleteSpace X] | |
| [NormedAddCommGroup Y] [NormedSpace β Y] [CompleteSpace Y] | |
| variable {F : β Γ X β Y} {E : Submodule β Y} [FiniteDimensional β E] | |
| {V : Set (β Γ X)} (fr : StabilizedKernelFrame F E V) | |
| def StabilizedKernelFrame.kernelEquiv {v : β Γ X} (hv : vβV) : | |
| E ββ[β] ((pathSpatialDerivative F v).coprod E.subtypeL).ker := by | |
| let A := (pathSpatialDerivative F v).coprod E.subtypeL | |
| let B : E ββ[β] A.ker := (fr.frame v).toLinearMap.codRestrict A.ker (fr.kernel v hv) | |
| refine LinearEquiv.ofBijective B β¨?_,?_β© | |
| Β· intro e f he | |
| have hh := congrArg (fun z : A.ker => fr.coordinate v z.val) he | |
| change fr.coordinate v (fr.frame v e)=fr.coordinate v (fr.frame v f) at hh | |
| simpa only [fr.left_inv v hv] using hh | |
| Β· intro w | |
| refine β¨fr.coordinate v w.val,?_β© | |
| apply Subtype.ext | |
| exact fr.right_inv v hv w.val w.property | |
| include fr in | |
| lemma StabilizedKernelFrame.fredholm {v : β Γ X} (hv : vβV) | |
| (hs : Surjective ((pathSpatialDerivative F v).coprod E.subtypeL)) : | |
| ((pathSpatialDerivative F v).coprod E.subtypeL).IsFredholm := by | |
| let A := (pathSpatialDerivative F v).coprod E.subtypeL | |
| let e := fr.kernelEquiv hv | |
| let : FiniteDimensional β A.ker := Module.Finite.equiv e | |
| have htop : A.range=β€ := LinearMap.range_eq_top.mpr hs | |
| refine β¨(A.isOpenMap hs).isStrictMap A.continuous,?_,inferInstance,?_,?_β© | |
| Β· rw [htop] | |
| exact isClosed_univ | |
| Β· rw [htop] | |
| infer_instance | |
| Β· exact Submodule.ClosedComplemented.of_finiteDimensional _ | |
| include fr in | |
| lemma StabilizedKernelFrame.zero_germ (hF : ContDiff β β F) | |
| {t : β} {x : X} {e : E} (hv : (t,x)βV) | |
| (hs : Surjective ((pathSpatialDerivative F (t,x)).coprod E.subtypeL)) | |
| (hz : finiteTargetAugment F E (t,(x,e))=0) : | |
| Nonempty (FiniteZeroGerm (finiteTargetAugment F E) t (x,e) (Module.finrank β E)) := by | |
| let A := (pathSpatialDerivative F (t,x)).coprod E.subtypeL | |
| have hd : HasFDerivAt (fun w : X Γ E => finiteTargetAugment F E (t,w)) A (x,e) := by | |
| have hsl : ContDiff β β (fun w : X Γ E => finiteTargetAugment F E (t,w)) := | |
| (finiteTargetAugment_smooth hF E).comp (contDiff_const.prodMk contDiff_id) | |
| have h := (hsl.differentiable (by simp) (x,e)).hasFDerivAt | |
| rwa [finiteTargetAugment_spatial_derivative hF E t x e] at h | |
| have hdim : Module.finrank β E=Module.finrank β A.ker := (fr.kernelEquiv hv).finrank_eq | |
| rw [hdim] | |
| exact finiteZeroGerm_of_surjective (finiteTargetAugment_smooth hF E) hd (fr.fredholm hv hs) hs hz | |
| end | |
| section | |
| open scoped ContDiff Topology | |
| open Set Function Filter | |
| variable {X Y E E' : Type*} [NormedAddCommGroup X] [NormedSpace β X] | |
| [NormedAddCommGroup Y] [NormedSpace β Y] | |
| [NormedAddCommGroup E] [NormedSpace β E] | |
| [NormedAddCommGroup E'] [NormedSpace β E'] | |
| variable {F : β Γ X β Y} | |
| def ZeroGraphChart.reparam (c : ZeroGraphChart F E) (e : E βL[β] E') : ZeroGraphChart F E' where | |
| base := c.base | |
| zero_base := c.zero_base | |
| coordinate := e.toContinuousLinearMap.comp c.coordinate | |
| reconstruct := fun q => c.reconstruct (q.1,e.symm q.2) | |
| domain := (fun q : β Γ E' => (q.1,e.symm q.2)) β»ΒΉ' c.domain | |
| ambient := c.ambient | |
| domain_open := c.domain_open.preimage (continuous_fst.prodMk (e.symm.continuous.comp continuous_snd)) | |
| ambient_open := c.ambient_open | |
| base_domain := by | |
| change (c.base.1,e.symm (e (c.coordinate c.base.2)))βc.domain | |
| simpa only [e.symm_apply_apply] using c.base_domain | |
| base_ambient := c.base_ambient | |
| smooth := c.smooth.comp (contDiffOn_fst.prodMk (e.symm.contDiff.contDiffOn.comp contDiffOn_snd (mapsTo_univ _ _))) | |
| (fun _ h => h) | |
| left_inv := by | |
| intro q | |
| change e (c.coordinate (c.reconstruct (q.1,e.symm q.2)))=q.2 | |
| rw [c.left_inv,e.apply_symm_apply] | |
| zero := by | |
| intro q hq | |
| exact c.zero (q.1,e.symm q.2) hq | |
| image_ambient := fun q hq => c.image_ambient (q.1,e.symm q.2) hq | |
| complete := by | |
| intro v hv hz | |
| change c.reconstruct (v.1,e.symm (e (c.coordinate v.2)))=v.2 | |
| rw [e.symm_apply_apply] | |
| exact c.complete v hv hz | |
| lemma FiniteZeroGerm.common_graphChart {t : β} {x : X} {m : β} | |
| (g : FiniteZeroGerm F t x m) (hz : F (t,x)=0) | |
| [FiniteDimensional β E] (hd : Module.finrank β E=m) : | |
| β c : ZeroGraphChart F E,c.base=(t,x) := by | |
| let := g.finite_kernel | |
| let e : g.kernelSpace βL[β] E := ContinuousLinearEquiv.ofFinrankEq (g.dimension.trans hd.symm) | |
| obtain β¨c,hb,hp,hrβ© := g.graphChart hz | |
| exact β¨c.reparam e,hbβ© | |
| end | |
| section | |
| open scoped ContDiff Topology | |
| open Set Function Filter | |
| variable {X Y E : Type*} [NormedAddCommGroup X] [NormedSpace β X] | |
| [NormedAddCommGroup Y] [NormedSpace β Y] | |
| [NormedAddCommGroup E] [NormedSpace β E] | |
| variable {F : β Γ X β Y} (c : ZeroGraphChart F E) | |
| def ZeroGraphChart.spatialDerivative (q : β Γ E) : E βL[β] X := | |
| (fderiv β c.reconstruct q).comp (ContinuousLinearMap.inr β β E) | |
| omit [NormedSpace β Y] in | |
| lemma ZeroGraphChart.spatialDerivative_continuous [NormedSpace β Y] : ContinuousOn c.spatialDerivative c.domain := by | |
| exact (c.smooth.continuousOn_fderiv_of_isOpen c.domain_open (by norm_num)).clm_comp continuousOn_const | |
| omit [NormedSpace β Y] in | |
| lemma ZeroGraphChart.hasSpatialDerivative [NormedSpace β Y] {q : β Γ E} (hq : qβc.domain) : | |
| HasFDerivAt (fun e => c.reconstruct (q.1,e)) (c.spatialDerivative q) q.2 := by | |
| have hd : DifferentiableAt β c.reconstruct q := | |
| (c.smooth.contDiffAt (c.domain_open.mem_nhds hq)).differentiableAt (by norm_num) | |
| exact hd.hasFDerivAt.comp q.2 ((hasFDerivAt_const q.1 q.2).prodMk (hasFDerivAt_id q.2)) | |
| lemma ZeroGraphChart.spatialDerivative_coordinate {q : β Γ E} (hq : qβc.domain) (e : E) : | |
| c.coordinate (c.spatialDerivative q e)=e := by | |
| have hd := c.coordinate.hasFDerivAt.comp q.2 (c.hasSpatialDerivative hq) | |
| have he : (fun z => c.coordinate (c.reconstruct (q.1,z)))=id := funext (fun z => c.left_inv _) | |
| simp only [Function.comp_def] at hd | |
| rw [he] at hd | |
| have hh := hd.unique (hasFDerivAt_id q.2) | |
| exact congrArg (fun A : E βL[β] E => A e) hh | |
| lemma ZeroGraphChart.spatialDerivative_injective {q : β Γ E} (hq : qβc.domain) : | |
| Injective (c.spatialDerivative q) := by | |
| intro e f he | |
| have hh := congrArg c.coordinate he | |
| simpa only [c.spatialDerivative_coordinate hq] using hh | |
| variable [CompleteSpace X] [CompleteSpace Y] | |
| lemma ZeroGraphChart.spatialDerivative_kernel (hF : ContDiff β β F) | |
| {q : β Γ E} (hq : qβc.domain) (e : E) : | |
| pathSpatialDerivative F (q.1,c.reconstruct q) (c.spatialDerivative q e)=0 := by | |
| have hsl : ContDiff β β (fun x => F (q.1,x)) := hF.comp (contDiff_const.prodMk contDiff_id) | |
| have hd := (hsl.differentiable (by simp) (c.reconstruct q)).hasFDerivAt.comp q.2 | |
| (c.hasSpatialDerivative hq) | |
| have he : (fun z => F (q.1,c.reconstruct (q.1,z))) =αΆ [π q.2] (fun _ => 0) := by | |
| have hm : βαΆ z in π q.2,(q.1,z)βc.domain := | |
| (continuousAt_const.prodMk continuousAt_id) (c.domain_open.mem_nhds hq) | |
| filter_upwards [hm] with z hz | |
| exact c.zero (q.1,z) hz | |
| have hz := hd.fderiv.symm.trans (he.fderiv_eq) | |
| simp only [fderiv_fun_const] at hz | |
| rw [pathSpatialDerivative_eq hF] | |
| exact congrArg (fun A : E βL[β] Y => A e) hz | |
| end | |
| section | |
| open scoped ContDiff Topology | |
| open Set Function Filter | |
| variable {X Y : Type*} [NormedAddCommGroup X] [NormedSpace β X] [CompleteSpace X] | |
| [NormedAddCommGroup Y] [NormedSpace β Y] [CompleteSpace Y] | |
| variable {F : β Γ X β Y} {E : Submodule β Y} [FiniteDimensional β E] | |
| {V : Set (β Γ X)} (fr : StabilizedKernelFrame F E V) | |
| (c : ZeroGraphChart (finiteTargetAugment F E) E) | |
| def framedChartJacobian (q : β Γ E) : E βL[β] E := | |
| (fr.coordinate (q.1,(c.reconstruct q).1)).comp (c.spatialDerivative q) | |
| lemma framedChartJacobian_injective (hF : ContDiff β β F) {q : β Γ E} | |
| (hq : qβc.domain) (hv : (q.1,(c.reconstruct q).1)βV) : | |
| Injective (framedChartJacobian fr c q) := by | |
| have hk (e : E) : ((pathSpatialDerivative F (q.1,(c.reconstruct q).1)).coprod E.subtypeL) | |
| (c.spatialDerivative q e)=0 := by | |
| have hh := c.spatialDerivative_kernel (finiteTargetAugment_smooth hF E) hq e | |
| rw [pathSpatialDerivative_eq (finiteTargetAugment_smooth hF E),finiteTargetAugment_spatial_derivative hF] at hh | |
| exact hh | |
| intro e f he | |
| apply c.spatialDerivative_injective hq | |
| have hh := congrArg (fr.frame (q.1,(c.reconstruct q).1)) he | |
| exact (fr.right_inv _ hv _ (hk e)).symm.trans (hh.trans (fr.right_inv _ hv _ (hk f))) | |
| lemma framedChartJacobian_bijective (hF : ContDiff β β F) {q : β Γ E} | |
| (hq : qβc.domain) (hv : (q.1,(c.reconstruct q).1)βV) : | |
| Bijective (framedChartJacobian fr c q) := | |
| β¨framedChartJacobian_injective fr c hF hq hv, | |
| (LinearMap.injective_iff_surjective).mp (framedChartJacobian_injective fr c hF hq hv)β© | |
| lemma framedChartJacobian_det_ne_zero (hF : ContDiff β β F) {q : β Γ E} | |
| (hq : qβc.domain) (hv : (q.1,(c.reconstruct q).1)βV) : | |
| (framedChartJacobian fr c q).detβ 0 := by | |
| let A := LinearEquiv.ofBijective (framedChartJacobian fr c q).toLinearMap | |
| (framedChartJacobian_bijective fr c hF hq hv) | |
| exact A.isUnit_det'.ne_zeroomit [CompleteSpace X] [CompleteSpace Y] [FiniteDimensional β E] in | |
| lemma framedChartJacobian_continuous [CompleteSpace X] [CompleteSpace Y] [FiniteDimensional β E] : | |
| ContinuousOn (framedChartJacobian fr c) (c.domain β© {q | (q.1,(c.reconstruct q).1)βV}) := by | |
| apply ContinuousOn.clm_comp | |
| Β· exact fr.coordinate_continuous.comp | |
| ((continuousOn_fst.mono inter_subset_left).prodMk | |
| (continuous_fst.continuousOn.comp (c.smooth.continuousOn.mono inter_subset_left) | |
| (mapsTo_univ _ _))) (fun _ h => h.2) | |
| Β· exact c.spatialDerivative_continuous.mono inter_subset_left | |
| lemma framedChart_orientation_neighborhood (hF : ContDiff β β F) (hV : IsOpen V) | |
| {q : β Γ E} (hq : qβc.domain) (hv : (q.1,(c.reconstruct q).1)βV) : | |
| β O : Set (β Γ E),IsOpen O β§ qβO β§ Oβc.domain β§ | |
| β rβO,0<(framedChartJacobian fr c r).det*(framedChartJacobian fr c q).det := by | |
| have hn := framedChartJacobian_det_ne_zero fr c hF hq hv | |
| have hm : c.domain β© {r | (r.1,(c.reconstruct r).1)βV}βπ q := by | |
| apply inter_mem (c.domain_open.mem_nhds hq) | |
| exact (continuousAt_fst.prodMk | |
| (continuous_fst.continuousAt.comp (c.smooth.contDiffAt (c.domain_open.mem_nhds hq)).continuousAt)) | |
| (hV.mem_nhds hv) | |
| have hc : ContinuousAt (fun r => (framedChartJacobian fr c r).det) q := | |
| ContinuousLinearMap.continuous_det.continuousAt.comp | |
| ((framedChartJacobian_continuous fr c q β¨hq,hvβ©).continuousAt hm) | |
| have hp : βαΆ r in π q,0<(framedChartJacobian fr c r).det*(framedChartJacobian fr c q).det := | |
| (hc.mul_const _).eventually (lt_mem_nhds (mul_self_pos.mpr hn)) | |
| obtain β¨O,hO,hOo,hOqβ© := mem_nhds_iff.mp (inter_mem (c.domain_open.mem_nhds hq) hp) | |
| exact β¨O,hOo,hOq,fun _ h => (hO h).1,fun _ h => (hO h).2β© | |
| end | |
| section | |
| open scoped ContDiff Topology | |
| open Set Function Filter | |
| variable {X Y E : Type*} [NormedAddCommGroup X] [NormedSpace β X] | |
| [NormedAddCommGroup Y] [NormedSpace β Y] | |
| [NormedAddCommGroup E] [NormedSpace β E] | |
| variable {F : β Γ X β Y} (c d : ZeroGraphChart F E) | |
| lemma zeroChart_transition_derivative {q : β Γ E} (hq : qβc.domain) | |
| (ha : (q.1,c.reconstruct q)βd.ambient) | |
| (hr : (q.1,d.coordinate (c.reconstruct q))βd.domain) : | |
| (d.spatialDerivative (q.1,d.coordinate (c.reconstruct q))).comp | |
| (d.coordinate.comp (c.spatialDerivative q))=c.spatialDerivative q := by | |
| have hc := c.hasSpatialDerivative hq | |
| have hd := (d.hasSpatialDerivative hr).comp q.2 (d.coordinate.hasFDerivAt.comp q.2 hc) | |
| have he : (fun z => d.reconstruct (q.1,d.coordinate (c.reconstruct (q.1,z)))) =αΆ [π q.2] | |
| (fun z => c.reconstruct (q.1,z)) := by | |
| have hm : βαΆ z in π q.2,(q.1,z)βc.domain := | |
| (continuousAt_const.prodMk continuousAt_id) (c.domain_open.mem_nhds hq) | |
| have hn : βαΆ z in π q.2,(q.1,c.reconstruct (q.1,z))βd.ambient := | |
| (continuousAt_const.prodMk hc.continuousAt) (d.ambient_open.mem_nhds ha) | |
| filter_upwards [hm,hn] with z hz hza | |
| exact d.complete (q.1,c.reconstruct (q.1,z)) hza (c.zero (q.1,z) hz) | |
| exact hd.fderiv.symm.trans (he.fderiv_eq.trans hc.fderiv) | |
| end | |
| section | |
| open scoped ContDiff Topology | |
| open Set Function Filter | |
| variable {X Y : Type*} [NormedAddCommGroup X] [NormedSpace β X] [CompleteSpace X] | |
| [NormedAddCommGroup Y] [NormedSpace β Y] [CompleteSpace Y] | |
| variable {F : β Γ X β Y} {E : Submodule β Y} [FiniteDimensional β E] | |
| {V : Set (β Γ X)} (fr : StabilizedKernelFrame F E V) | |
| (c d : ZeroGraphChart (finiteTargetAugment F E) E) | |
| omit [CompleteSpace X] [CompleteSpace Y] [FiniteDimensional β E] in | |
| lemma framedChart_transition_identity [CompleteSpace X] [CompleteSpace Y] [FiniteDimensional β E] | |
| {q : β Γ E} (hq : qβc.domain) | |
| (ha : (q.1,c.reconstruct q)βd.ambient) | |
| (hr : (q.1,d.coordinate (c.reconstruct q))βd.domain) : | |
| (framedChartJacobian fr d (q.1,d.coordinate (c.reconstruct q))).comp | |
| (d.coordinate.comp (c.spatialDerivative q))=framedChartJacobian fr c q := by | |
| have he := d.complete (q.1,c.reconstruct q) ha (c.zero q hq) | |
| change ((fr.coordinate (q.1,(d.reconstruct (q.1,d.coordinate (c.reconstruct q))).1)).comp | |
| (d.spatialDerivative (q.1,d.coordinate (c.reconstruct q)))).comp _=_ | |
| rw [he,ContinuousLinearMap.comp_assoc,zeroChart_transition_derivative c d hq ha hr] | |
| rfl | |
| lemma framedChart_transition_det {q : β Γ E} (hq : qβc.domain) | |
| (ha : (q.1,c.reconstruct q)βd.ambient) | |
| (hr : (q.1,d.coordinate (c.reconstruct q))βd.domain) : | |
| (framedChartJacobian fr d (q.1,d.coordinate (c.reconstruct q))).det * | |
| (d.coordinate.comp (c.spatialDerivative q)).det=(framedChartJacobian fr c q).det := by | |
| have he := congrArg (fun A : E βL[β] E => A.det) (framedChart_transition_identity fr c d hq ha hr) | |
| change LinearMap.det ((framedChartJacobian fr d (q.1,d.coordinate (c.reconstruct q))).toLinearMap.comp | |
| (d.coordinate.comp (c.spatialDerivative q)).toLinearMap)=_ at he | |
| simpa only [LinearMap.det_comp] using he | |
| lemma framedChart_transition_signed_det (hF : ContDiff β β F) | |
| {q : β Γ E} (hq : qβc.domain) (hv : (q.1,(c.reconstruct q).1)βV) | |
| (ha : (q.1,c.reconstruct q)βd.ambient) | |
| (hr : (q.1,d.coordinate (c.reconstruct q))βd.domain) : | |
| Real.sign (framedChartJacobian fr c q).det * (d.coordinate.comp (c.spatialDerivative q)).det = | |
| Real.sign (framedChartJacobian fr d (q.1,d.coordinate (c.reconstruct q))).det * | |
| |(d.coordinate.comp (c.spatialDerivative q)).det| := by | |
| have he := framedChart_transition_det fr c d hq ha hr | |
| have hn := framedChartJacobian_det_ne_zero fr c hF hq hv | |
| have hn' : (framedChartJacobian fr d (q.1,d.coordinate (c.reconstruct q))).detβ 0 := by | |
| intro hz | |
| rw [hz,zero_mul] at he | |
| exact hn he.symm | |
| have htn : (d.coordinate.comp (c.spatialDerivative q)).detβ 0 := by | |
| intro hz | |
| rw [hz,mul_zero] at he | |
| exact hn he.symm | |
| rw [βhe] | |
| rcases lt_or_gt_of_ne hn' with hd | hd <;> rcases lt_or_gt_of_ne htn with ht | ht | |
| Β· rw [Real.sign_of_pos (mul_pos_of_neg_of_neg hd ht),Real.sign_of_neg hd,abs_of_neg ht] | |
| ring | |
| Β· rw [Real.sign_of_neg (mul_neg_of_neg_of_pos hd ht),Real.sign_of_neg hd,abs_of_pos ht] | |
| Β· rw [Real.sign_of_neg (mul_neg_of_pos_of_neg hd ht),Real.sign_of_pos hd,abs_of_neg ht] | |
| ring | |
| Β· rw [Real.sign_of_pos (mul_pos hd ht),Real.sign_of_pos hd,abs_of_pos ht] | |
| end | |
| open scoped ContDiff Topology | |
| open Set Function Filter | |
| variable {P Q Y : Type*} [NormedAddCommGroup P] [NormedSpace β P] [CompleteSpace P] | |
| [NormedAddCommGroup Q] [NormedSpace β Q] [CompleteSpace Q] | |
| [NormedAddCommGroup Y] [NormedSpace β Y] [CompleteSpace Y] | |
| lemma smooth_actual_implicit_branch {f : P Γ Q β Y} (hf : ContDiff β β f) | |
| {Ο : P β Q} {D : Set P} (hD : IsOpen D) (hΟ : ContinuousOn Ο D) (z : Y) | |
| (hz : β pβD,f (p,Ο p)=z) | |
| (hi : β pβD,((fderiv β f (p,Ο p)).comp (ContinuousLinearMap.inr β P Q)).IsInvertible) : | |
| ContDiffOn β β Ο D := by | |
| intro p hp | |
| let g := hf.contDiffAt.implicitFunction (by simp) (hi p hp) | |
| have hg : ContDiffAt β β g p := hf.contDiffAt.contDiffAt_implicitFunction (by simp) (hi p hp) | |
| have he : Ο =αΆ [π p] g := by | |
| have hh := hf.contDiffAt.eventually_apply_eq_iff_implicitFunction (by simp) (hi p hp) | |
| have hc : ContinuousAt (fun r => (r,Ο r)) p := | |
| continuousAt_id.prodMk ((hΟ p hp).continuousAt (hD.mem_nhds hp)) | |
| have hm := hc hh | |
| filter_upwards [hm,hD.mem_nhds hp] with r hr hrD | |
| exact ((hr).mp ((hz r hrD).trans (hz p hp).symm)).symm | |
| exact (hg.congr_of_eventuallyEq he).contDiffWithinAt | |
| lemma implicitFunction_smooth_neighborhood {f : P Γ Q β Y} (hf : ContDiff β β f) | |
| {u : P Γ Q} (hi : ((fderiv β f u).comp (ContinuousLinearMap.inr β P Q)).IsInvertible) : | |
| β D : Set P,IsOpen D β§ u.1βD β§ | |
| ContDiffOn β β (hf.contDiffAt.implicitFunction (by simp) hi) D := by | |
| let Ο := hf.contDiffAt.implicitFunction (by simp) hi | |
| have hs : ContDiffAt β β Ο u.1 := hf.contDiffAt.contDiffAt_implicitFunction (by simp) hi | |
| have hb : Ο u.1=u.2 := hf.contDiffAt.implicitFunction_apply_self (by simp) hi | |
| obtain β¨S,hSn,hSsβ© := hs.contDiffOn (m := 1) (by simp) (by simp) | |
| have hΟf : βαΆ p in π u.1,f (p,Ο p)=f u := hf.contDiffAt.eventually_apply_implicitFunction (by simp) hi | |
| have hder : Continuous (fun v : P Γ Q => (fderiv β f v).comp (ContinuousLinearMap.inr β P Q)) := | |
| (hf.continuous_fderiv (by simp)).clm_comp continuous_const | |
| have hival : ((fderiv β f (u.1,Ο u.1)).comp (ContinuousLinearMap.inr β P Q)).IsInvertible := by | |
| simpa only [hb,Prod.mk.eta] using hi | |
| have hin : βαΆ p in π u.1,((fderiv β f (p,Ο p)).comp (ContinuousLinearMap.inr β P Q)).IsInvertible := | |
| (hder.continuousAt.comp (continuousAt_id.prodMk hs.continuousAt)) | |
| (ContinuousLinearEquiv.isOpen.mem_nhds hival) | |
| obtain β¨D,hD,hDo,hDuβ© := mem_nhds_iff.mp (inter_mem hSn (inter_mem hΟf hin)) | |
| refine β¨D,hDo,hDu,smooth_actual_implicit_branch hf hDo (hSs.continuousOn.mono (fun _ h => (hD h).1)) | |
| (f u) (fun _ h => (hD h).2.1) (fun _ h => (hD h).2.2)β© | |
| end HigherDimensionalBallPacking.Rigidity | |
| end | |
| end OAI | |