Download data/lean/OAI/Geometry/KahlerSplitting/BlockMaps.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 16.7 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/KahlerSplitting/BlockMaps.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Geometry/KahlerSplitting/BlockMaps.lean
-
curl -L -o BlockMaps.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/KahlerSplitting/BlockMaps.lean
16.7 kB
| import OAI.Geometry.KahlerSplitting.DiskAxes | |
| namespace OAI | |
| section | |
| noncomputable section | |
| open Set Filter Topology | |
| open scoped Manifold | |
| namespace UniversalCoverSplitting | |
| variable {n r s : β} {X : ComplexManifold n} {S : HolomorphicSplitting X r s} | |
| variable {E F : Type*} [NormedAddCommGroup E] [NormedSpace β E] | |
| [NormedAddCommGroup F] [NormedSpace β F] | |
| def IsBlockBox (S : HolomorphicSplitting X r s) (U : Set (E Γ F)) (f : E Γ F β X.Carrier) : Prop := | |
| MDifferentiableOn π(β,E Γ F) (model n) f U β§ β z β U, | |
| (β v : E, S.projection (f z) (mfderiv π(β,E Γ F) (model n) f z (v,0)) = | |
| mfderiv π(β,E Γ F) (model n) f z (v,0)) β§ | |
| (β w : F, S.projection (f z) (mfderiv π(β,E Γ F) (model n) f z (0,w)) = 0) | |
| lemma IsBlockBox.mono {U V : Set (E Γ F)} {f : E Γ F β X.Carrier} | |
| (hf : IsBlockBox S U f) (hV : V β U) : IsBlockBox S V f := | |
| β¨hf.1.mono hV,fun z hz β¦ hf.2 z (hV hz)β© | |
| lemma SplittingChart.block_coordinates (e : SplittingChart S) {U : Set (E Γ F)} | |
| (hU : IsOpen U) {f : E Γ F β X.Carrier} (hf : IsBlockBox S U f) | |
| (he : MapsTo f U e.chart.source) : | |
| DifferentiableOn β (e.chart β f) U β§ β z β U, | |
| (β v : E, (fderiv β (e.chart β f) z (v,0)).2=0) β§ | |
| (β w : F, (fderiv β (e.chart β f) z (0,w)).1=0) := by | |
| refine β¨mdifferentiableOn_iff_differentiableOn.mp (e.holomorphic.comp hf.1 he),?_β© | |
| intro z hz | |
| have h := mfderiv_comp z (e.holomorphic.mdifferentiableAt (e.chart.open_source.mem_nhds (he hz))) | |
| (hf.1.mdifferentiableAt (hU.mem_nhds hz)) | |
| change (mfderiv π(β,E Γ F) π(β,Model r Γ Model s) (e.chart β f) z : | |
| (E Γ F) βL[β] (Model r Γ Model s)) = | |
| (mfderiv (model n) π(β,Model r Γ Model s) e.chart (f z)).comp | |
| (mfderiv π(β,E Γ F) (model n) f z) at h | |
| simp only [mfderiv_eq_fderiv] at h | |
| rw [h] | |
| exact β¨fun v β¦ (e.horizontal _ (he hz) _).mp ((hf.2 z hz).1 v), | |
| fun w β¦ (e.vertical _ (he hz) _).mp ((hf.2 z hz).2 w)β© | |
| lemma SplittingChart.block_of_coordinate_tangencies (e : SplittingChart S) | |
| {U : Set (E Γ F)} (hU : IsOpen U) {f : E Γ F β Model r Γ Model s} | |
| (hf : DifferentiableOn β f U) (hmap : MapsTo f U e.chart.target) | |
| (ht : β z β U, (β v : E, (fderiv β f z (v,0)).2=0) β§ | |
| (β w : F, (fderiv β f z (0,w)).1=0)) : IsBlockBox S U (e.chart.symm β f) := by | |
| refine β¨e.inverse_holomorphic.comp (mdifferentiableOn_iff_differentiableOn.mpr hf) hmap,?_β© | |
| intro z hz | |
| have h := mfderiv_comp z | |
| (e.inverse_holomorphic.mdifferentiableAt (e.chart.open_target.mem_nhds (hmap hz))) | |
| (mdifferentiableAt_iff_differentiableAt.mpr (hf.differentiableAt (hU.mem_nhds hz))) | |
| change (mfderiv π(β,E Γ F) (model n) (e.chart.symm β f) z : (E Γ F) βL[β] Model n) = | |
| (mfderiv π(β,Model r Γ Model s) (model n) e.chart.symm (f z)).comp | |
| (mfderiv π(β,E Γ F) π(β,Model r Γ Model s) f z) at h | |
| simp only [mfderiv_eq_fderiv] at h | |
| constructor | |
| Β· intro v | |
| apply (e.horizontal _ (e.chart.map_target (hmap hz)) _).mpr | |
| rw [h] | |
| exact (e.inverse_derivative (hmap hz) (fderiv β f z (v,0))) βΈ (ht z hz).1 v | |
| Β· intro w | |
| apply (e.vertical _ (e.chart.map_target (hmap hz)) _).mpr | |
| rw [h] | |
| exact (e.inverse_derivative (hmap hz) (fderiv β f z (0,w))) βΈ (ht z hz).2 w | |
| lemma SplittingChart.inverse_isBlockBox (e : SplittingChart S) : | |
| IsBlockBox S e.chart.target e.chart.symm := by | |
| simpa only [Function.comp_id] using e.block_of_coordinate_tangencies e.chart.open_target | |
| differentiable_id.differentiableOn (mapsTo_id _) | |
| (by intro z _; simp) | |
| lemma SplittingChart.mix_block_maps (e : SplittingChart S) {U : Set (E Γ F)} | |
| (hU : IsOpen U) {f g : E Γ F β X.Carrier} (hf : IsBlockBox S U f) (hg : IsBlockBox S U g) | |
| (hfe : MapsTo f U e.chart.source) (hge : MapsTo g U e.chart.source) : | |
| IsBlockBox S U (fun z β¦ e.chart.symm ((e.chart (f z)).1,(e.chart (g z)).2)) := by | |
| have hfc := e.block_coordinates hU hf hfe | |
| have hgc := e.block_coordinates hU hg hge | |
| let k : E Γ F β Model r Γ Model s := fun z β¦ ((e.chart (f z)).1,(e.chart (g z)).2) | |
| have hk : DifferentiableOn β k U := hfc.1.fst.prodMk hgc.1.snd | |
| apply e.block_of_coordinate_tangencies hU hk | |
| Β· intro z hz | |
| have hfT := e.chart.map_source (hfe hz) | |
| have hgT := e.chart.map_source (hge hz) | |
| rw [e.product_range] at hfT hgT β’ | |
| exact β¨hfT.1,hgT.2β© | |
| Β· intro z hz | |
| have hdβ := (hfc.1.differentiableAt (hU.mem_nhds hz)).hasFDerivAt.fst | |
| have hdβ := (hgc.1.differentiableAt (hU.mem_nhds hz)).hasFDerivAt.snd | |
| have hd := (hdβ.prodMk hdβ).fderiv | |
| change fderiv β k z = _ at hd | |
| rw [hd] | |
| exact β¨fun v β¦ (hgc.2 z hz).1 v,fun w β¦ (hfc.2 z hz).2 wβ© | |
| end UniversalCoverSplitting | |
| end | |
| end | |
| section | |
| noncomputable section | |
| open Set Metric Filter Topology | |
| open scoped Manifold | |
| namespace UniversalCoverSplitting | |
| variable {n r s : β} {X : ComplexManifold n} {S : HolomorphicSplitting X r s} | |
| variable {E F G : Type*} [NormedAddCommGroup E] [NormedSpace β E] | |
| [NormedAddCommGroup F] [NormedSpace β F] [NormedAddCommGroup G] [NormedSpace β G] | |
| def IsHorizontalMap (S : HolomorphicSplitting X r s) (U : Set E) (f : E β X.Carrier) : Prop := | |
| MDifferentiableOn π(β,E) (model n) f U β§ β z β U, β v : E, | |
| S.projection (f z) (mfderiv π(β,E) (model n) f z v) = mfderiv π(β,E) (model n) f z v | |
| def IsVerticalMap (S : HolomorphicSplitting X r s) (U : Set E) (f : E β X.Carrier) : Prop := | |
| MDifferentiableOn π(β,E) (model n) f U β§ β z β U, β v : E, | |
| S.projection (f z) (mfderiv π(β,E) (model n) f z v) = 0 | |
| lemma IsHorizontalMap.comp {U : Set E} {V : Set F} (hU : IsOpen U) (hV : IsOpen V) | |
| {f : E β X.Carrier} (hf : IsHorizontalMap S U f) {q : F β E} | |
| (hq : DifferentiableOn β q V) (hmap : MapsTo q V U) : IsHorizontalMap S V (f β q) := by | |
| refine β¨hf.1.comp (mdifferentiableOn_iff_differentiableOn.mpr hq) hmap,?_β© | |
| intro z hz v | |
| rw [mfderiv_comp z (hf.1.mdifferentiableAt (hU.mem_nhds (hmap hz))) | |
| (mdifferentiableAt_iff_differentiableAt.mpr (hq.differentiableAt (hV.mem_nhds hz)))] | |
| exact hf.2 _ (hmap hz) _ | |
| lemma IsVerticalMap.comp {U : Set E} {V : Set F} (hU : IsOpen U) (hV : IsOpen V) | |
| {f : E β X.Carrier} (hf : IsVerticalMap S U f) {q : F β E} | |
| (hq : DifferentiableOn β q V) (hmap : MapsTo q V U) : IsVerticalMap S V (f β q) := by | |
| refine β¨hf.1.comp (mdifferentiableOn_iff_differentiableOn.mpr hq) hmap,?_β© | |
| intro z hz v | |
| rw [mfderiv_comp z (hf.1.mdifferentiableAt (hU.mem_nhds (hmap hz))) | |
| (mdifferentiableAt_iff_differentiableAt.mpr (hq.differentiableAt (hV.mem_nhds hz)))] | |
| exact hf.2 _ (hmap hz) _ | |
| lemma IsHorizontalMap.curve {U : Set β} {f : β β X.Carrier} (hf : IsHorizontalMap S U f) : | |
| IsHorizontalCurve S U f := β¨hf.1,fun z hz β¦ hf.2 z hz 1β© | |
| lemma IsVerticalMap.curve {U : Set β} {f : β β X.Carrier} (hf : IsVerticalMap S U f) : | |
| IsVerticalCurve S U f := β¨hf.1,fun z hz β¦ hf.2 z hz 1β© | |
| lemma IsHorizontalMap.block {U : Set E} {V : Set F} (hU : IsOpen U) (hV : IsOpen V) | |
| {f : E β X.Carrier} (hf : IsHorizontalMap S U f) : | |
| IsBlockBox S (U ΓΛ’ V) (fun z : E Γ F β¦ f z.1) := by | |
| have hc := hf.comp hU (hU.prod hV) differentiable_fst.differentiableOn | |
| (show MapsTo Prod.fst (U ΓΛ’ V) U from fun _ h β¦ h.1) | |
| refine β¨hc.1,fun z hz β¦ β¨fun v β¦ hc.2 z hz (v,0),fun w β¦ ?_β©β© | |
| have hd := mfderiv_comp z (hf.1.mdifferentiableAt (hU.mem_nhds hz.1)) | |
| (mdifferentiableAt_iff_differentiableAt.mpr differentiableAt_fst) | |
| change (mfderiv π(β,E Γ F) (model n) (f β Prod.fst) z : (E Γ F) βL[β] Model n) = _ at hd | |
| let P : Model n βL[β] Model n := S.projection (f z.1) | |
| change P ((mfderiv π(β,E Γ F) (model n) (f β Prod.fst) z : (E Γ F) βL[β] Model n) (0,w)) = 0 | |
| rw [hd] | |
| simp only [mfderiv_eq_fderiv,fderiv_fst] | |
| change P ((mfderiv π(β,E) (model n) f z.1 : E βL[β] Model n) 0) = 0 | |
| rw [map_zero] | |
| exact P.map_zero | |
| lemma IsVerticalMap.block {U : Set E} {V : Set F} (hU : IsOpen U) (hV : IsOpen V) | |
| {f : F β X.Carrier} (hf : IsVerticalMap S V f) : | |
| IsBlockBox S (U ΓΛ’ V) (fun z : E Γ F β¦ f z.2) := by | |
| have hc := hf.comp hV (hU.prod hV) differentiable_snd.differentiableOn | |
| (show MapsTo Prod.snd (U ΓΛ’ V) V from fun _ h β¦ h.2) | |
| refine β¨hc.1,fun z hz β¦ β¨fun v β¦ ?_,fun w β¦ hc.2 z hz (0,w)β©β© | |
| have hd := mfderiv_comp z (hf.1.mdifferentiableAt (hV.mem_nhds hz.2)) | |
| (mdifferentiableAt_iff_differentiableAt.mpr differentiableAt_snd) | |
| change (mfderiv π(β,E Γ F) (model n) (f β Prod.snd) z : (E Γ F) βL[β] Model n) = _ at hd | |
| let P : Model n βL[β] Model n := S.projection (f z.2) | |
| change P ((mfderiv π(β,E Γ F) (model n) (f β Prod.snd) z : (E Γ F) βL[β] Model n) (v,0)) = | |
| (mfderiv π(β,E Γ F) (model n) (f β Prod.snd) z : (E Γ F) βL[β] Model n) (v,0) | |
| rw [hd] | |
| simp only [mfderiv_eq_fderiv,fderiv_snd] | |
| change P ((mfderiv π(β,F) (model n) f z.2 : F βL[β] Model n) 0) = | |
| (mfderiv π(β,F) (model n) f z.2 : F βL[β] Model n) 0 | |
| rw [map_zero] | |
| exact P.map_zero | |
| end UniversalCoverSplitting | |
| end | |
| end | |
| section | |
| noncomputable section | |
| open Set Filter Topology | |
| open scoped Manifold | |
| namespace UniversalCoverSplitting | |
| variable {n r s : β} {X : ComplexManifold n} {S : HolomorphicSplitting X r s} | |
| variable {E F A B : Type*} [NormedAddCommGroup E] [NormedSpace β E] | |
| [NormedAddCommGroup F] [NormedSpace β F] [NormedAddCommGroup A] [NormedSpace β A] | |
| [NormedAddCommGroup B] [NormedSpace β B] | |
| lemma IsBlockBox.comp_parameters {U : Set E} {V : Set F} {W : Set A} {Z : Set B} | |
| (hU : IsOpen U) (hV : IsOpen V) (hW : IsOpen W) (hZ : IsOpen Z) | |
| {f : E Γ F β X.Carrier} (hf : IsBlockBox S (U ΓΛ’ V) f) | |
| {a : A β E} {b : B β F} (ha : DifferentiableOn β a W) (hb : DifferentiableOn β b Z) | |
| (hma : MapsTo a W U) (hmb : MapsTo b Z V) : | |
| IsBlockBox S (W ΓΛ’ Z) (f β Prod.map a b) := by | |
| have hq : DifferentiableOn β (Prod.map a b) (W ΓΛ’ Z) := | |
| (ha.comp differentiable_fst.differentiableOn (fun _ h β¦ h.1)).prodMk | |
| (hb.comp differentiable_snd.differentiableOn (fun _ h β¦ h.2)) | |
| have hqm : MapsTo (Prod.map a b) (W ΓΛ’ Z) (U ΓΛ’ V) := fun _ h β¦ β¨hma h.1,hmb h.2β© | |
| refine β¨hf.1.comp (mdifferentiableOn_iff_differentiableOn.mpr hq) hqm,?_β© | |
| intro z hz | |
| have had := ha.differentiableAt (hW.mem_nhds hz.1) | |
| have hbd := hb.differentiableAt (hZ.mem_nhds hz.2) | |
| have hd := mfderiv_comp z (hf.1.mdifferentiableAt ((hU.prod hV).mem_nhds (hqm hz))) | |
| (mdifferentiableAt_iff_differentiableAt.mpr (HasFDerivAt.prodMap z had.hasFDerivAt hbd.hasFDerivAt).differentiableAt) | |
| let D : (E Γ F) βL[β] Model n := mfderiv π(β,E Γ F) (model n) f (a z.1,b z.2) | |
| let P : Model n βL[β] Model n := S.projection (f (a z.1,b z.2)) | |
| let M : (A Γ B) βL[β] Model n := mfderiv π(β,A Γ B) (model n) (f β Prod.map a b) z | |
| have hM : M = D.comp ((fderiv β a z.1).prodMap (fderiv β b z.2)) := by | |
| change M = D.comp (mfderiv π(β,A Γ B) π(β,E Γ F) (Prod.map a b) z) at hd | |
| rw [mfderiv_eq_fderiv,(HasFDerivAt.prodMap z had.hasFDerivAt hbd.hasFDerivAt).fderiv] at hd | |
| exact hd | |
| change (β v : A, P (M (v,0))=M (v,0)) β§ (β w : B, P (M (0,w))=0) | |
| rw [hM] | |
| constructor | |
| Β· intro v | |
| change P (D (fderiv β a z.1 v,fderiv β b z.2 0))=D (fderiv β a z.1 v,fderiv β b z.2 0) | |
| rw [map_zero] | |
| exact (hf.2 (a z.1,b z.2) (hqm hz)).1 _ | |
| Β· intro w | |
| change P (D (fderiv β a z.1 0,fderiv β b z.2 w))=0 | |
| rw [map_zero] | |
| exact (hf.2 (a z.1,b z.2) (hqm hz)).2 _ | |
| end UniversalCoverSplitting | |
| end | |
| end | |
| section | |
| noncomputable section | |
| open Set Filter Topology | |
| open scoped Manifold | |
| namespace UniversalCoverSplitting | |
| variable {n r s : β} {X : ComplexManifold n} {S : HolomorphicSplitting X r s} | |
| variable {E F : Type*} [NormedAddCommGroup E] [NormedSpace β E] | |
| [NormedAddCommGroup F] [NormedSpace β F] | |
| lemma IsBlockBox.horizontal_slice {U : Set E} {V : Set F} (hU : IsOpen U) (hV : IsOpen V) | |
| {f : E Γ F β X.Carrier} (hf : IsBlockBox S (U ΓΛ’ V) f) {b : F} (hb : b β V) : | |
| IsHorizontalMap S U (fun a β¦ f (a,b)) := by | |
| let q : E β E Γ F := fun a β¦ (a,b) | |
| have hq : Differentiable β q := differentiable_id.prodMk (differentiable_const b) | |
| have hmap : MapsTo q U (U ΓΛ’ V) := fun _ h β¦ β¨h,hbβ© | |
| refine β¨hf.1.comp (mdifferentiableOn_iff_differentiableOn.mpr hq.differentiableOn) hmap,?_β© | |
| intro z hz v | |
| let P : Model n βL[β] Model n := S.projection (f (z,b)) | |
| let D : (E Γ F) βL[β] Model n := mfderiv π(β,E Γ F) (model n) f (z,b) | |
| have hd := mfderiv_comp z (hf.1.mdifferentiableAt ((hU.prod hV).mem_nhds (hmap hz))) | |
| (mdifferentiableAt_iff_differentiableAt.mpr (hq z)) | |
| change (mfderiv π(β,E) (model n) (f β q) z : E βL[β] Model n) = | |
| D.comp (mfderiv π(β,E) π(β,E Γ F) q z) at hd | |
| rw [mfderiv_eq_fderiv] at hd | |
| have hqd : fderiv β q z=(ContinuousLinearMap.id β E).prod 0 := by | |
| exact ((hasFDerivAt_id z).prodMk (hasFDerivAt_const b z)).fderiv | |
| rw [hqd] at hd | |
| change P ((mfderiv π(β,E) (model n) (f β q) z : E βL[β] Model n) v)= | |
| (mfderiv π(β,E) (model n) (f β q) z : E βL[β] Model n) v | |
| rw [hd] | |
| exact (hf.2 (z,b) β¨hz,hbβ©).1 v | |
| lemma IsBlockBox.vertical_slice {U : Set E} {V : Set F} (hU : IsOpen U) (hV : IsOpen V) | |
| {f : E Γ F β X.Carrier} (hf : IsBlockBox S (U ΓΛ’ V) f) {a : E} (ha : a β U) : | |
| IsVerticalMap S V (fun b β¦ f (a,b)) := by | |
| let q : F β E Γ F := fun b β¦ (a,b) | |
| have hq : Differentiable β q := (differentiable_const a).prodMk differentiable_id | |
| have hmap : MapsTo q V (U ΓΛ’ V) := fun _ h β¦ β¨ha,hβ© | |
| refine β¨hf.1.comp (mdifferentiableOn_iff_differentiableOn.mpr hq.differentiableOn) hmap,?_β© | |
| intro z hz v | |
| let P : Model n βL[β] Model n := S.projection (f (a,z)) | |
| let D : (E Γ F) βL[β] Model n := mfderiv π(β,E Γ F) (model n) f (a,z) | |
| have hd := mfderiv_comp z (hf.1.mdifferentiableAt ((hU.prod hV).mem_nhds (hmap hz))) | |
| (mdifferentiableAt_iff_differentiableAt.mpr (hq z)) | |
| change (mfderiv π(β,F) (model n) (f β q) z : F βL[β] Model n) = | |
| D.comp (mfderiv π(β,F) π(β,E Γ F) q z) at hd | |
| rw [mfderiv_eq_fderiv] at hd | |
| have hqd : fderiv β q z=(0 : F βL[β] E).prod (ContinuousLinearMap.id β F) := by | |
| exact ((hasFDerivAt_const a z).prodMk (hasFDerivAt_id z)).fderiv | |
| rw [hqd] at hd | |
| change P ((mfderiv π(β,F) (model n) (f β q) z : F βL[β] Model n) v)=0 | |
| rw [hd] | |
| exact (hf.2 (a,z) β¨ha,hzβ©).2 v | |
| end UniversalCoverSplitting | |
| end | |
| end | |
| section | |
| noncomputable section | |
| open Set Metric Filter Topology | |
| open scoped Manifold unitInterval | |
| namespace UniversalCoverSplitting | |
| variable {n r s : β} {X : ComplexManifold n} {S : HolomorphicSplitting X r s} | |
| abbrev Polydisk (d : β) := ball (0 : Model d) (1 : β) | |
| def SplittingChart.unitMap (e : SplittingChart S) : Model r Γ Model s β X.Carrier := | |
| fun z β¦ e.chart.symm ((e.radius : β) β’ z.1,(e.radius : β) β’ z.2) | |
| lemma scale_mem_ball {d : β} {Ο : β} (hΟ : 0 < Ο) {z : Model d} | |
| (hz : z β Polydisk d) : (Ο : β) β’ z β ball 0 Ο := by | |
| rw [mem_ball_zero_iff] at hz β’ | |
| rw [norm_smul,Complex.norm_real,Real.norm_eq_abs,abs_of_pos hΟ] | |
| nlinarith | |
| lemma unscale_mem_ball {d : β} {Ο : β} (hΟ : 0 < Ο) {z : Model d} | |
| (hz : z β ball 0 Ο) : (Ο : β)β»ΒΉ β’ z β Polydisk d := by | |
| rw [mem_ball_zero_iff] at hz β’ | |
| rw [norm_smul,norm_inv,Complex.norm_real,Real.norm_eq_abs,abs_of_pos hΟ] | |
| exact (inv_mul_lt_iffβ hΟ).mpr (by simpa using hz) | |
| lemma SplittingChart.unitMap_block (e : SplittingChart S) : | |
| IsBlockBox S (Polydisk r ΓΛ’ Polydisk s) e.unitMap := by | |
| have he : IsBlockBox S (ball 0 e.radius ΓΛ’ ball 0 e.radius) e.chart.symm := by | |
| simpa only [e.product_range] using e.inverse_isBlockBox | |
| exact he.comp_parameters isOpen_ball isOpen_ball isOpen_ball isOpen_ball | |
| (differentiable_id.const_smul (e.radius : β)).differentiableOn | |
| (differentiable_id.const_smul (e.radius : β)).differentiableOn | |
| (fun _ h β¦ scale_mem_ball e.radius_pos h) (fun _ h β¦ scale_mem_ball e.radius_pos h) | |
| lemma SplittingChart.unitMap_coordinates (e : SplittingChart S) {x : X.Carrier} | |
| (hx : x β e.chart.source) : | |
| e.unitMap ((e.radius : β)β»ΒΉ β’ (e.chart x).1,(e.radius : β)β»ΒΉ β’ (e.chart x).2)=x := by | |
| have hr : (e.radius : β) β 0 := Complex.ofReal_ne_zero.mpr e.radius_pos.ne' | |
| simpa only [SplittingChart.unitMap,smul_smul,mul_inv_cancelβ hr,one_smul] using | |
| e.chart.left_inv hx | |
| end UniversalCoverSplitting | |
| end | |
| end | |
| end OAI | |