| import OAI.Geometry.KahlerSplitting.BlockMaps |
|
|
| namespace OAI |
|
|
| section |
|
|
| noncomputable section |
| open Set Filter Topology |
| open scoped unitInterval |
|
|
| namespace ProductBoxTopology |
| variable {A B X C D : Type*} [TopologicalSpace A] [TopologicalSpace B] |
| [TopologicalSpace X] [TopologicalSpace C] [TopologicalSpace D] |
|
|
| def IsBox (atlas : Set (OpenPartialHomeomorph X (C × D))) (F : A × B → X) : Prop := |
| Continuous F ∧ ∀ e ∈ atlas, |
| (∀ a, IsLocallyConstant (fun b : {b : B // F (a,b) ∈ e.source} ↦ (e (F (a,b))).1)) ∧ |
| (∀ b, IsLocallyConstant (fun a : {a : A // F (a,b) ∈ e.source} ↦ (e (F (a,b))).2)) |
|
|
| lemma IsBox.separated {atlas : Set (OpenPartialHomeomorph X (C × D))} |
| {F : A × B → X} (hF : IsBox atlas F) {e : OpenPartialHomeomorph X (C × D)} |
| (he : e ∈ atlas) {U : Set A} {V : Set B} (hU : IsPreconnected U) (hV : IsPreconnected V) |
| (hmap : MapsTo F (U ×ˢ V) e.source) {a a₀ : A} {b b₀ : B} |
| (ha : a ∈ U) (ha₀ : a₀ ∈ U) (hb : b ∈ V) (hb₀ : b₀ ∈ V) : |
| e (F (a,b)) = ((e (F (a,b₀))).1,(e (F (a₀,b))).2) := by |
| let : PreconnectedSpace U := isPreconnected_iff_preconnectedSpace.mp hU |
| let : PreconnectedSpace V := isPreconnected_iff_preconnectedSpace.mp hV |
| have h₁ : IsLocallyConstant (fun b : V ↦ (e (F (a,b))).1) := |
| ((hF.2 e he).1 a).comp_continuous (continuous_subtype_val.subtype_mk |
| (fun b ↦ hmap ⟨ha,b.property⟩)) |
| have h₂ : IsLocallyConstant (fun a : U ↦ (e (F (a,b))).2) := |
| ((hF.2 e he).2 b).comp_continuous (continuous_subtype_val.subtype_mk |
| (fun a ↦ hmap ⟨a.property,hb⟩)) |
| exact Prod.ext (h₁.apply_eq_of_preconnectedSpace ⟨b,hb⟩ ⟨b₀,hb₀⟩) |
| (h₂.apply_eq_of_preconnectedSpace ⟨a,ha⟩ ⟨a₀,ha₀⟩) |
|
|
| theorem unique [T2Space X] (atlas : Set (OpenPartialHomeomorph X (C × D))) |
| (hcover : ∀ x : X, ∃ e ∈ atlas, x ∈ e.source) |
| {F G : I × I → X} (hF : IsBox atlas F) (hG : IsBox atlas G) |
| (hbottom : ∀ a, F (a,0)=G (a,0)) (hleft : ∀ b, F (0,b)=G (0,b)) : F = G := by |
| classical |
| let c : Option atlas → Set (I × I) |
| | none => {p | F p ≠ G p} |
| | some e => F ⁻¹' e.val.source ∩ G ⁻¹' e.val.source |
| have hc : ∀ i, IsOpen (c i) := by |
| rintro (_|e) |
| · exact (isClosed_eq hF.1 hG.1).isOpen_compl |
| · exact (e.val.open_source.preimage hF.1).inter (e.val.open_source.preimage hG.1) |
| have hcU : univ ⊆ ⋃ i, c i := by |
| intro p _ |
| by_cases hp : F p = G p |
| · obtain ⟨e,he,hpe⟩ := hcover (F p) |
| exact mem_iUnion.mpr ⟨some ⟨e,he⟩,hpe,show G p ∈ e.source from hp ▸ hpe⟩ |
| · exact mem_iUnion.mpr ⟨none,hp⟩ |
| obtain ⟨t,ht0,htmono,⟨N,hN⟩,ht⟩ := |
| exists_monotone_Icc_subset_open_cover_unitInterval_prod_self hc hcU |
| have hprefix : ∀ i j, EqOn F G (Icc 0 (t i) ×ˢ Icc 0 (t j)) := by |
| intro i |
| induction i with |
| | zero => |
| intro j p hp |
| have hp0 : p.1 = 0 := le_antisymm (ht0 ▸ hp.1.2) hp.1.1 |
| change F (p.1,p.2)=G (p.1,p.2) |
| rw [hp0] |
| exact hleft p.2 |
| | succ i hi => |
| intro j |
| induction j with |
| | zero => |
| intro p hp |
| have hp0 : p.2 = 0 := le_antisymm (ht0 ▸ hp.2.2) hp.2.1 |
| change F (p.1,p.2)=G (p.1,p.2) |
| rw [hp0] |
| exact hbottom p.1 |
| | succ j hj => |
| intro p hp |
| by_cases hpi : p.1 ≤ t i |
| · exact hi (j+1) ⟨⟨hp.1.1,hpi⟩,hp.2⟩ |
| by_cases hpj : p.2 ≤ t j |
| · exact hj ⟨hp.1,⟨hp.2.1,hpj⟩⟩ |
| have hti : t i ≤ t (i+1) := htmono (Nat.le_succ i) |
| have htj : t j ≤ t (j+1) := htmono (Nat.le_succ j) |
| have hcorner : F (t i,t j)=G (t i,t j) := hi j ⟨⟨bot_le,le_rfl⟩,⟨bot_le,le_rfl⟩⟩ |
| obtain ⟨k,hk⟩ := ht i j |
| cases k with |
| | none => exact False.elim ((hk ⟨⟨le_rfl,hti⟩,⟨le_rfl,htj⟩⟩) hcorner) |
| | some e => |
| have hmapF : MapsTo F (Icc (t i) (t (i+1)) ×ˢ Icc (t j) (t (j+1))) e.val.source := |
| fun _ h ↦ (hk h).1 |
| have hmapG : MapsTo G (Icc (t i) (t (i+1)) ×ˢ Icc (t j) (t (j+1))) e.val.source := |
| fun _ h ↦ (hk h).2 |
| have hpa : p.1 ∈ Icc (t i) (t (i+1)) := ⟨(not_le.mp hpi).le,hp.1.2⟩ |
| have hpb : p.2 ∈ Icc (t j) (t (j+1)) := ⟨(not_le.mp hpj).le,hp.2.2⟩ |
| have ha0 : t i ∈ Icc (t i) (t (i+1)) := ⟨le_rfl,hti⟩ |
| have hb0 : t j ∈ Icc (t j) (t (j+1)) := ⟨le_rfl,htj⟩ |
| apply e.val.injOn (hmapF ⟨hpa,hpb⟩) (hmapG ⟨hpa,hpb⟩) |
| rw [hF.separated e.property isPreconnected_Icc isPreconnected_Icc hmapF hpa ha0 hpb hb0, |
| hG.separated e.property isPreconnected_Icc isPreconnected_Icc hmapG hpa ha0 hpb hb0] |
| have hbEq : F (p.1,t j)=G (p.1,t j) := hj ⟨hp.1,⟨bot_le,le_rfl⟩⟩ |
| have hlEq : F (t i,p.2)=G (t i,p.2) := hi (j+1) ⟨⟨bot_le,le_rfl⟩,hp.2⟩ |
| rw [hbEq,hlEq] |
| funext p |
| exact hprefix N N (by simpa only [hN N le_rfl] using |
| (show p ∈ Icc (0:I) 1 ×ˢ Icc (0:I) 1 from ⟨⟨bot_le,le_top⟩,⟨bot_le,le_top⟩⟩)) |
|
|
| end ProductBoxTopology |
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open Set Filter Topology |
| namespace ProductBoxTopology |
| variable {A B X C D : Type*} [TopologicalSpace A] [TopologicalSpace B] |
| [TopologicalSpace X] [TopologicalSpace C] [TopologicalSpace D] |
|
|
| lemma locallyConstant_of_finite_closed_cover {ι Y : Type*} [Finite ι] |
| (U : ι → Set A) (hU : ∀ i, IsClosed (U i)) (hcover : ∀ a, ∃ i, a ∈ U i) |
| {f : A → Y} (hf : ∀ i, IsLocallyConstant (fun a : U i ↦ f a)) : IsLocallyConstant f := by |
| intro W |
| have heq : (f ⁻¹' W)ᶜ = ⋃ i, Subtype.val '' ((fun a : U i ↦ f a) ⁻¹' Wᶜ) := by |
| ext a |
| constructor |
| · intro ha |
| obtain ⟨i,hi⟩ := hcover a |
| exact mem_iUnion.mpr ⟨i,⟨⟨a,hi⟩,ha,rfl⟩⟩ |
| · rintro ⟨_,⟨i,rfl⟩,⟨a,ha,rfl⟩⟩ |
| exact ha |
| rw [← isClosed_compl_iff,heq] |
| apply isClosed_iUnion_of_finite |
| intro i |
| exact (hU i).isClosedMap_subtype_val _ ((hf i W).isClosed_compl) |
|
|
| lemma locallyConstant_source_of_finite_closed_cover {ι Y : Type*} [Finite ι] |
| (U : ι → Set A) (hU : ∀ i, IsClosed (U i)) (hcover : ∀ a, ∃ i, a ∈ U i) |
| (p : A → Prop) {f : A → Y} |
| (hf : ∀ i, IsLocallyConstant (fun a : {a : U i // p a} ↦ f a)) : |
| IsLocallyConstant (fun a : {a : A // p a} ↦ f a) := by |
| apply locallyConstant_of_finite_closed_cover |
| (fun i ↦ Subtype.val ⁻¹' U i) (fun i ↦ (hU i).preimage continuous_subtype_val) |
| (fun a ↦ hcover a) |
| intro i |
| let g : {a : {a : A // p a} // a.val ∈ U i} → {a : U i // p a} := |
| fun a ↦ ⟨⟨a.val.val,a.property⟩,a.val.property⟩ |
| have hg : Continuous g := ((continuous_subtype_val.comp continuous_subtype_val).subtype_mk _).subtype_mk _ |
| exact (hf i).comp_continuous hg |
|
|
| lemma IsBox.precomp {atlas : Set (OpenPartialHomeomorph X (C × D))} |
| {F : A × B → X} (hF : IsBox atlas F) {A' B' : Type*} |
| [TopologicalSpace A'] [TopologicalSpace B'] {a : A' → A} {b : B' → B} |
| (ha : Continuous a) (hb : Continuous b) : |
| IsBox atlas (fun p : A' × B' ↦ F (a p.1,b p.2)) := by |
| refine ⟨hF.1.comp (ha.prodMap hb),?_⟩ |
| intro e he |
| constructor |
| · intro x |
| exact ((hF.2 e he).1 (a x)).comp_continuous |
| ((hb.comp continuous_subtype_val).subtype_mk (fun y ↦ y.property)) |
| · intro y |
| exact ((hF.2 e he).2 (b y)).comp_continuous |
| ((ha.comp continuous_subtype_val).subtype_mk (fun x ↦ x.property)) |
|
|
| lemma IsBox.of_closed_rectangles {atlas : Set (OpenPartialHomeomorph X (C × D))} |
| {F : A × B → X} (hF : Continuous F) {ι : Type*} [Finite ι] |
| (U : ι → Set A) (V : ι → Set B) (hU : ∀ i, IsClosed (U i)) (hV : ∀ i, IsClosed (V i)) |
| (hcover : ∀ p : A × B, ∃ i, p ∈ U i ×ˢ V i) |
| (hf : ∀ i, IsBox atlas (fun p : U i × V i ↦ F (p.1,p.2))) : IsBox atlas F := by |
| refine ⟨hF,fun e he ↦ ⟨?_,?_⟩⟩ |
| · intro a |
| apply locallyConstant_source_of_finite_closed_cover (f := fun b ↦ (e (F (a,b))).1) |
| (fun i : {i : ι // a ∈ U i} ↦ V i) (fun i ↦ hV i) |
| (fun b ↦ by obtain ⟨i,hi⟩ := hcover (a,b); exact ⟨⟨i,hi.1⟩,hi.2⟩) |
| (fun b ↦ F (a,b) ∈ e.source) |
| intro i |
| exact ((hf i).2 e he).1 ⟨a,i.property⟩ |
| · intro b |
| apply locallyConstant_source_of_finite_closed_cover (f := fun a ↦ (e (F (a,b))).2) |
| (fun i : {i : ι // b ∈ V i} ↦ U i) (fun i ↦ hU i) |
| (fun a ↦ by obtain ⟨i,hi⟩ := hcover (a,b); exact ⟨⟨i,hi.2⟩,hi.1⟩) |
| (fun a ↦ F (a,b) ∈ e.source) |
| intro i |
| exact ((hf i).2 e he).2 ⟨b,i.property⟩ |
|
|
| end ProductBoxTopology |
| 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 locallyConstant_restrict_of_fderiv_zero {H K : Type*} |
| [NormedAddCommGroup H] [NormedSpace ℂ H] [NormedAddCommGroup K] [NormedSpace ℂ K] |
| {U : Set H} (hU : IsOpen U) {f : H → K} (hf : DifferentiableOn ℂ f U) |
| (hd : ∀ x ∈ U, fderiv ℂ f x = 0) : IsLocallyConstant (fun x : U ↦ f x) := by |
| intro W |
| have hW := hU.isOpen_inter_preimage_of_fderiv_eq_zero hf hd W |
| convert hW.preimage (continuous_subtype_val : Continuous (Subtype.val : U → H)) using 1 |
| ext x |
| simp |
|
|
| def splittingAtlas (S : HolomorphicSplitting X r s) : |
| Set (OpenPartialHomeomorph X.Carrier (Model r × Model s)) := |
| Set.range (fun e : SplittingChart S ↦ e.chart) |
|
|
| lemma IsBlockBox.plaqueBox {U : Set E} {V : Set F} (hU : IsOpen U) (hV : IsOpen V) |
| {f : E × F → X.Carrier} (hf : IsBlockBox S (U ×ˢ V) f) : |
| ProductBoxTopology.IsBox (splittingAtlas S) (fun p : U × V ↦ f (p.1,p.2)) := by |
| have hcont : ContinuousOn f (U ×ˢ V) := hf.1.continuousOn |
| refine ⟨hcont.comp_continuous (continuous_subtype_val.prodMap continuous_subtype_val) |
| (fun p ↦ ⟨p.1.property,p.2.property⟩),?_⟩ |
| rintro _ ⟨e,rfl⟩ |
| let W : Set (E × F) := (U ×ˢ V) ∩ f ⁻¹' e.chart.source |
| have hW : IsOpen W := hcont.isOpen_inter_preimage (hU.prod hV) e.chart.open_source |
| have hc := e.block_coordinates hW (hf.mono inter_subset_left) |
| (show MapsTo f W e.chart.source from fun _ h ↦ h.2) |
| constructor |
| · intro a |
| let T : Set F := V ∩ (fun b ↦ f (a,b)) ⁻¹' e.chart.source |
| have hT : IsOpen T := (hcont.comp (continuous_const.prodMk continuous_id).continuousOn |
| (fun _ h ↦ ⟨a.property,h⟩)).isOpen_inter_preimage hV e.chart.open_source |
| have hd (b : F) (hb : b ∈ T) : HasFDerivAt (fun b ↦ (e.chart (f (a,b))).1) (0 : F →L[ℂ] Model r) b := by |
| have hab : ((a:E),b) ∈ W := ⟨⟨a.property,hb.1⟩,hb.2⟩ |
| have hg := (hc.1.differentiableAt (hW.mem_nhds hab)).hasFDerivAt.fst.comp b |
| ((hasFDerivAt_const (𝕜 := ℂ) (a:E) b).prodMk (hasFDerivAt_id (𝕜 := ℂ) b)) |
| have heq : ((ContinuousLinearMap.fst ℂ (Model r) (Model s)).comp |
| (fderiv ℂ (e.chart ∘ f) ((a:E),b))).comp |
| ((0 : F →L[ℂ] E).prod (ContinuousLinearMap.id ℂ F)) = 0 := by |
| apply ContinuousLinearMap.ext |
| intro w |
| exact (hc.2 _ hab).2 w |
| rw [heq] at hg |
| exact hg |
| have hl := locallyConstant_restrict_of_fderiv_zero hT |
| (fun b hb ↦ (hd b hb).differentiableAt.differentiableWithinAt) (fun b hb ↦ (hd b hb).fderiv) |
| exact hl.comp_continuous ((continuous_subtype_val.comp continuous_subtype_val).subtype_mk |
| (fun b ↦ ⟨b.val.property,b.property⟩)) |
| · intro b |
| let T : Set E := U ∩ (fun a ↦ f (a,b)) ⁻¹' e.chart.source |
| have hT : IsOpen T := (hcont.comp (continuous_id.prodMk continuous_const).continuousOn |
| (fun _ h ↦ ⟨h,b.property⟩)).isOpen_inter_preimage hU e.chart.open_source |
| have hd (a : E) (ha : a ∈ T) : HasFDerivAt (fun a ↦ (e.chart (f (a,b))).2) (0 : E →L[ℂ] Model s) a := by |
| have hab : (a,(b:F)) ∈ W := ⟨⟨ha.1,b.property⟩,ha.2⟩ |
| have hg := (hc.1.differentiableAt (hW.mem_nhds hab)).hasFDerivAt.snd.comp a |
| ((hasFDerivAt_id (𝕜 := ℂ) a).prodMk (hasFDerivAt_const (𝕜 := ℂ) (b:F) a)) |
| have heq : ((ContinuousLinearMap.snd ℂ (Model r) (Model s)).comp |
| (fderiv ℂ (e.chart ∘ f) (a,(b:F)))).comp |
| ((ContinuousLinearMap.id ℂ E).prod (0 : E →L[ℂ] F)) = 0 := by |
| apply ContinuousLinearMap.ext |
| intro v |
| exact (hc.2 _ hab).1 v |
| rw [heq] at hg |
| exact hg |
| have hl := locallyConstant_restrict_of_fderiv_zero hT |
| (fun a ha ↦ (hd a ha).differentiableAt.differentiableWithinAt) (fun a ha ↦ (hd a ha).fderiv) |
| exact hl.comp_continuous ((continuous_subtype_val.comp continuous_subtype_val).subtype_mk |
| (fun a ↦ ⟨a.val.property,a.property⟩)) |
|
|
| end UniversalCoverSplitting |
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open Set Filter Topology |
| open scoped unitInterval |
| namespace ProductBoxTopology |
| variable {A B X C D : Type*} [TopologicalSpace A] [TopologicalSpace B] |
| [TopologicalSpace X] [TopologicalSpace C] [TopologicalSpace D] |
|
|
| lemma unique_paths [T2Space X] (atlas : Set (OpenPartialHomeomorph X (C × D))) |
| (hcover : ∀ x : X, ∃ e ∈ atlas, x ∈ e.source) |
| {F G : A × B → X} (hF : IsBox atlas F) (hG : IsBox atlas G) |
| {a₀ a : A} {b₀ b : B} (α : Path a₀ a) (β : Path b₀ b) |
| (hbottom : ∀ a, F (a,b₀)=G (a,b₀)) (hleft : ∀ b, F (a₀,b)=G (a₀,b)) : |
| F (a,b)=G (a,b) := by |
| have h := unique atlas hcover (hF.precomp α.continuous β.continuous) |
| (hG.precomp α.continuous β.continuous) |
| (fun s ↦ by simpa using hbottom (α s)) |
| (fun t ↦ by simpa using hleft (β t)) |
| simpa using congrFun h (1,1) |
|
|
| lemma unique_connected [T2Space X] [PathConnectedSpace A] [PathConnectedSpace B] |
| (atlas : Set (OpenPartialHomeomorph X (C × D))) |
| (hcover : ∀ x : X, ∃ e ∈ atlas, x ∈ e.source) |
| {F G : A × B → X} (hF : IsBox atlas F) (hG : IsBox atlas G) |
| (a₀ : A) (b₀ : B) |
| (hbottom : ∀ a, F (a,b₀)=G (a,b₀)) (hleft : ∀ b, F (a₀,b)=G (a₀,b)) : F=G := by |
| funext p |
| exact unique_paths atlas hcover hF hG (PathConnectedSpace.somePath a₀ p.1) |
| (PathConnectedSpace.somePath b₀ p.2) hbottom hleft |
|
|
| lemma pathConnected_Icc_unit {a b : I} (hab : a ≤ b) : PathConnectedSpace (Icc a b) := by |
| refine ⟨⟨⟨a,le_rfl,hab⟩⟩,fun x y ↦ ?_⟩ |
| have hm (t : I) : Icc.convexComb x.val y.val t ∈ Icc a b := by |
| constructor |
| · change (a:ℝ) ≤ (1-(t:ℝ))*(x.val:ℝ)+(t:ℝ)*(y.val:ℝ) |
| have hx : (a:ℝ) ≤ (x.val:ℝ) := x.property.1 |
| have hy : (a:ℝ) ≤ (y.val:ℝ) := y.property.1 |
| nlinarith [t.property.1,t.property.2] |
| · change (1-(t:ℝ))*(x.val:ℝ)+(t:ℝ)*(y.val:ℝ) ≤ (b:ℝ) |
| have hx : (x.val:ℝ) ≤ (b:ℝ) := x.property.2 |
| have hy : (y.val:ℝ) ≤ (b:ℝ) := y.property.2 |
| nlinarith [t.property.1,t.property.2] |
| exact ⟨⟨⟨fun t ↦ ⟨Icc.convexComb x.val y.val t,hm t⟩, |
| (Icc.continuous_convexComb x.val y.val).subtype_mk _⟩, |
| by ext; simp,by ext; simp⟩⟩ |
|
|
| end ProductBoxTopology |
| end |
| end |
|
|
| end OAI |
|
|
