import OAI.Geometry.ConjugatePoints.Metric
import OAI.Geometry.ConjugatePoints.Cometric

namespace OAI

noncomputable section

/-!
# The smooth Riemannian metric on the compact glued manifold.
-/

section
open Set Filter Topology Bundle Manifold IsManifold Bornology
open scoped ContDiff
namespace ThreeManifold.CompactMetric
open MetricConstruction CylinderConstruction

def radialLinear (a : ℝ) (ha : a ≠ 0) : P ≃L[ℝ] P :=
  { toFun := fun v => (a*v.1,v.2)
    invFun := fun v => (v.1/a,v.2)
    left_inv := by intro v; apply Prod.ext <;> simp [ha]
    right_inv := by
      intro v
      apply Prod.ext
      · change a*(v.1/a) = v.1
        field_simp
      · rfl
    map_add' := by
      intro v w
      apply Prod.ext
      · change a*(v.1+w.1) = a*v.1+a*w.1
        ring
      · rfl
    map_smul' := by
      intro c v
      apply Prod.ext
      · change a*(c*v.1) = c*(a*v.1)
        ring
      · rfl }

def radial (L : ℝ) (x : Cylinder) : Cylinder := (RadialProfile.coordinate L x.1,x.2)
def radialLift (L : ℝ) (x : P) : P := (RadialProfile.coordinate L x.1,x.2)
lemma radial_smooth (L : ℝ) : ContMDiff 𝓘(ℝ,P) 𝓘(ℝ,P) ∞ (radial L) := by
  have h := ((RadialProfile.coordinate_smooth L).contMDiff.comp
    (projection_fst_smooth (E := ℝ) (F := ℝ × ℝ) (M := ℝ) (N := AddCircle (6:ℝ) × AddCircle (6:ℝ)))).prodMk
      (projection_snd_smooth (E := ℝ) (F := ℝ × ℝ) (M := ℝ) (N := AddCircle (6:ℝ) × AddCircle (6:ℝ)))
  convert! h using 1
  simp only [← modelWithCornersSelf_prod]
lemma radialLift_smooth (L : ℝ) : ContMDiff 𝓘(ℝ,P) 𝓘(ℝ,P) ∞ (radialLift L) :=
  ((RadialProfile.coordinate_smooth L).comp contDiff_fst |>.prodMk contDiff_snd).contMDiff
lemma radialLift_deriv {L : ℝ} (hL : 4 ≤ L) (x : P) :
    (radialLinear (RadialProfile.slope L x.1) (RadialProfile.slope_pos hL x.1).ne').toContinuousLinearMap =
      mfderiv 𝓘(ℝ,P) 𝓘(ℝ,P) (radialLift L) x := by
  rw [mfderiv_eq_fderiv]
  have hd := ((RadialProfile.coordinate_deriv L x.1).comp_hasFDerivAt x
    (hasFDerivAt_fst (𝕜 := ℝ) (p := x))).prodMk (hasFDerivAt_snd (𝕜 := ℝ) (p := x))
  calc
    _ = _ := ?_
    _ = fderiv ℝ (radialLift L) x := hd.fderiv.symm
  apply ContinuousLinearMap.ext
  intro v
  rfl
lemma radial_commutes (L : ℝ) : radial L ∘ projection = projection ∘ radialLift L := rfl

def radialPull (g : Metric (E := P) Cylinder) {L : ℝ} (hL : 4 ≤ L) :
    Metric (E := P) Cylinder :=
  pullbackFromLift projection_cover projection_smooth local_inverse_smooth
    (radial_smooth L) (radialLift_smooth L) (radial_commutes L)
    (fun x => radialLinear (RadialProfile.slope L x.1) (RadialProfile.slope_pos hL x.1).ne')
    (radialLift_deriv hL) section_spec g

def radius₁ (δ B : ℝ) (t : ℝ) : ℝ := δ^2*B/6 * Collar.ell δ t
def radius₂ (δ B : ℝ) (t : ℝ) : ℝ := B/6 * Collar.ell δ (1-t)
lemma radius₁_smooth {δ : ℝ} (hδ : δ ∈ Icc 0 (1/2)) (B : ℝ) : ContDiff ℝ ∞ (radius₁ δ B) :=
  contDiff_const.mul (Collar.ell_smooth hδ)
lemma radius₂_smooth {δ : ℝ} (hδ : δ ∈ Icc 0 (1/2)) (B : ℝ) : ContDiff ℝ ∞ (radius₂ δ B) :=
  contDiff_const.mul ((Collar.ell_smooth hδ).comp (contDiff_const.sub contDiff_id))
lemma radius₁_pos {δ B : ℝ} (hδ : 0 < δ) (hB : 0 < B) (t : ℝ) : 0 < radius₁ δ B t :=
  mul_pos (div_pos (mul_pos (sq_pos_of_pos hδ) hB) (by norm_num)) (Collar.ell_pos δ t)
lemma radius₂_pos {δ B : ℝ} (hB : 0 < B) (t : ℝ) : 0 < radius₂ δ B t :=
  mul_pos (div_pos hB (by norm_num)) (Collar.ell_pos δ (1-t))

def neck {δ B : ℝ} (hδ : δ ∈ Ioc 0 (1/2)) (hB : 0 < B) : Metric (E := P) Cylinder :=
  CylinderConstruction.metric (radius₁_smooth ⟨hδ.1.le,hδ.2⟩ B)
    (radius₂_smooth ⟨hδ.1.le,hδ.2⟩ B) Cometric.χ_smooth
    (fun t => (radius₁_pos hδ.1 hB t).ne') (fun t => (radius₂_pos hB t).ne')
end ThreeManifold.CompactMetric

namespace ThreeManifold.MetricConstruction
variable {E M : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
  [TopologicalSpace M] [ChartedSpace E M] [IsManifold 𝓘(ℝ,E) ∞ M]

omit [IsManifold 𝓘(ℝ,E) ∞ M] in
lemma openSubtype_inverse_smooth (U : TopologicalSpace.Opens M) (hU : Nonempty U)
    {x : M} (hx : x ∈ U) :
    ContMDiffAt 𝓘(ℝ,E) 𝓘(ℝ,E) ∞ (U.openPartialHomeomorphSubtypeCoe hU).symm x := by
  apply (ContMDiffAt.subtypeVal_comp_iff U _ x).mp
  apply contMDiffAt_id.congr_of_eventuallyEq
  filter_upwards [U.isOpen.mem_nhds hx] with y hy
  exact (U.openPartialHomeomorphSubtypeCoe hU).right_inv (by simpa using hy)

omit [IsManifold 𝓘(ℝ,E) ∞ M] in
lemma openSubtype_mdifferentiable (U : TopologicalSpace.Opens M) (hU : Nonempty U) :
    (U.openPartialHomeomorphSubtypeCoe hU).MDifferentiable 𝓘(ℝ,E) 𝓘(ℝ,E) := by
  constructor
  · exact (contMDiff_subtype_val (U := U) (n := ∞)).mdifferentiable (by simp) |>.mdifferentiableOn
  · intro x hx
    exact (openSubtype_inverse_smooth U hU (by simpa using hx)).mdifferentiableAt
      (by simp) |>.mdifferentiableWithinAt

def restrict (g : Metric (E := E) M) (U : TopologicalSpace.Opens M) : Metric (E := E) U :=
  pullback g (contMDiff_subtype_val (U := U))
    (fun x => (openSubtype_mdifferentiable U ⟨x⟩).mfderiv (by simp)) (fun _ => rfl)

lemma restrict_inner (g : Metric (E := E) M) (U : TopologicalSpace.Opens M) (x : U) :
    (restrict g U).inner x = pullInner g (Subtype.val : U → M) x := rfl
end ThreeManifold.MetricConstruction

namespace ThreeManifold.CompactMetric
open MetricConstruction CylinderConstruction
open HyperbolicCore (rayOpens)

def timeReverse : ℝ ≃ₜ ℝ where
  toFun t := 1-t
  invFun t := 1-t
  left_inv t := by dsimp; ring
  right_inv t := by dsimp; ring
  continuous_toFun := continuous_const.sub continuous_id
  continuous_invFun := continuous_const.sub continuous_id

def switch : Cylinder ≃ₜ Cylinder := timeReverse.prodCongr GluedConstruction.torusShear
lemma switch_smooth : ContMDiff 𝓘(ℝ,P) 𝓘(ℝ,P) ∞ switch := by
  have h0 : ContMDiff 𝓘(ℝ,P) 𝓘(ℝ,ℝ) ∞ (fun q : Cylinder => 1-q.1) :=
    contMDiff_const.sub projection_fst_smooth
  have h1 : ContMDiff 𝓘(ℝ,P) 𝓘(ℝ,ℝ × ℝ) ∞
      (fun q : Cylinder => GluedConstruction.torusShear q.2) := by
    convert! GluedConstruction.torusShear_smooth.comp
      (projection_snd_smooth (E := ℝ) (F := ℝ × ℝ) (M := ℝ) (N := AddCircle (6:ℝ) × AddCircle (6:ℝ))) using 1
    simp only [← modelWithCornersSelf_prod]
  convert! h0.prodMk h1 using 1
  simp only [← modelWithCornersSelf_prod]
lemma switch_symm_smooth : ContMDiff 𝓘(ℝ,P) 𝓘(ℝ,P) ∞ switch.symm := by
  have h0 : ContMDiff 𝓘(ℝ,P) 𝓘(ℝ,ℝ) ∞ (fun q : Cylinder => 1-q.1) :=
    contMDiff_const.sub projection_fst_smooth
  have h1 : ContMDiff 𝓘(ℝ,P) 𝓘(ℝ,ℝ × ℝ) ∞
      (fun q : Cylinder => GluedConstruction.torusShear.symm q.2) := by
    convert! GluedConstruction.torusShear_symm_smooth.comp
      (projection_snd_smooth (E := ℝ) (F := ℝ × ℝ) (M := ℝ) (N := AddCircle (6:ℝ) × AddCircle (6:ℝ))) using 1
    simp only [← modelWithCornersSelf_prod]
  convert! h0.prodMk h1 using 1
  simp only [← modelWithCornersSelf_prod]

def switched (g : Metric (E := P) Cylinder) : Metric (E := P) Cylinder :=
  pullbackHomeomorph g switch switch_smooth switch_symm_smooth

abbrev HeightCylinder (a : ℝ) := Ioi a × (AddCircle (6:ℝ) × AddCircle (6:ℝ))
def logDomain (a : ℝ) : TopologicalSpace.Opens Cylinder :=
  ⟨{q | Real.log a < q.1},isOpen_lt continuous_const continuous_fst⟩

def logCylinderHomeomorph (a : ℝ) (ha : 0 < a) : HeightCylinder a ≃ₜ logDomain a where
  toFun q := ⟨(Real.log q.1.1,q.2), (Real.strictMonoOn_log ha (lt_trans ha q.1.2) q.1.2)⟩
  invFun q := (⟨Real.exp q.1.1,by
    have h := Real.exp_lt_exp.mpr q.2
    rwa [Real.exp_log ha] at h⟩,q.1.2)
  left_inv q := by ext <;> simp [Real.exp_log (lt_trans ha q.1.2)]
  right_inv q := by ext <;> simp
  continuous_toFun := (((continuous_subtype_val.comp continuous_fst).log
      (fun q => ne_of_gt (lt_trans ha q.1.2))).prodMk continuous_snd).subtype_mk _
  continuous_invFun := (((Real.continuous_exp.comp (continuous_fst.comp continuous_subtype_val)).subtype_mk _).prodMk
    (continuous_snd.comp continuous_subtype_val))

lemma logCylinder_smooth (a : ℝ) (ha : 0 < a) :
    ContMDiff 𝓘(ℝ,P) 𝓘(ℝ,P) ∞ (logCylinderHomeomorph a ha) := by
  apply (ContMDiff.subtypeVal_comp_iff (logDomain a) _).mp
  have hh : ContMDiff 𝓘(ℝ,P) 𝓘(ℝ,ℝ) ∞ (fun q : HeightCylinder a => q.1.1) :=
    (contMDiff_subtype_val (U := rayOpens a)).comp projection_fst_smooth
  have hl : ContMDiff 𝓘(ℝ,P) 𝓘(ℝ,ℝ) ∞ (fun q : HeightCylinder a => Real.log q.1.1) :=
    fun q => (Real.contDiffAt_log.mpr (ne_of_gt (lt_trans ha q.1.2))).contMDiffAt.comp q (hh q)
  have hs : ContMDiff 𝓘(ℝ,P) 𝓘(ℝ,ℝ × ℝ) ∞ (Prod.snd : HeightCylinder a → _) :=
    projection_snd_smooth
  convert! hl.prodMk hs using 1
  simp only [← modelWithCornersSelf_prod]

lemma logCylinder_symm_smooth (a : ℝ) (ha : 0 < a) :
    ContMDiff 𝓘(ℝ,P) 𝓘(ℝ,P) ∞ (logCylinderHomeomorph a ha).symm := by
  have hv : ContMDiff 𝓘(ℝ,P) 𝓘(ℝ,P) ∞ (Subtype.val : logDomain a → Cylinder) :=
    contMDiff_subtype_val
  have h0 : ContMDiff 𝓘(ℝ,P) 𝓘(ℝ,ℝ) ∞ (fun q : logDomain a =>
      (logCylinderHomeomorph a ha).symm q |>.1) := by
    apply (ContMDiff.subtypeVal_comp_iff (rayOpens a) _).mp
    exact Real.contDiff_exp.contMDiff.comp (projection_fst_smooth.comp hv)
  have h1 : ContMDiff 𝓘(ℝ,P) 𝓘(ℝ,ℝ × ℝ) ∞ (fun q : logDomain a => q.1.2) :=
    projection_snd_smooth.comp hv
  convert! h0.prodMk h1 using 1
  simp only [← modelWithCornersSelf_prod]

def heightMetric (g : Metric (E := P) Cylinder) (a : ℝ) (ha : 0 < a) :
    Metric (E := P) (HeightCylinder a) :=
  pullbackHomeomorph (MetricConstruction.restrict g (logDomain a)) (logCylinderHomeomorph a ha)
    (logCylinder_smooth a ha) (logCylinder_symm_smooth a ha)
end ThreeManifold.CompactMetric

namespace ThreeManifold.MetricConstruction

section
variable {E M A : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
  [TopologicalSpace M] [ChartedSpace E M] [IsManifold 𝓘(ℝ,E) ∞ M]

structure LocalMetric (M : Type*) {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
    [TopologicalSpace M] [ChartedSpace E M] [IsManifold 𝓘(ℝ,E) ∞ M] where
  domain : Set M
  open_domain : IsOpen domain
  inner : ∀ x : M, TangentSpace 𝓘(ℝ,E) x →L[ℝ] TangentSpace 𝓘(ℝ,E) x →L[ℝ] ℝ
  symm : ∀ x ∈ domain, ∀ u v, inner x u v = inner x v u
  pos : ∀ x ∈ domain, ∀ u, u ≠ 0 → 0 < inner x u u
  bounded : ∀ x ∈ domain, IsVonNBounded ℝ {u | inner x u u < 1}
  smooth : ∀ x ∈ domain, ContMDiffAt 𝓘(ℝ,E)
    (𝓘(ℝ,E).prod 𝓘(ℝ,E →L[ℝ] E →L[ℝ] ℝ)) ∞
    (fun y => TotalSpace.mk' (E →L[ℝ] E →L[ℝ] ℝ)
      (E := fun z => TangentSpace 𝓘(ℝ,E) z →L[ℝ] TangentSpace 𝓘(ℝ,E) z →L[ℝ] ℝ)
      y (inner y)) x

variable (g : A → LocalMetric (E := E) M)
    (cover : ∀ x, ∃ i, x ∈ (g i).domain)
    (compat : ∀ i j x, x ∈ (g i).domain → x ∈ (g j).domain → (g i).inner x = (g j).inner x)

def localGluedInner (x : M) := (g (cover x).choose).inner x

include compat in
lemma localGluedInner_eq (i : A) (x : M) (hx : x ∈ (g i).domain) :
    localGluedInner g cover x = (g i).inner x :=
  compat _ i x (cover x).choose_spec hx

include compat in
lemma localGluedInner_smooth :
    ContMDiff 𝓘(ℝ,E) (𝓘(ℝ,E).prod 𝓘(ℝ,E →L[ℝ] E →L[ℝ] ℝ)) ∞
      (fun y => TotalSpace.mk' (E →L[ℝ] E →L[ℝ] ℝ)
        (E := fun z => TangentSpace 𝓘(ℝ,E) z →L[ℝ] TangentSpace 𝓘(ℝ,E) z →L[ℝ] ℝ)
        y (localGluedInner g cover y)) := by
  intro x
  obtain ⟨i,hi⟩ := cover x
  apply ((g i).smooth x hi).congr_of_eventuallyEq
  filter_upwards [(g i).open_domain.mem_nhds hi] with y hy
  exact congrArg (TotalSpace.mk' (E →L[ℝ] E →L[ℝ] ℝ) y)
    (localGluedInner_eq g cover compat i y hy)

def glueLocal : Metric (E := E) M where
  inner := localGluedInner g cover
  symm x := (g (cover x).choose).symm x (cover x).choose_spec
  pos x := (g (cover x).choose).pos x (cover x).choose_spec
  isVonNBounded x := (g (cover x).choose).bounded x (cover x).choose_spec
  contMDiff := localGluedInner_smooth g cover compat

lemma glueLocal_eq (i : A) (x : M) (hx : x ∈ (g i).domain) :
    (glueLocal g cover compat).inner x = (g i).inner x :=
  localGluedInner_eq g cover compat i x hx
end

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]

def localPull (g : Metric (E := F) N) (e : OpenPartialHomeomorph M N)
    (hs : ContMDiffOn 𝓘(ℝ,E) 𝓘(ℝ,F) ∞ e e.source)
    (he : e.MDifferentiable 𝓘(ℝ,E) 𝓘(ℝ,F)) : LocalMetric (E := E) M where
  domain := e.source
  open_domain := e.open_source
  inner := pullInner g e
  symm x _ u v := g.symm (e x) _ _
  pos x hx u hu := by
    apply g.pos
    let d := he.mfderiv hx
    exact fun hh => hu (d.injective (hh.trans d.map_zero.symm))
  bounded x hx := by
    let d := he.mfderiv hx
    apply ((g.isVonNBounded (e x)).image d.symm.toContinuousLinearMap).subset
    intro u hu
    exact ⟨d u,hu,d.symm_apply_apply u⟩
  smooth x hx := pullback_inner_smoothAt g ((hs x hx).contMDiffAt (e.open_source.mem_nhds hx))

def localOn (g : Metric (E := E) M) (U : TopologicalSpace.Opens M) : LocalMetric (E := E) M where
  domain := U
  open_domain := U.isOpen
  inner := g.inner
  symm x _ := g.symm x
  pos x _ := g.pos x
  bounded x _ := g.isVonNBounded x
  smooth x _ := g.contMDiff x
end ThreeManifold.MetricConstruction

namespace ThreeManifold.CompactMetric
open MetricConstruction CylinderConstruction
open HyperbolicCore (Surface cusp cuspOpens cuspCoordinates cuspCoordinates_smooth cuspCoordinates_symm_smooth rayOpens)
abbrev WholePiece := Surface × AddCircle (6:ℝ)
abbrev EP := ℂ × ℝ

def wholeCusp (a : ℝ) : TopologicalSpace.Opens WholePiece :=
  ⟨{q | q.1 ∈ cusp a}, (cuspOpens a).isOpen.preimage continuous_fst⟩

def wholeCoordinates (a : ℝ) (ha : 1 < a) : wholeCusp a ≃ₜ HeightCylinder a where
  toFun q := ((cuspCoordinates a ha ⟨q.1.1,q.2⟩).1,
    ( (cuspCoordinates a ha ⟨q.1.1,q.2⟩).2, q.1.2))
  invFun q := ⟨(((cuspCoordinates a ha).symm (q.1,q.2.1)).1,q.2.2),
    ((cuspCoordinates a ha).symm (q.1,q.2.1)).2⟩
  left_inv q := by
    apply Subtype.ext
    apply Prod.ext
    · exact congrArg Subtype.val ((cuspCoordinates a ha).symm_apply_apply ⟨q.1.1,q.2⟩)
    · rfl
  right_inv q := by
    have h := (cuspCoordinates a ha).apply_symm_apply (q.1,q.2.1)
    change ((cuspCoordinates a ha ((cuspCoordinates a ha).symm (q.1,q.2.1))).1,
      (cuspCoordinates a ha ((cuspCoordinates a ha).symm (q.1,q.2.1))).2,q.2.2) = q
    rw [h]
  continuous_toFun := by
    have h := (cuspCoordinates a ha).continuous.comp
      ((continuous_fst.comp continuous_subtype_val).subtype_mk (fun q : wholeCusp a => q.2))
    exact h.fst.prodMk (h.snd.prodMk (continuous_snd.comp continuous_subtype_val))
  continuous_invFun := by
    have h := (cuspCoordinates a ha).symm.continuous.comp
      ((continuous_fst : Continuous (Prod.fst : HeightCylinder a → Ioi a)).prodMk (continuous_fst.comp continuous_snd))
    exact ((continuous_subtype_val.comp h).prodMk (continuous_snd.comp continuous_snd)).subtype_mk (fun q => ((cuspCoordinates a ha).symm (q.1,q.2.1)).2)

lemma wholeCoordinates_smooth (a : ℝ) (ha : 1 < a) :
    ContMDiff 𝓘(ℝ,EP) 𝓘(ℝ,P) ∞ (wholeCoordinates a ha) := by
  have hv : ContMDiff 𝓘(ℝ,EP) 𝓘(ℝ,EP) ∞ (Subtype.val : wholeCusp a → WholePiece) :=
    contMDiff_subtype_val
  have hsub : ContMDiff 𝓘(ℝ,EP) 𝓘(ℝ,ℂ) ∞
      (fun q : wholeCusp a => (⟨q.1.1,q.2⟩ : cusp a)) :=
    (ContMDiff.subtypeVal_comp_iff (cuspOpens a) _).mp (projection_fst_smooth.comp hv)
  have hc := (cuspCoordinates_smooth a ha).comp hsub
  have h0 := hc.fst
  have h1 := hc.snd.prodMk (projection_snd_smooth.comp hv)
  convert! h0.prodMk h1 using 1
  simp only [← modelWithCornersSelf_prod]

lemma wholeCoordinates_symm_smooth (a : ℝ) (ha : 1 < a) :
    ContMDiff 𝓘(ℝ,P) 𝓘(ℝ,EP) ∞ (wholeCoordinates a ha).symm := by
  have h0 : ContMDiff 𝓘(ℝ,P) 𝓘(ℝ,ℂ) ∞
      (fun q : HeightCylinder a => ((cuspCoordinates a ha).symm (q.1,q.2.1)).1) := by
    apply (contMDiff_subtype_val (U := cuspOpens a)).comp
    apply (cuspCoordinates_symm_smooth a ha).comp
    convert! (projection_fst_smooth (E := ℝ) (F := ℝ × ℝ) (M := Ioi a)
      (N := AddCircle (6:ℝ) × AddCircle (6:ℝ))).prodMk
      (projection_fst_smooth.comp projection_snd_smooth) using 1
  have h1 : ContMDiff 𝓘(ℝ,P) 𝓘(ℝ,ℝ) ∞ (fun q : HeightCylinder a => q.2.2) :=
    projection_snd_smooth.comp projection_snd_smooth
  apply (ContMDiff.subtypeVal_comp_iff (wholeCusp a) _).mp
  convert! h0.prodMk h1 using 1
  simp only [← modelWithCornersSelf_prod]

lemma wholeCusp_nonempty (a : ℝ) (ha : 1 < a) : Nonempty (wholeCusp a) := by
  let q : HeightCylinder a := (⟨a+1,show a < a+1 by linarith⟩,0,0)
  exact ⟨(wholeCoordinates a ha).symm q⟩

def cuspChart (a : ℝ) (ha : 1 < a) : OpenPartialHomeomorph WholePiece (HeightCylinder a) :=
  ((wholeCusp a).openPartialHomeomorphSubtypeCoe (wholeCusp_nonempty a ha)).symm.trans
    (wholeCoordinates a ha).toOpenPartialHomeomorph

lemma cuspChart_smooth (a : ℝ) (ha : 1 < a) :
    ContMDiffOn 𝓘(ℝ,EP) 𝓘(ℝ,P) ∞ (cuspChart a ha) (cuspChart a ha).source := by
  intro x hx
  have hx' : x ∈ wholeCusp a := by simpa [cuspChart] using hx
  exact ((wholeCoordinates_smooth a ha) _).comp x
    (openSubtype_inverse_smooth (wholeCusp a) (wholeCusp_nonempty a ha) hx') |>.contMDiffWithinAt
lemma cuspChart_mdifferentiable (a : ℝ) (ha : 1 < a) :
    (cuspChart a ha).MDifferentiable 𝓘(ℝ,EP) 𝓘(ℝ,P) := by
  apply (openSubtype_mdifferentiable (wholeCusp a) (wholeCusp_nonempty a ha)).symm.trans
  exact ⟨((wholeCoordinates_smooth a ha).mdifferentiable (by simp)).mdifferentiableOn,
    ((wholeCoordinates_symm_smooth a ha).mdifferentiable (by simp)).mdifferentiableOn⟩

def cuspMetric (g : Metric (E := P) Cylinder) (a : ℝ) (ha : 1 < a) :
    LocalMetric (E := EP) WholePiece :=
  localPull (heightMetric g a (by linarith)) (cuspChart a ha)
    (cuspChart_smooth a ha) (cuspChart_mdifferentiable a ha)

end ThreeManifold.CompactMetric
end

section
open Matrix
open Set Filter Topology Bundle Manifold IsManifold Bornology
open scoped ContDiff UpperHalfPlane MatrixGroups RealInnerProductSpace
namespace ThreeManifold.MetricConstruction
open HyperbolicCore QuotientConstruction

lemma halfPlane_coe_smooth : ContMDiff 𝓘(ℝ,ℂ) 𝓘(ℝ,ℂ) ∞ ((↑) : ℍ → ℂ) := by
  intro z
  have h := UpperHalfPlane.contMDiff_coe (n := ∞) z
  rw [contMDiffAt_iff] at h ⊢
  exact ⟨h.1,h.2.restrict_scalars ℝ⟩

lemma halfPlane_coe_deriv (z : ℍ) :
    mfderiv 𝓘(ℝ,ℂ) 𝓘(ℝ,ℂ) ((↑) : ℍ → ℂ) z = ContinuousLinearMap.id ℝ ℂ := by
  exact mfderiv_extChartAt_self (I := 𝓘(ℝ,ℂ)) (x := z)

lemma halfPlane_im_smooth : ContMDiff 𝓘(ℝ,ℂ) 𝓘(ℝ,ℝ) ∞ (fun z : ℍ => z.im) :=
  Complex.imCLM.contDiff.comp_contMDiff halfPlane_coe_smooth

def halfPlaneFlat : Metric (E := ℂ) ℍ :=
  pullback (euclidean (V := ℂ)) halfPlane_coe_smooth
    (fun _ => ContinuousLinearEquiv.refl ℝ ℂ) (fun z => (halfPlane_coe_deriv z).symm)

def hyperbolic : Metric (E := ℂ) ℍ :=
  scaleSq halfPlaneFlat (fun z : ℍ => z.im⁻¹)
    (halfPlane_im_smooth.inv₀ (fun z => ne_of_gt z.im_pos))
    (fun z => inv_ne_zero (ne_of_gt z.im_pos))

lemma hyperbolic_inner (z : ℍ) (u v : TangentSpace 𝓘(ℝ,ℂ) z) :
    hyperbolic.inner z u v = z.im⁻¹ ^ 2 * @inner ℝ ℂ _ u v := by
  change z.im⁻¹ ^ 2 * @inner ℝ ℂ _ (mfderiv 𝓘(ℝ,ℂ) 𝓘(ℝ,ℂ) ((↑) : ℍ → ℂ) z u)
    (mfderiv 𝓘(ℝ,ℂ) 𝓘(ℝ,ℂ) ((↑) : ℍ → ℂ) z v) = _
  rw [halfPlane_coe_deriv]
  rfl

lemma halfPlane_action_deriv (g : SL(2,ℤ)) (z : ℍ) :
    mfderiv 𝓘(ℝ,ℂ) 𝓘(ℝ,ℂ) (fun w : ℍ => g • w) z =
    UpperHalfPlane.smulFDeriv (SpecialLinearGroup.mapGL ℝ g) z := by
  apply HasMFDerivAt.mfderiv
  constructor
  · exact (action_smooth g).continuous.continuousAt
  · have hd := (UpperHalfPlane.hasStrictFDerivAt_smul (SpecialLinearGroup.mapGL ℝ g) z).hasFDerivAt
    apply HasFDerivAt.hasFDerivWithinAt
    apply hd.congr_of_eventuallyEq
    filter_upwards [(chartAt ℂ z).open_target.mem_nhds (mem_chart_target ℂ z)] with y hy
    have hy' : ((chartAt ℂ z).symm y : ℂ) = y := (chartAt ℂ z).right_inv hy
    have ho : UpperHalfPlane.ofComplex y = (chartAt ℂ z).symm y := by
      exact (congrArg UpperHalfPlane.ofComplex hy'.symm).trans (UpperHalfPlane.ofComplex_apply _)
    rw [ho]
    rfl

lemma halfPlane_action_deriv_apply (g : SL(2,ℤ)) (z : ℍ) (u : ℂ) :
    mfderiv 𝓘(ℝ,ℂ) 𝓘(ℝ,ℂ) (fun w : ℍ => g • w) z u =
      u / (UpperHalfPlane.denom (SpecialLinearGroup.mapGL ℝ g) z) ^ 2 := by
  rw [halfPlane_action_deriv]
  have hd : (SpecialLinearGroup.mapGL ℝ g).det.val = 1 := mapGL_det g
  simp only [UpperHalfPlane.smulFDeriv,UpperHalfPlane.σ,hd,zero_lt_one,ite_eq_left]
  change u * ((1 : ℂ) / UpperHalfPlane.denom (SpecialLinearGroup.mapGL ℝ g) z ^ 2) = _
  simp [div_eq_mul_inv]

lemma hyperbolic_action_quadratic (g : SL(2,ℤ)) (z : ℍ) (u : TangentSpace 𝓘(ℝ,ℂ) z) :
    pullInner hyperbolic (fun w : ℍ => g • w) z u u = hyperbolic.inner z u u := by
  let D : ℂ := UpperHalfPlane.denom (SpecialLinearGroup.mapGL ℝ g) z
  let u' : ℂ := u
  have hi : (g • z).im = z.im / ‖D‖ ^ 2 := by
    change (SpecialLinearGroup.mapGL ℝ g • z).im = _
    rw [UpperHalfPlane.im_smul_eq_div_normSq]
    simp [Complex.normSq_eq_norm_sq,D]
  have hs : (g • z).im⁻¹ ^ 2 * inner ℝ (u' / D ^ 2) (u' / D ^ 2) =
      z.im⁻¹ ^ 2 * inner ℝ u' u' := by
    rw [real_inner_self_eq_norm_sq,real_inner_self_eq_norm_sq,hi,norm_div,norm_pow]
    have hn : ‖D‖ ≠ 0 := norm_ne_zero_iff.mpr (UpperHalfPlane.denom_ne_zero _ z)
    field_simp
  rw [pullInner_apply]
  calc
    _ = (g • z).im⁻¹ ^ 2 * inner ℝ (u' / D ^ 2) (u' / D ^ 2) :=
      (hyperbolic_inner _ _ _).trans
        (congrArg (fun w : ℂ => (g • z).im⁻¹ ^ 2 * inner ℝ w w)
          (halfPlane_action_deriv_apply g z u'))
    _ = z.im⁻¹ ^ 2 * inner ℝ u' u' := hs
    _ = hyperbolic.inner z u u := (hyperbolic_inner z u u).symm

lemma hyperbolic_action_invariant (g : SL(2,ℤ)) (z : ℍ) :
    pullInner hyperbolic (fun w : ℍ => g • w) z = hyperbolic.inner z := by
  ext u v
  have h := hyperbolic_action_quadratic g z (u+v)
  have hu := hyperbolic_action_quadratic g z u
  have hv := hyperbolic_action_quadratic g z v
  have hs : ∀ u v : TangentSpace 𝓘(ℝ,ℂ) z, pullInner hyperbolic (fun w : ℍ => g • w) z u v =
      pullInner hyperbolic (fun w : ℍ => g • w) z v u := by
    intro u v
    exact hyperbolic.symm _ _ _
  simp only [map_add,_root_.add_apply] at h
  rw [hs v u,hyperbolic.symm z v u] at h
  linarith

lemma hyperbolic_effective_invariant (g : effective) (z : ℍ) :
    pullInner hyperbolic (fun w : ℍ => g • w) z = hyperbolic.inner z := by
  obtain ⟨a,rfl⟩ := effect_surjective g
  exact hyperbolic_action_invariant a.val z

def surfaceHyperbolic : Metric (E := ℂ) Surface :=
  descend projection_cover projection_smooth effective_smooth
    (local_lift_smoothAt projection_cover sectionMap_rightInverse effective_smooth)
    hyperbolic hyperbolic_effective_invariant sectionMap_rightInverse

lemma surface_projection_isometry (z : ℍ) :
    pullInner surfaceHyperbolic projection z = hyperbolic.inner z :=
  descend_projection projection_cover projection_smooth effective_smooth
    (local_lift_smoothAt projection_cover sectionMap_rightInverse effective_smooth)
    hyperbolic hyperbolic_effective_invariant sectionMap_rightInverse z

end ThreeManifold.MetricConstruction
end

section
open Set Filter Topology Bundle Manifold IsManifold Bornology
open scoped ContDiff
namespace ThreeManifold.MetricConstruction
variable {E F V M N X : Type*}
  [NormedAddCommGroup E] [NormedSpace ℝ E]
  [NormedAddCommGroup F] [NormedSpace ℝ F]
  [NormedAddCommGroup V] [NormedSpace ℝ V]
  [TopologicalSpace M] [ChartedSpace E M] [IsManifold 𝓘(ℝ,E) ∞ M]
  [TopologicalSpace N] [ChartedSpace F N] [IsManifold 𝓘(ℝ,F) ∞ N]
  [TopologicalSpace X] [ChartedSpace V X] [IsManifold 𝓘(ℝ,V) ∞ X]

lemma product_apply (g : Metric (E := E) M) (h : Metric (E := F) N) (x : M × N)
    (u v : TangentSpace 𝓘(ℝ,E × F) x) :
    (product g h).inner x u v = g.inner x.1 u.1 v.1 + h.inner x.2 u.2 v.2 :=
  productInner_apply g h x u v

omit [IsManifold 𝓘(ℝ,V) ∞ X] in
lemma pull_product {f : X → M} {k : X → N} {x : X}
    (hf : MDifferentiableAt 𝓘(ℝ,V) 𝓘(ℝ,E) f x)
    (hk : MDifferentiableAt 𝓘(ℝ,V) 𝓘(ℝ,F) k x)
    (g : Metric (E := E) M) (h : Metric (E := F) N) :
    pullInner (E := V) (product g h) (fun y => (f y,k y)) x = pullInner (E := V) g f x + pullInner (E := V) h k x := by
  ext u v
  rw [pullInner_apply,product_apply]
  have hd : mfderiv 𝓘(ℝ,V) 𝓘(ℝ,E × F) (fun y => (f y,k y)) x =
      (mfderiv 𝓘(ℝ,V) 𝓘(ℝ,E) f x).prod (mfderiv 𝓘(ℝ,V) 𝓘(ℝ,F) k x) := by
    convert! mfderiv_prodMk hf hk using 1
  rw [hd]
  rfl

omit [IsManifold 𝓘(ℝ,V) ∞ X] in
lemma pull_scaleSq (g : Metric (E := E) M) (r : M → ℝ)
    (hr : ContMDiff 𝓘(ℝ,E) 𝓘(ℝ,ℝ) ∞ r) (hp : ∀ x, r x ≠ 0)
    (f : X → M) (x : X) (u v : TangentSpace 𝓘(ℝ,V) x) :
    pullInner (scaleSq g r hr hp) f x u v = r (f x)^2 * pullInner (E := V) g f x u v := rfl
end ThreeManifold.MetricConstruction
end

section
open Set Filter Topology Bundle Manifold IsManifold Bornology
open scoped ContDiff UpperHalfPlane RealInnerProductSpace
namespace ThreeManifold.CompactMetric
open MetricConstruction
abbrev UniversalPiece := ℍ × ℝ

def sourceProjection : UniversalPiece → WholePiece :=
  Prod.map HyperbolicCore.projection ((↑) : ℝ → AddCircle (6:ℝ))
lemma sourceProjection_smooth : ContMDiff 𝓘(ℝ,EP) 𝓘(ℝ,EP) ∞ sourceProjection := by
  convert! HyperbolicCore.projection_smooth.prodMap (CircleConstruction.projection_smooth 6) using 1
  all_goals simp only [EP, ← modelWithCornersSelf_prod]
lemma sourceProjection_deriv (x : UniversalPiece) :
    mfderiv 𝓘(ℝ,EP) 𝓘(ℝ,EP) sourceProjection x =
      (mfderiv 𝓘(ℝ,ℂ) 𝓘(ℝ,ℂ) HyperbolicCore.projection x.1).prodMap
        (mfderiv 𝓘(ℝ,ℝ) 𝓘(ℝ,ℝ) ((↑) : ℝ → AddCircle (6:ℝ)) x.2) := by
  convert! mfderiv_prodMap ((HyperbolicCore.projection_smooth x.1).mdifferentiableAt (by simp))
    ((CircleConstruction.projection_smooth 6 x.2).mdifferentiableAt (by simp)) using 1

lemma sourceProjection_deriv_surjective (x : UniversalPiece) :
    Function.Surjective (mfderiv 𝓘(ℝ,EP) 𝓘(ℝ,EP) sourceProjection x) := by
  let ds := coveringDerivative HyperbolicCore.projection_cover HyperbolicCore.projection_smooth
    (QuotientConstruction.local_lift_smoothAt HyperbolicCore.projection_cover
      HyperbolicCore.sectionMap_rightInverse HyperbolicCore.effective_smooth) x.1
  let dc := coveringDerivative (CircleConstruction.projection_cover 6) (CircleConstruction.projection_smooth 6)
    (fun a _ h => QuotientConstruction.local_lift_smoothAt (CircleConstruction.projection_cover 6)
      (CircleConstruction.section_spec 6) (CircleConstruction.action_smooth 6) a h) x.2
  have hs : ds.toContinuousLinearMap = mfderiv 𝓘(ℝ,ℂ) 𝓘(ℝ,ℂ) HyperbolicCore.projection x.1 :=
    coveringDerivative_eq _ _ _ _
  have hc : dc.toContinuousLinearMap = mfderiv 𝓘(ℝ,ℝ) 𝓘(ℝ,ℝ) ((↑) : ℝ → AddCircle (6:ℝ)) x.2 :=
    coveringDerivative_eq _ _ _ _
  rw [sourceProjection_deriv,← hs,← hc]
  exact ds.surjective.prodMap dc.surjective

def coreMetric (c : ℝ) (hc : c ≠ 0) : Metric (E := EP) WholePiece :=
  product surfaceHyperbolic (scaleSq (circle 6) (fun _ => c) contMDiff_const (fun _ => hc))
lemma coreMetric_apply (c : ℝ) (hc : c ≠ 0) (q : WholePiece)
    (u v : EP) :
    (coreMetric c hc).inner q u v = surfaceHyperbolic.inner q.1 u.1 v.1 +
      c^2*(circle 6).inner q.2 u.2 v.2 :=
  productInner_apply surfaceHyperbolic _ q u v
lemma coreMetric_projection (c : ℝ) (hc : c ≠ 0) (x : UniversalPiece)
    (u v : EP) :
    pullInner (E := EP) (coreMetric c hc) sourceProjection x u v =
      x.1.im⁻¹^2 * inner ℝ u.1 v.1 + c^2*u.2*v.2 := by
  have hs := congrArg (fun B : ℂ →L[ℝ] ℂ →L[ℝ] ℝ => B u.1 v.1)
    (surface_projection_isometry x.1)
  have ht := congrArg (fun B : ℝ →L[ℝ] ℝ →L[ℝ] ℝ => B u.2 v.2)
    (circle_projection 6 x.2)
  let ds := mfderiv 𝓘(ℝ,ℂ) 𝓘(ℝ,ℂ) HyperbolicCore.projection x.1
  let dc := mfderiv 𝓘(ℝ,ℝ) 𝓘(ℝ,ℝ) ((↑) : ℝ → AddCircle (6:ℝ)) x.2
  have hdu : mfderiv 𝓘(ℝ,EP) 𝓘(ℝ,EP) sourceProjection x u = (ds u.1,dc u.2) :=
    congrArg (fun D : EP →L[ℝ] EP => D u) (sourceProjection_deriv x)
  have hdv : mfderiv 𝓘(ℝ,EP) 𝓘(ℝ,EP) sourceProjection x v = (ds v.1,dc v.2) :=
    congrArg (fun D : EP →L[ℝ] EP => D v) (sourceProjection_deriv x)
  calc
    _ = (coreMetric c hc).inner (sourceProjection x) (ds u.1,dc u.2) (ds v.1,dc v.2) :=
      congrArg₂ (fun a b : EP => (coreMetric c hc).inner (sourceProjection x) a b) hdu hdv
    _ = surfaceHyperbolic.inner (HyperbolicCore.projection x.1) (ds u.1) (ds v.1) +
        c^2*(circle 6).inner (x.2 : AddCircle (6:ℝ)) (dc u.2) (dc v.2) :=
      coreMetric_apply c hc _ _ _
    _ = hyperbolic.inner x.1 u.1 v.1 + c^2*(u.2*v.2) :=
      congrArg₂ (fun a b : ℝ => a+c^2*b) hs (ht.trans (by
        change inner ℝ u.2 v.2 = u.2*v.2
        simp [mul_comm]))
    _ = x.1.im⁻¹^2 * inner ℝ u.1 v.1 + c^2*(u.2*v.2) :=
      congrArg (fun a : ℝ => a+c^2*(u.2*v.2)) (hyperbolic_inner x.1 u.1 v.1)
    _ = x.1.im⁻¹^2 * inner ℝ u.1 v.1 + c^2*u.2*v.2 := by ring
end ThreeManifold.CompactMetric
end

section
open Set Filter Topology Bundle Manifold IsManifold Bornology
open scoped ContDiff
namespace ThreeManifold.MetricConstruction
variable {E F H M N Q : Type*}
  [NormedAddCommGroup E] [NormedSpace ℝ E]
  [NormedAddCommGroup F] [NormedSpace ℝ F]
  [NormedAddCommGroup H] [NormedSpace ℝ H]
  [TopologicalSpace M] [ChartedSpace E M]
  [TopologicalSpace N] [ChartedSpace F N]
  [TopologicalSpace Q] [ChartedSpace H Q] [IsManifold 𝓘(ℝ,H) ∞ Q]
variable {G : Type*} [Group G] [MulAction G M]
  [IsManifold 𝓘(ℝ,E) ∞ M]
  {X : Type*} [TopologicalSpace X] [ChartedSpace E X] [IsManifold 𝓘(ℝ,E) ∞ X]
  {p : M → X} (hp : IsQuotientCoveringMap p G)
  (hps : ContMDiff 𝓘(ℝ,E) 𝓘(ℝ,E) ∞ p)
  (hls : ∀ (b : M) {q : X}, q ∈ (hp.isCoveringMap.isLocalHomeomorph.localInverseAt b).source →
    ContMDiffAt 𝓘(ℝ,E) 𝓘(ℝ,E) ∞ (hp.isCoveringMap.isLocalHomeomorph.localInverseAt b) q)
  {f : X → X} {lift : M → M}
  (hf : ContMDiff 𝓘(ℝ,E) 𝓘(ℝ,E) ∞ f)
  (hl : ContMDiff 𝓘(ℝ,E) 𝓘(ℝ,E) ∞ lift)
  (comm : f ∘ p = p ∘ lift)
  (dl : M → E ≃L[ℝ] E)
  (hdl : ∀ x, (dl x).toContinuousLinearMap = mfderiv 𝓘(ℝ,E) 𝓘(ℝ,E) lift x)
  {σ : X → M} (hσ : Function.RightInverse σ p)
lemma pullbackFromLift_projection (g : Metric (E := E) X) (x : M) :
    pullInner (E := E) (pullbackFromLift hp hps hls hf hl comm dl hdl hσ g) p x =
      pullBilin (E := E) (F := E) (pullInner g p (lift x))
        (mfderiv 𝓘(ℝ,E) 𝓘(ℝ,E) lift x) := by
  let _ : IsManifold 𝓘(ℝ, E) ∞ M := inferInstance
  change pullBilin (E := E) (F := E) (pullInner g f (p x))
    (mfderiv 𝓘(ℝ,E) 𝓘(ℝ,E) p x) = _
  rw [← pull_composition g ((hps x).mdifferentiableAt (by simp))
    ((hf _).mdifferentiableAt (by simp)), comm]
  exact pull_composition g ((hl x).mdifferentiableAt (by simp))
    ((hps _).mdifferentiableAt (by simp))
end ThreeManifold.MetricConstruction
end

section
open Set Filter Topology Bundle Manifold IsManifold Bornology
open scoped ContDiff UpperHalfPlane
namespace ThreeManifold.CompactMetric
open MetricConstruction CylinderConstruction

def heightToCylinder (a : ℝ) (ha : 0 < a) : HeightCylinder a → Cylinder :=
  Subtype.val ∘ logCylinderHomeomorph a ha
lemma heightToCylinder_smooth (a : ℝ) (ha : 0 < a) :
    ContMDiff 𝓘(ℝ,P) 𝓘(ℝ,P) ∞ (heightToCylinder a ha) :=
  (contMDiff_subtype_val (U := logDomain a)).comp (logCylinder_smooth a ha)
lemma heightMetric_inner (g : Metric (E := P) Cylinder) (a : ℝ) (ha : 0 < a) (q : HeightCylinder a) :
    (heightMetric g a ha).inner q = pullInner (E := P) g (heightToCylinder a ha) q := by
  change pullBilin (E := P) (F := P)
    (pullInner g (Subtype.val : logDomain a → Cylinder) ((logCylinderHomeomorph a ha) q))
      (mfderiv 𝓘(ℝ,P) 𝓘(ℝ,P) (logCylinderHomeomorph a ha) q) = _
  exact (pull_composition g ((logCylinder_smooth a ha q).mdifferentiableAt (by simp))
    ((contMDiff_subtype_val (U := logDomain a) (n := ∞) _).mdifferentiableAt (by simp))).symm

def logCuspMap (a : ℝ) (ha : 1 < a) : WholePiece → Cylinder :=
  heightToCylinder a (by linarith) ∘ cuspChart a ha
lemma logCuspMap_smoothAt (a : ℝ) (ha : 1 < a) {x : WholePiece} (hx : x ∈ wholeCusp a) :
    ContMDiffAt 𝓘(ℝ,EP) 𝓘(ℝ,P) ∞ (logCuspMap a ha) x := by
  have hs : x ∈ (cuspChart a ha).source := by simpa [cuspChart] using hx
  exact ((heightToCylinder_smooth a (by linarith)) _).comp x
    ((cuspChart_smooth a ha x hs).contMDiffAt ((cuspChart a ha).open_source.mem_nhds hs))
lemma cuspMetric_inner (g : Metric (E := P) Cylinder) (a : ℝ) (ha : 1 < a)
    {x : WholePiece} (hx : x ∈ wholeCusp a) :
    (cuspMetric g a ha).inner x = pullInner (E := EP) g (logCuspMap a ha) x := by
  have hs : x ∈ (cuspChart a ha).source := by simpa [cuspChart] using hx
  change pullBilin (E := EP) (F := P) ((heightMetric g a (by linarith)).inner (cuspChart a ha x))
    (mfderiv 𝓘(ℝ,EP) 𝓘(ℝ,P) (cuspChart a ha) x) = _
  rw [heightMetric_inner]
  exact (pull_composition g
    (((cuspChart_smooth a ha x hs).contMDiffAt ((cuspChart a ha).open_source.mem_nhds hs)).mdifferentiableAt (by simp))
    (((heightToCylinder_smooth a (by linarith)) _).mdifferentiableAt (by simp))).symm

def logarithmicLift (x : UniversalPiece) : P := (Real.log x.1.im,x.1.re,x.2)
lemma logarithmicLift_smooth : ContMDiff 𝓘(ℝ,EP) 𝓘(ℝ,P) ∞ logarithmicLift := by
  have hi : ContMDiff 𝓘(ℝ,EP) 𝓘(ℝ,ℝ) ∞ (fun x : UniversalPiece => Real.log x.1.im) :=
    fun x => (Real.contDiffAt_log.mpr x.1.im_pos.ne').contMDiffAt.comp x
      ((halfPlane_im_smooth.comp projection_fst_smooth) x)
  have hr : ContMDiff 𝓘(ℝ,EP) 𝓘(ℝ,ℝ) ∞ (fun x : UniversalPiece => x.1.re) :=
    HyperbolicCore.upperHalfPlane_re_smooth.comp projection_fst_smooth
  exact hi.prodMk_space (hr.prodMk_space projection_snd_smooth)

lemma logCusp_projection_apply (a : ℝ) (ha : 1 < a) (x : UniversalPiece) (hx : a < x.1.im) :
    logCuspMap a ha (sourceProjection x) = projection (logarithmicLift x) := by
  have hul : sourceProjection x ∈ wholeCusp a := ⟨x.1,hx,rfl⟩
  have hsub : ((wholeCusp a).openPartialHomeomorphSubtypeCoe (wholeCusp_nonempty a ha)).symm
      (sourceProjection x) = ⟨sourceProjection x,hul⟩ :=
    ((wholeCusp a).openPartialHomeomorphSubtypeCoe (wholeCusp_nonempty a ha)).left_inv (x := ⟨sourceProjection x,hul⟩) (by simp)
  have hc := HyperbolicCore.cuspCoordinates_apply a ha x.1 hx
  change ((heightToCylinder a (by linarith)) ((wholeCoordinates a ha)
    (((wholeCusp a).openPartialHomeomorphSubtypeCoe (wholeCusp_nonempty a ha)).symm (sourceProjection x)))) = _
  rw [hsub]
  change (Real.log ((HyperbolicCore.cuspCoordinates a ha ⟨HyperbolicCore.projection x.1,_⟩).1 : ℝ),
    (HyperbolicCore.cuspCoordinates a ha ⟨HyperbolicCore.projection x.1,_⟩).2,(x.2 : AddCircle (6:ℝ))) = _
  rw [hc]
  rfl
lemma logCusp_projection_germ (a : ℝ) (ha : 1 < a) {x : UniversalPiece} (hx : a < x.1.im) :
    (logCuspMap a ha ∘ sourceProjection) =ᶠ[nhds x] (projection ∘ logarithmicLift) := by
  have hh : ∀ᶠ y : UniversalPiece in nhds x, a < y.1.im :=
    (UpperHalfPlane.continuous_im.comp continuous_fst).continuousAt (isOpen_Ioi.mem_nhds hx)
  filter_upwards [hh] with y hy
  exact logCusp_projection_apply a ha y hy

lemma cuspMetric_projection (g : Metric (E := P) Cylinder) (a : ℝ) (ha : 1 < a)
    {x : UniversalPiece} (hx : a < x.1.im) :
    pullBilin (E := EP) (F := EP) ((cuspMetric g a ha).inner (sourceProjection x))
      (mfderiv 𝓘(ℝ,EP) 𝓘(ℝ,EP) sourceProjection x) =
    pullBilin (E := EP) (F := P) (pullInner g projection (logarithmicLift x))
      (mfderiv 𝓘(ℝ,EP) 𝓘(ℝ,P) logarithmicLift x) := by
  rw [cuspMetric_inner g a ha (show sourceProjection x ∈ wholeCusp a from ⟨x.1,hx,rfl⟩)]
  rw [← pull_composition g ((sourceProjection_smooth x).mdifferentiableAt (by simp))
    ((logCuspMap_smoothAt a ha ⟨x.1,hx,rfl⟩).mdifferentiableAt (by simp))]
  rw [pullInner_congr g (logCusp_projection_germ a ha hx)]
  exact pull_composition g ((logarithmicLift_smooth x).mdifferentiableAt (by simp))
    ((projection_smooth _).mdifferentiableAt (by simp))
end ThreeManifold.CompactMetric
end

section
open Set Filter Topology Bundle Manifold IsManifold Bornology
open scoped ContDiff UpperHalfPlane RealInnerProductSpace
namespace ThreeManifold.CompactMetric
open MetricConstruction CylinderConstruction

def universalCoordinates (x : UniversalPiece) : EP := (x.1,x.2)
lemma universalCoordinates_smooth : ContMDiff 𝓘(ℝ,EP) 𝓘(ℝ,EP) ∞ universalCoordinates := by
  exact (halfPlane_coe_smooth.comp projection_fst_smooth).prodMk_space projection_snd_smooth
lemma universalCoordinates_deriv (x : UniversalPiece) :
    mfderiv 𝓘(ℝ,EP) 𝓘(ℝ,EP) universalCoordinates x = ContinuousLinearMap.id ℝ EP := by
  change mfderiv 𝓘(ℝ,EP) 𝓘(ℝ,EP) (extChartAt 𝓘(ℝ,EP) x) x = _
  exact mfderiv_extChartAt_self

def logLinear (y : ℝ) : EP →L[ℝ] P :=
  ((y⁻¹ • Complex.imCLM).comp (ContinuousLinearMap.fst ℝ ℂ ℝ)).prod
    ((Complex.reCLM.comp (ContinuousLinearMap.fst ℝ ℂ ℝ)).prod
      (ContinuousLinearMap.snd ℝ ℂ ℝ))
lemma logLinear_apply (y : ℝ) (u : EP) : logLinear y u = (y⁻¹*u.1.im,u.1.re,u.2) := rfl

def logNormed (x : EP) : P := (Real.log x.1.im, x.1.re, x.2)
lemma logNormed_deriv {x : EP} (hx : x.1.im ≠ 0) :
    HasFDerivAt logNormed (logLinear x.1.im) x := by
  have hi : HasFDerivAt (fun x : EP => x.1.im)
      (Complex.imCLM.comp (ContinuousLinearMap.fst ℝ ℂ ℝ)) x :=
    Complex.imCLM.hasFDerivAt.comp x (ContinuousLinearMap.fst ℝ ℂ ℝ).hasFDerivAt
  have hl := (Real.hasDerivAt_log hx).comp_hasFDerivAt x hi
  have hr := Complex.reCLM.hasFDerivAt.comp x (ContinuousLinearMap.fst ℝ ℂ ℝ).hasFDerivAt
  convert! hl.prodMk (hr.prodMk (ContinuousLinearMap.snd ℝ ℂ ℝ).hasFDerivAt) using 1

lemma logarithmicLift_deriv (x : UniversalPiece) :
    mfderiv 𝓘(ℝ,EP) 𝓘(ℝ,P) logarithmicLift x = logLinear x.1.im := by
  have he : logarithmicLift = logNormed ∘ universalCoordinates := rfl
  rw [he,mfderiv_comp x
    ((logNormed_deriv (x := universalCoordinates x) x.1.im_pos.ne').differentiableAt.mdifferentiableAt)
    ((universalCoordinates_smooth x).mdifferentiableAt (by simp)),universalCoordinates_deriv]
  rw [mfderiv_eq_fderiv]
  change (fderiv ℝ logNormed (universalCoordinates x)).comp (ContinuousLinearMap.id ℝ EP) = logLinear x.1.im
  rw [(logNormed_deriv (x := universalCoordinates x) x.1.im_pos.ne').fderiv]
  rfl
end ThreeManifold.CompactMetric
end

section
open Set Filter Topology
namespace ThreeManifold.CompactMetric
open CylinderConstruction

def period (δ : ℝ) : ℝ := 6 / (Real.exp 4 * Collar.ell δ (-1))
def leftLength (δ : ℝ) : ℝ := 4-2*Real.log δ

def leftCircleScale (δ : ℝ) : ℝ := period δ/6 * Collar.ell δ 1
def rightCircleScale (δ : ℝ) : ℝ := δ^2*period δ/6 * Collar.ell δ 1
lemma period_pos (δ : ℝ) : 0 < period δ :=
  div_pos (by norm_num) (mul_pos (Real.exp_pos _) (Collar.ell_pos _ _))
lemma leftCircleScale_pos (δ : ℝ) : 0 < leftCircleScale δ :=
  mul_pos (div_pos (period_pos δ) (by norm_num)) (Collar.ell_pos _ _)
lemma rightCircleScale_pos {δ : ℝ} (hδ : 0 < δ) : 0 < rightCircleScale δ :=
  mul_pos (div_pos (mul_pos (sq_pos_of_pos hδ) (period_pos δ)) (by norm_num)) (Collar.ell_pos _ _)
lemma leftLength_ge {δ : ℝ} (hδ : δ ∈ Ioc 0 (1/2)) : 4 ≤ leftLength δ := by
  have hl : Real.log δ ≤ 0 := Real.log_nonpos hδ.1.le (by linarith [hδ.2])
  unfold leftLength
  linarith
lemma exp_leftLength {δ : ℝ} (hδ : 0 < δ) : Real.exp (leftLength δ) = Real.exp 4 / δ^2 := by
  rw [leftLength,Real.exp_sub]
  congr 1
  rw [show 2*Real.log δ = Real.log (δ^2) by rw [Real.log_pow]; norm_num, Real.exp_log (sq_pos_of_pos hδ)]
lemma ell_plateau {δ t : ℝ} (hδ : δ ∈ Icc 0 (1/2)) (ht : 2/3 ≤ t) :
    Collar.ell δ t = Collar.ell δ 1 := by
  rw [Collar.ell_end_germ hδ (by linarith),Collar.ell_end_germ hδ (by norm_num)]
  rw [Cometric.A_plateau ht (by norm_num : (2/3:ℝ) ≤ 1)]
lemma radius₁_left_exact {δ r : ℝ} (hδ : δ ∈ Ioc 0 (1/2)) (hr : r ≤ 1/4) :
    radius₁ δ (period δ) (RadialProfile.coordinate (leftLength δ) r) = Real.exp (-r) := by
  have hL := leftLength_ge hδ
  rw [RadialProfile.coordinate_left hr]
  unfold radius₁
  rw [Collar.ell_cusp_germ ⟨hδ.1.le,hδ.2⟩ (by linarith)]
  rw [show -(r-leftLength δ-1+1) = leftLength δ-r by ring,Real.exp_sub,exp_leftLength hδ.1]
  unfold period
  rw [Real.exp_neg]
  field_simp [hδ.1.ne',(Real.exp_pos 4).ne',(Collar.ell_pos δ (-1)).ne']
lemma radius₂_left_exact {δ r : ℝ} (hδ : δ ∈ Ioc 0 (1/2)) (hr : r ≤ 1/4) :
    radius₂ δ (period δ) (RadialProfile.coordinate (leftLength δ) r) = leftCircleScale δ := by
  rw [RadialProfile.coordinate_left hr]
  unfold radius₂ leftCircleScale
  rw [ell_plateau ⟨hδ.1.le,hδ.2⟩ (by linarith [leftLength_ge hδ])]
lemma radius₂_right_exact {δ r : ℝ} (hδ : δ ∈ Ioc 0 (1/2)) (hr : r ≤ 1/4) :
    radius₂ δ (period δ) (1-RadialProfile.coordinate 4 r) = Real.exp (-r) := by
  rw [RadialProfile.coordinate_left hr]
  unfold radius₂
  rw [show 1-(1-(r-4-1)) = r-4-1 by ring,
    Collar.ell_cusp_germ ⟨hδ.1.le,hδ.2⟩ (by linarith)]
  rw [show -(r-4-1+1) = (4:ℝ)-r by ring,Real.exp_sub]
  unfold period
  rw [Real.exp_neg]
  field_simp [(Real.exp_pos 4).ne',(Collar.ell_pos δ (-1)).ne']
lemma radius₁_right_exact {δ r : ℝ} (hδ : δ ∈ Ioc 0 (1/2)) (hr : r ≤ 1/4) :
    radius₁ δ (period δ) (1-RadialProfile.coordinate 4 r) = rightCircleScale δ := by
  rw [RadialProfile.coordinate_left hr]
  unfold radius₁ rightCircleScale
  rw [ell_plateau ⟨hδ.1.le,hδ.2⟩ (by linarith)]
lemma slope_left_exact {L r : ℝ} (hr : r < 1/4) : RadialProfile.slope L r = 1 := by
  have he : RadialProfile.coordinate L =ᶠ[nhds r] fun t => t-L-1 := by
    filter_upwards [Iio_mem_nhds hr] with t ht
    exact RadialProfile.coordinate_left ht.le
  exact (RadialProfile.coordinate_deriv L r).deriv.symm.trans
    (he.deriv_eq.trans (((hasDerivAt_id r).sub_const L).sub_const 1).deriv)
end ThreeManifold.CompactMetric
end

section
open Set Filter Topology Bundle Manifold IsManifold Bornology
open scoped ContDiff
namespace ThreeManifold.CompactMetric
open MetricConstruction CylinderConstruction

lemma neck_projection_apply {δ B : ℝ} (hδ : δ ∈ Ioc 0 (1/2)) (hB : 0 < B)
    (x : P) (u v : P) :
    pullInner (E := P) (neck hδ hB) projection x u v =
      u.1*v.1 + radius₁ δ B x.1 ^2 * (u.2.1-Cometric.χ x.1*u.2.2)*
        (v.2.1-Cometric.χ x.1*v.2.2) + radius₂ δ B x.1 ^2*u.2.2*v.2.2 := by
  rw [show pullInner (E := P) (neck hδ hB) projection x =
    (lifted (radius₁_smooth ⟨hδ.1.le,hδ.2⟩ B) (radius₂_smooth ⟨hδ.1.le,hδ.2⟩ B) Cometric.χ_smooth
      (fun t => (radius₁_pos hδ.1 hB t).ne') (fun t => (radius₂_pos hB t).ne')).inner x from
      metric_projection _ _ _ _ _ x]
  exact lifted_apply _ _ _ _ _ x u v

lemma radialPull_projection (g : Metric (E := P) Cylinder) {L : ℝ} (hL : 4 ≤ L)
    (x : P) (u v : P) :
    pullInner (E := P) (radialPull g hL) projection x u v =
      pullInner (E := P) g projection (radialLift L x)
        (RadialProfile.slope L x.1*u.1,u.2) (RadialProfile.slope L x.1*v.1,v.2) := by
  have hh := pullbackFromLift_projection projection_cover projection_smooth local_inverse_smooth
    (radial_smooth L) (radialLift_smooth L) (radial_commutes L)
    (fun x => radialLinear (RadialProfile.slope L x.1) (RadialProfile.slope_pos hL x.1).ne')
    (radialLift_deriv hL) section_spec g x
  change pullInner (E := P) (radialPull g hL) projection x = _ at hh
  rw [hh,← radialLift_deriv hL x]
  rfl

def switchLift (x : P) : P := (1-x.1, x.2.1+x.2.2,x.2.1)
def switchLinear : P ≃L[ℝ] P :=
  { toFun := fun v => (-v.1, v.2.1+v.2.2,v.2.1)
    invFun := fun v => (-v.1, v.2.2,v.2.1-v.2.2)
    left_inv := by intro v; ext <;> simp
    right_inv := by intro v; ext <;> simp
    map_add' := by intro v w; ext <;> dsimp <;> ring
    map_smul' := by intro a v; ext <;> dsimp <;> ring }
lemma switchLift_eq (x : P) : switchLift x = switchLinear x + (1,0,0) := by
  ext <;> simp [switchLift,switchLinear,sub_eq_add_neg,add_comm]
lemma switchLift_smooth : ContMDiff 𝓘(ℝ,P) 𝓘(ℝ,P) ∞ switchLift := by
  have he : switchLift = fun x => switchLinear x + (1,0,0) := funext switchLift_eq
  rw [he]
  exact switchLinear.contDiff.contMDiff.add contMDiff_const
lemma switchLift_deriv (x : P) :
    mfderiv 𝓘(ℝ,P) 𝓘(ℝ,P) switchLift x = switchLinear.toContinuousLinearMap := by
  rw [mfderiv_eq_fderiv]
  change fderiv ℝ switchLift x = switchLinear.toContinuousLinearMap
  have he : switchLift = fun x => switchLinear x + (1,0,0) := funext switchLift_eq
  rw [he]
  exact (switchLinear.hasFDerivAt.add_const (1,0,0)).fderiv
lemma switch_commutes : switch ∘ projection = projection ∘ switchLift := by
  funext x
  apply Prod.ext
  · rfl
  · apply Prod.ext
    · exact (AddCircle.coe_add (6:ℝ) x.2.1 x.2.2).symm
    · rfl

lemma switched_projection (g : Metric (E := P) Cylinder) (x : P) :
    pullInner (E := P) (switched g) projection x =
      pullBilin (E := P) (F := P) (pullInner g projection (switchLift x)) switchLinear.toContinuousLinearMap := by
  change pullBilin (E := P) (F := P) (pullInner g switch (projection x))
    (mfderiv 𝓘(ℝ,P) 𝓘(ℝ,P) projection x) = _
  rw [← pull_composition g ((projection_smooth x).mdifferentiableAt (by simp))
    ((switch_smooth _).mdifferentiableAt (by simp)),switch_commutes]
  rw [pull_composition g ((switchLift_smooth x).mdifferentiableAt (by simp))
    ((projection_smooth _).mdifferentiableAt (by simp)),switchLift_deriv]

def leftCylinder {δ : ℝ} (hδ : δ ∈ Ioc 0 (1/2)) : Metric (E := P) Cylinder :=
  radialPull (neck hδ (period_pos δ)) (leftLength_ge hδ)
def rightCylinder {δ : ℝ} (hδ : δ ∈ Ioc 0 (1/2)) : Metric (E := P) Cylinder :=
  radialPull (switched (neck hδ (period_pos δ))) (L := 4) le_rfl

lemma leftCylinder_low {δ : ℝ} (hδ : δ ∈ Ioc 0 (1/2)) (x : P) (hx : x.1 < 1/4)
    (u v : P) :
    pullInner (E := P) (leftCylinder hδ) projection x u v =
      u.1*v.1 + Real.exp (-x.1)^2*u.2.1*v.2.1 + leftCircleScale δ^2*u.2.2*v.2.2 := by
  change pullInner (E := P) (radialPull _ (leftLength_ge hδ)) projection x u v = _
  have he := radialPull_projection (neck hδ (period_pos δ)) (leftLength_ge hδ) x u v
  have hn := neck_projection_apply hδ (period_pos δ) (radialLift (leftLength δ) x)
    (RadialProfile.slope (leftLength δ) x.1*u.1,u.2) (RadialProfile.slope (leftLength δ) x.1*v.1,v.2)
  apply Eq.trans (he.trans hn)
  change (RadialProfile.slope (leftLength δ) x.1*u.1)*(RadialProfile.slope (leftLength δ) x.1*v.1) +
    radius₁ δ (period δ) (RadialProfile.coordinate (leftLength δ) x.1)^2 *
      (u.2.1-Cometric.χ (RadialProfile.coordinate (leftLength δ) x.1)*u.2.2)*
      (v.2.1-Cometric.χ (RadialProfile.coordinate (leftLength δ) x.1)*v.2.2) +
    radius₂ δ (period δ) (RadialProfile.coordinate (leftLength δ) x.1)^2*u.2.2*v.2.2 = _
  rw [slope_left_exact hx,radius₁_left_exact hδ hx.le,radius₂_left_exact hδ hx.le]
  have hz : Cometric.χ (RadialProfile.coordinate (leftLength δ) x.1) = 0 := by
    rw [RadialProfile.coordinate_left hx.le]
    exact Cometric.χ_eq_zero (by linarith [leftLength_ge hδ])
  simp only [hz,zero_mul,sub_zero,one_mul]

lemma rightCylinder_low {δ : ℝ} (hδ : δ ∈ Ioc 0 (1/2)) (x : P) (hx : x.1 < 1/4)
    (u v : P) :
    pullInner (E := P) (rightCylinder hδ) projection x u v =
      u.1*v.1 + Real.exp (-x.1)^2*u.2.1*v.2.1 + rightCircleScale δ^2*u.2.2*v.2.2 := by
  change pullInner (E := P) (radialPull _ (L := 4) le_rfl) projection x u v = _
  have he := radialPull_projection (switched (neck hδ (period_pos δ))) (L := 4) le_rfl x u v
  have hs := congrArg (fun D : P →L[ℝ] P →L[ℝ] ℝ =>
    D (RadialProfile.slope 4 x.1*u.1,u.2) (RadialProfile.slope 4 x.1*v.1,v.2))
    (switched_projection (neck hδ (period_pos δ)) (radialLift 4 x))
  have hn := neck_projection_apply hδ (period_pos δ) (switchLift (radialLift 4 x))
    (switchLinear (RadialProfile.slope 4 x.1*u.1,u.2))
    (switchLinear (RadialProfile.slope 4 x.1*v.1,v.2))
  apply Eq.trans (he.trans (hs.trans hn))
  change (-(RadialProfile.slope 4 x.1*u.1))*(-(RadialProfile.slope 4 x.1*v.1)) +
    radius₁ δ (period δ) (1-RadialProfile.coordinate 4 x.1)^2 *
      (u.2.1+u.2.2-Cometric.χ (1-RadialProfile.coordinate 4 x.1)*u.2.1)*
      (v.2.1+v.2.2-Cometric.χ (1-RadialProfile.coordinate 4 x.1)*v.2.1) +
    radius₂ δ (period δ) (1-RadialProfile.coordinate 4 x.1)^2*u.2.1*v.2.1 = _
  rw [slope_left_exact hx,radius₁_right_exact hδ hx.le,radius₂_right_exact hδ hx.le]
  have ho : Cometric.χ (1-RadialProfile.coordinate 4 x.1) = 1 := by
    rw [RadialProfile.coordinate_left hx.le]
    exact Cometric.χ_eq_one (by linarith)
  rw [ho]
  ring
end ThreeManifold.CompactMetric
end

section
open Set Filter Topology Bundle Manifold IsManifold Bornology
open scoped ContDiff UpperHalfPlane RealInnerProductSpace
namespace ThreeManifold.CompactMetric
open MetricConstruction CylinderConstruction

variable (g : Metric (E := P) Cylinder) (c : ℝ) (hc : c ≠ 0)
  (low : ∀ (x : P), x.1 < 1/4 → ∀ u v : P,
    pullInner (E := P) g projection x u v =
      u.1*v.1 + Real.exp (-x.1)^2*u.2.1*v.2.1 + c^2*u.2.2*v.2.2)

include low in
lemma cusp_linear_formula (x : UniversalPiece) (hx : Real.log x.1.im < 1/4) (u v : EP) :
    pullBilin (E := EP) (F := P) (pullInner g projection (logarithmicLift x))
      (logLinear x.1.im) u v =
        x.1.im⁻¹^2 * inner ℝ u.1 v.1 + c^2*u.2*v.2 := by
  have he := low (logarithmicLift x) hx (logLinear x.1.im u) (logLinear x.1.im v)
  apply he.trans
  change (x.1.im⁻¹*u.1.im)*(x.1.im⁻¹*v.1.im) + Real.exp (-Real.log x.1.im)^2*u.1.re*v.1.re +
    c^2*u.2*v.2 = _
  rw [Real.exp_neg,Real.exp_log x.1.im_pos,Complex.inner]
  simp only [Complex.mul_re,Complex.conj_re,Complex.conj_im]
  ring

include low in
lemma cusp_core_match_projection (a : ℝ) (ha : 1 < a) {x : UniversalPiece}
    (hx : a < x.1.im) (hl : Real.log x.1.im < 1/4) :
    (cuspMetric g a ha).inner (sourceProjection x) = (coreMetric c hc).inner (sourceProjection x) := by
  apply bilin_eq_of_pull_eq (E := EP) (F := EP) x (sourceProjection_deriv_surjective x)
  rw [cuspMetric_projection g a ha hx,logarithmicLift_deriv]
  apply ContinuousLinearMap.ext
  intro u
  apply ContinuousLinearMap.ext
  intro v
  exact (cusp_linear_formula g c low x hl u v).trans (coreMetric_projection c hc x u v).symm

include low in
lemma cusp_core_match (a : ℝ) (ha : 1 < a) {q : WholePiece}
    (hq : q ∈ wholeCusp a) (hl : HyperbolicCore.height q.1 < 1/4) :
    (cuspMetric g a ha).inner q = (coreMetric c hc).inner q := by
  obtain ⟨z,hz,hzq⟩ := hq
  let r := CircleConstruction.sectionMap 6 q.2
  have he : sourceProjection (z,r) = q := by
    apply Prod.ext
    · exact hzq
    · exact CircleConstruction.section_spec 6 q.2
  have hlog : Real.log z.im < 1/4 := by
    rw [← HyperbolicCore.height_projection_high (ha.trans hz),hzq]
    exact hl
  exact he ▸ cusp_core_match_projection g c hc low a ha hz hlog

lemma left_cusp_core_match {δ : ℝ} (hδ : δ ∈ Ioc 0 (1/2)) (a : ℝ) (ha : 1 < a)
    {q : WholePiece} (hq : q ∈ wholeCusp a) (hl : HyperbolicCore.height q.1 < 1/4) :
    (cuspMetric (leftCylinder hδ) a ha).inner q =
      (coreMetric (leftCircleScale δ) (leftCircleScale_pos δ).ne').inner q :=
  cusp_core_match _ _ _ (leftCylinder_low hδ) a ha hq hl
lemma right_cusp_core_match {δ : ℝ} (hδ : δ ∈ Ioc 0 (1/2)) (a : ℝ) (ha : 1 < a)
    {q : WholePiece} (hq : q ∈ wholeCusp a) (hl : HyperbolicCore.height q.1 < 1/4) :
    (cuspMetric (rightCylinder hδ) a ha).inner q =
      (coreMetric (rightCircleScale δ) (rightCircleScale_pos hδ.1).ne').inner q :=
  cusp_core_match _ _ _ (rightCylinder_low hδ) a ha hq hl
end ThreeManifold.CompactMetric
end

section
open Set Filter Topology Bundle Manifold IsManifold Bornology
open scoped ContDiff UpperHalfPlane
namespace ThreeManifold.CompactMetric
open MetricConstruction CylinderConstruction

def coreRegion : TopologicalSpace.Opens WholePiece :=
  ⟨{q | HyperbolicCore.height q.1 < 1/4},
    isOpen_lt (HyperbolicCore.height_continuous.comp continuous_fst) continuous_const⟩
def cuspLevel : ℝ := Real.exp (1/8)
lemma cuspLevel_gt : 1 < cuspLevel := by
  unfold cuspLevel
  exact Real.one_lt_exp_iff.mpr (by norm_num)
lemma log_cuspLevel : Real.log cuspLevel = 1/8 := Real.log_exp _
lemma cuspMetric_domain (g : Metric (E := P) Cylinder) (a : ℝ) (ha : 1 < a) :
    (cuspMetric g a ha).domain = wholeCusp a := by
  ext x
  simp [cuspMetric,localPull,cuspChart]

variable (g : Metric (E := P) Cylinder) (c : ℝ) (hc : c ≠ 0)
  (low : ∀ (x : P), x.1 < 1/4 → ∀ u v : P,
    pullInner (E := P) g projection x u v =
      u.1*v.1 + Real.exp (-x.1)^2*u.2.1*v.2.1 + c^2*u.2.2*v.2.2)

def wholeLocals (i : Bool) : LocalMetric (E := EP) WholePiece :=
  if i then cuspMetric g cuspLevel cuspLevel_gt else localOn (coreMetric c hc) coreRegion
lemma wholeLocals_cover (x : WholePiece) : ∃ i, x ∈ (wholeLocals g c hc i).domain := by
  by_cases hx : x ∈ coreRegion
  · exact ⟨false,hx⟩
  · refine ⟨true,?_⟩
    change x ∈ (cuspMetric g cuspLevel cuspLevel_gt).domain
    rw [cuspMetric_domain]
    apply (HyperbolicCore.mem_cusp_iff_height cuspLevel_gt x.1).mpr
    rw [log_cuspLevel]
    have hh : ¬HyperbolicCore.height x.1 < 1/4 := hx
    linarith
include low in
lemma wholeLocals_compatible (i j : Bool) (x : WholePiece)
    (hi : x ∈ (wholeLocals g c hc i).domain) (hj : x ∈ (wholeLocals g c hc j).domain) :
    (wholeLocals g c hc i).inner x = (wholeLocals g c hc j).inner x := by
  cases i <;> cases j
  · rfl
  · change (coreMetric c hc).inner x = (cuspMetric g cuspLevel cuspLevel_gt).inner x
    apply (cusp_core_match g c hc low cuspLevel cuspLevel_gt _ hi).symm
    change x ∈ (cuspMetric g cuspLevel cuspLevel_gt).domain at hj
    rw [cuspMetric_domain] at hj
    change x.1 ∈ HyperbolicCore.cusp cuspLevel
    exact hj
  · change (cuspMetric g cuspLevel cuspLevel_gt).inner x = (coreMetric c hc).inner x
    apply cusp_core_match g c hc low cuspLevel cuspLevel_gt _ hj
    change x ∈ (cuspMetric g cuspLevel cuspLevel_gt).domain at hi
    rw [cuspMetric_domain] at hi
    change x.1 ∈ HyperbolicCore.cusp cuspLevel
    exact hi
  · rfl

def wholeMetric : Metric (E := EP) WholePiece :=
  glueLocal (wholeLocals g c hc) (wholeLocals_cover g c hc) (wholeLocals_compatible g c hc low)
lemma wholeMetric_core {x : WholePiece} (hx : x ∈ coreRegion) :
    (wholeMetric g c hc low).inner x = (coreMetric c hc).inner x :=
  glueLocal_eq _ _ _ false x hx
lemma wholeMetric_cusp {x : WholePiece} (hx : x ∈ wholeCusp cuspLevel) :
    (wholeMetric g c hc low).inner x = (cuspMetric g cuspLevel cuspLevel_gt).inner x := by
  apply glueLocal_eq _ _ _ true x
  change x ∈ (cuspMetric g cuspLevel cuspLevel_gt).domain
  rwa [cuspMetric_domain]

def leftWhole {δ : ℝ} (hδ : δ ∈ Ioc 0 (1/2)) : Metric (E := EP) WholePiece :=
  wholeMetric (leftCylinder hδ) (leftCircleScale δ) (leftCircleScale_pos δ).ne' (leftCylinder_low hδ)
def rightWhole {δ : ℝ} (hδ : δ ∈ Ioc 0 (1/2)) : Metric (E := EP) WholePiece :=
  wholeMetric (rightCylinder hδ) (rightCircleScale δ) (rightCircleScale_pos hδ.1).ne' (rightCylinder_low hδ)
end ThreeManifold.CompactMetric
end

section
open Set Filter Topology Bundle Manifold IsManifold Bornology
open scoped ContDiff
namespace ThreeManifold.CompactMetric

section
open MetricConstruction CylinderConstruction GluedConstruction HyperbolicCore

def pieceMap : Piece → WholePiece := fun x => (x.1.1,x.2)
lemma pieceMap_smooth : ContMDiff 𝓘(ℝ,EP) 𝓘(ℝ,EP) ∞ pieceMap := by
  have h := ((contMDiff_subtype_val (U := coreOpens 8) (n := ∞)).comp
    (projection_fst_smooth (E := ℂ) (F := ℝ) (M := OpenCore 8) (N := GluedConstruction.Circle))).prodMk
      (projection_snd_smooth (E := ℂ) (F := ℝ) (M := OpenCore 8) (N := GluedConstruction.Circle))
  convert! h using 1
  simp only [← modelWithCornersSelf_prod]

lemma core8_nonempty : Nonempty (coreOpens 8) := by
  exact HyperbolicCore.openCore_nonempty (by norm_num)

def pieceEmbedding : OpenPartialHomeomorph Piece WholePiece :=
  ((coreOpens 8).openPartialHomeomorphSubtypeCoe core8_nonempty).prod (OpenPartialHomeomorph.refl GluedConstruction.Circle)

lemma pieceEmbedding_smooth_inverse {x : WholePiece} (hx : x ∈ pieceEmbedding.target) :
    ContMDiffAt 𝓘(ℝ,EP) 𝓘(ℝ,EP) ∞ pieceEmbedding.symm x := by
  have h1 := (openSubtype_inverse_smooth (coreOpens 8) core8_nonempty (by simpa using hx.1)).comp x
    ((projection_fst_smooth (E := ℂ) (F := ℝ) (M := Surface) (N := GluedConstruction.Circle)) x)
  have h2 := (projection_snd_smooth (E := ℂ) (F := ℝ) (M := Surface) (N := GluedConstruction.Circle)) x
  convert! h1.prodMk h2 using 1
  simp only [← modelWithCornersSelf_prod]
lemma pieceEmbedding_differentiable : pieceEmbedding.MDifferentiable 𝓘(ℝ,EP) 𝓘(ℝ,EP) := by
  constructor
  · exact (pieceMap_smooth.mdifferentiable (by simp)).mdifferentiableOn
  · intro x hx
    exact ((pieceEmbedding_smooth_inverse hx).mdifferentiableAt (by simp)).mdifferentiableWithinAt

def pieceMetric (g : Metric (E := EP) WholePiece) : Metric (E := EP) Piece :=
  pullback g pieceMap_smooth (fun x => pieceEmbedding_differentiable.mfderiv (by exact ⟨mem_univ _,mem_univ _⟩))
    (fun _ => rfl)
lemma pieceMetric_inner (g : Metric (E := EP) WholePiece) (x : Piece) :
    (pieceMetric g).inner x = pullInner g pieceMap x := rfl

def leftPiece {δ : ℝ} (hδ : δ ∈ Ioc 0 (1/2)) : Metric (E := EP) Piece := pieceMetric (leftWhole hδ)
def rightPiece {δ : ℝ} (hδ : δ ∈ Ioc 0 (1/2)) : Metric (E := EP) Piece := pieceMetric (rightWhole hδ)
end

open MetricConstruction CylinderConstruction

lemma cuspLevel_lt_two : cuspLevel < 2 := by
  rw [cuspLevel,← Real.exp_log (by norm_num : (0:ℝ)<2)]
  apply Real.exp_lt_exp.mpr
  linarith [RadialProfile.log_bounds.1]

lemma cuspMetric_change (g : Metric (E := P) Cylinder) (a b : ℝ) (ha : 1 < a) (hb : 1 < b)
    (hab : a ≤ b) {q : WholePiece} (hq : q ∈ wholeCusp b) :
    (cuspMetric g a ha).inner q = (cuspMetric g b hb).inner q := by
  obtain ⟨z,hz,hzq⟩ := hq
  let r := CircleConstruction.sectionMap 6 q.2
  have he : sourceProjection (z,r) = q := by
    exact Prod.ext hzq (CircleConstruction.section_spec 6 q.2)
  have ht : (cuspMetric g a ha).inner (sourceProjection (z,r)) =
      (cuspMetric g b hb).inner (sourceProjection (z,r)) := by
    apply bilin_eq_of_pull_eq (E := EP) (F := EP) (z,r) (sourceProjection_deriv_surjective (z,r))
    rw [cuspMetric_projection g a ha (x := (z,r)) (hab.trans_lt hz),cuspMetric_projection g b hb (x := (z,r)) hz]
  exact he ▸ ht

variable (g : Metric (E := P) Cylinder) (c : ℝ) (hc : c ≠ 0)
  (low : ∀ (x : P), x.1 < 1/4 → ∀ u v : P,
    pullInner (E := P) g projection x u v =
      u.1*v.1 + Real.exp (-x.1)^2*u.2.1*v.2.1 + c^2*u.2.2*v.2.2)
lemma wholeMetric_cusp_two {q : WholePiece} (hq : q ∈ wholeCusp 2) :
    (wholeMetric g c hc low).inner q = pullInner (E := EP) g (logCuspMap 2 (by norm_num)) q := by
  have hqa : q ∈ wholeCusp cuspLevel := by
    obtain ⟨z,hz,hzq⟩ := hq
    exact ⟨z,cuspLevel_lt_two.trans hz,hzq⟩
  rw [wholeMetric_cusp g c hc low hqa,
    cuspMetric_change g cuspLevel 2 cuspLevel_gt (by norm_num) cuspLevel_lt_two.le hq,
    cuspMetric_inner g 2 (by norm_num) hq]
end ThreeManifold.CompactMetric
end

section
open Set Filter Topology Bundle Manifold IsManifold Bornology
open scoped ContDiff UpperHalfPlane
namespace ThreeManifold.CompactMetric
open MetricConstruction CylinderConstruction GluedConstruction

def collarLog : collar → Cylinder := logCuspMap 2 (by norm_num) ∘ pieceMap ∘ Subtype.val
lemma collarLog_smooth : ContMDiff 𝓘(ℝ,EP) 𝓘(ℝ,P) ∞ collarLog := by
  intro x
  exact (logCuspMap_smoothAt 2 (by norm_num) (show pieceMap x.1 ∈ wholeCusp 2 from x.2)).comp x
    ((pieceMap_smooth x.1).comp x ((contMDiff_subtype_val (U := collar) (n := ∞)) x))
lemma collarLog_eq (x : collar) :
    collarLog x = (Real.log (collarCoordinates x).1.1,(collarCoordinates x).2) := by
  obtain ⟨z,hz,r,rfl⟩ := neckLift_surjective x
  rw [neckLift_coordinates]
  exact logCusp_projection_apply 2 (by norm_num) (z,r) hz.1

variable (g : Metric (E := P) Cylinder) (c : ℝ) (hc : c ≠ 0)
  (low : ∀ (x : P), x.1 < 1/4 → ∀ u v : P,
    pullInner (E := P) g projection x u v =
      u.1*v.1 + Real.exp (-x.1)^2*u.2.1*v.2.1 + c^2*u.2.2*v.2.2)
lemma pieceMetric_collar (x : collar) :
    pullInner (E := EP) (pieceMetric (wholeMetric g c hc low)) Subtype.val x =
      pullInner (E := EP) g collarLog x := by
  let f : collar → WholePiece := pieceMap ∘ Subtype.val
  have hfs : ContMDiff 𝓘(ℝ,EP) 𝓘(ℝ,EP) ∞ f :=
    pieceMap_smooth.comp (contMDiff_subtype_val (U := collar))
  change pullBilin (E := EP) (F := EP)
    (pullInner (wholeMetric g c hc low) pieceMap x.1)
      (mfderiv 𝓘(ℝ,EP) 𝓘(ℝ,EP) (Subtype.val : collar → Piece) x) = _
  rw [← pull_composition _ ((contMDiff_subtype_val (U := collar) (n := ∞) x).mdifferentiableAt (by simp))
    ((pieceMap_smooth x.1).mdifferentiableAt (by simp))]
  change pullBilin (E := EP) (F := EP) ((wholeMetric g c hc low).inner (f x))
    (mfderiv 𝓘(ℝ,EP) 𝓘(ℝ,EP) f x) = _
  rw [wholeMetric_cusp_two g c hc low (show f x ∈ wholeCusp 2 from x.2)]
  exact (pull_composition g ((hfs x).mdifferentiableAt (by simp))
    ((logCuspMap_smoothAt 2 (by norm_num) (show f x ∈ wholeCusp 2 from x.2)).mdifferentiableAt (by simp))).symm

def leftPosition (δ : ℝ) : collar → Cylinder := radial (leftLength δ) ∘ collarLog
def rightPosition : collar → Cylinder := switch ∘ radial 4 ∘ collarLog
lemma leftPosition_smooth (δ : ℝ) : ContMDiff 𝓘(ℝ,EP) 𝓘(ℝ,P) ∞ (leftPosition δ) :=
  (radial_smooth (leftLength δ)).comp collarLog_smooth
lemma rightPosition_smooth : ContMDiff 𝓘(ℝ,EP) 𝓘(ℝ,P) ∞ rightPosition :=
  switch_smooth.comp ((radial_smooth 4).comp collarLog_smooth)
lemma position_match (δ : ℝ) : rightPosition ∘ gluingMap = leftPosition δ := by
  funext x
  change switch (radial 4 (collarLog (gluingMap x))) = radial (leftLength δ) (collarLog x)
  rw [collarLog_eq,collarLog_eq]
  have hc : collarCoordinates (gluingMap x) =
      (collarFlip (collarCoordinates x).1,torusShear.symm (collarCoordinates x).2) := by
    simp only [gluingMap,Homeomorph.trans_apply,Homeomorph.apply_symm_apply]
    rfl
  rw [hc]
  apply Prod.ext
  · change 1 - RadialProfile.coordinate 4 (Real.log (16/(collarCoordinates x).1.1)) =
      RadialProfile.coordinate (leftLength δ) (Real.log (collarCoordinates x).1.1)
    rw [RadialProfile.coordinate_flip (L := leftLength δ)
      (show (collarCoordinates x).1.1 ∈ Icc (2:ℝ) 8 from
        ⟨(collarCoordinates x).1.2.1.le,(collarCoordinates x).1.2.2.le⟩)]
    ring
  · exact torusShear.apply_symm_apply _

lemma leftPiece_collar {δ : ℝ} (hδ : δ ∈ Ioc 0 (1/2)) (x : collar) :
    pullInner (E := EP) (leftPiece hδ) Subtype.val x =
      pullInner (E := EP) (neck hδ (period_pos δ)) (leftPosition δ) x := by
  rw [show leftPiece hδ = pieceMetric (wholeMetric (leftCylinder hδ) (leftCircleScale δ)
    (leftCircleScale_pos δ).ne' (leftCylinder_low hδ)) from rfl,
    pieceMetric_collar]
  change pullBilin (E := EP) (F := P)
    (pullInner (neck hδ (period_pos δ)) (radial (leftLength δ)) (collarLog x))
    (mfderiv 𝓘(ℝ,EP) 𝓘(ℝ,P) collarLog x) = _
  exact (pull_composition _ ((collarLog_smooth x).mdifferentiableAt (by simp))
    ((radial_smooth (leftLength δ) _).mdifferentiableAt (by simp))).symm
lemma rightPiece_collar {δ : ℝ} (hδ : δ ∈ Ioc 0 (1/2)) (x : collar) :
    pullInner (E := EP) (rightPiece hδ) Subtype.val x =
      pullInner (E := EP) (neck hδ (period_pos δ)) rightPosition x := by
  rw [show rightPiece hδ = pieceMetric (wholeMetric (rightCylinder hδ) (rightCircleScale δ)
    (rightCircleScale_pos hδ.1).ne' (rightCylinder_low hδ)) from rfl,
    pieceMetric_collar]
  change pullBilin (E := EP) (F := P)
    (pullInner (switched (neck hδ (period_pos δ))) (radial 4) (collarLog x))
    (mfderiv 𝓘(ℝ,EP) 𝓘(ℝ,P) collarLog x) = _
  rw [← pull_composition _ ((collarLog_smooth x).mdifferentiableAt (by simp))
    ((radial_smooth 4 _).mdifferentiableAt (by simp))]
  change pullBilin (E := EP) (F := P)
    (pullInner (neck hδ (period_pos δ)) switch ((radial 4 ∘ collarLog) x))
    (mfderiv 𝓘(ℝ,EP) 𝓘(ℝ,P) (radial 4 ∘ collarLog) x) = _
  exact (pull_composition _ (((radial_smooth 4).comp collarLog_smooth x).mdifferentiableAt (by simp))
    ((switch_smooth _).mdifferentiableAt (by simp))).symm
end ThreeManifold.CompactMetric
end

section
open Set Filter Topology Bundle Manifold IsManifold Bornology
open scoped ContDiff
namespace ThreeManifold.CompactMetric
open MetricConstruction CylinderConstruction GluedConstruction

lemma gluing_smooth_self : ContMDiff 𝓘(ℝ,EP) 𝓘(ℝ,EP) ∞ gluingMap := by
  simpa only [modelWithCornersSelf_prod] using gluingMap_smooth
lemma transition_smooth (x : collar) :
    ContMDiffAt 𝓘(ℝ,EP) 𝓘(ℝ,EP) ∞ (TwoGluing.extendedTransition collar gluingMap) x.1 :=
  TwoGluing.extendedTransition_smooth collar gluingMap gluing_smooth_self x

lemma collar_pull_match {δ : ℝ} (hδ : δ ∈ Ioc 0 (1/2)) (x : collar) :
    pullInner (E := EP) (leftPiece hδ) Subtype.val x =
      pullInner (E := EP) (rightPiece hδ) (Subtype.val ∘ gluingMap) x := by
  rw [pull_composition _ ((gluing_smooth_self x).mdifferentiableAt (by simp))
    ((contMDiff_subtype_val (U := collar) (n := ∞) _).mdifferentiableAt (by simp)),
    rightPiece_collar,← pull_composition _ ((gluing_smooth_self x).mdifferentiableAt (by simp))
      ((rightPosition_smooth _).mdifferentiableAt (by simp)),position_match,leftPiece_collar]

lemma piece_overlap {δ : ℝ} (hδ : δ ∈ Ioc 0 (1/2)) (x : collar) :
    (leftPiece hδ).inner x.1 =
      pullInner (E := EP) (rightPiece hδ) (TwoGluing.extendedTransition collar gluingMap) x.1 := by
  apply bilin_eq_of_pull_eq (E := EP) (F := EP) x
    ((openSubtype_mdifferentiable collar ⟨x⟩).mfderiv (x := x) (mem_univ _) :
      TangentSpace 𝓘(ℝ,EP) x ≃L[ℝ] TangentSpace 𝓘(ℝ,EP) x.1).surjective
  have hc := pull_composition (E := EP) (F := EP) (rightPiece hδ)
    ((contMDiff_subtype_val (U := collar) (n := ∞) x).mdifferentiableAt (by simp))
    ((transition_smooth x).mdifferentiableAt (by simp))
  have he : TwoGluing.extendedTransition collar gluingMap ∘ (Subtype.val : collar → Piece) =
      Subtype.val ∘ gluingMap := funext (TwoGluing.extendedTransition_apply collar gluingMap)
  have hf := congrArg (fun f : collar → Piece => pullInner (E := EP) (rightPiece hδ) f x) he
  exact (collar_pull_match hδ x).trans (hf.symm.trans hc)
end ThreeManifold.CompactMetric

namespace ThreeManifold.MetricConstruction
variable {E F M N A : 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]
  (c : A → OpenPartialHomeomorph M N)
  (hc : ∀ x, ∃ i, x ∈ (c i).source)
  (hg : A → Metric (E := F) N)
  (heq : ∀ i j x, x ∈ (c i).source → x ∈ (c j).source →
    pullInner (E := E) (hg i) (c i) x = pullInner (E := E) (hg j) (c j) x)
  (hs : ∀ i, ContMDiffOn 𝓘(ℝ,E) 𝓘(ℝ,F) ∞ (c i) (c i).source)
  (hdi : ∀ i, (c i).MDifferentiable 𝓘(ℝ,E) 𝓘(ℝ,F))

def gluedInner (x : M) : TangentSpace 𝓘(ℝ,E) x →L[ℝ] TangentSpace 𝓘(ℝ,E) x →L[ℝ] ℝ :=
  pullInner (E := E) (hg (hc x).choose) (c (hc x).choose) x

omit [IsManifold 𝓘(ℝ,E) ∞ M] in
include heq in
lemma gluedInner_eq (i : A) (x : M) (hx : x ∈ (c i).source) :
    gluedInner c hc hg x = pullInner (E := E) (hg i) (c i) x :=
  heq _ i x (hc x).choose_spec hx

include heq hs in
lemma gluedInner_smooth :
    ContMDiff 𝓘(ℝ,E) (𝓘(ℝ,E).prod 𝓘(ℝ,E →L[ℝ] E →L[ℝ] ℝ)) ∞
      (fun x => TotalSpace.mk' (E →L[ℝ] E →L[ℝ] ℝ)
        (E := fun y => TangentSpace 𝓘(ℝ,E) y →L[ℝ] TangentSpace 𝓘(ℝ,E) y →L[ℝ] ℝ)
        x (gluedInner c hc hg x)) := by
  intro x
  obtain ⟨i,hi⟩ := hc x
  apply (pullback_inner_smoothAt (hg i) ((hs i x hi).contMDiffAt
    ((c i).open_source.mem_nhds hi))).congr_of_eventuallyEq
  filter_upwards [(c i).open_source.mem_nhds hi] with y hy
  exact congrArg (TotalSpace.mk' (E →L[ℝ] E →L[ℝ] ℝ) y)
    (gluedInner_eq c hc hg heq i y hy)

omit [IsManifold 𝓘(ℝ,E) ∞ M] in
lemma gluedInner_symm (x : M) (u v : TangentSpace 𝓘(ℝ,E) x) :
    gluedInner c hc hg x u v = gluedInner c hc hg x v u := by
  exact (hg (hc x).choose).symm _ _ _

omit [IsManifold 𝓘(ℝ,E) ∞ M] in
include hdi in
lemma gluedInner_pos (x : M) (u : TangentSpace 𝓘(ℝ,E) x) (hu : u ≠ 0) :
    0 < gluedInner c hc hg x u u := by
  let e := (hdi (hc x).choose).mfderiv (hc x).choose_spec
  apply (hg (hc x).choose).pos
  exact fun hh => hu (e.injective (hh.trans e.map_zero.symm))

omit [IsManifold 𝓘(ℝ,E) ∞ M] in
include hdi in
lemma gluedInner_bounded (x : M) :
    IsVonNBounded ℝ {u : TangentSpace 𝓘(ℝ,E) x | gluedInner c hc hg x u u < 1} := by
  let e := (hdi (hc x).choose).mfderiv (hc x).choose_spec
  have hb := ((hg (hc x).choose).isVonNBounded (c (hc x).choose x)).image
    e.symm.toContinuousLinearMap
  apply hb.subset
  intro u hu
  exact ⟨e u,hu,e.symm_apply_apply u⟩

def glue : Metric (E := E) M where
  inner := gluedInner c hc hg
  symm := gluedInner_symm c hc hg
  pos := gluedInner_pos c hc hg hdi
  isVonNBounded := gluedInner_bounded c hc hg hdi
  contMDiff := gluedInner_smooth c hc hg heq hs

lemma glue_local (i : A) (x : M) (hx : x ∈ (c i).source) :
    (glue c hc hg heq hs hdi).inner x = pullInner (E := E) (hg i) (c i) x :=
  gluedInner_eq c hc hg heq i x hx

lemma glue_inverse (i : A) (y : N) (hy : y ∈ (c i).target) :
    pullInner (E := F) (glue c hc hg heq hs hdi) (c i).symm y = (hg i).inner y := by
  have hx : (c i).symm y ∈ (c i).source := (c i).map_target hy
  have he : ((c i) ∘ (c i).symm) =ᶠ[nhds y] id := by
    filter_upwards [(c i).open_target.mem_nhds hy] with z hz
    exact (c i).right_inv hz
  have hd : (mfderiv 𝓘(ℝ,E) 𝓘(ℝ,F) (c i) ((c i).symm y)).comp
      (mfderiv 𝓘(ℝ,F) 𝓘(ℝ,E) (c i).symm y) = ContinuousLinearMap.id ℝ F := by
    rw [← mfderiv_comp y (((hdi i).1 _ hx).mdifferentiableAt
      ((c i).open_source.mem_nhds hx)) (((hdi i).2 _ hy).mdifferentiableAt
        ((c i).open_target.mem_nhds hy))]
    exact he.mfderiv_eq.trans mfderiv_id
  ext u v
  rw [pullInner_apply,glue_local c hc hg heq hs hdi i _ hx,pullInner_apply]
  have hdu := congrArg (fun L : F →L[ℝ] F => L u) hd
  have hdv := congrArg (fun L : F →L[ℝ] F => L v) hd
  calc
    _ = (hg i).inner (c i ((c i).symm y)) u v :=
      congrArg₂ (fun a b : F => (hg i).inner (c i ((c i).symm y)) a b) hdu hdv
    _ = (hg i).inner y u v :=
      congrArg (fun z : N => ((hg i).inner z : F →L[ℝ] F →L[ℝ] ℝ) u v) ((c i).right_inv hy)

end ThreeManifold.MetricConstruction

namespace ThreeManifold.GluedConstruction
open TwoGluing (pieceChart pieceChart_apply)
abbrev EPm := ℂ × ℝ

lemma inclusion_smooth (i : Bool) : ContMDiff 𝓘(ℝ,EPm) 𝓘(ℝ,EPm) ∞ (inclusion i) := by
  intro x
  let c := pieceChart (E := EPm) collar gluingMap i x
  have hc : c ∈ atlas EPm Manifold := ⟨i,x,rfl⟩
  have ht : chartAt EPm x x ∈ c.target := (chartAt EPm x).map_source (mem_chart_source _ _)
  have h1 := contMDiffAt_of_mem_maximalAtlas
    (I := 𝓘(ℝ,EPm)) (chart_mem_maximalAtlas (I := 𝓘(ℝ,EPm)) (n := ∞) x) (mem_chart_source _ _)
  have h2 := contMDiffAt_symm_of_mem_maximalAtlas
    (I := 𝓘(ℝ,EPm)) (subset_maximalAtlas (I := 𝓘(ℝ,EPm)) (n := ∞) hc) ht
  apply (h2.comp x h1).congr_of_eventuallyEq
  filter_upwards [(chartAt EPm x).open_source.mem_nhds (mem_chart_source _ _)] with y hy
  change inclusion i y = c.symm (chartAt EPm x y)
  change TwoGluing.inclusion collar gluingMap i y =
    TwoGluing.inclusion collar gluingMap i ((chartAt EPm x).symm (chartAt EPm x y))
  rw [(chartAt EPm x).left_inv hy]

def pieceOpenMap (i : Bool) : OpenPartialHomeomorph Piece Manifold :=
  (TwoGluing.inclusion_openEmbedding collar gluingMap i).toOpenPartialHomeomorph _
lemma pieceOpenMap_apply (i : Bool) : (pieceOpenMap i : Piece → Manifold) = inclusion i := rfl
lemma pieceOpenMap_inclusion (i : Bool) (x : Piece) : (pieceOpenMap i).symm (inclusion i x) = x :=
  (pieceOpenMap i).left_inv (by simp [pieceOpenMap])

lemma pieceOpenMap_inverse_smooth (i : Bool) {p : Manifold} (hp : p ∈ (pieceOpenMap i).target) :
    ContMDiffAt 𝓘(ℝ,EPm) 𝓘(ℝ,EPm) ∞ (pieceOpenMap i).symm p := by
  let x := (pieceOpenMap i).symm p
  have hxp : inclusion i x = p := (pieceOpenMap i).right_inv hp
  let c := pieceChart (E := EPm) collar gluingMap i x
  have hc : c ∈ atlas EPm Manifold := ⟨i,x,rfl⟩
  have hps : p ∈ c.source := ⟨x,mem_chart_source _ _,hxp⟩
  have hcp : c p ∈ (chartAt EPm x).target := c.map_source hps
  have h1 := contMDiffAt_of_mem_maximalAtlas (I := 𝓘(ℝ,EPm))
    (subset_maximalAtlas (I := 𝓘(ℝ,EPm)) (n := ∞) hc) hps
  have h2 := contMDiffAt_symm_of_mem_maximalAtlas (I := 𝓘(ℝ,EPm))
    (chart_mem_maximalAtlas (I := 𝓘(ℝ,EPm)) (n := ∞) x) hcp
  apply (h2.comp p h1).congr_of_eventuallyEq
  filter_upwards [c.open_source.mem_nhds hps] with q hq
  obtain ⟨y,hy,rfl⟩ := hq
  change (pieceOpenMap i).symm (inclusion i y) = (chartAt EPm x).symm (c (inclusion i y))
  rw [pieceOpenMap_inclusion]
  change y = (chartAt EPm x).symm (pieceChart (E := EPm) collar gluingMap i x (TwoGluing.inclusion collar gluingMap i y))
  rw [pieceChart_apply,(chartAt EPm x).left_inv hy]

lemma pieceOpenMap_mdifferentiable (i : Bool) : (pieceOpenMap i).MDifferentiable 𝓘(ℝ,EPm) 𝓘(ℝ,EPm) := by
  constructor
  · exact ((inclusion_smooth i).mdifferentiable (by simp)).mdifferentiableOn
  · intro p hp
    exact ((pieceOpenMap_inverse_smooth i hp).mdifferentiableAt (by simp)).mdifferentiableWithinAt

lemma pieceOpenMap_cover (p : Manifold) : ∃ i, p ∈ (pieceOpenMap i).symm.source := by
  obtain ⟨i,x,hx⟩ := TwoGluing.inclusion_surjective collar gluingMap p
  refine ⟨i,?_⟩
  have ht := (pieceOpenMap i).map_source (x := x) (by simp [pieceOpenMap])
  exact hx ▸ ht
end ThreeManifold.GluedConstruction

namespace ThreeManifold.CompactMetric
open MetricConstruction CylinderConstruction GluedConstruction

lemma piece_inverse_transition {p : GluedConstruction.Manifold}
    (h0 : p ∈ (pieceOpenMap false).target) (h1 : p ∈ (pieceOpenMap true).target) :
    ∃ _hx : (pieceOpenMap false).symm p ∈ collar,
      TwoGluing.extendedTransition collar gluingMap ((pieceOpenMap false).symm p) =
        (pieceOpenMap true).symm p := by
  have he : TwoGluing.inclusion collar gluingMap false ((pieceOpenMap false).symm p) =
      TwoGluing.inclusion collar gluingMap true ((pieceOpenMap true).symm p) :=
    ((pieceOpenMap false).right_inv h0).trans ((pieceOpenMap true).right_inv h1).symm
  obtain ⟨hx,hxe⟩ := (TwoGluing.inclusion_mixed_eq collar gluingMap _ _).mp he
  exact ⟨hx,(TwoGluing.extendedTransition_apply collar gluingMap ⟨_,hx⟩).trans hxe⟩
lemma piece_inverse_transition_germ {p : GluedConstruction.Manifold}
    (h0 : p ∈ (pieceOpenMap false).target) (h1 : p ∈ (pieceOpenMap true).target) :
    (pieceOpenMap true).symm =ᶠ[nhds p]
      (TwoGluing.extendedTransition collar gluingMap ∘ (pieceOpenMap false).symm) := by
  filter_upwards [(pieceOpenMap false).open_target.mem_nhds h0,
    (pieceOpenMap true).open_target.mem_nhds h1] with q hq0 hq1
  exact (piece_inverse_transition hq0 hq1).choose_spec.symm

lemma glued_mixed_metric {δ : ℝ} (hδ : δ ∈ Ioc 0 (1/2)) {p : GluedConstruction.Manifold}
    (h0 : p ∈ (pieceOpenMap false).target) (h1 : p ∈ (pieceOpenMap true).target) :
    pullInner (E := EP) (leftPiece hδ) (pieceOpenMap false).symm p =
      pullInner (E := EP) (rightPiece hδ) (pieceOpenMap true).symm p := by
  obtain ⟨hx,hxe⟩ := piece_inverse_transition h0 h1
  rw [pullInner_congr _ (piece_inverse_transition_germ h0 h1)]
  rw [pull_composition _ ((pieceOpenMap_inverse_smooth false h0).mdifferentiableAt (by simp))
    ((transition_smooth ⟨_,hx⟩).mdifferentiableAt (by simp))]
  exact congrArg (fun b : EP →L[ℝ] EP →L[ℝ] ℝ =>
    pullBilin (E := EP) (F := EP) b (mfderiv 𝓘(ℝ,EP) 𝓘(ℝ,EP) (pieceOpenMap false).symm p))
      (piece_overlap hδ ⟨_,hx⟩)

def pieceMetrics {δ : ℝ} (hδ : δ ∈ Ioc 0 (1/2)) (i : Bool) : Metric (E := EP) Piece :=
  if i then rightPiece hδ else leftPiece hδ
lemma pieceMetrics_compatible {δ : ℝ} (hδ : δ ∈ Ioc 0 (1/2)) (i j : Bool)
    (p : GluedConstruction.Manifold) (hi : p ∈ (pieceOpenMap i).symm.source)
    (hj : p ∈ (pieceOpenMap j).symm.source) :
    pullInner (E := EP) (pieceMetrics hδ i) (pieceOpenMap i).symm p =
      pullInner (E := EP) (pieceMetrics hδ j) (pieceOpenMap j).symm p := by
  cases i <;> cases j
  · rfl
  · exact glued_mixed_metric hδ hi hj
  · exact (glued_mixed_metric hδ hj hi).symm
  · rfl
lemma inverse_piece_smooth (i : Bool) :
    ContMDiffOn 𝓘(ℝ,EP) 𝓘(ℝ,EP) ∞ (pieceOpenMap i).symm (pieceOpenMap i).symm.source :=
  fun _ hp => (pieceOpenMap_inverse_smooth i hp).contMDiffWithinAt

def compactMetric {δ : ℝ} (hδ : δ ∈ Ioc 0 (1/2)) : Metric (E := EP) GluedConstruction.Manifold :=
  glue (fun i => (pieceOpenMap i).symm) pieceOpenMap_cover (pieceMetrics hδ)
    (pieceMetrics_compatible hδ) inverse_piece_smooth (fun i => (pieceOpenMap_mdifferentiable i).symm)
lemma compactMetric_local {δ : ℝ} (hδ : δ ∈ Ioc 0 (1/2)) (i : Bool) (x : Piece) :
    pullInner (E := EP) (compactMetric hδ) (inclusion i) x = (pieceMetrics hδ i).inner x := by
  exact glue_inverse (fun i => (pieceOpenMap i).symm) pieceOpenMap_cover (pieceMetrics hδ)
    (pieceMetrics_compatible hδ) inverse_piece_smooth (fun i => (pieceOpenMap_mdifferentiable i).symm) i x
    (by exact mem_univ _)
end ThreeManifold.CompactMetric

namespace ThreeManifold.Rechart
variable {E F M : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
  [NormedAddCommGroup F] [NormedSpace ℝ F] [TopologicalSpace M]
  [ChartedSpace E M] [IsManifold 𝓘(ℝ,E) ∞ M]
variable (e : E ≃L[ℝ] F)

lemma identity_smooth_forward : let := charts (M := M) e
    ContMDiff 𝓘(ℝ,E) 𝓘(ℝ,F) ∞ (id : M → M) := by
  dsimp only
  let := charts (M := M) e
  let := isManifold (M := M) e
  intro x
  have h1 := contMDiffAt_of_mem_maximalAtlas (I := 𝓘(ℝ,E))
    (chart_mem_maximalAtlas (I := 𝓘(ℝ,E)) (n := ∞) x) (mem_chart_source _ _)
  have h2 : ContMDiffAt 𝓘(ℝ,E) 𝓘(ℝ,F) ∞ e (chartAt E x x) :=
    e.contDiff.contMDiff.contMDiffAt
  have ht : e (chartAt E x x) ∈ (chartAt F x).target := by
    rw [show chartAt F x = chart e (chartAt E x) from rfl,chart_target]
    exact ⟨chartAt E x x,(chartAt E x).map_source (mem_chart_source _ _),rfl⟩
  have h3 := contMDiffAt_symm_of_mem_maximalAtlas (I := 𝓘(ℝ,F))
    (chart_mem_maximalAtlas (I := 𝓘(ℝ,F)) (n := ∞) x) ht
  apply (h3.comp x (h2.comp x h1)).congr_of_eventuallyEq
  filter_upwards [(chartAt E x).open_source.mem_nhds (mem_chart_source _ _)] with y hy
  change y = (chartAt E x).symm (e.symm (e (chartAt E x y)))
  rw [e.symm_apply_apply,(chartAt E x).left_inv hy]

lemma identity_smooth_backward : let := charts (M := M) e
    ContMDiff 𝓘(ℝ,F) 𝓘(ℝ,E) ∞ (id : M → M) := by
  dsimp only
  let := charts (M := M) e
  let := isManifold (M := M) e
  intro x
  have h1 := contMDiffAt_of_mem_maximalAtlas (I := 𝓘(ℝ,F))
    (chart_mem_maximalAtlas (I := 𝓘(ℝ,F)) (n := ∞) x) (mem_chart_source _ _)
  have h2 : ContMDiffAt 𝓘(ℝ,F) 𝓘(ℝ,E) ∞ e.symm (chartAt F x x) :=
    e.symm.contDiff.contMDiff.contMDiffAt
  have ht : e.symm (chartAt F x x) ∈ (chartAt E x).target := by
    change e.symm (e (chartAt E x x)) ∈ (chartAt E x).target
    rw [e.symm_apply_apply]
    exact (chartAt E x).map_source (mem_chart_source _ _)
  have h3 := contMDiffAt_symm_of_mem_maximalAtlas (I := 𝓘(ℝ,E))
    (chart_mem_maximalAtlas (I := 𝓘(ℝ,E)) (n := ∞) x) ht
  apply (h3.comp x (h2.comp x h1)).congr_of_eventuallyEq
  filter_upwards [(chartAt E x).open_source.mem_nhds (mem_chart_source _ _)] with y hy
  change y = (chartAt E x).symm (e.symm (e (chartAt E x y)))
  rw [e.symm_apply_apply,(chartAt E x).left_inv hy]
end ThreeManifold.Rechart
end

open Set Filter Topology Bundle Manifold IsManifold Bornology
open scoped ContDiff
namespace ThreeManifold.CompactMetric
open MetricConstruction CylinderConstruction GluedConstruction

def realCompactMetric {δ : ℝ} (hδ : δ ∈ Ioc 0 (1/2)) : SmoothMetric GluedConstruction.Manifold :=
  pullbackHomeomorph (compactMetric hδ) (Homeomorph.refl _)
    (Rechart.identity_smooth_backward Coordinates3.coordinates)
    (Rechart.identity_smooth_forward Coordinates3.coordinates)

theorem closed_oriented_metric :
    ∃ (M : Type) (top : TopologicalSpace M),
      letI := top
      ∃ (_ : T2Space M) (_ : SecondCountableTopology M) (_ : CompactSpace M)
        (_ : ConnectedSpace M) (charts : ChartedSpace E3 M),
        letI := charts
        ∃ (smooth : IsManifold I3 ∞ M),
          letI := smooth
          OrientedAtlas (M := M) ∧ Nonempty (SmoothMetric M) := by
  exact ⟨GluedConstruction.Manifold,inferInstance,inferInstance,inferInstance,inferInstance,
    inferInstance,realCharts,realSmooth,manifold_oriented,
    ⟨realCompactMetric (δ := 1/4) (by norm_num)⟩⟩
end ThreeManifold.CompactMetric

end

end OAI