Download data/lean/OAI/Geometry/KahlerSplitting/FlowVariation.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 15.7 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/KahlerSplitting/FlowVariation.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Geometry/KahlerSplitting/FlowVariation.lean
-
curl -L -o FlowVariation.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/KahlerSplitting/FlowVariation.lean
15.7 kB
| import OAI.Geometry.KahlerSplitting.Picard | |
| namespace OAI | |
| noncomputable section | |
| open scoped Manifold ContDiff | |
| open Set Topology Filter Metric | |
| open Set MeasureTheory Metric Filter Topology | |
| open scoped ENNReal | |
| open Set Metric | |
| open scoped ENNReal NNReal | |
| 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 scoped Manifold ENNReal | |
| open Set | |
| open scoped Manifold | |
| open Set Metric Filter Topology Asymptotics | |
| open Set MeasureTheory | |
| open Set Metric Filter Topology | |
| open scoped ContDiff | |
| open Set Metric Filter Topology MeasureTheory | |
| open scoped Interval | |
| namespace UniversalCoverSplitting | |
| variable {E : Type*} [NormedAddCommGroup E] [NormedSpace β E] | |
| [NormedSpace β E] [IsScalarTower β β E] [CompleteSpace E] | |
| omit [CompleteSpace E] in | |
| theorem picard_initial_variation (V : C(E,E)) (D : C(E,E βL[β] E)) | |
| {U : Set E} (hU : IsOpen U) (hder : β x β U, HasFDerivAt V (D x) x) | |
| {p v : E} {z : β} {Ο : β β FlowPath E} {Z : FlowPath E} | |
| (hΟ : HasDerivAt Ο Z 0) (hr : range (Ο 0) β U) | |
| (heq : βαΆ w in π (0 : β), | |
| Ο w = ContinuousMap.const FlowTime (p+wβ’v) + z β’ picardIntegral V (Ο w)) : | |
| Z = ContinuousMap.const FlowTime v + | |
| z β’ pathPrimitiveL (pathLinearApply (D.comp (Ο 0)) Z) := by | |
| have hi := (hasFDerivAt_picardIntegral V D hU hder hr).comp_hasDerivAt 0 hΟ | |
| have hp := ((hasDerivAt_id (0 : β)).smul_const v).const_add p | |
| have hc := (ContinuousLinearMap.const β FlowTime : E βL[β] FlowPath E).hasFDerivAt.comp_hasDerivAt 0 hp | |
| have hh := hc.add (hi.const_smul z) | |
| have he : HasDerivAt Ο (ContinuousMap.const FlowTime v + | |
| z β’ pathPrimitiveL (pathLinearApply (D.comp (Ο 0)) Z)) 0 := by | |
| convert! hh.congr_of_eventuallyEq heq using 1 | |
| simp | |
| rfl | |
| exact hΟ.unique he | |
| theorem commuting_field_picard_equation (V W : C(E,E)) (D : C(E,E βL[β] E)) | |
| (DW : E β E βL[β] E) {U : Set E} | |
| (hW : β x β U, HasFDerivAt W (DW x) x) | |
| (hcomm : β x β U, DW x (V x) = D x (W x)) | |
| {p : E} {z : β} {Ξ³ : FlowPath E} (hr : range Ξ³ β U) | |
| (heq : Ξ³ = ContinuousMap.const FlowTime p + z β’ picardIntegral V Ξ³) : | |
| W.comp Ξ³ = ContinuousMap.const FlowTime (W p) + | |
| z β’ pathPrimitiveL (pathLinearApply (D.comp Ξ³) (W.comp Ξ³)) := by | |
| let Ξ· := picardRealExtension V p z Ξ³ | |
| let B := pathLinearApply (D.comp Ξ³) (W.comp Ξ³) | |
| have hΞ· (u : FlowTime) : Ξ· u = Ξ³ u := picardRealExtension_eq V heq u | |
| have hd (u : FlowTime) : HasDerivAt (fun v : β β¦ W (Ξ· v)) | |
| (z β’ pathExtend B u) u := by | |
| have ht := picardRealExtension_hasDerivAt V p z Ξ³ u.val | |
| have hv := ((hW (Ξ³ u) (hr (mem_range_self u))).restrictScalars β) | |
| rw [β hΞ· u] at hv | |
| have hc := hv.comp_hasDerivAt u.val ht | |
| convert! hc using 1 | |
| rw [pathExtend_apply,hΞ· u,pathExtend_apply] | |
| change z β’ D (Ξ³ u) (W (Ξ³ u)) = DW (Ξ³ u) (z β’ V (Ξ³ u)) | |
| rw [map_smul,hcomm _ (hr (mem_range_self u))] | |
| ext t | |
| have hderiv (u : β) (hu : u β uIcc (0 : β) t.val) : | |
| HasDerivAt (fun v : β β¦ W (Ξ· v)) (z β’ pathExtend B u) u := by | |
| have hu' : u β Icc (0 : β) 1 := by | |
| rw [uIcc_of_le t.property.1] at hu | |
| exact β¨hu.1,hu.2.trans t.property.2β© | |
| exact hd β¨u,hu'β© | |
| have hi := intervalIntegral.integral_eq_sub_of_hasDerivAt hderiv | |
| (((pathExtend B).continuous.const_smul z).intervalIntegrable 0 t.val) | |
| rw [intervalIntegral.integral_smul,hΞ· t] at hi | |
| have hΞ·0 : Ξ· 0 = p := by simp [Ξ·,picardRealExtension] | |
| rw [hΞ·0] at hi | |
| change W (Ξ³ t) = W p + z β’ β« u in (0 : β)..t.val, pathExtend B u | |
| exact (sub_eq_iff_eq_add.mp hi.symm).trans (add_comm _ _) | |
| theorem picard_endpoint_preserves_commuting_field (V W : C(E,E)) | |
| (D : C(E,E βL[β] E)) (DW : E β E βL[β] E) | |
| {U : Set E} (hU : IsOpen U) (hV : β x β U, HasFDerivAt V (D x) x) | |
| (hW : β x β U, HasFDerivAt W (DW x) x) | |
| (hcomm : β x β U, DW x (V x) = D x (W x)) | |
| {p : E} {z : β} {Ο : β β FlowPath E} {Z : FlowPath E} | |
| (hΟ : HasDerivAt Ο Z 0) (hr : range (Ο 0) β U) | |
| (heq : βαΆ w in π (0 : β), Ο w = | |
| ContinuousMap.const FlowTime (p+wβ’W p) + z β’ picardIntegral V (Ο w)) | |
| (hz : βzβ * βD.comp (Ο 0)β < 1) : | |
| HasDerivAt (fun w β¦ Ο w β¨1,zero_le_one,le_rflβ©) | |
| (W (Ο 0 β¨1,zero_le_one,le_rflβ©)) 0 := by | |
| have hZ := picard_initial_variation V D hU hV hΟ hr heq | |
| have heq0 : Ο 0 = ContinuousMap.const FlowTime p + z β’ picardIntegral V (Ο 0) := by | |
| simpa using heq.self_of_nhds | |
| have hY := commuting_field_picard_equation V W D DW hW hcomm hr heq0 | |
| have hZY := picard_linear_unique (D.comp (Ο 0)) hz hZ hY | |
| have hEval := (ContinuousMap.evalCLM (R := β) (M := E) | |
| (β¨1,zero_le_one,le_rflβ© : FlowTime)).hasFDerivAt.comp_hasDerivAt 0 hΟ | |
| convert! hEval using 1 | |
| rw [hZY]; rfl | |
| end UniversalCoverSplitting | |
| open Set Metric Filter Topology | |
| open scoped ContDiff | |
| namespace UniversalCoverSplitting | |
| variable {E : Type*} [NormedAddCommGroup E] [NormedSpace β E] | |
| [NormedSpace β E] [IsScalarTower β β E] [CompleteSpace E] | |
| theorem exists_small_holomorphic_picard_family (V : C(E,E)) (D : C(E,E βL[β] E)) | |
| {U : Set E} (hU : IsOpen U) (hder : β x β U, HasFDerivAt V (D x) x) | |
| {p : E} (hp : p β U) : | |
| β W : Set (FlowParameter E), IsOpen W β§ (p,0) β W β§ | |
| β Ο : FlowParameter E β FlowPath E, | |
| ContDiffOn β 1 Ο W β§ Ο (p,0) = ContinuousMap.const FlowTime p β§ | |
| β q β W, range (Ο q) β U β§ | |
| Ο q = ContinuousMap.const FlowTime q.1 + q.2 β’ picardIntegral V (Ο q) β§ | |
| βq.2β * βD.comp (Ο q)β < 1 := by | |
| obtain β¨O,hOo,hOp,Ο,hΟ,hΟbase,heqβ© := exists_holomorphic_picard_family V D hU hder hp | |
| have hcΟ : ContinuousAt Ο (p,0) := hΟ.continuousOn.continuousAt (hOo.mem_nhds hOp) | |
| have hcD : ContinuousAt (fun q : E Γ β β¦ D.comp (Ο q)) (p,0) := by | |
| convert! D.continuous_postcomp.continuousAt.comp hcΟ | |
| have hn : Continuous (fun A : C(FlowTime,E βL[β] E) β¦ βAβ) := by | |
| convert! @continuous_norm C(FlowTime,E βL[β] E) inferInstance | |
| have hcNorm : ContinuousAt (fun q : E Γ β β¦ βq.2β * βD.comp (Ο q)β) (p,0) := | |
| continuous_snd.continuousAt.norm.mul (hn.continuousAt.comp hcD) | |
| have hsmall : βαΆ q : E Γ β in π (p,0), βq.2β * βD.comp (Ο q)β < 1 := by | |
| apply hcNorm.eventually_lt continuousAt_const | |
| simp | |
| have hboth : O β© {q | βq.2β * βD.comp (Ο q)β < 1} β π (p,0) := | |
| inter_mem (hOo.mem_nhds hOp) hsmall | |
| obtain β¨W,hWO,hWo,hWpβ© := _root_.mem_nhds_iff.mp hboth | |
| refine β¨W,hWo,hWp,Ο,hΟ.mono (fun q hq β¦ (hWO hq).1),hΟbase,?_β© | |
| intro q hq | |
| exact β¨(heq q (hWO hq).1).1,(heq q (hWO hq).1).2,(hWO hq).2β© | |
| end UniversalCoverSplitting | |
| open Set Metric Filter Topology | |
| open scoped ContDiff | |
| namespace UniversalCoverSplitting | |
| variable {E : Type*} [NormedAddCommGroup E] [NormedSpace β E] | |
| [NormedSpace β E] [IsScalarTower β β E] [CompleteSpace E] | |
| theorem picard_endpoint_hasDerivAt (V : C(E,E)) (D : C(E,E βL[β] E)) | |
| {U : Set E} (hU : IsOpen U) (hder : β x β U, HasFDerivAt V (D x) x) | |
| {p : E} {z : β} {Ο : β β FlowPath E} {Z : FlowPath E} | |
| (hΟ : HasDerivAt Ο Z z) (hr : range (Ο z) β U) | |
| (heq : βαΆ w in π z, Ο w = ContinuousMap.const FlowTime p + w β’ picardIntegral V (Ο w)) | |
| (hz : βzβ * βD.comp (Ο z)β < 1) : | |
| HasDerivAt (fun w β¦ Ο w β¨1,zero_le_one,le_rflβ©) | |
| (V (Ο z β¨1,zero_le_one,le_rflβ©)) z := by | |
| have hZ := picard_variation_equation V D hU hder hΟ hr heq | |
| have hY := picardTimeVariation_equation V D hder hr heq.self_of_nhds | |
| have hZY := picard_linear_unique (D.comp (Ο z)) hz hZ hY | |
| have he := (ContinuousMap.evalCLM (R := β) (M := E) | |
| (β¨1,zero_le_one,le_rflβ© : FlowTime)).hasFDerivAt.comp_hasDerivAt z hΟ | |
| convert! he using 1 | |
| rw [hZY] | |
| simp [picardTimeVariation] | |
| theorem exists_holomorphic_flow_representatives (V : C(E,E)) (D : C(E,E βL[β] E)) | |
| {U : Set E} (hU : IsOpen U) (hder : β x β U, HasFDerivAt V (D x) x) | |
| {p : E} (hp : p β U) : | |
| β W : Set (E Γ β), IsOpen W β§ (p,0) β W β§ | |
| β F : E Γ β β E, | |
| ContDiffOn β 1 F W β§ MapsTo F W U β§ | |
| (β x, (x,0) β W β F (x,0) = x) β§ | |
| (β q β W, HasDerivAt (fun z β¦ F (q.1,z)) (V (F q)) q.2) := by | |
| obtain β¨W,hWo,hWp,Ο,hΟ,hΟbase,heqβ© := | |
| exists_small_holomorphic_picard_family V D hU hder hp | |
| let eβ : FlowTime := β¨1,zero_le_one,le_rflβ© | |
| let F : E Γ β β E := fun q β¦ Ο q eβ | |
| refine β¨W,hWo,hWp,F,?_,?_,?_,?_β© | |
| Β· exact (ContinuousMap.evalCLM (R := β) (M := E) eβ).contDiff.comp_contDiffOn | |
| hΟ | |
| Β· intro q hq | |
| exact (heq q hq).1 (mem_range_self eβ) | |
| Β· intro x hx | |
| have h := congrArg (fun Ξ³ : FlowPath E β¦ Ξ³ eβ) (heq (x,0) hx).2.1 | |
| simpa [F] using h | |
| Β· intro q hq | |
| have hΟq : DifferentiableAt β Ο q := | |
| (hΟ.contDiffAt (hWo.mem_nhds hq)).differentiableAt (by norm_num) | |
| have hem : DifferentiableAt β (fun z : β β¦ (q.1,z)) q.2 := | |
| (differentiableAt_const q.1).prodMk differentiableAt_id | |
| have hΟ := (hΟq.comp q.2 hem).hasDerivAt | |
| have heq' : βαΆ z in π q.2, | |
| Ο (q.1,z) = ContinuousMap.const FlowTime q.1 + z β’ picardIntegral V (Ο (q.1,z)) := by | |
| have hn := hem.continuousAt.tendsto.eventually (hWo.mem_nhds hq) | |
| filter_upwards [hn] with z hz | |
| exact (heq _ hz).2.1 | |
| exact picard_endpoint_hasDerivAt V D hU hder hΟ (heq q hq).1 heq' (heq q hq).2.2 | |
| end UniversalCoverSplitting | |
| open Set Metric Filter Topology | |
| open scoped ContDiff | |
| namespace UniversalCoverSplitting | |
| variable {E : Type*} [NormedAddCommGroup E] [NormedSpace β E] | |
| [NormedSpace β E] [IsScalarTower β β E] [CompleteSpace E] | |
| theorem picard_family_fderiv_preserves (V W : C(E,E)) | |
| (D : C(E,E βL[β] E)) (DW : E β E βL[β] E) | |
| {U : Set E} (hU : IsOpen U) (hV : β x β U, HasFDerivAt V (D x) x) | |
| (hW : β x β U, HasFDerivAt W (DW x) x) | |
| (hcomm : β x β U, DW x (V x) = D x (W x)) | |
| {O : Set (E Γ β)} (hO : IsOpen O) {Ο : E Γ β β FlowPath E} | |
| (hΟ : ContDiffOn β 1 Ο O) | |
| (heq : β q β O, range (Ο q) β U β§ | |
| Ο q = ContinuousMap.const FlowTime q.1 + q.2 β’ picardIntegral V (Ο q) β§ | |
| βq.2β * βD.comp (Ο q)β < 1) | |
| {q : E Γ β} (hq : q β O) : | |
| fderiv β (fun r β¦ Ο r β¨1,zero_le_one,le_rflβ©) q (W q.1,0) = | |
| W (Ο q β¨1,zero_le_one,le_rflβ©) := by | |
| let c : β β E Γ β := fun w β¦ (q.1 + w β’ W q.1,q.2) | |
| have hc : HasDerivAt c (W q.1,0) 0 := by | |
| convert! (((hasDerivAt_id (0 : β)).smul_const (W q.1)).const_add q.1).prodMk | |
| (hasDerivAt_const (0 : β) q.2) using 1; simp | |
| have hc0 : c 0 = q := by simp [c] | |
| have hΟq := (hΟ.contDiffAt (hO.mem_nhds hq)).differentiableAt (by norm_num : (1 : ββΟ) β 0) | |
| have hΟc : DifferentiableAt β Ο (c 0) := by simpa only [hc0] using hΟq | |
| have hΟ := hΟc.hasFDerivAt.comp_hasDerivAt 0 hc | |
| have hr : range (Ο (c 0)) β U := by simpa [hc0] using (heq q hq).1 | |
| have hi : βαΆ w in π (0 : β), Ο (c w) = | |
| ContinuousMap.const FlowTime (q.1+wβ’W q.1) + q.2 β’ picardIntegral V (Ο (c w)) := by | |
| have hnc : O β π (c 0) := by simpa only [hc0] using hO.mem_nhds hq | |
| have hn := hc.continuousAt.tendsto.eventually hnc | |
| filter_upwards [hn] with w hw | |
| exact (heq _ hw).2.1 | |
| have hz : βq.2β * βD.comp (Ο (c 0))β < 1 := by | |
| simpa [hc0] using (heq q hq).2.2 | |
| have hP := picard_endpoint_preserves_commuting_field V W D DW hU hV hW hcomm hΟ hr hi hz | |
| let F : E Γ β β E := fun r β¦ Ο r β¨1,zero_le_one,le_rflβ© | |
| have hF : DifferentiableAt β F q := | |
| (ContinuousMap.evalCLM (R := β) (M := E) (β¨1,zero_le_one,le_rflβ© : FlowTime)).differentiableAt.comp q hΟq | |
| have hFc : DifferentiableAt β F (c 0) := by simpa only [hc0] using hF | |
| have hF' := hFc.hasFDerivAt.comp_hasDerivAt 0 hc | |
| simpa [hc0,F] using hF'.unique hP | |
| theorem exists_holomorphic_flow_preserving_representatives (V : C(E,E)) (D : C(E,E βL[β] E)) | |
| {U : Set E} (hU : IsOpen U) (hder : β x β U, HasFDerivAt V (D x) x) | |
| {p : E} (hp : p β U) : | |
| β W : Set (E Γ β), IsOpen W β§ (p,0) β W β§ | |
| β F : E Γ β β E, | |
| ContDiffOn β 1 F W β§ MapsTo F W U β§ | |
| (β x, (x,0) β W β F (x,0) = x) β§ | |
| (β q β W, HasDerivAt (fun z β¦ F (q.1,z)) (V (F q)) q.2) β§ | |
| (β (A : C(E,E)) (DA : E β E βL[β] E), | |
| (β x β U, HasFDerivAt A (DA x) x) β | |
| (β x β U, DA x (V x) = D x (A x)) β | |
| β q β W, fderiv β F q (A q.1,0) = A (F q)) := by | |
| obtain β¨W,hWo,hWp,Ο,hΟ,hΟbase,heqβ© := | |
| exists_small_holomorphic_picard_family V D hU hder hp | |
| let eβ : FlowTime := β¨1,zero_le_one,le_rflβ© | |
| let F : E Γ β β E := fun q β¦ Ο q eβ | |
| refine β¨W,hWo,hWp,F,?_,?_,?_,?_,?_β© | |
| Β· exact (ContinuousMap.evalCLM (R := β) (M := E) eβ).contDiff.comp_contDiffOn | |
| hΟ | |
| Β· intro q hq | |
| exact (heq q hq).1 (mem_range_self eβ) | |
| Β· intro x hx | |
| have h := congrArg (fun Ξ³ : FlowPath E β¦ Ξ³ eβ) (heq (x,0) hx).2.1 | |
| simpa [F] using h | |
| Β· intro q hq | |
| have hΟq : DifferentiableAt β Ο q := | |
| (hΟ.contDiffAt (hWo.mem_nhds hq)).differentiableAt (by norm_num) | |
| have hem : DifferentiableAt β (fun z : β β¦ (q.1,z)) q.2 := | |
| (differentiableAt_const q.1).prodMk differentiableAt_id | |
| have hΟ := (hΟq.comp q.2 hem).hasDerivAt | |
| have heq' : βαΆ z in π q.2, | |
| Ο (q.1,z) = ContinuousMap.const FlowTime q.1 + z β’ picardIntegral V (Ο (q.1,z)) := by | |
| have hn := hem.continuousAt.tendsto.eventually (hWo.mem_nhds hq) | |
| filter_upwards [hn] with z hz | |
| exact (heq _ hz).2.1 | |
| exact picard_endpoint_hasDerivAt V D hU hder hΟ (heq q hq).1 heq' (heq q hq).2.2 | |
| Β· intro A DA hA hcomm q hq | |
| exact picard_family_fderiv_preserves V A D DA hU hder hA hcomm hWo hΟ heq hq | |
| end UniversalCoverSplitting | |
| open Set Metric Filter Topology | |
| open scoped ContDiff | |
| namespace UniversalCoverSplitting | |
| variable {E : Type*} [NormedAddCommGroup E] [NormedSpace β E] | |
| [NormedSpace β E] [IsScalarTower β β E] [CompleteSpace E] | |
| structure HolomorphicFlowData (V : C(E,E)) (D : C(E,E βL[β] E)) (U : Set E) (p : E) where | |
| domain : Set (E Γ β) | |
| isOpen_domain : IsOpen domain | |
| base_mem : (p,0) β domain | |
| map : E Γ β β E | |
| contDiff : ContDiffOn β 1 map domain | |
| mapsTo : MapsTo map domain U | |
| zero : β x, (x,0) β domain β map (x,0) = x | |
| time : β q β domain, fderiv β map q (0,1) = V (map q) | |
| preserves : β (A : C(E,E)) (DA : E β E βL[β] E), | |
| (β x β U, HasFDerivAt A (DA x) x) β | |
| (β x β U, DA x (V x) = D x (A x)) β | |
| β q β domain, fderiv β map q (A q.1,0) = A (map q) | |
| theorem exists_holomorphicFlowData (V : C(E,E)) (D : C(E,E βL[β] E)) | |
| {U : Set E} (hU : IsOpen U) (hV : β x β U, HasFDerivAt V (D x) x) | |
| {p : E} (hp : p β U) : Nonempty (HolomorphicFlowData V D U p) := by | |
| obtain β¨O,hO,hpO,F,hF,hFU,hF0,hFt,hFAβ© := | |
| exists_holomorphic_flow_preserving_representatives V D hU hV hp | |
| refine β¨β¨O,hO,hpO,F,hF,hFU,hF0,?_,hFAβ©β© | |
| intro q hq | |
| have hFq := (hF.contDiffAt (hO.mem_nhds hq)).differentiableAt (by norm_num) | |
| have hc : HasDerivAt (fun z : β β¦ (q.1,z)) (0,1) q.2 := | |
| (hasDerivAt_const q.2 q.1).prodMk (hasDerivAt_id q.2) | |
| exact (hFq.hasFDerivAt.comp_hasDerivAt q.2 hc).unique (hFt q hq) | |
| end UniversalCoverSplitting | |
| end | |
| end OAI | |