Blame for lean/OAI/Geometry/ConjugatePoints/Distance.lean

import OAI.Geometry.ConjugatePoints.Continuation

namespace OAI

noncomputable section

/-!
# Riemannian distance and the nonpositively curved universal-cover metric.
-/

section
open Set Filter Topology Bundle Manifold MeasureTheory
open scoped ContDiff ENNReal NNReal
namespace ThreeManifold.RiemannianDistance

section

lemma edist_finite_of_preconnected {X : Type*} [PseudoEMetricSpace X] [PreconnectedSpace X]
    (x y : X) : edist x y ≠ ⊤ := by
  let S := {z : X | edist x z ≠ ⊤}
  have hopen : IsOpen S := by
    apply EMetric.isOpen_iff.mpr
    intro z hz
    refine ⟨1,by norm_num,fun w hw => ?_⟩
    have hwz : edist z w ≠ ⊤ := ne_top_of_lt (by simpa only [edist_comm] using (Metric.mem_eball.mp hw))
    exact ne_top_of_le_ne_top (ENNReal.add_ne_top.mpr ⟨hz,hwz⟩) (edist_triangle x z w)
  have hcomp : IsOpen Sᶜ := by
    apply EMetric.isOpen_iff.mpr
    intro z hz
    refine ⟨1,by norm_num,fun w hw => ?_⟩
    intro hwS
    have hwz : edist w z ≠ ⊤ := ne_top_of_lt (Metric.mem_eball.mp hw)
    exact hz (ne_top_of_le_ne_top (ENNReal.add_ne_top.mpr ⟨hwS,hwz⟩) (edist_triangle x w z))
  have he : S = univ := (show IsClopen S from ⟨by simpa only [compl_compl] using hcomp.isClosed_compl,hopen⟩).eq_univ
    ⟨x,by simp [S]⟩
  have : y ∈ S := he ▸ mem_univ y
  exact this

variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
local notation "I" => 𝓘(ℝ,E)

abbrev metricSpace (g : ContinuousRiemannianMetric E (TangentSpace 𝓘(ℝ,E) : E → Type _)) : MetricSpace E :=
  letI : RiemannianBundle (TangentSpace 𝓘(ℝ,E) : E → Type _) := ⟨g.toRiemannianMetric⟩
  letI : EMetricSpace E := .ofRiemannianMetric I E
  EMetricSpace.toMetricSpace (edist_finite_of_preconnected)

variable (g : ContinuousRiemannianMetric E (TangentSpace 𝓘(ℝ,E) : E → Type _))

lemma tangent_enorm (x : E) (v : TangentSpace 𝓘(ℝ,E) x) :
    letI : RiemannianBundle (TangentSpace 𝓘(ℝ,E) : E → Type _) := ⟨g.toRiemannianMetric⟩
    ‖v‖ₑ = ENNReal.ofReal (Real.sqrt (g.inner x v v)) := by
  let : RiemannianBundle (TangentSpace 𝓘(ℝ,E) : E → Type _) := ⟨g.toRiemannianMetric⟩
  rw [← ofReal_norm,norm_eq_sqrt_real_inner]
  rfl

lemma norm_sub_le_pathELength (R : ℝ≥0)
    (hR : ∀ (x : E) (v : E), ‖v‖ ≤ R * Real.sqrt (g.inner x v v))
    {γ : ℝ → E} {a b : ℝ} (hγ : ContDiffOn ℝ 1 γ (Icc a b)) (hab : a ≤ b) :
    letI : RiemannianBundle (TangentSpace 𝓘(ℝ,E) : E → Type _) := ⟨g.toRiemannianMetric⟩
    ‖γ b - γ a‖ₑ ≤ (R : ℝ≥0∞) * pathELength I γ a b := by
  let : RiemannianBundle (TangentSpace 𝓘(ℝ,E) : E → Type _) := ⟨g.toRiemannianMetric⟩
  apply (enorm_sub_le_lintegral_deriv_of_contDiffOn_Icc hγ hab).trans
  rw [pathELength_eq_lintegral_mfderiv_Icc,← lintegral_const_mul' _ _ ENNReal.coe_ne_top]
  apply lintegral_mono
  intro t
  have h := ENNReal.ofReal_le_ofReal (hR (γ t) (deriv γ t))
  rw [ENNReal.ofReal_mul R.coe_nonneg] at h
  have hv : (mfderiv 𝓘(ℝ,ℝ) 𝓘(ℝ,E) γ t 1 : E) = deriv γ t := by
    rw [mfderiv_eq_fderiv]
    rfl
  have hx := congrArg (fun v : E => g.inner (γ t) v v) hv
  dsimp only
  rw [tangent_enorm g]
  rw [hx]
  simpa only [ofReal_norm,ENNReal.ofReal_coe_nnreal] using h

lemma norm_sub_le_riemannianEDist (R : ℝ≥0) (hRp : 0 < R)
    (hR : ∀ (x : E) (v : E), ‖v‖ ≤ R * Real.sqrt (g.inner x v v)) (x y : E) :
    letI : RiemannianBundle (TangentSpace 𝓘(ℝ,E) : E → Type _) := ⟨g.toRiemannianMetric⟩
    ‖y-x‖ₑ ≤ (R : ℝ≥0∞) * riemannianEDist I x y := by
  let : RiemannianBundle (TangentSpace 𝓘(ℝ,E) : E → Type _) := ⟨g.toRiemannianMetric⟩
  rw [mul_comm]
  apply (ENNReal.div_le_iff (by exact_mod_cast hRp.ne') ENNReal.coe_ne_top).mp
  apply le_of_forall_gt
  intro r hr
  obtain ⟨γ,h0,h1,hγ,hlen⟩ := exists_lt_of_riemannianEDist_lt hr
  have hb := norm_sub_le_pathELength g R hR (contMDiffOn_iff_contDiffOn.mp hγ) (by norm_num : (0:ℝ) ≤ 1)
  rw [h0,h1,mul_comm] at hb
  exact ((ENNReal.div_le_iff (by exact_mod_cast hRp.ne') ENNReal.coe_ne_top).mpr hb).trans_lt hlen

lemma norm_sub_le_dist (R : ℝ≥0) (hRp : 0 < R)
    (hR : ∀ (x : E) (v : E), ‖v‖ ≤ R * Real.sqrt (g.inner x v v)) (x y : E) :
    ‖y-x‖ ≤ R * @dist E (metricSpace g).toPseudoMetricSpace.toDist x y := by
  have h := norm_sub_le_riemannianEDist g R hRp hR x y
  let : RiemannianBundle (TangentSpace 𝓘(ℝ,E) : E → Type _) := ⟨g.toRiemannianMetric⟩
  let : MetricSpace E := metricSpace g
  have hh : ‖y-x‖ₑ ≤ (R : ℝ≥0∞) * edist x y := h
  have hh' := ENNReal.toReal_mono (ENNReal.mul_ne_top ENNReal.coe_ne_top (@edist_ne_top E (metricSpace g).toPseudoMetricSpace x y)) hh
  rw [ENNReal.toReal_mul,ENNReal.coe_toReal,toReal_enorm] at hh'
  rw [@edist_dist E (metricSpace g).toPseudoMetricSpace,
    ENNReal.toReal_ofReal (@dist_nonneg E (metricSpace g).toPseudoMetricSpace x y)] at hh'
  exact hh'

theorem properSpace [ProperSpace E] (R : ℝ≥0) (hRp : 0 < R)
    (hR : ∀ (x : E) (v : E), ‖v‖ ≤ R * Real.sqrt (g.inner x v v)) :
    @ProperSpace E (metricSpace g).toPseudoMetricSpace := by
  have hc (x : E) (r : ℝ) : IsCompact {y : E | ‖y-x‖ ≤ R*r} := by
    simpa only [Metric.closedBall,dist_eq_norm] using isCompact_closedBall x ((R:ℝ)*r)
  let : PseudoMetricSpace E := (metricSpace g).toPseudoMetricSpace
  constructor
  intro x r
  apply (hc x r).of_isClosed_subset Metric.isClosed_closedBall
  intro y hy
  exact (norm_sub_le_dist g R hRp hR x y).trans
    (mul_le_mul_of_nonneg_left (by simpa only [Metric.mem_closedBall,dist_comm] using hy) R.coe_nonneg)
end

variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
variable (g : ContinuousRiemannianMetric E (TangentSpace 𝓘(ℝ,E) : E → Type _))

lemma pathELength_comp_eq {f : E → E} (hf : ContDiff ℝ 1 f)
    (hi : ∀ (x u v : E), g.inner (f x) (fderiv ℝ f x u) (fderiv ℝ f x v) = g.inner x u v)
    {γ : ℝ → E} {a b : ℝ} (hγ : ContDiffOn ℝ 1 γ (Icc a b)) :
    letI : RiemannianBundle (TangentSpace 𝓘(ℝ,E) : E → Type _) := ⟨g.toRiemannianMetric⟩
    pathELength 𝓘(ℝ,E) (f ∘ γ) a b = pathELength 𝓘(ℝ,E) γ a b := by
  let : RiemannianBundle (TangentSpace 𝓘(ℝ,E) : E → Type _) := ⟨g.toRiemannianMetric⟩
  simp only [pathELength_eq_lintegral_mfderiv_Ioo]
  apply setLIntegral_congr_fun measurableSet_Ioo
  intro t ht
  have hγt := (hγ.contDiffAt (Icc_mem_nhds ht.1 ht.2)).differentiableAt (by simp)
  dsimp only
  rw [tangent_enorm g,tangent_enorm g]
  have hv : (mfderiv 𝓘(ℝ,ℝ) 𝓘(ℝ,E) (f ∘ γ) t 1 : E) =
      fderiv ℝ f (γ t) (mfderiv 𝓘(ℝ,ℝ) 𝓘(ℝ,E) γ t 1 : E) := by
    rw [mfderiv_eq_fderiv,mfderiv_eq_fderiv,fderiv_comp t
      (hf.differentiable (by simp) (γ t)) hγt]
    rfl
  apply congrArg (ENNReal.ofReal ∘ Real.sqrt)
  calc
    _ = g.inner (f (γ t))
        (fderiv ℝ f (γ t) (mfderiv 𝓘(ℝ,ℝ) 𝓘(ℝ,E) γ t 1 : E))
        (fderiv ℝ f (γ t) (mfderiv 𝓘(ℝ,ℝ) 𝓘(ℝ,E) γ t 1 : E)) :=
      congrArg₂ (fun u v : E => g.inner (f (γ t)) u v) hv hv
    _ = _ := hi _ _ _

lemma riemannianEDist_map_le {f : E → E} (hf : ContDiff ℝ 1 f)
    (hi : ∀ (x u v : E), g.inner (f x) (fderiv ℝ f x u) (fderiv ℝ f x v) = g.inner x u v)
    (x y : E) :
    letI : RiemannianBundle (TangentSpace 𝓘(ℝ,E) : E → Type _) := ⟨g.toRiemannianMetric⟩
    riemannianEDist 𝓘(ℝ,E) (f x) (f y) ≤ riemannianEDist 𝓘(ℝ,E) x y := by
  let : RiemannianBundle (TangentSpace 𝓘(ℝ,E) : E → Type _) := ⟨g.toRiemannianMetric⟩
  apply le_of_forall_gt
  intro r hr
  obtain ⟨γ,h0,h1,hγ,hlen⟩ := exists_lt_of_riemannianEDist_lt hr
  have hc := hf.contMDiff.comp_contMDiffOn hγ
  have hl := riemannianEDist_le_pathELength (I := 𝓘(ℝ,E)) hc rfl rfl (by norm_num : (0:ℝ) ≤ 1)
  simp only [Function.comp_apply,h0,h1] at hl
  rw [pathELength_comp_eq g hf hi (contMDiffOn_iff_contDiffOn.mp hγ)] at hl
  exact hl.trans_lt hlen

theorem isometry_of_inner (f : E ≃ E) (hf : ContDiff ℝ 1 f) (hfi : ContDiff ℝ 1 f.symm)
    (hi : ∀ (x u v : E), g.inner (f x) (fderiv ℝ f x u) (fderiv ℝ f x v) = g.inner x u v)
    (hii : ∀ (x u v : E), g.inner (f.symm x) (fderiv ℝ f.symm x u) (fderiv ℝ f.symm x v) = g.inner x u v) :
    @Isometry E E (metricSpace g).toPseudoEMetricSpace (metricSpace g).toPseudoEMetricSpace f := by
  have hle := riemannianEDist_map_le g hf hi
  have hlei := riemannianEDist_map_le g hfi hii
  let : MetricSpace E := metricSpace g
  intro x y
  apply le_antisymm (hle x y)
  simpa only [Equiv.symm_apply_apply] using hlei (f x) (f y)
end ThreeManifold.RiemannianDistance
end

section
open Set Filter Topology Bundle Manifold IsManifold Bornology
open scoped ContDiff
namespace ThreeManifold.MetricConstruction
variable {E F M N : Type*}
  [NormedAddCommGroup E] [NormedSpace ℝ E]
  [NormedAddCommGroup F] [NormedSpace ℝ F]
  [TopologicalSpace M] [ChartedSpace E M] [IsManifold 𝓘(ℝ,E) ∞ M]
  [TopologicalSpace N] [ChartedSpace F N] [IsManifold 𝓘(ℝ,F) ∞ N]
lemma flip_contAt {X G A B C : Type*}
    [NormedAddCommGroup X] [NormedSpace ℝ X] [TopologicalSpace G] [ChartedSpace X G]
    [NormedAddCommGroup A] [NormedSpace ℝ A] [NormedAddCommGroup B] [NormedSpace ℝ B]
    [NormedAddCommGroup C] [NormedSpace ℝ C]
    {f : G → A →L[ℝ] B →L[ℝ] C} {x : G}
    (hf : ContMDiffAt 𝓘(ℝ,X) 𝓘(ℝ,A →L[ℝ] B →L[ℝ] C) 0 f x) :
    ContMDiffAt 𝓘(ℝ,X) 𝓘(ℝ,B →L[ℝ] A →L[ℝ] C) 0 (fun y => (f y).flip) x := by
  let : NormedAddCommGroup (B →L[ℝ] C) := ContinuousLinearMap.toNormedAddCommGroup
  let : NormedSpace ℝ (B →L[ℝ] C) := ContinuousLinearMap.toNormedSpace
  let : NormedAddCommGroup (A →L[ℝ] B →L[ℝ] C) := ContinuousLinearMap.toNormedAddCommGroup
  let : NormedSpace ℝ (A →L[ℝ] B →L[ℝ] C) := ContinuousLinearMap.toNormedSpace
  let : NormedAddCommGroup (A →L[ℝ] C) := ContinuousLinearMap.toNormedAddCommGroup
  let : NormedSpace ℝ (A →L[ℝ] C) := ContinuousLinearMap.toNormedSpace
  let : NormedAddCommGroup (B →L[ℝ] A →L[ℝ] C) := ContinuousLinearMap.toNormedAddCommGroup
  let : NormedSpace ℝ (B →L[ℝ] A →L[ℝ] C) := ContinuousLinearMap.toNormedSpace
  have hc : ContDiff ℝ 0 (fun L : A →L[ℝ] B →L[ℝ] C => L.flip) :=
    (ContinuousLinearMap.flipₗᵢ ℝ A B C).toContinuousLinearEquiv.contDiff
  exact hc.comp_contMDiffAt hf

lemma bilin_comp_contAt {X G H : Type*}
    [NormedAddCommGroup X] [NormedSpace ℝ X] [TopologicalSpace G] [ChartedSpace X G]
    [NormedAddCommGroup H] [NormedSpace ℝ H]
    {q : G → F →L[ℝ] F →L[ℝ] ℝ} {L : G → H →L[ℝ] F} {x : G}
    (hq : ContMDiffAt 𝓘(ℝ,X) 𝓘(ℝ,F →L[ℝ] F →L[ℝ] ℝ) 0 q x)
    (hL : ContMDiffAt 𝓘(ℝ,X) 𝓘(ℝ,H →L[ℝ] F) 0 L x) :
    ContMDiffAt 𝓘(ℝ,X) 𝓘(ℝ,H →L[ℝ] H →L[ℝ] ℝ) 0
      (fun y => (q y).bilinearComp (L y) (L y)) x := by
  exact flip_contAt ((flip_contAt (hq.clm_comp hL)).clm_comp hL)

lemma pullback_inner_contAt (g : Metric (E := F) N) {f : M → N}
    {x : M} (hf : ContMDiffAt 𝓘(ℝ,E) 𝓘(ℝ,F) 1 f x) :
    ContMDiffAt 𝓘(ℝ,E) (𝓘(ℝ,E).prod 𝓘(ℝ,E →L[ℝ] E →L[ℝ] ℝ)) 0
      (fun x => TotalSpace.mk' (E →L[ℝ] E →L[ℝ] ℝ)
        (E := fun y => TangentSpace 𝓘(ℝ,E) y →L[ℝ] TangentSpace 𝓘(ℝ,E) y →L[ℝ] ℝ)
        x (pullInner g f x)) x := by
  rw [contMDiffAt_section]
  have hg := g.contMDiff (f x)
  rw [contMDiffAt_section] at hg
  simp only [hom_trivializationAt_apply] at hg ⊢
  have hgc := (hg.of_le (show (0:ℕ∞ω) ≤ ∞ by simp)).comp x (hf.of_le (by simp))
  have hL := hf.mfderiv_const (m := 0) (by simp)
  apply (bilin_comp_contAt hgc hL).congr_of_eventuallyEq
  filter_upwards [(trivializationAt E (TangentSpace 𝓘(ℝ,E)) x).open_baseSet.mem_nhds
    (mem_baseSet_trivializationAt E (TangentSpace 𝓘(ℝ,E)) x),
    hf.continuousAt
      ((trivializationAt F (TangentSpace 𝓘(ℝ,F)) (f x)).open_baseSet.mem_nhds
        (mem_baseSet_trivializationAt F (TangentSpace 𝓘(ℝ,F)) (f x)))] with y hy hy'
  exact pullback_coordinates g f x y hy hy'

def continuousPullback (g : Metric (E := F) N) {f : M → N}
    (hf : ContMDiff 𝓘(ℝ,E) 𝓘(ℝ,F) 1 f)
    (e : ∀ x, TangentSpace 𝓘(ℝ,E) x ≃L[ℝ] TangentSpace 𝓘(ℝ,F) (f x))
    (he : ∀ x, (e x : TangentSpace 𝓘(ℝ,E) x →L[ℝ] TangentSpace 𝓘(ℝ,F) (f x)) =
      mfderiv 𝓘(ℝ,E) 𝓘(ℝ,F) f x) :
    ContinuousRiemannianMetric E (TangentSpace 𝓘(ℝ,E) : M → Type _) where
  inner x := pullInner g f x
  symm x u v := g.symm (f x) _ _
  pos x u hu := by
    rw [pullInner_apply,← he]
    apply g.pos
    intro hh
    apply hu
    apply (e x).injective
    rw [(e x).map_zero]
    exact hh
  isVonNBounded x := by
    have hb := (g.isVonNBounded (f x)).image (e x).symm.toContinuousLinearMap
    apply hb.subset
    intro u hu
    refine ⟨e x u,?_,by simp⟩
    change g.inner (f x) (mfderiv 𝓘(ℝ,E) 𝓘(ℝ,F) f x u)
      (mfderiv 𝓘(ℝ,E) 𝓘(ℝ,F) f x u) < 1 at hu
    rw [← he] at hu
    exact hu
  continuous := continuous_iff_continuousAt.mpr (fun x => (pullback_inner_contAt g (hf x)).continuousAt)
end ThreeManifold.MetricConstruction

namespace ThreeManifold.RiemannianCoordinates
variable {M : Type} [TopologicalSpace M] [ChartedSpace E3 M] [IsManifold I3 ∞ M]
  [CompactSpace M] [T2Space M]

def exponentialTangentEquiv (g : SmoothMetric M) (hn : NonpositiveSectionalCurvature g)
    (p : M) (v : E3) : E3 ≃L[ℝ] TangentSpace I3 (exponential g p v) :=
  (LinearEquiv.ofInjectiveEndo (show E3 →ₗ[ℝ] E3 from
    (mfderiv 𝓘(ℝ,E3) I3 (exponential g p) v).toLinearMap)
      (exponential_mfderiv_injective g (npc_noConjugatePoints g hn) p v)).toContinuousLinearEquiv

def exponentialMetric (g : SmoothMetric M) (hn : NonpositiveSectionalCurvature g) (p : M) :
    ContinuousRiemannianMetric E3 (TangentSpace 𝓘(ℝ,E3) : E3 → Type _) :=
  MetricConstruction.continuousPullback g (exponential_contMDiff g p)
    (exponentialTangentEquiv g hn p) (fun _ => rfl)

lemma exponentialMetric_inner (g : SmoothMetric M) (hn : NonpositiveSectionalCurvature g)
    (p : M) (v a b : E3) :
    (exponentialMetric g hn p).inner v a b = g.inner (exponential g p v)
      (mfderiv 𝓘(ℝ,E3) I3 (exponential g p) v a)
      (mfderiv 𝓘(ℝ,E3) I3 (exponential g p) v b) := rfl

lemma exponentialMetric_expanding (g : SmoothMetric M) (hn : NonpositiveSectionalCurvature g)
    (p : M) (v b : E3) :
    g.inner p b b ≤ (exponentialMetric g hn p).inner v b b :=
  npc_exponential_differential_expanding g hn p v b
end ThreeManifold.RiemannianCoordinates
end

section
open Set Filter Topology
namespace ThreeManifold.UniversalDeck
variable {E X : Type*} [TopologicalSpace E] [TopologicalSpace X] {p : E → X}

def group (p : E → X) : Subgroup (Equiv.Perm E) where
  carrier := {d | Continuous d ∧ Continuous d.symm ∧ ∀ z, p (d z) = p z}
  one_mem' := ⟨continuous_id,continuous_id,fun _ => rfl⟩
  mul_mem' := by
    rintro a b ⟨ha,hai,hap⟩ ⟨hb,hbi,hbp⟩
    exact ⟨ha.comp hb,hbi.comp hai,fun z => (hap (b z)).trans (hbp z)⟩
  inv_mem' := by
    rintro a ⟨ha,hai,hap⟩
    refine ⟨hai,ha,fun z => ?_⟩
    simpa using (hap (a.symm z)).symm

instance deckAction : MulAction (group p) E where
  smul d z := d.val z
  one_smul _ := rfl
  mul_smul _ _ _ := rfl
instance deckContinuous : ContinuousConstSMul (group p) E :=
  ⟨fun d => d.property.1⟩
lemma map_smul (d : group p) (z : E) : p (d • z) = p z := by
  let _ : TopologicalSpace X := inferInstance
  exact d.property.2.2 z

lemma deck_ext [PreconnectedSpace E] (hp : IsCoveringMap p)
    {a b : group p} {z : E} (h : a • z = b • z) : a = b := by
  apply Subtype.ext
  apply Equiv.ext
  exact congr_fun (hp.eq_of_comp_eq a.property.1 b.property.1
    (funext (fun w => (map_smul a w).trans (map_smul b w).symm)) z h)

lemma covering_surjective [Nonempty E] [PathConnectedSpace X] (hp : IsCoveringMap p) :
    Function.Surjective p := by
  let e : E := Classical.choice inferInstance
  intro y
  let γ := PathConnectedSpace.somePath (p e) y
  obtain ⟨v,hv,hv0⟩ := hp.exists_path_lifts γ.toContinuousMap e γ.source
  exact ⟨v 1,(congr_fun hv 1).trans γ.target⟩

variable [SimplyConnectedSpace E] [LocallyPathConnectedSpace E]

lemma exists_deck (hp : IsCoveringMap p) {a b : E} (hab : p a = p b) :
    ∃ d : group p, d • a = b := by
  obtain ⟨f,⟨hfa,hfp⟩,_⟩ := hp.existsUnique_continuousMap_lifts
    ⟨p,hp.continuous⟩ a b hab.symm
  obtain ⟨g,⟨hgb,hgp⟩,_⟩ := hp.existsUnique_continuousMap_lifts
    ⟨p,hp.continuous⟩ b a hab
  have hfg : Function.RightInverse g f := by
    have he : f ∘ g = id := hp.eq_of_comp_eq
      (f.continuous.comp g.continuous) continuous_id
      (funext (fun z => (congr_fun hfp (g z)).trans (congr_fun hgp z))) b (by simp [hgb,hfa])
    exact congr_fun he
  have hgf : Function.LeftInverse g f := by
    have he : g ∘ f = id := hp.eq_of_comp_eq
      (g.continuous.comp f.continuous) continuous_id
      (funext (fun z => (congr_fun hgp (f z)).trans (congr_fun hfp z))) a (by simp [hfa,hgb])
    exact congr_fun he
  let d : Equiv.Perm E := ⟨f,g,hgf,hfg⟩
  exact ⟨⟨d,f.continuous,g.continuous,fun z => congr_fun hfp z⟩,hfa⟩

theorem quotient_cover [PathConnectedSpace X] (hp : IsCoveringMap p) :
    IsQuotientCoveringMap p (group p) := by
  refine {
    toIsQuotientMap := hp.isQuotientMap (covering_surjective hp)
    continuous_const_smul := fun d => d.property.1
    apply_eq_iff_mem_orbit := ?_
    disjoint := ?_ }
  · intro a b
    constructor
    · intro h
      obtain ⟨d,hd⟩ := exists_deck hp h.symm
      exact ⟨d,hd⟩
    · rintro ⟨d,rfl⟩
      exact map_smul d b
  · intro z
    obtain ⟨U,hU,hz,hi⟩ := hp.isLocalHomeomorph.isLocallyInjective z
    refine ⟨U,hU.mem_nhds hz,?_⟩
    rintro d ⟨w,⟨y,hy,rfl⟩,hdy⟩
    apply deck_ext hp (z := y)
    exact hi hdy hy (map_smul d y)

def fundamentalGroupEquiv [PathConnectedSpace X] (hp : IsCoveringMap p) (z : E) :
    FundamentalGroup X (p z) ≃* (group p)ᵐᵒᵖ :=
  (quotient_cover hp).fundamentalGroupEquiv ⟨z,rfl⟩
end ThreeManifold.UniversalDeck
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 lift_contDiff {f : E3 → M} (hf : ContMDiff 𝓘(ℝ,E3) I3 1 f)
    (hi : ∀ a, Function.Injective (mfderiv 𝓘(ℝ,E3) I3 f a))
    (hl : IsLocalHomeomorph f) {d : E3 → E3} (hd : Continuous d)
    (he : ∀ x, f (d x) = f x) : ContDiff ℝ 1 d := by
  apply contDiff_iff_contDiffAt.mpr
  intro x
  let i := hl.localInverseAt (d x)
  have hic := localInverseAt_contMDiffAt hf hi hl (d x)
  rw [he x] at hic
  have heq : d =ᶠ[𝓝 x] fun z => i (f z) := by
    filter_upwards [hd.continuousAt.preimage_mem_nhds
      (i.open_target.mem_nhds hl.self_mem_localInverseAt_target)] with z hz
    have hh := i.right_inv hz
    rw [hl.localInverseAt_symm,he z] at hh
    exact hh.symm
  exact (contMDiffAt_iff_contDiffAt.mp (hic.comp x hf.contMDiffAt)).congr_of_eventuallyEq heq

variable [CompactSpace M] [T2Space M]
lemma exponentialDeck_contDiff (g : SmoothMetric M) (hn : NonpositiveSectionalCurvature g)
    (p : M) (d : UniversalDeck.group (exponential g p)) : ContDiff ℝ 1 (fun v : E3 => d • v) :=
  lift_contDiff (exponential_contMDiff g p)
    (exponential_mfderiv_injective g (npc_noConjugatePoints g hn) p)
    (npc_exponential_isLocalHomeomorph g hn p) d.property.1 (UniversalDeck.map_smul d)

lemma exponentialDeck_inner (g : SmoothMetric M) (hn : NonpositiveSectionalCurvature g)
    (p : M) (d : UniversalDeck.group (exponential g p)) (x u v : E3) :
    (exponentialMetric g hn p).inner (d • x)
      (fderiv ℝ (fun z => d • z) x u) (fderiv ℝ (fun z => d • z) x v) =
    (exponentialMetric g hn p).inner x u v := by
  have hd := (exponentialDeck_contDiff g hn p d).differentiable (by simp)
  have heq : (exponential g p) ∘ (fun z => d • z) = exponential g p :=
    funext (UniversalDeck.map_smul d)
  have hdif := mfderiv_comp x ((exponential_contMDiff g p).mdifferentiable (by simp) (d • x))
    ((exponentialDeck_contDiff g hn p d).contMDiff.mdifferentiable (by simp) x)
  rw [heq,mfderiv_eq_fderiv] at hdif
  have hu := congrArg (fun L : E3 →L[ℝ] E3 => L u) hdif
  have hv := congrArg (fun L : E3 →L[ℝ] E3 => L v) hdif
  change mfderiv 𝓘(ℝ,E3) I3 (exponential g p) x u =
    mfderiv 𝓘(ℝ,E3) I3 (exponential g p) (d • x) (fderiv ℝ (fun z => d • z) x u) at hu
  change mfderiv 𝓘(ℝ,E3) I3 (exponential g p) x v =
    mfderiv 𝓘(ℝ,E3) I3 (exponential g p) (d • x) (fderiv ℝ (fun z => d • z) x v) at hv
  change g.inner (exponential g p (d • x)) _ _ = g.inner (exponential g p x) _ _
  calc
    _ = g.inner (exponential g p (d • x))
        (mfderiv 𝓘(ℝ,E3) I3 (exponential g p) x u)
        (mfderiv 𝓘(ℝ,E3) I3 (exponential g p) x v) :=
      congrArg₂ (fun a b : E3 => g.inner (exponential g p (d • x)) a b) hu.symm hv.symm
    _ = _ := congrArg (fun z : M => g.inner z
      (mfderiv 𝓘(ℝ,E3) I3 (exponential g p) x u : E3)
      (mfderiv 𝓘(ℝ,E3) I3 (exponential g p) x v : E3)) (UniversalDeck.map_smul d x)
end ThreeManifold.RiemannianCoordinates
end

section
open Set Filter Topology
namespace ThreeManifold.QuotientCoverGeometry
variable {E X G : Type*} [TopologicalSpace E] [TopologicalSpace X] [Group G] [MulAction G E]
variable {p : E → X} (hp : IsQuotientCoveringMap p G)
include hp

lemma locallyFinite_graphs [T2Space X] :
    LocallyFinite (fun g : G => {q : E × E | q.2 = g • q.1}) := by
  let := hp.toContinuousConstSMul
  intro q
  by_cases hq : p q.2 = p q.1
  · obtain ⟨d,hd⟩ := hp.apply_eq_iff_mem_orbit.mp hq
    obtain ⟨U,hU,hdis⟩ := hp.disjoint q.1
    have hV : (fun z : E => d • z) '' U ∈ 𝓝 q.2 := by
      rw [← hd]
      exact (Homeomorph.smul d).isOpenEmbedding.image_mem_nhds.mpr hU
    refine ⟨U ×ˢ ((fun z : E => d • z) '' U),prod_mem_nhds hU hV,?_⟩
    apply (finite_singleton d).subset
    rintro g ⟨⟨a,b⟩,hgraph,ha,⟨c,hc,hcb⟩⟩
    have hmove : (d⁻¹*g) • a = c := by
      rw [mul_smul,← hgraph,← hcb,inv_smul_smul]
    have he := hdis (d⁻¹*g) ⟨c,⟨a,ha,hmove⟩,hc⟩
    exact (inv_mul_eq_one.mp he).symm
  · let V := {q : E × E | p q.2 ≠ p q.1}
    have hV : IsOpen V := isClosed_eq (hp.continuous.comp continuous_snd)
      (hp.continuous.comp continuous_fst) |>.isOpen_compl
    refine ⟨V,hV.mem_nhds hq,?_⟩
    apply finite_empty.subset
    rintro g ⟨⟨a,b⟩,hgraph,hne⟩
    exact False.elim (hne (hgraph ▸ hp.map_smul g))

theorem properlyDiscontinuous [T2Space X] : ProperlyDiscontinuousSMul G E := by
  constructor
  intro K L hK hL
  apply ((locallyFinite_graphs hp).finite_nonempty_inter_compact (hK.prod hL)).subset
  rintro g ⟨b,⟨a,ha,rfl⟩,hb⟩
  exact ⟨(a,g•a),rfl,ha,hb⟩

theorem compact_fundamental_set [LocallyCompactSpace E] [CompactSpace X] :
    ∃ K : Set E, IsCompact K ∧ ∀ z : E, ∃ g : G, g • z ∈ K := by
  choose e he using hp.surjective
  choose K hK hKn using fun x : X => exists_compact_mem_nhds (e x)
  have hn : ∀ x : X, p '' K x ∈ 𝓝 x := by
    intro x
    have h := hp.isCoveringMap.isOpenMap.image_mem_nhds (hKn x)
    simpa only [he x] using h
  obtain ⟨s,hs,hcover⟩ := isCompact_univ.elim_nhds_subcover (fun x => p '' K x) (fun x _ => hn x)
  refine ⟨⋃ x ∈ s, K x,s.finite_toSet.isCompact_biUnion (fun x _ => hK x),?_⟩
  intro z
  obtain ⟨x,hxs,y,hy,hpy⟩ := mem_iUnion₂.mp (hcover (mem_univ (p z)))
  obtain ⟨g,hg⟩ := hp.apply_eq_iff_mem_orbit.mp hpy
  refine ⟨g,mem_iUnion₂.mpr ⟨x,hxs,?_⟩⟩
  have hz : g • z = y := hg
  rw [hz]
  exact hy
end ThreeManifold.QuotientCoverGeometry
end

section

open Set Metric

namespace ThreeManifold.NoNPC

section Attainment
variable {G X : Type*} [Group G] [MetricSpace X] [ProperSpace X]
  [MulAction G X] [IsIsometricSMul G X] [ProperlyDiscontinuousSMul G X]

omit [ProperSpace X] [ProperlyDiscontinuousSMul G X] in
lemma conjugate_displacement (g k : G) (x : X) :
    dist (k • x) ((k * g * k⁻¹) • (k • x)) = dist x (g • x) := by
  simp only [mul_smul, inv_smul_smul, dist_smul]

theorem displacement_attains_minimum [Nonempty X] (g : G)
    {K : Set X} (hK : IsCompact K) (hcover : ∀ x : X, ∃ k : G, k • x ∈ K) :
    ∃ x : X, ∀ y : X, dist x (g • x) ≤ dist y (g • y) := by
  let x₀ : X := Classical.choice inferInstance
  let R : ℝ := dist x₀ (g • x₀)
  let S : Set G := {h | (∃ k : G, h = k * g * k⁻¹) ∧
    ∃ y ∈ K, dist y (h • y) ≤ R}
  have hS : S.Finite := by
    apply (finite_disjoint_inter_image (Γ := G) hK (hK.cthickening (r := R))).subset
    rintro h ⟨_, y, hy, hd⟩
    exact ⟨h • y, ⟨y, hy, rfl⟩,
      mem_cthickening_of_dist_le (h • y) y R K hy (by rwa [dist_comm])⟩
  let A : Set ℝ := ⋃ h ∈ S, (fun y : X => dist y (h • y)) '' K
  have hA : IsCompact A := hS.isCompact_biUnion fun h _ =>
    hK.image (continuous_id.dist (isometry_smul X h).continuous)
  have hmem (x : X) (hx : dist x (g • x) ≤ R) : dist x (g • x) ∈ A := by
    obtain ⟨k, hk⟩ := hcover x
    have hd := conjugate_displacement g k x
    apply mem_iUnion.mpr ⟨k * g * k⁻¹, ?_⟩
    apply mem_iUnion.mpr ⟨⟨⟨k, rfl⟩, k • x, hk, hd.trans_le hx⟩, ?_⟩
    exact ⟨k • x, hk, hd⟩
  have hR : R ∈ A := hmem x₀ le_rfl
  obtain ⟨r, hrA, hr⟩ := hA.exists_isLeast ⟨R, hR⟩
  rcases mem_iUnion.mp hrA with ⟨h, hrA⟩
  rcases mem_iUnion.mp hrA with ⟨hh, y, hy, hyr⟩
  obtain ⟨k, rfl⟩ := hh.1
  refine ⟨k⁻¹ • y, fun z => ?_⟩
  have hdisp : dist (k⁻¹ • y) (g • (k⁻¹ • y)) = r := by
    have he := conjugate_displacement g k (k⁻¹ • y)
    simpa only [smul_inv_smul, hyr] using he.symm
  rw [hdisp]
  by_cases hz : dist z (g • z) ≤ R
  · exact hr (hmem z hz)
  · exact (hr hR).trans (le_of_not_ge hz)

omit [ProperSpace X] [IsIsometricSMul G X] [ProperlyDiscontinuousSMul G X] in
lemma attained_minimum_positive (g : G) (hg : g ≠ 1)
    (hfree : ∀ {g : G} {x : X}, g • x = x → g = 1) (x : X) :
    0 < dist x (g • x) := by
  exact dist_pos.mpr (fun h => hg (hfree h.symm))
end Attainment

section ProductShift

lemma product_shift_constant {Y : Type*} [PseudoMetricSpace Y]
    (f : Y → Y) (τ : Y → ℝ)
    (h : ∀ (y z : Y) (t s : ℝ),
      dist (f y) (f z) ^ 2 + ((t + τ y) - (s + τ z)) ^ 2 =
        dist y z ^ 2 + (t - s) ^ 2) :
    ∀ y z, τ y = τ z := by
  intro y z
  have h₀ := h y z 0 0
  have h₁ := h y z 1 0
  nlinarith

lemma zero_shift_pythagoras {Y : Type*} [PseudoMetricSpace Y]
    (y y' : Y) (t ℓ : ℝ) :
    dist y y' ^ 2 + ((t + ℓ) - t) ^ 2 =
      (dist y y' ^ 2 + (t - t) ^ 2) + (dist y y ^ 2 + ((t + ℓ) - t) ^ 2) := by
  simp
end ProductShift

variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E]

theorem shear_orthogonality_impossible {u v : E} (hu : u ≠ 0)
    (h₁ : inner ℝ u v = 0) (h₂ : inner ℝ (u + v) u = 0) : False := by
  have hvu : inner ℝ v u = 0 := by simpa only [real_inner_comm] using h₁
  rw [inner_add_left, hvu, add_zero] at h₂
  exact hu (inner_self_eq_zero.mp h₂)

theorem shear_pythagoras_impossible {u v : E} (hu : u ≠ 0)
    (h₁ : ‖u + v‖ ^ 2 = ‖u‖ ^ 2 + ‖v‖ ^ 2)
    (h₂ : ‖(u + v) + u‖ ^ 2 = ‖u + v‖ ^ 2 + ‖u‖ ^ 2) : False := by
  apply shear_orthogonality_impossible hu
  · have h := norm_add_sq_real u v
    linarith
  · have h := norm_add_sq_real (u + v) u
    linarith
end ThreeManifold.NoNPC
end

section
open Set Filter Topology Bundle Manifold
open scoped ContDiff NNReal
namespace ThreeManifold.RiemannianCoordinates
variable {M : Type} [TopologicalSpace M] [ChartedSpace E3 M] [IsManifold I3 ∞ M]
  [CompactSpace M] [T2Space M]

lemma exponentialMetric_coercive (g : SmoothMetric M) (hn : NonpositiveSectionalCurvature g)
    (p : M) : ∃ R : ℝ≥0, 0 < R ∧ ∀ (x v : E3),
      ‖v‖ ≤ R * Real.sqrt ((exponentialMetric g hn p).inner x v v) := by
  obtain ⟨C,hC,hb⟩ := positive_bilinear_norm_bound (show E3 →L[ℝ] E3 →L[ℝ] ℝ from g.inner p)
    (fun v hv => g.pos p v hv)
  refine ⟨⟨Real.sqrt C,Real.sqrt_nonneg C⟩,Real.sqrt_pos.mpr hC,fun x v => ?_⟩
  have hx := exponentialMetric_expanding g hn p x v
  have hy : 0 ≤ (exponentialMetric g hn p).inner x v v :=
    (inner_self_nonneg g p v).trans hx
  have hs := Real.sq_sqrt hC.le
  have ht := Real.sq_sqrt hy
  have hh := (hb v).trans (mul_le_mul_of_nonneg_left hx hC.le)
  change ‖v‖ ≤ Real.sqrt C * Real.sqrt ((exponentialMetric g hn p).inner x v v)
  nlinarith [norm_nonneg v,Real.sqrt_nonneg C,
    Real.sqrt_nonneg ((exponentialMetric g hn p).inner x v v),
    mul_nonneg (Real.sqrt_nonneg C) (Real.sqrt_nonneg ((exponentialMetric g hn p).inner x v v)),
    sq_nonneg (‖v‖-Real.sqrt C*Real.sqrt ((exponentialMetric g hn p).inner x v v))]

abbrev universalMetric (g : SmoothMetric M) (hn : NonpositiveSectionalCurvature g) (p : M) : MetricSpace E3 :=
  RiemannianDistance.metricSpace (exponentialMetric g hn p)

lemma universalMetric_proper (g : SmoothMetric M) (hn : NonpositiveSectionalCurvature g) (p : M) :
    @ProperSpace E3 (universalMetric g hn p).toPseudoMetricSpace := by
  obtain ⟨R,hR,hb⟩ := exponentialMetric_coercive g hn p
  exact RiemannianDistance.properSpace _ R hR hb

lemma universalMetric_deck_isometry (g : SmoothMetric M) (hn : NonpositiveSectionalCurvature g)
    (p : M) (d : UniversalDeck.group (exponential g p)) :
    @Isometry E3 E3 (universalMetric g hn p).toPseudoEMetricSpace
      (universalMetric g hn p).toPseudoEMetricSpace (fun x => d • x) :=
  RiemannianDistance.isometry_of_inner (exponentialMetric g hn p) d.val
    (exponentialDeck_contDiff g hn p d) (exponentialDeck_contDiff g hn p d⁻¹)
    (exponentialDeck_inner g hn p d) (exponentialDeck_inner g hn p d⁻¹)

theorem npc_deck_displacement_minimum [PathConnectedSpace M]
    (g : SmoothMetric M) (hn : NonpositiveSectionalCurvature g) (p : M)
    (d : UniversalDeck.group (exponential g p)) :
    ∃ x : E3, ∀ y : E3,
      @dist E3 (universalMetric g hn p).toPseudoMetricSpace.toDist x (d • x) ≤
      @dist E3 (universalMetric g hn p).toPseudoMetricSpace.toDist y (d • y) := by
  let : MetricSpace E3 := universalMetric g hn p
  let : PseudoMetricSpace E3 := (universalMetric g hn p).toPseudoMetricSpace
  let : PseudoEMetricSpace E3 := (universalMetric g hn p).toPseudoEMetricSpace
  let : ProperSpace E3 := universalMetric_proper g hn p
  let : IsIsometricSMul (UniversalDeck.group (exponential g p)) E3 :=
    ⟨fun d => universalMetric_deck_isometry g hn p d⟩
  have hq := UniversalDeck.quotient_cover (npc_exponential_isCoveringMap g hn p)
  let := QuotientCoverGeometry.properlyDiscontinuous hq
  obtain ⟨K,hK,hcover⟩ := QuotientCoverGeometry.compact_fundamental_set hq
  exact NoNPC.displacement_attains_minimum d hK hcover
end ThreeManifold.RiemannianCoordinates
end

section
open Set Filter Topology Bundle Manifold MeasureTheory
open scoped ContDiff ENNReal NNReal
namespace ThreeManifold.RiemannianDistance
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
variable {F : Type*} [NormedAddCommGroup F] [NormedSpace ℝ F]
variable (h : ContinuousRiemannianMetric F (TangentSpace 𝓘(ℝ,F) : F → Type _))
variable (g : ContinuousRiemannianMetric E (TangentSpace 𝓘(ℝ,E) : E → Type _))

lemma pathELength_comp_eq_between {f : E → F} (hf : ContDiff ℝ 1 f)
    (hi : ∀ (x u v : E), h.inner (f x) (fderiv ℝ f x u) (fderiv ℝ f x v) = g.inner x u v)
    {γ : ℝ → E} {a b : ℝ} (hγ : ContDiffOn ℝ 1 γ (Icc a b)) :
    letI : RiemannianBundle (TangentSpace 𝓘(ℝ,E) : E → Type _) := ⟨g.toRiemannianMetric⟩
    letI : RiemannianBundle (TangentSpace 𝓘(ℝ,F) : F → Type _) := ⟨h.toRiemannianMetric⟩
    pathELength 𝓘(ℝ,F) (f ∘ γ) a b = pathELength 𝓘(ℝ,E) γ a b := by
  let : RiemannianBundle (TangentSpace 𝓘(ℝ,E) : E → Type _) := ⟨g.toRiemannianMetric⟩
  let : RiemannianBundle (TangentSpace 𝓘(ℝ,F) : F → Type _) := ⟨h.toRiemannianMetric⟩
  simp only [pathELength_eq_lintegral_mfderiv_Ioo]
  apply setLIntegral_congr_fun measurableSet_Ioo
  intro t ht
  have hγt := (hγ.contDiffAt (Icc_mem_nhds ht.1 ht.2)).differentiableAt (by simp)
  dsimp only
  rw [tangent_enorm h,tangent_enorm g]
  have hv : (mfderiv 𝓘(ℝ,ℝ) 𝓘(ℝ,F) (f ∘ γ) t 1 : F) =
      fderiv ℝ f (γ t) (mfderiv 𝓘(ℝ,ℝ) 𝓘(ℝ,E) γ t 1 : E) := by
    rw [mfderiv_eq_fderiv,mfderiv_eq_fderiv,fderiv_comp t
      (hf.differentiable (by simp) (γ t)) hγt]
    rfl
  apply congrArg (ENNReal.ofReal ∘ Real.sqrt)
  calc
    _ = h.inner (f (γ t))
        (fderiv ℝ f (γ t) (mfderiv 𝓘(ℝ,ℝ) 𝓘(ℝ,E) γ t 1 : E))
        (fderiv ℝ f (γ t) (mfderiv 𝓘(ℝ,ℝ) 𝓘(ℝ,E) γ t 1 : E)) :=
      congrArg₂ (fun u v : F => h.inner (f (γ t)) u v) hv hv
    _ = _ := hi _ _ _

lemma riemannianEDist_map_le_between {f : E → F} (hf : ContDiff ℝ 1 f)
    (hi : ∀ (x u v : E), h.inner (f x) (fderiv ℝ f x u) (fderiv ℝ f x v) = g.inner x u v)
    (x y : E) :
    letI : RiemannianBundle (TangentSpace 𝓘(ℝ,E) : E → Type _) := ⟨g.toRiemannianMetric⟩
    letI : RiemannianBundle (TangentSpace 𝓘(ℝ,F) : F → Type _) := ⟨h.toRiemannianMetric⟩
    riemannianEDist 𝓘(ℝ,F) (f x) (f y) ≤ riemannianEDist 𝓘(ℝ,E) x y := by
  let : RiemannianBundle (TangentSpace 𝓘(ℝ,E) : E → Type _) := ⟨g.toRiemannianMetric⟩
  let : RiemannianBundle (TangentSpace 𝓘(ℝ,F) : F → Type _) := ⟨h.toRiemannianMetric⟩
  apply le_of_forall_gt
  intro r hr
  obtain ⟨γ,h0,h1,hγ,hlen⟩ := exists_lt_of_riemannianEDist_lt hr
  have hc := hf.contMDiff.comp_contMDiffOn hγ
  have hl := riemannianEDist_le_pathELength (I := 𝓘(ℝ,F)) hc rfl rfl (by norm_num : (0:ℝ) ≤ 1)
  simp only [Function.comp_apply,h0,h1] at hl
  rw [pathELength_comp_eq_between h g hf hi (contMDiffOn_iff_contDiffOn.mp hγ)] at hl
  exact hl.trans_lt hlen

theorem isometry_between (f : E ≃ F) (hf : ContDiff ℝ 1 f) (hfi : ContDiff ℝ 1 f.symm)
    (hi : ∀ (x u v : E), h.inner (f x) (fderiv ℝ f x u) (fderiv ℝ f x v) = g.inner x u v)
    (hii : ∀ (x u v : F), g.inner (f.symm x) (fderiv ℝ f.symm x u) (fderiv ℝ f.symm x v) = h.inner x u v) :
    @Isometry E F (metricSpace g).toPseudoEMetricSpace (metricSpace h).toPseudoEMetricSpace f := by
  have hle := riemannianEDist_map_le_between h g hf hi
  have hlei := riemannianEDist_map_le_between g h hfi hii
  intro x y
  apply le_antisymm (hle x y)
  simpa only [Equiv.symm_apply_apply] using hlei (f x) (f y)
end ThreeManifold.RiemannianDistance
end

section
open Set Filter Topology
namespace ThreeManifold.UniversalCover
variable {E F X : Type*} [TopologicalSpace E] [TopologicalSpace F] [TopologicalSpace X]
  [SimplyConnectedSpace E] [LocallyPathConnectedSpace E]
  [SimplyConnectedSpace F] [LocallyPathConnectedSpace F]
  {p : E → X} {q : F → X}

theorem exists_based_homeomorph (hp : IsCoveringMap p) (hq : IsCoveringMap q)
    (a : E) (b : F) (hab : p a = q b) :
    ∃ e : E ≃ₜ F, e a = b ∧ ∀ z, q (e z) = p z := by
  obtain ⟨f,⟨hfa,hfp⟩,_⟩ := hq.existsUnique_continuousMap_lifts ⟨p,hp.continuous⟩ a b hab.symm
  obtain ⟨g,⟨hgb,hgp⟩,_⟩ := hp.existsUnique_continuousMap_lifts ⟨q,hq.continuous⟩ b a hab
  have hfg : Function.RightInverse g f := by
    have he : f ∘ g = id := hq.eq_of_comp_eq (f.continuous.comp g.continuous) continuous_id
      (funext (fun z => (congr_fun hfp (g z)).trans (congr_fun hgp z))) b (by simp [hgb,hfa])
    exact congr_fun he
  have hgf : Function.LeftInverse g f := by
    have he : g ∘ f = id := hp.eq_of_comp_eq (g.continuous.comp f.continuous) continuous_id
      (funext (fun z => (congr_fun hgp (f z)).trans (congr_fun hfp z))) a (by simp [hfa,hgb])
    exact congr_fun he
  exact ⟨⟨⟨f,g,hgf,hfg⟩,f.continuous,g.continuous⟩,hfa,fun z => congr_fun hfp z⟩
end ThreeManifold.UniversalCover
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 lift_map_contDiff {f k : E3 → M} (hf : ContMDiff 𝓘(ℝ,E3) I3 1 f)
    (hk : ContMDiff 𝓘(ℝ,E3) I3 1 k)
    (hi : ∀ a, Function.Injective (mfderiv 𝓘(ℝ,E3) I3 f a))
    (hl : IsLocalHomeomorph f) {d : E3 → E3} (hd : Continuous d)
    (he : ∀ x, f (d x) = k x) : ContDiff ℝ 1 d := by
  apply contDiff_iff_contDiffAt.mpr
  intro x
  let i := hl.localInverseAt (d x)
  have hic := localInverseAt_contMDiffAt hf hi hl (d x)
  rw [he x] at hic
  have heq : d =ᶠ[𝓝 x] fun z => i (k z) := by
    filter_upwards [hd.continuousAt.preimage_mem_nhds
      (i.open_target.mem_nhds hl.self_mem_localInverseAt_target)] with z hz
    have hh := i.right_inv hz
    rw [hl.localInverseAt_symm,he z] at hh
    exact hh.symm
  exact (contMDiffAt_iff_contDiffAt.mp (hic.comp x hk.contMDiffAt)).congr_of_eventuallyEq heq

variable [CompactSpace M] [T2Space M]
lemma exponentialChange_contDiff (g : SmoothMetric M) (hn : NonpositiveSectionalCurvature g)
    {p q : M} {e : E3 → E3} (hc : Continuous e)
    (he : ∀ v, exponential g q (e v) = exponential g p v) : ContDiff ℝ 1 e :=
  lift_map_contDiff (exponential_contMDiff g q) (exponential_contMDiff g p)
    (exponential_mfderiv_injective g (npc_noConjugatePoints g hn) q)
    (npc_exponential_isLocalHomeomorph g hn q) hc he

lemma exponentialChange_inner (g : SmoothMetric M) (hn : NonpositiveSectionalCurvature g)
    {p q : M} {e : E3 → E3} (hc : Continuous e)
    (he : ∀ v, exponential g q (e v) = exponential g p v) (x u v : E3) :
    (exponentialMetric g hn q).inner (e x) (fderiv ℝ e x u) (fderiv ℝ e x v) =
      (exponentialMetric g hn p).inner x u v := by
  have heq : exponential g q ∘ e = exponential g p := funext he
  have hdif := mfderiv_comp x ((exponential_contMDiff g q).mdifferentiable (by simp) (e x))
    ((exponentialChange_contDiff g hn hc he).contMDiff.mdifferentiable (by simp) x)
  rw [heq,mfderiv_eq_fderiv] at hdif
  have hu := congrArg (fun L : E3 →L[ℝ] E3 => L u) hdif
  have hv := congrArg (fun L : E3 →L[ℝ] E3 => L v) hdif
  change mfderiv 𝓘(ℝ,E3) I3 (exponential g p) x u =
    mfderiv 𝓘(ℝ,E3) I3 (exponential g q) (e x) (fderiv ℝ e x u) at hu
  change mfderiv 𝓘(ℝ,E3) I3 (exponential g p) x v =
    mfderiv 𝓘(ℝ,E3) I3 (exponential g q) (e x) (fderiv ℝ e x v) at hv
  change g.inner (exponential g q (e x)) _ _ = g.inner (exponential g p x) _ _
  calc
    _ = g.inner (exponential g q (e x))
        (mfderiv 𝓘(ℝ,E3) I3 (exponential g p) x u)
        (mfderiv 𝓘(ℝ,E3) I3 (exponential g p) x v) :=
      congrArg₂ (fun a b : E3 => g.inner (exponential g q (e x)) a b) hu.symm hv.symm
    _ = _ := congrArg (fun z : M => g.inner z
      (mfderiv 𝓘(ℝ,E3) I3 (exponential g p) x u : E3)
      (mfderiv 𝓘(ℝ,E3) I3 (exponential g p) x v : E3)) (he x)

theorem exists_exponential_coordinates (g : SmoothMetric M) (hn : NonpositiveSectionalCurvature g)
    {p q : M} (a b : E3) (hab : exponential g p a = exponential g q b) :
    ∃ e : E3 ≃ₜ E3, e a = b ∧ (∀ z, exponential g q (e z) = exponential g p z) ∧
      ContDiff ℝ 1 e ∧ ContDiff ℝ 1 e.symm ∧
      @Isometry E3 E3 (universalMetric g hn p).toPseudoEMetricSpace
        (universalMetric g hn q).toPseudoEMetricSpace e := by
  obtain ⟨e,hea,he⟩ := UniversalCover.exists_based_homeomorph
    (npc_exponential_isCoveringMap g hn p) (npc_exponential_isCoveringMap g hn q) a b hab
  have hei (z : E3) : exponential g p (e.symm z) = exponential g q z := by
    simpa only [e.apply_symm_apply] using (he (e.symm z)).symm
  have hc := exponentialChange_contDiff g hn e.continuous he
  have hci := exponentialChange_contDiff g hn e.symm.continuous hei
  refine ⟨e,hea,he,hc,hci,?_⟩
  exact RiemannianDistance.isometry_between (exponentialMetric g hn q) (exponentialMetric g hn p)
    e.toEquiv hc hci (exponentialChange_inner g hn e.continuous he)
      (exponentialChange_inner g hn e.symm.continuous hei)
end ThreeManifold.RiemannianCoordinates
end

section
open Set Filter Topology Bundle Manifold MeasureTheory
open scoped ContDiff ENNReal NNReal
namespace ThreeManifold.RiemannianDistance
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
variable (g : ContinuousRiemannianMetric E (TangentSpace 𝓘(ℝ,E) : E → Type _))

lemma functional_le_pathELength (L : E →L[ℝ] ℝ)
    (hL : ∀ (x v : E), |L v| ≤ Real.sqrt (g.inner x v v))
    {γ : ℝ → E} {a b : ℝ} (hγ : ContDiffOn ℝ 1 γ (Icc a b)) (hab : a ≤ b) :
    letI : RiemannianBundle (TangentSpace 𝓘(ℝ,E) : E → Type _) := ⟨g.toRiemannianMetric⟩
    ENNReal.ofReal |L (γ b-γ a)| ≤ pathELength 𝓘(ℝ,E) γ a b := by
  let : RiemannianBundle (TangentSpace 𝓘(ℝ,E) : E → Type _) := ⟨g.toRiemannianMetric⟩
  have h := enorm_sub_le_lintegral_deriv_of_contDiffOn_Icc (L.contDiff.comp_contDiffOn hγ) hab
  simp only [Function.comp_apply,← L.map_sub,← ofReal_norm,Real.norm_eq_abs] at h
  apply h.trans
  rw [pathELength_eq_lintegral_mfderiv_Ioo]
  rw [Measure.restrict_congr_set (Ioo_ae_eq_Icc (μ := volume)).symm]
  apply setLIntegral_mono' measurableSet_Ioo
  intro t ht
  have htγ := (hγ.contDiffAt (Icc_mem_nhds ht.1 ht.2)).differentiableAt (by simp)
  have hd := L.hasFDerivAt.comp t htγ.hasDerivAt.hasFDerivAt
  have he : deriv (L ∘ γ) t = L (deriv γ t) := by
    rw [hd.hasDerivAt.deriv]
    simp
  have hv : (mfderiv 𝓘(ℝ,ℝ) 𝓘(ℝ,E) γ t 1 : E) = deriv γ t := by
    rw [mfderiv_eq_fderiv]
    rfl
  rw [tangent_enorm g]
  rw [congrArg (fun v : E => g.inner (γ t) v v) hv,he]
  exact ENNReal.ofReal_le_ofReal (hL (γ t) (deriv γ t))

lemma functional_le_riemannianEDist (L : E →L[ℝ] ℝ)
    (hL : ∀ (x v : E), |L v| ≤ Real.sqrt (g.inner x v v)) (x y : E) :
    letI : RiemannianBundle (TangentSpace 𝓘(ℝ,E) : E → Type _) := ⟨g.toRiemannianMetric⟩
    ENNReal.ofReal |L (y-x)| ≤ riemannianEDist 𝓘(ℝ,E) x y := by
  let : RiemannianBundle (TangentSpace 𝓘(ℝ,E) : E → Type _) := ⟨g.toRiemannianMetric⟩
  apply le_of_forall_gt
  intro r hr
  obtain ⟨γ,h0,h1,hγ,hlen⟩ := exists_lt_of_riemannianEDist_lt hr
  have hb := functional_le_pathELength g L hL (contMDiffOn_iff_contDiffOn.mp hγ) (by norm_num : (0:ℝ) ≤ 1)
  rw [h0,h1] at hb
  exact hb.trans_lt hlen

lemma positive_bilinear_cauchy_schwarz (B : E →L[ℝ] E →L[ℝ] ℝ)
    (hs : ∀ v w, B v w = B w v) (hp : ∀ v, 0 ≤ B v v) (v w : E) :
    B v w ^ 2 ≤ B v v * B w w := by
  have h (t : ℝ) := hp (v + t • w)
  simp only [map_add,map_smul,_root_.add_apply,_root_.smul_apply,
    smul_eq_mul] at h
  rw [hs w v] at h
  have hd := discrim_le_zero (a := B w w) (b := 2*B v w) (c := B v v)
    (fun t => by nlinarith only [h t])
  unfold discrim at hd
  nlinarith only [hd]

theorem bilinear_le_riemannianEDist (B : E →L[ℝ] E →L[ℝ] ℝ)
    (hs : ∀ v w, B v w = B w v) (hp : ∀ v ≠ 0, 0 < B v v)
    (hB : ∀ (x v : E), B v v ≤ g.inner x v v) (x y : E) :
    letI : RiemannianBundle (TangentSpace 𝓘(ℝ,E) : E → Type _) := ⟨g.toRiemannianMetric⟩
    ENNReal.ofReal (Real.sqrt (B (y-x) (y-x))) ≤ riemannianEDist 𝓘(ℝ,E) x y := by
  let : RiemannianBundle (TangentSpace 𝓘(ℝ,E) : E → Type _) := ⟨g.toRiemannianMetric⟩
  by_cases he : y-x = 0
  · simp [he]
  have hpn (v : E) : 0 ≤ B v v := by
    by_cases hv : v = 0
    · simp [hv]
    · exact (hp v hv).le
  let d := y-x
  let c := Real.sqrt (B d d)
  have hc : 0 < c := Real.sqrt_pos.mpr (hp d he)
  have hc2 : c^2 = B d d := Real.sq_sqrt (hpn d)
  let L : E →L[ℝ] ℝ := c⁻¹ • B d
  have hL (z v : E) : |L v| ≤ Real.sqrt (g.inner z v v) := by
    have hcs := positive_bilinear_cauchy_schwarz B hs hpn d v
    have hg : 0 ≤ g.inner z v v := (hpn v).trans (hB z v)
    have hh := mul_le_mul_of_nonneg_left (hB z v) (hpn d)
    have hsq := Real.sq_sqrt hg
    change |c⁻¹ * B d v| ≤ _
    rw [abs_mul,abs_of_pos (inv_pos.mpr hc)]
    apply (inv_mul_le_iff₀ hc).mpr
    have hab : |B d v|^2 = B d v^2 := sq_abs _
    nlinarith [abs_nonneg (B d v),Real.sqrt_nonneg (g.inner z v v),
      mul_nonneg hc.le (Real.sqrt_nonneg (g.inner z v v))]
  have hd : |L (y-x)| = c := by
    change |c⁻¹ * B d d| = c
    rw [← hc2]
    have hh : c⁻¹ * c^2 = c := by field_simp
    rw [hh,abs_of_pos hc]
  simpa only [hd] using functional_le_riemannianEDist g L hL x y
end ThreeManifold.RiemannianDistance
end

section
open Set Filter Topology Bundle Manifold IsManifold MeasureTheory
open scoped ContDiff ENNReal
namespace ThreeManifold.RiemannianCoordinates
variable {M : Type} [TopologicalSpace M] [ChartedSpace E3 M] [IsManifold I3 ∞ M]
  [CompactSpace M] [T2Space M]

lemma globalGeodesic_speed (g : SmoothMetric M) (p : M) (v : E3) (t : ℝ) :
    g.inner (globalGeodesic g (fiberPhase p v) t)
      (velocity (globalGeodesic g (fiberPhase p v)) t)
      (velocity (globalGeodesic g (fiberPhase p v)) t) = g.inner p v v := by
  let γ := globalGeodesic g (fiberPhase p v)
  have hγ := globalGeodesic_isGeodesic g (fiberPhase p v)
  let f : ℝ → ℝ := fun r => g.inner (γ r) (velocity γ r) (velocity γ r)
  have hd (r : ℝ) : HasDerivAt f 0 r := geodesic_speed_hasDerivAt g isOpen_univ hγ (mem_univ r)
  have he : f t = f 0 := isOpen_univ.is_const_of_deriv_eq_zero isPreconnected_univ
    (fun r _ => (hd r).differentiableAt.differentiableWithinAt)
    (fun r _ => (hd r).deriv) (mem_univ t) (mem_univ 0)
  refine he.trans ?_
  exact congrArg (phaseEnergy g) (globalGeodesic_initial g (fiberPhase p v))

lemma exponentialMetric_radial (g : SmoothMetric M) (hn : NonpositiveSectionalCurvature g)
    (p : M) (v : E3) (t : ℝ) :
    (exponentialMetric g hn p).inner (t • v) v v = g.inner p v v := by
  have hr : ContDiff ℝ 1 (fun r : ℝ => r • v) := contDiff_id.smul contDiff_const
  have hd : mfderiv 𝓘(ℝ,ℝ) 𝓘(ℝ,E3) (fun r : ℝ => r • v) t 1 = v := by
    rw [mfderiv_eq_fderiv]
    change deriv (fun r : ℝ => r • v) t = v
    simpa only [one_smul,id_eq] using ((hasDerivAt_id t).smul_const v).deriv
  have heq : exponential g p ∘ (fun r : ℝ => r • v) = globalGeodesic g (fiberPhase p v) :=
    funext (exponential_scale g p v)
  have hc := mfderiv_comp t ((exponential_contMDiff g p).mdifferentiable (by simp) (t • v))
    (hr.contMDiff.mdifferentiable (by simp) t)
  rw [heq] at hc
  have hv := congrArg (fun L : ℝ →L[ℝ] E3 => L 1) hc
  change (velocity (globalGeodesic g (fiberPhase p v)) t : E3) =
    mfderiv 𝓘(ℝ,E3) I3 (exponential g p) (t • v)
      (mfderiv 𝓘(ℝ,ℝ) 𝓘(ℝ,E3) (fun r : ℝ => r • v) t 1) at hv
  rw [hd] at hv
  rw [exponentialMetric_inner]
  calc
    _ = g.inner (exponential g p (t • v))
      (velocity (globalGeodesic g (fiberPhase p v)) t : E3)
      (velocity (globalGeodesic g (fiberPhase p v)) t : E3) :=
        congrArg₂ (fun a b : E3 => g.inner (exponential g p (t • v)) a b) hv.symm hv.symm
    _ = g.inner (globalGeodesic g (fiberPhase p v) t)
      (velocity (globalGeodesic g (fiberPhase p v)) t : E3)
      (velocity (globalGeodesic g (fiberPhase p v)) t : E3) := by
        rw [exponential_scale]
    _ = _ := globalGeodesic_speed g p v t

lemma exponentialMetric_radial_length (g : SmoothMetric M) (hn : NonpositiveSectionalCurvature g)
    (p : M) (v : E3) (a b : ℝ) :
    letI : RiemannianBundle (TangentSpace 𝓘(ℝ,E3) : E3 → Type _) :=
      ⟨(exponentialMetric g hn p).toRiemannianMetric⟩
    pathELength 𝓘(ℝ,E3) (fun r : ℝ => r • v) a b =
      ENNReal.ofReal (Real.sqrt (g.inner p v v)) * ENNReal.ofReal (b-a) := by
  let : RiemannianBundle (TangentSpace 𝓘(ℝ,E3) : E3 → Type _) :=
      ⟨(exponentialMetric g hn p).toRiemannianMetric⟩
  rw [pathELength_eq_lintegral_mfderiv_Icc]
  have hh (t : ℝ) : ‖mfderiv 𝓘(ℝ,ℝ) 𝓘(ℝ,E3) (fun r : ℝ => r • v) t 1‖ₑ =
      ENNReal.ofReal (Real.sqrt (g.inner p v v)) := by
    rw [RiemannianDistance.tangent_enorm (exponentialMetric g hn p)]
    have hd : (mfderiv 𝓘(ℝ,ℝ) 𝓘(ℝ,E3) (fun r : ℝ => r • v) t 1 : E3) = v := by
      rw [mfderiv_eq_fderiv]
      change deriv (fun r : ℝ => r • v) t = v
      simpa only [one_smul,id_eq] using ((hasDerivAt_id t).smul_const v).deriv
    rw [congrArg (fun w : E3 => (exponentialMetric g hn p).inner (t • v) w w) hd,
      exponentialMetric_radial]
  simp_rw [hh]
  simp [Real.volume_Icc]

lemma universalMetric_lower (g : SmoothMetric M) (hn : NonpositiveSectionalCurvature g)
    (p : M) (x y : E3) :
    Real.sqrt (g.inner p (y-x) (y-x)) ≤
      @dist E3 (universalMetric g hn p).toPseudoMetricSpace.toDist x y := by
  have hh := RiemannianDistance.bilinear_le_riemannianEDist (exponentialMetric g hn p)
    (show E3 →L[ℝ] E3 →L[ℝ] ℝ from g.inner p) (g.symm p) (g.pos p)
    (exponentialMetric_expanding g hn p) x y
  let : RiemannianBundle (TangentSpace 𝓘(ℝ,E3) : E3 → Type _) :=
      ⟨(exponentialMetric g hn p).toRiemannianMetric⟩
  change ENNReal.ofReal _ ≤ @edist E3 (universalMetric g hn p).toPseudoEMetricSpace.toEDist x y at hh
  rw [@edist_dist E3 (universalMetric g hn p).toPseudoMetricSpace] at hh
  exact (ENNReal.ofReal_le_ofReal_iff (@dist_nonneg E3 (universalMetric g hn p).toPseudoMetricSpace x y)).mp hh

lemma universalMetric_radial_zero (g : SmoothMetric M) (hn : NonpositiveSectionalCurvature g)
    (p : M) (v : E3) :
    @dist E3 (universalMetric g hn p).toPseudoMetricSpace.toDist 0 v = Real.sqrt (g.inner p v v) := by
  apply le_antisymm
  · let : RiemannianBundle (TangentSpace 𝓘(ℝ,E3) : E3 → Type _) :=
      ⟨(exponentialMetric g hn p).toRiemannianMetric⟩
    have hc : ContMDiff 𝓘(ℝ,ℝ) 𝓘(ℝ,E3) 1 (fun r : ℝ => r • v) :=
      (contDiff_id.smul contDiff_const).contMDiff
    have hh := riemannianEDist_le_pathELength hc.contMDiffOn (by simp : (0:ℝ) • v = 0)
      (by simp : (1:ℝ) • v = v) (by norm_num : (0:ℝ) ≤ 1)
    rw [exponentialMetric_radial_length] at hh
    simp only [sub_zero,ENNReal.ofReal_one,mul_one] at hh
    change @edist E3 (universalMetric g hn p).toPseudoEMetricSpace.toEDist 0 v ≤ _ at hh
    rw [@edist_dist E3 (universalMetric g hn p).toPseudoMetricSpace] at hh
    exact (ENNReal.ofReal_le_ofReal_iff (Real.sqrt_nonneg _)).mp hh
  · simpa only [sub_zero] using universalMetric_lower g hn p 0 v
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]
  [CompactSpace M] [T2Space M]

lemma exponential_recenter (g : SmoothMetric M) (p : M) (v : E3) (t s : ℝ) :
    exponential g (globalGeodesic g (fiberPhase p v) t)
      (s • (velocity (globalGeodesic g (fiberPhase p v)) t : E3)) =
        exponential g p ((t+s) • v) := by
  trans globalGeodesic g (fiberPhase (globalGeodesic g (fiberPhase p v) t)
    (velocity (globalGeodesic g (fiberPhase p v)) t : E3)) s
  · exact exponential_scale g _ _ s
  rw [exponential_scale]
  exact congrArg Bundle.TotalSpace.proj (geodesicFlow_add g (fiberPhase p v) t s)

lemma recenter_radial_line (g : SmoothMetric M) (hn : NonpositiveSectionalCurvature g)
    (p : M) (v : E3) (t : ℝ) {e : E3 ≃ₜ E3}
    (he0 : e (t • v) = 0)
    (he : ∀ z, exponential g (globalGeodesic g (fiberPhase p v) t) (e z) = exponential g p z)
    (s : ℝ) : e ((t+s) • v) = s • (velocity (globalGeodesic g (fiberPhase p v)) t : E3) := by
  let q := globalGeodesic g (fiberPhase p v) t
  let w : E3 := velocity (globalGeodesic g (fiberPhase p v)) t
  change e ((t+s) • v) = s • w
  have hh : (fun r : ℝ => e ((t+r) • v)) =
      (fun r : ℝ => r • w) := by
    refine (npc_exponential_isCoveringMap g hn q).eq_of_comp_eq
      (e.continuous.comp ((continuous_const.add continuous_id).smul continuous_const))
      (continuous_id.smul continuous_const) ?_ 0 ?_
    · funext r
      exact (he _).trans (exponential_recenter g p v t r).symm
    · simpa only [add_zero,zero_smul] using he0
  exact congrFun hh s

lemma positive_form_smul (g : SmoothMetric M) (p : M) (v : E3) (t : ℝ) :
    g.inner p (t • v) (t • v) = t^2 * g.inner p v v := by
  let _ : CompactSpace M := inferInstance
  let _ : T2Space M := inferInstance
  let B : E3 →L[ℝ] E3 →L[ℝ] ℝ := g.inner p
  change B (t • v) (t • v) = t^2 * B v v
  simp only [map_smul,_root_.smul_apply,smul_eq_mul]
  ring

lemma positive_form_parallelogram (g : SmoothMetric M) (p : M) (u v : E3) :
    g.inner p (u+v) (u+v) + g.inner p (u-v) (u-v) =
      2*g.inner p u u + 2*g.inner p v v := by
  let _ : CompactSpace M := inferInstance
  let _ : T2Space M := inferInstance
  let B : E3 →L[ℝ] E3 →L[ℝ] ℝ := g.inner p
  change B (u+v) (u+v) + B (u-v) (u-v) = 2*B u u + 2*B v v
  simp only [map_add,map_sub,_root_.add_apply,_root_.sub_apply]
  ring

lemma universalMetric_lower_sq (g : SmoothMetric M) (hn : NonpositiveSectionalCurvature g)
    (p : M) (x y : E3) :
    g.inner p (y-x) (y-x) ≤
      (@dist E3 (universalMetric g hn p).toPseudoMetricSpace.toDist x y)^2 := by
  have h := universalMetric_lower g hn p x y
  have hs := Real.sq_sqrt (inner_self_nonneg g p (y-x))
  have hd := @dist_nonneg E3 (universalMetric g hn p).toPseudoMetricSpace x y
  nlinarith [Real.sqrt_nonneg (g.inner p (y-x) (y-x))]

lemma universalMetric_distance_zero_sq (g : SmoothMetric M) (hn : NonpositiveSectionalCurvature g)
    (p : M) (x : E3) :
    (@dist E3 (universalMetric g hn p).toPseudoMetricSpace.toDist 0 x)^2 =
      g.inner p x x := by
  rw [universalMetric_radial_zero,Real.sq_sqrt (inner_self_nonneg g p x)]

theorem universalMetric_radial_CN (g : SmoothMetric M) (hn : NonpositiveSectionalCurvature g)
    (p : M) (v z : E3) :
    let D := @dist E3 (universalMetric g hn p).toPseudoMetricSpace.toDist
    D ((1/2:ℝ) • v) z ^2 ≤ (D 0 z ^2 + D v z ^2)/2 - D 0 v ^2/4 := by
  let m := (1/2:ℝ) • v
  let q := globalGeodesic g (fiberPhase p v) (1/2)
  let w : E3 := velocity (globalGeodesic g (fiberPhase p v)) (1/2)
  have hbase : exponential g p m = exponential g q 0 := by
    rw [exponential_zero]
    exact exponential_scale g p v (1/2)
  obtain ⟨e,he0,he,hc,hci,hi⟩ := exists_exponential_coordinates g hn m 0 hbase
  have heA : e 0 = (-1/2:ℝ) • w := by
    have hh : e (((1/2:ℝ)+(-1/2)) • v) = (-1/2:ℝ) • w :=
      recenter_radial_line g hn p v (1/2) he0 he (-1/2)
    norm_num only [show (1/2:ℝ)+(-1/2)=0 by norm_num,zero_smul] at hh
    simpa only [neg_div] using hh
  have heB : e v = (1/2:ℝ) • w := by
    have hh : e (((1/2:ℝ)+(1/2)) • v) = (1/2:ℝ) • w :=
      recenter_radial_line g hn p v (1/2) he0 he (1/2)
    norm_num only [show (1/2:ℝ)+(1/2)=1 by norm_num,one_smul] at hh
    exact hh
  let D := @dist E3 (universalMetric g hn p).toPseudoMetricSpace.toDist
  let Q := @dist E3 (universalMetric g hn q).toPseudoMetricSpace.toDist
  have hid (a b : E3) : Q (e a) (e b) = D a b := by
    exact @Isometry.dist_eq E3 E3 (universalMetric g hn p).toPseudoMetricSpace
      (universalMetric g hn q).toPseudoMetricSpace e hi a b
  have hmid : D m z ^2 = g.inner q (e z) (e z) := by
    rw [← hid,he0]
    exact universalMetric_distance_zero_sq g hn q (e z)
  have ha : g.inner q (e z + (1/2:ℝ) • w) (e z + (1/2:ℝ) • w) ≤ D 0 z ^2 := by
    have hh := universalMetric_lower_sq g hn q (e 0) (e z)
    change g.inner q (e z - e 0) (e z - e 0) ≤ Q (e 0) (e z) ^2 at hh
    rw [hid,heA] at hh
    simpa only [neg_div,neg_smul,sub_neg_eq_add] using hh
  have hb : g.inner q (e z - (1/2:ℝ) • w) (e z - (1/2:ℝ) • w) ≤ D v z ^2 := by
    have hh := universalMetric_lower_sq g hn q (e v) (e z)
    change g.inner q (e z - e v) (e z - e v) ≤ Q (e v) (e z) ^2 at hh
    rwa [hid,heB] at hh
  have hp := positive_form_parallelogram g q (e z) ((1/2:ℝ) • w)
  rw [positive_form_smul] at hp
  have hw : g.inner q w w = g.inner p v v := globalGeodesic_speed g p v (1/2)
  have hv : D 0 v ^2 = g.inner p v v := universalMetric_distance_zero_sq g hn p v
  change D m z ^2 ≤ _
  nlinarith only [ha,hb,hp,hw,hv,hmid]
end ThreeManifold.RiemannianCoordinates

end

end OAI