| import OAI.Geometry.KahlerSplitting.ParameterGrid |
|
|
| namespace OAI |
|
|
| section |
|
|
| noncomputable section |
| open Set Metric |
| namespace UnitPolydisk |
|
|
| def discShift (a z : ℂ) : ℂ := (a+z)/(1+star a*z) |
|
|
| lemma denominator_ne_zero {a z : ℂ} (ha : ‖a‖ < 1) (hz : ‖z‖ < 1) : 1+star a*z ≠ 0 := by |
| intro he |
| have hn : ‖star a*z‖ < 1 := by |
| rw [norm_mul,norm_star] |
| nlinarith [norm_nonneg a,norm_nonneg z] |
| have hh : star a*z = -1 := by linear_combination he |
| rw [hh,norm_neg,norm_one] at hn |
| exact (lt_irrefl 1) hn |
|
|
| lemma normSq_difference (a z : ℂ) : |
| Complex.normSq (1+star a*z) - Complex.normSq (a+z) = |
| (1-Complex.normSq a)*(1-Complex.normSq z) := by |
| simp only [Complex.star_def,Complex.normSq_apply,Complex.add_re,Complex.add_im,Complex.mul_re, |
| Complex.mul_im,Complex.conj_re,Complex.conj_im,Complex.one_re,Complex.one_im] |
| ring |
|
|
| lemma discShift_mem {a z : ℂ} (ha : ‖a‖ < 1) (hz : ‖z‖ < 1) : ‖discShift a z‖ < 1 := by |
| have hden := denominator_ne_zero ha hz |
| have ha2 : Complex.normSq a < 1 := by rw [Complex.normSq_eq_norm_sq]; nlinarith [norm_nonneg a] |
| have hz2 : Complex.normSq z < 1 := by rw [Complex.normSq_eq_norm_sq]; nlinarith [norm_nonneg z] |
| have hn : Complex.normSq (a+z) < Complex.normSq (1+star a*z) := by |
| have hh := normSq_difference a z |
| have hp := mul_pos (sub_pos.mpr ha2) (sub_pos.mpr hz2) |
| linarith |
| rw [Complex.normSq_eq_norm_sq,Complex.normSq_eq_norm_sq] at hn |
| rw [discShift,norm_div,div_lt_one (norm_pos_iff.mpr hden)] |
| nlinarith [norm_nonneg (a+z),norm_nonneg (1+star a*z)] |
|
|
| lemma discShift_zero (a : ℂ) : discShift a 0=a := by simp [discShift] |
|
|
| lemma discShift_neg_self {a : ℂ} : discShift (-a) a=0 := by |
| simp [discShift] |
|
|
| lemma discShift_inverse {a z : ℂ} (ha : ‖a‖ < 1) (hz : ‖z‖ < 1) : |
| discShift (-a) (discShift a z)=z := by |
| have hden := denominator_ne_zero ha hz |
| have ha' : ‖-a‖ < 1 := by simpa using ha |
| have hden' := denominator_ne_zero ha' (discShift_mem ha hz) |
| change (-a+discShift a z)/(1+star (-a)*discShift a z)=z |
| apply (div_eq_iff hden').mpr |
| simp only [discShift,star_neg,div_eq_mul_inv] |
| have hcancel : (1+star a*z)*(1+star a*z)⁻¹=1 := mul_inv_cancel₀ hden |
| linear_combination (a+z)*hcancel |
|
|
| lemma differentiableOn_discShift {a : ℂ} (ha : ‖a‖ < 1) : |
| DifferentiableOn ℂ (discShift a) (ball (0:ℂ) 1) := by |
| exact ((differentiable_const a).add differentiable_id).differentiableOn.div |
| ((differentiable_const 1).add ((differentiable_const (star a)).mul differentiable_id)).differentiableOn |
| (fun z hz ↦ denominator_ne_zero ha (mem_ball_zero_iff.mp hz)) |
|
|
| def shift {d : ℕ} (a z : Fin d → ℂ) : Fin d → ℂ := fun i ↦ discShift (a i) (z i) |
|
|
| lemma norm_coord_lt_one {d : ℕ} {a : Fin d → ℂ} (ha : a ∈ ball 0 1) (i : Fin d) : ‖a i‖ < 1 := |
| (norm_le_pi_norm a i).trans_lt (mem_ball_zero_iff.mp ha) |
|
|
| lemma shift_mem {d : ℕ} {a z : Fin d → ℂ} (ha : a ∈ ball 0 1) (hz : z ∈ ball 0 1) : |
| shift a z ∈ ball 0 1 := by |
| rw [mem_ball_zero_iff,pi_norm_lt_iff (by norm_num : (0:ℝ)<1)] |
| exact fun i ↦ discShift_mem (norm_coord_lt_one ha i) (norm_coord_lt_one hz i) |
|
|
| lemma shift_zero {d : ℕ} (a : Fin d → ℂ) : shift a 0=a := by ext i; exact discShift_zero (a i) |
| |
| lemma shift_inverse {d : ℕ} {a z : Fin d → ℂ} (ha : a ∈ ball 0 1) (hz : z ∈ ball 0 1) : |
| shift (-a) (shift a z)=z := by |
| ext i |
| exact discShift_inverse (norm_coord_lt_one ha i) (norm_coord_lt_one hz i) |
|
|
| lemma differentiableOn_shift {d : ℕ} {a : Fin d → ℂ} (ha : a ∈ ball 0 1) : |
| DifferentiableOn ℂ (shift a) (ball 0 1) := by |
| apply differentiableOn_pi.mpr |
| intro i |
| exact (differentiableOn_discShift (norm_coord_lt_one ha i)).comp |
| (differentiable_apply i).differentiableOn |
| (fun z hz ↦ mem_ball_zero_iff.mpr (norm_coord_lt_one hz i)) |
|
|
| end UnitPolydisk |
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open Set Metric Filter Topology |
| open scoped Manifold |
| namespace UniversalCoverSplitting |
| variable {n r s d e : ℕ} {X : ComplexManifold n} {S : HolomorphicSplitting X r s} |
|
|
| theorem polydisk_axes [CompactSpace X.Carrier] (g : KahlerMetric X) |
| (h₁ : Integrable S.projection) (h₂ : Integrable (complementaryProjection S)) |
| {α : Model d → X.Carrier} {β : Model e → X.Carrier} |
| (hα : IsHorizontalMap S (ball 0 1) α) (hβ : IsVerticalMap S (ball 0 1) β) |
| {p₀ : Model d} {q₀ : Model e} (hp₀ : p₀ ∈ ball 0 1) (hq₀ : q₀ ∈ ball 0 1) |
| (hbase : α p₀=β q₀) : |
| ∃ H : Model d × Model e → X.Carrier, IsBlockBox S (ball 0 1 ×ˢ ball 0 1) H ∧ |
| (∀ p ∈ ball 0 1, H (p,q₀)=α p) ∧ (∀ q ∈ ball 0 1, H (p₀,q)=β q) := by |
| have hpN : -p₀ ∈ ball (0:Model d) 1 := by simpa using hp₀ |
| have hqN : -q₀ ∈ ball (0:Model e) 1 := by simpa using hq₀ |
| have hα' := hα.comp isOpen_ball isOpen_ball (UnitPolydisk.differentiableOn_shift hp₀) |
| (fun _ h ↦ UnitPolydisk.shift_mem hp₀ h) |
| have hβ' := hβ.comp isOpen_ball isOpen_ball (UnitPolydisk.differentiableOn_shift hq₀) |
| (fun _ h ↦ UnitPolydisk.shift_mem hq₀ h) |
| obtain ⟨F,hF,hFα,hFβ⟩ := ball_axes_zero g h₁ h₂ hα' hβ' |
| (by simpa only [Function.comp_apply,UnitPolydisk.shift_zero] using hbase) |
| let a := UnitPolydisk.shift (-p₀) |
| let b := UnitPolydisk.shift (-q₀) |
| have hap₀ : a p₀=0 := by ext i; exact UnitPolydisk.discShift_neg_self |
| have hbq₀ : b q₀=0 := by ext i; exact UnitPolydisk.discShift_neg_self |
| refine ⟨F ∘ Prod.map a b,hF.comp_parameters isOpen_ball isOpen_ball isOpen_ball isOpen_ball |
| (UnitPolydisk.differentiableOn_shift hpN) (UnitPolydisk.differentiableOn_shift hqN) |
| (fun _ h ↦ UnitPolydisk.shift_mem hpN h) (fun _ h ↦ UnitPolydisk.shift_mem hqN h),?_,?_⟩ |
| · intro p hp |
| change F (a p,b q₀)=α p |
| rw [hbq₀,hFα (a p) (UnitPolydisk.shift_mem hpN hp)] |
| have hh := UnitPolydisk.shift_inverse hpN hp |
| simpa only [neg_neg,Function.comp_apply] using congrArg α hh |
| · intro q hq |
| change F (a p₀,b q)=β q |
| rw [hap₀,hFβ (b q) (UnitPolydisk.shift_mem hqN hq)] |
| have hh := UnitPolydisk.shift_inverse hqN hq |
| simpa only [neg_neg,Function.comp_apply] using congrArg β hh |
|
|
| lemma IsBlockBox.unique_polydisk {F G : Model d × Model e → X.Carrier} |
| (h₁ : Integrable S.projection) (h₂ : Integrable (complementaryProjection S)) |
| (hF : IsBlockBox S (ball 0 1 ×ˢ ball 0 1) F) (hG : IsBlockBox S (ball 0 1 ×ˢ ball 0 1) G) |
| {p₀ : Model d} {q₀ : Model e} (hp₀ : p₀ ∈ ball 0 1) (hq₀ : q₀ ∈ ball 0 1) |
| (hb : ∀ p ∈ ball 0 1, F (p,q₀)=G (p,q₀)) |
| (hl : ∀ q ∈ ball 0 1, F (p₀,q)=G (p₀,q)) : EqOn F G (ball 0 1 ×ˢ ball 0 1) := by |
| let : PathConnectedSpace (ball (0:Model d) 1) := |
| isPathConnected_iff_pathConnectedSpace.mp ((convex_ball (0:Model d) 1).isPathConnected ⟨p₀,hp₀⟩) |
| let : PathConnectedSpace (ball (0:Model e) 1) := |
| isPathConnected_iff_pathConnectedSpace.mp ((convex_ball (0:Model e) 1).isPathConnected ⟨q₀,hq₀⟩) |
| have hcover : ∀ x : X.Carrier, ∃ c ∈ splittingAtlas S, x ∈ c.source := by |
| intro x |
| obtain ⟨c,hc,_⟩ := exists_splittingChart S h₁ h₂ x |
| exact ⟨c.chart,⟨c,rfl⟩,hc⟩ |
| have he := ProductBoxTopology.unique_connected (splittingAtlas S) hcover |
| (hF.plaqueBox isOpen_ball isOpen_ball) (hG.plaqueBox isOpen_ball isOpen_ball) |
| (⟨p₀,hp₀⟩ : ball (0:Model d) 1) (⟨q₀,hq₀⟩ : ball (0:Model e) 1) |
| (fun p ↦ hb p p.property) (fun q ↦ hl q q.property) |
| intro z hz |
| exact congrFun he (⟨z.1,hz.1⟩,⟨z.2,hz.2⟩) |
|
|
| end UniversalCoverSplitting |
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open Set Metric Filter Topology |
| open scoped Manifold |
| namespace UniversalCoverSplitting |
| variable {n r s d e : ℕ} {X : ComplexManifold n} {S : HolomorphicSplitting X r s} |
|
|
| def IsDiskHorizontal (S : HolomorphicSplitting X r s) (f : Polydisk d → X.Carrier) : Prop := |
| ∃ g : Model d → X.Carrier, IsHorizontalMap S (Polydisk d) g ∧ ∀ z : Polydisk d, g z=f z |
|
|
| def IsDiskVertical (S : HolomorphicSplitting X r s) (f : Polydisk e → X.Carrier) : Prop := |
| ∃ g : Model e → X.Carrier, IsVerticalMap S (Polydisk e) g ∧ ∀ z : Polydisk e, g z=f z |
|
|
| def IsDiskTile (S : HolomorphicSplitting X r s) (f : Polydisk d × Polydisk e → X.Carrier) : Prop := |
| ∃ g : Model d × Model e → X.Carrier, IsBlockBox S (Polydisk d ×ˢ Polydisk e) g ∧ |
| ∀ z : Polydisk d × Polydisk e, g (z.1,z.2)=f z |
|
|
| lemma IsDiskTile.horizontal {f : Polydisk d × Polydisk e → X.Carrier} |
| (hf : IsDiskTile S f) (q : Polydisk e) : IsDiskHorizontal S (fun p ↦ f (p,q)) := by |
| obtain ⟨g,hg,he⟩ := hf |
| exact ⟨fun p ↦ g (p,q),hg.horizontal_slice isOpen_ball isOpen_ball q.property, |
| fun p ↦ he (p,q)⟩ |
|
|
| lemma IsDiskTile.vertical {f : Polydisk d × Polydisk e → X.Carrier} |
| (hf : IsDiskTile S f) (p : Polydisk d) : IsDiskVertical S (fun q ↦ f (p,q)) := by |
| obtain ⟨g,hg,he⟩ := hf |
| exact ⟨fun q ↦ g (p,q),hg.vertical_slice isOpen_ball isOpen_ball p.property, |
| fun q ↦ he (p,q)⟩ |
|
|
| lemma IsDiskTile.plaqueBox {f : Polydisk d × Polydisk e → X.Carrier} |
| (hf : IsDiskTile S f) : ProductBoxTopology.IsBox (splittingAtlas S) f := by |
| obtain ⟨g,hg,he⟩ := hf |
| have heq : f=(fun z : Polydisk d × Polydisk e ↦ g (z.1,z.2)) := funext fun z ↦ (he z).symm |
| rw [heq] |
| exact hg.plaqueBox isOpen_ball isOpen_ball |
|
|
| lemma disk_fill [CompactSpace X.Carrier] (g : KahlerMetric X) |
| (h₁ : Integrable S.projection) (h₂ : Integrable (complementaryProjection S)) |
| {a : Polydisk d → X.Carrier} {b : Polydisk e → X.Carrier} |
| (ha : IsDiskHorizontal S a) (hb : IsDiskVertical S b) |
| (p : Polydisk d) (q : Polydisk e) (hc : a p=b q) : |
| ∃ f, IsDiskTile S f ∧ (∀ x, f (x,q)=a x) ∧ (∀ y, f (p,y)=b y) := by |
| obtain ⟨A,hA,eA⟩ := ha |
| obtain ⟨B,hB,eB⟩ := hb |
| obtain ⟨F,hF,hFa,hFb⟩ := polydisk_axes g h₁ h₂ hA hB p.property q.property |
| (by rw [eA p,eB q]; exact hc) |
| refine ⟨fun z ↦ F (z.1,z.2),⟨F,hF,fun _ ↦ rfl⟩,?_,?_⟩ |
| · intro x; exact (hFa x x.property).trans (eA x) |
| · intro y; exact (hFb y y.property).trans (eB y) |
| |
| theorem holomorphic_grid [CompactSpace X.Carrier] (g : KahlerMetric X) |
| (h₁ : Integrable S.projection) (h₂ : Integrable (complementaryProjection S)) |
| (a : ℕ → Polydisk d → X.Carrier) (ha : ∀ i, IsDiskHorizontal S (a i)) |
| (lo hi : ℕ → Polydisk d) (joinA : ∀ i, a i (hi i)=a (i+1) (lo (i+1))) |
| (b : ℕ → Polydisk e → X.Carrier) (hb : ∀ j, IsDiskVertical S (b j)) |
| (bot top : ℕ → Polydisk e) (joinB : ∀ j, b j (top j)=b (j+1) (bot (j+1))) |
| (corner : a 0 (lo 0)=b 0 (bot 0)) : |
| ∃ f : ℕ → ℕ → Polydisk d × Polydisk e → X.Carrier, |
| (∀ i j, IsDiskTile S (f i j)) ∧ |
| (∀ i x, f i 0 (x,bot 0)=a i x) ∧ (∀ j y, f 0 j (lo 0,y)=b j y) ∧ |
| (∀ i j y, f i j (hi i,y)=f (i+1) j (lo (i+1),y)) ∧ |
| (∀ i j x, f i j (x,top j)=f i (j+1) (x,bot (j+1))) := by |
| exact RectangleGrid.grid {a | IsDiskHorizontal S a} {b | IsDiskVertical S b} |
| {f | IsDiskTile S f} (fun _ h q ↦ h.horizontal q) (fun _ h p ↦ h.vertical p) |
| (fun _ hA _ hB p q hc ↦ disk_fill g h₁ h₂ hA hB p q hc) |
| a ha lo hi joinA b hb bot top joinB corner |
|
|
| end UniversalCoverSplitting |
| end |
| end |
|
|
| end OAI |
|
|
