| 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 |
| 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 |
| 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 |
| ⟨c.base_ambient,c.base_domain⟩ |
|
|
| lemma partialHomeomorph_apply (v : {v : ℝ × X |
| 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 |
|
|
