Download data/lean/OAI/Geometry/ConjugatePoints/Geodesics.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 126 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/ConjugatePoints/Geodesics.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Geometry/ConjugatePoints/Geodesics.lean
-
curl -L -o Geodesics.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/ConjugatePoints/Geodesics.lean
126 kB
import OAI.Geometry.ConjugatePoints.Index
import OAI.Geometry.ConjugatePoints.Curvature
namespace OAI
noncomputable section
/-!
# Geodesic flow, variation equations, and the Gauss lemma.
-/
section
open Set Filter Topology Asymptotics
open scoped NNReal
namespace ThreeManifold.ODEVariation
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace β E]
lemma remainder_bound {f : E β E} {D : E β E βL[β] E}
{u v : β β E} {A : β β E βL[β] E} {x y : E} {a b K C L : β}
(hK : 0 < K) (hC : 0 β€ C) (_hL : 0 β€ L)
(hu : β t β Icc a b, HasDerivAt u (f (u t)) t)
(hv : β t β Icc a b, HasDerivAt v (f (v t)) t)
(hA : β t β Icc a b, β z, HasDerivAt (fun s => A s z) (D (u t) (A t z)) t)
(hua : u a = x) (hva : v a = y) (hAa : A a = ContinuousLinearMap.id β E)
(hD : β t β Icc a b, βD (u t)β β€ K)
(hLip : β t β Icc a b, βv t - u tβ β€ L * βy-xβ)
(hTaylor : β t β Icc a b,
βf (v t) - f (u t) - D (u t) (v t-u t)β β€ C * βv t-u tβ ^ 2) :
β t β Icc a b,
βv t - u t - A t (y-x)β β€
(C * L^2 / K * (Real.exp (K * (t-a))-1)) * βy-xβ^2 := by
intro t ht
let R : β β E := fun s => v s-u s-A s (y-x)
let R' : β β E := fun s => f (v s)-f (u s)-D (u s) (A s (y-x))
have hd : β s β Icc a b, HasDerivAt R (R' s) s := fun s hs =>
((hv s hs).sub (hu s hs)).sub (hA s hs (y-x))
have hb : β s β Ico a b, βR' sβ β€ K * βR sβ + C*L^2*βy-xβ^2 := by
intro s hs
have hsc := Ico_subset_Icc_self hs
have he : R' s = D (u s) (R s) +
(f (v s)-f (u s)-D (u s) (v s-u s)) := by
simp only [R', R, map_sub]
abel
rw [he]
calc
_ β€ βD (u s) (R s)β + βf (v s)-f (u s)-D (u s) (v s-u s)β := norm_add_le _ _
_ β€ K * βR sβ + C * βv s-u sβ^2 := add_le_add
((D (u s)).le_opNorm _ |>.trans (mul_le_mul_of_nonneg_right (hD s hsc) (norm_nonneg _)))
(hTaylor s hsc)
_ β€ K * βR sβ + C*L^2*βy-xβ^2 := by
have hh : βv s-u sβ^2 β€ (L*βy-xβ)^2 :=
pow_le_pow_leftβ (norm_nonneg _) (hLip s hsc) 2
nlinarith [mul_le_mul_of_nonneg_left hh hC]
have hr := norm_le_gronwallBound_of_norm_deriv_right_le
(f := R) (f' := R') (K := K) (Ξ΅ := C*L^2*βy-xβ^2) (Ξ΄ := 0)
(fun s hs => (hd s hs).continuousAt.continuousWithinAt)
(fun s hs => (hd s (Ico_subset_Icc_self hs)).hasDerivWithinAt)
(by simp [R,hua,hva,hAa]) hb t ht
dsimp [gronwallBound] at hr
rw [ite_eq_right hK.ne', zero_mul, zero_add] at hr
change βR tβ β€ _
convert hr using 1 ; ring
lemma hasFDerivAt_of_quadratic_error {F : E β E} {A : E βL[β] E} {x : E}
{Q : β} (h : βαΆ y in π x, βF y-F x-A (y-x)β β€ Q*βy-xβ^2) :
HasFDerivAt F A x := by
rw [hasFDerivAt_iff_isLittleO]
have hb : (fun y => F y-F x-A (y-x)) =O[π x] (fun y => βy-xβ^2) := by
apply isBigO_iff.mpr
refine β¨Q,?_β©
filter_upwards [h] with y hy
simpa only [Real.norm_eq_abs, abs_of_nonneg (sq_nonneg βy-xβ)] using hy
exact hb.trans_isLittleO (isLittleO_pow_sub_sub x (by norm_num : 1 < (2 : β)))
lemma flow_hasFDerivAt {f : E β E} {D : E β E βL[β] E}
{X : E β β β E} {A : β β E βL[β] E} {x : E} {a b K C L : β}
(hK : 0 < K) (hC : 0 β€ C) (hL : 0 β€ L)
(hx : β t β Icc a b, HasDerivAt (X x) (f (X x t)) t)
(hA : β t β Icc a b, β z,
HasDerivAt (fun s => A s z) (D (X x t) (A t z)) t)
(hxa : X x a = x) (hAa : A a = ContinuousLinearMap.id β E)
(hD : β t β Icc a b, βD (X x t)β β€ K)
(hnear : βαΆ y in π x, X y a = y β§
(β t β Icc a b, HasDerivAt (X y) (f (X y t)) t) β§
(β t β Icc a b, βX y t-X x tβ β€ L*βy-xβ) β§
(β t β Icc a b, βf (X y t)-f (X x t)-D (X x t) (X y t-X x t)β β€
C*βX y t-X x tβ^2)) {t : β} (ht : t β Icc a b) :
HasFDerivAt (fun y => X y t) (A t) x := by
apply hasFDerivAt_of_quadratic_error (Q := C*L^2/K*(Real.exp (K*(t-a))-1))
filter_upwards [hnear] with y hy
exact remainder_bound hK hC hL hx hy.2.1 hA hxa hy.1 hAa hD hy.2.2.1 hy.2.2.2 t ht
lemma quadratic_taylor {f : E β E} {S : Set E} {C : ββ₯0}
(hS : Convex β S) (hf : β z β S, DifferentiableAt β f z)
(hD : LipschitzOnWith C (fderiv β f) S) {x y : E} (hx : x β S) (hy : y β S) :
βf y-f x-fderiv β f x (y-x)β β€ C*βy-xβ^2 := by
have hseg := hS.segment_subset hx hy
have hd : β z β segment β x y, βfderiv β f z-fderiv β f xβ β€ C*βy-xβ := by
intro z hz
exact (hD.norm_sub_le (hseg hz) hx).trans
(mul_le_mul_of_nonneg_left (norm_sub_le_of_mem_segment hz) C.coe_nonneg)
have hh := (convex_segment x y).norm_image_sub_le_of_norm_fderiv_le'
(fun z hz => hf z (hseg hz)) hd (left_mem_segment β x y) (right_mem_segment β x y)
simpa only [pow_two,mul_assoc] using hh
lemma local_bounds {f : E β E} {x : E} (hf : ContDiffAt β 2 f x) :
β r > (0 : β), β K > (0 : β), β C : ββ₯0,
(β z β Metric.ball x r, DifferentiableAt β f z) β§
(β z β Metric.ball x r, βfderiv β f zβ β€ K) β§
(β z β Metric.ball x r, β w β Metric.ball x r,
βf w-f z-fderiv β f z (w-z)β β€ C*βw-zβ^2) := by
have hD : ContDiffAt β 1 (fderiv β f) x := hf.fderiv_right (by norm_num)
obtain β¨C,S,hS,hLipβ© := hD.exists_lipschitzOnWith
have hdiff : βαΆ z in π x, DifferentiableAt β f z := by
filter_upwards [hf.eventually (by norm_num)] with z hz
exact hz.differentiableAt (by norm_num)
have hbound : βαΆ z in π x, βfderiv β f zβ < βfderiv β f xβ+1 :=
hD.continuousAt.norm.eventually_lt_const (by linarith)
obtain β¨r,hr,hrsβ© := Metric.mem_nhds_iff.mp (inter_mem hS (inter_mem hdiff hbound))
refine β¨r,hr,βfderiv β f xβ+1,by positivity,C,?_,?_,?_β©
Β· intro z hz; exact (hrs hz).2.1
Β· intro z hz; exact (hrs hz).2.2.le
Β· intro z hz w hw
exact quadratic_taylor (convex_ball x r) (fun z hz => (hrs hz).2.1)
(hLip.mono (fun z hz => (hrs hz).1)) hz hw
end ThreeManifold.ODEVariation
end
section
open Set Filter Topology Metric
open scoped NNReal
namespace ThreeManifold.ODEVariation
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace β E] [CompleteSpace E]
def variationVector (f : E β E) (z : E Γ (E βL[β] E)) : E Γ (E βL[β] E) :=
(f z.1, (fderiv β f z.1).comp z.2)
lemma variationVector_smoothAt {f : E β E} {x : E}
(hf : ContDiffAt β 2 f x) (A : E βL[β] E) :
ContDiffAt β 1 (variationVector f) (x,A) := by
let _ : CompleteSpace E := inferInstance
exact ((hf.of_le (by norm_num)).comp (x,A) contDiffAt_fst).prodMk
(((hf.fderiv_right (m := 1) (by norm_num)).comp (x,A) contDiffAt_fst).clm_comp contDiffAt_snd)
lemma exists_variation_flow {f : E β E} {x : E} (hf : ContDiffAt β 2 f x) :
β r > (0 : β), β Ξ΅ > (0 : β), β X : E β β β E,
β A : E β β β E βL[β] E, β L : ββ₯0,
(β y β closedBall x r, X y 0 = y β§ A y 0 = ContinuousLinearMap.id β E) β§
(β y β closedBall x r, β t β Icc (-Ξ΅) Ξ΅,
HasDerivAt (X y) (f (X y t)) t β§
HasDerivAt (A y) ((fderiv β f (X y t)).comp (A y t)) t) β§
(β t β Icc (-Ξ΅) Ξ΅, β y β closedBall x r, β z β closedBall x r,
βX y t-X z tβ β€ L*βy-zβ β§ βA y t-A z tβ β€ L*βy-zβ) β§
ContinuousOn (fun yt : E Γ β => (X yt.1 yt.2,A yt.1 yt.2))
(closedBall x r ΓΛ’ Icc (-Ξ΅) Ξ΅) := by
let zβ : E Γ (E βL[β] E) := (x,ContinuousLinearMap.id β E)
obtain β¨Ξ΅,hΞ΅,a,r,B,K,hr,hplβ© := IsPicardLindelof.of_contDiffAt_one
(variationVector_smoothAt hf (ContinuousLinearMap.id β E))
obtain β¨Y,hY,L,hLipβ© := (hpl 0).exists_forall_mem_closedBall_eq_hasDerivWithinAt_lipschitzOnWith
have hcont : ContinuousOn (Function.uncurry Y) (closedBall zβ r ΓΛ’ Icc (0-Ξ΅) (0+Ξ΅)) := by
apply continuousOn_prod_of_continuousOn_lipschitzOnWith _ L _ hLip
intro z hz
exact HasDerivWithinAt.continuousOn (hY z hz).2
let ΞΉ : E β E Γ (E βL[β] E) := fun y => (y,ContinuousLinearMap.id β E)
have hi : LipschitzWith 1 ΞΉ := by
apply LipschitzWith.of_dist_le_mul
intro z w
simp [ΞΉ,Prod.dist_eq]
have hi_mem : β y β closedBall x r, ΞΉ y β closedBall zβ r := by
intro y hy
change dist y x β€ (r : β) at hy
change dist (ΞΉ y) zβ β€ (r : β)
simpa only [ΞΉ,zβ,Prod.dist_eq,dist_self,max_eq_left dist_nonneg] using hy
have htime : Icc (-(Ξ΅/2)) (Ξ΅/2) β Icc (0-Ξ΅) (0+Ξ΅) := by
rintro t β¨ht1,ht2β©; constructor <;> linarith
have htime_nhds : β t β Icc (-(Ξ΅/2)) (Ξ΅/2), Icc (0-Ξ΅) (0+Ξ΅) β π t := by
rintro t β¨ht1,ht2β©
apply Icc_mem_nhds <;> linarith
refine β¨r,hr,Ξ΅/2,half_pos hΞ΅,(fun y t => (Y (ΞΉ y) t).1),
(fun y t => (Y (ΞΉ y) t).2),L,?_,?_,?_,?_β©
Β· intro y hy
have hy0 := (hY (ΞΉ y) (hi_mem y hy)).1
exact β¨congrArg Prod.fst hy0,congrArg Prod.snd hy0β©
Β· intro y hy t ht
have hd := ((hY (ΞΉ y) (hi_mem y hy)).2 t (htime ht)).hasDerivAt (htime_nhds t ht)
exact β¨hd.fst,hd.sndβ©
Β· intro t ht y hy z hz
have hh := (hLip t (htime ht)).norm_sub_le (hi_mem y hy) (hi_mem z hz)
have he : βΞΉ y-ΞΉ zβ = βy-zβ := by
change max βy-zβ β(ContinuousLinearMap.id β E)-(ContinuousLinearMap.id β E)β = βy-zβ
simp
rw [he] at hh
exact β¨(norm_fst_le _).trans hh,(norm_snd_le _).trans hhβ©
Β· change ContinuousOn (Function.uncurry Y β (fun yt : E Γ β => (ΞΉ yt.1,yt.2))) _
apply hcont.comp ((hi.continuous.comp continuous_fst).prodMk continuous_snd).continuousOn
intro yt hyt
exact β¨hi_mem yt.1 hyt.1,htime hyt.2β©
lemma flow_derivative_on {f : E β E} {X : E β β β E} {A : E β β β E βL[β] E}
{S : Set E} {Ξ΅ K C L : β} (hS : IsOpen S) (hK : 0 < K) (hC : 0 β€ C) (hL : 0 β€ L)
(h0 : β y β S, X y 0 = y β§ A y 0 = ContinuousLinearMap.id β E)
(hODE : β y β S, β t β Icc (-Ξ΅) Ξ΅,
HasDerivAt (X y) (f (X y t)) t β§
HasDerivAt (A y) ((fderiv β f (X y t)).comp (A y t)) t)
(hD : β y β S, β t β Icc (-Ξ΅) Ξ΅, βfderiv β f (X y t)β β€ K)
(hLip : β y β S, β z β S, β t β Icc (-Ξ΅) Ξ΅, βX z t-X y tβ β€ L*βz-yβ)
(hTaylor : β y β S, β z β S, β t β Icc (-Ξ΅) Ξ΅,
βf (X z t)-f (X y t)-fderiv β f (X y t) (X z t-X y t)β β€ C*βX z t-X y tβ^2)
{y : E} (hy : y β S) {t : β} (ht : t β Icc (-Ξ΅) Ξ΅) :
HasFDerivAt (fun z => X z t) (A y t) y := by
let _ : CompleteSpace E := inferInstance
have hΞ΅ : 0 β€ Ξ΅ := by have := ht.1; have := ht.2; linarith
have hp : Icc (0 : β) Ξ΅ β Icc (-Ξ΅) Ξ΅ := by
rintro s β¨hs0,hsΞ΅β©; exact β¨by linarith,hsΞ΅β©
have hm : β s β Icc (0 : β) Ξ΅, -s β Icc (-Ξ΅) Ξ΅ := by
rintro s β¨hs0,hsΞ΅β©; constructor <;> linarith
by_cases ht0 : 0 β€ t
Β· apply flow_hasFDerivAt hK hC hL (b := Ξ΅)
(fun s hs => (hODE y hy s (hp hs)).1)
(fun s hs z => by
simpa only [ContinuousLinearMap.comp_apply,map_zero,add_zero] using
(hODE y hy s (hp hs)).2.clm_apply (hasDerivAt_const s z))
(h0 y hy).1 (h0 y hy).2 (fun s hs => hD y hy s (hp hs)) (ht := β¨ht0,ht.2β©)
filter_upwards [hS.mem_nhds hy] with z hz
exact β¨(h0 z hz).1,(fun s hs => (hODE z hz s (hp hs)).1),
(fun s hs => hLip y hy z hz s (hp hs)),(fun s hs => hTaylor y hy z hz s (hp hs))β©
Β· have hxrev : β z β S, β s β Icc (0 : β) Ξ΅,
HasDerivAt (fun r => X z (-r)) (-(f (X z (-s)))) s := by
intro z hz s hs
simpa only [Function.comp_def,neg_one_smul] using
((hODE z hz (-s) (hm s hs)).1.scomp s (hasDerivAt_id s).neg)
have hArev : β s β Icc (0 : β) Ξ΅, β v,
HasDerivAt (fun r => A y (-r) v)
((-fderiv β f (X y (-s))) (A y (-s) v)) s := by
intro s hs v
have hh := ((hODE y hy (-s) (hm s hs)).2.clm_apply (hasDerivAt_const (-s) v)).scomp s
(hasDerivAt_id s).neg
simpa only [Function.comp_def,ContinuousLinearMap.comp_apply,_root_.neg_apply,
neg_one_smul,map_zero,add_zero] using hh
have hh : HasFDerivAt (fun z => X z (-(-t))) (A y (-(-t))) y := by
apply flow_hasFDerivAt (f := fun w => -f w) (D := fun w => -fderiv β f w)
(X := fun z s => X z (-s)) (A := fun s => A y (-s)) hK hC hL
(b := Ξ΅) (hxrev y hy) hArev (by simpa using (h0 y hy).1)
(by simpa using (h0 y hy).2)
(fun s hs => by simpa only [norm_neg] using hD y hy (-s) (hm s hs))
(ht := β¨by linarith,by linarith [ht.1]β©)
filter_upwards [hS.mem_nhds hy] with z hz
refine β¨by simpa using (h0 z hz).1,hxrev z hz,(fun s hs => hLip y hy z hz (-s) (hm s hs)),?_β©
intro s hs
have he : (-f (X z (-s)))-(-f (X y (-s)))-(-fderiv β f (X y (-s))) (X z (-s)-X y (-s)) =
-(f (X z (-s))-f (X y (-s))-fderiv β f (X y (-s)) (X z (-s)-X y (-s))) := by
simp only [_root_.neg_apply]; abel
rw [he,norm_neg]
exact hTaylor y hy z hz (-s) (hm s hs)
simpa only [neg_neg] using hh
lemma shrink_flow_image {x : E} {r Ξ΅ R : β} {X : E β β β E}
(hr : 0 < r) (hΞ΅ : 0 < Ξ΅) (hR : 0 < R) (h0 : X x 0 = x)
(hc : ContinuousOn (Function.uncurry X) (closedBall x r ΓΛ’ Icc (-Ξ΅) Ξ΅)) :
β Ο > (0 : β), β Ξ΄ > (0 : β), β y β ball x Ο, β t β Icc (-Ξ΄) Ξ΄,
X y t β ball x R β§ y β closedBall x r β§ t β Icc (-Ξ΅) Ξ΅ := by
let _ : NormedSpace β E := inferInstance
let _ : CompleteSpace E := inferInstance
have hn : closedBall x r ΓΛ’ Icc (-Ξ΅) Ξ΅ β π (x,(0 : β)) := by
rw [nhds_prod_eq]
exact prod_mem_prod (closedBall_mem_nhds x hr) (Icc_mem_nhds (by linarith) hΞ΅)
have hxc : ContinuousAt (Function.uncurry X) (x,(0 : β)) := hc.continuousAt hn
have hm : (Function.uncurry X) β»ΒΉ' ball x R β π (x,(0 : β)) := by
apply hxc.preimage_mem_nhds
apply isOpen_ball.mem_nhds
simpa only [Function.uncurry_apply_pair,h0] using mem_ball_self hR
have hd : ball x r ΓΛ’ Ioo (-Ξ΅) Ξ΅ β π (x,(0 : β)) := by
rw [nhds_prod_eq]
exact prod_mem_prod (ball_mem_nhds x hr) (Ioo_mem_nhds (by linarith) hΞ΅)
obtain β¨Ξ·,hΞ·,hsubβ© := Metric.mem_nhds_iff.mp (inter_mem hm hd)
refine β¨Ξ·/2,half_pos hΞ·,Ξ·/2,half_pos hΞ·,?_β©
intro y hy t ht
have hp : (y,t) β ball (x,(0 : β)) Ξ· := by
rw [mem_ball,Prod.dist_eq,max_lt_iff]
constructor
Β· exact lt_trans hy (half_lt_self hΞ·)
Β· rw [Real.dist_eq,sub_zero,abs_lt]
constructor <;> linarith [ht.1,ht.2]
exact β¨(hsub hp).1,ball_subset_closedBall (hsub hp).2.1,
Ioo_subset_Icc_self (hsub hp).2.2β©
lemma exists_contDiff_variation_flow {f : E β E} {x : E} (hf : ContDiffAt β 2 f x) :
β r > (0 : β), β Ξ΅ > (0 : β), β X : E β β β E,
(β y β ball x r, X y 0 = y) β§
(β y β ball x r, β t β Ioo (-Ξ΅) Ξ΅, HasDerivAt (X y) (f (X y t)) t) β§
ContDiffOn β 1 (Function.uncurry X) (ball x r ΓΛ’ Ioo (-Ξ΅) Ξ΅) β§
β A : E β β β E βL[β] E,
(β y β ball x r, A y 0 = ContinuousLinearMap.id β E) β§
(β y β ball x r, β t β Ioo (-Ξ΅) Ξ΅, HasFDerivAt (fun z => X z t) (A y t) y) β§
(β y β ball x r, β t β Ioo (-Ξ΅) Ξ΅,
HasDerivAt (A y) ((fderiv β f (X y t)).comp (A y t)) t) := by
obtain β¨R,hR,K,hK,C,hfd,hDf,hTaylorβ© := local_bounds hf
obtain β¨r,hr,Ξ΅,hΞ΅,X,A,L,h0,hODE,hLip,hcontβ© := exists_variation_flow hf
have h0x : X x 0 = x := (h0 x (mem_closedBall_self hr.le)).1
obtain β¨Ο,hΟ,Ξ΄,hΞ΄,hsmallβ© := shrink_flow_image hr hΞ΅ hR h0x hcont.fst
have hz : (0 : β) β Icc (-Ξ΄) Ξ΄ := β¨by linarith,hΞ΄.leβ©
have hinit : β y β ball x Ο, y β closedBall x r := fun y hy => (hsmall y hy 0 hz).2.1
have htime : Icc (-Ξ΄) Ξ΄ β Icc (-Ξ΅) Ξ΅ :=
fun t ht => (hsmall x (mem_ball_self hΟ) t ht).2.2
have hdf : β y β ball x Ο, β t β Icc (-Ξ΄) Ξ΄,
HasFDerivAt (fun z => X z t) (A y t) y := by
intro y hy t ht
apply flow_derivative_on isOpen_ball hK C.coe_nonneg L.coe_nonneg
(fun y hy => h0 y (hinit y hy))
(fun y hy t ht => hODE y (hinit y hy) t (htime ht))
(fun y hy t ht => hDf _ (hsmall y hy t ht).1)
(fun y hy z hz t ht => (hLip t (htime ht) z (hinit z hz) y (hinit y hy)).1)
(fun y hy z hz t ht => hTaylor _ (hsmall y hy t ht).1 _ (hsmall z hz t ht).1)
hy ht
let O := ball x Ο ΓΛ’ Ioo (-Ξ΄) Ξ΄
have hO : IsOpen O := isOpen_ball.prod isOpen_Ioo
have hcont' : ContinuousOn (fun yt : E Γ β => (X yt.1 yt.2,A yt.1 yt.2)) O :=
hcont.mono (fun p hp => β¨hinit p.1 hp.1,htime (Ioo_subset_Icc_self hp.2)β©)
have hX : ContinuousOn (Function.uncurry X) O := hcont'.fst
have hA : ContinuousOn (Function.uncurry A) O := hcont'.snd
have hfX : ContinuousOn (fun p : E Γ β => f (X p.1 p.2)) O := by
intro p hp
exact (hfd _ (hsmall p.1 hp.1 p.2 (Ioo_subset_Icc_self hp.2)).1).continuousAt.comp_continuousWithinAt (f := Function.uncurry X)
(hX p hp)
let B : E Γ β β β βL[β] E := fun p => ContinuousLinearMap.toSpanSingleton β (f (X p.1 p.2))
have hB : ContinuousOn B O :=
(ContinuousLinearMap.toSpanSingletonCLE (π := β) (E := E)).continuous.comp_continuousOn hfX
let D : E Γ β β (E Γ β) βL[β] E := fun p => (A p.1 p.2).coprod (B p)
have hd : β p β O, HasFDerivAt (Function.uncurry X) (D p) p := by
intro p hp
apply HasStrictFDerivAt.hasFDerivAt
apply hasStrictFDerivAt_uncurry_coprod (fβ := A) (fβ := fun y t => B (y,t))
Β· filter_upwards [hO.mem_nhds hp] with q hq
exact hdf q.1 hq.1 q.2 (Ioo_subset_Icc_self hq.2)
Β· filter_upwards [hO.mem_nhds hp] with q hq
exact (hODE q.1 (hinit q.1 hq.1) q.2 (htime (Ioo_subset_Icc_self hq.2))).1.hasFDerivAt
Β· exact hA.continuousAt (hO.mem_nhds hp)
Β· exact hB.continuousAt (hO.mem_nhds hp)
have hD : ContinuousOn D O := by
have hh := (hA.clm_comp (continuousOn_const (c := ContinuousLinearMap.fst β E β))).add
(hB.clm_comp (continuousOn_const (c := ContinuousLinearMap.snd β E β)))
exact hh
refine β¨Ο,hΟ,Ξ΄,hΞ΄,X,(fun y hy => (h0 y (hinit y hy)).1),
(fun y hy t ht => (hODE y (hinit y hy) t (htime (Ioo_subset_Icc_self ht))).1),?_β©
constructor
Β· apply (contDiffOn_succ_iff_fderiv_of_isOpen (n := 0) hO).mpr
refine β¨fun p hp => (hd p hp).differentiableAt.differentiableWithinAt,by simp,?_β©
rw [contDiffOn_zero]
exact hD.congr (fun p hp => (hd p hp).fderiv)
Β· exact β¨A,(fun y hy => (h0 y (hinit y hy)).2),
(fun y hy t ht => hdf y hy t (Ioo_subset_Icc_self ht)),
(fun y hy t ht => (hODE y (hinit y hy) t (htime (Ioo_subset_Icc_self ht))).2)β©
lemma exists_contDiff_flow {f : E β E} {x : E} (hf : ContDiffAt β 2 f x) :
β r > (0 : β), β Ξ΅ > (0 : β), β X : E β β β E,
(β y β ball x r, X y 0 = y) β§
(β y β ball x r, β t β Ioo (-Ξ΅) Ξ΅, HasDerivAt (X y) (f (X y t)) t) β§
ContDiffOn β 1 (Function.uncurry X) (ball x r ΓΛ’ Ioo (-Ξ΅) Ξ΅) := by
obtain β¨r,hr,Ξ΅,hΞ΅,X,h0,hd,hs,_β© := exists_contDiff_variation_flow hf
exact β¨r,hr,Ξ΅,hΞ΅,X,h0,hd,hsβ©
end ThreeManifold.ODEVariation
end
section
open Set Filter Topology Bundle Manifold IsManifold Matrix
open scoped ContDiff Matrix.Norms.Elementwise
namespace ThreeManifold.ODEVariation
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace β E]
lemma solution_smooth {f : E β E} {S : Set E} {U : Set β} {x : β β E}
(hf : ContDiffOn β β f S) (hU : IsOpen U) (hx : MapsTo x U S)
(hd : β t β U, HasDerivAt x (f (x t)) t) : ContDiffOn β β x U := by
rw [contDiffOn_infty]
intro n
induction n with
| zero => exact (contDiffOn_zero).2 (fun t ht => (hd t ht).continuousAt.continuousWithinAt)
| succ n hn =>
rw [Nat.cast_add,Nat.cast_one,contDiffOn_succ_iff_deriv_of_isOpen hU]
refine β¨fun t ht => (hd t ht).differentiableAt.differentiableWithinAt,by simp,?_β©
exact ((contDiffOn_infty.mp hf n).comp hn hx).congr (fun t ht => (hd t ht).deriv)
end ThreeManifold.ODEVariation
namespace ThreeManifold.RiemannianCoordinates
variable {M : Type} [TopologicalSpace M] [ChartedSpace E3 M] [IsManifold I3 β M]
def geodesicPhase (g : SmoothMetric M) (c : OpenPartialHomeomorph M E3) (z : E3 Γ E3) : E3 Γ E3 :=
(z.2,-connectionTerm g c z.1 z.2 z.2)
lemma geodesicPhase_smoothAt (g : SmoothMetric M) {c : OpenPartialHomeomorph M E3}
(hc : c β atlas E3 M) {z : E3 Γ E3} (hz : z.1 β c.target) :
ContDiffAt β β (geodesicPhase g c) z := by
apply contDiffAt_snd.prodMk
apply ContDiffAt.neg
apply contDiffAt_pi.mpr
intro i
apply ContDiffAt.sum
intro j _
apply ContDiffAt.sum
intro k _
exact (((christoffel_smoothAt g hc hz i j k).comp z contDiffAt_fst).mul
(contDiffAt_pi.mp contDiffAt_snd j)).mul (contDiffAt_pi.mp contDiffAt_snd k)
lemma chart_geodesic (g : SmoothMetric M) {c : OpenPartialHomeomorph M E3}
(hc : c β atlas E3 M) {U : Set β} (hU : IsOpen U) {z : β β E3 Γ E3}
(hz : β t β U, (z t).1 β c.target)
(hd : β t β U, HasDerivAt z (geodesicPhase g c (z t)) t) :
IsGeodesicOn g (fun t => c.symm (z t).1) U := by
have hzs : ContDiffOn β β z U := ODEVariation.solution_smooth
(fun x hx => (geodesicPhase_smoothAt g hc hx).contDiffWithinAt) hU hz hd
have hxs : ContDiffOn β β (fun t => (z t).1) U := hzs.fst
have hvs : ContDiffOn β β (fun t => (z t).2) U := hzs.snd
have hΞ³ : ContMDiffOn π(β,β) I3 β (fun t => c.symm (z t).1) U := by
intro t ht
exact ((contMDiffAt_symm_of_mem_maximalAtlas (subset_maximalAtlas hc) (hz t ht)).comp t
(contMDiffAt_iff_contDiffAt.mpr (hxs.contDiffAt (hU.mem_nhds ht)))).contMDiffWithinAt
refine β¨hΞ³,?_β©
intro d hdc t ht hdt
have hdx : β r β U, HasDerivAt (fun s => (z s).1) (z r).2 r := fun r hr => (hd r hr).fst
have hdv : β r β U, HasDerivAt (fun s => (z s).2)
(-connectionTerm g c (z r).1 (z r).2 (z r).2) r := fun r hr => (hd r hr).snd
have heq : (fun r => deriv (fun s => (z s).1) r) =αΆ [π t] fun r => (z r).2 := by
filter_upwards [hU.mem_nhds ht] with r hr
exact (hdx r hr).deriv
have hacc : alongDerivative g c (fun s => (z s).1) (fun s => (z s).2) t = 0 := by
rw [alongDerivative,(hdx t ht).deriv,(hdv t ht).deriv,neg_add_cancel]
have hchange := along_change g hc hdc (hdx t ht).differentiableAt
(hdv t ht).differentiableAt (hz t ht) hdt
dsimp only at hchange
rw [hacc,map_zero] at hchange
have hdtrans : (fun r => fderiv β (d β c.symm) ((z r).1) ((z r).2)) =αΆ [π t]
deriv ((d β c.symm) β (fun r => (z r).1)) := by
have hnh := (hΞ³.continuousOn.continuousAt (hU.mem_nhds ht)).preimage_mem_nhds
(d.open_source.mem_nhds hdt)
filter_upwards [hU.mem_nhds ht,hnh] with r hr hdr
exact ((transition_smoothAt hc hdc (hz r hr) hdr).differentiableAt (by simp)).hasFDerivAt
|>.comp_hasDerivAt r (hdx r hr) |>.deriv |>.symm
rw [along_congr g d Filter.EventuallyEq.rfl hdtrans] at hchange
exact hchange
theorem exists_geodesic_local_flow (g : SmoothMetric M) {c : OpenPartialHomeomorph M E3}
(hc : c β atlas E3 M) {z : E3 Γ E3} (hz : z.1 β c.target) :
β r > (0 : β), β Ξ΅ > (0 : β), β X : (E3 Γ E3) β β β E3 Γ E3,
(β y β Metric.ball z r, X y 0 = y) β§
(β y β Metric.ball z r, IsGeodesicOn g (fun t => c.symm (X y t).1) (Ioo (-Ξ΅) Ξ΅)) β§
(β y β Metric.ball z r, β t β Ioo (-Ξ΅) Ξ΅,
HasDerivAt (X y) (geodesicPhase g c (X y t)) t) β§
(β y β Metric.ball z r, β t β Ioo (-Ξ΅) Ξ΅, (X y t).1 β c.target) β§
ContDiffOn β 1 (Function.uncurry X) (Metric.ball z r ΓΛ’ Ioo (-Ξ΅) Ξ΅) := by
obtain β¨r,hr,Ξ΅,hΞ΅,X,h0,hd,hsβ© :=
ODEVariation.exists_contDiff_flow (contDiffAt_infty.mp (geodesicPhase_smoothAt g hc hz) 2)
have hO : IsOpen (Metric.ball z r ΓΛ’ Ioo (-Ξ΅) Ξ΅) := Metric.isOpen_ball.prod isOpen_Ioo
have hp : (z,(0:β)) β Metric.ball z r ΓΛ’ Ioo (-Ξ΅) Ξ΅ := β¨Metric.mem_ball_self hr,by constructor <;> linarithβ©
have hx : ContinuousAt (Function.uncurry X) (z,0) := hs.continuousOn.continuousAt (hO.mem_nhds hp)
have hmem : {p : (E3 Γ E3) Γ β | (X p.1 p.2).1 β c.target} β π (z,0) := by
apply hx.fst.preimage_mem_nhds
simpa only [Function.uncurry_apply_pair,h0 z (Metric.mem_ball_self hr)] using c.open_target.mem_nhds hz
obtain β¨Ξ·,hΞ·,hsmallβ© := Metric.mem_nhds_iff.mp (inter_mem hmem (hO.mem_nhds hp))
have hsub : β y β Metric.ball z (Ξ·/2), β t β Ioo (-(Ξ·/2)) (Ξ·/2),
(X y t).1 β c.target β§ (y,t) β Metric.ball z r ΓΛ’ Ioo (-Ξ΅) Ξ΅ := by
intro y hy t ht
apply hsmall (a := (y,t))
rw [Metric.mem_ball,Prod.dist_eq,max_lt_iff]
exact β¨lt_trans hy (half_lt_self hΞ·),by rw [Real.dist_eq,sub_zero,abs_lt]; constructor <;> linarith [ht.1,ht.2]β©
refine β¨Ξ·/2,half_pos hΞ·,Ξ·/2,half_pos hΞ·,X,?_,?_,?_,?_,?_β©
Β· intro y hy
exact h0 y (hsub y hy 0 β¨by linarith,by linarithβ©).2.1
Β· intro y hy
exact chart_geodesic g hc isOpen_Ioo (fun t ht => (hsub y hy t ht).1)
(fun t ht => hd y (hsub y hy t ht).2.1 t (hsub y hy t ht).2.2)
Β· intro y hy t ht
exact hd y (hsub y hy t ht).2.1 t (hsub y hy t ht).2.2
Β· exact fun y hy t ht => (hsub y hy t ht).1
Β· exact hs.mono (fun p hp => (hsub p.1 hp.1 p.2 hp.2).2)
end ThreeManifold.RiemannianCoordinates
end
section
open Set Filter Topology Bundle
namespace ThreeManifold
theorem fiberBundle_t2 {B F : Type*} {E : B β Type*}
[TopologicalSpace B] [T2Space B] [TopologicalSpace F] [T2Space F]
[TopologicalSpace (TotalSpace F E)] [β x, TopologicalSpace (E x)] [FiberBundle F E] :
T2Space (TotalSpace F E) := by
classical
rw [t2Space_iff_disjoint_nhds]
intro p q hpq
by_cases hb : p.1 = q.1
Β· let e := trivializationAt F E p.1
have hp : p β e.source := e.mem_source.mpr (FiberBundle.mem_baseSet_trivializationAt' p.1)
have hq : q β e.source := e.mem_source.mpr (hb βΈ FiberBundle.mem_baseSet_trivializationAt' p.1)
have he : e p β e q := fun h => hpq (e.toOpenPartialHomeomorph.injOn hp hq h)
exact Filter.disjoint_of_map ((disjoint_nhds_nhds.mpr he).mono
(e.toOpenPartialHomeomorph.continuousAt hp) (e.toOpenPartialHomeomorph.continuousAt hq))
Β· exact Filter.disjoint_of_map ((disjoint_nhds_nhds.mpr hb).mono
(FiberBundle.continuous_proj F E).continuousAt (FiberBundle.continuous_proj F E).continuousAt)
end ThreeManifold
end
section
open Set Filter Topology Bundle Manifold IsManifold
open scoped ContDiff
namespace ThreeManifold.RiemannianCoordinates
variable {M : Type} [TopologicalSpace M] [ChartedSpace E3 M] [IsManifold I3 β M]
def phaseLift (Ξ³ : β β M) (t : β) : TangentBundle I3 M := β¨Ξ³ t,velocity Ξ³ tβ©
def chartPhase (c : OpenPartialHomeomorph M E3) (Ξ³ : β β M) (t : β) : E3 Γ E3 :=
(c (Ξ³ t),deriv (c β Ξ³) t)
lemma phaseLift_chart {Ξ³ : β β M} {t : β} (hΞ³ : ContMDiffAt π(β,β) I3 β Ξ³ t)
{p : TangentBundle I3 M} (hp : Ξ³ t β (chartAt E3 p.1).source) :
chartAt (ModelProd E3 E3) p (phaseLift Ξ³ t) = chartPhase (chartAt E3 p.1) Ξ³ t := by
apply Prod.ext
Β· rfl
Β· have he := congrArg (fun q : TangentBundle I3 E3 => q.2)
(tangentMap_chart (I := I3) (p := p) (q := phaseLift Ξ³ t) hp)
exact he.symm.trans (velocity_coordinates hΞ³ (chart_mem_atlas E3 p.1) hp)
lemma phaseLift_continuousAt {Ξ³ : β β M} {t : β} {U : Set β}
(hU : IsOpen U) (hΞ³U : ContMDiffOn π(β,β) I3 β Ξ³ U) (htU : t β U) :
ContinuousAt (phaseLift Ξ³) t := by
have hΞ³ := hΞ³U.contMDiffAt (hU.mem_nhds htU)
let p := phaseLift Ξ³ t
let c := chartAt E3 (Ξ³ t)
have ht : Ξ³ t β c.source := mem_chart_source E3 (Ξ³ t)
have hn : Ξ³ β»ΒΉ' c.source β π t := hΞ³.continuousAt.preimage_mem_nhds (c.open_source.mem_nhds ht)
apply ((chartAt (ModelProd E3 E3) p).continuousAt_iff_continuousAt_comp_left
(show (phaseLift Ξ³) β»ΒΉ' (chartAt (ModelProd E3 E3) p).source β π t by
filter_upwards [hn] with r hr
exact (TangentBundle.mem_chart_source_iff _ _).mpr hr)).mpr
have hcΞ³ : ContDiffAt β β (c β Ξ³) t := contMDiffAt_iff_contDiffAt.mp
((contMDiffAt_of_mem_maximalAtlas (subset_maximalAtlas (chart_mem_atlas E3 (Ξ³ t))) ht).comp t hΞ³)
have hs : βαΆ r in π t, ContMDiffAt π(β,β) I3 β Ξ³ r := by
filter_upwards [hU.mem_nhds htU] with r hr
exact hΞ³U.contMDiffAt (hU.mem_nhds hr)
apply (hcΞ³.continuousAt.prodMk (hcΞ³.derivWithin (m := β) (by simp)).continuousAt).congr_of_eventuallyEq
filter_upwards [hn,hs] with r hr hrs
exact phaseLift_chart hrs hr
lemma chartPhase_contDiffAt {Ξ³ : β β M} {t : β}
(hΞ³ : ContMDiffAt π(β,β) I3 β Ξ³ t) {c : OpenPartialHomeomorph M E3}
(hc : c β atlas E3 M) (ht : Ξ³ t β c.source) : ContDiffAt β β (chartPhase c Ξ³) t := by
have h : ContDiffAt β β (c β Ξ³) t := contMDiffAt_iff_contDiffAt.mp
((contMDiffAt_of_mem_maximalAtlas (subset_maximalAtlas hc) ht).comp t hΞ³)
exact h.prodMk (h.derivWithin (m := β) (by simp))
lemma geodesic_chartPhase_ode (g : SmoothMetric M) {Ξ³ : β β M} {U : Set β}
(hU : IsOpen U) (hΞ³ : IsGeodesicOn g Ξ³ U) {t : β} (ht : t β U)
{c : OpenPartialHomeomorph M E3} (hc : c β atlas E3 M) (hct : Ξ³ t β c.source) :
HasDerivAt (chartPhase c Ξ³) (geodesicPhase g c (chartPhase c Ξ³ t)) t := by
have hs := chartPhase_contDiffAt (hΞ³.1.contMDiffAt (hU.mem_nhds ht)) hc hct
have hd := hs.snd.differentiableAt (by simp) |>.hasDerivAt
have he := hΞ³.2 c hc t ht hct
change deriv (deriv (c β Ξ³)) t + connectionTerm g c (c (Ξ³ t)) (deriv (c β Ξ³) t)
(deriv (c β Ξ³) t) = 0 at he
have he' : deriv (deriv (c β Ξ³)) t =
-connectionTerm g c (c (Ξ³ t)) (deriv (c β Ξ³) t) (deriv (c β Ξ³) t) := eq_neg_of_add_eq_zero_left he
exact (hs.fst.differentiableAt (by simp)).hasDerivAt.prodMk (hd.congr_deriv he')
lemma geodesic_eventuallyEq (g : SmoothMetric M) {Ξ³ Ξ· : β β M} {U : Set β}
(hU : IsOpen U) (hΞ³ : IsGeodesicOn g Ξ³ U) (hΞ· : IsGeodesicOn g Ξ· U)
{t : β} (ht : t β U) (he : phaseLift Ξ³ t = phaseLift Ξ· t) : Ξ³ =αΆ [π t] Ξ· := by
let c := chartAt E3 (Ξ³ t)
have hc := chart_mem_atlas E3 (Ξ³ t)
have hct : Ξ³ t β c.source := mem_chart_source E3 (Ξ³ t)
have hbase : Ξ³ t = Ξ· t := congrArg Bundle.TotalSpace.proj he
have hΞ·t : Ξ· t β c.source := hbase βΈ hct
have hΞ³s := hΞ³.1.contMDiffAt (hU.mem_nhds ht)
have hΞ·s := hΞ·.1.contMDiffAt (hU.mem_nhds ht)
have hinitial : chartPhase c Ξ³ t = chartPhase c Ξ· t := by
have h1 := phaseLift_chart (p := phaseLift Ξ³ t) hΞ³s hct
have h2 := phaseLift_chart (p := phaseLift Ξ³ t) hΞ·s hΞ·t
change _ = chartPhase c Ξ³ t at h1
change _ = chartPhase c Ξ· t at h2
rw [β h1, β h2, he]
obtain β¨K,S,hS,hLβ© :=
(geodesicPhase_smoothAt g (z := chartPhase c Ξ³ t) hc (c.map_source hct)).of_le (show (1:ββΟ) β€ β by simp)
|>.exists_lipschitzOnWith
have hΞ³n : βαΆ r in π t, r β U β§ Ξ³ r β c.source β§ chartPhase c Ξ³ r β S :=
Filter.Eventually.and (hU.mem_nhds ht) (Filter.Eventually.and
(hΞ³s.continuousAt.preimage_mem_nhds (c.open_source.mem_nhds hct))
((chartPhase_contDiffAt hΞ³s hc hct).continuousAt.preimage_mem_nhds hS))
have hΞ·n : βαΆ r in π t, r β U β§ Ξ· r β c.source β§ chartPhase c Ξ· r β S :=
Filter.Eventually.and (hU.mem_nhds ht) (Filter.Eventually.and
(hΞ·s.continuousAt.preimage_mem_nhds (c.open_source.mem_nhds hΞ·t))
((chartPhase_contDiffAt hΞ·s hc hΞ·t).continuousAt.preimage_mem_nhds (hinitial βΈ hS)))
have hode := ODE_solution_unique_of_eventually (v := fun _ => geodesicPhase g c)
(s := fun _ => S) (Filter.Eventually.of_forall (fun _ => hL))
(hΞ³n.mono (fun r hr => β¨geodesic_chartPhase_ode g hU hΞ³ hr.1 hc hr.2.1,hr.2.2β©))
(hΞ·n.mono (fun r hr => β¨geodesic_chartPhase_ode g hU hΞ· hr.1 hc hr.2.1,hr.2.2β©)) hinitial
filter_upwards [hode,hΞ³n,hΞ·n] with r hr hgr her
exact c.injOn hgr.2.1 her.2.1 (congrArg Prod.fst hr)
lemma phaseLift_eventuallyEq {Ξ³ Ξ· : β β M} {t : β} (he : Ξ³ =αΆ [π t] Ξ·) :
phaseLift Ξ³ =αΆ [π t] phaseLift Ξ· := by
let _ : IsManifold I3 β M := inferInstance
filter_upwards [he.eventually_nhds] with r hr
change Ξ³ =αΆ [π r] Ξ· at hr
have hb := hr.eq_of_nhds
have hd := congrArg (fun L : β βL[β] E3 => L 1) (hr.mfderiv_eq (I := π(β,β)) (I' := I3))
unfold phaseLift velocity
exact Bundle.TotalSpace.ext hb (heq_of_eq hd)
theorem geodesic_unique [T2Space M] (g : SmoothMetric M) {Ξ³ Ξ· : β β M} {U : Set β}
(hU : IsOpen U) (hUc : OrdConnected U) (hΞ³ : IsGeodesicOn g Ξ³ U) (hΞ· : IsGeodesicOn g Ξ· U)
{t : β} (ht : t β U) (he : phaseLift Ξ³ t = phaseLift Ξ· t) : EqOn Ξ³ Ξ· U := by
let : T2Space (TangentBundle I3 M) := fiberBundle_t2
let Z : Set U := {s | phaseLift Ξ³ s = phaseLift Ξ· s}
let : PreconnectedSpace U := Subtype.preconnectedSpace hUc.isPreconnected
have hZ : IsClopen Z := by
constructor
Β· apply isClosed_eq
Β· exact continuous_iff_continuousAt.mpr (fun s =>
(phaseLift_continuousAt hU hΞ³.1 s.property).comp continuous_subtype_val.continuousAt)
Β· exact continuous_iff_continuousAt.mpr (fun s =>
(phaseLift_continuousAt hU hΞ·.1 s.property).comp continuous_subtype_val.continuousAt)
Β· apply isOpen_iff_mem_nhds.mpr
intro s hs
exact continuous_subtype_val.continuousAt.preimage_mem_nhds
(phaseLift_eventuallyEq (geodesic_eventuallyEq g hU hΞ³ hΞ· s.property hs))
have hZu := hZ.eq_univ β¨β¨t,htβ©,heβ©
intro s hs
have hsz : (β¨s,hsβ© : U) β Z := by rw [hZu]; trivial
exact congrArg Bundle.TotalSpace.proj hsz
end ThreeManifold.RiemannianCoordinates
end
section
open Set Filter Topology Bundle
namespace ThreeManifold.CompactEnergy
variable {B : Type*} [TopologicalSpace B] [CompactSpace B] [T2Space B]
variable {F : Type*} [NormedAddCommGroup F] [NormedSpace β F] [ProperSpace F]
variable {E : B β Type*} [TopologicalSpace (TotalSpace F E)]
[β x, NormedAddCommGroup (E x)] [β x, InnerProductSpace β (E x)]
[FiberBundle F E] [VectorBundle β F E] [IsContinuousRiemannianBundle F E]
lemma continuous_fiberNorm : Continuous (fun p : TotalSpace F E => βp.2β) := by
let _ : CompactSpace B := inferInstance
let _ : T2Space B := inferInstance
let _ : ProperSpace F := inferInstance
have h : Continuous (fun p : TotalSpace F E => inner β p.2 p.2) :=
Continuous.inner_bundle continuous_id continuous_id
convert h.sqrt using 1
ext p
simp
theorem isCompact_fiberDisk (R : β) :
IsCompact {p : TotalSpace F E | βp.2β β€ R} := by
classical
have hlocal : β x : B, β C > (0:β), β K : Set B,
K β π x β§ IsCompact K β§ K β (trivializationAt F E x).baseSet β§
β y β K, β(trivializationAt F E x).continuousLinearMapAt β yβ β€ C := by
intro x
obtain β¨C,hC,hbβ© := eventually_norm_trivializationAt_lt F E x
obtain β¨K,hK,hsub,hcompβ© := local_compact_nhds
(inter_mem hb ((trivializationAt F E x).open_baseSet.mem_nhds
(FiberBundle.mem_baseSet_trivializationAt' x)))
exact β¨C,hC,K,hK,hcomp,fun y hy => (hsub hy).2,fun y hy => (hsub hy).1.leβ©
choose C hC K hKn hKc hKb hbound using hlocal
obtain β¨T,_,hcoverβ© := isCompact_univ.elim_nhds_subcover K (fun x _ => hKn x)
let L : B β Set (TotalSpace F E) := fun x =>
(trivializationAt F E x).toOpenPartialHomeomorph.symm ''
(K x ΓΛ’ Metric.closedBall (0:F) (C x * max R 0))
have hLc : β x, IsCompact (L x) := by
intro x
apply ((hKc x).prod (isCompact_closedBall _ _)).image_of_continuousOn
exact (trivializationAt F E x).toOpenPartialHomeomorph.continuousOn_symm.mono
(fun z hz => (trivializationAt F E x).mem_target.mpr (hKb x hz.1))
apply (T.isCompact_biUnion (fun x _ => hLc x)).of_isClosed_subset
(isClosed_le continuous_fiberNorm continuous_const)
intro p hp
obtain β¨x,hx,hpxβ© := mem_iUnionβ.mp (hcover (mem_univ p.1))
apply mem_iUnionβ.mpr
refine β¨x,hx,?_β©
let e := trivializationAt F E x
have hps : p β e.source := e.mem_source.mpr (hKb x hpx)
refine β¨e p,β¨?_,?_β©,e.symm_apply_apply hpsβ©
Β· simpa only [e.coe_fst hps] using hpx
Β· rw [Metric.mem_closedBall,dist_zero_right]
have he : (e p).2 = e.continuousLinearMapAt β p.1 p.2 := by
exact (e.continuousLinearMapAt_apply_of_mem β (hKb x hpx) p.2).symm
rw [he]
calc
βe.continuousLinearMapAt β p.1 p.2β β€ βe.continuousLinearMapAt β p.1β * βp.2β :=
ContinuousLinearMap.le_opNorm _ _
_ β€ C x * max R 0 := mul_le_mul (hbound x p.1 hpx) (hp.trans (le_max_left _ _))
(norm_nonneg _) (hC x).le
end ThreeManifold.CompactEnergy
end
section
open Set Filter Topology Bundle Manifold
open scoped ContDiff
namespace ThreeManifold.RiemannianCoordinates
variable {M : Type} [TopologicalSpace M] [ChartedSpace E3 M] [IsManifold I3 β M]
[CompactSpace M] [T2Space M]
def phaseEnergy (g : SmoothMetric M) (p : TangentBundle I3 M) : β := g.inner p.1 p.2 p.2
lemma continuous_phaseEnergy (g : SmoothMetric M) : Continuous (phaseEnergy g) := by
let _ : CompactSpace M := inferInstance
let _ : T2Space M := inferInstance
let : RiemannianBundle (fun x : M => TangentSpace I3 x) := β¨g.toRiemannianMetricβ©
let : IsContinuousRiemannianBundle E3 (fun x : M => TangentSpace I3 x) :=
β¨g.inner, g.contMDiff.continuous, fun _ _ _ => rflβ©
have h : Continuous (fun p : TangentBundle I3 M => inner β p.2 p.2) :=
Continuous.inner_bundle continuous_id continuous_id
exact h
theorem isCompact_phaseEnergy (g : SmoothMetric M) (R : β) :
IsCompact {p : TangentBundle I3 M | phaseEnergy g p β€ R} := by
let : RiemannianBundle (fun x : M => TangentSpace I3 x) := β¨g.toRiemannianMetricβ©
let : IsContinuousRiemannianBundle E3 (fun x : M => TangentSpace I3 x) :=
β¨g.inner, g.contMDiff.continuous, fun _ _ _ => rflβ©
apply (CompactEnergy.isCompact_fiberDisk (F := E3) (E := fun x : M => TangentSpace I3 x)
(Real.sqrt (max R 0))).of_isClosed_subset (isClosed_le (continuous_phaseEnergy g) continuous_const)
intro p hp
change βp.2β β€ Real.sqrt (max R 0)
rw [norm_eq_sqrt_real_inner]
apply Real.sqrt_le_sqrt
exact hp.trans (le_max_left _ _)
end ThreeManifold.RiemannianCoordinates
end
section
open Set Filter Topology
namespace ThreeManifold.FlowContinuation
structure Equation (X : Type*) where
Holds : (β β X) β β β Prop
germ {z w : β β X} {t : β} : z =αΆ [π t] w β Holds z t β Holds w t
shift (z : β β X) (a t : β) : Holds (fun r => z (r+a)) t β Holds z (t+a)
unique {z w : β β X} {a b t : β} :
(β r β Ioo a b, Holds z r) β (β r β Ioo a b, Holds w r) β
t β Ioo a b β z t = w t β EqOn z w (Ioo a b)
namespace Equation
variable {X : Type*} (P : Equation X)
def CurveOn (z : β β X) (U : Set β) : Prop := β t β U, P.Holds z t
lemma CurveOn.mono {z : β β X} {U V : Set β} (h : P.CurveOn z U) (hVU : V β U) :
P.CurveOn z V := fun t ht => h t (hVU ht)
lemma CurveOn.congr {z w : β β X} {U : Set β} (hU : IsOpen U)
(h : P.CurveOn z U) (he : EqOn z w U) : P.CurveOn w U := by
intro t ht
exact P.germ (Filter.eventually_of_mem (hU.mem_nhds ht) (fun r hr => he hr)) (h t ht)
lemma CurveOn.comp_add {z : β β X} {U : Set β} (h : P.CurveOn z U) (a : β) :
P.CurveOn (fun r => z (r+a)) ((fun r => r+a) β»ΒΉ' U) := by
intro t ht
exact (P.shift z a t).mpr (h (t+a) ht)
lemma eqOn_piecewise {z w : β β X} {a b c d t : β}
(hz : P.CurveOn z (Ioo a b)) (hw : P.CurveOn w (Ioo c d))
(ht : t β Ioo a b β© Ioo c d) (he : z t = w t) :
EqOn (piecewise (Ioo a b) z w) w (Ioo c d) := by
classical
have H : EqOn z w (Ioo (max a c) (min b d)) :=
P.unique (hz.mono P (Ioo_subset_Ioo (le_max_left ..) (min_le_left ..)))
(hw.mono P (Ioo_subset_Ioo (le_max_right ..) (min_le_right ..)))
β¨max_lt ht.1.1 ht.2.1,lt_min ht.1.2 ht.2.2β© he
intro r hr
by_cases hrz : r β Ioo a b
Β· rw [piecewise,ite_eq_left hrz]
exact H β¨max_lt hrz.1 hr.1,lt_min hrz.2 hr.2β©
Β· rw [piecewise,ite_eq_right hrz]
lemma curveOn_piecewise {z w : β β X} {a b c d t : β}
(hz : P.CurveOn z (Ioo a b)) (hw : P.CurveOn w (Ioo c d))
(ht : t β Ioo a b β© Ioo c d) (he : z t = w t) :
P.CurveOn (piecewise (Ioo a b) z w) (Ioo a b βͺ Ioo c d) := by
classical
intro r hr
by_cases hrz : r β Ioo a b
Β· exact P.germ (Filter.eventually_of_mem (isOpen_Ioo.mem_nhds hrz)
(fun s hs => (piecewise_eq_of_mem (Ioo a b) z w hs).symm)) (hz r hrz)
Β· have hrw := hr.resolve_left hrz
exact P.germ (Filter.eventually_of_mem (isOpen_Ioo.mem_nhds hrw)
(fun s hs => (P.eqOn_piecewise hz hw ht he hs).symm)) (hw r hrw)
lemma global_of_arbitrarily_long {x : X}
(h : β a : β, β z, z 0 = x β§ P.CurveOn z (Ioo (-a) a)) :
β z, z 0 = x β§ β t, P.Holds z t := by
choose z h0 hz using h
have he {a b : β} (ha : 0 < a) (hab : a β€ b) : EqOn (z a) (z b) (Ioo (-a) a) :=
P.unique (hz a) ((hz b).mono P (Ioo_subset_Ioo (neg_le_neg hab) hab))
β¨neg_lt_zero.mpr ha,haβ© ((h0 a).trans (h0 b).symm)
let w : β β X := fun t => z (|t|+1) t
have hw {a : β} : EqOn w (z a) (Ioo (-a) a) := by
intro t ht
by_cases hta : |t|+1 β€ a
Β· exact he (by positivity) hta (abs_lt.mp (lt_add_one _))
Β· exact (he (by linarith [ht.1,ht.2]) (le_of_not_ge hta) ht).symm
refine β¨w,h0 (|0|+1),fun t => ?_β©
have ht : t β Ioo (-(|t|+1)) (|t|+1) := abs_lt.mp (lt_add_one _)
exact P.germ (Filter.eventually_of_mem (isOpen_Ioo.mem_nhds ht) (fun r hr => (hw hr).symm))
(hz (|t|+1) t ht)
theorem exists_global_of_uniform_invariant {K : Set X} {Ξ΅ : β} (hΞ΅ : 0 < Ξ΅)
(hloc : β x β K, β z : β β X, z 0 = x β§ P.CurveOn z (Ioo (-Ξ΅) Ξ΅))
(hinv : β (z : β β X) (a : β), 0 < a β z 0 β K β
P.CurveOn z (Ioo (-a) a) β MapsTo z (Ioo (-a) a) K)
{x : X} (hx : x β K) : β z, z 0 = x β§ β t, P.Holds z t := by
classical
let S := {a : β | β z, z 0 = x β§ P.CurveOn z (Ioo (-a) a)}
have hΞ΅S : Ξ΅ β S := hloc x hx
apply P.global_of_arbitrarily_long
suffices hnb : Β¬ BddAbove S by
intro a
obtain β¨b,hb,habβ© := not_bddAbove_iff.mp hnb a
obtain β¨z,hz0,hzβ© := hb
exact β¨z,hz0,hz.mono P (Ioo_subset_Ioo (neg_le_neg hab.le) hab.le)β©
intro hbdd
let A := sSup S
have hΞ΅A : Ξ΅ β€ A := le_csSup hbdd hΞ΅S
obtain β¨a,β¨z,hz0,hzβ©,haβ© := Real.add_neg_lt_sSup (β¨Ξ΅,hΞ΅Sβ© : S.Nonempty)
(Ξ΅ := -(Ξ΅/2)) (by linarith)
change A + -(Ξ΅/2) < a at ha
have ha0 : 0 < a := by linarith
have hleft : -(A-Ξ΅/2) β Ioo (-a) a := β¨by linarith,by linarithβ©
have hright : A-Ξ΅/2 β Ioo (-a) a := β¨by linarith,by linarithβ©
have hzK := hinv z a ha0 (hz0 βΈ hx) hz
obtain β¨z1,h10,h1β© := hloc (z (-(A-Ξ΅/2))) (hzK hleft)
obtain β¨z2,h20,h2β© := hloc (z (A-Ξ΅/2)) (hzK hright)
let w1 : β β X := fun t => z1 (t+(A-Ξ΅/2))
let w2 : β β X := fun t => z2 (t-(A-Ξ΅/2))
have hw1 : P.CurveOn w1 (Ioo (-(A+Ξ΅/2)) (-(A-3*Ξ΅/2))) := by
apply (h1.comp_add P (A-Ξ΅/2)).mono P
intro t ht; change -Ξ΅ < t+(A-Ξ΅/2) β§ t+(A-Ξ΅/2) < Ξ΅
constructor <;> linarith [ht.1,ht.2]
have hw2 : P.CurveOn w2 (Ioo (A-3*Ξ΅/2) (A+Ξ΅/2)) := by
apply (h2.comp_add P (-(A-Ξ΅/2))).mono P
intro t ht; change -Ξ΅ < t+ -(A-Ξ΅/2) β§ t+ -(A-Ξ΅/2) < Ξ΅
constructor <;> linarith [ht.1,ht.2]
have he1 : z (-(A-Ξ΅/2)) = w1 (-(A-Ξ΅/2)) := by simp [w1,h10]
have he2 : z (A-Ξ΅/2) = w2 (A-Ξ΅/2) := by simp [w2,h20]
let w : β β X := piecewise (Ioo (-(A+Ξ΅/2)) a) (piecewise (Ioo (-a) a) z w1) w2
have hw0 : w 0 = x := by
simp only [w,piecewise,ite_eq_left (show 0 β Ioo (-(A+Ξ΅/2)) a from β¨by linarith,ha0β©),
ite_eq_left (show 0 β Ioo (-a) a from β¨by linarith,ha0β©),hz0]
have hw : P.CurveOn w (Ioo (-(A+Ξ΅/2)) (A+Ξ΅/2)) := by
apply (P.curveOn_piecewise (t := A-Ξ΅/2) ?_ hw2
β¨β¨by linarith,by linarithβ©,β¨by linarith,by linarithβ©β©
(by rw [piecewise,ite_eq_left hright]; exact he2)).mono P
(Ioo_subset_Ioo_union_Ioo le_rfl (by linarith) (by linarith))
exact (P.curveOn_piecewise hz hw1
β¨hleft,β¨by linarith,by linarithβ©β© he1).mono P
(union_comm _ _ βΈ Ioo_subset_Ioo_union_Ioo (by linarith) (by linarith) le_rfl)
exact (not_lt.mpr (le_csSup hbdd (show A+Ξ΅/2 β S from β¨w,hw0,hwβ©)))
(lt_add_of_pos_right A (half_pos hΞ΅))
theorem exists_global_of_compact_invariant [TopologicalSpace X] {K : Set X} (hK : IsCompact K)
(hloc : β x β K, β U β π x, β Ξ΅ > (0:β), β y β U,
β z, z 0 = y β§ P.CurveOn z (Ioo (-Ξ΅) Ξ΅))
(hinv : β (z : β β X) (a : β), 0 < a β z 0 β K β
P.CurveOn z (Ioo (-a) a) β MapsTo z (Ioo (-a) a) K)
{x : X} (hx : x β K) : β z, z 0 = x β§ β t, P.Holds z t := by
classical
choose U hUn Ξ΅ hΞ΅ hsol using hloc
obtain β¨T,hcoverβ© := hK.elim_nhds_subcover' U hUn
have hT : T.Nonempty := by
obtain β¨i,hi,_β© := mem_iUnionβ.mp (hcover hx)
exact β¨i,hiβ©
let e := T.inf' hT (fun i => Ξ΅ i i.property)
have he : 0 < e := (Finset.lt_inf'_iff hT).mpr (fun i _ => hΞ΅ i i.property)
apply P.exists_global_of_uniform_invariant he ?_ hinv hx
intro y hy
obtain β¨i,hi,hyiβ© := mem_iUnionβ.mp (hcover hy)
obtain β¨z,hz0,hzβ© := hsol i i.property y hyi
have hei : e β€ Ξ΅ i i.property := Finset.inf'_le _ hi
exact β¨z,hz0,hz.mono P (Ioo_subset_Ioo (neg_le_neg hei) hei)β©
end Equation
end ThreeManifold.FlowContinuation
end
section
open Set Filter Topology Bundle Manifold IsManifold
open scoped ContDiff
namespace ThreeManifold.RiemannianCoordinates
variable {M : Type} [TopologicalSpace M] [ChartedSpace E3 M] [IsManifold I3 β M]
lemma deriv_comp_translate {E : Type*} [NormedAddCommGroup E] [NormedSpace β E]
{f : β β E} {a t : β} (hf : DifferentiableAt β f (t+a)) :
deriv (fun r => f (r+a)) t = deriv f (t+a) := by
exact (hf.hasFDerivAt.comp_hasDerivAt t ((hasDerivAt_id t).add_const a)).deriv
lemma geodesic_translate (g : SmoothMetric M) {Ξ³ : β β M} {U : Set β}
(hU : IsOpen U) (hΞ³ : IsGeodesicOn g Ξ³ U) (a : β) :
IsGeodesicOn g (fun r => Ξ³ (r+a)) ((fun r => r+a) β»ΒΉ' U) := by
have htA : ContMDiff π(β,β) π(β,β) β (fun r : β => r+a) :=
contMDiff_iff_contDiff.mpr (contDiff_id.add contDiff_const)
refine β¨hΞ³.1.comp htA.contMDiffOn (fun _ h => h),?_β©
intro c hc t ht hct
have hs := chartPhase_contDiffAt (hΞ³.1.contMDiffAt (hU.mem_nhds ht)) hc hct
have hn : βαΆ r in π t, r+a β U β§ Ξ³ (r+a) β c.source :=
continuousAt_id.add continuousAt_const |>.preimage_mem_nhds
(Filter.Eventually.and (hU.mem_nhds ht)
((hΞ³.1.contMDiffAt (hU.mem_nhds ht)).continuousAt.preimage_mem_nhds
(c.open_source.mem_nhds hct)))
have hd : deriv (c β (fun r => Ξ³ (r+a))) =αΆ [π t] fun r => deriv (c β Ξ³) (r+a) := by
filter_upwards [hn] with r hr
exact deriv_comp_translate ((chartPhase_contDiffAt
(hΞ³.1.contMDiffAt (hU.mem_nhds hr.1)) hc hr.2).fst.differentiableAt (by simp))
have hdd : deriv (deriv (c β (fun r => Ξ³ (r+a)))) t = deriv (deriv (c β Ξ³)) (t+a) :=
hd.deriv_eq.trans (deriv_comp_translate (hs.snd.differentiableAt (by simp)))
change _ + _ = 0
rw [hdd,hd.eq_of_nhds]
exact hΞ³.2 c hc (t+a) ht hct
lemma phaseLift_translate {Ξ³ : β β M} {a t : β}
(hΞ³ : ContMDiffAt π(β,β) I3 β Ξ³ (t+a)) :
phaseLift (fun r => Ξ³ (r+a)) t = phaseLift Ξ³ (t+a) := by
let p := phaseLift Ξ³ (t+a)
let c := chartAt (ModelProd E3 E3) p
have htrans : ContMDiffAt π(β,β) I3 β (fun r => Ξ³ (r+a)) t := hΞ³.comp t
(contMDiffAt_iff_contDiffAt.mpr (contDiffAt_id.add contDiffAt_const))
have hs : phaseLift (fun r => Ξ³ (r+a)) t β c.source :=
(TangentBundle.mem_chart_source_iff _ _).mpr (mem_chart_source E3 (Ξ³ (t+a)))
apply c.injOn hs (mem_chart_source (ModelProd E3 E3) p)
rw [phaseLift_chart htrans (mem_chart_source E3 (Ξ³ (t+a))),
phaseLift_chart hΞ³ (mem_chart_source E3 (Ξ³ (t+a)))]
apply Prod.ext
Β· rfl
exact deriv_comp_translate ((chartPhase_contDiffAt hΞ³ (chart_mem_atlas E3 (Ξ³ (t+a)))
(mem_chart_source E3 (Ξ³ (t+a)))).fst.differentiableAt (by simp))
def PhaseGeodesicAt (g : SmoothMetric M) (z : β β TangentBundle I3 M) (t : β) : Prop :=
β (Ξ³ : β β M) (U : Set β), IsOpen U β§ t β U β§ IsGeodesicOn g Ξ³ U β§ EqOn z (phaseLift Ξ³) U
lemma phaseGeodesic_germ (g : SmoothMetric M) {z w : β β TangentBundle I3 M} {t : β}
(he : z =αΆ [π t] w) (hz : PhaseGeodesicAt g z t) : PhaseGeodesicAt g w t := by
obtain β¨Ξ³,U,hU,ht,hΞ³,hzβ© := hz
obtain β¨V,hV,hVo,htVβ© := mem_nhds_iff.mp he
exact β¨Ξ³,U β© V,hU.inter hVo,β¨ht,htVβ©,β¨hΞ³.1.mono inter_subset_left,
fun c hc s hs hsc => hΞ³.2 c hc s hs.1 hscβ©,
fun s hs => (hV hs.2).symm.trans (hz hs.1)β©
lemma phaseGeodesic_translate (g : SmoothMetric M) {z : β β TangentBundle I3 M} {a t : β}
(hz : PhaseGeodesicAt g z (t+a)) : PhaseGeodesicAt g (fun r => z (r+a)) t := by
obtain β¨Ξ³,U,hU,ht,hΞ³,hzβ© := hz
refine β¨fun r => Ξ³ (r+a),(fun r => r+a) β»ΒΉ' U,
hU.preimage (continuous_id.add continuous_const),ht,geodesic_translate g hU hΞ³ a,?_β©
intro r hr
exact (hz hr).trans (phaseLift_translate (hΞ³.1.contMDiffAt (hU.mem_nhds hr))).symm
lemma phaseGeodesicOn_base (g : SmoothMetric M) {z : β β TangentBundle I3 M} {U : Set β}
(_hU : IsOpen U) (hz : β t β U, PhaseGeodesicAt g z t) :
IsGeodesicOn g (fun t => (z t).proj) U β§ EqOn z (phaseLift (fun t => (z t).proj)) U := by
have hlocal (t : β) (ht : t β U) : β Ξ³ V, IsOpen V β§ t β V β§ IsGeodesicOn g Ξ³ V β§
(fun r => (z r).proj) =αΆ [π t] Ξ³ β§ z t = phaseLift Ξ³ t := by
obtain β¨Ξ³,V,hV,htV,hΞ³,heβ© := hz t ht
exact β¨Ξ³,V,hV,htV,hΞ³,(Filter.eventually_of_mem (hV.mem_nhds htV)
(fun r hr => congrArg Bundle.TotalSpace.proj (he hr))),he htVβ©
refine β¨β¨?_,?_β©,?_β©
Β· intro t ht
obtain β¨Ξ³,V,hV,htV,hΞ³,he,_β© := hlocal t ht
exact ((hΞ³.1.contMDiffAt (hV.mem_nhds htV)).congr_of_eventuallyEq he).contMDiffWithinAt
Β· intro c hc t ht hct
obtain β¨Ξ³,V,hV,htV,hΞ³,he,_β© := hlocal t ht
have hec := he.fun_comp c
rw [along_congr g c hec hec.deriv]
exact hΞ³.2 c hc t htV (he.eq_of_nhds βΈ hct)
Β· intro t ht
obtain β¨Ξ³,V,hV,htV,hΞ³,he,hetβ© := hlocal t ht
exact het.trans (phaseLift_eventuallyEq he).eq_of_nhds.symm
def geodesicEquation [T2Space M] (g : SmoothMetric M) : FlowContinuation.Equation (TangentBundle I3 M) where
Holds := PhaseGeodesicAt g
germ := phaseGeodesic_germ g
shift z a t := by
constructor
Β· intro h
have hh := phaseGeodesic_translate g (a := -a) (t := t+a) (by simpa using h)
simpa only [add_assoc,neg_add_cancel,add_zero] using hh
Β· exact phaseGeodesic_translate g
unique := by
intro z w a b t hz hw ht he
obtain β¨hΞ³,hzpβ© := phaseGeodesicOn_base g isOpen_Ioo hz
obtain β¨hΞ·,hwpβ© := phaseGeodesicOn_base g isOpen_Ioo hw
have hbase := geodesic_unique g isOpen_Ioo ordConnected_Ioo hΞ³ hΞ· ht
((hzp ht).symm.trans (he.trans (hwp ht)))
intro r hr
have hphase := phaseLift_eventuallyEq
(Filter.eventually_of_mem (isOpen_Ioo.mem_nhds hr) (fun s hs => hbase hs))
exact (hzp hr).trans (hphase.eq_of_nhds.trans (hwp hr).symm)
lemma phaseGeodesic_local_existence (g : SmoothMetric M) (p : TangentBundle I3 M) :
β U β π p, β Ξ΅ > (0:β), β y β U,
β z, z 0 = y β§ β t β Ioo (-Ξ΅) Ξ΅, PhaseGeodesicAt g z t := by
let c := chartAt E3 p.1
let C := chartAt (ModelProd E3 E3) p
have hp : p β C.source := mem_chart_source _ p
have hp' : (C p).1 β c.target := c.map_source (mem_chart_source E3 p.1)
obtain β¨r,hr,Ξ΅,hΞ΅,X,h0,hΞ³,hd,hXt,_β© := exists_geodesic_local_flow g (chart_mem_atlas E3 p.1) hp'
let q : TangentBundle I3 M β E3 Γ E3 := fun y => C y
let U := C.source β© q β»ΒΉ' Metric.ball (q p) r
have hUn : U β π p := inter_mem (C.open_source.mem_nhds hp)
((show ContinuousAt q p from C.continuousAt hp).preimage_mem_nhds (Metric.isOpen_ball.mem_nhds (Metric.mem_ball_self hr)))
refine β¨U,hUn,Ξ΅,hΞ΅,?_β©
intro y hy
let Ξ³ : β β M := fun t => c.symm (X (C y) t).1
have hyb : C y β Metric.ball (q p) r := hy.2
have hzero : (0:β) β Ioo (-Ξ΅) Ξ΅ := β¨by linarith,by linarithβ©
have hΞ³s : IsGeodesicOn g Ξ³ (Ioo (-Ξ΅) Ξ΅) := hΞ³ (C y) hyb
have hm : Ξ³ 0 β c.source := c.map_target (hXt (C y) hyb 0 hzero)
have hchart : chartPhase c Ξ³ 0 = C y := by
have he : c β Ξ³ =αΆ [π (0:β)] fun t => (X (C y) t).1 :=
Filter.eventually_of_mem (isOpen_Ioo.mem_nhds hzero)
(fun t ht => c.right_inv (hXt (C y) hyb t ht))
apply Prod.ext
Β· exact he.eq_of_nhds.trans (congrArg Prod.fst (h0 (C y) hyb))
Β· have hd1 : HasDerivAt (fun t => (X (C y) t).1) (X (C y) 0).2 0 :=
(hd (C y) hyb 0 hzero).fst
exact he.deriv_eq.trans (hd1.deriv.trans (congrArg Prod.snd (h0 (C y) hyb)))
refine β¨phaseLift Ξ³,?_,fun t ht => β¨Ξ³,Ioo (-Ξ΅) Ξ΅,isOpen_Ioo,ht,hΞ³s,fun _ _ => rflβ©β©
apply C.injOn ((TangentBundle.mem_chart_source_iff _ _).mpr hm) hy.1
exact (phaseLift_chart (p := p) (hΞ³s.1.contMDiffAt (isOpen_Ioo.mem_nhds hzero)) hm).trans hchart
lemma phaseEnergy_conserved [CompactSpace M] [T2Space M] (g : SmoothMetric M)
{z : β β TangentBundle I3 M} {U : Set β} (hU : IsOpen U) (hUc : OrdConnected U)
(hz : β t β U, PhaseGeodesicAt g z t) {s t : β} (hs : s β U) (ht : t β U) :
phaseEnergy g (z s) = phaseEnergy g (z t) := by
obtain β¨hΞ³,heβ© := phaseGeodesicOn_base g hU hz
let f : β β β := fun r => g.inner (z r).proj (velocity (fun u => (z u).proj) r)
(velocity (fun u => (z u).proj) r)
have hd : β r β U, HasDerivAt f 0 r := fun r hr => geodesic_speed_hasDerivAt g hU hΞ³ hr
have hc : f s = f t := hU.is_const_of_deriv_eq_zero hUc.isPreconnected
(fun r hr => (hd r hr).differentiableAt.differentiableWithinAt)
(fun r hr => (hd r hr).deriv) hs ht
change _ = _
rw [he hs,he ht]
exact hc
theorem exists_global_geodesic [CompactSpace M] [T2Space M] (g : SmoothMetric M)
(p : TangentBundle I3 M) :
β Ξ³ : β β M, phaseLift Ξ³ 0 = p β§ IsGeodesicOn g Ξ³ univ := by
let K := {q : TangentBundle I3 M | phaseEnergy g q β€ phaseEnergy g p}
have hinv : β (z : β β TangentBundle I3 M) (a : β), 0 < a β z 0 β K β
(geodesicEquation g).CurveOn z (Ioo (-a) a) β MapsTo z (Ioo (-a) a) K := by
intro z a ha hzK hcurve t ht
change phaseEnergy g (z t) β€ phaseEnergy g p
rw [phaseEnergy_conserved g isOpen_Ioo ordConnected_Ioo hcurve ht
(show (0:β) β Ioo (-a) a from β¨by linarith,haβ©)]
exact hzK
obtain β¨z,hz0,hzβ© := (geodesicEquation g).exists_global_of_compact_invariant
(K := K) (isCompact_phaseEnergy g (phaseEnergy g p))
(fun q _ => phaseGeodesic_local_existence g q) hinv
(x := p) (show p β K from (show phaseEnergy g p β€ phaseEnergy g p from le_rfl))
obtain β¨hΞ³,heβ© := phaseGeodesicOn_base g isOpen_univ (fun t _ => hz t)
exact β¨fun t => (z t).proj,(he (mem_univ 0)).symm.trans hz0,hΞ³β©
end ThreeManifold.RiemannianCoordinates
end
section
open Set Filter Topology Manifold
open scoped ContDiff
namespace ThreeManifold.FlowContinuation
variable {E H X : Type*} [NormedAddCommGroup E] [NormedSpace β E]
[TopologicalSpace H] {I : ModelWithCorners β E H}
[TopologicalSpace X] [ChartedSpace H X] [IsManifold I 1 X]
lemma flow_contMDiff (F : X β β β X)
(h0 : β x, F x 0 = x)
(hadd : β x s t, F (F x s) t = F x (s+t))
(hc : β x, Continuous (F x))
(hloc : β x, ContMDiffAt (I.prod π(β,β)) I 1 (Function.uncurry F) (x,0)) :
ContMDiff (I.prod π(β,β)) I 1 (Function.uncurry F) := by
have htime (x : X) (t : β) : ContMDiffAt I I 1 (fun y => F y t) x := by
let Z := {s : β | ContMDiffAt I I 1 (fun y => F y s) x}
have hstep {s t : β} (hs : s β Z)
(hl : ContMDiffAt (I.prod π(β,β)) I 1 (Function.uncurry F) (F x s,t-s)) : t β Z := by
have hh := hl.comp x (hs.prodMk (contMDiffAt_const (c := t-s)))
apply hh.congr_of_eventuallyEq
exact Filter.Eventually.of_forall (fun y => by
change F y t = F (F y s) (t-s)
rw [hadd,add_sub_cancel])
have hZc : IsClosed Z := by
apply isClosed_of_closure_subset
intro t ht
have hh := (contMDiffAt_iff_contMDiffAt_nhds (by simp : (1:ββΟ) β β)).mp (hloc (F x t))
have hd : ContinuousAt (fun s => (F x s,t-s)) t :=
((hc x).continuousAt).prodMk (continuousAt_const.sub continuousAt_id)
have hn : {s : β | ContMDiffAt (I.prod π(β,β)) I 1
(Function.uncurry F) (F x s,t-s)} β π t := by
have hh' : βαΆ q in π (F x t,t-t), ContMDiffAt (I.prod π(β,β)) I 1
(Function.uncurry F) q := by simpa only [sub_self] using hh
exact hd.eventually hh'
obtain β¨s,hs,hstβ© := mem_closure_iff_nhds.mp ht _ hn
exact hstep hst hs
have hZo : IsOpen Z := by
apply isOpen_iff_mem_nhds.mpr
intro s hs
have hh := (contMDiffAt_iff_contMDiffAt_nhds (by simp : (1:ββΟ) β β)).mp (hloc (F x s))
have hd : ContinuousAt (fun t : β => (F x s,t-s)) s :=
continuousAt_const.prodMk (continuousAt_id.sub continuousAt_const)
have hn : {t : β | ContMDiffAt (I.prod π(β,β)) I 1
(Function.uncurry F) (F x s,t-s)} β π s := by
have hh' : βαΆ q in π (F x s,s-s), ContMDiffAt (I.prod π(β,β)) I 1
(Function.uncurry F) q := by simpa only [sub_self] using hh
exact hd.eventually hh'
exact Filter.mem_of_superset hn (fun t ht => hstep hs ht)
have h0Z : (0:β) β Z := contMDiffAt_id.congr_of_eventuallyEq
(Filter.Eventually.of_forall h0)
have he := (show IsClopen Z from β¨hZc,hZoβ©).eq_univ β¨0,h0Zβ©
change t β Z
rw [he]
trivial
intro p
have hfirst : ContMDiffAt (I.prod π(β,β)) I 1 (fun q : X Γ β => F q.1 p.2) p :=
(htime p.1 p.2).comp p contMDiffAt_fst
have hsecond : ContMDiffAt (I.prod π(β,β)) π(β,β) 1
(fun q : X Γ β => q.2-p.2) p := contMDiffAt_snd.sub contMDiffAt_const
have hl : ContMDiffAt (I.prod π(β,β)) I 1 (Function.uncurry F) (F p.1 p.2,p.2-p.2) := by
simpa only [sub_self] using hloc (F p.1 p.2)
apply (hl.comp p (hfirst.prodMk hsecond)).congr_of_eventuallyEq
exact Filter.Eventually.of_forall (fun q => by
change F q.1 q.2 = F (F q.1 p.2) (q.2-p.2)
rw [hadd,add_sub_cancel])
end ThreeManifold.FlowContinuation
end
section
open Set Filter Topology Bundle Manifold IsManifold
open scoped ContDiff
namespace ThreeManifold.RiemannianCoordinates
section
variable {M : Type} [TopologicalSpace M] [ChartedSpace E3 M] [IsManifold I3 β M]
[CompactSpace M] [T2Space M]
def globalGeodesic (g : SmoothMetric M) (p : TangentBundle I3 M) : β β M :=
(exists_global_geodesic g p).choose
lemma globalGeodesic_initial (g : SmoothMetric M) (p : TangentBundle I3 M) :
phaseLift (globalGeodesic g p) 0 = p := (exists_global_geodesic g p).choose_spec.1
lemma globalGeodesic_isGeodesic (g : SmoothMetric M) (p : TangentBundle I3 M) :
IsGeodesicOn g (globalGeodesic g p) univ := (exists_global_geodesic g p).choose_spec.2
def geodesicFlow (g : SmoothMetric M) (p : TangentBundle I3 M) (t : β) : TangentBundle I3 M :=
phaseLift (globalGeodesic g p) t
lemma geodesicFlow_zero (g : SmoothMetric M) (p : TangentBundle I3 M) :
geodesicFlow g p 0 = p := globalGeodesic_initial g p
lemma geodesicFlow_continuous (g : SmoothMetric M) (p : TangentBundle I3 M) :
Continuous (geodesicFlow g p) := continuous_iff_continuousAt.mpr (fun t =>
phaseLift_continuousAt isOpen_univ (globalGeodesic_isGeodesic g p).1 (mem_univ t))
lemma geodesicFlow_add (g : SmoothMetric M) (p : TangentBundle I3 M) (s t : β) :
geodesicFlow g (geodesicFlow g p s) t = geodesicFlow g p (s+t) := by
have hΞ³ := globalGeodesic_isGeodesic g p
have hΞ· := globalGeodesic_isGeodesic g (geodesicFlow g p s)
have htrans : IsGeodesicOn g (fun r => globalGeodesic g p (r+s)) univ := by
simpa using geodesic_translate g isOpen_univ hΞ³ s
have h0 : phaseLift (globalGeodesic g (geodesicFlow g p s)) 0 =
phaseLift (fun r => globalGeodesic g p (r+s)) 0 := by
rw [globalGeodesic_initial,phaseLift_translate (hΞ³.1.contMDiffAt (by simp)),zero_add]
rfl
have he := geodesic_unique g isOpen_univ ordConnected_univ hΞ· htrans (mem_univ 0) h0
have he' := phaseLift_eventuallyEq (t := t) (Filter.Eventually.of_forall (fun r => he (mem_univ r)))
change phaseLift _ t = _
rw [he'.eq_of_nhds,phaseLift_translate (hΞ³.1.contMDiffAt (by simp)),add_comm]
rfl
lemma geodesicFlow_eq_chart (g : SmoothMetric M) (p : TangentBundle I3 M)
{Ξ΅ : β} (hΞ΅ : 0 < Ξ΅) {X : (E3 Γ E3) β β β E3 Γ E3} {y : TangentBundle I3 M}
(hy : y β (chartAt (ModelProd E3 E3) p).source)
(h0 : X (chartAt (ModelProd E3 E3) p y) 0 = chartAt (ModelProd E3 E3) p y)
(hd : β t β Ioo (-Ξ΅) Ξ΅, HasDerivAt (X (chartAt (ModelProd E3 E3) p y))
(geodesicPhase g (chartAt E3 p.1) (X (chartAt (ModelProd E3 E3) p y) t)) t)
(hXt : β t β Ioo (-Ξ΅) Ξ΅, (X (chartAt (ModelProd E3 E3) p y) t).1 β (chartAt E3 p.1).target)
{t : β} (ht : t β Ioo (-Ξ΅) Ξ΅) :
geodesicFlow g y t = (extChartAt I3.tangent p).symm (X (chartAt (ModelProd E3 E3) p y) t) := by
let c := chartAt E3 p.1
let C := chartAt (ModelProd E3 E3) p
let Ξ³ : β β M := fun r => c.symm (X (C y) r).1
have hΞ³ : IsGeodesicOn g Ξ³ (Ioo (-Ξ΅) Ξ΅) := chart_geodesic g (chart_mem_atlas E3 p.1) isOpen_Ioo hXt hd
have hz : (0:β) β Ioo (-Ξ΅) Ξ΅ := β¨by linarith,hΞ΅β©
have hphase : β r β Ioo (-Ξ΅) Ξ΅, C (phaseLift Ξ³ r) = X (C y) r := by
intro r hr
rw [phaseLift_chart (hΞ³.1.contMDiffAt (isOpen_Ioo.mem_nhds hr)) (c.map_target (hXt r hr))]
have he : c β Ξ³ =αΆ [π r] fun t => (X (C y) t).1 :=
Filter.eventually_of_mem (isOpen_Ioo.mem_nhds hr) (fun t ht => c.right_inv (hXt t ht))
apply Prod.ext
Β· exact he.eq_of_nhds
Β· have hh : HasDerivAt (fun t => (X (C y) t).1) (X (C y) r).2 r := (hd r hr).fst
exact he.deriv_eq.trans hh.deriv
have hinit : phaseLift Ξ³ 0 = y := C.injOn
((TangentBundle.mem_chart_source_iff _ _).mpr (c.map_target (hXt 0 hz))) hy ((hphase 0 hz).trans h0)
have he := geodesic_unique g isOpen_Ioo ordConnected_Ioo hΞ³
(show IsGeodesicOn g (globalGeodesic g y) (Ioo (-Ξ΅) Ξ΅) from
β¨(globalGeodesic_isGeodesic g y).1.mono (subset_univ _),
fun c hc t ht hct => (globalGeodesic_isGeodesic g y).2 c hc t (mem_univ t) hctβ©) hz
(hinit.trans (globalGeodesic_initial g y).symm)
have het : phaseLift Ξ³ t = geodesicFlow g y t := (phaseLift_eventuallyEq
(Filter.eventually_of_mem (isOpen_Ioo.mem_nhds ht) (fun r hr => he hr))).eq_of_nhds
rw [β het,β hphase t ht]
exact (C.left_inv ((TangentBundle.mem_chart_source_iff _ _).mpr (c.map_target (hXt t ht)))).symm
lemma geodesicFlow_contMDiffAt_zero (g : SmoothMetric M) (p : TangentBundle I3 M) :
ContMDiffAt (I3.tangent.prod π(β,β)) I3.tangent 1 (Function.uncurry (geodesicFlow g)) (p,0) := by
let c := chartAt E3 p.1
let C := chartAt (ModelProd E3 E3) p
let e := extChartAt I3.tangent p
have hp : p β C.source := mem_chart_source _ p
obtain β¨r,hr,Ξ΅,hΞ΅,X,h0,hΞ³,hd,hXt,hXsβ© := exists_geodesic_local_flow g (z := e p)
(chart_mem_atlas E3 p.1) (c.map_source (mem_chart_source E3 p.1))
have hz : (0:β) β Ioo (-Ξ΅) Ξ΅ := β¨by linarith,hΞ΅β©
have hXp : ContDiffAt β 1 (Function.uncurry X) (e p,0) :=
hXs.contDiffAt ((Metric.isOpen_ball.prod isOpen_Ioo).mem_nhds β¨Metric.mem_ball_self hr,hzβ©)
have he : ContMDiffAt I3.tangent π(β,E3 Γ E3) 1 e p := contMDiffAt_extChartAt
have harg : ContMDiffAt (I3.tangent.prod π(β,β)) π(β,(E3 Γ E3) Γ β) 1
(fun q : TangentBundle I3 M Γ β => (e q.1,q.2)) (p,0) :=
(he.comp (p,0) contMDiffAt_fst).prodMk_space contMDiffAt_snd
have hOut : ContMDiffAt π(β,E3 Γ E3) I3.tangent 1 e.symm (X (e p) 0) := by
have hh := contMDiffWithinAt_extChartAt_symm_target (I := I3.tangent) (n := 1) p
(show X (e p) 0 β e.target from by rw [h0 _ (Metric.mem_ball_self hr)]; exact e.map_source (mem_extChartAt_source p))
apply hh.contMDiffAt
rw [h0 _ (Metric.mem_ball_self hr)]
exact extChartAt_target_mem_nhds p
apply (hOut.comp (p,0) (hXp.contMDiffAt.comp (p,0) harg)).congr_of_eventuallyEq
have hn : {y : TangentBundle I3 M | y β C.source β§ e y β Metric.ball (e p) r} β π p :=
inter_mem (C.open_source.mem_nhds hp)
(he.continuousAt.preimage_mem_nhds (Metric.isOpen_ball.mem_nhds (Metric.mem_ball_self hr)))
have ht : Ioo (-Ξ΅) Ξ΅ β π (0:β) := isOpen_Ioo.mem_nhds hz
have hnh := prod_mem_nhds hn ht
filter_upwards [hnh] with q hq
exact geodesicFlow_eq_chart g p hΞ΅ hq.1.1 (h0 _ hq.1.2) (hd _ hq.1.2) (hXt _ hq.1.2) hq.2
theorem geodesicFlow_contMDiff (g : SmoothMetric M) :
ContMDiff (I3.tangent.prod π(β,β)) I3.tangent 1 (Function.uncurry (geodesicFlow g)) :=
FlowContinuation.flow_contMDiff (geodesicFlow g) (geodesicFlow_zero g)
(geodesicFlow_add g) (geodesicFlow_continuous g) (geodesicFlow_contMDiffAt_zero g)
end
section
variable {M : Type} [TopologicalSpace M] [ChartedSpace E3 M] [IsManifold I3 β M]
theorem exists_geodesic_local_variation (g : SmoothMetric M) {c : OpenPartialHomeomorph M E3}
(hc : c β atlas E3 M) {z : E3 Γ E3} (hz : z.1 β c.target) :
β r > (0 : β), β Ξ΅ > (0 : β), β X : (E3 Γ E3) β β β E3 Γ E3,
(β y β Metric.ball z r, X y 0 = y) β§
(β y β Metric.ball z r, IsGeodesicOn g (fun t => c.symm (X y t).1) (Ioo (-Ξ΅) Ξ΅)) β§
(β y β Metric.ball z r, β t β Ioo (-Ξ΅) Ξ΅,
HasDerivAt (X y) (geodesicPhase g c (X y t)) t) β§
(β y β Metric.ball z r, β t β Ioo (-Ξ΅) Ξ΅, (X y t).1 β c.target) β§
ContDiffOn β 1 (Function.uncurry X) (Metric.ball z r ΓΛ’ Ioo (-Ξ΅) Ξ΅) β§
β A : (E3 Γ E3) β β β (E3 Γ E3) βL[β] E3 Γ E3,
(β y β Metric.ball z r, A y 0 = ContinuousLinearMap.id β (E3 Γ E3)) β§
(β y β Metric.ball z r, β t β Ioo (-Ξ΅) Ξ΅, HasFDerivAt (fun w => X w t) (A y t) y) β§
(β y β Metric.ball z r, β t β Ioo (-Ξ΅) Ξ΅,
HasDerivAt (A y) ((fderiv β (geodesicPhase g c) (X y t)).comp (A y t)) t) := by
obtain β¨r,hr,Ξ΅,hΞ΅,X,h0,hd,hs,A,hA0,hdf,hAdβ© :=
ODEVariation.exists_contDiff_variation_flow (contDiffAt_infty.mp (geodesicPhase_smoothAt g hc hz) 2)
have hO : IsOpen (Metric.ball z r ΓΛ’ Ioo (-Ξ΅) Ξ΅) := Metric.isOpen_ball.prod isOpen_Ioo
have hp : (z,(0:β)) β Metric.ball z r ΓΛ’ Ioo (-Ξ΅) Ξ΅ := β¨Metric.mem_ball_self hr,by constructor <;> linarithβ©
have hx : ContinuousAt (Function.uncurry X) (z,0) := hs.continuousOn.continuousAt (hO.mem_nhds hp)
have hmem : {p : (E3 Γ E3) Γ β | (X p.1 p.2).1 β c.target} β π (z,0) := by
apply hx.fst.preimage_mem_nhds
simpa only [Function.uncurry_apply_pair,h0 z (Metric.mem_ball_self hr)] using c.open_target.mem_nhds hz
obtain β¨Ξ·,hΞ·,hsmallβ© := Metric.mem_nhds_iff.mp (inter_mem hmem (hO.mem_nhds hp))
have hsub : β y β Metric.ball z (Ξ·/2), β t β Ioo (-(Ξ·/2)) (Ξ·/2),
(X y t).1 β c.target β§ (y,t) β Metric.ball z r ΓΛ’ Ioo (-Ξ΅) Ξ΅ := by
intro y hy t ht
apply hsmall (a := (y,t))
rw [Metric.mem_ball,Prod.dist_eq,max_lt_iff]
exact β¨lt_trans hy (half_lt_self hΞ·),by rw [Real.dist_eq,sub_zero,abs_lt]; constructor <;> linarith [ht.1,ht.2]β©
refine β¨Ξ·/2,half_pos hΞ·,Ξ·/2,half_pos hΞ·,X,?_,?_,?_,?_,?_β©
Β· intro y hy
exact h0 y (hsub y hy 0 β¨by linarith,by linarithβ©).2.1
Β· intro y hy
exact chart_geodesic g hc isOpen_Ioo (fun t ht => (hsub y hy t ht).1)
(fun t ht => hd y (hsub y hy t ht).2.1 t (hsub y hy t ht).2.2)
Β· intro y hy t ht
exact hd y (hsub y hy t ht).2.1 t (hsub y hy t ht).2.2
Β· exact fun y hy t ht => (hsub y hy t ht).1
Β· refine β¨hs.mono (fun p hp => (hsub p.1 hp.1 p.2 hp.2).2),A,?_,?_,?_β©
Β· intro y hy
exact hA0 y (hsub y hy 0 β¨by linarith,by linarithβ©).2.1
Β· intro y hy t ht
exact hdf y (hsub y hy t ht).2.1 t (hsub y hy t ht).2.2
Β· intro y hy t ht
exact hAd y (hsub y hy t ht).2.1 t (hsub y hy t ht).2.2
lemma geodesicPhase_fderiv_apply (g : SmoothMetric M) {c : OpenPartialHomeomorph M E3}
(hc : c β atlas E3 M) {z : E3 Γ E3} (hz : z.1 β c.target) (w : E3 Γ E3) :
fderiv β (geodesicPhase g c) z w =
(w.2,-(fderiv β (connectionBilin g c) z.1 w.1 z.2 z.2 +
connectionBilin g c z.1 w.2 z.2 + connectionBilin g c z.1 z.2 w.2)) := by
let : NormedAddCommGroup (E3 βL[β] E3) := ContinuousLinearMap.toNormedAddCommGroup
let : NormedSpace β (E3 βL[β] E3) := ContinuousLinearMap.toNormedSpace
let : NormedAddCommGroup (E3 βL[β] E3 βL[β] E3) := ContinuousLinearMap.toNormedAddCommGroup
let : NormedSpace β (E3 βL[β] E3 βL[β] E3) := ContinuousLinearMap.toNormedSpace
have hC := ((connectionBilin_smoothAt g hc hz).differentiableAt (by simp)).hasFDerivAt.comp z
(hasFDerivAt_fst (p := z))
have hh := (hasFDerivAt_snd (p := z)).prodMk
(((hC.clm_apply (hasFDerivAt_snd (p := z))).clm_apply (hasFDerivAt_snd (p := z))).neg)
have he : geodesicPhase g c = (fun q : E3 Γ E3 =>
(q.2,-connectionBilin g c q.1 q.2 q.2)) := by
funext q
simp only [geodesicPhase,connectionBilin_apply]
change HasFDerivAt (fun q : E3 Γ E3 => (q.2,-connectionBilin g c q.1 q.2 q.2)) _ z at hh
rw [he,hh.fderiv]
simp only [ContinuousLinearMap.prod_apply,
_root_.neg_apply,_root_.add_apply,ContinuousLinearMap.comp_apply,
ContinuousLinearMap.flip_apply,Function.comp_apply]
congr 1
change -(connectionBilin g c z.1 z.2 w.2 + (connectionBilin g c z.1 w.2 z.2 +
fderiv β (connectionBilin g c) z.1 w.1 z.2 z.2)) = _
abel
lemma geodesicPhase_variation_smooth (g : SmoothMetric M) {c : OpenPartialHomeomorph M E3}
(hc : c β atlas E3 M) {U : Set β} (hU : IsOpen U) {z w : β β E3 Γ E3}
(hz : β t β U, (z t).1 β c.target)
(hdz : β t β U, HasDerivAt z (geodesicPhase g c (z t)) t)
(hdw : β t β U, HasDerivAt w (fderiv β (geodesicPhase g c) (z t) (w t)) t) :
ContDiffOn β β (fun t => (z t,w t)) U := by
apply ODEVariation.solution_smooth (f := fun q : (E3 Γ E3) Γ (E3 Γ E3) =>
(geodesicPhase g c q.1,fderiv β (geodesicPhase g c) q.1 q.2))
(S := {q | q.1.1 β c.target}) _ hU (fun t ht => hz t ht)
(fun t ht => (hdz t ht).prodMk (hdw t ht))
intro q hq
have hf := geodesicPhase_smoothAt g hc hq
exact ((hf.comp q contDiffAt_fst).prodMk
((hf.fderiv_right (m := β) (by simp)).comp q contDiffAt_fst |>.clm_apply contDiffAt_snd)).contDiffWithinAt
lemma linearized_geodesic_jacobi (g : SmoothMetric M) {c : OpenPartialHomeomorph M E3}
(hc : c β atlas E3 M) {U : Set β} (hU : IsOpen U) {z w : β β E3 Γ E3}
(hz : β t β U, (z t).1 β c.target)
(hdz : β t β U, HasDerivAt z (geodesicPhase g c (z t)) t)
(hdw : β t β U, HasDerivAt w (fderiv β (geodesicPhase g c) (z t) (w t)) t)
{s : β} (hs : s β U) :
alongDerivative g c (fun t => (z t).1)
(alongDerivative g c (fun t => (z t).1) (fun t => (w t).1)) s +
curvatureTerm g c (z s).1 (w s).1 (z s).2 (z s).2 = 0 := by
let : NormedAddCommGroup (E3 βL[β] E3) := ContinuousLinearMap.toNormedAddCommGroup
let : NormedSpace β (E3 βL[β] E3) := ContinuousLinearMap.toNormedSpace
let : NormedAddCommGroup (E3 βL[β] E3 βL[β] E3) := ContinuousLinearMap.toNormedAddCommGroup
let : NormedSpace β (E3 βL[β] E3 βL[β] E3) := ContinuousLinearMap.toNormedSpace
let C := connectionBilin g c
have hdw' (t : β) (ht : t β U) := (hdw t ht).congr_deriv
(geodesicPhase_fderiv_apply g hc (hz t ht) (w t))
have hx (t : β) (ht : t β U) : HasDerivAt (fun r => (z r).1) (z t).2 t := (hdz t ht).fst
have hv (t : β) (ht : t β U) : HasDerivAt (fun r => (z r).2) (-C (z t).1 (z t).2 (z t).2) t := by
have hh : HasDerivAt (fun r => (z r).2) (geodesicPhase g c (z t)).2 t := (hdz t ht).snd
simpa only [C,connectionBilin_apply,geodesicPhase] using hh
have hj (t : β) (ht : t β U) : HasDerivAt (fun r => (w r).1) (w t).2 t := (hdw' t ht).fst
have hk (t : β) (ht : t β U) : HasDerivAt (fun r => (w r).2)
(-(fderiv β C (z t).1 (w t).1 (z t).2 (z t).2 + C (z t).1 (w t).2 (z t).2 + C (z t).1 (z t).2 (w t).2)) t := (hdw' t ht).snd
let F : β β E3 := fun t => (w t).2 + C (z t).1 (z t).2 (w t).1
have he : alongDerivative g c (fun t => (z t).1) (fun t => (w t).1) =αΆ [π s] F := by
filter_upwards [hU.mem_nhds hs] with t ht
rw [alongDerivative,(hx t ht).deriv,(hj t ht).deriv]
exact (connectionBilin_apply g c (z t).1 (z t).2 (w t).1).symm βΈ rfl
have hC := ((connectionBilin_smoothAt g hc (hz s hs)).differentiableAt (by simp)).hasFDerivAt.comp_hasDerivAt s (hx s hs)
have hF := (hk s hs).add ((hC.clm_apply (hv s hs)).clm_apply (hj s hs))
change HasDerivAt F _ s at hF
rw [along_congr g c Filter.EventuallyEq.rfl he,alongDerivative,(hx s hs).deriv,hF.deriv,
curvature_connection g hc (hz s hs)]
rw [β connectionBilin_apply]
change -(fderiv β C (z s).1 (w s).1 (z s).2 (z s).2 + C (z s).1 (w s).2 (z s).2 + C (z s).1 (z s).2 (w s).2) +
((fderiv β C (z s).1 (z s).2 (z s).2 + C (z s).1 (-C (z s).1 (z s).2 (z s).2)) (w s).1 +
C (z s).1 (z s).2 (w s).2) +
C (z s).1 (z s).2 ((w s).2 + C (z s).1 (z s).2 (w s).1) +
(fderiv β C (z s).1 (w s).1 (z s).2 (z s).2 - fderiv β C (z s).1 (z s).2 (w s).1 (z s).2 +
C (z s).1 (w s).1 (C (z s).1 (z s).2 (z s).2) - C (z s).1 (z s).2 (C (z s).1 (w s).1 (z s).2)) = 0
simp only [_root_.add_apply,map_neg,_root_.neg_apply,map_add]
rw [connectionBilin_deriv_symm g hc (hz s hs) (z s).2 (z s).2 (w s).1,
connectionBilin_symm g c (z s).1 (w s).2 (z s).2,
connectionBilin_symm g c (z s).1 (C (z s).1 (z s).2 (z s).2) (w s).1,
connectionBilin_symm g c (z s).1 (w s).1 (z s).2]
abel
end
section
variable {M : Type} [TopologicalSpace M] [ChartedSpace E3 M] [IsManifold I3 β M]
variable [CompactSpace M] [T2Space M]
variable {E : Type} [NormedAddCommGroup E] [NormedSpace β E]
lemma geodesic_family_contMDiffAt (g : SmoothMetric M) {f : E β TangentBundle I3 M}
{a : E} (hf : ContMDiffAt π(β,E) I3.tangent 1 f a) (s : β) :
ContMDiffAt π(β,E) I3.tangent 1 (fun y => geodesicFlow g (f y) s) a := by
exact (geodesicFlow_contMDiff g).contMDiffAt.comp a (hf.prodMk contMDiffAt_const)
theorem geodesic_variation_representation (g : SmoothMetric M)
{f : E β TangentBundle I3 M} {a : E}
(hf : ContMDiffAt π(β,E) I3.tangent 1 f a) (s : β) :
let p := geodesicFlow g (f a) s
let e := extChartAt I3.tangent p
let Z := fun y => e (geodesicFlow g (f y) s)
β Ξ΅ > (0 : β), β X : (E3 Γ E3) β β β E3 Γ E3,
β A : (E3 Γ E3) β β β (E3 Γ E3) βL[β] E3 Γ E3,
(β t β Ioo (-Ξ΅) Ξ΅, e (geodesicFlow g (f a) (s+t)) = X (Z a) t) β§
(β t β Ioo (-Ξ΅) Ξ΅, HasDerivAt (X (Z a))
(geodesicPhase g (chartAt E3 p.1) (X (Z a) t)) t) β§
(β t β Ioo (-Ξ΅) Ξ΅, (X (Z a) t).1 β (chartAt E3 p.1).target) β§
(β t β Ioo (-Ξ΅) Ξ΅, HasFDerivAt
(fun y => e (geodesicFlow g (f y) (s+t))) ((A (Z a) t).comp (fderiv β Z a)) a) β§
(β t β Ioo (-Ξ΅) Ξ΅, HasDerivAt (A (Z a))
((fderiv β (geodesicPhase g (chartAt E3 p.1)) (X (Z a) t)).comp (A (Z a) t)) t) := by
intro p e Z
let c := chartAt E3 p.1
let C := chartAt (ModelProd E3 E3) p
have hp : p β C.source := mem_chart_source _ p
have hz : (e p).1 β c.target := c.map_source (mem_chart_source E3 p.1)
obtain β¨r,hr,Ξ΅,hΞ΅,X,h0,hΞ³,hd,hXt,hXs,A,hA0,hdf,hAdβ© :=
exists_geodesic_local_variation g (chart_mem_atlas E3 p.1) hz
have ha : Z a β Metric.ball (e p) r := Metric.mem_ball_self hr
have hFa := geodesic_family_contMDiffAt g hf s
have he : ContMDiffAt I3.tangent π(β,E3 Γ E3) 1 e p := contMDiffAt_extChartAt
have hZ : ContDiffAt β 1 Z a := contMDiffAt_iff_contDiffAt.mp (he.comp a hFa)
have hZn : {y : E | geodesicFlow g (f y) s β C.source β§ Z y β Metric.ball (e p) r} β π a :=
inter_mem (hFa.continuousAt.preimage_mem_nhds (C.open_source.mem_nhds hp))
(hZ.continuousAt.preimage_mem_nhds (Metric.isOpen_ball.mem_nhds ha))
have hrep (t : β) (ht : t β Ioo (-Ξ΅) Ξ΅) :
(fun y => e (geodesicFlow g (f y) (s+t))) =αΆ [π a] fun y => X (Z y) t := by
filter_upwards [hZn] with y hy
rw [β geodesicFlow_add g (f y) s t,geodesicFlow_eq_chart g p hΞ΅ hy.1
(h0 _ hy.2) (hd _ hy.2) (hXt _ hy.2) ht]
apply e.right_inv
change X (Z y) t β (extChartAt I3.tangent p).target
rw [extChartAt_target]
exact β¨(TangentBundle.mem_chart_target_iff _ _).mpr (hXt _ hy.2 t ht),by simpβ©
refine β¨Ξ΅,hΞ΅,X,A,fun t ht => (hrep t ht).eq_of_nhds,hd _ ha,hXt _ ha,?_,hAd _ haβ©
intro t ht
exact ((hdf _ ha t ht).comp a (hZ.differentiableAt (by simp)).hasFDerivAt).congr_of_eventuallyEq
(hrep t ht)
theorem geodesic_family_linearization (g : SmoothMetric M)
{f : E β TangentBundle I3 M} {a : E}
(hf : ContMDiffAt π(β,E) I3.tangent 1 f a) (s : β) (b : E) :
let p := geodesicFlow g (f a) s
let e := extChartAt I3.tangent p
let z := fun t => e (geodesicFlow g (f a) (s+t))
let w := fun t => fderiv β (fun y => e (geodesicFlow g (f y) (s+t))) a b
β Ξ΅ > (0 : β),
(β t β Ioo (-Ξ΅) Ξ΅, (z t).1 β (chartAt E3 p.1).target) β§
(β t β Ioo (-Ξ΅) Ξ΅, HasDerivAt z (geodesicPhase g (chartAt E3 p.1) (z t)) t) β§
(β t β Ioo (-Ξ΅) Ξ΅, HasDerivAt w (fderiv β (geodesicPhase g (chartAt E3 p.1)) (z t) (w t)) t) := by
intro p e z w
obtain β¨Ξ΅,hΞ΅,X,A,hX,hd,hXt,hdf,hAdβ© := geodesic_variation_representation g hf s
let Z := fun y => e (geodesicFlow g (f y) s)
have hew : β t β Ioo (-Ξ΅) Ξ΅, w t = A (Z a) t (fderiv β Z a b) := by
intro t ht
exact congrArg (fun L => L b) (hdf t ht).fderiv
have hen (t : β) (ht : t β Ioo (-Ξ΅) Ξ΅) : z =αΆ [π t] X (Z a) :=
Filter.eventually_of_mem (isOpen_Ioo.mem_nhds ht) (fun r hr => hX r hr)
have hwen (t : β) (ht : t β Ioo (-Ξ΅) Ξ΅) : w =αΆ [π t] fun r => A (Z a) r (fderiv β Z a b) :=
Filter.eventually_of_mem (isOpen_Ioo.mem_nhds ht) (fun r hr => hew r hr)
refine β¨Ξ΅,hΞ΅,?_,?_,?_β©
Β· intro t ht
rw [show z t = X (Z a) t from hX t ht]
exact hXt t ht
Β· intro t ht
rw [(hen t ht).eq_of_nhds]
exact (hd t ht).congr_of_eventuallyEq (hen t ht)
Β· intro t ht
rw [(hen t ht).eq_of_nhds,(hwen t ht).eq_of_nhds]
have hh := ((hAd t ht).clm_apply (hasDerivAt_const t (fderiv β Z a b))).congr_of_eventuallyEq (hwen t ht)
simpa only [map_zero,add_zero,ContinuousLinearMap.comp_apply] using hh
lemma geodesic_family_linearization_at (g : SmoothMetric M)
{f : E β TangentBundle I3 M} {a : E}
(hf : ContMDiffAt π(β,E) I3.tangent 1 f a) (s : β) (b : E) :
let p := geodesicFlow g (f a) s
let e := extChartAt I3.tangent p
let z := fun t => e (geodesicFlow g (f a) t)
let w := fun t => fderiv β (fun y => e (geodesicFlow g (f y) t)) a b
β U : Set β, IsOpen U β§ s β U β§
(β t β U, (z t).1 β (chartAt E3 p.1).target) β§
(β t β U, HasDerivAt z (geodesicPhase g (chartAt E3 p.1) (z t)) t) β§
(β t β U, HasDerivAt w (fderiv β (geodesicPhase g (chartAt E3 p.1)) (z t) (w t)) t) := by
intro p e z w
obtain β¨Ξ΅,hΞ΅,hz,hdz,hdwβ© := geodesic_family_linearization g hf s b
have hh (t : β) (ht : t β Ioo (s-Ξ΅) (s+Ξ΅)) : t-s β Ioo (-Ξ΅) Ξ΅ := by
constructor <;> linarith [ht.1,ht.2]
refine β¨Ioo (s-Ξ΅) (s+Ξ΅),isOpen_Ioo,by constructor <;> linarith,?_,?_,?_β©
Β· intro t ht
simpa only [add_sub_cancel] using hz (t-s) (hh t ht)
Β· intro t ht
have hd := (hdz (t-s) (hh t ht)).scomp t ((hasDerivAt_id t).sub_const s)
simpa only [Function.comp_def,add_sub_cancel,mul_one,one_smul,id_eq,z,w,p,e] using hd
Β· intro t ht
have hd := (hdw (t-s) (hh t ht)).scomp t ((hasDerivAt_id t).sub_const s)
simpa only [Function.comp_def,add_sub_cancel,mul_one,one_smul,id_eq,z,w,p,e] using hd
end
section
variable {M : Type} [TopologicalSpace M] [ChartedSpace E3 M] [IsManifold I3 β M]
lemma smoothField_of_local_coordinates {Ξ³ : β β M} {J : β s, TangentSpace I3 (Ξ³ s)}
{U : Set β} (hU : IsOpen U) (hΞ³ : ContMDiffOn π(β,β) I3 β Ξ³ U)
(h : β s β U, β c : OpenPartialHomeomorph M E3, c β atlas E3 M β§ Ξ³ s β c.source β§
ContDiffAt β β (fieldCoordinates Ξ³ J c) s) : SmoothFieldOn Ξ³ J U := by
intro d hd s hs
obtain β¨c,hc,hsc,hFβ© := h s hs.1
have hΞ³s := hΞ³.contMDiffAt (hU.mem_nhds hs.1)
have fsm := transition_smoothAt hc hd (c.map_source hsc)
(show c.symm (c (Ξ³ s)) β d.source by rw [c.left_inv hsc]; exact hs.2)
have hx := curve_coordinates_smoothAt hU hΞ³ hc hs.1 hsc
have he : fieldCoordinates Ξ³ J d =αΆ [π s] fun r =>
fderiv β (d β c.symm) (c (Ξ³ r)) (fieldCoordinates Ξ³ J c r) := by
filter_upwards [hΞ³s.continuousAt.preimage_mem_nhds
((c.open_source.inter d.open_source).mem_nhds β¨hsc,hs.2β©)] with r hr
exact (field_coordinates_change hc hd hr.1 hr.2).symm
exact (((fsm.fderiv_right (m := β) (by simp)).comp s hx).clm_apply hF).congr_of_eventuallyEq he |>.contDiffWithinAt
lemma jacobi_of_local_coordinates (g : SmoothMetric M) {Ξ³ : β β M}
{J : β s, TangentSpace I3 (Ξ³ s)} {U : Set β}
(hU : IsOpen U) (hΞ³ : ContMDiffOn π(β,β) I3 β Ξ³ U)
(h : β s β U, β c : OpenPartialHomeomorph M E3, c β atlas E3 M β§ Ξ³ s β c.source β§
ContDiffAt β β (fieldCoordinates Ξ³ J c) s β§
alongDerivative g c (c β Ξ³) (alongDerivative g c (c β Ξ³) (fieldCoordinates Ξ³ J c)) s +
curvatureTerm g c (c (Ξ³ s)) (fieldCoordinates Ξ³ J c s) (deriv (c β Ξ³) s) (deriv (c β Ξ³) s) = 0) :
IsJacobiFieldOn g Ξ³ J U := by
have hJ : SmoothFieldOn Ξ³ J U := smoothField_of_local_coordinates hU hΞ³
(fun s hs => by obtain β¨c,hc,hsc,hcs,_β© := h s hs; exact β¨c,hc,hsc,hcsβ©)
have hi (s : β) (hs : s β U) :
covariantDerivative g Ξ³ (covariantDerivative g Ξ³ J) s + curvatureAlong g Ξ³ J s = 0 := by
obtain β¨c,hc,hsc,_,heβ© := h s hs
apply (mdifferentiable_of_mem_atlas (I := I3) hc).mfderiv_injective hsc
rw [map_add,map_zero]
change fieldCoordinates Ξ³ (covariantDerivative g Ξ³ (covariantDerivative g Ξ³ J)) c s +
fieldCoordinates Ξ³ (curvatureAlong g Ξ³ J) c s = 0
rw [covariantDerivative_iterate_coordinates g hU hΞ³ hJ hs hc hsc,
curvatureAlong_coordinates g J (hΞ³.contMDiffAt (hU.mem_nhds hs)) hc hsc]
exact he
intro c hc
refine β¨hJ c hc,?_β©
intro s hs hsc
rw [β covariantDerivative_iterate_coordinates g hU hΞ³ hJ hs hc hsc,
β curvatureAlong_coordinates g J (hΞ³.contMDiffAt (hU.mem_nhds hs)) hc hsc]
change mfderiv I3 I3 c (Ξ³ s) (covariantDerivative g Ξ³ (covariantDerivative g Ξ³ J) s) +
mfderiv I3 I3 c (Ξ³ s) (curvatureAlong g Ξ³ J s) = 0
rw [β map_add,hi s hs,map_zero]
end
variable {M : Type} [TopologicalSpace M] [ChartedSpace E3 M] [IsManifold I3 β M]
variable [CompactSpace M] [T2Space M]
variable {E : Type} [NormedAddCommGroup E] [NormedSpace β E]
def geodesicFamily (g : SmoothMetric M) (f : E β TangentBundle I3 M) (a : E) (t : β) : M :=
(geodesicFlow g (f a) t).proj
def geodesicVariation (g : SmoothMetric M) (f : E β TangentBundle I3 M) (a b : E)
(t : β) : TangentSpace I3 (geodesicFamily g f a t) :=
mfderiv π(β,E) I3 (fun y => geodesicFamily g f y t) a b
lemma geodesicFamily_isGeodesic (g : SmoothMetric M) (f : E β TangentBundle I3 M) (a : E) :
IsGeodesicOn g (geodesicFamily g f a) univ := by
let _ : NormedAddCommGroup E := inferInstance
let _ : NormedSpace β E := inferInstance
exact globalGeodesic_isGeodesic g (f a)
lemma geodesicFamily_parameter_smooth (g : SmoothMetric M) {f : E β TangentBundle I3 M}
{a : E} (hf : ContMDiffAt π(β,E) I3.tangent 1 f a) (t : β) :
ContMDiffAt π(β,E) I3 1 (fun y => geodesicFamily g f y t) a :=
(contMDiff_proj (IB := I3) (F := E3) (E := TangentSpace I3)).contMDiffAt.comp a
(geodesic_family_contMDiffAt g hf t)
lemma geodesicVariation_coordinates (g : SmoothMetric M) {f : E β TangentBundle I3 M}
{a : E} (hf : ContMDiffAt π(β,E) I3.tangent 1 f a) (b : E) (t : β)
{p : TangentBundle I3 M} (hp : geodesicFamily g f a t β (chartAt E3 p.1).source) :
fieldCoordinates (geodesicFamily g f a) (geodesicVariation g f a b) (chartAt E3 p.1) t =
(fderiv β (fun y => extChartAt I3.tangent p (geodesicFlow g (f y) t)) a b).1 := by
let c := chartAt E3 p.1
let e := extChartAt I3.tangent p
have ha := geodesic_family_contMDiffAt g hf t
have hb := geodesicFamily_parameter_smooth g hf t
have he : ContMDiffAt I3.tangent π(β,E3 Γ E3) 1 e (geodesicFlow g (f a) t) :=
contMDiffAt_extChartAt' ((TangentBundle.mem_chart_source_iff _ _).mpr hp)
have hs : ContDiffAt β 1 (fun y => e (geodesicFlow g (f y) t)) a :=
contMDiffAt_iff_contDiffAt.mp (he.comp a ha)
have hd : HasFDerivAt (fun y => (e (geodesicFlow g (f y) t)).1)
((ContinuousLinearMap.fst β E3 E3).comp (fderiv β (fun y => e (geodesicFlow g (f y) t)) a)) a :=
(hs.differentiableAt (by simp)).hasFDerivAt.fst
have hm := mfderiv_comp a ((mdifferentiable_of_mem_atlas (I := I3) (chart_mem_atlas E3 p.1)).mdifferentiableAt hp)
(hb.mdifferentiableAt (by simp))
have hv := congrArg (fun L => L b) hm
rw [mfderiv_eq_fderiv] at hv
change fderiv β (fun y => c (geodesicFamily g f y t)) a b =
fieldCoordinates (geodesicFamily g f a) (geodesicVariation g f a b) c t at hv
rw [β hv]
change fderiv β (fun y => (e (geodesicFlow g (f y) t)).1) a b = _
rw [hd.fderiv]
rfl
theorem geodesicVariation_isJacobi (g : SmoothMetric M) {f : E β TangentBundle I3 M}
{a : E} (hf : ContMDiffAt π(β,E) I3.tangent 1 f a) (b : E) :
IsJacobiFieldOn g (geodesicFamily g f a) (geodesicVariation g f a b) univ := by
let Ξ³ := geodesicFamily g f a
let J := geodesicVariation g f a b
have hΞ³ := geodesicFamily_isGeodesic g f a
apply jacobi_of_local_coordinates g isOpen_univ hΞ³.1
intro s _
let p := geodesicFlow g (f a) s
let c := chartAt E3 p.1
let e := extChartAt I3.tangent p
let z := fun t => e (geodesicFlow g (f a) t)
let w := fun t => fderiv β (fun y => e (geodesicFlow g (f y) t)) a b
have hc : c β atlas E3 M := chart_mem_atlas E3 p.1
have hsc : Ξ³ s β c.source := mem_chart_source E3 p.1
obtain β¨U,hU,hs,hz,hdz,hdwβ© := geodesic_family_linearization_at g hf s b
have hsmooth : ContDiffOn β β (fun t => (z t,w t)) U :=
geodesicPhase_variation_smooth g hc hU hz hdz hdw
have he : fieldCoordinates Ξ³ J c =αΆ [π s] fun t => (w t).1 := by
filter_upwards [(hΞ³.1.contMDiffAt (by simp)).continuousAt.preimage_mem_nhds
(c.open_source.mem_nhds hsc)] with t ht
exact geodesicVariation_coordinates g hf b t ht
have hw : ContDiffAt β β (fun t => (w t).1) s := (hsmooth.contDiffAt (hU.mem_nhds hs)).snd.fst
refine β¨c,hc,hsc,hw.congr_of_eventuallyEq he,?_β©
have hde : alongDerivative g c (c β Ξ³) (fieldCoordinates Ξ³ J c) =αΆ [π s]
alongDerivative g c (fun t => (z t).1) (fun t => (w t).1) := by
filter_upwards [he.eventuallyEq_nhds] with t ht
exact along_congr g c Filter.EventuallyEq.rfl ht
rw [along_congr g c Filter.EventuallyEq.rfl hde,he.eq_of_nhds]
have hx : deriv (c β Ξ³) s = (z s).2 := by
exact (show HasDerivAt (fun t => (z t).1) (z s).2 s from (hdz s hs).fst).deriv
rw [hx]
exact linearized_geodesic_jacobi g hc hU hz hdz hdw hs
end ThreeManifold.RiemannianCoordinates
end
section
open Set Filter Topology Bundle Manifold IsManifold Matrix MeasureTheory
open scoped ContDiff Matrix.Norms.Elementwise
namespace ThreeManifold.RiemannianCoordinates
variable {M : Type} [TopologicalSpace M] [ChartedSpace E3 M] [IsManifold I3 β M]
lemma curvatureAlong_pairing_nonpos (g : SmoothMetric M) {Ξ³ : β β M}
(J : β s, TangentSpace I3 (Ξ³ s)) {s : β}
(hΞ³ : ContMDiffAt π(β,β) I3 β Ξ³ s) (hn : NonpositiveAt g (Ξ³ s)) :
g.inner (Ξ³ s) (curvatureAlong g Ξ³ J s) (J s) β€ 0 := by
have hc := chart_mem_atlas E3 (Ξ³ s)
have hsc := mem_chart_source E3 (Ξ³ s)
rw [β metric_field_coordinates g (curvatureAlong g Ξ³ J) J hc hsc,
curvatureAlong_coordinates g J hΞ³ hc hsc]
exact hn _ hc hsc _ _
lemma npc_noConjugatePoints (g : SmoothMetric M) (hn : NonpositiveSectionalCurvature g) :
NoConjugatePoints g := by
apply noConjugatePoints_of_intrinsic_index g
intro U hU hUc Ξ³ hΞ³ J hJ hJc hJU
apply integral_nonneg
intro s
by_cases hs : s β U
Β· exact indexPairDensity_nonneg_of_nonpositiveAt g J
(hΞ³.1.contMDiffAt (hU.mem_nhds hs)) (nonpositiveAt_of_nonpositive g hn _)
Β· have hz := notMem_subset hJU hs
have hz' : indexPairDensity g Ξ³ J J s = 0 :=
Function.notMem_support.mp (notMem_subset (indexPairDensity_support g Ξ³ J J) hz)
exact hz'.ge
def jacobiNormSq (g : SmoothMetric M) (Ξ³ : β β M)
(J : β s, TangentSpace I3 (Ξ³ s)) (s : β) : β := g.inner (Ξ³ s) (J s) (J s)
def jacobiNormSqSlope (g : SmoothMetric M) (Ξ³ : β β M)
(J : β s, TangentSpace I3 (Ξ³ s)) (s : β) : β :=
2 * g.inner (Ξ³ s) (covariantDerivative g Ξ³ J s) (J s)
lemma jacobiNormSq_hasDerivAt (g : SmoothMetric M) {Ξ³ : β β M}
{J : β s, TangentSpace I3 (Ξ³ s)} {U : Set β} (hU : IsOpen U)
(hΞ³ : ContMDiffOn π(β,β) I3 β Ξ³ U) (hJ : SmoothFieldOn Ξ³ J U)
{s : β} (hs : s β U) :
HasDerivAt (jacobiNormSq g Ξ³ J) (jacobiNormSqSlope g Ξ³ J s) s := by
change HasDerivAt (fun r => g.inner (Ξ³ r) (J r) (J r))
(2 * g.inner (Ξ³ s) (covariantDerivative g Ξ³ J s) (J s)) s
have hd := intrinsic_pairing_hasDerivAt g hU hΞ³ hJ hJ hs
rw [g.symm (Ξ³ s) (J s) (covariantDerivative g Ξ³ J s)] at hd
rw [two_mul]
exact hd
lemma jacobiNormSqSlope_hasDerivAt (g : SmoothMetric M) {Ξ³ : β β M}
{J : β s, TangentSpace I3 (Ξ³ s)} {U : Set β} (hU : IsOpen U)
(hΞ³ : ContMDiffOn π(β,β) I3 β Ξ³ U) (hJ : IsJacobiFieldOn g Ξ³ J U)
{s : β} (hs : s β U) :
HasDerivAt (jacobiNormSqSlope g Ξ³ J) (2 * indexPairDensity g Ξ³ J J s) s :=
(jacobi_indexPairDensity_hasDerivAt g hU hΞ³ hJ (jacobi_smoothField g hJ) hs).const_mul 2
lemma npc_jacobiNormSqSlope_deriv_lower (g : SmoothMetric M)
(hn : NonpositiveSectionalCurvature g) {Ξ³ : β β M}
{J : β s, TangentSpace I3 (Ξ³ s)} {U : Set β} (hU : IsOpen U)
(hΞ³ : ContMDiffOn π(β,β) I3 β Ξ³ U) (hJ : IsJacobiFieldOn g Ξ³ J U)
{s : β} (hs : s β U) :
2 * g.inner (Ξ³ s) (covariantDerivative g Ξ³ J s) (covariantDerivative g Ξ³ J s) β€
deriv (jacobiNormSqSlope g Ξ³ J) s := by
rw [(jacobiNormSqSlope_hasDerivAt g hU hΞ³ hJ hs).deriv, indexPairDensity]
have h := curvatureAlong_pairing_nonpos g J (hΞ³.contMDiffAt (hU.mem_nhds hs))
(nonpositiveAt_of_nonpositive g hn _)
linarith
lemma npc_jacobiNormSq_convex (g : SmoothMetric M) (hn : NonpositiveSectionalCurvature g)
{Ξ³ : β β M} {J : β s, TangentSpace I3 (Ξ³ s)} {U : Set β}
(hU : IsOpen U) (hUc : OrdConnected U)
(hΞ³ : ContMDiffOn π(β,β) I3 β Ξ³ U) (hJ : IsJacobiFieldOn g Ξ³ J U) :
ConvexOn β U (jacobiNormSq g Ξ³ J) := by
apply convexOn_of_hasDerivWithinAt2_nonneg hUc.convex
(intrinsic_pairing_smooth g hU hΞ³ (jacobi_smoothField g hJ) (jacobi_smoothField g hJ)).continuousOn
(f' := jacobiNormSqSlope g Ξ³ J) (f'' := fun s => 2 * indexPairDensity g Ξ³ J J s)
Β· intro s hs
exact (jacobiNormSq_hasDerivAt g hU hΞ³ (jacobi_smoothField g hJ) (interior_subset hs)).hasDerivWithinAt
Β· intro s hs
exact (jacobiNormSqSlope_hasDerivAt g hU hΞ³ hJ (interior_subset hs)).hasDerivWithinAt
Β· intro s hs
exact mul_nonneg (by norm_num) (indexPairDensity_nonneg_of_nonpositiveAt g J
(hΞ³.contMDiffAt (hU.mem_nhds (interior_subset hs))) (nonpositiveAt_of_nonpositive g hn _))
end ThreeManifold.RiemannianCoordinates
end
section
open Set Filter Topology Bundle Manifold IsManifold
open scoped ContDiff
namespace ThreeManifold.RiemannianCoordinates
section
variable {M : Type} [TopologicalSpace M] [ChartedSpace E3 M] [IsManifold I3 β M]
variable [CompactSpace M] [T2Space M]
def fiberPhase (x : M) (v : E3) : TangentBundle I3 M := β¨x,vβ©
lemma fiberPhase_contMDiff (x : M) : ContMDiff π(β,E3) I3.tangent β (fiberPhase x) := by
let _ : CompactSpace M := inferInstance
let _ : T2Space M := inferInstance
intro v
apply Bundle.contMDiffAt_totalSpace.mpr
refine β¨contMDiffAt_const,?_β©
let e := trivializationAt E3 (TangentSpace I3) x
have hmem : x β e.baseSet := mem_baseSet_trivializationAt E3 (TangentSpace I3) x
have he : (fun w : E3 => (e (fiberPhase x w)).2) = e.continuousLinearMapAt β x := by
funext w
exact (e.continuousLinearMapAt_apply_of_mem β hmem w).symm
change ContMDiffAt π(β,E3) π(β,E3) β (fun w => (e (fiberPhase x w)).2) v
rw [he]
exact (show E3 βL[β] E3 from e.continuousLinearMapAt β x).contDiff.contMDiff.contMDiffAt
lemma fiberPhase_extChart (x : M) (v w : E3) :
extChartAt I3.tangent (fiberPhase x v) (fiberPhase x w) =
(chartAt E3 x x,mfderiv I3 I3 (chartAt E3 x) x w) := by
let _ : CompactSpace M := inferInstance
let _ : T2Space M := inferInstance
apply Prod.ext
Β· rfl
Β· exact (congrArg (fun q : TangentBundle I3 E3 => q.2)
(tangentMap_chart (I := I3) (p := fiberPhase x v) (q := fiberPhase x w) (mem_chart_source E3 x))).symm
def exponential (g : SmoothMetric M) (x : M) (v : E3) : M :=
geodesicFamily g (fiberPhase x) v 1
lemma exponential_contMDiff (g : SmoothMetric M) (x : M) :
ContMDiff π(β,E3) I3 1 (exponential g x) := by
intro v
exact geodesicFamily_parameter_smooth g ((fiberPhase_contMDiff x).of_le (by simp)).contMDiffAt 1
lemma exponentialFamily_zero (g : SmoothMetric M) (x : M) (v : E3) :
geodesicFamily g (fiberPhase x) v 0 = x := by
change (geodesicFlow g (fiberPhase x v) 0).proj = x
rw [geodesicFlow_zero]
rfl
lemma exponentialVariation_zero (g : SmoothMetric M) (x : M) (v w : E3) :
geodesicVariation g (fiberPhase x) v w 0 = 0 := by
unfold geodesicVariation
have he : (fun y : E3 => geodesicFamily g (fiberPhase x) y 0) = fun _ => x := by
funext y; exact exponentialFamily_zero g x y
rw [he,mfderiv_const]
rfl
lemma fiberPhase_extChart_fderiv (x : M) (v b : E3) :
fderiv β (fun w => extChartAt I3.tangent (fiberPhase x v) (fiberPhase x w)) v b =
(0,mfderiv I3 I3 (chartAt E3 x) x b) := by
let L : E3 βL[β] E3 := mfderiv I3 I3 (chartAt E3 x) x
have hd : HasFDerivAt (fun w => (chartAt E3 x x,L w))
((0 : E3 βL[β] E3).prod L) v := (hasFDerivAt_const (chartAt E3 x x) v).prodMk L.hasFDerivAt
have he : (fun w => extChartAt I3.tangent (fiberPhase x v) (fiberPhase x w)) =
fun w => (chartAt E3 x x,L w) := funext (fiberPhase_extChart x v)
rw [he,hd.fderiv]
rfl
theorem exponential_mfderiv_injective (g : SmoothMetric M) (hn : NoConjugatePoints g)
(x : M) (v : E3) : Function.Injective (mfderiv π(β,E3) I3 (exponential g x) v) := by
suffices h : β b : E3, mfderiv π(β,E3) I3 (exponential g x) v b = 0 β b = 0 by
intro a b hab
have hz : mfderiv π(β,E3) I3 (exponential g x) v (a-b) = 0 := by
rw [map_sub,hab,sub_self]
exact sub_eq_zero.mp (h (a-b) hz)
intro b hb
let f := fiberPhase x
let Ξ³ := geodesicFamily g f v
let J := geodesicVariation g f v b
have hf : ContMDiffAt π(β,E3) I3.tangent 1 f v :=
((fiberPhase_contMDiff x).of_le (by simp)).contMDiffAt
have hΞ³ := geodesicFamily_isGeodesic g f v
have hJ := geodesicVariation_isJacobi g hf b
have hz : β t : β, J t = 0 := fun t => hn univ isOpen_univ ordConnected_univ Ξ³ hΞ³ J hJ
0 (mem_univ 0) 1 (mem_univ 1) (by norm_num) (exponentialVariation_zero g x v b) hb t (mem_univ t)
let c := chartAt E3 x
let e := extChartAt I3.tangent (fiberPhase x v)
let z := fun t => e (geodesicFlow g (f v) t)
let w := fun t => fderiv β (fun y => e (geodesicFlow g (f y) t)) v b
have hlin := geodesic_family_linearization_at g hf 0 b
simp only [geodesicFlow_zero] at hlin
obtain β¨U,hU,h0,hzt,hdz,hdwβ© := hlin
have he : (fun t => (w t).1) =αΆ [π (0:β)] fun _ => (0:E3) := by
have hbase : Ξ³ 0 = x := exponentialFamily_zero g x v
have hsource : Ξ³ 0 β c.source := hbase βΈ mem_chart_source E3 x
filter_upwards [(hΞ³.1.contMDiffAt (by simp)).continuousAt.preimage_mem_nhds
(c.open_source.mem_nhds hsource)] with t ht
have hc := geodesicVariation_coordinates g hf b t (p := fiberPhase x v) ht
rw [β hc]
change mfderiv I3 I3 c (Ξ³ t) (J t) = 0
rw [hz t,map_zero]
have hd : HasDerivAt (fun t => (w t).1) (w 0).2 0 := by
have hd' := (hdw 0 h0).congr_deriv
(geodesicPhase_fderiv_apply g (chart_mem_atlas E3 x) (hzt 0 h0) (w 0))
exact hd'.fst
have hw0 : (w 0).2 = 0 := by
have hh := hd.congr_of_eventuallyEq he.symm
exact hh.unique (hasDerivAt_const 0 (0:E3))
have hi : w 0 = (0,mfderiv I3 I3 c x b) := by
dsimp only [w]
simp only [geodesicFlow_zero]
exact fiberPhase_extChart_fderiv x v b
rw [hi] at hw0
exact (mdifferentiable_of_mem_atlas (I := I3) (chart_mem_atlas E3 x)).mfderiv_injective
(mem_chart_source E3 x) (hw0.trans (map_zero _).symm)
end
variable {M : Type} [TopologicalSpace M] [ChartedSpace E3 M] [IsManifold I3 β M]
lemma isLocalHomeomorph_of_mfderiv_injective {f : E3 β M}
(hf : ContMDiff π(β,E3) I3 1 f)
(hi : β a, Function.Injective (mfderiv π(β,E3) I3 f a)) :
IsLocalHomeomorph f := by
apply isLocalHomeomorph_iff_isOpenEmbedding_restrict.mpr
intro a
let c := chartAt E3 (f a)
let F : E3 β E3 := c β f
have hc : c β atlas E3 M := chart_mem_atlas E3 (f a)
have hca : f a β c.source := mem_chart_source E3 (f a)
have hC : ContMDiffAt I3 I3 1 c (f a) := contMDiffAt_extChartAt' hca
have hF : ContDiffAt β 1 F a := contMDiffAt_iff_contDiffAt.mp (hC.comp a hf.contMDiffAt)
have hd : fderiv β F a = (mfderiv I3 I3 c (f a)).comp (mfderiv π(β,E3) I3 f a) := by
rw [β mfderiv_eq_fderiv]
exact mfderiv_comp a (hC.mdifferentiableAt (by simp)) (hf.mdifferentiable (by simp) a)
have hdi : Function.Injective (fderiv β F a) := by
rw [hd]
exact ((mdifferentiable_of_mem_atlas (I := I3) hc).mfderiv_injective hca).comp (hi a)
let L : E3 βL[β] E3 := (LinearEquiv.ofInjectiveEndo (fderiv β F a).toLinearMap hdi).toContinuousLinearEquiv
have hL : (L : E3 βL[β] E3) = fderiv β F a := rfl
have hFd : HasFDerivAt F (L : E3 βL[β] E3) a := by
rw [hL]
exact (hF.differentiableAt (by simp)).hasFDerivAt
let e := hF.toOpenPartialHomeomorph F hFd (by simp)
have hea : a β e.source := hF.mem_toOpenPartialHomeomorph_source hFd (by simp)
let U := e.source β© f β»ΒΉ' c.source
have hU : IsOpen U := e.open_source.inter (c.open_source.preimage hf.continuous)
have ha : a β U := β¨hea,hcaβ©
let d := (e.trans c.symm).restr U
have heq : d.source = U := by
simp only [d,OpenPartialHomeomorph.restr_source,OpenPartialHomeomorph.trans_source,
hU.interior_eq]
ext y
constructor
Β· exact fun h => h.2
Β· intro hy
exact β¨β¨hy.1,c.map_source hy.2β©,hyβ©
have hequ : U.domRestrict f = d.source.domRestrict d β (Homeomorph.setCongr heq.symm) := by
funext y
change f y.1 = c.symm (c (f y.1))
exact (c.left_inv y.2.2).symm
refine β¨U,hU.mem_nhds ha,?_β©
rw [hequ]
exact d.isOpenEmbedding_restrict.comp (Homeomorph.setCongr heq.symm).isOpenEmbedding
variable [CompactSpace M] [T2Space M]
theorem exponential_isLocalHomeomorph (g : SmoothMetric M)
(hn : NoConjugatePoints g) (x : M) : IsLocalHomeomorph (exponential g x) :=
isLocalHomeomorph_of_mfderiv_injective (exponential_contMDiff g x)
(exponential_mfderiv_injective g hn x)
theorem npc_exponential_isLocalHomeomorph (g : SmoothMetric M)
(hn : NonpositiveSectionalCurvature g) (x : M) : IsLocalHomeomorph (exponential g x) :=
exponential_isLocalHomeomorph g (npc_noConjugatePoints g hn) x
end ThreeManifold.RiemannianCoordinates
end
section
open Set Filter Topology Bundle Manifold IsManifold MeasureTheory
open scoped ContDiff
namespace ThreeManifold.RiemannianCoordinates
variable {M : Type} [TopologicalSpace M] [ChartedSpace E3 M] [IsManifold I3 β M]
lemma metric_cauchy_schwarz (g : SmoothMetric M) (p : M)
(v w : TangentSpace I3 p) : g.inner p v w ^ 2 β€ g.inner p v v * g.inner p w w := by
have h (t : β) := inner_self_nonneg g p (v + t β’ w)
simp only [map_add,map_smul,_root_.add_apply,_root_.smul_apply,smul_eq_mul] at h
rw [g.symm p w v] at h
have hd := discrim_le_zero (a := g.inner p w w) (b := 2*g.inner p v w)
(c := g.inner p v v) (fun t => by nlinarith only [h t])
unfold discrim at hd
nlinarith only [hd]
def jacobiNorm (g : SmoothMetric M) (Ξ³ : β β M) (J : β t, TangentSpace I3 (Ξ³ t)) : β β β :=
fun t => Real.sqrt (jacobiNormSq g Ξ³ J t)
def jacobiRadialPairing (g : SmoothMetric M) (Ξ³ : β β M)
(J : β t, TangentSpace I3 (Ξ³ t)) (t : β) : β :=
g.inner (Ξ³ t) (covariantDerivative g Ξ³ J t) (J t)
lemma jacobiNorm_hasDerivAt (g : SmoothMetric M) {Ξ³ : β β M}
{J : β t, TangentSpace I3 (Ξ³ t)} {U : Set β} (hU : IsOpen U)
(hΞ³ : ContMDiffOn π(β,β) I3 β Ξ³ U) (hJ : IsJacobiFieldOn g Ξ³ J U)
{s : β} (hs : s β U) (hJs : J s β 0) :
HasDerivAt (jacobiNorm g Ξ³ J)
(jacobiRadialPairing g Ξ³ J s / jacobiNorm g Ξ³ J s) s := by
have hp : 0 < jacobiNormSq g Ξ³ J s := g.pos _ _ hJs
have hd := (jacobiNormSq_hasDerivAt g hU hΞ³ (jacobi_smoothField g hJ) hs).sqrt (ne_of_gt hp)
change HasDerivAt (fun t => Real.sqrt (jacobiNormSq g Ξ³ J t)) _ s
apply hd.congr_deriv
dsimp only [jacobiNormSqSlope,jacobiRadialPairing,jacobiNorm]
ring
lemma npc_jacobiNormSlope_hasDerivAt (g : SmoothMetric M)
(hn : NonpositiveSectionalCurvature g) {Ξ³ : β β M}
{J : β t, TangentSpace I3 (Ξ³ t)} {U : Set β} (hU : IsOpen U)
(hΞ³ : ContMDiffOn π(β,β) I3 β Ξ³ U) (hJ : IsJacobiFieldOn g Ξ³ J U)
{s : β} (hs : s β U) (hJs : J s β 0) :
β a : β, 0 β€ a β§ HasDerivAt (fun t => jacobiRadialPairing g Ξ³ J t / jacobiNorm g Ξ³ J t) a s := by
let A := jacobiRadialPairing g Ξ³ J s
let Q := jacobiNormSq g Ξ³ J s
let N := jacobiNorm g Ξ³ J s
let K := indexPairDensity g Ξ³ J J s
have hQ : 0 < Q := g.pos _ _ hJs
have hN : 0 < N := Real.sqrt_pos.mpr hQ
have hN2 : N^2 = Q := Real.sq_sqrt hQ.le
have hdA : HasDerivAt (jacobiRadialPairing g Ξ³ J) K s :=
jacobi_indexPairDensity_hasDerivAt g hU hΞ³ hJ (jacobi_smoothField g hJ) hs
have hdN := jacobiNorm_hasDerivAt g hU hΞ³ hJ hs hJs
refine β¨(K*N-A*(A/N))/N^2,?_,hdA.div hdN (ne_of_gt hN)β©
apply div_nonneg _ (sq_nonneg N)
have hcs := metric_cauchy_schwarz g (Ξ³ s) (covariantDerivative g Ξ³ J s) (J s)
have hc := curvatureAlong_pairing_nonpos g J (hΞ³.contMDiffAt (hU.mem_nhds hs))
(nonpositiveAt_of_nonpositive g hn _)
have hK : g.inner (Ξ³ s) (covariantDerivative g Ξ³ J s) (covariantDerivative g Ξ³ J s) β€ K := by
dsimp [K,indexPairDensity]
linarith only [hc]
have hmul := mul_le_mul_of_nonneg_right hK hQ.le
have hmain : A^2 β€ K*Q := hcs.trans hmul
have he : (K*N-A*(A/N))*N = K*Q-A^2 := by
rw [β hN2]
field_simp
exact (mul_nonneg_iff_of_pos_right hN).mp (by rw [he]; linarith only [hmain])
theorem npc_jacobiNorm_convex_Ici (g : SmoothMetric M)
(hn : NonpositiveSectionalCurvature g) {Ξ³ : β β M}
{J : β t, TangentSpace I3 (Ξ³ t)} (hΞ³ : ContMDiff π(β,β) I3 β Ξ³)
(hJ : IsJacobiFieldOn g Ξ³ J univ) (hpos : β t > 0, J t β 0) :
ConvexOn β (Ici 0) (jacobiNorm g Ξ³ J) := by
classical
have hc : Continuous (jacobiNorm g Ξ³ J) := by
apply Real.continuous_sqrt.comp
apply continuousOn_univ.mp
exact (intrinsic_pairing_smooth g isOpen_univ hΞ³.contMDiffOn
(jacobi_smoothField g hJ) (jacobi_smoothField g hJ)).continuousOn
have hd (s : β) (hs : s β interior (Ici (0:β))) :=
npc_jacobiNormSlope_hasDerivAt g hn isOpen_univ hΞ³.contMDiffOn hJ
(mem_univ s) (hpos s (by simpa only [interior_Ici,mem_Ioi] using hs))
choose a ha hda using hd
apply convexOn_of_hasDerivWithinAt2_nonneg (convex_Ici 0) hc.continuousOn
(f' := fun t => jacobiRadialPairing g Ξ³ J t / jacobiNorm g Ξ³ J t)
(f'' := fun s => if hs : s β interior (Ici (0:β)) then a s hs else 0)
Β· intro s hs
exact (jacobiNorm_hasDerivAt g isOpen_univ hΞ³.contMDiffOn hJ (mem_univ s)
(hpos s (by simpa only [interior_Ici,mem_Ioi] using hs))).hasDerivWithinAt
Β· intro s hs
simpa only [dite_eq_left hs] using (hda s hs).hasDerivWithinAt (s := interior (Ici (0:β)))
Β· intro s hs
simpa only [dite_eq_left hs] using ha s hs
lemma connectionTerm_zero_right (g : SmoothMetric M) (c : OpenPartialHomeomorph M E3)
(x v : E3) : connectionTerm g c x v 0 = 0 := by
ext i
simp only [connectionTerm,Pi.zero_apply,mul_zero,Finset.sum_const_zero]
lemma jacobiNorm_initial_rightDerivative (g : SmoothMetric M) {Ξ³ : β β M}
{J : β t, TangentSpace I3 (Ξ³ t)} (hΞ³ : ContMDiff π(β,β) I3 β Ξ³)
(hJ : SmoothFieldOn Ξ³ J univ) (h0 : J 0 = 0) :
HasDerivWithinAt (jacobiNorm g Ξ³ J)
(Real.sqrt (g.inner (Ξ³ 0) (covariantDerivative g Ξ³ J 0) (covariantDerivative g Ξ³ J 0)))
(Ioi 0) 0 := by
let c := chartAt E3 (Ξ³ 0)
let j := fieldCoordinates Ξ³ J c
let v := deriv j 0
have hc : c β atlas E3 M := chart_mem_atlas E3 (Ξ³ 0)
have hsc : Ξ³ 0 β c.source := mem_chart_source E3 (Ξ³ 0)
have hjs : ContDiffAt β β j 0 := smoothField_coordinatesAt isOpen_univ hΞ³.contMDiffOn hJ hc (mem_univ 0) hsc
have hz : j 0 = 0 := by simp only [j,fieldCoordinates,h0,map_zero]; rfl
have hdj : HasDerivAt j v 0 := (hjs.differentiableAt (by simp)).hasDerivAt
have hlimj : Tendsto (fun t : β => tβ»ΒΉ β’ j t) (π[>] 0) (π v) := by
simpa only [zero_add,hz,sub_zero] using hdj.tendsto_slope_zero_right
have hcov : fieldCoordinates Ξ³ (covariantDerivative g Ξ³ J) c 0 = v := by
rw [covariantDerivative_coordinates g hΞ³.contMDiffAt
(hjs.differentiableAt (by simp)) hc hsc]
change deriv j 0 + connectionTerm g c (c (Ξ³ 0)) (deriv (c β Ξ³) 0) (j 0) = v
rw [hz,connectionTerm_zero_right,add_zero]
have hB : ContinuousAt (fun t : β => chartBilin g c (c (Ξ³ t))) 0 := by
change ContinuousAt (chartBilin g c β (c β Ξ³)) 0
exact ContinuousAt.comp (f := c β Ξ³)
(chartBilin_smoothAt g hc (c.map_source hsc)).continuousAt
((c.continuousAt hsc).comp hΞ³.continuous.continuousAt)
have hlimB := hB.tendsto.mono_left (show π[>] (0:β) β€ π 0 from nhdsWithin_le_nhds)
have hcontβ : Continuous (fun p : (E3 βL[β] E3 βL[β] β) Γ E3 => p.1 p.2) :=
continuous_fst.clm_apply continuous_snd
have hlimβ := hcontβ.tendsto (chartBilin g c (c (Ξ³ 0)),v) |>.comp (hlimB.prodMk_nhds hlimj)
have hcontβ : Continuous (fun p : (E3 βL[β] β) Γ E3 => p.1 p.2) :=
continuous_fst.clm_apply continuous_snd
have hlimβ := hcontβ.tendsto (chartBilin g c (c (Ξ³ 0)) v,v) |>.comp (hlimβ.prodMk_nhds hlimj)
have hlim := Real.continuous_sqrt.tendsto (chartBilin g c (c (Ξ³ 0)) v v) |>.comp hlimβ
have hbase : chartBilin g c (c (Ξ³ 0)) v v =
g.inner (Ξ³ 0) (covariantDerivative g Ξ³ J 0) (covariantDerivative g Ξ³ J 0) := by
rw [β hcov]
exact metric_field_coordinates g _ _ hc hsc
rw [hbase] at hlim
apply (hasDerivWithinAt_iff_tendsto_slope' self_notMem_Ioi).mpr
apply hlim.congr'
have hnorm0 : jacobiNorm g Ξ³ J 0 = 0 := by
simp only [jacobiNorm,jacobiNormSq,h0,map_zero,Real.sqrt_zero]
have hsource : Ξ³ β»ΒΉ' c.source β π[>] (0:β) :=
nhdsWithin_le_nhds (hΞ³.continuous.continuousAt.preimage_mem_nhds (c.open_source.mem_nhds hsc))
filter_upwards [self_mem_nhdsWithin,hsource] with t ht htc
change Real.sqrt (chartBilin g c (c (Ξ³ t)) (tβ»ΒΉ β’ j t) (tβ»ΒΉ β’ j t)) = slope (jacobiNorm g Ξ³ J) 0 t
have hm : chartBilin g c (c (Ξ³ t)) (j t) (j t) = jacobiNormSq g Ξ³ J t :=
metric_field_coordinates g J J hc htc
simp only [map_smul,_root_.smul_apply,smul_eq_mul]
rw [β mul_assoc,β sq,hm,Real.sqrt_mul (sq_nonneg _),Real.sqrt_sq (inv_nonneg.mpr ht.le)]
rw [slope_def_field,hnorm0,sub_zero,sub_zero]
simp only [jacobiNorm,div_eq_mul_inv,mul_comm]
theorem npc_jacobiNorm_lower (g : SmoothMetric M) (hn : NonpositiveSectionalCurvature g)
{Ξ³ : β β M} {J : β t, TangentSpace I3 (Ξ³ t)}
(hΞ³ : IsGeodesicOn g Ξ³ univ) (hJ : IsJacobiFieldOn g Ξ³ J univ) (h0 : J 0 = 0)
{t : β} (ht : 0 β€ t) :
t * Real.sqrt (g.inner (Ξ³ 0) (covariantDerivative g Ξ³ J 0) (covariantDerivative g Ξ³ J 0)) β€
jacobiNorm g Ξ³ J t := by
by_cases hd : covariantDerivative g Ξ³ J 0 = 0
Β· simp only [hd,map_zero,Real.sqrt_zero,mul_zero]
exact Real.sqrt_nonneg _
have hpos : β s > (0:β), J s β 0 := by
intro s hs hsz
have hzero : β z : β, J z = 0 := fun z => npc_noConjugatePoints g hn univ isOpen_univ ordConnected_univ
Ξ³ hΞ³ J hJ 0 (mem_univ 0) s (mem_univ s) (ne_of_lt hs) h0 hsz z (mem_univ z)
apply hd
dsimp only [covariantDerivative,alongDerivative]
have hz : fieldCoordinates Ξ³ J (chartAt E3 (Ξ³ 0)) = fun _ => 0 := by
funext r; simp only [fieldCoordinates,hzero r,map_zero]; rfl
rw [hz,deriv_const,connectionTerm_zero_right,add_zero]
exact map_zero _
have hΞ³' : ContMDiff π(β,β) I3 β Ξ³ := contMDiffOn_univ.mp hΞ³.1
have hc := npc_jacobiNorm_convex_Ici g hn hΞ³' hJ hpos
have hnorm0 : jacobiNorm g Ξ³ J 0 = 0 := by
simp only [jacobiNorm,jacobiNormSq,h0,map_zero,Real.sqrt_zero]
rcases ht.eq_or_lt with rfl | ht
Β· simpa only [zero_mul,hnorm0] using (le_refl (0:β))
have he := hc.le_slope_of_hasDerivWithinAt_Ioi (show (0:β) β Ici 0 by simp)
ht.le ht (jacobiNorm_initial_rightDerivative g hΞ³' (jacobi_smoothField g hJ) h0)
simp only [slope_def_field,hnorm0,sub_zero] at he
simpa only [mul_comm] using (le_div_iffβ ht).mp he
end ThreeManifold.RiemannianCoordinates
end
section
open Set Filter Topology Bundle Manifold IsManifold
open scoped ContDiff
namespace ThreeManifold.RiemannianCoordinates
section
variable {M : Type} [TopologicalSpace M] [ChartedSpace E3 M] [IsManifold I3 β M]
variable [CompactSpace M] [T2Space M]
lemma exponentialVariation_initial_covariantDerivative (g : SmoothMetric M)
(x : M) (v b : E3) :
covariantDerivative g (geodesicFamily g (fiberPhase x) v)
(geodesicVariation g (fiberPhase x) v b) 0 = b := by
let f := fiberPhase x
let Ξ³ := geodesicFamily g f v
let J := geodesicVariation g f v b
let c := chartAt E3 x
let e := extChartAt I3.tangent (fiberPhase x v)
let z := fun t => e (geodesicFlow g (f v) t)
let w := fun t => fderiv β (fun y => e (geodesicFlow g (f y) t)) v b
have hf : ContMDiffAt π(β,E3) I3.tangent 1 f v :=
((fiberPhase_contMDiff x).of_le (by simp)).contMDiffAt
have hΞ³ := geodesicFamily_isGeodesic g f v
have hJ := geodesicVariation_isJacobi g hf b
have hbase : Ξ³ 0 = x := exponentialFamily_zero g x v
have hsource : Ξ³ 0 β c.source := hbase βΈ mem_chart_source E3 x
have hlin := geodesic_family_linearization_at g hf 0 b
simp only [geodesicFlow_zero] at hlin
obtain β¨U,hU,h0,hzt,hdz,hdwβ© := hlin
have he : fieldCoordinates Ξ³ J c =αΆ [π (0:β)] fun t => (w t).1 := by
filter_upwards [(hΞ³.1.contMDiffAt (by simp)).continuousAt.preimage_mem_nhds
(c.open_source.mem_nhds hsource)] with t ht
exact geodesicVariation_coordinates g hf b t (p := fiberPhase x v) ht
have hd : HasDerivAt (fieldCoordinates Ξ³ J c) (w 0).2 0 := by
have hd' := (hdw 0 h0).congr_deriv
(geodesicPhase_fderiv_apply g (chart_mem_atlas E3 x) (hzt 0 h0) (w 0))
have hh : HasDerivAt (fun t => (w t).1) (w 0).2 0 := hd'.fst
exact hh.congr_of_eventuallyEq he
have hi : w 0 = (0,mfderiv I3 I3 c x b) := by
dsimp only [w]
simp only [geodesicFlow_zero]
exact fiberPhase_extChart_fderiv x v b
have hcov := covariantDerivative_coordinates g (hΞ³.1.contMDiffAt (by simp))
((smoothField_coordinatesAt isOpen_univ hΞ³.1 (jacobi_smoothField g hJ)
(chart_mem_atlas E3 (Ξ³ 0)) (mem_univ 0) (mem_chart_source E3 (Ξ³ 0))).differentiableAt (by simp))
(chart_mem_atlas E3 x) hsource
have hz : fieldCoordinates Ξ³ J c 0 = 0 := by
change mfderiv I3 I3 c (Ξ³ 0) (J 0) = 0
rw [show J 0 = 0 from exponentialVariation_zero g x v b,map_zero]
change mfderiv I3 I3 c (Ξ³ 0) (covariantDerivative g Ξ³ J 0) = _ at hcov
rw [alongDerivative,hd.deriv,hi,hz,connectionTerm_zero_right,add_zero,hbase] at hcov
exact (mdifferentiable_of_mem_atlas (I := I3) (chart_mem_atlas E3 x)).mfderiv_injective
(mem_chart_source E3 x) hcov
theorem npc_exponential_differential_expanding (g : SmoothMetric M)
(hn : NonpositiveSectionalCurvature g) (x : M) (v b : E3) :
g.inner x b b β€ g.inner (exponential g x v)
(mfderiv π(β,E3) I3 (exponential g x) v b)
(mfderiv π(β,E3) I3 (exponential g x) v b) := by
have hf : ContMDiffAt π(β,E3) I3.tangent 1 (fiberPhase x) v :=
((fiberPhase_contMDiff x).of_le (by simp)).contMDiffAt
have h := npc_jacobiNorm_lower g hn (geodesicFamily_isGeodesic g (fiberPhase x) v)
(geodesicVariation_isJacobi g hf b) (exponentialVariation_zero g x v b) (t := 1) (by norm_num)
rw [exponentialVariation_initial_covariantDerivative,exponentialFamily_zero,one_mul] at h
change Real.sqrt (g.inner x b b) β€ Real.sqrt (g.inner (exponential g x v)
(mfderiv π(β,E3) I3 (exponential g x) v b) (mfderiv π(β,E3) I3 (exponential g x) v b)) at h
exact (Real.sqrt_le_sqrt_iff (inner_self_nonneg g _ _)).mp h
end
variable {M : Type} [TopologicalSpace M] [ChartedSpace E3 M] [IsManifold I3 β M]
lemma deriv_comp_mul {E : Type*} [NormedAddCommGroup E] [NormedSpace β E]
{f : β β E} {k t : β} (hf : DifferentiableAt β f (k*t)) :
deriv (fun r => f (k*r)) t = k β’ deriv f (k*t) := by
simpa only [Function.comp_def,mul_one] using (hf.hasDerivAt.scomp t ((hasDerivAt_id t).const_mul k)).deriv
lemma geodesic_scale (g : SmoothMetric M) {Ξ³ : β β M} {U : Set β}
(hU : IsOpen U) (hΞ³ : IsGeodesicOn g Ξ³ U) (k : β) :
IsGeodesicOn g (fun r => Ξ³ (k*r)) ((fun r => k*r) β»ΒΉ' U) := by
have htA : ContMDiff π(β,β) π(β,β) β (fun r : β => k*r) :=
contMDiff_iff_contDiff.mpr (contDiff_const.mul contDiff_id)
refine β¨hΞ³.1.comp htA.contMDiffOn (fun _ h => h),?_β©
intro c hc t ht hct
have hs := chartPhase_contDiffAt (hΞ³.1.contMDiffAt (hU.mem_nhds ht)) hc hct
have hn : βαΆ r in π t, k*r β U β§ Ξ³ (k*r) β c.source :=
continuousAt_const.mul continuousAt_id |>.preimage_mem_nhds
(Filter.Eventually.and (hU.mem_nhds ht)
((hΞ³.1.contMDiffAt (hU.mem_nhds ht)).continuousAt.preimage_mem_nhds
(c.open_source.mem_nhds hct)))
have hd : deriv (c β (fun r => Ξ³ (k*r))) =αΆ [π t] fun r => k β’ deriv (c β Ξ³) (k*r) := by
filter_upwards [hn] with r hr
exact deriv_comp_mul ((chartPhase_contDiffAt
(hΞ³.1.contMDiffAt (hU.mem_nhds hr.1)) hc hr.2).fst.differentiableAt (by simp))
have hdd : deriv (deriv (c β (fun r => Ξ³ (k*r)))) t = (k*k) β’ deriv (deriv (c β Ξ³)) (k*t) := by
rw [hd.deriv_eq]
change deriv (k β’ (fun r => deriv (c β Ξ³) (k*r))) t = _
have hdΞ³ : DifferentiableAt β (deriv (c β Ξ³)) (k*t) := hs.snd.differentiableAt (by simp)
rw [deriv_const_smul k,deriv_comp_mul hdΞ³,smul_smul]
exact hdΞ³.comp t (((hasDerivAt_id t).const_mul k).differentiableAt)
change _ + _ = 0
rw [hdd,hd.eq_of_nhds]
have hbil (u v : E3) : connectionTerm g c (c (Ξ³ (k*t))) (k β’ u) (k β’ v) =
(k*k) β’ connectionTerm g c (c (Ξ³ (k*t))) u v := by
simp only [β connectionBilin_apply,map_smul,_root_.smul_apply,smul_smul]
simp only [Function.comp_apply] at *
have hgeo := hΞ³.2 c hc (k*t) ht hct
change deriv (deriv (c β Ξ³)) (k*t) + connectionTerm g c (c (Ξ³ (k*t)))
(deriv (c β Ξ³) (k*t)) (deriv (c β Ξ³) (k*t)) = 0 at hgeo
rw [hbil,β smul_add,hgeo,smul_zero]
lemma geodesic_const (g : SmoothMetric M) (x : M) : IsGeodesicOn g (fun _ : β => x) univ := by
refine β¨contMDiff_const.contMDiffOn,?_β©
intro c hc t ht hxt
simp only [Function.comp_def,alongDerivative,deriv_const]
simp only [β connectionBilin_apply,map_zero]
simp [deriv_const]
variable [CompactSpace M] [T2Space M]
lemma exponential_zero (g : SmoothMetric M) (x : M) : exponential g x 0 = x := by
let Ξ³ := globalGeodesic g (fiberPhase x 0)
have hΞ³ := globalGeodesic_isGeodesic g (fiberPhase x 0)
have he : phaseLift Ξ³ 0 = phaseLift (fun _ : β => x) 0 := by
rw [globalGeodesic_initial]
unfold fiberPhase phaseLift velocity
rw [mfderiv_const]
rfl
exact geodesic_unique g isOpen_univ ordConnected_univ hΞ³ (geodesic_const g x)
(mem_univ 0) he (mem_univ 1)
lemma exponential_scale (g : SmoothMetric M) (x : M) (v : E3) (k : β) :
exponential g x (k β’ v) = globalGeodesic g (fiberPhase x v) k := by
let Ξ³ := globalGeodesic g (fiberPhase x v)
have hΞ³ := globalGeodesic_isGeodesic g (fiberPhase x v)
have hk : IsGeodesicOn g (fun r => Ξ³ (k*r)) univ := by
simpa only [preimage_univ] using geodesic_scale g isOpen_univ hΞ³ k
have he : phaseLift (globalGeodesic g (fiberPhase x (k β’ v))) 0 =
phaseLift (fun r => Ξ³ (k*r)) 0 := by
rw [globalGeodesic_initial]
have hbase : Ξ³ (k*0) = x := by
change globalGeodesic g (fiberPhase x v) (k*0) = x
rw [mul_zero]
exact congrArg Bundle.TotalSpace.proj (globalGeodesic_initial g (fiberPhase x v))
apply Bundle.TotalSpace.ext hbase.symm
apply heq_of_eq
change k β’ v = mfderiv π(β,β) I3 (fun r => Ξ³ (k*r)) 0 1
have hc := mfderiv_comp 0 ((hΞ³.1.contMDiffAt (by simp)).mdifferentiableAt (by simp))
((contMDiff_iff_contDiff.mpr (contDiff_const.mul contDiff_id) :
ContMDiff π(β,β) π(β,β) β (fun r : β => k*r)).mdifferentiable (by simp) 0)
have hmul : mfderiv π(β,β) π(β,β) (fun r : β => k*r) 0 1 = k := by
rw [mfderiv_eq_fderiv]
change deriv (fun r : β => k*r) 0 = k
simpa only [mul_one,id_eq] using ((hasDerivAt_id (0:β)).const_mul k).deriv
have hv : (velocity Ξ³ 0 : E3) = v := congrArg
(fun p : TangentBundle I3 M => (p.snd : E3)) (globalGeodesic_initial g (fiberPhase x v))
have hh := congrArg (fun L : β βL[β] E3 => L 1) hc
change mfderiv π(β,β) I3 (fun r => Ξ³ (k*r)) 0 1 =
mfderiv π(β,β) I3 Ξ³ (k*0) (mfderiv π(β,β) π(β,β) (fun r : β => k*r) 0 1) at hh
rw [hmul,mul_zero] at hh
have hsm : (mfderiv π(β,β) I3 Ξ³ 0 k : E3) = k β’ (velocity Ξ³ 0 : E3) := by
unfold velocity
let L : β βL[β] E3 := mfderiv π(β,β) I3 Ξ³ 0
change L k = k β’ L 1
have hL := L.map_smul k (1:β)
simp only [smul_eq_mul,mul_one] at hL
exact hL
exact ((congrArg (fun w : E3 => k β’ w) hv).symm.trans hsm.symm).trans hh.symm
have hh := geodesic_unique g isOpen_univ ordConnected_univ
(globalGeodesic_isGeodesic g (fiberPhase x (k β’ v))) hk (mem_univ 0) he (mem_univ 1)
change globalGeodesic g (fiberPhase x (k β’ v)) 1 = globalGeodesic g (fiberPhase x v) k
simpa only [mul_one] using hh
end ThreeManifold.RiemannianCoordinates
end
open Set Filter Topology Bundle Manifold IsManifold
open scoped ContDiff
namespace ThreeManifold.RiemannianCoordinates
variable {M : Type} [TopologicalSpace M] [ChartedSpace E3 M] [IsManifold I3 β M]
lemma curvatureAlong_velocity_pairing (g : SmoothMetric M) {Ξ³ : β β M}
(J : β s, TangentSpace I3 (Ξ³ s)) {s : β}
(hΞ³ : ContMDiffAt π(β,β) I3 β Ξ³ s) :
g.inner (Ξ³ s) (curvatureAlong g Ξ³ J s) (velocity Ξ³ s) = 0 := by
let c := chartAt E3 (Ξ³ s)
have hc := chart_mem_atlas E3 (Ξ³ s)
have hx := mem_chart_source E3 (Ξ³ s)
rw [β metric_field_coordinates g (curvatureAlong g Ξ³ J) (velocity Ξ³) hc hx,
curvatureAlong_coordinates g J hΞ³ hc hx,velocity_coordinates hΞ³ hc hx]
have h := curvature_pairing_skew g hc (c.map_source hx)
(fieldCoordinates Ξ³ J c s) (deriv (c β Ξ³) s) (deriv (c β Ξ³) s) (deriv (c β Ξ³) s)
rw [chartBilin_symm g c] at h
rw [chartBilin_symm g (chartAt E3 (Ξ³ s))]
change _ + _ = 0 at h
linarith
lemma jacobi_velocity_pairing (g : SmoothMetric M) {Ξ³ : β β M}
(hΞ³ : IsGeodesicOn g Ξ³ univ) {J : β s, TangentSpace I3 (Ξ³ s)}
(hJ : IsJacobiFieldOn g Ξ³ J univ) (h0 : J 0 = 0) (s : β) :
g.inner (Ξ³ s) (J s) (velocity Ξ³ s) =
s * g.inner (Ξ³ 0) (covariantDerivative g Ξ³ J 0) (velocity Ξ³ 0) := by
let D := covariantDerivative g Ξ³ J
have hD := covariantDerivative_smooth g isOpen_univ hΞ³.1 (jacobi_smoothField g hJ)
have hd (t : β) : HasDerivAt (fun r => g.inner (Ξ³ r) (D r) (velocity Ξ³ r)) 0 t := by
have h := intrinsic_pairing_hasDerivAt g isOpen_univ hΞ³.1 hD
(velocity_smooth isOpen_univ hΞ³.1) (mem_univ t)
have he := jacobi_intrinsic_equation g isOpen_univ hΞ³.1 hJ (mem_univ t)
change covariantDerivative g Ξ³ D t + curvatureAlong g Ξ³ J t = 0 at he
have he' := eq_neg_of_add_eq_zero_left he
dsimp only [D] at he'
simpa only [he',geodesic_acceleration_zero g isOpen_univ hΞ³ (mem_univ t),map_zero,
map_neg,_root_.neg_apply,curvatureAlong_velocity_pairing g J (hΞ³.1.contMDiffAt (by simp)),
neg_zero,add_zero] using h
have hconst (t : β) : g.inner (Ξ³ t) (D t) (velocity Ξ³ t) = g.inner (Ξ³ 0) (D 0) (velocity Ξ³ 0) :=
isOpen_univ.is_const_of_deriv_eq_zero (convex_univ : Convex β (univ : Set β)).isPreconnected
(fun t _ => (hd t).differentiableAt.differentiableWithinAt)
(fun t _ => (hd t).deriv) (mem_univ t) (mem_univ 0)
have hp (t : β) : HasDerivAt (fun r => g.inner (Ξ³ r) (J r) (velocity Ξ³ r))
(g.inner (Ξ³ 0) (D 0) (velocity Ξ³ 0)) t := by
have h := intrinsic_pairing_hasDerivAt g isOpen_univ hΞ³.1 (jacobi_smoothField g hJ)
(velocity_smooth isOpen_univ hΞ³.1) (mem_univ t)
simp only [geodesic_acceleration_zero g isOpen_univ hΞ³ (mem_univ t),map_zero,add_zero] at h
exact h.congr_deriv (hconst t)
have hh := isOpen_univ.eqOn_of_deriv_eq (convex_univ : Convex β (univ : Set β)).isPreconnected
(fun t _ => (hp t).differentiableAt.differentiableWithinAt)
((differentiable_id.mul_const (g.inner (Ξ³ 0) (D 0) (velocity Ξ³ 0))).differentiableOn)
(fun t _ => by rw [(hp t).deriv]; simp)
(mem_univ 0) (by simp only [h0,map_zero,_root_.zero_apply,zero_mul,id_eq])
exact hh (mem_univ s)
variable [CompactSpace M] [T2Space M]
lemma exponential_radial_differential (g : SmoothMetric M) (p : M) (v : E3) :
mfderiv π(β,E3) I3 (exponential g p) v v = velocity (globalGeodesic g (fiberPhase p v)) 1 := by
have he : (fun t : β => exponential g p (t β’ v)) = globalGeodesic g (fiberPhase p v) :=
funext (exponential_scale g p v)
have hh := mfderiv_comp (I := π(β,β)) (I' := π(β,E3)) (I'' := I3)
(f := fun t : β => t β’ v) (g := exponential g p) (1:β)
((exponential_contMDiff g p).mdifferentiable (by simp) (1 β’ v))
((contDiff_id.smul contDiff_const : ContDiff β 1 (fun t : β => t β’ v)).differentiable (by simp) 1).mdifferentiableAt
have h := congrArg (fun L : β βL[β] E3 => L 1) hh
simp only [Function.comp_def] at h
rw [he] at h
have hd : mfderiv π(β,β) π(β,E3) (fun t : β => t β’ v) 1 1 = v := by
rw [mfderiv_eq_fderiv]
change deriv (fun t : β => t β’ v) 1 = v
simpa using ((hasDerivAt_id (1:β)).smul_const v).deriv
change velocity (globalGeodesic g (fiberPhase p v)) 1 =
mfderiv π(β,E3) I3 (exponential g p) (1 β’ v)
(mfderiv π(β,β) π(β,E3) (fun t : β => t β’ v) 1 1) at h
rw [hd,one_smul] at h
exact h.symm
theorem exponential_gauss (g : SmoothMetric M) (p : M) (v b : E3) :
g.inner (exponential g p v) (mfderiv π(β,E3) I3 (exponential g p) v b)
(mfderiv π(β,E3) I3 (exponential g p) v v) = g.inner p b v := by
have hf := ((fiberPhase_contMDiff p).of_le (show (1 : WithTop ββ) β€ β by simp)).contMDiffAt (x := v)
have hh := jacobi_velocity_pairing g (geodesicFamily_isGeodesic g (fiberPhase p) v)
(geodesicVariation_isJacobi g hf b) (exponentialVariation_zero g p v b) 1
rw [exponentialVariation_initial_covariantDerivative,exponentialFamily_zero,one_mul] at hh
have hv : (velocity (geodesicFamily g (fiberPhase p) v) 0 : E3) = v :=
congrArg (fun q : TangentBundle I3 M => (q.snd : E3)) (globalGeodesic_initial g (fiberPhase p v))
rw [hv] at hh
rw [exponential_radial_differential]
exact hh
end ThreeManifold.RiemannianCoordinates
end
end OAI
import OAI.Geometry.ConjugatePoints.Index
import OAI.Geometry.ConjugatePoints.Curvature
namespace OAI
noncomputable section
/-!
# Geodesic flow, variation equations, and the Gauss lemma.
-/
section
open Set Filter Topology Asymptotics
open scoped NNReal
namespace ThreeManifold.ODEVariation
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace β E]
lemma remainder_bound {f : E β E} {D : E β E βL[β] E}
{u v : β β E} {A : β β E βL[β] E} {x y : E} {a b K C L : β}
(hK : 0 < K) (hC : 0 β€ C) (_hL : 0 β€ L)
(hu : β t β Icc a b, HasDerivAt u (f (u t)) t)
(hv : β t β Icc a b, HasDerivAt v (f (v t)) t)
(hA : β t β Icc a b, β z, HasDerivAt (fun s => A s z) (D (u t) (A t z)) t)
(hua : u a = x) (hva : v a = y) (hAa : A a = ContinuousLinearMap.id β E)
(hD : β t β Icc a b, βD (u t)β β€ K)
(hLip : β t β Icc a b, βv t - u tβ β€ L * βy-xβ)
(hTaylor : β t β Icc a b,
βf (v t) - f (u t) - D (u t) (v t-u t)β β€ C * βv t-u tβ ^ 2) :
β t β Icc a b,
βv t - u t - A t (y-x)β β€
(C * L^2 / K * (Real.exp (K * (t-a))-1)) * βy-xβ^2 := by
intro t ht
let R : β β E := fun s => v s-u s-A s (y-x)
let R' : β β E := fun s => f (v s)-f (u s)-D (u s) (A s (y-x))
have hd : β s β Icc a b, HasDerivAt R (R' s) s := fun s hs =>
((hv s hs).sub (hu s hs)).sub (hA s hs (y-x))
have hb : β s β Ico a b, βR' sβ β€ K * βR sβ + C*L^2*βy-xβ^2 := by
intro s hs
have hsc := Ico_subset_Icc_self hs
have he : R' s = D (u s) (R s) +
(f (v s)-f (u s)-D (u s) (v s-u s)) := by
simp only [R', R, map_sub]
abel
rw [he]
calc
_ β€ βD (u s) (R s)β + βf (v s)-f (u s)-D (u s) (v s-u s)β := norm_add_le _ _
_ β€ K * βR sβ + C * βv s-u sβ^2 := add_le_add
((D (u s)).le_opNorm _ |>.trans (mul_le_mul_of_nonneg_right (hD s hsc) (norm_nonneg _)))
(hTaylor s hsc)
_ β€ K * βR sβ + C*L^2*βy-xβ^2 := by
have hh : βv s-u sβ^2 β€ (L*βy-xβ)^2 :=
pow_le_pow_leftβ (norm_nonneg _) (hLip s hsc) 2
nlinarith [mul_le_mul_of_nonneg_left hh hC]
have hr := norm_le_gronwallBound_of_norm_deriv_right_le
(f := R) (f' := R') (K := K) (Ξ΅ := C*L^2*βy-xβ^2) (Ξ΄ := 0)
(fun s hs => (hd s hs).continuousAt.continuousWithinAt)
(fun s hs => (hd s (Ico_subset_Icc_self hs)).hasDerivWithinAt)
(by simp [R,hua,hva,hAa]) hb t ht
dsimp [gronwallBound] at hr
rw [ite_eq_right hK.ne', zero_mul, zero_add] at hr
change βR tβ β€ _
convert hr using 1 ; ring
lemma hasFDerivAt_of_quadratic_error {F : E β E} {A : E βL[β] E} {x : E}
{Q : β} (h : βαΆ y in π x, βF y-F x-A (y-x)β β€ Q*βy-xβ^2) :
HasFDerivAt F A x := by
rw [hasFDerivAt_iff_isLittleO]
have hb : (fun y => F y-F x-A (y-x)) =O[π x] (fun y => βy-xβ^2) := by
apply isBigO_iff.mpr
refine β¨Q,?_β©
filter_upwards [h] with y hy
simpa only [Real.norm_eq_abs, abs_of_nonneg (sq_nonneg βy-xβ)] using hy
exact hb.trans_isLittleO (isLittleO_pow_sub_sub x (by norm_num : 1 < (2 : β)))
lemma flow_hasFDerivAt {f : E β E} {D : E β E βL[β] E}
{X : E β β β E} {A : β β E βL[β] E} {x : E} {a b K C L : β}
(hK : 0 < K) (hC : 0 β€ C) (hL : 0 β€ L)
(hx : β t β Icc a b, HasDerivAt (X x) (f (X x t)) t)
(hA : β t β Icc a b, β z,
HasDerivAt (fun s => A s z) (D (X x t) (A t z)) t)
(hxa : X x a = x) (hAa : A a = ContinuousLinearMap.id β E)
(hD : β t β Icc a b, βD (X x t)β β€ K)
(hnear : βαΆ y in π x, X y a = y β§
(β t β Icc a b, HasDerivAt (X y) (f (X y t)) t) β§
(β t β Icc a b, βX y t-X x tβ β€ L*βy-xβ) β§
(β t β Icc a b, βf (X y t)-f (X x t)-D (X x t) (X y t-X x t)β β€
C*βX y t-X x tβ^2)) {t : β} (ht : t β Icc a b) :
HasFDerivAt (fun y => X y t) (A t) x := by
apply hasFDerivAt_of_quadratic_error (Q := C*L^2/K*(Real.exp (K*(t-a))-1))
filter_upwards [hnear] with y hy
exact remainder_bound hK hC hL hx hy.2.1 hA hxa hy.1 hAa hD hy.2.2.1 hy.2.2.2 t ht
lemma quadratic_taylor {f : E β E} {S : Set E} {C : ββ₯0}
(hS : Convex β S) (hf : β z β S, DifferentiableAt β f z)
(hD : LipschitzOnWith C (fderiv β f) S) {x y : E} (hx : x β S) (hy : y β S) :
βf y-f x-fderiv β f x (y-x)β β€ C*βy-xβ^2 := by
have hseg := hS.segment_subset hx hy
have hd : β z β segment β x y, βfderiv β f z-fderiv β f xβ β€ C*βy-xβ := by
intro z hz