| import OAI.Geometry.KahlerSplitting.Removable |
|
|
| namespace OAI |
|
|
| noncomputable section |
| open scoped Manifold ContDiff |
| open Set Topology Filter Metric |
| open Set MeasureTheory Metric Filter Topology |
| open scoped Interval |
| open Set MeasureTheory |
| open scoped ENNReal |
| open Set Metric |
| open scoped ENNReal NNReal |
| open Set Metric Filter Topology |
| open scoped Manifold ENNReal NNReal |
| open Complex |
| open Set Filter Topology |
| open Set Metric Filter Topology Complex |
| open Set Metric Filter Topology MeasureTheory Complex |
| open Set Metric Filter Topology MeasureTheory |
| open scoped Manifold ENNReal |
| open Set |
| open scoped Manifold |
|
|
| namespace UniversalCoverSplitting |
| variable {n r s : ℕ} {X : ComplexManifold n} |
|
|
| theorem chart_mfderiv_inverses (c : X.Carrier) {z : Model n} |
| (hz : z ∈ (extChartAt (model n) c).target) : |
| (mfderiv (model n) (model n) (extChartAt (model n) c) ((extChartAt (model n) c).symm z)).comp |
| (mfderiv (model n) (model n) (extChartAt (model n) c).symm z) = |
| ContinuousLinearMap.id ℂ (Model n) ∧ |
| (mfderiv (model n) (model n) (extChartAt (model n) c).symm z).comp |
| (mfderiv (model n) (model n) (extChartAt (model n) c) ((extChartAt (model n) c).symm z)) = |
| ContinuousLinearMap.id ℂ (Model n) := by |
| constructor |
| · have h := mfderiv_extChartAt_comp_mfderivWithin_extChartAt_symm hz |
| change (mfderiv (model n) (model n) (extChartAt (model n) c) ((extChartAt (model n) c).symm z)).comp |
| (mfderivWithin (model n) (model n) (extChartAt (model n) c).symm (range (model n)) z) = |
| ContinuousLinearMap.id ℂ (Model n) at h |
| simpa only [ModelWithCorners.range_eq_univ,mfderivWithin_univ] using h |
| · have h := mfderivWithin_extChartAt_symm_comp_mfderiv_extChartAt hz |
| change (mfderivWithin (model n) (model n) (extChartAt (model n) c).symm (range (model n)) z).comp |
| (mfderiv (model n) (model n) (extChartAt (model n) c) ((extChartAt (model n) c).symm z)) = |
| ContinuousLinearMap.id ℂ (Model n) at h |
| simpa only [ModelWithCorners.range_eq_univ,mfderivWithin_univ] using h |
|
|
| lemma projectionInChart_self (P : ProjectionField X) (c : X.Carrier) : |
| projectionInChart P c (extChartAt (model n) c c) = P c := by |
| let e := extChartAt (model n) c |
| let A : X.Carrier → Model n →L[ℂ] Model n := fun x ↦ mfderiv (model n) (model n) e x |
| let B : Model n → Model n →L[ℂ] Model n := fun z ↦ mfderiv (model n) (model n) e.symm z |
| let T : X.Carrier → Model n →L[ℂ] Model n := fun x ↦ P x |
| have hA : A c = ContinuousLinearMap.id ℂ (Model n) := mfderiv_extChartAt_self |
| have hB : B (e c) = ContinuousLinearMap.id ℂ (Model n) := by |
| have h := mfderivWithin_range_extChartAt_symm (I := model n) (x := c) |
| change (mfderivWithin (model n) (model n) e.symm (range (model n)) (e c) : |
| Model n →L[ℂ] Model n) = ContinuousLinearMap.id ℂ (Model n) at h |
| simp only [ModelWithCorners.range_eq_univ,mfderivWithin_univ] at h |
| exact h |
| change (A (e.symm (e c))).comp ((T (e.symm (e c))).comp (B (e c))) = T c |
| rw [e.left_inv (mem_extChartAt_source c),hA,hB] |
| simp |
|
|
| lemma projectionInChart_idempotent (S : HolomorphicSplitting X r s) (c : X.Carrier) |
| {z : Model n} (hz : z ∈ (extChartAt (model n) c).target) (v : Model n) : |
| projectionInChart S.projection c z (projectionInChart S.projection c z v) = |
| projectionInChart S.projection c z v := by |
| let e := extChartAt (model n) c |
| let a : Model n →L[ℂ] Model n := mfderiv (model n) (model n) e (e.symm z) |
| let b : Model n →L[ℂ] Model n := mfderiv (model n) (model n) e.symm z |
| have hba : b.comp a = ContinuousLinearMap.id ℂ (Model n) := (chart_mfderiv_inverses c hz).2 |
| have hba' (u : Model n) : b (a u) = u := congrArg (fun L : Model n →L[ℂ] Model n ↦ L u) hba |
| let T : Model n →L[ℂ] Model n := S.projection (e.symm z) |
| have hT (u : Model n) : T (T u) = T u := S.idempotent (e.symm z) u |
| change a (T (b (a (T (b v))))) = a (T (b v)) |
| rw [hba',hT] |
|
|
| lemma projectionInChart_complement (P : ProjectionField X) (c : X.Carrier) |
| {z : Model n} (hz : z ∈ (extChartAt (model n) c).target) : |
| projectionInChart (fun x ↦ ContinuousLinearMap.id ℂ (Tangent X x)-P x) c z = |
| ContinuousLinearMap.id ℂ (Model n)-projectionInChart P c z := by |
| let e := extChartAt (model n) c |
| let a : Model n →L[ℂ] Model n := mfderiv (model n) (model n) e (e.symm z) |
| let b : Model n →L[ℂ] Model n := mfderiv (model n) (model n) e.symm z |
| have hab : a.comp b = ContinuousLinearMap.id ℂ (Model n) := (chart_mfderiv_inverses c hz).1 |
| have hab' (u : Model n) : a (b u) = u := congrArg (fun L : Model n →L[ℂ] Model n ↦ L u) hab |
| let T : Model n →L[ℂ] Model n := P (e.symm z) |
| apply ContinuousLinearMap.ext |
| intro v |
| change a (b v-T (b v)) = v-a (T (b v)) |
| rw [map_sub,hab'] |
|
|
| end UniversalCoverSplitting |
|
|
| open Set Metric Filter Topology Asymptotics |
|
|
| namespace UniversalCoverSplitting |
| variable {𝕜 E F : Type*} [NontriviallyNormedField 𝕜] |
| [NormedAddCommGroup E] [NormedSpace 𝕜 E] |
| [NormedAddCommGroup F] [NormedSpace 𝕜 F] |
|
|
| theorem uniform_strict_derivative_on_compact {f : E → F} {D : E → E →L[𝕜] F} |
| {K : Set E} (hK : IsCompact K) |
| (hder : ∀ x ∈ K, HasStrictFDerivAt f (D x) x) |
| (hD : ∀ x ∈ K, ContinuousAt D x) {ε : ℝ} (hε : 0 < ε) : |
| ∃ δ > 0, ∀ a ∈ K, ∀ x ∈ ball a δ, ∀ y ∈ ball a δ, |
| ‖f x - f y - D a (x-y)‖ ≤ ε * ‖x-y‖ := by |
| classical |
| have hlocal (a : K) : ∃ d > 0, |
| (∀ b ∈ ball a.val d, ‖D b-D a.val‖ ≤ ε/2) ∧ |
| ∀ x ∈ ball a.val (2*d), ∀ y ∈ ball a.val (2*d), |
| ‖f x-f y-D a.val (x-y)‖ ≤ (ε/2)*‖x-y‖ := by |
| have he := (hasStrictFDerivAt_iff_isLittleO.mp (hder a.val a.property)).bound (half_pos hε) |
| obtain ⟨r,hr,hrb⟩ := Metric.eventually_nhds_iff_ball.mp he |
| obtain ⟨s,hs,hsb⟩ := Metric.eventually_nhds_iff_ball.mp |
| ((hD a.val a.property) (ball_mem_nhds (D a.val) (half_pos hε))) |
| let d := min (r/3) s |
| have hd : 0 < d := lt_min (by linarith) hs |
| refine ⟨d,hd,?_,?_⟩ |
| · intro b hb |
| have : b ∈ ball a.val s := ball_subset_ball (min_le_right _ _) hb |
| exact le_of_lt (by simpa only [mem_ball,dist_eq_norm] using hsb b this) |
| · intro x hx y hy |
| apply hrb (x,y) |
| rw [← ball_prod_same] |
| have hcmp : 2*d ≤ r := by have := min_le_left (r/3) s; dsimp [d]; linarith |
| exact ⟨ball_subset_ball hcmp hx,ball_subset_ball hcmp hy⟩ |
| choose d hd hDb hstrict using hlocal |
| obtain ⟨s,hs⟩ := hK.elim_finite_subcover (fun a : K ↦ ball a.val (d a)) |
| (fun _ ↦ isOpen_ball) (fun a ha ↦ mem_iUnion.mpr ⟨⟨a,ha⟩,mem_ball_self (hd ⟨a,ha⟩)⟩) |
| by_cases hsn : s.Nonempty |
| · refine ⟨s.inf' hsn d, (Finset.lt_inf'_iff hsn).mpr (fun a _ ↦ hd a),?_⟩ |
| intro a ha x hx y hy |
| obtain ⟨b,hb⟩ := mem_iUnion.mp (hs ha) |
| obtain ⟨hbs,hab⟩ := mem_iUnion.mp hb |
| have hdle : s.inf' hsn d ≤ d b := s.inf'_le d hbs |
| have hxb : x ∈ ball b.val (2*d b) := by |
| have : dist x b.val ≤ dist x a + dist a b.val := dist_triangle _ _ _ |
| change dist x a < _ at hx |
| change dist a b.val < _ at hab |
| change dist x b.val < _ |
| linarith |
| have hyb : y ∈ ball b.val (2*d b) := by |
| have : dist y b.val ≤ dist y a + dist a b.val := dist_triangle _ _ _ |
| change dist y a < _ at hy |
| change dist a b.val < _ at hab |
| change dist y b.val < _ |
| linarith |
| have herr := hstrict b x hxb y hyb |
| have hop : ‖D b.val-D a‖ ≤ ε/2 := by |
| rw [norm_sub_rev] |
| exact hDb b a hab |
| calc |
| ‖f x-f y-D a (x-y)‖ = |
| ‖(f x-f y-D b.val (x-y)) + (D b.val-D a) (x-y)‖ := by |
| congr 1; simp only [sub_apply]; abel |
| _ ≤ ‖f x-f y-D b.val (x-y)‖ + ‖(D b.val-D a) (x-y)‖ := norm_add_le _ _ |
| _ ≤ (ε/2)*‖x-y‖ + (ε/2)*‖x-y‖ := |
| add_le_add herr (((D b.val-D a).le_opNorm _).trans (by gcongr)) |
| _ = ε*‖x-y‖ := by ring |
| · refine ⟨1,zero_lt_one,?_⟩ |
| intro a ha |
| have := hs ha |
| simp only [Finset.not_nonempty_iff_eq_empty.mp hsn,Finset.notMem_empty, iUnion_of_empty, |
| iUnion_empty,mem_empty_iff_false] at this |
|
|
| end UniversalCoverSplitting |
| open Set Metric Filter Topology Asymptotics |
|
|
| namespace UniversalCoverSplitting |
| variable {𝕜 E F T : Type*} [NontriviallyNormedField 𝕜] |
| [NormedAddCommGroup E] [NormedSpace 𝕜 E] |
| [NormedAddCommGroup F] [NormedSpace 𝕜 F] |
| [TopologicalSpace T] [CompactSpace T] |
|
|
| def pathLinearApply (A : C(T,E →L[𝕜] F)) : C(T,E) →L[𝕜] C(T,F) := |
| LinearMap.mkContinuous |
| { toFun := fun η ↦ ⟨fun t ↦ A t (η t), by fun_prop⟩ |
| map_add' := by intros; ext; simp |
| map_smul' := by intros; ext; simp } |
| ‖A‖ (fun η ↦ by |
| dsimp only [LinearMap.coe_mk, AddHom.coe_mk] |
| apply (ContinuousMap.norm_le _ (mul_nonneg (norm_nonneg A) (norm_nonneg η))).mpr |
| intro t |
| exact ((A t).le_opNorm (η t)).trans |
| (mul_le_mul (A.norm_coe_le_norm t) (η.norm_coe_le_norm t) |
| (norm_nonneg _) (norm_nonneg _))) |
|
|
| @[simp] theorem pathLinearApply_apply (A : C(T,E →L[𝕜] F)) (η : C(T,E)) (t : T) : |
| pathLinearApply A η t = A t (η t) := rfl |
|
|
| def pathDerivative (D : E → E →L[𝕜] F) (γ : C(T,E)) |
| (hD : ∀ t, ContinuousAt D (γ t)) : C(T,E →L[𝕜] F) := |
| ⟨fun t ↦ D (γ t), continuous_iff_continuousAt.mpr |
| (fun t ↦ (hD t).comp γ.continuous.continuousAt)⟩ |
|
|
| theorem hasStrictFDerivAt_pathCompose (f : C(E,F)) (D : E → E →L[𝕜] F) |
| (γ : C(T,E)) (hder : ∀ t, HasStrictFDerivAt f (D (γ t)) (γ t)) |
| (hD : ∀ t, ContinuousAt D (γ t)) : |
| HasStrictFDerivAt (fun η : C(T,E) ↦ f.comp η) |
| (pathLinearApply (pathDerivative D γ hD)) γ := by |
| rw [hasStrictFDerivAt_iff_isLittleO, isLittleO_iff] |
| intro ε hε |
| obtain ⟨δ,hδ,hb⟩ := uniform_strict_derivative_on_compact |
| (isCompact_range γ.continuous) |
| (by rintro x ⟨t,rfl⟩; exact hder t) |
| (by rintro x ⟨t,rfl⟩; exact hD t) hε |
| apply Metric.eventually_nhds_iff_ball.mpr |
| refine ⟨δ,hδ,?_⟩ |
| intro p hp |
| rw [← ball_prod_same] at hp |
| apply (ContinuousMap.norm_le _ (mul_nonneg hε.le (norm_nonneg _))).mpr |
| intro t |
| have hx : p.1 t ∈ ball (γ t) δ := by |
| have ht := (p.1-γ).norm_coe_le_norm t |
| rw [mem_ball, dist_eq_norm] |
| exact lt_of_le_of_lt ht (by simpa only [mem_ball,dist_eq_norm] using hp.1) |
| have hy : p.2 t ∈ ball (γ t) δ := by |
| have ht := (p.2-γ).norm_coe_le_norm t |
| rw [mem_ball, dist_eq_norm] |
| exact lt_of_le_of_lt ht (by simpa only [mem_ball,dist_eq_norm] using hp.2) |
| exact (hb (γ t) (mem_range_self t) _ hx _ hy).trans |
| (mul_le_mul_of_nonneg_left ((p.1-p.2).norm_coe_le_norm t) hε.le) |
|
|
| end UniversalCoverSplitting |
| open Set Metric Filter Topology |
|
|
| namespace UniversalCoverSplitting |
| variable {𝕜 E F T : Type*} [RCLike 𝕜] |
| [NormedAddCommGroup E] [NormedSpace 𝕜 E] |
| [NormedAddCommGroup F] [NormedSpace 𝕜 F] |
| [TopologicalSpace T] [CompactSpace T] |
|
|
| theorem pathLinearApply_norm_le (A : C(T,E →L[𝕜] F)) : |
| ‖pathLinearApply A‖ ≤ ‖A‖ := by |
| apply ContinuousLinearMap.opNorm_le_bound (pathLinearApply A) (norm_nonneg A) |
| intro η |
| apply (ContinuousMap.norm_le _ (mul_nonneg (norm_nonneg A) (norm_nonneg η))).mpr |
| intro t |
| exact ((A t).le_opNorm (η t)).trans |
| (mul_le_mul (A.norm_coe_le_norm t) (η.norm_coe_le_norm t) |
| (norm_nonneg _) (norm_nonneg _)) |
|
|
| def pathLinearApplyL : C(T,E →L[𝕜] F) →L[𝕜] C(T,E) →L[𝕜] C(T,F) := |
| LinearMap.mkContinuous |
| { toFun := fun A : C(T,E →L[𝕜] F) ↦ pathLinearApply A |
| map_add' := by intros; ext η t; simp |
| map_smul' := by intros; ext η t; simp } |
| 1 (fun A ↦ by simpa using pathLinearApply_norm_le A) |
|
|
| @[simp] theorem pathLinearApplyL_apply (A : C(T,E →L[𝕜] F)) : |
| pathLinearApplyL A = pathLinearApply A := rfl |
|
|
| theorem contDiffAt_pathCompose_one (f : C(E,F)) (D : C(E,E →L[𝕜] F)) |
| {U : Set E} (hU : IsOpen U) |
| (hder : ∀ x ∈ U, HasFDerivAt f (D x) x) |
| (γ : C(T,E)) (hγ : range γ ⊆ U) : |
| ContDiffAt 𝕜 1 (fun η : C(T,E) ↦ f.comp η) γ := by |
| let O : Set C(T,E) := {η | range η ⊆ U} |
| have hO : IsOpen O := ContinuousMap.isOpen_setOfPred_range_subset hU |
| have hcoef : Continuous (fun η : C(T,E) ↦ pathLinearApply (D.comp η)) := |
| pathLinearApplyL.continuous.comp D.continuous_postcomp |
| apply contDiffAt_one_iff.mpr |
| refine ⟨fun η ↦ pathLinearApply (D.comp η), O, hO.mem_nhds hγ, |
| hcoef.continuousOn, ?_⟩ |
| intro η hη |
| have hs (t : T) : HasStrictFDerivAt f (D (η t)) (η t) := by |
| apply hasStrictFDerivAt_of_hasFDerivAt_of_continuousAt |
| · filter_upwards [hU.mem_nhds (hη (mem_range_self t))] with x hx |
| exact hder x hx |
| · exact D.continuous.continuousAt |
| have hD (t : T) : ContinuousAt D (η t) := D.continuous.continuousAt |
| convert! (hasStrictFDerivAt_pathCompose f D η hs hD).hasFDerivAt using 1 |
|
|
| end UniversalCoverSplitting |
|
|
| end |
|
|
| end OAI |
|
|
