diff --git a/Mathlib.lean b/Mathlib.lean
index 2ed01bc313bb77..8f655d3724c8ed 100644
--- a/Mathlib.lean
+++ b/Mathlib.lean
@@ -4463,6 +4463,7 @@ public import Mathlib.Geometry.Manifold.Notation
 public import Mathlib.Geometry.Manifold.PartitionOfUnity
 public import Mathlib.Geometry.Manifold.PoincareConjecture
 public import Mathlib.Geometry.Manifold.Riemannian.Basic
+public import Mathlib.Geometry.Manifold.Riemannian.ExistsRiemannianMetric
 public import Mathlib.Geometry.Manifold.Riemannian.PathELength
 public import Mathlib.Geometry.Manifold.Sheaf.Basic
 public import Mathlib.Geometry.Manifold.Sheaf.LocallyRingedSpace
@@ -4472,16 +4473,31 @@ public import Mathlib.Geometry.Manifold.SmoothEmbedding
 public import Mathlib.Geometry.Manifold.StructureGroupoid
 public import Mathlib.Geometry.Manifold.VectorBundle.Basic
 public import Mathlib.Geometry.Manifold.VectorBundle.CovariantDerivative.Basic
+public import Mathlib.Geometry.Manifold.VectorBundle.CovariantDerivative.ChristoffelSymbols
+public import Mathlib.Geometry.Manifold.VectorBundle.CovariantDerivative.Curvature
+public import Mathlib.Geometry.Manifold.VectorBundle.CovariantDerivative.Ehresmann
+public import Mathlib.Geometry.Manifold.VectorBundle.CovariantDerivative.Geodesics
+public import Mathlib.Geometry.Manifold.VectorBundle.CovariantDerivative.IntegralCurvePrelim
+public import Mathlib.Geometry.Manifold.VectorBundle.CovariantDerivative.LeviCivita
+public import Mathlib.Geometry.Manifold.VectorBundle.CovariantDerivative.Lift
+public import Mathlib.Geometry.Manifold.VectorBundle.CovariantDerivative.Metric
+public import Mathlib.Geometry.Manifold.VectorBundle.CovariantDerivative.Prelim
 public import Mathlib.Geometry.Manifold.VectorBundle.CovariantDerivative.Torsion
+public import Mathlib.Geometry.Manifold.VectorBundle.CovariantDerivative.Torsion2
+public import Mathlib.Geometry.Manifold.VectorBundle.CovariantDerivative.TrivPrelim
+public import Mathlib.Geometry.Manifold.VectorBundle.CovariantDerivative.Trivial
 public import Mathlib.Geometry.Manifold.VectorBundle.FiberwiseLinear
+public import Mathlib.Geometry.Manifold.VectorBundle.GramSchmidtOrtho
 public import Mathlib.Geometry.Manifold.VectorBundle.Hom
 public import Mathlib.Geometry.Manifold.VectorBundle.LocalFrame
 public import Mathlib.Geometry.Manifold.VectorBundle.MDifferentiable
+public import Mathlib.Geometry.Manifold.VectorBundle.OrthonormalFrame
 public import Mathlib.Geometry.Manifold.VectorBundle.Pullback
 public import Mathlib.Geometry.Manifold.VectorBundle.Riemannian
 public import Mathlib.Geometry.Manifold.VectorBundle.SmoothSection
 public import Mathlib.Geometry.Manifold.VectorBundle.Tangent
 public import Mathlib.Geometry.Manifold.VectorBundle.Tensoriality
+public import Mathlib.Geometry.Manifold.VectorBundle.Unused
 public import Mathlib.Geometry.Manifold.VectorField.LieBracket
 public import Mathlib.Geometry.Manifold.VectorField.Pullback
 public import Mathlib.Geometry.Manifold.WhitneyEmbedding
diff --git a/Mathlib/Geometry/Manifold/CheatSheet.md b/Mathlib/Geometry/Manifold/CheatSheet.md
new file mode 100644
index 00000000000000..ede331a4011da6
--- /dev/null
+++ b/Mathlib/Geometry/Manifold/CheatSheet.md
@@ -0,0 +1,127 @@
+## Differential geometry cheat sheet
+
+How do I say certain basic things in Lean?
+For each of them, include a variable block. Can verso do this already?
+
+
+Let M be a C^k manifold.
+```
+variable {𝕜 E M H : Type*} [NontriviallyNormedField 𝕜] [NormedAddCommGroup E]
+  [NormedSpace 𝕜 E] [TopologicalSpace H] [TopologicalSpace M] {k : ℕ} -- more general: take k : WithTop ℕ∞, allows smooth and analytic; remove WithTop to exclude analyticity
+  {I : ModelWithCorners 𝕜 E H} [ChartedSpace H M] [IsManifold I k M]
+```
+
+Let M be a smooth manifold
+```
+variable {𝕜 E M H : Type*} [NontriviallyNormedField 𝕜] [NormedAddCommGroup E]
+  [NormedSpace 𝕜 E] [TopologicalSpace H] [TopologicalSpace M]
+  {I : ModelWithCorners 𝕜 E H} [ChartedSpace H M] [IsManifold I ∞ M]
+```
+
+Let M be a smooth real manifold.
+```
+variable {E M H : Type*} [NormedAddCommGroup E]
+  [NormedSpace ℝ E] [TopologicalSpace H] [TopologicalSpace M]
+  {I : ModelWithCorners ℝ E H} [ChartedSpace H M] [IsManifold I ∞ M] -- test, needs open scoped Manifold??
+```
+
+Let M be an analytic manifold
+```
+open scoped Manifold -- test, necessary?
+
+variable {𝕜 E M H : Type*} [NontriviallyNormedField 𝕜] [NormedAddCommGroup E]
+  [NormedSpace 𝕜 E] [TopologicalSpace H] [TopologicalSpace M]
+  {I : ModelWithCorners 𝕜 E H} [ChartedSpace H M] [IsManifold I ω M]
+```
+
+Differentiability of functions between manifolds
+```
+import Mathlib.Geometry.Manifold.MFDeriv.Defs
+import Mathlib.Geometry.Manifold.ContMDiff.Defs
+
+variable
+  -- Given a non-trivially normed field 𝕜
+  {𝕜 : Type*} [NontriviallyNormedField 𝕜]
+  -- A manifold M over 𝕜
+  {E : Type*} [NormedAddCommGroup E] [NormedSpace 𝕜 E]
+  {H : Type*} [TopologicalSpace H] (I : ModelWithCorners 𝕜 E H)
+  {M : Type*} [TopologicalSpace M] [ChartedSpace H M]
+  -- A manifold M' over 𝕜
+  {E' : Type*} [NormedAddCommGroup E'] [NormedSpace 𝕜 E']
+  {H' : Type*} [TopologicalSpace H'] (I' : ModelWithCorners 𝕜 E' H')
+  {M' : Type*} [TopologicalSpace M'] [ChartedSpace H' M']
+  -- A function from M to M' and x in M
+  (f : M → M') (x : M)
+
+variable (x : M) in
+-- f is differentiable at x
+#check MDifferentiableAt I I' f x
+
+variable (n : WithTop ℕ∞) in -- A natural number or ∞ or ω
+#check ContMDiff I I' n f
+
+
+variable
+  {F : Type*} [NormedAddCommGroup F] [NormedSpace 𝕜 F]
+  (g : M → F) in
+open scoped Manifold in
+#check ContMDiff I 𝓘(𝕜, F) n g  -- g is n times continuously differentiable
+```
+
+Consider the product manifold M \times N.
+
+
+Let \phi be the preferred chart at x\in M.
+
+Let \phi be any (compatible) chart on M.
+
+--------
+
+Let E\to M be a topological vector bundle.
+
+Let E\to M be a smooth vector bundle.
+
+Let s be a section of E.
+```
+variable (s : Π x : M, V x)
+```
+Let X be a vector field on `M`
+```
+(X : Π x : M, TangentSpace I x)
+```
+
+Let s be a C^k section of E. / The section s of E is C^k.
+```
+ContMDiff I (I.prod 𝓘(𝕜, F)) (k + 1) (fun x ↦ TotalSpace.mk' F x (σ x))
+```
+
+Let `X` be a C^k vector field on M.
+```
+variable {X : Π x : M, TangentSpace I x}
+-- TODO: this doesn't work!
+-- variable (___hX: ContMDiff I I.tangent 2 (fun x ↦ (X x : TangentBundle I M)))
+```
+
+Let \phi be the preferred local trivialisation at x\in E.
+Let \phi be any compatible trivialisation on M.
+
+Consider the tangent bundle TM of M.
+
+Let X be a C^k vector field on M.
+
+explain TotalSpace.mk' somewhere in here...
+
+
+
+**Basic API lemmas**
+- testing smoothness of a map in charts: the standard charts; any charts
+
+- testing smoothness of a section in trivialisations: the standard charts; any charts
+
+
+**constructions**
+- product manifold (tricky!)
+- disjoint union
+
+- product bundle (how difficult?)
+- Lie bracket of vector fields
diff --git a/Mathlib/Geometry/Manifold/MFDeriv/NormedSpace.lean b/Mathlib/Geometry/Manifold/MFDeriv/NormedSpace.lean
index aefaa0e157067d..0e2769b98e8589 100644
--- a/Mathlib/Geometry/Manifold/MFDeriv/NormedSpace.lean
+++ b/Mathlib/Geometry/Manifold/MFDeriv/NormedSpace.lean
@@ -83,7 +83,7 @@ theorem Differentiable.comp_mdifferentiable {g : F → F'} {f : M → F}
 
 end Module
 
-section ExtChartAt
+section extChartAt
 
 variable {F : Type*} [NormedAddCommGroup F] [NormedSpace 𝕜 F] {f : M → F}
 
@@ -101,7 +101,7 @@ theorem DifferentiableWithinAt.mdifferentiableWithinAt_of_comp_extChartAt_symm [
   refine (mdifferentiableWithinAt_iff_source_of_mem_source (mem_chart_source H x)).2 ?_
   simpa [extChartAt_self_eq] using hf.mdifferentiableWithinAt
 
-end ExtChartAt
+end extChartAt
 
 /-! ### Linear maps between normed spaces are differentiable -/
 
@@ -398,20 +398,20 @@ end smul
 /-! ### Exterior derivative of a scalar function -/
 
 /-- The exterior derivative of a scalar function on `M`, as a section of the cotangent bundle. -/
-noncomputable abbrev extDerivFun (g : M → 𝕜) :
-    Π x : M, TangentSpace I x →L[𝕜] 𝕜 :=
+noncomputable abbrev extDerivFun (g : M → F) :
+    Π x : M, TangentSpace I x →L[𝕜] F :=
   fun x ↦ (NormedSpace.fromTangentSpace <| g x).toContinuousLinearMap ∘L (mfderiv% g x)
 
 @[simp]
-lemma extDerivFun_add {g g' : M → 𝕜} {x : M} (hg : MDiffAt g x) (hg' : MDiffAt g' x) :
+lemma extDerivFun_add {g g' : M → F} {x : M} (hg : MDiffAt g x) (hg' : MDiffAt g' x) :
     extDerivFun (g + g') x = extDerivFun (I := I) g x + extDerivFun g' x := by
   simp [extDerivFun, mfderiv_add hg hg']
   congr
 
 @[simp]
-lemma extDerivFun_zero {x : M} : extDerivFun (I := I) (0 : M → 𝕜) x = 0 := by
-  have : extDerivFun (0 : M → 𝕜) x + extDerivFun (0 : M → 𝕜) x =
-      extDerivFun (I := I) (0 : M → 𝕜) x := by
+lemma extDerivFun_zero {x : M} : extDerivFun (I := I) (0 : M → F) x = 0 := by
+  have : extDerivFun (0 : M → F) x + extDerivFun (0 : M → F) x =
+      extDerivFun (I := I) (0 : M → F) x := by
     rw [← extDerivFun_add (by exact mdifferentiable_const ..) (by exact mdifferentiable_const ..)]
     simp
   simpa using this
diff --git a/Mathlib/Geometry/Manifold/MFDeriv/SpecificFunctions.lean b/Mathlib/Geometry/Manifold/MFDeriv/SpecificFunctions.lean
index 19a57d0c91d8d5..0f77ccf83303c0 100644
--- a/Mathlib/Geometry/Manifold/MFDeriv/SpecificFunctions.lean
+++ b/Mathlib/Geometry/Manifold/MFDeriv/SpecificFunctions.lean
@@ -790,6 +790,20 @@ theorem mfderiv_add (hf : MDiffAt f z) (hg : MDiffAt g z) :
       (by exact mfderiv% f z) + (by exact mfderiv% g z) :=
   (hf.hasMFDerivAt.add hg.hasMFDerivAt).mfderiv
 
+open NormedSpace in
+theorem fromTangentSpace_mfderiv_add (hf : MDiffAt f z) (hg : MDiffAt g z) :
+    (fromTangentSpace _).toContinuousLinearMap ∘L (mfderiv% (f + g) z)
+    = (fromTangentSpace _).toContinuousLinearMap ∘L (mfderiv% f z)
+    + (fromTangentSpace _).toContinuousLinearMap ∘L (mfderiv% g z) :=
+  (hf.hasMFDerivAt.add hg.hasMFDerivAt).mfderiv
+
+open NormedSpace in
+theorem fromTangentSpace_mfderiv_add_apply (hf : MDiffAt f z) (hg : MDiffAt g z)
+    (v : TangentSpace I x) :
+    fromTangentSpace _ (mfderiv% (f + g) z v)
+    = fromTangentSpace _ (mfderiv% f z v) + fromTangentSpace _ (mfderiv% g z v) :=
+  congr($(fromTangentSpace_mfderiv_add hf hg) v)
+
 section sum
 variable {ι : Type} {t : Finset ι} {f : ι → M → E'} {f' : ι → TangentSpace I z →L[𝕜] E'}
 
diff --git a/Mathlib/Geometry/Manifold/Riemannian/ExistsRiemannianMetric.lean b/Mathlib/Geometry/Manifold/Riemannian/ExistsRiemannianMetric.lean
new file mode 100644
index 00000000000000..5dac18d1b9c710
--- /dev/null
+++ b/Mathlib/Geometry/Manifold/Riemannian/ExistsRiemannianMetric.lean
@@ -0,0 +1,301 @@
+/-
+Copyright (c) 2025 Michael Rothgang. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Michael Rothgang
+-/
+module
+
+import Mathlib.Geometry.Manifold.PartitionOfUnity
+import Mathlib.Geometry.Manifold.VectorBundle.OrthonormalFrame
+import Mathlib.Geometry.Manifold.VectorBundle.Riemannian
+
+/-! ## Existence of a Riemannian bundle metric
+Using a partition of unity, we prove that every finite-dimensional smooth vector bundle
+admits a smooth Riemannian metric.
+
+## TODO
+- this should work for C^n; prove the same for topological bundles and add it there
+- also deduce that every manifold can be made Riemannian...
+-/
+
+open Bundle ContDiff Manifold
+
+-- Let E be a smooth vector bundle over a manifold E
+
+variable
+  {EB : Type*} [NormedAddCommGroup EB] [NormedSpace ℝ EB]
+  {HB : Type*} [TopologicalSpace HB] {IB : ModelWithCorners ℝ EB HB} {n : WithTop ℕ∞}
+  {B : Type*} [TopologicalSpace B] [ChartedSpace HB B]
+  {F : Type*} [NormedAddCommGroup F] [NormedSpace ℝ F]
+  {E : B → Type*} [TopologicalSpace (TotalSpace F E)]
+  [∀ x, TopologicalSpace (E x)] [∀ x, AddCommGroup (E x)] [∀ x, Module ℝ (E x)]
+  [FiberBundle F E] [VectorBundle ℝ F E]
+  [IsManifold IB n B] [ContMDiffVectorBundle n F E IB]
+
+-- This file is really slow, for reasons to be investigated, and not crucially required for
+-- studying Ehresman or the Levi-Civita connections. Thus, let us not compile it for now.
+#exit
+
+section
+
+variable (E) in
+/-- This is the bundle `Hom_ℝ(E, T)`, where `T` is the rank one trivial bundle over `B`. -/
+private def V : (b : B) → Type _ := (fun b ↦ E b →L[ℝ] Trivial B ℝ b)
+
+-- TODO: all of these instances are really slow, investigate and fix this!
+noncomputable instance : (x : B) → TopologicalSpace (V E x) := by
+  unfold V
+  infer_instance
+
+noncomputable instance : (x : B) → AddCommGroup (V E x) := by
+  unfold V
+  infer_instance
+
+noncomputable instance (x : B) : Module ℝ (V E x) := by
+  unfold V
+  infer_instance
+
+noncomputable instance : TopologicalSpace (TotalSpace (F →L[ℝ] ℝ) (V E)) := by
+  unfold V
+  infer_instance
+
+noncomputable instance : FiberBundle (F →L[ℝ] ℝ) (V E) := by
+  unfold V
+  infer_instance
+
+noncomputable instance : VectorBundle ℝ (F →L[ℝ] ℝ) (V E) := by
+  unfold V
+  infer_instance
+
+noncomputable instance : ContMDiffVectorBundle n (F →L[ℝ] ℝ) (V E) IB := by
+  unfold V
+  infer_instance
+
+instance (x : B) : ContinuousAdd (V E x) := by
+  unfold V
+  infer_instance
+
+instance (x : B) : ContinuousSMul ℝ (V E x) := by
+  unfold V
+  infer_instance
+
+instance (x : B) : IsTopologicalAddGroup (V E x) := by
+  unfold V
+  infer_instance
+
+example : ContMDiffVectorBundle n (F →L[ℝ] F →L[ℝ] ℝ) (fun b ↦ E b →L[ℝ] V E b) IB :=
+  ContMDiffVectorBundle.continuousLinearMap (IB := IB) (n := n)
+    (F₁ := F) (E₁ := E) (F₂ := F →L[ℝ] ℝ) (E₂ := V E)
+
+variable (E) in
+/-- The real vector bundle `Hom(E, Hom(E, T)) = Hom(E, V)`, whose fiber at `x` is
+(equivalent to) the space of continuous real bilinear maps `E x → E x → ℝ`. -/
+private def W : (b : B) → Type _ := fun b ↦ E b →L[ℝ] V E b
+
+noncomputable instance (x : B) : AddCommGroup (W E x) := by
+  unfold W
+  infer_instance
+
+noncomputable instance (x : B) : Module ℝ (W E x) := by
+  unfold W
+  infer_instance
+
+noncomputable instance : TopologicalSpace (TotalSpace (F →L[ℝ] F →L[ℝ] ℝ) (W E)) := by
+  unfold W
+  infer_instance
+
+noncomputable instance (x : B) : TopologicalSpace (W E x) := by
+  unfold W
+  infer_instance
+
+noncomputable instance : FiberBundle (F →L[ℝ] F →L[ℝ] ℝ) (W E) := by
+  unfold W
+  infer_instance
+
+noncomputable instance : VectorBundle ℝ (F →L[ℝ] F →L[ℝ] ℝ) (W E) := by
+  unfold W
+  infer_instance
+
+noncomputable instance : ContMDiffVectorBundle n (F →L[ℝ] F →L[ℝ] ℝ) (W E) IB := by
+  unfold W
+  infer_instance
+
+end
+
+variable (E) in
+/-- The first condition imposed on sections of `W`: they should give rise to a symmetric
+pairing on each fibre `E x`. -/
+private def condition1 (x : B) : Set (E x →L[ℝ] E x →L[ℝ] ℝ) :=
+  {φ | ∀ v w : E x, φ v w = φ w v}
+
+variable (E) in
+/-- The second condition imposed on sections of `W`: they should give rise to a positive definite
+pairing on each fibre `E x`. -/
+private def condition2 (x : B) : Set (E x →L[ℝ] E x →L[ℝ] ℝ) :=
+  {φ | ∀ v : E x, v ≠ 0 → 0 < φ v v}
+
+omit [TopologicalSpace B] in
+lemma convex_condition1 (x : B) : Convex ℝ (condition1 E x) := by
+  intro φ hφ ψ hψ s t hs ht hst v w
+  simp [hφ v w, hψ v w]
+
+omit [TopologicalSpace B] in
+lemma convex_condition2 (x : B) : Convex ℝ (condition2 E x) := by
+  unfold condition2
+  intro φ hφ ψ hψ s t hs ht hst v hv
+  rw [Set.mem_setOf] at hφ hψ
+  have aux := Convex.min_le_combo ((φ v) v) ((ψ v) v) hs ht hst
+  have : 0 < min ((φ v) v) ((ψ v) v) := lt_min (hφ v hv) (hψ v hv)
+  simpa using gt_of_ge_of_gt aux this
+
+variable (E) in
+/-- Conditions imposed on sections of `W`: they should give rise to a positive definite symmetric
+pairing on each fibre `E x`. -/
+def condition (x : B) : Set (W E x) := by
+  unfold W V Bundle.Trivial
+  exact condition1 E x ∩ condition2 E x
+
+omit [TopologicalSpace B] in
+lemma convex_condition (x : B) : Convex ℝ (condition E x) :=
+  Convex.inter (convex_condition1 x) (convex_condition2 x)
+
+variable [FiniteDimensional ℝ EB] [IsManifold IB ∞ B] [SigmaCompactSpace B] [T2Space B]
+
+-- TODO: construct a local section which is smooth in my coords,
+-- and has all the definiteness properties I'll want later!
+variable (E) in
+def local_section_at (x₀ : B) : (x : B) → W E x := sorry
+
+variable (E F) in
+lemma contMDiff_localSection (x₀ : B) :
+    letI t := trivializationAt F E x₀
+    ContMDiffOn IB (IB.prod 𝓘(ℝ, F →L[ℝ] F →L[ℝ] ℝ)) ∞
+      (fun x ↦ TotalSpace.mk' (F →L[ℝ] F →L[ℝ] ℝ) x (local_section_at E x₀ x)) t.baseSet :=
+  sorry
+
+-- MAYBE: also make a definition nhd, which is the nhd on which local_section_at stays pos. def.
+lemma is_good_localSection (x₀ : B) :
+    ∀ y ∈ (trivializationAt F E x₀).baseSet, local_section_at E x₀ y ∈ condition E y := by
+  intro y hy
+  unfold condition
+  simp only [id_eq]
+  erw [Set.mem_setOf]
+  refine ⟨?_, ?_⟩
+  · sorry -- symmetry
+  · sorry -- pos. definite
+
+lemma hloc_TODO (x₀ : B) :
+    ∃ U_x₀ ∈ nhds x₀, ∃ s_loc : (x : B) → W E x,
+      ContMDiffOn IB (IB.prod 𝓘(ℝ, F →L[ℝ] F →L[ℝ] ℝ)) ∞
+        (fun x ↦ TotalSpace.mk' (F →L[ℝ] F →L[ℝ] ℝ) x (s_loc x)) U_x₀ ∧
+      ∀ y ∈ U_x₀, s_loc y ∈ condition E y := by
+  letI t := trivializationAt F E x₀
+  have := t.open_baseSet.mem_nhds <| FiberBundle.mem_baseSet_trivializationAt' x₀
+  use t.baseSet, this, local_section_at E x₀
+  exact ⟨contMDiff_localSection F E x₀, is_good_localSection x₀⟩
+
+variable (E F IB) in
+/-- Key step in the construction of a Riemannian metric on `E`: we construct a smooth section
+of the bundle `W = Hom(E, Hom(E, T))` with the right properties (translating into symmetric
+and positive definiteness of the resulting metric. -/
+noncomputable def foo_aux : Cₛ^∞⟮IB; F →L[ℝ] F →L[ℝ] ℝ, W E⟯ :=
+  Classical.choose <|
+    exists_contMDiffOn_section_forall_mem_convex_of_local IB (V := W E) (n := (⊤ : ℕ∞))
+      (condition E) convex_condition hloc_TODO
+
+variable (E F IB) in
+lemma foo_aux_prop (x₀ : B) : foo_aux IB F E x₀ ∈ condition E x₀ := by
+  apply Classical.choose_spec <|
+    exists_contMDiffOn_section_forall_mem_convex_of_local IB (V := W E) (n := (⊤ : ℕ∞))
+      (condition E) convex_condition hloc_TODO
+
+-- In what generality does this hold?
+lemma aux_special (G : Type*) [NormedAddCommGroup G] [NormedSpace ℝ G] [FiniteDimensional ℝ G]
+    (φ : G →L[ℝ] G →L[ℝ] ℝ) (hpos : ∀ v : G, v ≠ 0 → 0 < φ v v) :
+    Bornology.IsVonNBounded ℝ {v | (φ v) v < 1} := by
+  -- Proof sketch: choose a basis {b_i} of G.
+  -- Each `φ b_i b_i` is non-zero by hypothesis, hence has positive norm.
+  -- By finite-dimensionality of `G`, we have `0 < r := min ‖φ b_i b_i‖`,
+  -- thus B(r, 0) is contained in the image of the unit ball under v ↦ φ v v.
+  sorry
+
+section aux
+
+variable {G : Type*} [AddCommGroup G] [TopologicalSpace G] [Module ℝ G]
+  [ContinuousAdd G] [ContinuousSMul ℝ G] [FiniteDimensional ℝ G]
+
+-- XXX: this is also a norm, not just a seminorm!
+noncomputable def mynorm (φ : G →L[ℝ] G →L[ℝ] ℝ) : Seminorm ℝ G where
+  toFun v := Real.sqrt (φ v v)
+  map_zero' := by simp
+  add_le' r s := by sorry -- shouldn't be difficult
+  neg' r := by simp
+  smul' a v := by simp [← mul_assoc, ← Real.sqrt_mul_self_eq_abs, Real.sqrt_mul (mul_self_nonneg a)]
+
+-- noncomputable def mynorm_space (φ : G →L[ℝ] G →L[ℝ] ℝ) : SeminormedAddCommGroup G where
+--   norm := mynorm φ
+--   dist_self x := by simp
+--   dist_comm x y := by
+--     simp only [mynorm]
+--     change Real.sqrt (φ (x - y) (x - y)) = Real.sqrt (φ (y - x) (y - x))
+--     sorry -- is just neg, so provable
+--   dist_triangle := sorry -- follows from add_le' above (probably not difficult)
+
+-- attribute [local instance] mynorm_space
+-- noncomputable def mynorm_space2 (φ : G →L[ℝ] G →L[ℝ] ℝ) : NormedSpace ℝ G where
+
+noncomputable def aux (φ : G →L[ℝ] G →L[ℝ] ℝ) : SeminormFamily ℝ G (Fin 1) := fun _ ↦ mynorm φ
+
+lemma hoge (φ : G →L[ℝ] G →L[ℝ] ℝ) (hpos : ∀ v : G, v ≠ 0 → 0 < φ v v) : WithSeminorms (aux φ) :=
+  -- In finite dimension there is a single topological vector space structure...
+  -- and mynorm defines a norm, hence a TVS structure.
+  sorry
+
+end aux
+
+-- golfing suggestions welcome
+lemma qux {α : Type*} [Unique α] (s : Finset α) : s = ∅ ∨ s = {default} := by
+  by_cases h : s = ∅
+  · simp [h]
+  · rw [Finset.eq_singleton_iff_nonempty_unique_mem]
+    refine Or.inr ⟨Finset.nonempty_iff_ne_empty.mpr h, fun x hx ↦ Unique.uniq _ _⟩
+
+lemma aux_tvs (G : Type*) [AddCommGroup G] [TopologicalSpace G] [Module ℝ G]
+    [ContinuousAdd G] [ContinuousSMul ℝ G] [FiniteDimensional ℝ G]
+    (φ : G →L[ℝ] G →L[ℝ] ℝ) (hpos : ∀ v : G, v ≠ 0 → 0 < φ v v) :
+    Bornology.IsVonNBounded ℝ {v | (φ v) v < 1} := by
+  -- Proof sketch (courtesy of Sébastien  Gouezel):
+  -- Phi gives you a norm, which defines the same topology as the initial one
+  -- (as in finite dimension there is a single topological vector space structure).
+  -- The unit ball for the norm is von Neumann bounded wrt the topology defined by the norm
+  -- (we have this in mathlib), so also for the initial topology.
+  rw [WithSeminorms.isVonNBounded_iff_finset_seminorm_bounded (p := aux φ) (hoge φ hpos)]
+  intro I
+  letI J : Finset (Fin 1) := {1}
+  suffices ∃ r > 0, ∀ x ∈ {v | (φ v) v < 1}, (J.sup (aux φ)) x < r by
+    obtain (rfl | h) := qux I
+    · use 1; simp
+    · convert this
+  simp only [Set.mem_setOf_eq, Finset.sup_singleton, J]
+  refine ⟨1, by norm_num, fun x h ↦ ?_⟩
+  simp only [aux, mynorm]
+  change Real.sqrt (φ x x) < 1
+  rw [Real.sqrt_lt' (by norm_num)]
+  simp [h]
+
+-- TODO: is the finite-dimensionality actually required?
+-- Are the TVS hypotheses actually a restriction?
+noncomputable def foo
+    [∀ x, FiniteDimensional ℝ (E x)] [∀ x, ContinuousAdd (E x)] [∀ x, ContinuousSMul ℝ (E x)] :
+    ContMDiffRiemannianMetric IB ∞ F E where
+  inner := foo_aux IB F E
+  symm b := (foo_aux_prop IB F E b).1
+  pos b := (foo_aux_prop IB F E b).2
+  isVonNBounded b := aux_tvs (E b) (foo_aux IB F E b) (foo_aux_prop IB F E b).2
+  contMDiff := (foo_aux IB F E).contMDiff
+
+-- /-- Every `C^n` vector bundle whose fibre admits a `C^n` partition of unity
+-- is a `C^n` Riemannian vector bundle. (The Lean statement assumes an inner product on each fibre
+-- already, which is why there are no other assumptions yet??) -/
+-- lemma ContDiffVectorBundle.isContMDiffRiemannianBundle : IsContMDiffRiemannianBundle IB n F E :=
+--   ⟨RMetric IB E, rMetric_contMDiff, fun x v w ↦ rMetric_eq x v w⟩
diff --git a/Mathlib/Geometry/Manifold/VectorBundle/Basic.lean b/Mathlib/Geometry/Manifold/VectorBundle/Basic.lean
index 4b5bb3c3a8d11b..cb07d559d2b07b 100644
--- a/Mathlib/Geometry/Manifold/VectorBundle/Basic.lean
+++ b/Mathlib/Geometry/Manifold/VectorBundle/Basic.lean
@@ -63,13 +63,9 @@ fields, etc.
 
 assert_not_exists mfderiv
 
-open Bundle Set OpenPartialHomeomorph
-
+open Bundle Filter Set OpenPartialHomeomorph
 open Function (id_def)
-
-open Filter
-
-open scoped Manifold Bundle Topology ContDiff
+open scoped Manifold Topology ContDiff
 
 variable {n : WithTop ℕ∞} {𝕜 B B' F M : Type*} {E : B → Type*}
 
diff --git a/Mathlib/Geometry/Manifold/VectorBundle/CovariantDerivative/Basic.lean b/Mathlib/Geometry/Manifold/VectorBundle/CovariantDerivative/Basic.lean
index f91202ea2fd00f..78ddcd4334d0d0 100644
--- a/Mathlib/Geometry/Manifold/VectorBundle/CovariantDerivative/Basic.lean
+++ b/Mathlib/Geometry/Manifold/VectorBundle/CovariantDerivative/Basic.lean
@@ -142,13 +142,10 @@ lemma iUnion {ι : Type*} {cov : (Π x : M, V x) → (Π x : M, TangentSpace I x
 
 end changing_set
 
--- TODO: prove that `cov σ x` depends on `σ` only via the 1-jet of `σ` at `x`.
--- This will be easy using the projection formula about Ehresmann connections,
--- which will be added in the planned file `CovariantDerivative/Ehresmann.lean`.
--- In the mean-time we use the following weaker results (which are convenient to apply anyway).
-
 /-- Given a covariant derivative `cov` on a neighborhood `s` of a point `x`, if sections `σ` and
-`σ'` agree on `s` and are differentiable at `x`, then `cov σ x = cov σ x'`. -/
+`σ'` agree on `s` and are differentiable at `x`, then `cov σ x = cov σ x'`.
+
+This is a convenient special case of `congr_of_eq_one_jet`. -/
 lemma congr_of_eqOn
     {cov : (Π x : M, V x) → (Π x : M, TangentSpace I x →L[𝕜] V x)}
     {s : Set M} (hcov : IsCovariantDerivativeOn F cov s)
@@ -183,7 +180,9 @@ lemma congr_of_eqOn
 
 open Filter Set in
 /-- Given a covariant derivative `cov` on a neighborhood `s` of a point `x`, if sections `σ` and
-`σ'` agree near `x` and are differentiable at `x`, then `cov σ x = cov σ x'`. -/
+`σ'` agree near `x` and are differentiable at `x`, then `cov σ x = cov σ x'`.
+
+This is a convenient special case of `congr_of_eq_one_jet`. -/
 lemma congr_of_eventuallyEq
     {cov : (Π x : M, V x) → (Π x : M, TangentSpace I x →L[𝕜] V x)}
     {s : Set M} (hcov : IsCovariantDerivativeOn F cov s)
@@ -195,6 +194,18 @@ lemma congr_of_eventuallyEq
   choose s' hs' b using hσσ'
   exact (hcov.mono inter_subset_left).congr_of_eqOn hσ hσ' (inter_mem hxs hs') fun x hx ↦ b x hx.2
 
+/-- Given a covariant derivative `cov` on a neighborhood `s` of a point `x`, if sections `σ` and
+`σ'` are differentiable at `x` with the same one-jet (i.e., agree at `x` and have the same
+`mfderiv`), then `cov σ x = cov σ x'`. -/
+lemma congr_of_eq_one_jet
+    {cov : (Π x : M, V x) → (Π x : M, TangentSpace I x →L[𝕜] V x)}
+    {s : Set M} (hcov : IsCovariantDerivativeOn F cov s) {x : M} (hxs : s ∈ 𝓝 x)
+    {σ σ' : Π x : M, V x} (hσ : MDiffAt (T% σ) x) (hσ' : MDiffAt (T% σ') x)
+    (hσσ' : σ x = σ' x) (hσσ' : mfderiv% (T% σ) x = mfderiv% (T% σ') x) :
+    cov σ x = cov σ' x := by
+  -- This should be easy using the projection formula in `CovariantDerivative.Ehresmann`.
+  sorry
+
 /-! ### Computational properties -/
 
 section computational_properties
@@ -207,6 +218,20 @@ lemma zero [VectorBundle 𝕜 F V] (hcov : IsCovariantDerivativeOn F cov s)
   simpa using (hcov.add (mdifferentiableAt_zeroSection ..)
     (mdifferentiableAt_zeroSection ..) : cov (0 + 0) x = _)
 
+lemma neg [VectorBundle 𝕜 F V] (hcov : IsCovariantDerivativeOn F cov s)
+    {σ : Π x : M, V x} {x}
+    (hσ : MDiffAt (T% σ) x) (hx : x ∈ s := by trivial) :
+    cov (-σ) x = - cov σ x := by
+  rw [eq_neg_iff_add_eq_zero, ← hcov.add (mdifferentiableAt_neg_section hσ) hσ]
+  simp (disch := assumption) [hcov.zero]
+
+lemma sub [VectorBundle 𝕜 F V] (hcov : IsCovariantDerivativeOn F cov s)
+    {σ σ' : Π x : M, V x} {x}
+    (hσ : MDiffAt (T% σ) x) (hσ' : MDiffAt (T% σ') x) (hx : x ∈ s := by trivial) :
+    cov (σ - σ') x = cov σ x - cov σ' x := by
+  rw [sub_eq_neg_add, hcov.add (mdifferentiableAt_neg_section hσ') hσ, hcov.neg hσ']
+  abel
+
 theorem smul_const (hcov : IsCovariantDerivativeOn F cov s)
     {σ : Π x : M, V x} {x} (a : 𝕜)
     (hσ : MDiffAt (T% σ) x) (hx : x ∈ s := by trivial) :
@@ -386,6 +411,22 @@ lemma zero [VectorBundle 𝕜 F V] (cov : CovariantDerivative I F V) : cov 0 = 0
   ext1 x
   simp [cov.isCovariantDerivativeOnUniv.zero]
 
+-- XXX: do we prefer this statement, or point-wise versions instead?
+-- if both, which one should be simp?
+@[simp]
+lemma neg [VectorBundle 𝕜 F V] (cov : CovariantDerivative I F V)
+    {σ : Π x : M, V x} (hσ : MDiff (T% σ)) :
+    cov (-σ) = - cov σ := by
+  ext1 x
+  exact cov.isCovariantDerivativeOnUniv.neg (hσ x)
+
+@[simp]
+lemma sub [VectorBundle 𝕜 F V] (cov : CovariantDerivative I F V)
+    {σ σ' : Π x : M, V x} (hσ : MDiff (T% σ)) (hσ' : MDiff (T% σ')) :
+    cov (σ - σ') = cov σ - cov σ' := by
+  ext1 x
+  exact cov.isCovariantDerivativeOnUniv.sub (hσ x) (hσ' x)
+
 /-- If `cov` is a covariant derivative on each set in an open cover, it is a covariant derivative.
 -/
 def of_isCovariantDerivativeOn_of_open_cover {ι : Type*} {s : ι → Set M}
diff --git a/Mathlib/Geometry/Manifold/VectorBundle/CovariantDerivative/ChristoffelSymbols.lean b/Mathlib/Geometry/Manifold/VectorBundle/CovariantDerivative/ChristoffelSymbols.lean
new file mode 100644
index 00000000000000..ac3171e202f810
--- /dev/null
+++ b/Mathlib/Geometry/Manifold/VectorBundle/CovariantDerivative/ChristoffelSymbols.lean
@@ -0,0 +1,319 @@
+/-
+Copyright (c) 2025 Michael Rothgang. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Michael Rothgang
+-/
+module
+
+public import Mathlib.Analysis.InnerProductSpace.Dual
+public import Mathlib.Geometry.Manifold.VectorBundle.CovariantDerivative.Metric
+public import Mathlib.Geometry.Manifold.VectorBundle.CovariantDerivative.Torsion
+public import Mathlib.Geometry.Manifold.VectorBundle.OrthonormalFrame
+
+/-! # Christoffel symbols for a covariant derivative
+
+Old code for defining the Christoffel symbols of a connection:
+it's not clear how much this will be used,
+and it would need to be thoroughly updated to compile, given the other modifications made
+
+-/
+set_option backward.isDefEq.respectTransparency false
+
+namespace CovariantDerivative
+
+open Bundle Filter Function Module NormedSpace Topology
+open scoped ContDiff Manifold
+
+variable {n : WithTop ℕ∞}
+  {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
+  {H : Type*} [TopologicalSpace H] (I : ModelWithCorners ℝ E H)
+  {M : Type*} [EMetricSpace M] [ChartedSpace H M] [IsManifold I 2 M]
+  [RiemannianBundle (fun (x : M) ↦ TangentSpace I x)]
+  {E' : Type*} [NormedAddCommGroup E'] [NormedSpace ℝ E']
+  {X X' X'' Y Y' Y'' Z Z' : Π x : M, TangentSpace I x}
+  (cov : CovariantDerivative I E (TangentSpace I : M → Type _))
+  [IsContMDiffRiemannianBundle I 1 E (fun (x : M) ↦ TangentSpace I x)] {x : M}
+
+-- TODO: move this section to `Torsion.lean`
+section
+
+--omit [IsContMDiffRiemannianBundle I 1 E (fun (x : M) ↦ TangentSpace I x)]
+--omit [RiemannianBundle (fun (x : M) ↦ TangentSpace I x)]
+
+/-- The **Christoffel symbol** of a covariant derivative on a set `U ⊆ M`
+with respect to a local frame `(s_i)` on `U`: for each triple `(i, j, k)` of indices,
+this is a function `Γᵢⱼᵏ : M → ℝ`, whose value outside of `U` is meaningless. -/
+noncomputable def ChristoffelSymbol
+    (f : (Π x : M, TangentSpace I x) → (Π x : M, TangentSpace I x →L[ℝ] TangentSpace I x))
+    {U : Set M} {ι : Type*} {s : ι → (x : M) → TangentSpace I x}
+    (hs : IsLocalFrameOn I E n s U) (i j k : ι) : M → ℝ :=
+  (LinearMap.piApply (hs.coeff k)) (fun x ↦ f (s i) x (s j x))
+
+-- special case of `foobar` below; needed?
+lemma ChristoffelSymbol.sum_eq
+    (f : (Π x : M, TangentSpace I x) → (Π x : M, TangentSpace I x →L[ℝ] TangentSpace I x))
+    {U : Set M} {ι : Type*} [Fintype ι] {s : ι → (x : M) → TangentSpace I x}
+    (hs : IsLocalFrameOn I E n s U) (i j : ι) (hx : x ∈ U) :
+    f (s i) x (s j x) = ∑ k, (ChristoffelSymbol I f hs i j k x) • (s k) x := by
+  simp only [ChristoffelSymbol, LinearMap.piApply_apply]
+  apply hs.coeff_sum_eq _ hx
+
+variable {U : Set M}
+  {f g : (Π x : M, TangentSpace I x) → (Π x : M, TangentSpace I x →L[ℝ] TangentSpace I x)}
+  {ι : Type*} {s : ι → (x : M) → TangentSpace I x}
+
+-- Note that this result is false if `{s i}` is merely a local frame.
+lemma eq_product_apply [Fintype ι]
+    (hf : IsCovariantDerivativeOn E f U)
+    (hs : IsOrthonormalFrameOn I E n s U)
+    (i j k : ι) (hx : x ∈ U) :
+    ChristoffelSymbol I f hs.toIsLocalFrameOn i j k x = inner ℝ (f (s i) x (s j x)) (s k x) := by
+  -- Choose a linear order on ι: which one really does not matter for our result.
+  have : LinearOrder ι := by
+    choose r wo using exists_wellOrder _
+    exact r
+  have : LocallyFiniteOrderBot ι := by sorry
+  sorry
+  -- was: rw [ChristoffelSymbol, hs.coeff_eq_inner' (f (s i) (s j)) hx k, real_inner_comm]
+
+#exit
+-- TODO: the next lines have a number of errors, and would need to be updated
+
+-- Lemma 4.3 in Lee, Chapter 5: first term still missing
+lemma foobar [Fintype ι] [FiniteDimensional ℝ E] (hf : IsCovariantDerivativeOn E f U)
+    (hs : IsLocalFrameOn I E 1 s U) {x : M} (hx : x ∈ U) :
+    f X x (Y x) = ∑ k,
+      letI S₁ := ∑ i, ∑ j,
+        ((LinearMap.piApply (hs.coeff i)) X) * (LinearMap.piApply (hs.coeff j) Y)
+          * (ChristoffelSymbol I f hs i j k)
+      letI S₂ : M → ℝ := sorry -- first summand in Leibniz' rule!
+      S₁ x • s k x := by
+  have hY := hs.coeff_sum_eq Y hx
+  -- should this be a separate lemma also?
+  have : ∀ x ∈ U, Y x = ∑ i, hs.coeff i x (Y x) • s i x := by
+    intro x hx
+    apply hs.coeff_sum_eq Y hx
+  have : f X x (Y x) = f X (fun x ↦ ∑ i, (hs.coeff i) Y x • s i x) x := by
+    -- apply `congr_σ_of_eventuallyEq` from Basic.lean (after restoring it)
+    -- want U to be a neighbourhood of x to make this work
+    sorry
+  rw [this]
+  -- straightforward computation: use linearity and Leibniz rule
+  sorry
+
+/- TODO: prove some basic properties, such as
+- the Christoffel symbols are linear in cov
+- if (s_i) is a smooth local frame on U, then cov is smooth on U iff each Christoffel symbol is (?)
+- prove a `spec` equality
+- deduce: two covariant derivatives are equal iff their Christoffel symbols are equal
+-/
+
+lemma _root_.IsCovariantDerivativeOn.congr_of_christoffelSymbol_eq [Fintype ι]
+    [FiniteDimensional ℝ E] -- TODO: this is implied by Finite ι, right?
+    (hf : IsCovariantDerivativeOn E f U) (hg : IsCovariantDerivativeOn E g U)
+    (hs : IsLocalFrameOn I E n s U)
+    (hfg : ∀ i j k, ∀ x ∈ U, ChristoffelSymbol I f hs i j k x = ChristoffelSymbol I g hs i j k x) :
+    ∀ X Y : Π x : M, TangentSpace I x, ∀ x ∈ U, f X x (Y x) = g X x (Y x) := by
+  have (i j : ι) : ∀ x ∈ U, f (s i) (s j) x = g (s i) (s j) x := by
+    intro x hx
+    rw [hs.eq_iff_coeff hx]
+    exact fun k ↦ hfg i j k x hx
+  intro X Y x hx
+  -- use linearity (=formula for f in terms of Christoffel symbols) now, another separate lemma!
+  sorry
+
+/-- Two covariant derivatives on `U` are equal on `U` if and only if all of their
+covariant derivatives w.r.t. some local frame on `U` are equal on `U`. -/
+lemma _root_.IsCovariantDerivativeOn.congr_iff_christoffelSymbol_eq [Fintype ι]
+    [FiniteDimensional ℝ E] -- TODO: this is implied by Finite ι, right?
+    (hf : IsCovariantDerivativeOn E f U) (hg : IsCovariantDerivativeOn E g U)
+    (hs : IsLocalFrameOn I E n s U) :
+    (∀ X Y : Π x : M, TangentSpace I x, ∀ x ∈ U, f X x (Y x) = g X x (Y x)) ↔
+    ∀ i j k, ∀ x ∈ U, ChristoffelSymbol I f hs i j k x = ChristoffelSymbol I g hs i j k x :=
+  ⟨fun hfg _i _j _k _x hx ↦ hs.coeff_congr (hfg _ _ _ hx ) ..,
+    fun h X Y x hx ↦ hf.congr_of_christoffelSymbol_eq I hg hs h X Y x hx⟩
+
+-- TODO: global version for convenience, with an alias for the interesting direction!
+
+variable (hs : IsLocalFrameOn I E n s U)
+
+lemma christoffelSymbol_zero (U : Set M) {ι : Type*} {s : ι → (x : M) → TangentSpace I x}
+    (hs : IsLocalFrameOn I E n s U) (i j k : ι) : ChristoffelSymbol I 0 hs i j k = 0 := by
+  simp [ChristoffelSymbol]
+
+@[simp]
+lemma christoffelSymbol_zero_apply (U : Set M) {ι : Type*} {s : ι → (x : M) → TangentSpace I x}
+    (hs : IsLocalFrameOn I E n s U) (i j k : ι) (x) : ChristoffelSymbol I 0 hs i j k x = 0 := by
+  simp [christoffelSymbol_zero]
+
+end
+
+-- Lemma 4.3 in Lee, Chapter 5: first term still missing
+variable {U : Set M} {ι : Type*} [Fintype ι] {s : ι → (x : M) → TangentSpace I x}
+  {f : (Π x : M, TangentSpace I x) → (Π x : M, TangentSpace I x →L[ℝ] TangentSpace I x)}
+
+-- XXX: generalise this to any field
+variable {I} in
+/-- `∇` is torsion-free on `U` if its torsion vanishes at each `x ∈ U` -/
+noncomputable def IsTorsionFreeOn
+    (cov : (Π x : M, TangentSpace I x) → (Π x : M, TangentSpace I x →L[ℝ] TangentSpace I x))
+    (U : Set M) : Prop :=
+  ∀ x ∈ U, ∀ X Y : Π x : M, TangentSpace I x, IsCovariantDerivativeOn.torsionAux cov X Y x = 0
+namespace IsTorsionFreeOn
+section changing_set
+/-! Changing set
+In this changing we change `s` in `IsTorsionFreeOn F f s`.
+-/
+lemma mono {s t : Set M} (hf : IsTorsionFreeOn f t) (hst : s ⊆ t) :
+  IsTorsionFreeOn f s :=
+  fun _ hx _ _ ↦ hf _ (hst hx) ..
+
+lemma iUnion {ι : Type*} {s : ι → Set M} (hf : ∀ i, IsTorsionFreeOn f (s i)) :
+    IsTorsionFreeOn cov (⋃ i, s i) := by
+  rintro x ⟨si, ⟨i, hi⟩, hxsi⟩ X Y
+  sorry -- was: exact hf i x (by simp [hi, hxsi]) X Y
+end changing_set
+end IsTorsionFreeOn
+
+-- errors: omit [IsContMDiffRiemannianBundle I 1 E fun x ↦ TangentSpace I x] in
+/-- Let `{s i}` be a local frame on `U` such that `[s i, s j] = 0` on `U` for all `i, j`.
+A covariant derivative on `U` is torsion-free on `U` iff for each `x ∈ U`,
+the Christoffel symbols `Γᵢⱼᵏ` w.r.t. `{s i}` are symmetric. -/
+lemma isTorsionFreeOn_iff_christoffelSymbols [CompleteSpace E] {ι : Type*} [Fintype ι]
+    [FiniteDimensional ℝ E] -- TODO: this is implied by Finite ι, right?
+    (hf : IsCovariantDerivativeOn E f U)
+    {s : ι → (x : M) → TangentSpace I x} (hs : IsLocalFrameOn I E n s U)
+    (hs'' : ∀ i j, ∀ x : U, VectorField.mlieBracket I (s i) (s j) x = 0) :
+    IsTorsionFreeOn f U ↔
+      ∀ i j k, ∀ x ∈ U, ChristoffelSymbol I f hs i j k x = ChristoffelSymbol I f hs j i k x := by
+  rw [hf.isTorsionFreeOn_iff_localFrame (n := n) hs]
+  have (i j : ι) {x} (hx : x ∈ U) :
+      torsion f (s i) (s j) x = f (s i) x (s j x) - f (s j) x (s i x) := by
+    simp [torsion, hs'' i j ⟨x, hx⟩]
+  peel with i j
+  refine ⟨?_, ?_⟩
+  · intro h k x hx
+    simp only [ChristoffelSymbol]
+    apply hs.coeff_congr
+    specialize h x hx
+    rw [this i j hx, sub_eq_zero] at h
+    exact h
+  · intro h x hx
+    rw [this i j hx, sub_eq_zero, hs.eq_iff_coeff hx]
+    exact fun k ↦ h k x hx
+
+-- Exercise 4.2(b) in Lee, Chapter 4
+/-- A covariant derivative on `U` is torsion-free on `U` iff for each `x ∈ U` and
+any local coordinate frame, the Christoffel symbols `Γᵢⱼᵏ` are symmetric.
+
+TODO: figure out the right quantifiers here!
+right now, I just have one fixed coordinate frame... will this do??
+-/
+lemma isTorsionFree_iff_christoffelSymbols' [FiniteDimensional ℝ E] [IsManifold I ∞ M]
+    (hf : IsCovariantDerivativeOn E f U) :
+    IsTorsionFreeOn f U ↔
+      ∀ x ∈ U,
+      -- Let `{s_i}` be the coordinate frame at `x`: this statement is false for arbitrary frames.
+      -- TODO: does the following do what I want??
+      letI cs := ChristoffelSymbol I f
+          (trivializationAt E _ x).isLocalFrameOn_localFrame_baseSet I 1 ((Basis.ofVectorSpace ℝ E))
+      ∀ i j k, cs i j k x = cs j i k x := by
+  letI t := (trivializationAt E (fun (x : M) ↦ TangentSpace I x))
+  have hs (x) :=
+    ((Basis.ofVectorSpace ℝ E).localFrame_isLocalFrameOn_baseSet I 1 (t x))
+
+  -- TODO: check that the Lie bracket of any two coordinate vector fields is zero!
+  rw [isTorsionFreeOn_iff_christoffelSymbols (ι := (↑(Basis.ofVectorSpaceIndex ℝ E))) I hf]
+  -- issues with quantifier order in the statement... prove both directions separately, at each x?
+  repeat sorry
+
+theorem LeviCivitaConnection.christoffelSymbol_symm [FiniteDimensional ℝ E] (x : M) :
+    letI t := trivializationAt E (TangentSpace I) x;
+    letI hs := t.isLocalFrameOn_localFrame_baseSet I 1 (Basis.ofVectorSpace ℝ E)
+    ∀ x', x' ∈ t.baseSet → ∀ (i j k : ↑(Basis.ofVectorSpaceIndex ℝ E)),
+      ChristoffelSymbol I (LeviCivitaConnection I M) hs i j k x' =
+        ChristoffelSymbol I (LeviCivitaConnection I M) hs j i k x' := by
+  by_cases hE : Subsingleton E
+  · have (y : M) (X : TangentSpace I y) : X = 0 := by
+      have : Subsingleton (TangentSpace I y) := inferInstanceAs (Subsingleton E)
+      apply Subsingleton.eq_zero X
+    have (X : Π y : M, TangentSpace I y) : X = 0 := sorry
+    intro x'' hx'' i j k
+    simp only [LeviCivitaConnection, LeviCivitaConnection_aux]
+    unfold lcCandidate
+    simp only [lcAux, hE, ↓reduceDIte]
+
+    letI t := trivializationAt E (TangentSpace I) x;
+    letI hs := (Basis.ofVectorSpace ℝ E).localFrame_isLocalFrameOn_baseSet I 1 t
+    have : ChristoffelSymbol I 0 hs i j k = 0 := christoffelSymbol_zero I t.baseSet hs i j k
+    -- now, use a congruence result and the first `have`
+    sorry
+  -- Note that hs is not necessarily an orthonormal frame, so we cannot simply rewrite
+  -- the Christoffel symbols as Γᵢⱼᵏ = ⟪∇ᵍ X Y, Z⟫`: however, the result we wants to prove boils
+  -- down to proving the same.
+  intro x' hx' i j
+  set t := trivializationAt E (TangentSpace I) x
+  set b := (Basis.ofVectorSpace ℝ E)
+  set s := t.localFrame b
+  set ι := ↑(Basis.ofVectorSpaceIndex ℝ E)
+  -- Same computation as above; extract as lemma!
+  let O : (x : M) → TangentSpace I x := fun x ↦ 0
+  have need : ∀ i j, VectorField.mlieBracket I (s i) (s j) x' = O x' := sorry
+  have aux : ∀ k, ⟪LeviCivitaConnection I M (s i) (s j), (s k)⟫ x'
+      = ⟪LeviCivitaConnection I M (s j) (s i), (s k)⟫ x' := by
+    intro k
+    simp only [LeviCivitaConnection, LeviCivitaConnection_aux]
+    unfold lcCandidate
+    rw [product_apply, product_apply]
+    simp only [lcAux, hE, ↓reduceDIte]
+    -- Choose a linear order on ι: which one really does not matter for our result.
+    have : LinearOrder ι := by
+      choose r wo using exists_wellOrder _
+      exact r
+    have : Nontrivial E := not_subsingleton_iff_nontrivial.mp hE
+    have : Nonempty ι := b.index_nonempty
+    -- The linear ordering on the indexing set of `b` is only used in this proof,
+    -- so our choice does not matter.
+    have : LinearOrder ι := by
+      choose r wo using exists_wellOrder _
+      exact r
+    have : Fintype ι := sorry
+    -- why does this fail? are there two different orders in play?
+    have : LocallyFiniteOrderBot ι := sorry
+    have : ∑ k', inner ℝ
+      (leviCivitaRhs I (s i) (s j)
+          (b.orthonormalFrame (trivializationAt E (TangentSpace I) x') k') x' •
+          b.orthonormalFrame (trivializationAt E (TangentSpace I) x') k' x')
+      (s k x') =
+       ∑ k', inner ℝ
+        (leviCivitaRhs I (s j) (s i)
+          (b.orthonormalFrame (trivializationAt E (TangentSpace I) x') k') x' •
+          b.orthonormalFrame (trivializationAt E (TangentSpace I) x') k' x')
+        (s k x') := by
+      congr with k'
+      simp only [leviCivitaRhs]
+      set sij := b.orthonormalFrame (trivializationAt E (TangentSpace I) x') k' x'
+      rw [inner_smul_left, inner_smul_left]
+      congr
+      simp [leviCivitaRhs']
+      set S := b.orthonormalFrame (trivializationAt E (TangentSpace I) x') k'
+      have need' : ∀ i, VectorField.mlieBracket I (s i) S x' = O x' := by
+        -- expand the definition of Gram-Schmidt and use need and linearity
+        sorry
+      have need'' : ∀ i, VectorField.mlieBracket I S (s i) x' = O x' := by
+        sorry -- swap and use need', or so
+      rw [product_congr_right I (need i j), product_congr_right I (need j i),
+        product_congr_right I (need' i), product_congr_right I (need'' i),
+        product_congr_right I (need' j), product_congr_right I (need'' j),
+        rhs_aux_swap I (s i) (s j), rhs_aux_swap I (s j) S, rhs_aux_swap I S (s i)]
+      simp [O]
+      abel
+    -- now, just rewrite `inner` to take out a sum: same lemma twice
+    convert this
+    · sorry
+    · sorry
+
+  -- deduce the goal from `aux`
+  sorry
+
+end CovariantDerivative
diff --git a/Mathlib/Geometry/Manifold/VectorBundle/CovariantDerivative/Curvature.lean b/Mathlib/Geometry/Manifold/VectorBundle/CovariantDerivative/Curvature.lean
new file mode 100644
index 00000000000000..ed040d3b593566
--- /dev/null
+++ b/Mathlib/Geometry/Manifold/VectorBundle/CovariantDerivative/Curvature.lean
@@ -0,0 +1,279 @@
+/-
+Copyright (c) 2025 Patrick Massot. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Patrick Massot, Michael Rothgang, Heather Macbeth
+-/
+module
+
+public import Mathlib.Geometry.Manifold.VectorBundle.CovariantDerivative.Basic
+public import Mathlib.Geometry.Manifold.VectorField.LieBracket
+public import Mathlib.LinearAlgebra.Trace
+
+/-! # Curvature of an affine connection
+
+We define the curvature tensor of an affine connection, i.e. a covariant derivative on the tangent
+bundle `TM` of some manifold `M`.
+
+## Main definitions and results
+
+TODO!
+
+-/
+
+@[expose] public section
+
+open Bundle Set NormedSpace
+open scoped Manifold ContDiff
+
+variable {𝕜 : Type*} [NontriviallyNormedField 𝕜]
+  {E : Type*} [NormedAddCommGroup E] [NormedSpace 𝕜 E]
+  {H : Type*} [TopologicalSpace H] {I : ModelWithCorners 𝕜 E H}
+  {M : Type*} [TopologicalSpace M] [ChartedSpace H M] {x : M}
+
+/-! A preliminary lemma about -/
+section prelim
+
+variable (F : Type*) [NormedAddCommGroup F] [NormedSpace 𝕜 F]
+  {V : M → Type*} [TopologicalSpace (TotalSpace F V)]
+  [∀ x, AddCommGroup (V x)] [∀ x, Module 𝕜 (V x)]
+  [∀ x : M, TopologicalSpace (V x)]
+  [∀ x, IsTopologicalAddGroup (V x)] [∀ x, ContinuousSMul 𝕜 (V x)]
+  [FiberBundle F V]
+
+-- FIXME: does this require real bundles?
+lemma exists_contMDiff_of_one_form {k : WithTop ℕ∞}
+    {σ : Π x : M, V x} (hσ : CMDiffAt k (T% σ) x) :
+    ∃ σ' : (Π x : M, V x),
+      CMDiff k (T% σ') ∧ σ' x = σ x ∧ mfderiv% (T% σ') x = mfderiv% (T% σ) x := by
+  /- proof idea: assuming smooth bump functions, this becomes a local question
+  locally, convolve σ with a bump function of small support; should preserve σ x and mfderiv
+  does mathlib have this already? (Moritz Doll proved something similar, I think!)
+  -/
+  sorry
+
+-- We need one level more of agreement!
+
+-- TODO: might be a better definition of smoothness; proving the equivalence requires more work!
+variable {F} in
+lemma ContMDiffCovariantDerivativeOn.contMDiff' [IsManifold I 1 M] [VectorBundle 𝕜 F V]
+    {k : WithTop ℕ∞} {cov : (Π x : M, V x) → (Π x : M, TangentSpace I x →L[𝕜] V x)}
+    (hcov : IsCovariantDerivativeOn F cov) [hcov' : ContMDiffCovariantDerivativeOn F k cov univ]
+    {σ : Π x : M, V x} (hσ :CMDiffAt (k + 1) (T% σ) x) :
+    letI cov (x : M) : TotalSpace (E →L[𝕜] F) fun x ↦ TangentSpace I x →L[𝕜] V x := ⟨x, cov σ x⟩
+    ContMDiffAt I (I.prod 𝓘(𝕜, E →L[𝕜] F)) k cov x := by
+  obtain ⟨σ', hσ', heqs, hdiffx⟩ := exists_contMDiff_of_one_form F hσ
+  have aux := contMDiffOn_univ.mp (hcov'.contMDiff hσ'.contMDiffOn)
+  -- know: ∇ σ and ∇ σ' agree at x
+  have aux' := hcov.congr_of_eq_one_jet (Filter.univ_mem)
+    (hσ.mdifferentiableAt (by simp)) (hσ'.mdifferentiableAt (by simp))
+    heqs.symm hdiffx.symm -- TODO: choose direction for both equalities!
+  -- we need one more level, though!
+  sorry
+
+end prelim
+
+/-! ## The Riemannian curvature tensor of an unbundled covariant derivative on `TM` on a set `s`
+
+TODO: generalise this discussion to any vector bundle E
+-/
+namespace IsCovariantDerivativeOn
+
+variable (cov : (Π x : M, TangentSpace I x) → (Π x : M, TangentSpace I x →L[𝕜] TangentSpace I x))
+
+variable {X X' Y : (Π x : M, TangentSpace I x)}
+
+/-- Local notation for a covariant derivative on a vector bundle acting on a vector field and a
+section. -/
+local syntax "∇" term:arg term : term
+local macro_rules | `(∇ $X $σ) => `(fun (x : M) ↦ cov $σ x ($X x))
+
+example {x} : (∇ X Y) x = cov Y x (X x) := by rfl
+
+/-- The Riemannian curvature endomorphism of a covariant derivative on the tangent bundle `TM`,
+as a bare function. Prefer to use `IsCovariantDerivativeOn.curvatureTensor`
+(which is a (3,1)-tensor) instead. -/
+noncomputable def curvatureTensorAux :
+    (Π x : M, TangentSpace I x) → (Π x : M, TangentSpace I x) →
+      (Π x : M, TangentSpace I x) → (Π x : M, TangentSpace I x) :=
+  fun X Y Z ↦ (∇ X (∇ Y Z)) - ∇ Y (∇ X Z) - ∇ (VectorField.mlieBracket I X Y) Z
+
+variable [IsManifold I 2 M] [CompleteSpace E]
+  {cov cov' : (Π x : M, TangentSpace I x) → (Π x : M, TangentSpace I x →L[𝕜] TangentSpace I x)}
+  {X X' Y Z : Π x : M, TangentSpace I x}
+
+-- TODO: generalise further and try to find in the library!
+lemma temp
+    {cov : ((x : M) → TangentSpace I x) → (x : M) → TangentSpace I x →L[𝕜] TangentSpace I x}
+    (hcov : IsCovariantDerivativeOn E cov)
+    {x : M} {X σ : (x : M) → TangentSpace I x}
+    (hσ : CMDiff 2 T% σ) (hZ : CMDiff 2 T% X)
+    (aux : ContMDiffAt I (I.prod 𝓘(𝕜, E →L[𝕜] E)) 1
+      (fun x ↦ TotalSpace.mk' (E →L[𝕜] E) x (cov X x)) x) :
+    ContMDiffAt I (I.prod 𝓘(𝕜, E)) 1 (fun x ↦ TotalSpace.mk' E x ((cov X x) (σ x))) x := by
+  sorry
+
+lemma temp' -- I suspect this one will also work!
+    {cov : ((x : M) → TangentSpace I x) → (x : M) → TangentSpace I x →L[𝕜] TangentSpace I x}
+    (hcov : IsCovariantDerivativeOn E cov)
+    {x : M} {X σ : (x : M) → TangentSpace I x}
+    -- XXX: I suspect σ being C¹ will suffice, and no extra hypotheses on X are necessary
+    (hσ : CMDiffAt 1 (T% σ) x)
+    (aux : ContMDiffAt I (I.prod 𝓘(𝕜, E →L[𝕜] E)) 1
+      (fun x ↦ TotalSpace.mk' (E →L[𝕜] E) x (cov X x)) x) :
+    ContMDiffAt I (I.prod 𝓘(𝕜, E)) 1 (fun x ↦ TotalSpace.mk' E x ((cov X x) (σ x))) x := by
+  sorry
+
+/- Lessons learned from the experiment below:
+- we need the lemma temp (or perhaps just temp'); is this in mathlib already?
+- the curvature tensor needs a C¹ connection, and a manifold of order 3 and minSmoothness k 2 or so
+- we can only prove tensoriality for C² sections (at a point, I hope! to be confirmed),
+  so need new tensoriality lemmas
+- `mdifferentiableAt` lemmas for C^k covariant derivatives would be nice API addition
+-/
+
+variable [IsManifold I (2 + 1) M] [IsManifold I (minSmoothness 𝕜 2) M]
+
+lemma aux
+    (hcov : IsCovariantDerivativeOn E cov) [hcov' : ContMDiffCovariantDerivativeOn E 1 cov univ]
+    {x : M} {Y Z σ : (x : M) → TangentSpace I x}
+    (hσ : CMDiffAt 2 (T% σ) x) (hY : CMDiffAt 2 (T% Y) x) (hZ : CMDiffAt 2 (T% Z) x) :
+    (MDiffAt fun x ↦ TotalSpace.mk' E x ((cov Z x) (VectorField.mlieBracket I σ Y x))) x := by
+  apply ContMDiffAt.mdifferentiableAt _ one_ne_zero
+  apply temp' hcov ?_ (hcov'.contMDiff' hcov hZ)
+  apply ContMDiffAt.mlieBracket_vectorField hσ hY _
+  simp; sorry -- want sth with minSmoothness instead; otherwise too weak for general 𝕜
+
+theorem curvatureTensorAux_tensorial₁ (hcov : IsCovariantDerivativeOn E cov) (x : M)
+    [hcov' : ContMDiffCovariantDerivativeOn E 1 cov univ]
+    (Y Z : (Π x : M, TangentSpace I x)) :
+    TensorialAt I E (curvatureTensorAux cov · Y Z x) x where
+  smul {f X} hf hX := by
+    unfold curvatureTensorAux
+    dsimp
+    sorry
+  add {σ σ'} hσ hσ' := by
+    unfold curvatureTensorAux
+    simp only [Pi.add_apply, map_add, Pi.sub_apply]
+    --rw [VectorField.mlieBracket_add_left hσ hσ']
+    have : VectorField.mlieBracket I (σ + σ') Y x =
+        VectorField.mlieBracket I σ Y x + VectorField.mlieBracket I σ' Y x := by
+      rw [VectorField.mlieBracket_add_left hσ hσ']
+    set A := cov (fun x ↦ (cov Z x) (Y x)) x (σ x)
+    set B := cov (fun x ↦ (cov Z x) (Y x)) x (σ' x)
+    --erw [ContinuousLinearMap.add_apply]
+    -- TODO: need stronger assumptions on σ, σ' and Z!
+    have hσ : CMDiff 2 (T% σ) := sorry
+    have hσ' : CMDiff 2 (T% σ') := sorry
+    have hY : CMDiffAt 2 (T% Y) x := sorry
+    have hZ : CMDiff 2 (T% Z) := sorry
+    have hZ' : CMDiffAt 2 (T% Z) x := sorry
+    -- corollaries, which occur as side goals several times
+    have hZσ : MDiffAt (fun x ↦ TotalSpace.mk' E x (cov Z x (σ x))) x := by
+      apply ContMDiffAt.mdifferentiableAt _ one_ne_zero
+      exact temp hcov hσ hZ (hcov'.contMDiff' hcov hZ')
+    have hZσ' : MDiffAt (fun x ↦ TotalSpace.mk' E x (cov Z x (σ' x))) x := by
+      apply ContMDiffAt.mdifferentiableAt _ one_ne_zero
+      exact temp hcov hσ' hZ (hcov'.contMDiff' hcov hZ')
+    have missing :
+      (cov (fun x ↦ (cov Z x) (VectorField.mlieBracket I (σ + σ') Y x)) x) (Y x) =
+        (cov (fun x ↦ (cov Z x) (VectorField.mlieBracket I σ Y x)) x) (Y x)
+        + (cov (fun x ↦ (cov Z x) (VectorField.mlieBracket I σ' Y x)) x) (Y x) := by
+      trans (cov (fun x ↦ (
+          cov Z x (VectorField.mlieBracket I σ Y x)) + cov Z x (VectorField.mlieBracket I σ' Y x)
+          ) x) (Y x)
+      · congr 1
+        sorry -- missing tensoriality lemma; first arguments are equal at x
+      · erw [hcov.add (aux hcov (hσ x) hY hZ') (aux hcov (hσ' x) hY hZ')]
+        simp
+    rw [hcov.sub]
+    rotate_left
+    · exact mdifferentiableAt_add_section hZσ hZσ'
+    · apply ContMDiffAt.mdifferentiableAt _ one_ne_zero
+      apply temp' hcov ?_ (hcov'.contMDiff' hcov hZ')
+      apply ContMDiffAt.mlieBracket_vectorField (ContMDiff.add_section hσ hσ' ..) hY
+      simp; sorry -- want sth with minSmoothness instead; otherwise too weak for general k
+    rw [hcov.sub hZσ (aux hcov (hσ x) hY hZ')]
+    dsimp
+    erw [hcov.add hZσ hZσ']
+    simp only [ContinuousLinearMap.add_apply]
+    --set C := cov (fun x ↦ (cov Z x) (σ x)) x
+    --set D := cov (fun x ↦ (cov Z x) (σ' x)) x
+    rw [hcov.sub hZσ' ((aux hcov (hσ' x) hY hZ'))]
+    rw [missing]
+    --set E := (cov (fun x ↦ (cov Z x) (VectorField.mlieBracket I σ Y x)) x) (Y x)
+    dsimp
+    --set F := (cov (fun x ↦ (cov Z x) (VectorField.mlieBracket I σ' Y x)) x) (Y x)
+    abel
+
+-- update hypotheses to match lemma above, once proven!
+theorem curvatureTensorAux_tensorial₂ (hcov : IsCovariantDerivativeOn E cov) (x : M)
+    [hcov' : ContMDiffCovariantDerivativeOn E 1 cov univ]
+    (X Z : (Π x : M, TangentSpace I x)) :
+    TensorialAt I E (curvatureTensorAux cov X · Z x) x :=
+  -- proof is analogous to the version in X
+  sorry
+
+-- update hypotheses to match lemma above, once proven!
+theorem curvatureTensorAux_tensorial₃ (hcov : IsCovariantDerivativeOn E cov) (x : M)
+    [hcov' : ContMDiffCovariantDerivativeOn E 1 cov univ]
+    (X Y : (Π x : M, TangentSpace I x)) :
+    TensorialAt I E (curvatureTensorAux cov X Y · x) x :=
+  -- linearity should be "easy" also, scalar multiplication is a different proof
+  sorry
+
+noncomputable section
+
+/-- The Riemannian curvature endomorphism `R`, as a (3,1)-tensor field: for vector fields `X`, `Y`
+and `Z`, it is defined as `R(X, Y)Z = ∇_X (∇_Y Z) - ∇_Y (∇_X Z) - ∇_[X,Y] Z`. -/
+-- This definition follows Lee's sign conventions.
+-- TODO: decide if we want this one, and add a comment accordingly!
+def curvatureEndomorphismTensor (hcov : IsCovariantDerivativeOn E cov) (x : M)
+    [ContMDiffCovariantDerivativeOn E 1 cov univ] :
+    TangentSpace I x →L[𝕜] TangentSpace I x →L[𝕜] TangentSpace I x →L[𝕜] TangentSpace I x :=
+  TensorialAt.mkHom₃ (curvatureTensorAux cov · · · x) x
+    (fun σ τ _ ↦ hcov.curvatureTensorAux_tensorial₁ x σ τ)
+    (fun σ τ _ ↦ hcov.curvatureTensorAux_tensorial₂ x σ τ)
+    (fun σ τ _ ↦ hcov.curvatureTensorAux_tensorial₃ x σ τ)
+
+variable [ContMDiffCovariantDerivativeOn E 1 cov univ]
+
+-- lemmas: curvatureEndomorphismTensor_apply and curvatureEndomorphismTensor_apply_extend
+
+variable (X) in
+@[simp]
+lemma curvatureEndomorphismTensor_self (hcov : IsCovariantDerivativeOn E cov)
+    (X₀ : TangentSpace I x) :
+    hcov.curvatureEndomorphismTensor x X₀ X₀ = 0 := by
+  sorry
+
+variable (X Y) in
+lemma curvatureEndomorphismTensor_swap (hcov : IsCovariantDerivativeOn E cov)
+    (X₀ Y₀ : TangentSpace I x) :
+    hcov.curvatureEndomorphismTensor x X₀ Y₀ = - hcov.curvatureEndomorphismTensor x Y₀ X₀ := by
+  sorry
+
+-- lemma: if cov is the Levi-Civita connection, we have <V, R(X, Y)Z> + <R(X, Y)V, Z> = 0
+-- for all vector fields V, X, Y and Z.
+
+-- The Ricci curvature is the trace of this linear map
+def ricciCurvatureAux (hcov : IsCovariantDerivativeOn E cov) (x : M) (Y Z : TangentSpace I x) :
+    TangentSpace I x →L[𝕜] TangentSpace I x where
+  toFun := fun X₀ ↦ curvatureEndomorphismTensor hcov x X₀ Y Z
+  map_add' X₀ X₁ := by simp
+  map_smul' a X₀ := by simp
+
+def RicciCurvatureFun (hcov : IsCovariantDerivativeOn E cov) (x : M) :
+    TangentSpace I x → TangentSpace I x → 𝕜 :=
+  fun Y Z ↦ LinearMap.trace 𝕜 _ (ricciCurvatureAux hcov x Y Z).toLinearMap
+
+def RicciCurvature (hcov : IsCovariantDerivativeOn E cov) (x : M) :
+    TangentSpace I x →L[𝕜] TangentSpace I x → 𝕜 :=
+  sorry -- apply tensoriality criterion, again
+
+-- most conceptual proof: define the contraction of a tensor and show it is still a tensor
+
+-- scalar curvature left to the reader
+
+end
+
+end IsCovariantDerivativeOn
diff --git a/Mathlib/Geometry/Manifold/VectorBundle/CovariantDerivative/Ehresmann.lean b/Mathlib/Geometry/Manifold/VectorBundle/CovariantDerivative/Ehresmann.lean
new file mode 100644
index 00000000000000..2a29fff87c7ffe
--- /dev/null
+++ b/Mathlib/Geometry/Manifold/VectorBundle/CovariantDerivative/Ehresmann.lean
@@ -0,0 +1,403 @@
+/-
+Copyright (c) 2025 Patrick Massot. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Patrick Massot, Michael Rothgang
+-/
+module
+
+public import Mathlib.Geometry.Manifold.VectorBundle.CovariantDerivative.Prelim
+public import Mathlib.Geometry.Manifold.VectorBundle.Tensoriality
+public import Mathlib.Geometry.Manifold.VectorField.LieBracket
+public import Mathlib.Geometry.Manifold.IsManifold.InteriorBoundary
+public import Mathlib.Geometry.Manifold.VectorBundle.CovariantDerivative.Trivial
+
+/-!
+# Covariant derivatives
+
+TODO: add a more complete doc-string
+
+-/
+
+open Bundle Filter Module Topology Set
+open scoped Bundle Manifold ContDiff
+
+lemma Bundle.Trivialization.continuousLinearMapAt_apply_of_mem (R : Type*) {B : Type*} {F : Type*}
+    {E : B → Type*} [NontriviallyNormedField R] [(x : B) → AddCommMonoid (E x)]
+    [(x : B) → Module R (E x)]
+    [NormedAddCommGroup F] [NormedSpace R F]
+    [TopologicalSpace B] [TopologicalSpace (TotalSpace F E)]
+    [(x : B) → TopologicalSpace (E x)] [FiberBundle F E] (e : Trivialization F TotalSpace.proj)
+    [Trivialization.IsLinear R e] {b : B} (hb : b ∈ e.baseSet) (y : E b) :
+    (continuousLinearMapAt R e b) y = (e ⟨b, y⟩).2 := by
+  simp [coe_linearMapAt_of_mem e hb]
+
+attribute [simp] Bundle.Trivialization.coe_linearMapAt_of_mem
+
+variable {𝕜 : Type*} [NontriviallyNormedField 𝕜]
+
+@[expose] public section -- TODO: think if we want to expose all definitions!
+
+variable {E : Type*} [NormedAddCommGroup E]
+  [NormedSpace 𝕜 E]
+  {H : Type*} [TopologicalSpace H] {I : ModelWithCorners 𝕜 E H}
+  {M : Type*} [TopologicalSpace M] [ChartedSpace H M] {x : M}
+
+variable {F : Type*} [NormedAddCommGroup F] [NormedSpace 𝕜 F]
+  -- `F` model fiber
+  (n : WithTop ℕ∞)
+  {V : M → Type*} [TopologicalSpace (TotalSpace F V)]
+  [∀ x, AddCommGroup (V x)] [∀ x, Module 𝕜 (V x)]
+  [∀ x : M, TopologicalSpace (V x)] [FiberBundle F V]
+  -- `V` vector bundle
+
+--- TODO FROM HERE!
+
+namespace IsCovariantDerivativeOn
+
+section projection_trivial_bundle
+
+variable [CompleteSpace 𝕜] [FiniteDimensional 𝕜 F]
+    [IsManifold I 1 M]
+
+local notation "TM" => TangentSpace I
+
+variable {cov : (M → F) → (Π x : M, TangentSpace I x →L[𝕜] F)} {s : Set M}
+
+noncomputable
+def projection (hcov : IsCovariantDerivativeOn F cov s) (x : M) (f : F) : (TM x) × F →L[𝕜] F :=
+  .snd 𝕜 (TM x) F + (hcov.one_form x f ∘L .fst 𝕜 (TM x) F)
+
+@[simp]
+lemma projection_apply (hcov : IsCovariantDerivativeOn F cov s) (x : M) (f : F) (v : TM x) (w : F) :
+  hcov.projection x f (v, w) = w + hcov.one_form x f v := rfl
+
+lemma cov_eq_proj (hcov : IsCovariantDerivativeOn F cov s) (σ : M → F)
+    {x : M} (X₀ : TM x) (hσ : MDiffAt (T% σ) x) (hx : x ∈ s := by trivial) :
+    cov σ x X₀ = hcov.projection x (σ x) (X₀, mfderiv I 𝓘(𝕜, F) σ x X₀) := by
+  simpa using congr($(hcov.eq_one_form hσ) X₀)
+
+noncomputable def horiz (hcov : IsCovariantDerivativeOn F cov s) (x : M) (f : F) :
+    Submodule 𝕜 (TM x × F) :=
+  (hcov.projection x f).ker
+
+lemma horiz_vert_direct_sum (hcov : IsCovariantDerivativeOn F cov s) (x : M) (f : F) :
+    IsCompl (hcov.horiz x f) (.prod ⊥ ⊤) := by
+  refine IsCompl.of_eq ?_ ?_
+  · refine (Submodule.eq_bot_iff _).mpr ?_
+    rintro ⟨u, w⟩ ⟨huw, hu, hw⟩
+    simp_all [horiz]
+  · apply Submodule.sup_eq_top_iff _ _ |>.2
+    intro u
+    use u - (0, hcov.projection x f u), ?_, (0, hcov.projection x f u), ?_, ?_
+    all_goals simp [horiz]
+
+set_option backward.isDefEq.respectTransparency false in
+lemma mem_horiz_iff_exists [FiniteDimensional 𝕜 E] (hcov : IsCovariantDerivativeOn F cov s) {x : M}
+    {f : F} {u : TM x} {v : F} (hx : x ∈ s := by trivial) : (u, v) ∈ hcov.horiz x f ↔
+    ∃ s : M → F, MDiffAt s x ∧
+                 s x = f ∧
+                 mfderiv I 𝓘(𝕜, F) s x u = v ∧
+                 cov s x u = 0 := by
+  constructor
+  · intro huv
+    simp only [horiz, LinearMap.mem_ker, ContinuousLinearMap.coe_coe, projection_apply] at huv
+    let w : TangentSpace 𝓘(𝕜, F) f := v
+    by_cases hu : u = 0
+    · subst hu
+      replace huv : v = 0 := by simpa using huv
+      subst huv
+      use fun x ↦ f
+      simp [mdifferentiableAt_const]
+    rcases map_of_one_jet_spec u w (by tauto) with ⟨h, h', h''⟩
+    use map_of_one_jet u w, h', h, h''
+    · rw [hcov.eq_one_form]
+      · simp only [w, h]
+        convert huv
+        convert ContinuousLinearMap.add_apply (M₁ := TangentSpace I x) (M₂ := F) _
+          (hcov.one_form x f) u
+        exact h''.symm
+      · rwa [mdifferentiableAt_section]
+  · rintro ⟨s, s_diff, rfl, rfl, covs⟩
+    simp only [horiz, LinearMap.mem_ker, ContinuousLinearMap.coe_coe, projection_apply, ← covs]
+    rw [hcov.eq_one_form (mdifferentiableAt_section_trivial_iff.mpr s_diff)]
+    rfl
+
+end projection_trivial_bundle
+
+end IsCovariantDerivativeOn
+
+namespace Bundle.Trivialization
+
+section to_trivialization
+
+variable (e : Trivialization F (π F V)) [VectorBundle 𝕜 F V] [MemTrivializationAtlas e]
+  [IsManifold I 1 M]
+
+noncomputable
+def pushCovDer
+    (cov : (Π x : M, V x) → (Π x : M, TangentSpace I x →L[𝕜] V x)) :
+    (M → F) → (Π x : M, TangentSpace I x →L[𝕜] F) :=
+  fun σ x ↦ e.continuousLinearMapAt 𝕜 x ∘L (cov (e.funToSec σ) x)
+
+
+-- FIXME Decide whether we want to add enough assumption to use the commented out statement
+omit [IsManifold I 1 M] in
+lemma pushCovDer_secToFun -- [CompleteSpace 𝕜]
+    [FiniteDimensional 𝕜 F] [IsManifold I 1 M]
+    [∀ x, IsTopologicalAddGroup (V x)] [∀ x, ContinuousSMul 𝕜 (V x)]
+    [ContMDiffVectorBundle 1 F V I]
+    {cov : (Π x : M, V x) → (Π x : M, TangentSpace I x →L[𝕜] V x)}
+    (hcov : IsCovariantDerivativeOn F cov e.baseSet)
+    {u : TangentSpace I x} {σ : Π x : M, V x} {x : M}
+    (hσ : MDiffAt T%σ x)
+    (hx : x ∈ e.baseSet := by assumption) :
+--  e.pushCovDer cov (e.secToFun σ) x = (e.linearEquivAt 𝕜 x hx).toContinuousLinearMap ∘L (cov σ x)
+    e.pushCovDer cov (e.secToFun σ) x u = (e (cov σ x u)).2 := by
+  have : cov (e.funToSec (e.secToFun σ)) x = cov σ x := by
+    apply hcov.congr_of_eqOn _ hσ (e.baseSet_mem_nhds hx)
+    · simp +contextual
+    · rw [(e.total_funToSec_secToFun_eventuallyEq hx σ).mdifferentiableAt_iff]
+      exact hσ
+  unfold pushCovDer
+  simp [this, hx]
+
+omit [IsManifold I 1 M] in
+lemma pushCovDer_funToSec [FiniteDimensional 𝕜 F]
+    [IsManifold I 1 M]
+    [∀ x, IsTopologicalAddGroup (V x)] [∀ x, ContinuousSMul 𝕜 (V x)]
+    [ContMDiffVectorBundle 1 F V I]
+    (cov : (Π x : M, V x) → (Π x : M, TangentSpace I x →L[𝕜] V x))
+    {x : M} {s : M → F}
+    (hx : x ∈ e.baseSet := by assumption) :
+    cov (e.funToSec s) x = e.symmL 𝕜 x ∘L (e.pushCovDer cov s x) := by
+  ext u
+  simp [pushCovDer, hx]
+
+variable {cov : (Π x : M, V x) → (Π x : M, TangentSpace I x →L[𝕜] V x)}
+    -- {s : Set M} (hcov : IsCovariantDerivativeOn F cov s)
+
+omit [IsManifold I 1 M] in
+lemma pushCovDer_isCovariantDerivativeOn
+    [∀ x, IsTopologicalAddGroup (V x)] [∀ x, ContinuousSMul 𝕜 (V x)]
+    [ContMDiffVectorBundle 1 F V I]
+    {u : Set M} (hu : u ⊆ e.baseSet)
+    (hcov : IsCovariantDerivativeOn F cov u) :
+    IsCovariantDerivativeOn F (e.pushCovDer cov) u where
+  add {σ σ' x} hσ hσ' hx := by
+    have hs := mdifferentiableAt_funToSec' e (hu hx) hσ
+    have hs' := mdifferentiableAt_funToSec' e (hu hx) hσ'
+    unfold Trivialization.pushCovDer
+    rw [← ContinuousLinearMap.comp_add, ← hcov.add hs hs' hx, e.funToSec_map_add 𝕜]
+  leibniz {σ g x} hσ hg hx := by
+    have hs := mdifferentiableAt_funToSec' e (hu hx) hσ
+    ext u
+    unfold Trivialization.pushCovDer
+    rw [e.funToSec_map_smul g]
+    rw [hcov.leibniz hs hg hx]
+    simp [e.linearMapAt_funToSec (hu hx)]
+
+-- This is PAIIIIINNNN and currently unused
+variable {e} in
+lemma coordChangeL_coordChangeL
+    {e' : Trivialization F (π F V)} [MemTrivializationAtlas e']
+    {x : M} (hx : x ∈ e.baseSet ∩ e'.baseSet) (v : F) :
+    e'.coordChangeL 𝕜 e x (e.coordChangeL 𝕜 e' x v) = v := by
+  have hx' := inter_comm _ _ ▸ hx
+  change ((coordChangeL 𝕜 e' e x) ∘ (coordChangeL 𝕜 e e' x)) v = v
+  rw [coe_coordChangeL _ _ hx]
+  rw [coe_coordChangeL _ _ hx']
+  change
+    ((linearEquivAt 𝕜 e x hx'.2 ∘ (linearEquivAt 𝕜 e' x hx'.1).symm)  ∘
+    (linearEquivAt 𝕜 e' x hx'.1 ∘ (linearEquivAt 𝕜 e x hx'.2).symm))
+     v = v
+  rw [Function.comp_assoc]
+  conv =>
+    congr
+    congr
+    rfl
+    rw [← Function.comp_assoc]
+  change
+    ((linearEquivAt 𝕜 e x _) ∘
+    (↑(linearEquivAt 𝕜 e' x hx'.1).symm ∘ₗ (linearEquivAt 𝕜 e' x hx'.1).toLinearMap) ∘ _)
+    v = v
+  rw [(linearEquivAt 𝕜 e' x hx'.1).symm_comp]
+  simp only [LinearMap.id_coe, CompTriple.comp_eq]
+  change (↑(linearEquivAt 𝕜 e x hx'.2) ∘ₗ (linearEquivAt 𝕜 e x _).symm.toLinearMap) v = v
+  rw [(linearEquivAt 𝕜 e x hx'.2).comp_symm]
+  simp
+
+
+end to_trivialization
+
+end Bundle.Trivialization
+
+section horiz
+namespace CovariantDerivative
+
+variable [CompleteSpace 𝕜] [FiniteDimensional 𝕜 F]
+    [IsManifold I 1 M]
+    [∀ x, IsTopologicalAddGroup (V x)] [∀ x, ContinuousSMul 𝕜 (V x)]
+    [VectorBundle 𝕜 F V] [ContMDiffVectorBundle 1 F V I]
+
+local notation "TM" => TangentSpace I
+
+noncomputable
+def proj (cov : CovariantDerivative I F V) (v : TotalSpace F V) :
+    TangentSpace (I.prod 𝓘(𝕜, F)) v →L[𝕜] V v.proj :=
+  letI t := trivializationAt F V v.proj
+  haveI d_covDerOn := t.pushCovDer_isCovariantDerivativeOn (u := t.baseSet) subset_rfl
+    cov.isCovariantDerivativeOn
+  letI tproj := d_covDerOn.projection v.proj (t v).2
+  letI Tvt := t.deriv I v
+  t.symmL 𝕜 v.proj ∘L tproj ∘L Tvt
+
+omit [FiniteDimensional 𝕜 F] [CompleteSpace 𝕜] [IsManifold I 1 M] in
+lemma isCovariantDerivativeOn_pushCovDer
+    (cov : CovariantDerivative I F V) (e : Trivialization F (π F V)) [MemTrivializationAtlas e] :
+    IsCovariantDerivativeOn F (e.pushCovDer cov) e.baseSet :=
+  e.pushCovDer_isCovariantDerivativeOn subset_rfl
+      (cov.isCovariantDerivativeOn.mono fun _ _ ↦ mem_univ _)
+
+lemma snd_triv_proj (cov : CovariantDerivative I F V) (v : TotalSpace F V) (u : TangentSpace (I.prod
+  𝓘(𝕜, F)) v) :
+    letI t := trivializationAt F V v.proj
+    haveI d_covDerOn := cov.isCovariantDerivativeOn_pushCovDer t
+    letI tproj := d_covDerOn.projection v.proj (t v).2
+    letI Tvt := t.deriv I v
+    (t <| cov.proj v u).2 = tproj (Tvt u) := by
+  simp [CovariantDerivative.proj, (mem_baseSet_trivializationAt F V v.proj)]
+
+noncomputable def horiz (cov : CovariantDerivative I F V) (v : TotalSpace F V) :
+    Submodule 𝕜 (TangentSpace (I.prod 𝓘(𝕜, F)) v) :=
+  (cov.proj v).ker
+
+lemma mem_horiz_iff_proj {cov : CovariantDerivative I F V} {v : TotalSpace F V}
+    (u : TangentSpace (I.prod 𝓘(𝕜, F)) v) :
+    u ∈ cov.horiz v ↔ cov.proj v u = 0 := by
+  simp [horiz]
+
+lemma comap_trivializationAt_horiz (cov : CovariantDerivative I F V) (v : TotalSpace F V) :
+    letI t := trivializationAt F V v.proj
+    haveI d_covDerOn := cov.isCovariantDerivativeOn_pushCovDer t
+    horiz cov v = Submodule.comap (t.deriv I v).toLinearMap
+      (d_covDerOn.horiz v.proj (t v).2) := by
+  -- FIXME: needing all those lets and the change is awful
+  let t := trivializationAt F V v.proj
+  let Tvt := t.deriv I v
+  haveI hcov := cov.isCovariantDerivativeOn_pushCovDer t
+  let tproj := hcov.projection v.proj (t v).2
+  let t' := t.continuousLinearEquivAt 𝕜 v.proj (mem_baseSet_trivializationAt F V v.proj)
+  ext u
+  change t'.symm (tproj (Tvt u)) = 0 ↔ tproj (Tvt u) = 0
+  simp
+
+omit [ContMDiffVectorBundle 1 F V I] in
+lemma horiz_vert_direct_sum [ContMDiffVectorBundle 1 F V I]
+    (cov : CovariantDerivative I F V) (v : TotalSpace F V) :
+    IsCompl (cov.horiz v) (vert v) := by
+  let t := trivializationAt F V v.proj
+  let Tvt := t.deriv I v
+  have hcov := cov.isCovariantDerivativeOn_pushCovDer t
+  rw [t.comap_vert (mem_baseSet_trivializationAt F V v.proj), comap_trivializationAt_horiz]
+  apply LinearMap.comap_isCompl
+  · apply t.bijective_deriv
+    exact FiberBundle.mem_baseSet_trivializationAt' v.proj
+  · apply hcov.horiz_vert_direct_sum
+
+variable {cov : CovariantDerivative I F V}
+
+lemma proj_mderiv {σ : Π x : M, V x} (x : M)
+    (hσ : MDiffAt (T% σ) x) :
+    cov σ x = cov.proj (σ x) ∘L
+      (mfderiv I (I.prod 𝓘(𝕜, F)) (T% σ) x) := by
+  let t := trivializationAt F V x
+  let s := t.secToFun σ
+  let Tσx := mfderiv% (T% σ) x
+  -- FIXME `mfderiv%` fails in next line
+  let Ttσx := mfderiv (I.prod 𝓘(𝕜, F)) (I.prod 𝓘(𝕜, F)) t (σ x)
+  ext1 X₀
+  have hcov := cov.isCovariantDerivativeOn_pushCovDer t
+  have hx := mem_baseSet_trivializationAt F V x
+  have hs : MDiffAt (T% s) x := t.mdifferentiableAt_total_secToFun hx hσ
+  change cov σ x X₀ = cov.proj (T% σ x) (mfderiv% (T% σ) x X₀)
+  apply t.eq_of hx
+  rw  [cov.snd_triv_proj (T% σ x),
+       ← t.pushCovDer_secToFun cov.isCovariantDerivativeOn hσ,
+       hcov.cov_eq_proj s X₀ hs, t.mfderiv_comp_section hσ _ hx]
+  rfl
+
+lemma mem_horiz_iff_exists [FiniteDimensional 𝕜 E]
+    {cov : CovariantDerivative I F V} {v : TotalSpace F V}
+    (w : TangentSpace (I.prod 𝓘(𝕜, F)) v) :
+    letI u := mfderiv (I.prod 𝓘(𝕜, F)) I TotalSpace.proj v w
+    w ∈ cov.horiz v ↔ ∃ σ : Π x, V x,
+                        MDiffAt (T% σ) v.proj ∧
+                        σ v.proj = v ∧
+                        mfderiv% (T% σ) v.proj u = w ∧
+                        cov σ v.proj u = 0
+    := by
+  set u := mfderiv (I.prod 𝓘(𝕜, F)) I TotalSpace.proj v w with u_def
+  set t := trivializationAt F V v.proj with t_def
+  set Tvt := t.deriv I v with Tvt_def
+  have hcov := cov.isCovariantDerivativeOn_pushCovDer t
+  have hvproj : v.proj ∈ t.baseSet := FiberBundle.mem_baseSet_trivializationAt' v.proj
+  have hTvtw : (Tvt w).1 = u :=
+    t.mfderiv_proj_fst_deriv hvproj w |>.symm
+  simp_rw [cov.comap_trivializationAt_horiz v, ← t_def, ← Tvt_def, Submodule.mem_comap,
+           hcov.mem_horiz_iff_exists]
+  constructor
+  · rintro ⟨s, sdiff, sval, mfderivs, covs⟩
+    use t.funToSec s, ?_, ?_, ?_, ?_
+    · exact t.mdifferentiableAt_funToSec hvproj sdiff
+    · simp [sval, hvproj]
+    · -- TODO needs a lot of cleanup here
+      -- TODO cleanup those erw by understanding why we sometimes have Tvt and
+      -- sometimes Tvt.toLinerMap
+      erw [hTvtw] at mfderivs
+      rw [u_def, t.mfderiv_total_funToSec sdiff hvproj]
+      simp only [ContinuousLinearMap.coe_comp', Function.comp_apply, ContinuousLinearMap.prod_apply,
+        ContinuousLinearMap.coe_id', id_eq]
+      erw [mfderivs]
+      rw [t.mfderiv_proj_fst_deriv hvproj]
+      have : (((Trivialization.deriv I t v) w).1, (Tvt w).2) = Tvt w := rfl
+      erw [this, Tvt_def, t.funToSec_proj_eq hvproj sval]
+      exact t.derivInv_deriv_apply hvproj w
+    · rw [ContinuousLinearMap.coe_coe] at covs
+      simp [t.pushCovDer_funToSec cov, ← hTvtw, covs, t.symm_map_zero 𝕜]
+  · rintro ⟨σ, σdiff, σval, mfderivσ, covσ⟩
+    use t.secToFun σ, ?_, ?_, ?_
+    · rw [t.pushCovDer_secToFun cov.isCovariantDerivativeOn σdiff]
+      -- TODO cleanup those erw by understanding why we sometimes have Tvt and
+      -- sometimes Tvt.toLinerMap
+      erw [hTvtw, covσ]
+      exact t.map_zero 𝕜 hvproj
+    · exact Trivialization.mdifferentiableAt_secToFun t hvproj σdiff
+    · exact t.secToFun_apply_of_eq σval
+    · erw [hTvtw]
+      rw [t.mfderiv_secToFun_apply σdiff hvproj, mfderivσ, σval]
+      rfl
+
+end CovariantDerivative
+end horiz
+
+-- variable (E E') in
+-- /-- The trivial connection on a trivial bundle, given by the directional derivative -/
+-- @[simps]
+-- noncomputable def trivial : CovariantDerivative 𝓘(𝕜, E) E'
+--   (Bundle.Trivial E E') where
+--   toFun X s := fun x ↦ fderiv 𝕜 s x (X x)
+--   isCovariantDerivativeOn :=
+--   { addX X X' σ x _ := by simp
+--     smulX X σ c' x _ := by simp
+--     add X σ σ' x hσ hσ' hx := by
+--       rw [Bundle.Trivial.mdifferentiableAt_iff] at hσ hσ'
+--       rw [fderiv_add hσ hσ']
+--       rfl
+--     smul_constX σ a x hx := by simp [fderiv_const_smul_of_field a]
+--     leibniz X σ f x hσ hf hx := by
+--       have : fderiv 𝕜 (f • σ) x = f x • fderiv 𝕜 σ x + (fderiv 𝕜 f x).smulRight (σ x) :=
+--         fderiv_smul (by simp_all) (by simp_all)
+--       simp [this, bar]
+--       rfl }
+
+end
diff --git a/Mathlib/Geometry/Manifold/VectorBundle/CovariantDerivative/Geodesics.lean b/Mathlib/Geometry/Manifold/VectorBundle/CovariantDerivative/Geodesics.lean
new file mode 100644
index 00000000000000..0aeb17de89fd81
--- /dev/null
+++ b/Mathlib/Geometry/Manifold/VectorBundle/CovariantDerivative/Geodesics.lean
@@ -0,0 +1,97 @@
+/-
+Copyright (c) 2025 Patrick Massot. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Heather Macbeth, Patrick Massot, Michael Rothgang
+-/
+module
+
+public import Mathlib.Geometry.Manifold.VectorBundle.CovariantDerivative.Lift
+public import Mathlib.Geometry.Manifold.VectorBundle.CovariantDerivative.IntegralCurvePrelim
+
+/-!
+# Geodesics for covariant derivatives on tangent bundles
+
+TODO: add a more complete doc-string
+
+-/
+
+@[expose] public section
+
+open Bundle Filter Module Topology Set
+
+open scoped Bundle Manifold ContDiff
+
+variable
+  {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] [FiniteDimensional ℝ E]
+  {H : Type*} [TopologicalSpace H] {I : ModelWithCorners ℝ E H} {M : Type*} [TopologicalSpace M]
+  [ChartedSpace H M]
+  [IsManifold I 2 M]
+  (cov : CovariantDerivative I E (TangentSpace I : M → Type _))
+
+lemma IsMIntegralCurveAt.proj_acceleration {X : Π x : M, TangentSpace I x}
+    {γ : ℝ → M} {t₀ : ℝ} (hX : MDiffAt (T% X) (γ t₀))
+    (hγX : IsMIntegralCurveAt γ X t₀) :
+    cov.proj _ (velocity I.tangent (velocity I γ) t₀).2 = cov X (γ t₀) (X (γ t₀)) := by
+  rw [hγX.acceleration hX, cov.proj_mderiv _ hX]
+  simp
+
+/-- The geodesic vector field of a covariant derivative on a tangent bundle, defined
+by send any vector `v` to its lift at itself. -/
+noncomputable
+def CovariantDerivative.geodVF (v : TotalSpace E (TangentSpace I : M → Type _)) :
+    TangentSpace (I.prod 𝓘(ℝ, E)) v :=  cov.lift_vec v v.2
+
+@[simp]
+lemma CovariantDerivative.geodVF_horiz (v : TotalSpace E (TangentSpace I : M → Type _)) :
+    cov.geodVF v ∈ cov.horiz v := by
+  simp [CovariantDerivative.geodVF]
+
+@[simp]
+lemma CovariantDerivative.proj_geodVF (v : TotalSpace E (TangentSpace I : M → Type _)) :
+    cov.proj v (cov.geodVF v) = 0 := by
+  simp [CovariantDerivative.geodVF]
+
+/-- A curve `γ : ℝ → M` is a geodesic for `cov` at `t` if it is an integral
+curve of the geodesic vector field of `cov` near `t`.
+Remember: `IsMIntegralCurveAt` is local, not pointwise. -/
+def CovariantDerivative.isGeodAt (γ : ℝ → M) (t : ℝ) :=
+  IsMIntegralCurveAt (velocity I γ) cov.geodVF t
+
+set_option backward.isDefEq.respectTransparency false in
+lemma CovariantDerivative.isGeodAt_iff_horiz {γ : ℝ → M} {t₀ : ℝ}
+    (hγ : ∀ᶠ (t : ℝ) in 𝓝 t₀, MDiffAt (velocity I γ) t) :
+    cov.isGeodAt γ t₀ ↔
+    ∀ᶠ (t : ℝ) in 𝓝 t₀, (velocity I.tangent (velocity I γ) t).2 ∈ cov.horiz _ := by
+  unfold CovariantDerivative.isGeodAt CovariantDerivative.geodVF
+  rw [IsMIntegralCurveAt_iff_mfderiv _ _ _ hγ]
+  refine eventually_congr ?_
+  filter_upwards [hγ] with t ht
+  conv_lhs => rw [Eq.comm, cov.lift_vec_eq_iff (velocity I γ t).2]
+  rw [← cov.mem_horiz_iff_proj, proj_velocity,
+      show mfderiv% (velocity I γ) t (1 : ℝ) = (velocity I.tangent (velocity I γ) t).2 from
+        rfl, -- TODO need a simp lemma here?
+      ]
+  -- TODO: understand why
+  -- simp [proj_velocity, proj_acceleration I ht]
+  -- doesn’t close the goal
+  simp only [proj_velocity, and_iff_left_iff_imp]
+  exact fun _ ↦ proj_acceleration I ht
+
+lemma CovariantDerivative.isGeodAt_iff_proj {γ : ℝ → M} {t₀ : ℝ}
+    (hγ : ∀ᶠ (t : ℝ) in 𝓝 t₀, MDiffAt (velocity I γ) t) :
+    cov.isGeodAt γ t₀ ↔
+     ∀ᶠ (t : ℝ) in 𝓝 t₀, cov.proj _ (velocity I.tangent (velocity I γ) t).2 = 0 :=
+  cov.isGeodAt_iff_horiz hγ
+
+def CovariantDerivative.isGeod (γ : ℝ → M) := ∀ t, cov.isGeodAt γ t
+
+set_option backward.isDefEq.respectTransparency false in
+lemma CovariantDerivative.orbit_geodVF {X : Π x : M, TangentSpace I x}
+    {γ : ℝ → M} {t₀ : ℝ} (hX : ∀ᶠ t in 𝓝 t₀, MDiffAt (T% X) (γ t))
+    (hγ : ∀ᶠ (t : ℝ) in 𝓝 t₀, MDiffAt (velocity I γ) t)
+    (hγX : IsMIntegralCurveAt γ X t₀) :
+    cov.isGeodAt γ t₀ ↔ ∀ᶠ t in 𝓝 t₀, cov X (γ t) (X (γ t)) = 0 := by
+  rw [cov.isGeodAt_iff_proj hγ]
+  refine eventually_congr ?_
+  filter_upwards [hX, hγX.eventually_isMIntegralCurveAt] with t ht ht'
+  rw [ht'.proj_acceleration cov ht]
diff --git a/Mathlib/Geometry/Manifold/VectorBundle/CovariantDerivative/IntegralCurvePrelim.lean b/Mathlib/Geometry/Manifold/VectorBundle/CovariantDerivative/IntegralCurvePrelim.lean
new file mode 100644
index 00000000000000..c762b2b4f68fc0
--- /dev/null
+++ b/Mathlib/Geometry/Manifold/VectorBundle/CovariantDerivative/IntegralCurvePrelim.lean
@@ -0,0 +1,108 @@
+module
+
+public import Mathlib.Geometry.Manifold.VectorBundle.MDifferentiable
+public import Mathlib.Geometry.Manifold.IntegralCurve.Basic
+
+
+/-!
+# Preliminaries about integral curves of vector fiels
+
+TODO: PR that material to Mathlib.Geometry.Manifold.IntegralCurve.Basic
+except for `proj_acceleration` which uses
+`Mathlib.Geometry.Manifold.VectorBundle.MDifferentiable`.
+-/
+
+@[expose] public section
+
+open Bundle Filter Module Topology Set
+
+open scoped Bundle Manifold ContDiff
+
+variable
+  {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] {H : Type*}
+  [TopologicalSpace H] {I : ModelWithCorners ℝ E H} {M : Type*}
+  [TopologicalSpace M] [ChartedSpace H M] (γ : ℝ → M)
+  (v : (x : M) → TangentSpace I x) (t₀ : ℝ)
+
+variable (I) in
+noncomputable
+def velocity (γ : ℝ → M) (t : ℝ) : TangentBundle I M := ⟨γ t, mfderiv% γ t (1 : ℝ)⟩
+
+@[simp]
+lemma proj_velocity (γ : ℝ → M) (t : ℝ) : (velocity I γ t).proj = γ t := rfl
+
+lemma IsMIntegralCurveAt.mdifferentiableAt (h : IsMIntegralCurveAt γ v t₀) :
+    ∀ᶠ t in 𝓝 t₀, MDiffAt γ t := by
+  filter_upwards [h] with t ht
+  exact ht.mdifferentiableAt
+
+set_option backward.isDefEq.respectTransparency false in
+protected lemma IsMIntegralCurveAt.mfderiv (hγ : IsMIntegralCurveAt γ v t₀) :
+    ∀ᶠ t in 𝓝 t₀, mfderiv% γ t (1 : ℝ) = v (γ t) := by
+  filter_upwards [hγ] with t ht
+  rw [ht.mfderiv]
+  rw [ContinuousLinearMap.smulRight_apply]
+  change 1 • v (γ t) = v (γ t)
+  simp
+
+protected lemma IsMIntegralCurveAt.velocity_eventuallyEq
+    (hγ : IsMIntegralCurveAt γ v t₀) : velocity I γ =ᶠ[𝓝 t₀] T%v ∘ γ := by
+  filter_upwards [hγ.mfderiv] with t ht
+  simp [ht, velocity]
+
+-- Is this really missing??
+lemma IsMIntegralCurveAt_iff_mfderiv (hγ : ∀ᶠ t in 𝓝 t₀, MDiffAt γ t) :
+    IsMIntegralCurveAt γ v t₀ ↔ ∀ᶠ t in 𝓝 t₀, mfderiv% γ t (1 : ℝ) = v (γ t) := by
+  refine ⟨fun h ↦ h.mfderiv, fun h ↦ ?_⟩
+  filter_upwards [hγ.and h] with t ⟨ht, ht'⟩
+  rw [← ht']
+  convert ht.hasMFDerivAt
+  ext
+  simp
+  rfl
+
+lemma IsMIntegralCurveAt.eventually_isMIntegralCurveAt
+    {X : Π x : M, TangentSpace I x} {γ : ℝ → M} {t₀ : ℝ}
+    (hγX : IsMIntegralCurveAt γ X t₀) :
+    ∀ᶠ t in 𝓝 t₀, IsMIntegralCurveAt γ X t :=
+  eventually_eventually_nhds.2 hγX
+
+variable [IsManifold I 1 M]
+
+set_option linter.flexible false in --FIXME
+lemma IsMIntegralCurveAt.acceleration {X : Π x : M, TangentSpace I x}
+    {γ : ℝ → M} {t₀ : ℝ} (hX : MDiffAt (T% X) (γ t₀))
+    (hγX : IsMIntegralCurveAt γ X t₀) :
+    velocity I.tangent (velocity I γ) t₀ = mfderiv% (T% X) (γ t₀) (X (γ t₀)) := by
+  have : velocity I γ =ᶠ[𝓝 t₀] T%X ∘ γ := hγX.velocity_eventuallyEq
+  have := this.mfderiv_eq (I := 𝓘(ℝ, ℝ)) (I' := I.tangent)
+  have foo := EventuallyEq.eq_of_nhds hγX.mfderiv
+  simp [velocity, this, foo]
+  have := hγX.mdifferentiableAt.self_of_nhds
+  rw [mfderiv_comp t₀ hX this, ← foo]
+  rfl
+
+lemma IsMIntegralCurveAt.eventually_acceleration {X : Π x : M, TangentSpace I x}
+    {γ : ℝ → M} {t₀ : ℝ} (hX : ∀ᶠ t in 𝓝 t₀, MDiffAt (T% X) (γ t))
+    (hγX : IsMIntegralCurveAt γ X t₀) :
+    ∀ᶠ t in 𝓝 t₀, velocity I.tangent (velocity I γ) t = mfderiv% (T% X) (γ t) (X (γ t)) := by
+  filter_upwards [hX, hγX.eventually_isMIntegralCurveAt] with t hXt hγXt
+  exact acceleration hXt hγXt
+
+-- FIXME: bug in `mfderiv%`?
+-- FIXME: missing elaborator support to find I.tangent
+variable (I) in
+@[simp]
+lemma proj_acceleration {γ : ℝ → M} {t : ℝ} (h : MDiffAt (velocity I γ) t) :
+    mfderiv I.tangent I (TotalSpace.proj : TangentBundle I M → M)
+  (velocity I γ t) (velocity I.tangent (velocity I γ) t).2 = (velocity
+I γ t).2 := by
+  have comp_eq: (TotalSpace.proj : TangentBundle I M → M) ∘ (velocity I γ) = γ := by
+    ext t
+    simp
+  have diff : MDifferentiableAt I.tangent I (TotalSpace.proj : TangentBundle I M → M)
+      (velocity I γ t) := by
+    exact mdifferentiableAt_proj (TangentSpace I)
+  have := mfderiv_comp t diff h
+  rw [comp_eq] at this
+  exact congr($this (1 : ℝ)).symm
diff --git a/Mathlib/Geometry/Manifold/VectorBundle/CovariantDerivative/LeviCivita.lean b/Mathlib/Geometry/Manifold/VectorBundle/CovariantDerivative/LeviCivita.lean
new file mode 100644
index 00000000000000..38b8450d10b69e
--- /dev/null
+++ b/Mathlib/Geometry/Manifold/VectorBundle/CovariantDerivative/LeviCivita.lean
@@ -0,0 +1,860 @@
+/-
+Copyright (c) 2025 Michael Rothgang. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Patrick Massot, Michael Rothgang, Heather Macbeth
+-/
+module
+
+public import Mathlib.Analysis.InnerProductSpace.Dual
+public import Mathlib.Geometry.Manifold.VectorBundle.CovariantDerivative.Metric
+public import Mathlib.Geometry.Manifold.VectorBundle.CovariantDerivative.Torsion
+
+/-!
+# The Levi-Civita connection on a Riemannian manifold
+
+To be continued and polished!
+
+This file defines the Levi-Civita connection on a (finite-dimensional) Riemannian manifold `(M, g)`.
+connection `∇` on the tangent bundle of a Riemannian manifold `(M, g)` is called a
+*Levi-Civita connection* if and only if it is both compatible with the metric `g` and torsion-free.
+Any two such connections are equal (on differentiable vector fields), which is why one speaks of
+*the* Levi-Civita connection on `TM`.
+We construct a Levi-Civita connection and prove that is defines a compatible torsion-free
+connection.
+
+
+## Main definitions and results
+
+* `CovariantDerivative.IsLeviCivitaConnection`: a covariant derivative `∇` on `(M, g)` is a
+  Levi-Civita connection if and only if it is both torsion-free and compatible with `g`
+
+* `CovariantDerivative.IsLeviCivitaConnection.uniqueness`: a Levi-Civita connection on `(M, g)` is
+  uniquely determined on differentiable vector fields.
+
+* `CovariantDerivative.LeviCivitaConnection`: a choice of Levi-Civita connection on the tangent
+  bundle `TM` of a Riemannian manifold `(M, g)`: this is unique up to the value on
+  non-differentiable vector fields.
+  If you know the Levi-Civita connection already, you can use `IsLeviCivitaConnection` instead.
+* `CovariantDerivative.leviCivitaConnection_isLeviCivitaConnection`:
+  `LeviCivitaConnection` is a Levi-Civita connection (i.e., compatible and torsion-free)
+
+## Implementation notes
+* construction of LC using a tensoriality argument, and the musical isomorphism
+  (avoids the use of local frames and trivialisations)
+
+-/
+
+open Bundle FiberBundle Function NormedSpace
+open scoped Manifold ContDiff
+
+@[expose] public section -- TODO: think if we want to expose all definitions!
+
+-- TODO: revisit and fix this once the dust has settled
+set_option backward.isDefEq.respectTransparency false
+
+-- Let `(M, g)` be a `C^k` real manifold modeled on `(E, H)`, endowed with a Riemannian metric `g`.
+variable {n : WithTop ℕ∞}
+  {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
+  {H : Type*} [TopologicalSpace H] (I : ModelWithCorners ℝ E H)
+  {M : Type*} [EMetricSpace M] [ChartedSpace H M] [IsManifold I 2 M]
+  [RiemannianBundle (fun (x : M) ↦ TangentSpace I x)]
+  {X X' X'' Y Y' Y'' Z Z' : Π x : M, TangentSpace I x}
+
+namespace CovariantDerivative
+
+-- Let `cov` be a covariant derivative on `TM`.
+-- TODO: include in cheat sheet!
+variable (cov : CovariantDerivative I E (TangentSpace I : M → Type _))
+
+/-- Local notation for a connection. Caution: `∇ Y, X` corresponds to `∇ₓ Y` in textbooks -/
+local notation "∇" Y "," X => fun (x:M) ↦ cov Y x (X x)
+
+variable [IsContMDiffRiemannianBundle I 1 E (fun (x : M) ↦ TangentSpace I x)]
+
+/-- A covariant derivative on a Riemannian bundle `TM` is called the **Levi-Civita connection**
+iff it is torsion-free and compatible with `g`.
+Note that the bundle metric on `TM` is implicitly hidden in this definition. See `TODO` for a
+version depending on a choice of Riemannian metric on `M`.
+-/
+def IsLeviCivitaConnection [FiniteDimensional ℝ E] : Prop := cov.IsCompatible ∧ cov.torsion = 0
+
+local notation "⟪" X ", " Y "⟫" => product X Y
+
+/- TODO: writing `hσ.inner_bundle hτ` or writing `by apply MDifferentiable.inner_bundle hσ hτ`
+yields an error
+synthesized type class instance is not definitionally equal to expression inferred by typing rules,
+synthesized
+  fun x ↦ instNormedAddCommGroupOfRiemannianBundle x
+inferred
+  fun b ↦ inst✝⁷
+Diagnose and fix this, and then replace the below by `MDifferentiable(At).inner_bundle! -/
+
+variable {I} in
+lemma _root_.MDifferentiable.inner_bundle' {X Y : Π x : M, TangentSpace I x}
+    (hX : MDiff (T% X)) (hY : MDiff (T% Y)) : MDiff ⟪X, Y⟫ :=
+  MDifferentiable.inner_bundle hX hY
+
+variable {I} in
+lemma _root_.MDifferentiableAt.inner_bundle' {x : M} {X Y : Π x : M, TangentSpace I x}
+    (hX : MDiffAt (T% X) x) (hY : MDiffAt (T% Y) x) :
+    MDiffAt ⟪X, Y⟫ x :=
+  MDifferentiableAt.inner_bundle hX hY
+
+variable (X Y Z) in
+/-- The first term in the definition of the candidate Levi-Civita connection:
+`rhs_aux I X Y Z = X ⟨Y, Z⟩ = x ↦ d(⟨Y, Z⟩)_x (X x)`.
+
+This definition contains mild defeq abuse, which is invisible on paper:
+The function `⟨Y, Z⟩` maps `M` into `ℝ`, hence its differential at a point `x` maps `T_p M`
+to an element of the tangent space of `ℝ`. A summand `⟨Y, [X, Z]⟩`, however, yields an honest
+real number: Lean complains that these have different types.
+Fortunately, `ℝ` is defeq to its own tangent space; casting `rhs_aux` to the real numbers
+allows the addition to type-check. -/
+noncomputable abbrev rhs_aux : M → ℝ := fun x ↦ (mfderiv% ⟪Y, Z⟫ x (X x))
+
+section rhs_aux
+
+variable (Y Z) in
+omit [IsManifold I 2 M] in
+lemma rhs_aux_swap : rhs_aux I X Y Z = rhs_aux I X Z Y := by
+  ext x
+  simp only [rhs_aux]
+  congr 2
+  exact product_swap Z Y
+
+omit [IsManifold I 2 M] in
+variable (X X' Y Z) in
+lemma rhs_aux_addX : rhs_aux I (X + X') Y Z = rhs_aux I X Y Z + rhs_aux I X' Y Z := by
+  ext x
+  simp [rhs_aux]
+
+variable {x : M}
+
+variable (X) in
+@[simp]
+lemma rhs_aux_addY_apply (hY : MDiffAt (T% Y) x) (hY' : MDiffAt (T% Y') x) (hZ : MDiffAt (T% Z) x) :
+    rhs_aux I X (Y + Y') Z x = rhs_aux I X Y Z x + rhs_aux I X Y' Z x := by
+  simp only [rhs_aux]
+  rw [product_add_left, mfderiv_add (hY.inner_bundle' hZ) (hY'.inner_bundle' hZ)]
+  simp; congr
+
+variable (X) in
+lemma rhs_aux_addY (hY : MDiff (T% Y)) (hY' : MDiff (T% Y')) (hZ : MDiff (T% Z)) :
+    rhs_aux I X (Y + Y') Z = rhs_aux I X Y Z + rhs_aux I X Y' Z := by
+  ext x
+  exact rhs_aux_addY_apply I X (hY x) (hY' x) (hZ x)
+
+variable (X) in
+@[simp]
+lemma rhs_aux_addZ_apply (hY : MDiffAt (T% Y) x) (hZ : MDiffAt (T% Z) x) (hZ' : MDiffAt (T% Z') x) :
+  rhs_aux I X Y (Z + Z') x = rhs_aux I X Y Z x + rhs_aux I X Y Z' x := by
+  unfold rhs_aux
+  rw [product_add_right, mfderiv_add (hY.inner_bundle' hZ) (hY.inner_bundle' hZ')]; simp; congr
+
+variable (X) in
+lemma rhs_aux_addZ (hY : MDiff (T% Y)) (hZ : MDiff (T% Z)) (hZ' : MDiff (T% Z')) :
+    rhs_aux I X Y (Z + Z') = rhs_aux I X Y Z + rhs_aux I X Y Z' := by
+  ext x
+  exact rhs_aux_addZ_apply I X (hY x) (hZ x) (hZ' x)
+
+omit [IsManifold I 2 M] in
+variable (X Y Z) in
+lemma rhs_aux_smulX_apply (f : M → ℝ) (x) : rhs_aux I (f • X) Y Z x = f x * rhs_aux I X Y Z x := by
+  simp [rhs_aux]
+
+omit [IsManifold I 2 M] in
+variable (X Y Z) in
+lemma rhs_aux_smulX (f : M → ℝ) : rhs_aux I (f • X) Y Z = f * rhs_aux I X Y Z := by
+  ext x
+  exact rhs_aux_smulX_apply ..
+
+variable (X) in
+lemma rhs_aux_smulY_apply {f : M → ℝ}
+    (hf : MDiffAt f x) (hY : MDiffAt (T% Y) x) (hZ : MDiffAt (T% Z) x) :
+    letI A (x) := fromTangentSpace _ ((mfderiv% f x) (X x))
+    rhs_aux I X (f • Y) Z x = f x * rhs_aux I X Y Z x + A x * ⟪Y, Z⟫ x := by
+  rw [rhs_aux, product_smul_left, mfderiv_smul hf (hY.inner_bundle' hZ)]
+  rfl
+
+variable (X) in
+lemma rhs_aux_smulY {f : M → ℝ} (hf : MDiff f) (hY : MDiff (T% Y)) (hZ : MDiff (T% Z)) :
+    letI A (x) := fromTangentSpace _ ((mfderiv% f x) (X x))
+    rhs_aux I X (f • Y) Z = f * rhs_aux I X Y Z + A * ⟪Y, Z⟫ := by
+  ext x
+  simp [rhs_aux_smulY_apply I X (hf x) (hY x) (hZ x)]
+
+variable (X) in
+lemma rhs_aux_smulY_const_apply {a : ℝ} (hY : MDiffAt (T% Y) x) (hZ : MDiffAt (T% Z) x) :
+    rhs_aux I X (a • Y) Z x = a * rhs_aux I X Y Z x := by
+  let f : M → ℝ := fun _ ↦ a
+  have h1 : rhs_aux I X (a • Y) Z x = rhs_aux I X (f • Y) Z x := by simp only [f]; congr
+  rw [h1, rhs_aux_smulY_apply I X mdifferentiableAt_const hY hZ]
+  simp [mfderiv_const]
+
+variable (X) in
+lemma rhs_aux_smulY_const {a : ℝ} (hY : MDiff (T% Y)) (hZ : MDiff (T% Z)) :
+    rhs_aux I X (a • Y) Z = a • rhs_aux I X Y Z := by
+  ext x
+  apply rhs_aux_smulY_const_apply I X (hY x) (hZ x)
+
+variable (X) in
+lemma rhs_aux_smulZ_apply {f : M → ℝ}
+    (hf : MDiffAt f x) (hY : MDiffAt (T% Y) x) (hZ : MDiffAt (T% Z) x) :
+    letI A (x) := fromTangentSpace _ ((mfderiv% f x) (X x))
+    rhs_aux I X Y (f • Z) x = f x * rhs_aux I X Y Z x + A x * ⟪Y, Z⟫ x := by
+  rw [rhs_aux_swap, rhs_aux_smulY_apply, rhs_aux_swap, product_swap]
+  exacts [hf, hZ, hY]
+
+variable (X) in
+lemma rhs_aux_smulZ {f : M → ℝ} (hf : MDiff f) (hY : MDiff (T% Y)) (hZ : MDiff (T% Z)) :
+    letI A (x) := fromTangentSpace _ ((mfderiv% f x) (X x))
+    rhs_aux I X Y (f • Z) = f * rhs_aux I X Y Z + A * ⟪Y, Z⟫ := by
+  rw [rhs_aux_swap, rhs_aux_smulY, rhs_aux_swap, product_swap]
+  exacts [hf, hZ, hY]
+
+variable (X) in
+lemma rhs_aux_smulZ_const_apply {a : ℝ} (hY : MDiffAt (T% Y) x) (hZ : MDiffAt (T% Z) x) :
+    rhs_aux I X Y (a • Z) x = a * rhs_aux I X Y Z x := by
+  let f : M → ℝ := fun _ ↦ a
+  have h1 : rhs_aux I X Y (a • Z) x = rhs_aux I X Y (f • Z) x := by simp only [f]; congr
+  rw [h1, rhs_aux_smulZ_apply I X mdifferentiableAt_const hY hZ]
+  simp [mfderiv_const]
+
+variable (X) in
+lemma rhs_aux_smulZ_const {a : ℝ} (hY : MDiff (T% Y)) (hZ : MDiff (T% Z)) :
+    rhs_aux I X Y (a • Z) = a • rhs_aux I X Y Z := by
+  ext x
+  exact rhs_aux_smulZ_const_apply I X (hY x) (hZ x)
+
+end rhs_aux
+
+variable {x : M}
+
+variable (X Y Z) in
+/-- Auxiliary quantity used in the uniqueness proof of the Levi-Civita connection:
+If ∇ is a Levi-Civita connection on `TM`, then
+`2 ⟨∇ X Y, Z⟩ = leviCivitaRhs' I X Y Z` for all vector fields `Z`. -/
+noncomputable def leviCivitaRhs' : M → ℝ :=
+  rhs_aux I X Y Z + rhs_aux I Y Z X - rhs_aux I Z X Y
+  - ⟪Y ,(VectorField.mlieBracket I X Z)⟫
+  - ⟪Z, (VectorField.mlieBracket I Y X)⟫
+  + ⟪X, (VectorField.mlieBracket I Z Y)⟫
+
+variable (X Y Z) in
+/-- Auxiliary quantity used in the uniqueness proof of the Levi-Civita connection:
+If `∇` is a Levi-Civita connection on `TM`, then
+`⟨∇ X Y, Z⟩ = leviCivitaRhs I X Y Z` for all smooth vector fields `X`, `Y` and `Z`. -/
+noncomputable def leviCivitaRhs : M → ℝ := (1 / 2 : ℝ) • leviCivitaRhs' I X Y Z
+
+omit [IsManifold I 2 M] in
+lemma leviCivitaRhs_apply : leviCivitaRhs I X Y Z x = (1 / 2 : ℝ) • leviCivitaRhs' I X Y Z x :=
+  rfl
+
+section leviCivitaRhs
+
+@[simp]
+lemma leviCivitaRhs'_addX_apply [CompleteSpace E]
+    (hX : MDiffAt (T% X) x) (hX' : MDiffAt (T% X') x)
+    (hY : MDiffAt (T% Y) x) (hZ : MDiffAt (T% Z) x) :
+    leviCivitaRhs' I (X + X') Y Z x =
+      leviCivitaRhs' I X Y Z x + leviCivitaRhs' I X' Y Z x := by
+  simp only [leviCivitaRhs', rhs_aux_addX, Pi.add_apply, Pi.sub_apply]
+  -- We have to rewrite back and forth: the Lie bracket is only additive at x,
+  -- as we are only asking for differentiability at x.
+  -- Fortunately, the `product_congr_right₂` lemma abstracts this very well.
+  rw [product_congr_right₂ (VectorField.mlieBracket_add_right (V := Y) hX hX'),
+    product_congr_right₂ (VectorField.mlieBracket_add_left (W := Z) hX hX'),
+    product_add_left_apply, rhs_aux_addY_apply, rhs_aux_addZ_apply] <;> try assumption
+  abel
+
+lemma leviCivitaRhs'_addX [CompleteSpace E]
+    (hX : MDiff (T% X)) (hX' : MDiff (T% X')) (hY : MDiff (T% Y)) (hZ : MDiff (T% Z)) :
+    leviCivitaRhs' I (X + X') Y Z =
+      leviCivitaRhs' I X Y Z + leviCivitaRhs' I X' Y Z := by
+  ext x
+  simp [leviCivitaRhs'_addX_apply _ (hX x) (hX' x) (hY x) (hZ x)]
+
+lemma leviCivitaRhs_addX_apply [CompleteSpace E]
+    (hX : MDiffAt (T% X) x) (hX' : MDiffAt (T% X') x)
+    (hY : MDiffAt (T% Y) x) (hZ : MDiffAt (T% Z) x) :
+    leviCivitaRhs I (X + X') Y Z x = leviCivitaRhs I X Y Z x + leviCivitaRhs I X' Y Z x := by
+  simp [leviCivitaRhs, leviCivitaRhs'_addX_apply I hX hX' hY hZ, left_distrib]
+
+lemma leviCivitaRhs_addX [CompleteSpace E]
+    (hX : MDiff (T% X)) (hX' : MDiff (T% X')) (hY : MDiff (T% Y)) (hZ : MDiff (T% Z)) :
+    leviCivitaRhs I (X + X') Y Z = leviCivitaRhs I X Y Z + leviCivitaRhs I X' Y Z := by
+  ext x
+  simp [leviCivitaRhs_addX_apply _ (hX x) (hX' x) (hY x) (hZ x)]
+
+open VectorField NormedSpace
+
+variable {I} in
+lemma leviCivitaRhs'_smulX_apply [CompleteSpace E] {f : M → ℝ}
+    (hf : MDiffAt f x) (hX : MDiffAt (T% X) x) (hY : MDiffAt (T% Y) x) (hZ : MDiffAt (T% Z) x) :
+    leviCivitaRhs' I (f • X) Y Z x = f x • leviCivitaRhs' I X Y Z x := by
+  unfold leviCivitaRhs'
+  simp only [Pi.add_apply, Pi.sub_apply]
+  rw [rhs_aux_smulX, rhs_aux_smulY_apply, rhs_aux_smulZ_apply] <;> try assumption
+  -- TODO: add the right congr_right lemma to avoid the product_apply, ← product_apply dance!
+  simp only [product_apply, mlieBracket_smul_left (W := Z) hf hX,
+    mlieBracket_smul_right (V := Y) hf hX, inner_add_right]
+  -- Combining this line with the previous one fails.
+  simp only [← product_apply, neg_smul, inner_neg_right]
+  have h1 :
+      inner ℝ (Y x) ((fromTangentSpace _ (mfderiv% f x (Z x))) • X x) =
+        fromTangentSpace (f x) (mfderiv% f x (Z x)) * ⟪X, Y⟫ x := by
+    simp only [product]
+    rw [← real_inner_smul_left, real_inner_smul_right, real_inner_smul_left, real_inner_comm]
+  have h2 :
+      inner ℝ (Z x) (fromTangentSpace (f x) ((mfderiv% f x (Y x))) • X x) =
+        (fromTangentSpace (f x) (mfderiv% f x (Y x))) * ⟪Z, X⟫ x := by
+    simp only [product]
+    rw [← real_inner_smul_left, real_inner_smul_right, real_inner_smul_left]
+  rw [h1, h2]
+  --set dfY := fromTangentSpace (f x) ((mfderiv% f x (Y x)))--(mfderiv% f x) (Y x)
+  --set dfZ : ℝ := (mfderiv% f x) (Z x)
+  have h3 : ⟪f • X, mlieBracket I Z Y⟫ x = f x * ⟪X, mlieBracket I Z Y⟫ x := by
+    rw [product_apply, Pi.smul_apply', real_inner_smul_left]
+  have h4 : inner ℝ (Z x) (f x • mlieBracket I Y X x) = f x * ⟪Z, mlieBracket I Y X⟫ x := by
+    rw [product_apply, real_inner_smul_right]
+  rw [real_inner_smul_right (Y x), h3, h4]
+  -- Push all applications of `x` inwards, then it's indeed obvious.
+  simp
+  -- set A := ⟪Y, mlieBracket I X Z⟫ with hA
+  -- set B := ⟪Z, mlieBracket I X Y⟫
+  -- set C := ⟪X, mlieBracket I Z Y⟫
+  -- set R := dfZ * ⟪X, Y⟫ x with hR
+  -- set R' := dfY * ⟪Z, X⟫ x with hR'
+  -- set E := rhs_aux I X Y Z x
+  -- set F := rhs_aux I Y Z X x
+  -- set G := rhs_aux I Z X Y x
+  ring_nf
+
+variable {I} in
+lemma leviCivitaRhs_smulX_apply [CompleteSpace E] {f : M → ℝ}
+    (hf : MDiffAt f x) (hX : MDiffAt (T% X) x) (hY : MDiffAt (T% Y) x) (hZ : MDiffAt (T% Z) x) :
+    leviCivitaRhs I (f • X) Y Z x = f x • leviCivitaRhs I X Y Z x := by
+  simp only [leviCivitaRhs, one_div, Pi.smul_apply, smul_eq_mul]
+  simp_rw [leviCivitaRhs'_smulX_apply (I := I) hf hX hY hZ]
+  rw [← mul_assoc, mul_comm (f x), smul_eq_mul]
+  ring
+
+variable {I} in
+lemma leviCivitaRhs_smulX [CompleteSpace E] {f : M → ℝ}
+    (hf : MDiff f) (hX : MDiff (T% X)) (hY : MDiff (T% Y)) (hZ : MDiff (T% Z)) :
+    leviCivitaRhs I (f • X) Y Z = f • leviCivitaRhs I X Y Z := by
+  ext x
+  exact leviCivitaRhs_smulX_apply (hf x) (hX x) (hY x) (hZ x)
+
+lemma leviCivitaRhs'_addY_apply [CompleteSpace E]
+    (hX : MDiffAt (T% X) x) (hY : MDiffAt (T% Y) x)
+    (hY' : MDiffAt (T% Y') x) (hZ : MDiffAt (T% Z) x) :
+    leviCivitaRhs' I X (Y + Y') Z x = leviCivitaRhs' I X Y Z x + leviCivitaRhs' I X Y' Z x := by
+  simp only [leviCivitaRhs', Pi.add_apply, Pi.sub_apply, product_add_left_apply]
+  rw [rhs_aux_addX, rhs_aux_addY_apply, rhs_aux_addZ_apply] <;> try assumption
+  -- We have to rewrite back and forth: the Lie bracket is only additive at x,
+  -- as we are only asking for differentiability at x.
+  rw [product_congr_right₂ (mlieBracket_add_left (W := X) hY hY')]
+  rw [product_congr_right₂ (VectorField.mlieBracket_add_right (V := Z) hY hY')]
+  simp only [Pi.add_apply]
+  abel
+
+lemma leviCivitaRhs_addY_apply [CompleteSpace E]
+    (hX : MDiffAt (T% X) x) (hY : MDiffAt (T% Y) x)
+    (hY' : MDiffAt (T% Y') x) (hZ : MDiffAt (T% Z) x) :
+    leviCivitaRhs I X (Y + Y') Z x = leviCivitaRhs I X Y Z x + leviCivitaRhs I X Y' Z x := by
+  simp [leviCivitaRhs, leviCivitaRhs'_addY_apply I hX hY hY' hZ, left_distrib]
+
+lemma leviCivitaRhs_addY [CompleteSpace E]
+    (hX : MDiff (T% X)) (hY : MDiff (T% Y)) (hY' : MDiff (T% Y')) (hZ : MDiff (T% Z)) :
+    leviCivitaRhs I X (Y + Y') Z = leviCivitaRhs I X Y Z + leviCivitaRhs I X Y' Z := by
+  ext x
+  simp [leviCivitaRhs_addY_apply I (hX x) (hY x) (hY' x) (hZ x)]
+
+variable {I} in
+lemma leviCivitaRhs'_smulY_const_apply [CompleteSpace E] {a : ℝ}
+    (hX : MDiffAt (T% X) x) (hY : MDiffAt (T% Y) x) (hZ : MDiffAt (T% Z) x) :
+    leviCivitaRhs' I X (a • Y) Z x = a • leviCivitaRhs' I X Y Z x := by
+  simp only [leviCivitaRhs']
+  simp only [product_smul_const_left, Pi.add_apply, Pi.sub_apply, Pi.smul_apply]
+  rw [rhs_aux_smulY_const_apply I X hY hZ]
+  -- TODO: clean up this proof!
+  let f : M → ℝ := fun _ ↦ a
+  have : rhs_aux I (a • Y) Z X x = a • rhs_aux I Y Z X x := by
+    trans rhs_aux I (f • Y) Z X x
+    · rfl
+    rw [rhs_aux_smulX I Y (f := f) (Y := Z) (Z := X)]
+    rfl
+  rw [this, rhs_aux_smulZ_const_apply I _ hX hY]
+  -- is there a better abstraction for "Lie bracket conv mode"?
+  have : ⟪Z, mlieBracket I (a • Y) X⟫ x = a • ⟪Z, mlieBracket I Y X⟫ x := by
+    simp_rw [product_apply, mlieBracket_const_smul_left (W := X) hY, inner_smul_right_eq_smul]
+  rw [this]
+  have aux2 : ⟪X, mlieBracket I Z (a • Y)⟫ x = a • ⟪X, mlieBracket I Z Y⟫ x := by
+    simp_rw [product_apply,  mlieBracket_const_smul_right (V := Z) hY, inner_smul_right_eq_smul]
+  rw [aux2]
+  simp
+  ring
+
+variable {I} in
+lemma leviCivitaRhs_smulY_const_apply [CompleteSpace E] {a : ℝ}
+    (hX : MDiffAt (T% X) x) (hY : MDiffAt (T% Y) x) (hZ : MDiffAt (T% Z) x) :
+    leviCivitaRhs I X (a • Y) Z x = a • leviCivitaRhs I X Y Z x := by
+  simp_rw [leviCivitaRhs, Pi.smul_apply]; rw [smul_comm]
+  congr
+  exact leviCivitaRhs'_smulY_const_apply hX hY hZ
+
+variable {I} in
+lemma leviCivitaRhs_smulY_const [CompleteSpace E] {a : ℝ}
+    (hX : MDiff (T% X)) (hY : MDiff (T% Y)) (hZ : MDiff (T% Z)) :
+    leviCivitaRhs I X (a • Y) Z = a • leviCivitaRhs I X Y Z := by
+  ext x
+  exact leviCivitaRhs_smulY_const_apply (hX x) (hY x) (hZ x)
+
+lemma leviCivitaRhs'_smulY_apply [CompleteSpace E] {f : M → ℝ}
+    (hf : MDiffAt f x) (hX : MDiffAt (T% X) x) (hY : MDiffAt (T% Y) x) (hZ : MDiffAt (T% Z) x) :
+    leviCivitaRhs' I X (f • Y) Z x =
+      f x • leviCivitaRhs' I X Y Z x +
+        ((fromTangentSpace _).toFun <| mfderiv% f x (X x)) • 2 * ⟪Y, Z⟫ x := by
+  simp only [leviCivitaRhs']
+  simp_rw [rhs_aux_smulX I Y Z X f]
+  simp only [product_smul_left, Pi.add_apply, Pi.sub_apply, smul_eq_mul, Pi.mul_apply]
+  rw [rhs_aux_smulY_apply I X hf hY hZ, rhs_aux_smulZ_apply I Z hf hX hY]
+  -- TODO: is there a better abstraction for this kind of "Lie bracket conv mode"?
+  have h1 : ⟪Z, mlieBracket I (f • Y) X⟫ x =
+      - (fromTangentSpace _).toFun (((mfderiv% f x) (X x))) • ⟪Z, Y⟫ x
+      + f x • ⟪Z, mlieBracket I Y X⟫ x := by
+    simp_rw [product_apply, mlieBracket_smul_left (W := X) hf hY, inner_add_right]
+    congr
+    · simp only [neg_smul, inner_neg_right, fromTangentSpace, AddHom.toFun_eq_coe, AddHom.coe_mk,
+        smul_eq_mul, neg_mul, neg_inj]
+      rw [real_inner_smul_right]
+      rfl
+    · rw [inner_smul_right_eq_smul]
+  have h2 : ⟪X, mlieBracket I Z (f • Y)⟫ x =
+      (fromTangentSpace _).toFun (((mfderiv% f x) (Z x))) • ⟪X, Y⟫ x
+        + f x • ⟪X, mlieBracket I Z Y⟫ x := by
+    simp_rw [product_apply, mlieBracket_smul_right (V := Z) hf hY, inner_add_right]
+    congr
+    · simp only [fromTangentSpace, AddHom.toFun_eq_coe, AddHom.coe_mk, smul_eq_mul]
+      rw [real_inner_smul_right]
+      rfl
+    · rw [inner_smul_right_eq_smul]
+  rw [h1, h2, product_swap Y Z]
+  set A := rhs_aux I X Y Z x
+  set B := rhs_aux I Y Z X x
+  set C := rhs_aux I Z X Y x
+  set D := ⟪Y, mlieBracket I X Z⟫ x
+  set E := ⟪Z, mlieBracket I Y X⟫ x
+  set F := ⟪X, mlieBracket I Z Y⟫ x
+  set G1 := ⟪Y, Z⟫ x
+  set G2 := ⟪X, Y⟫ x
+  set dfx := (mfderiv I 𝓘(ℝ, ℝ) f x)
+  set H := (fromTangentSpace (f x)) (dfx (X x)) with H_eq
+  set K := (fromTangentSpace (f x)) (dfx (Z x)) with K_eq
+  change f x * A + (fromTangentSpace _).toFun (dfx (X x)) * G1 + f x * B
+    - (f x * C + (fromTangentSpace _).toFun (dfx (Z x)) * G2)
+    - f x * D - (-H * G1 + f x * E) + (K * G2 + f x * F) = _
+  dsimp
+  rw [← H_eq, ← K_eq]
+  ring
+
+lemma leviCivitaRhs_smulY_apply [CompleteSpace E] {f : M → ℝ}
+    (hf : MDiffAt f x) (hX : MDiffAt (T% X) x) (hY : MDiffAt (T% Y) x) (hZ : MDiffAt (T% Z) x) :
+    leviCivitaRhs I X (f • Y) Z x =
+      f x • leviCivitaRhs I X Y Z x
+        + ((fromTangentSpace _).toFun <| mfderiv% f x (X x)) • ⟪Y, Z⟫ x := by
+  simp only [leviCivitaRhs, Pi.smul_apply, leviCivitaRhs'_smulY_apply I hf hX hY hZ]
+  rw [smul_add, smul_comm]
+  congr 1
+  rw [← smul_eq_mul]
+  dsimp
+  field_simp
+
+lemma leviCivitaRhs'_addZ_apply [CompleteSpace E]
+    (hX : MDiffAt (T% X) x) (hY : MDiffAt (T% Y) x)
+    (hZ : MDiffAt (T% Z) x) (hZ' : MDiffAt (T% Z') x) :
+    leviCivitaRhs' I X Y (Z + Z') x =
+      leviCivitaRhs' I X Y Z x + leviCivitaRhs' I X Y Z' x := by
+  simp only [leviCivitaRhs', rhs_aux_addX, Pi.add_apply, Pi.sub_apply, product_add_left_apply]
+  rw [product_congr_right₂ (VectorField.mlieBracket_add_right (V := X) hZ hZ'),
+    product_congr_right₂ (VectorField.mlieBracket_add_left (W := Y) hZ hZ'),
+    rhs_aux_addY_apply, rhs_aux_addZ_apply] <;> try assumption
+  abel
+
+lemma leviCivitaRhs'_addZ [CompleteSpace E]
+    (hX : MDiff (T% X)) (hY : MDiff (T% Y)) (hZ : MDiff (T% Z)) (hZ' : MDiff (T% Z')) :
+    leviCivitaRhs' I X Y (Z + Z') =
+      leviCivitaRhs' I X Y Z + leviCivitaRhs' I X Y Z' := by
+  ext x
+  exact leviCivitaRhs'_addZ_apply I (hX x) (hY x) (hZ x) (hZ' x)
+
+lemma leviCivitaRhs_addZ_apply [CompleteSpace E]
+    (hX : MDiffAt (T% X) x) (hY : MDiffAt (T% Y) x)
+    (hZ : MDiffAt (T% Z) x) (hZ' : MDiffAt (T% Z') x) :
+    leviCivitaRhs I X Y (Z + Z') x = leviCivitaRhs I X Y Z x + leviCivitaRhs I X Y Z' x := by
+  simp [leviCivitaRhs, leviCivitaRhs'_addZ_apply I hX hY hZ hZ', left_distrib]
+
+lemma leviCivitaRhs_addZ [CompleteSpace E]
+    (hX : MDiff (T% X)) (hY : MDiff (T% Y)) (hZ : MDiff (T% Z)) (hZ' : MDiff (T% Z')) :
+    leviCivitaRhs I X Y (Z + Z') = leviCivitaRhs I X Y Z + leviCivitaRhs I X Y Z' := by
+  ext x
+  exact leviCivitaRhs_addZ_apply I (hX x) (hY x) (hZ x) (hZ' x)
+
+lemma leviCivitaRhs'_smulZ_apply [CompleteSpace E] {f : M → ℝ}
+    (hf : MDiffAt f x) (hX : MDiffAt (T% X) x) (hY : MDiffAt (T% Y) x) (hZ : MDiffAt (T% Z) x) :
+    leviCivitaRhs' I X Y (f • Z) x = f x • leviCivitaRhs' I X Y Z x := by
+  simp only [leviCivitaRhs', rhs_aux_smulX, Pi.add_apply, Pi.sub_apply]
+  rw [rhs_aux_smulY_apply _ _ hf hZ hX, rhs_aux_smulZ_apply _ _ hf hY hZ]
+  -- Apply the product rule for the lie bracket.
+  -- Let's encapsulate the going into the product and back out again.
+  have h1 : ⟪Y, mlieBracket I X (f • Z)⟫ x =
+      f x • ⟪Y, mlieBracket I X Z⟫ x + ⟪Y, fromTangentSpace _ (mfderiv% f x (X x)) • Z⟫ x := by
+    rw [product_apply, VectorField.mlieBracket_smul_right hf hZ, inner_add_right, add_comm,
+      inner_smul_right]
+    congr
+  have h2 : letI dfY := fromTangentSpace _ ((mfderiv% f x) (Y x));
+      ⟪X, mlieBracket I (f • Z) Y⟫ x = - dfY • ⟪X, Z⟫ x + f x • ⟪X, mlieBracket I Z Y⟫ x := by
+    rw [product_apply, VectorField.mlieBracket_smul_left hf hZ, inner_add_right, inner_smul_right,
+      inner_smul_right]
+    congr
+  rw [h1, h2, product_smul_left, product_swap X Z]
+  erw [product_smul_right]
+  simp
+  -- set A := rhs_aux I X Y Z x
+  -- set B := rhs_aux I Y Z X x
+  -- set C := rhs_aux I Z X Y x
+  -- set D := ⟪Y, mlieBracket I X Z⟫ x
+  -- set E := ⟪Z, mlieBracket I Y X⟫ x with E_eq
+  -- set F := ⟪X, mlieBracket I Z Y⟫ x
+  -- letI dfX : ℝ := (mfderiv I 𝓘(ℝ, ℝ) f x) (X x)
+  -- set G := dfX * ⟪Y, Z⟫ x
+  -- letI dfY : ℝ := (mfderiv I 𝓘(ℝ, ℝ) f x) (Y x)
+  -- set H := dfY * ⟪X, Z⟫ x
+  ring
+
+lemma leviCivitaRhs'_smulZ [CompleteSpace E] {f : M → ℝ}
+    (hf : MDiff f) (hX : MDiff (T% X)) (hY : MDiff (T% Y)) (hZ : MDiff (T% Z)) :
+    leviCivitaRhs' I X Y (f • Z) = f • leviCivitaRhs' I X Y Z := by
+  ext x
+  exact leviCivitaRhs'_smulZ_apply I (hf x) (hX x) (hY x) (hZ x)
+
+lemma leviCivitaRhs_smulZ [CompleteSpace E] {f : M → ℝ}
+    (hf : MDiff f) (hX : MDiff (T% X)) (hY : MDiff (T% Y)) (hZ : MDiff (T% Z)) :
+    leviCivitaRhs I X Y (f • Z) = f • leviCivitaRhs I X Y Z := by
+  simp only [leviCivitaRhs]
+  rw [smul_comm, leviCivitaRhs'_smulZ I hf hX hY hZ]
+
+lemma leviCivitaRhs_smulZ_apply [CompleteSpace E] {f : M → ℝ}
+    (hf : MDiffAt f x) (hX : MDiffAt (T% X) x) (hY : MDiffAt (T% Y) x) (hZ : MDiffAt (T% Z) x) :
+    leviCivitaRhs I X Y (f • Z) x = f x * leviCivitaRhs I X Y Z x := by
+  simp [leviCivitaRhs, leviCivitaRhs'_smulZ_apply I hf hX hY hZ]
+  ring
+
+end leviCivitaRhs
+
+variable [FiniteDimensional ℝ E] in
+lemma aux (h : cov.IsLeviCivitaConnection) {x : M}
+    (hX : MDiffAt (T% X) x) (hY : MDiffAt (T% Y) x) (hZ : MDiffAt (T% Z) x) : rhs_aux I X Y Z x =
+    ⟪∇ Y, X, Z⟫ x + ⟪Y, ∇ X, Z⟫ x + ⟪Y, VectorField.mlieBracket I X Z⟫ x := by
+  trans ⟪∇ Y, X, Z⟫ x + ⟪Y, ∇ Z, X⟫ x
+  · exact cov.isCompatible_iff.mp h.1 hX hY hZ
+  · simp [← cov.torsion_eq_zero_iff.mp h.2 hX hZ, product, inner_sub_right]
+
+variable {cov} in
+/-- Auxiliary lemma towards the uniquness of the Levi-Civita connection: expressing the term
+⟨∇ X Y, Z⟩ for all differentiable vector fields X, Y and Z, without reference to ∇. -/
+lemma IsLeviCivitaConnection.eq_leviCivitaRhs [FiniteDimensional ℝ E]
+    (h : cov.IsLeviCivitaConnection)
+    {x : M} (hX : MDiffAt (T% X) x) (hY : MDiffAt (T% Y) x) (hZ : MDiffAt (T% Z) x) :
+    ⟪∇ Y, X, Z⟫ x = leviCivitaRhs I X Y Z x := by
+  unfold leviCivitaRhs leviCivitaRhs'
+  have eq1 := aux I cov h hX hY hZ
+  have eq2 := aux I cov h hY hZ hX
+  have eq3 := aux I cov h hZ hX hY
+  simp [real_inner_comm, smul_eq_mul] at *
+  linear_combination - (eq1 + eq2 - eq3) / 2
+
+section
+
+omit [IsManifold I 2 M] [IsContMDiffRiemannianBundle I 1 E (TangentSpace I (M := M))] in
+variable {I} in
+lemma congr_of_forall_product_apply [FiniteDimensional ℝ E] {Y Y' : TangentSpace I x}
+    (h : ∀ Z : TangentSpace I x, inner ℝ Y Z = inner ℝ Y' Z) : Y = Y' := by
+  have : FiniteDimensional ℝ (TangentSpace I x) := inferInstanceAs (FiniteDimensional ℝ E)
+  have : CompleteSpace (TangentSpace I x) := FiniteDimensional.complete ℝ _
+  set Φ := InnerProductSpace.toDual ℝ (TangentSpace I x)
+  apply Φ.injective
+  ext Z₀
+  simpa [Φ, product] using h Z₀
+
+omit [IsContMDiffRiemannianBundle I 1 E (TangentSpace I (M := M))] in
+variable {I} in
+/-- If two vector fields `X` and `X'` on `M` satisfy the relation `⟨X, Z⟩ = ⟨X', Z⟩` for all
+vector fields `Z`, then `X = X'`. XXX up to differentiability? -/
+-- TODO: is this true if E is infinite-dimensional? trace the origin of the `Fintype` assumptions!
+lemma congr_of_forall_product [FiniteDimensional ℝ E]
+    (h : ∀ Z : Π x : M, TangentSpace I x, ⟪X, Z⟫ = ⟪X', Z⟫) : X = X' := by
+  ext1 x
+  apply congr_of_forall_product_apply
+  intro Z₀
+  simpa [product] using congr($(h (extend E Z₀)) x)
+
+/-- The Levi-Civita connection on `(M, g)` is uniquely determined,
+at least on differentiable vector fields. -/
+-- (probably not everywhere, as addition rules apply only for differentiable vector fields?)
+theorem IsLeviCivitaConnection.uniqueness [FiniteDimensional ℝ E]
+    {cov cov' : CovariantDerivative I E (TangentSpace I : M → Type _)}
+    (hcov : cov.IsLeviCivitaConnection) (hcov' : cov'.IsLeviCivitaConnection)
+    {X Y : Π x : M, TangentSpace I x} {x : M}
+    (hX : MDiffAt (T% X) x) (hY : MDiffAt (T% Y) x) :
+    cov Y x (X x) = cov' Y x (X x) := by
+  have : FiniteDimensional ℝ (TangentSpace I x) := inferInstanceAs (FiniteDimensional ℝ E)
+  have : CompleteSpace (TangentSpace I x) := FiniteDimensional.complete ℝ _
+  set Φ := InnerProductSpace.toDual ℝ (TangentSpace I x)
+  apply Φ.injective
+  ext Z₀
+  let Z := extend E Z₀
+  have hZ := mdifferentiableAt_extend I E Z₀
+  suffices inner ℝ (cov Y x (X x)) (Z x) = inner ℝ (cov' Y x (X x)) (Z x) by simpa [Φ, Z]
+  trans leviCivitaRhs I X Y Z x
+  · rw [← hcov.eq_leviCivitaRhs I hX hY hZ]
+  · rw [← hcov'.eq_leviCivitaRhs I hX hY hZ]
+
+open Classical in
+noncomputable def lcAux₀' (Y : Π x : M, TangentSpace I x) (x : M)
+    (X Z : Π x : M, TangentSpace I x) :=
+  if MDiffAt (T% X) x then if MDiffAt (T% Z) x then
+    leviCivitaRhs I X Y Z
+  else 0 else 0
+
+theorem leviCivitaRhs_tensorial₁ [FiniteDimensional ℝ E]
+    {Y : Π x : M, TangentSpace I x} (x : M) (hY : MDiffAt (T% Y) x) (Z : Π x, TangentSpace I x) :
+    TensorialAt I E (lcAux₀' I Y x · Z x) x where
+  smul hf hX := by
+    dsimp [lcAux₀']
+    rw [if_pos hX, if_pos]
+    · split_ifs with hZ
+      · exact leviCivitaRhs_smulX_apply hf hX hY hZ
+      · simp
+    · exact hf.smul_section hX
+  add hX₁ hX₂ := by
+    dsimp [lcAux₀']
+    rw [if_pos hX₁, if_pos hX₂, if_pos]
+    · split_ifs with hZ
+      · exact leviCivitaRhs_addX_apply I hX₁ hX₂ hY hZ
+      · simp
+    · exact mdifferentiableAt_add_section hX₁ hX₂
+
+theorem leviCivitaRhs_tensorial₂ [FiniteDimensional ℝ E]
+    {Y : Π x : M, TangentSpace I x} (x : M) (hY : MDiffAt (T% Y) x) (X : Π x, TangentSpace I x)
+    (hX : MDiffAt (T% X) x) :
+    TensorialAt I E (lcAux₀' I Y x X · x) x where
+  smul hf hZ := by
+    dsimp [lcAux₀']
+    rw [if_pos hX, if_pos hZ, if_pos, if_pos hX]
+    · exact leviCivitaRhs_smulZ_apply I hf hX hY hZ
+    · exact hf.smul_section hZ
+  add hZ₁ hZ₂ := by
+    dsimp [lcAux₀']
+    rw [if_pos hZ₁, if_pos hZ₂, if_pos hX, if_pos, if_pos hX, if_pos hX]
+    · exact leviCivitaRhs_addZ_apply I hX hY hZ₁ hZ₂
+    · exact mdifferentiableAt_add_section hZ₁ hZ₂
+
+open Classical in
+noncomputable def lcAux₀ [FiniteDimensional ℝ E]
+    {Y : Π x : M, TangentSpace I x} (x : M) (hY : MDiffAt (T% Y) x) :
+    TangentSpace I x →L[ℝ] TangentSpace I x →L[ℝ] ℝ :=
+  TensorialAt.mkHom₂ _ (x := x)
+    (fun Z _ ↦ leviCivitaRhs_tensorial₁ _ _ hY Z)
+    (fun X hX ↦ leviCivitaRhs_tensorial₂ _ _ hY X hX)
+
+theorem lcAux₀_apply [FiniteDimensional ℝ E] {x : M}
+    {X : Π x : M, TangentSpace I x} (hX : MDiffAt (T% X) x)
+    {Y : Π x : M, TangentSpace I x} (hY : MDiffAt (T% Y) x)
+    {Z : Π x : M, TangentSpace I x} (hZ : MDiffAt (T% Z) x) :
+    lcAux₀ I x hY (X x) (Z x) = leviCivitaRhs I X Y Z x := by
+  unfold lcAux₀
+  rw [TensorialAt.mkHom₂_apply _ _ hX hZ, lcAux₀', if_pos hX, if_pos hZ]
+
+noncomputable def lcAux₁ [FiniteDimensional ℝ E]
+    {Y : Π x : M, TangentSpace I x} (x : M) (hY : MDiffAt (T% Y) x) :
+    TangentSpace I x →L[ℝ] TangentSpace I x :=
+  -- use the musical isomorphism to produce a candidate ∇ Y as a (1,1)-tensor
+  -- (rather than a 2-tensor)
+  have : FiniteDimensional ℝ (TangentSpace I x) := inferInstanceAs (FiniteDimensional ℝ E)
+  have : CompleteSpace (TangentSpace I x) := FiniteDimensional.complete ℝ _
+  (InnerProductSpace.toDual ℝ _).symm.toContinuousLinearEquiv.toContinuousLinearMap ∘L
+    (lcAux₀ I x hY)
+
+theorem lcAux₁_apply [FiniteDimensional ℝ E] {x : M}
+    {X : Π x : M, TangentSpace I x} (hX : MDiffAt (T% X) x)
+    {Y : Π x : M, TangentSpace I x} (hY : MDiffAt (T% Y) x)
+    {Z : Π x : M, TangentSpace I x} (hZ : MDiffAt (T% Z) x) :
+    inner ℝ (lcAux₁ I x hY (X x)) (Z x) = leviCivitaRhs I X Y Z x := by
+  simpa [lcAux₁] using lcAux₀_apply I hX hY hZ
+
+open Classical in
+noncomputable def lcAux [FiniteDimensional ℝ E]
+    (Y : Π x : M, TangentSpace I x) (x : M) :
+    TangentSpace I x →L[ℝ] TangentSpace I x :=
+  if hY : MDiffAt (T% Y) x then lcAux₁ I x hY else 0
+
+theorem lcAux_apply [FiniteDimensional ℝ E] {x : M}
+    {X : Π x : M, TangentSpace I x} (hX : MDiffAt (T% X) x)
+    {Y : Π x : M, TangentSpace I x} (hY : MDiffAt (T% Y) x)
+    {Z : Π x : M, TangentSpace I x} (hZ : MDiffAt (T% Z) x) :
+    inner ℝ (lcAux I Y x (X x)) (Z x) = leviCivitaRhs I X Y Z x := by
+  unfold lcAux
+  rw [dif_pos hY]
+  simpa [lcAux] using lcAux₁_apply I hX hY hZ
+
+lemma isCovariantDerivativeOn_lcAux [FiniteDimensional ℝ E] :
+    IsCovariantDerivativeOn E (lcAux I (M := M)) where
+  add {Y Y'} x hY hY' _ := by
+    unfold lcAux
+    rw [dif_pos hY, dif_pos hY', dif_pos (mdifferentiableAt_add_section hY hY')]
+    unfold lcAux₁
+    dsimp
+    rw [← ContinuousLinearMap.comp_add]
+    congr! 1
+    simp only [lcAux₀]
+    ext X₀ Y₀
+    simp only [TensorialAt.mkHom₂_apply_eq_extend, ContinuousLinearMap.add_apply, lcAux₀']
+    rw [if_pos, if_pos, if_pos, if_pos, if_pos, if_pos]
+    · exact leviCivitaRhs_addY_apply _ (FiberBundle.mdifferentiableAt_extend ..)
+        hY hY' (FiberBundle.mdifferentiableAt_extend ..)
+    · exact FiberBundle.mdifferentiableAt_extend ..
+    · exact FiberBundle.mdifferentiableAt_extend ..
+    · exact FiberBundle.mdifferentiableAt_extend ..
+    · exact FiberBundle.mdifferentiableAt_extend ..
+    · exact FiberBundle.mdifferentiableAt_extend ..
+    · exact FiberBundle.mdifferentiableAt_extend ..
+  leibniz {Y f x} hY hf _ := by
+    dsimp [lcAux]
+    rw [dif_pos hY, dif_pos]
+    · unfold lcAux₁
+      dsimp
+      rw [← ContinuousLinearMap.comp_smul]
+      have : FiniteDimensional ℝ (TangentSpace I x) := inferInstanceAs (FiniteDimensional ℝ E)
+      have : CompleteSpace (TangentSpace I x) := FiniteDimensional.complete ℝ _
+      set Φ := InnerProductSpace.toDual ℝ (TangentSpace I x)
+      ext X₀
+      apply Φ.injective
+      simp only [ContinuousLinearMap.coe_comp', ContinuousLinearEquiv.coe_coe,
+        LinearIsometryEquiv.coe_symm_toContinuousLinearEquiv, comp_apply,
+        LinearIsometryEquiv.apply_symm_apply, ContinuousLinearMap.comp_smulₛₗ, RingHom.id_apply,
+        ContinuousLinearMap.add_apply, ContinuousLinearMap.coe_smul', Pi.smul_apply,
+        map_add, map_smul]
+      ext Z₀
+      simp only [lcAux₀, lcAux₀', TensorialAt.mkHom₂_apply_eq_extend,
+        ContinuousLinearMap.add_apply, ContinuousLinearMap.coe_smul', Pi.smul_apply, smul_eq_mul]
+      rw [if_pos, if_pos, if_pos, if_pos]
+      · convert leviCivitaRhs_smulY_apply I hf (FiberBundle.mdifferentiableAt_extend I E X₀) hY
+          (FiberBundle.mdifferentiableAt_extend I E Z₀)
+        simp [Φ, product]
+      · exact FiberBundle.mdifferentiableAt_extend ..
+      · exact FiberBundle.mdifferentiableAt_extend ..
+      · exact FiberBundle.mdifferentiableAt_extend ..
+      · exact FiberBundle.mdifferentiableAt_extend ..
+    exact MDifferentiableAt.smul_section hf hY
+
+end
+
+-- TODO: make g part of the notation!
+variable (M) in
+/-- A choice of Levi-Civita connection on the tangent bundle `TM` of a Riemannian manifold `(M, g)`:
+this is unique up to the value on non-differentiable vector fields.
+If you know the Levi-Civita connection already, you can use `IsLeviCivitaConnection` instead. -/
+noncomputable def LeviCivitaConnection [FiniteDimensional ℝ E] :
+    CovariantDerivative I E (TangentSpace I : M → Type _) where
+  toFun := lcAux I
+  isCovariantDerivativeOnUniv := isCovariantDerivativeOn_lcAux I
+
+theorem leviCivitaConnection_apply [FiniteDimensional ℝ E] {x : M}
+    {X : Π x : M, TangentSpace I x} (hX : MDiffAt (T% X) x)
+    {Y : Π x : M, TangentSpace I x} (hY : MDiffAt (T% Y) x)
+    {Z : Π x : M, TangentSpace I x} (hZ : MDiffAt (T% Z) x) :
+    inner ℝ (LeviCivitaConnection I M Y x (X x)) (Z x) = leviCivitaRhs I X Y Z x :=
+  lcAux_apply _ hX hY hZ
+
+-- Side computation for `leviCivitaConnection_isCompatible`.
+omit [IsManifold I 2 M] in
+lemma leviCivitaConnection_isCompatible_aux
+    {x : M} {X Y Z : (x : M) → TangentSpace I x} :
+    leviCivitaRhs I X Y Z x + leviCivitaRhs I X Z Y x =
+    fromTangentSpace _ ((mfderiv% fun x ↦ inner ℝ (Y x) (Z x)) x (X x)) := by
+  simp only [leviCivitaRhs, Pi.smul_apply, ← smul_add,  leviCivitaRhs']
+  -- Normalise the expressions by swapping arguments for rhs_aux and mlieBracket,
+  -- until the swappable arguments are in order X < Y < Z.
+  rw [rhs_aux_swap I Z Y, rhs_aux_swap I Z X, rhs_aux_swap I Y X,
+    VectorField.mlieBracket_swap (V := Z) (W := Y),
+    VectorField.mlieBracket_swap (V := Y) (W := X),
+    VectorField.mlieBracket_swap (V := Z) (W := X)]
+  -- Observe that the right hand side is rhx_aux X Y Z; then we just need to simplify and rearrange.
+  trans 1 / 2 * (rhs_aux I X Y Z x + rhs_aux I X Y Z x)
+  · simp
+    abel
+  · rw [← two_mul, ← mul_assoc, one_div, inv_mul_cancel₀ (by simp), one_mul]
+    rfl
+
+-- Why is everything so slow?
+lemma leviCivitaConnection_isCompatible [FiniteDimensional ℝ E] :
+    (LeviCivitaConnection I M).IsCompatible := by
+  rw [isCompatible_iff]
+  intro x X Y Z hX hY hZ
+  symm
+  unfold product
+  dsimp
+  rw [leviCivitaConnection_apply I hX hY hZ]
+  have : inner ℝ (Y x) (((LeviCivitaConnection I M) Z x) (X x)) =
+      inner ℝ (((LeviCivitaConnection I M) Z x) (X x)) (Y x) := by
+    rw [real_inner_comm]
+  -- TODO: why does the following line not work, but `rw [this]` does?
+  --rw [real_inner_comm]
+  rw [this]
+  have : inner ℝ (((LeviCivitaConnection I M) Z x) (X x)) (Y x) = leviCivitaRhs I X Z Y x := by
+    rw [leviCivitaConnection_apply I hX hZ hY]
+  rw [leviCivitaConnection_apply I hX hZ hY, leviCivitaConnection_isCompatible_aux]
+
+lemma leviCivitaConnection_torsion_eq_zero [FiniteDimensional ℝ E] :
+    (LeviCivitaConnection I M).torsion = 0 := by
+  have a := (LeviCivitaConnection I M).isCovariantDerivativeOnUniv
+  rw [CovariantDerivative.torsion_eq_zero_iff]
+  intro X Y x hX hY
+  apply congr_of_forall_product_apply
+  intro Z
+  trans (inner ℝ (((LeviCivitaConnection I M) Y x) (X x)) Z) -
+    (inner ℝ (((LeviCivitaConnection I M) X x) (Y x)) Z)
+  · apply inner_sub_left
+  have hZ' : extend E Z x = Z := extend_apply_self E Z
+  rw [← hZ']
+  rw [leviCivitaConnection_apply I hY hX (mdifferentiableAt_extend ..)]
+  rw [leviCivitaConnection_apply I hX hY (mdifferentiableAt_extend ..)]
+  simp only [leviCivitaRhs_apply]
+  -- XXX: should there be leviCivitaRhs'_apply?
+  simp only [leviCivitaRhs', Pi.add_apply, Pi.sub_apply, product_apply]
+  simp only [VectorField.mlieBracket_swap (V := Y) (W := X)]
+  simp only [Pi.neg_apply, inner_neg_right, sub_neg_eq_add]
+  set C := inner ℝ Z (VectorField.mlieBracket I X Y x)
+  set Z' := extend E Z
+  simp only [VectorField.mlieBracket_swap (V := Z') (W := X)]
+  simp only [VectorField.mlieBracket_swap (V := Z') (W := Y)]
+  simp only [Pi.neg_apply, inner_neg_right]
+  rw [rhs_aux_swap (Y := Z'), rhs_aux_swap (Y := Z'), rhs_aux_swap (X := Z')]
+  rw [real_inner_comm (Z' x) (VectorField.mlieBracket I X Y x)]
+  -- set A := inner ℝ (Z' x) (VectorField.mlieBracket I X Y x)
+  -- set B := inner ℝ (Y x) (VectorField.mlieBracket I X Z' x)
+  -- set C := inner ℝ (X x) (VectorField.mlieBracket I Y Z' x)
+  -- set D := rhs_aux I X Y Z' x
+  -- set E := rhs_aux I Y X Z' x
+  -- set F := rhs_aux I Z' X Y x
+  match_scalars <;> simp
+  norm_num
+
+/-- `LeviCivitaConnection` is a Levi-Civita connection (i.e., compatible and torsion-free) -/
+lemma leviCivitaConnection_isLeviCivitaConnection [FiniteDimensional ℝ E] :
+    (LeviCivitaConnection I M).IsLeviCivitaConnection :=
+  ⟨leviCivitaConnection_isCompatible I, leviCivitaConnection_torsion_eq_zero I⟩
+
+end CovariantDerivative
diff --git a/Mathlib/Geometry/Manifold/VectorBundle/CovariantDerivative/Lift.lean b/Mathlib/Geometry/Manifold/VectorBundle/CovariantDerivative/Lift.lean
new file mode 100644
index 00000000000000..3fd2e5a3696bab
--- /dev/null
+++ b/Mathlib/Geometry/Manifold/VectorBundle/CovariantDerivative/Lift.lean
@@ -0,0 +1,196 @@
+/-
+Copyright (c) 2025 Patrick Massot. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Heather Macbeth, Patrick Massot, Michael Rothgang
+-/
+module
+
+public import Mathlib.Geometry.Manifold.VectorBundle.CovariantDerivative.Ehresmann
+
+/-!
+# Lifting vectors using covariant derivatives
+
+TODO: add a more complete doc-string
+
+-/
+
+@[expose] public section
+
+open Bundle Filter Module Topology Set
+
+open scoped Bundle Manifold ContDiff
+
+section
+variable
+  {𝕜 : Type*} [NontriviallyNormedField 𝕜] [CompleteSpace 𝕜]
+  {E : Type*} [NormedAddCommGroup E] [NormedSpace 𝕜 E]
+  {H : Type*} [TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type*} [TopologicalSpace M]
+  [ChartedSpace H M] {F : Type*} [NormedAddCommGroup F] [NormedSpace 𝕜 F]
+  [FiniteDimensional 𝕜 F] [IsManifold I 1 M]
+  {cov : (M → F) → (Π x : M, TangentSpace I x →L[𝕜] F)}
+  {s : Set M} (hcov : IsCovariantDerivativeOn F cov s)
+
+
+noncomputable
+def IsCovariantDerivativeOn.lift_vec (x : M) (f : F) :
+    TangentSpace I x →L[𝕜] TangentSpace I x × F :=
+  .prod (.id 𝕜 _) (-hcov.one_form x f)
+
+@[simp]
+lemma IsCovariantDerivativeOn.lift_vec_apply (x : M) (f : F) (u : TangentSpace I x) :
+    hcov.lift_vec x f u = (u , -hcov.one_form x f u) :=
+  rfl
+
+@[simp]
+lemma IsCovariantDerivativeOn.fst_comp_lift_vec (x : M) (f : F) :
+    .fst 𝕜 _ _ ∘L hcov.lift_vec x f = .id 𝕜 _ := by
+  ext u
+  simp
+
+@[simp]
+lemma IsCovariantDerivativeOn.projection_lift_vec (x : M) (f : F) :
+    (hcov.projection x f) ∘L (hcov.lift_vec x f) = 0 := by
+  ext u
+  simp
+
+lemma IsCovariantDerivativeOn.lift_vec_mem_horiz (x : M) (f : F) (u : TangentSpace I x) :
+    hcov.lift_vec x f u ∈ hcov.horiz x f := by
+  rw [horiz]
+  simp
+
+lemma IsCovariantDerivativeOn.lift_vec_eq_iff
+  {x : M} {f : F} {u : TangentSpace I x} {w : TangentSpace I x × F} :
+    hcov.lift_vec x f u = w ↔ hcov.projection x f w = 0 ∧ w.1 = u := by
+  constructor
+  · intro rfl
+    simp
+  · rcases w with ⟨a, b⟩
+    rintro ⟨h, rfl⟩
+    simp_all
+    grind
+
+end
+
+section
+variable
+  {𝕜 : Type*} [NontriviallyNormedField 𝕜] [CompleteSpace 𝕜]
+  {E : Type*} [NormedAddCommGroup E] [NormedSpace 𝕜 E]
+  {H : Type*} [TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type*} [TopologicalSpace M]
+  [ChartedSpace H M] {F : Type*} [NormedAddCommGroup F] [NormedSpace 𝕜 F] {V : M → Type*}
+  [TopologicalSpace (TotalSpace F V)] [(x : M) → AddCommGroup (V x)] [(x : M) → Module 𝕜 (V x)]
+  [(x : M) → TopologicalSpace (V x)] [FiberBundle F V]
+  [∀ (x : M), IsTopologicalAddGroup (V x)] [∀ (x : M), ContinuousSMul 𝕜 (V x)]
+  [FiniteDimensional 𝕜 F]
+  [IsManifold I 1 M] [VectorBundle 𝕜 F V] {cov : CovariantDerivative I F V}
+  [ContMDiffVectorBundle 1 F V I]
+
+/-- Horizontal lift of a vector tangent to the base at a point in the corresponding fiber. -/
+noncomputable
+def CovariantDerivative.lift_vec (v : TotalSpace F V) :
+    TangentSpace I v.proj →L[𝕜] TangentSpace (I.prod 𝓘(𝕜, F)) v :=
+  letI t := trivializationAt F V v.proj
+  have hcov := cov.isCovariantDerivativeOn_pushCovDer t
+  letI tlift := hcov.lift_vec v.proj (t v).2
+  t.derivInv I v ∘L tlift
+
+lemma CovariantDerivative.lift_vec_apply {v : TotalSpace F V} (u : TangentSpace I v.proj) :
+    letI t := trivializationAt F V v.proj
+    haveI hcov := cov.isCovariantDerivativeOn_pushCovDer t
+    letI tlift := hcov.lift_vec v.proj (t v).2
+    cov.lift_vec v u = t.derivInv I v (tlift u) := rfl
+
+@[simp]
+lemma CovariantDerivative.lift_vec_mem_horiz {v : TotalSpace F V} (u : TangentSpace I v.proj) :
+    cov.lift_vec v u ∈ cov.horiz v := by
+  let t := trivializationAt F V v.proj
+  have hcov := cov.isCovariantDerivativeOn_pushCovDer t
+  let tlift := hcov.lift_vec v.proj (t v).2
+  rw [lift_vec_apply, CovariantDerivative.mem_horiz_iff_proj]
+  -- TODO: cleanup
+  simp only [proj, IsCovariantDerivativeOn.lift_vec_apply, ContinuousLinearMap.coe_comp',
+             Trivialization.symmL_apply, Function.comp_apply]
+  rw [t.deriv_derivInv_apply (FiberBundle.mem_baseSet_trivializationAt' v.proj)]
+  suffices t.symm v.proj 0 = 0 by simpa
+  exact (t.symmL 𝕜 v.proj).map_zero
+
+@[simp]
+lemma CovariantDerivative.proj_lift_vec {v : TotalSpace F V} (u : TangentSpace I v.proj) :
+    cov.proj v (cov.lift_vec v u) = 0 := by
+  rw [← cov.mem_horiz_iff_proj]
+  exact lift_vec_mem_horiz u
+
+@[simp]
+lemma CovariantDerivative.mfderiv_proj_lift_vec {v : TotalSpace F V} (u : TangentSpace I v.proj) :
+    mfderiv (I.prod 𝓘(𝕜, F)) I TotalSpace.proj v (cov.lift_vec v u) = u := by
+  unfold CovariantDerivative.lift_vec
+  simp [FiberBundle.mem_baseSet_trivializationAt' v.proj]
+
+lemma CovariantDerivative.lift_vec_eq_iff {v : TotalSpace F V} (u : TangentSpace I v.proj)
+    (w : TangentSpace (I.prod 𝓘(𝕜, F)) v) :
+    cov.lift_vec v u = w  ↔
+      cov.proj v w = 0 ∧
+      mfderiv (I.prod 𝓘(𝕜, F)) I (TotalSpace.proj : TotalSpace F V → M) v w = u := by
+  constructor
+  · rintro rfl
+    simp
+  · rintro ⟨h, h'⟩
+    let t := trivializationAt F V v.proj
+    have hcov := cov.isCovariantDerivativeOn_pushCovDer t
+    have mem := FiberBundle.mem_baseSet_trivializationAt F V v.proj
+    apply (t.bijective_deriv mem).1
+    unfold CovariantDerivative.lift_vec
+    simp only [ContinuousLinearMap.coe_comp', Function.comp_apply]
+    rw [t.deriv_derivInv_apply mem]
+    rw [hcov.lift_vec_eq_iff]
+    constructor
+    · change t.symm v.proj ((hcov.projection v.proj (t v).2) ((t.deriv I v) w)) = 0 at h
+      apply t.injective_symm mem
+      refold_let t
+      simp [h, t.symm_map_zero 𝕜]
+    · rw [← h', t.mfderiv_proj_fst_deriv mem]
+
+lemma CovariantDerivative.lift_vec_eq_iff' {v : TotalSpace F V} (u : TangentSpace I v.proj)
+    (w : TangentSpace (I.prod 𝓘(𝕜, F)) v) :
+    cov.lift_vec v u = w  ↔
+      w ∈ cov.horiz v ∧
+      mfderiv (I.prod 𝓘(𝕜, F)) I (TotalSpace.proj : TotalSpace F V → M) v w = u := by
+  simp [CovariantDerivative.lift_vec_eq_iff, horiz]
+
+/-- We can compute `lift_vec v` using any trivialization whose
+base set contains `v.proj`. This is crucial to prove smoothness
+of `lift_vec`. -/
+lemma CovariantDerivative.lift_vec_eq [FiniteDimensional 𝕜 E] {v : TotalSpace F V}
+    {e : Trivialization F TotalSpace.proj} [MemTrivializationAtlas e]
+    (hv : v.proj ∈ e.baseSet)
+    (u : TangentSpace I v.proj) :
+    haveI hcov := cov.isCovariantDerivativeOn_pushCovDer e
+    cov.lift_vec v u = e.derivInv I v (hcov.lift_vec v.proj (e v).2 u) := by
+  apply (cov.lift_vec_eq_iff' _ _).mpr ⟨?_, ?_⟩
+  · rw [cov.mem_horiz_iff_exists]
+    have hcov := cov.isCovariantDerivativeOn_pushCovDer e
+    have := hcov.lift_vec_mem_horiz v.proj (e v).2 u
+    rw [hcov.mem_horiz_iff_exists] at this
+    have proj_lift : (hcov.lift_vec v.proj (e v).2 u).1 = u := by simp
+    rcases this with ⟨s, sdiff, sval, mfderivs, covs⟩
+    -- TODO: cleanup the proof below and see how to factor stuff in
+    -- `CovariantDerivative.mem_horiz_iff_exists`
+    use e.funToSec s, ?_, ?_, ?_, ?_
+    · exact e.mdifferentiableAt_funToSec hv sdiff
+    · simp [sval, hv]
+    · rw [e.mfderiv_total_funToSec sdiff hv]
+      simp only [TotalSpace.proj_mk', ContinuousLinearMap.coe_comp', Function.comp_apply,
+                 ContinuousLinearMap.prod_apply, ContinuousLinearMap.coe_id', id_eq]
+      congr 2
+      · simp [e.funToSec_proj_eq hv sval]
+      · simp [e.mfderiv_proj_fst_deriv, hv]
+      · simp only [hv, e.mfderiv_proj_derivInv_apply, ContinuousLinearMap.coe_neg,
+                   LinearMap.neg_apply, ContinuousLinearMap.coe_coe]
+        rw [proj_lift] at mfderivs ⊢
+        erw [mfderivs]
+        simp
+    · rw [proj_lift] at covs
+      simp [e.pushCovDer_funToSec cov, e.mfderiv_proj_fst_deriv hv, e.deriv_derivInv_apply hv, covs,
+            e.symm_map_zero 𝕜]
+  · simp [hv]
+
+end
diff --git a/Mathlib/Geometry/Manifold/VectorBundle/CovariantDerivative/Metric.lean b/Mathlib/Geometry/Manifold/VectorBundle/CovariantDerivative/Metric.lean
new file mode 100644
index 00000000000000..7f9e7ae75a2757
--- /dev/null
+++ b/Mathlib/Geometry/Manifold/VectorBundle/CovariantDerivative/Metric.lean
@@ -0,0 +1,291 @@
+/-
+Copyright (c) 2025 Michael Rothgang. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Patrick Massot, Michael Rothgang, Heather Macbeth
+-/
+module
+
+public import Mathlib.Geometry.Manifold.VectorBundle.CovariantDerivative.Basic
+public import Mathlib.Geometry.Manifold.VectorBundle.Riemannian
+public import Mathlib.Geometry.Manifold.MFDeriv.NormedSpace
+
+/-! # Metric connections
+
+This file defines connections on a Riemannian vector bundle which are compatible with the ambient
+metric. A bundled connection `∇` on a Riemannian vector bundle `(V, g)` is compatible with the
+metric `g` if and only if the differentiated metric tensor `∇ g` (defined by
+`(X, σ, τ) ↦ ∇_X g(σ, τ) - g(∇_X σ, τ) - g(σ, ∇_X τ)`) vanishes on all differentiable vector fields
+`X` and differentiable sections `σ`, `τ`.
+
+## Main definitions and results
+
+* `CovariantDerivative.compatibilityTensor`: the tensor
+  `(X, σ, τ) ↦ X g(σ, τ) - g(∇_X σ, τ) - g(σ, ∇_X τ)` defining when a connection `∇` on a Riemannian
+  vector bundle `(V, g)` is compatible with the metric `g`.
+* `CovariantDerivative.compatibilityTensor_apply` and
+  `CovariantDerivative.compatibilityTensor_apply` give formulas for applying the compatibility
+  tensor at `x` to vector fields and sections which are differentiable at `x`,
+  resp. to extensions of tangent vectors and sections at `x` to differentiable vector fields and
+  sections near `x`.
+* `CovariantDerivative.IsCompatible`: predicate for a connection to be metric, namely that
+  `∇` is metric iff its `compatibilityTensor` vanishes
+
+## TODO
+
+* When Mathlib has a notion of parallel transport, prove the equivalence of
+ `CovariantDerivative.IsCompatible` with the characterisation that parallel transport be an
+  isometry.
+
+* Given connections on bundles `V` and `W`, there is an induced connnection on the bundle Hom(V, W).
+  When this induced connection has been defined in Mathlib, rephrase the definition of
+  `CovariantDerivative.compatibilityTensor`, to be simply the covariant derivative of the metric
+  tensor (considered as a section of Hom(V, Hom(V, ℝ))).
+
+-/
+open Bundle NormedSpace
+open scoped Manifold ContDiff
+
+@[expose] public section
+
+-- TODO: revisit and fix this once the dust has settled
+set_option backward.isDefEq.respectTransparency false
+
+variable
+  -- Let `M` be a `C^k` real manifold modeled on `(E, H)`
+  {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
+  {H : Type*} [TopologicalSpace H] (I : ModelWithCorners ℝ E H)
+  {M : Type*} [TopologicalSpace M] [ChartedSpace H M]
+  -- Let `V` be a bundle over `M`, endowed with a Riemannian metric.
+  (F : Type*) [NormedAddCommGroup F] [NormedSpace ℝ F]
+  {V : M → Type*} [TopologicalSpace (TotalSpace F V)]
+  [∀ x, AddCommGroup (V x)] [∀ x, Module ℝ (V x)]
+  [∀ x : M, TopologicalSpace (V x)]
+  [∀ x, IsTopologicalAddGroup (V x)] [∀ x, ContinuousSMul ℝ (V x)]
+  [FiberBundle F V] [RiemannianBundle V]
+
+/-! # Compatible connections
+
+A connection on `V` is compatible with the metric on `V` iff `X ⟨σ, τ⟩ = ⟨∇_X σ, τ⟩ + ⟨σ, ∇_X τ⟩`
+holds for all sufficiently nice vector fields `X` on `M` and sections `σ`, `τ` of `V`.
+The left hand side is the pushforward of the function `⟨σ, τ⟩` along the vector field `X`:
+the left hand side at `x` is `df(X x)`, where `f := ⟨σ, τ⟩` (ie. `X` is seen a derivation on
+the algebra of function on the base manifold acting on the function `⟨σ, τ⟩`).
+In our definition, we ask for this identity to at each `x : M`, whenever `X`, `σ` and `τ` are
+differentiable at `x`.
+-/
+
+variable {σ σ' σ'' τ τ' τ'' : Π x : M, V x}
+
+-- set_option trace.profiler true
+-- set_option profiler.threshold 500
+
+/-- The scalar product of two sections. -/
+noncomputable abbrev product (σ τ : Π x : M, V x) : M → ℝ :=
+  fun x ↦ inner ℝ (σ x) (τ x)
+
+-- `product` is C^k if σ and τ are: this is shown in `Riemannian.lean`
+
+local notation "⟪" σ ", " τ "⟫" => product σ τ
+
+-- Basic API for the product of two sections.
+section product
+
+omit [TopologicalSpace M]
+
+lemma product_apply (x) : ⟪σ, τ⟫ x = inner ℝ (σ x) (τ x) := rfl
+
+variable (σ σ' τ)
+
+lemma product_swap : ⟪τ, σ⟫ = ⟪σ, τ⟫ := by
+  ext x
+  apply real_inner_comm
+
+@[simp]
+lemma product_zero_left : ⟪0, σ⟫ = 0 := by
+  ext x
+  simp only [product, Pi.zero_apply, inner_zero_left]
+
+@[simp]
+lemma product_zero_right : ⟪σ, 0⟫ = 0 := by rw [product_swap, product_zero_left]
+
+lemma product_add_left : ⟪σ + σ', τ⟫ = ⟪σ, τ⟫ + ⟪σ', τ⟫ := by
+  ext x
+  simp [product, InnerProductSpace.add_left]
+
+@[simp]
+lemma product_add_left_apply (x) : ⟪σ + σ', τ⟫ x = ⟪σ, τ⟫ x + ⟪σ', τ⟫ x := by
+  simp [product, InnerProductSpace.add_left]
+
+lemma product_add_right : ⟪σ, τ + τ'⟫ = ⟪σ, τ⟫ + ⟪σ, τ'⟫ := by
+  rw [product_swap, product_swap τ, product_swap τ', product_add_left]
+
+@[simp]
+lemma product_add_right_apply (x) : ⟪σ, τ + τ'⟫ x = ⟪σ, τ⟫ x + ⟪σ, τ'⟫ x := by
+  rw [product_swap, product_swap τ, product_swap τ', product_add_left_apply]
+
+@[simp] lemma product_neg_left : ⟪-σ, τ⟫ = -⟪σ, τ⟫ := by ext x; simp [product]
+
+@[simp] lemma product_neg_right : ⟪σ, -τ⟫ = -⟪σ, τ⟫ := by ext x; simp [product]
+
+lemma product_sub_left : ⟪σ - σ', τ⟫ = ⟪σ, τ⟫ - ⟪σ', τ⟫ := by
+  ext x
+  simp [product, inner_sub_left]
+
+lemma product_sub_right : ⟪σ, τ - τ'⟫ = ⟪σ, τ⟫ - ⟪σ, τ'⟫ := by
+  ext x
+  simp [product, inner_sub_right]
+
+lemma product_smul_left (f : M → ℝ) : product (f • σ) τ = f • product σ τ := by
+  ext x
+  simp [product, real_inner_smul_left]
+
+@[simp]
+lemma product_smul_const_left (a : ℝ) : product (a • σ) τ = a • product σ τ := by
+  ext x
+  simp [product, real_inner_smul_left]
+
+lemma product_smul_right (f : M → ℝ) : product σ (f • τ) = f • product σ τ := by
+  ext x
+  simp [product, real_inner_smul_right]
+
+@[simp]
+lemma product_smul_const_right (a : ℝ) : product σ (a • τ) = a • product σ τ := by
+  ext x
+  simp [product, real_inner_smul_right]
+
+end product
+
+-- These lemmas are necessary as my Lie bracket identities (assuming minimal differentiability)
+-- only hold point-wise. They abstract the expanding and unexpanding of `product`.
+omit [TopologicalSpace M] in
+lemma product_congr_left {x} (h : σ x = σ' x) : product σ τ x = product σ' τ x := by
+  rw [product_apply, h, ← product_apply]
+
+omit [TopologicalSpace M] in
+lemma product_congr_left₂ {x} (h : σ x = σ' x + σ'' x) :
+    product σ τ x = product σ' τ x + product σ'' τ x := by
+  rw [product_apply, h, inner_add_left, ← product_apply]
+omit [TopologicalSpace M] in
+lemma product_congr_right {x} (h : τ x = τ' x) : product σ τ x = product σ τ' x := by
+  rw [product_apply, h, ← product_apply]
+
+omit [TopologicalSpace M] in
+lemma product_congr_right₂ {x} (h : τ x = τ' x + τ'' x) :
+    product σ τ x = product σ τ' x + product σ τ'' x := by
+  rw [product_apply, h, inner_add_right, ← product_apply]
+
+namespace CovariantDerivative
+
+-- Let `cov` be a covariant derivative on `V`.
+-- TODO: include in cheat sheet!
+variable (cov : CovariantDerivative I F V)
+
+
+/-- Local notation for a covariant derivative on a vector bundle acting on a vector field and a
+section. -/
+local syntax "∇" term:arg term : term
+local macro_rules | `(∇ $X $σ) => `(fun (x : M) ↦ cov $σ x ($X x))
+
+variable {F}
+
+/-- The function defining the compatibility tensor for `∇` w.r.t. `g`:
+prefer using `compatibilityTensor` instead -/
+noncomputable def compatibilityTensorAux (σ τ : Π x : M, V x) :
+    Π (x : M), TangentSpace I x →L[ℝ] ℝ := fun x ↦
+  (NormedSpace.fromTangentSpace _).toContinuousLinearMap ∘L mfderiv% ⟪σ, τ⟫ x
+  - ((innerSL ℝ (τ x)) ∘L (cov σ x)) - ((innerSL ℝ (σ x)) ∘L (cov τ x))
+
+lemma compatibilityTensorAux_apply (σ τ : Π x : M, V x)
+    {x : M} (X₀ : TangentSpace I x) :
+    compatibilityTensorAux I cov σ τ x X₀ =
+      NormedSpace.fromTangentSpace _ (mfderiv% ⟪σ, τ⟫ x X₀)
+      - inner ℝ (cov σ x X₀) (τ x) - inner ℝ (σ x) (cov τ x X₀) := by
+  rw [real_inner_comm]
+  rfl
+
+variable [VectorBundle ℝ F V] [IsContMDiffRiemannianBundle I 1 F V] {x : M}
+
+theorem compatibilityTensorAux_tensorial₁ (τ : Π x, V x) (hτ : MDiffAt (T% τ) x) :
+    TensorialAt I F (compatibilityTensorAux I cov · τ x) x where
+  smul hf hσ := by
+    ext X₀
+    rw [compatibilityTensorAux_apply, product_smul_left,
+      fromTangentSpace_mfderiv_smul_apply hf (hσ.inner_bundle hτ)]
+    simp [compatibilityTensorAux_apply, cov.isCovariantDerivativeOn.leibniz hσ hf, inner_add_left,
+      inner_smul_left]
+    ring
+  add hσ hσ' := by
+    ext X₀
+    rw [compatibilityTensorAux_apply, product_add_left,
+      fromTangentSpace_mfderiv_add_apply (hσ.inner_bundle hτ) (hσ'.inner_bundle hτ)]
+    simp [compatibilityTensorAux_apply, cov.isCovariantDerivativeOn.add hσ hσ', inner_add_left]
+    abel
+
+theorem compatibilityTensorAux_tensorial₂ (σ : Π x, V x) (hσ : MDiffAt (T% σ) x) :
+    TensorialAt I F (compatibilityTensorAux I cov σ · x) x where
+  smul hf hτ := by
+    ext X₀
+    rw [compatibilityTensorAux_apply, product_smul_right,
+      fromTangentSpace_mfderiv_smul_apply hf (hσ.inner_bundle hτ)]
+    simp [compatibilityTensorAux_apply, cov.isCovariantDerivativeOn.leibniz hτ hf, inner_add_right,
+      inner_smul_right]
+    ring
+  add hτ hτ' := by
+    ext X₀
+    rw [compatibilityTensorAux_apply, product_add_right,
+      fromTangentSpace_mfderiv_add_apply (hσ.inner_bundle hτ) (hσ.inner_bundle hτ')]
+    simp [compatibilityTensorAux_apply, cov.isCovariantDerivativeOn.add hτ hτ', inner_add_right]
+    abel
+
+variable {I} [ContMDiffVectorBundle 1 F V I] in
+/-- The tensor `(X, σ, τ) ↦ X g(σ, τ) - g(∇_X σ, τ) - g(σ, ∇_X τ)` defining when a connection
+`∇` on a Riemannian bundle `(M, V)` is compatible with the metric `g`. -/
+@[no_expose] noncomputable def compatibilityTensor [FiniteDimensional ℝ F] (x : M) :
+    V x →L[ℝ] V x →L[ℝ] (TangentSpace I x →L[ℝ] ℝ) :=
+  TensorialAt.mkHom₂ (compatibilityTensorAux I cov · · x) _
+    (compatibilityTensorAux_tensorial₁ I cov) (compatibilityTensorAux_tensorial₂ I cov)
+
+variable {X : Π x : M, TangentSpace I x}
+
+variable {I} [ContMDiffVectorBundle 1 F V I] in
+theorem compatibilityTensor_apply [FiniteDimensional ℝ F] (x : M)
+    (hσ : MDiffAt (T% σ) x) (hτ : MDiffAt (T% τ) x) :
+    cov.compatibilityTensor x (σ x) (τ x) (X x) =
+    fromTangentSpace _ (mfderiv% ⟪σ, τ⟫ x (X x)) - ⟪∇ X σ, τ⟫ x - ⟪σ, ∇ X τ⟫ x := by
+  unfold compatibilityTensor
+  rw [TensorialAt.mkHom₂_apply _ _ hσ hτ, compatibilityTensorAux_apply]
+
+variable {I} [ContMDiffVectorBundle 1 F V I] in
+theorem compatibilityTensor_apply_eq_extend [FiniteDimensional ℝ F] (X₀ : TangentSpace I x)
+    (σ₀ τ₀ : V x) :
+    cov.compatibilityTensor x σ₀ τ₀ X₀ =
+      fromTangentSpace _ (mfderiv% ⟪(FiberBundle.extend F σ₀), (FiberBundle.extend F τ₀)⟫ x X₀)
+        - inner ℝ (cov (FiberBundle.extend F σ₀) x X₀) τ₀
+        - inner ℝ σ₀ (cov (FiberBundle.extend F τ₀) x X₀) := by
+  simp [compatibilityTensor, TensorialAt.mkHom₂_apply_eq_extend, compatibilityTensorAux_apply]
+
+variable {I} [ContMDiffVectorBundle 1 F V I] in
+/-- Predicate saying that a connection `∇` on a Riemannian bundle `(V, g)` is compatible with the
+ambient metric, i.e. for all differentiable vector fields `X` on `M` and sections `σ` and `τ` of
+`V`, we have `X ⟨σ, τ⟩ = ⟨∇_X σ, τ⟩ + ⟨σ, ∇_X τ⟩`. -/
+def IsCompatible [FiniteDimensional ℝ F] : Prop := compatibilityTensor cov = 0
+
+variable {I} [IsManifold I 1 M] [ContMDiffVectorBundle 1 F V I]
+
+lemma isCompatible_iff [FiniteDimensional ℝ F] :
+    cov.IsCompatible ↔ ∀ {x : M} {X : Π x, TangentSpace I x} {σ τ : (x : M) → V x},
+      MDiffAt (T% X) x → MDiffAt (T% σ) x → MDiffAt (T% τ) x →
+      fromTangentSpace _ (mfderiv% ⟪σ, τ⟫ x (X x)) = ⟪∇ X σ, τ⟫ x + ⟪σ, ∇ X τ⟫ x := by
+  refine ⟨fun hcov x X σ τ hX hσ hτ ↦ ?_, fun h ↦ ?_⟩
+  · have H := congr($hcov x (σ x) (τ x) (X x))
+    simp [compatibilityTensor_apply _ _ hσ hτ] at H
+    linear_combination H
+  ext x σ₀ τ₀ X₀
+  rw [compatibilityTensor_apply_eq_extend]
+  have h' := h (FiberBundle.mdifferentiableAt_extend I E X₀)
+    (FiberBundle.mdifferentiableAt_extend I F σ₀) (FiberBundle.mdifferentiableAt_extend I F τ₀)
+  simp [product] at h' ⊢
+  linear_combination (norm := skip) h'
+  ring_nf
+
+end CovariantDerivative
diff --git a/Mathlib/Geometry/Manifold/VectorBundle/CovariantDerivative/Prelim.lean b/Mathlib/Geometry/Manifold/VectorBundle/CovariantDerivative/Prelim.lean
new file mode 100644
index 00000000000000..502b34ec1bc402
--- /dev/null
+++ b/Mathlib/Geometry/Manifold/VectorBundle/CovariantDerivative/Prelim.lean
@@ -0,0 +1,230 @@
+/-
+Copyright (c) 2025 Patrick Massot. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Patrick Massot, Michael Rothgang
+-/
+module
+
+public import Mathlib.Geometry.Manifold.IsManifold.InteriorBoundary
+public import Mathlib.Geometry.Manifold.MFDeriv.Atlas
+public import Mathlib.Geometry.Manifold.VectorBundle.MDifferentiable
+
+/-!
+# Supporting lemmas for CovariantDerivative.Basic
+
+TODO: PR all this to appropriate places.
+
+-/
+
+open Bundle Filter Module Topology Set
+open scoped Bundle Manifold ContDiff
+
+@[expose] public section tangent_bundle_normedSpace
+
+variable (F : Type*) [NormedAddCommGroup F] [NormedSpace ℝ F]
+
+instance (f : F) : CoeOut (TangentSpace 𝓘(ℝ, F) f) F :=
+  ⟨fun x ↦ x⟩
+
+end tangent_bundle_normedSpace
+
+@[expose] public section mfderiv
+
+open Function
+
+variable {𝕜 : Type*} [NontriviallyNormedField 𝕜]
+  {E : Type*} [NormedAddCommGroup E] [NormedSpace 𝕜 E]
+  {H : Type*} [TopologicalSpace H] {I : ModelWithCorners 𝕜 E H}
+  {M : Type*} [TopologicalSpace M] [ChartedSpace H M]
+  {E' : Type*} [NormedAddCommGroup E'] [NormedSpace 𝕜 E']
+  {H' : Type*} [TopologicalSpace H'] {I' : ModelWithCorners 𝕜 E' H'}
+  {M' : Type*} [TopologicalSpace M'] [ChartedSpace H' M']
+
+-- unused; could move to `SpecificFunctions`
+lemma injective_mfderiv_of_eventually_leftInverse
+    {f : M → M'} (x : M) {g : M' → M}
+    (hg : MDiffAt g (f x)) (hf : MDiffAt f x)
+    (hfg : g ∘ f =ᶠ[𝓝 x] id) : Injective (mfderiv% f x) := by
+  have := mfderiv_comp x hg hf
+  rw [hfg.mfderiv_eq] at this
+  have : LeftInverse (mfderiv% g (f x)) (mfderiv% f x) := by
+    intro u
+    simpa using congr($this u).symm
+  exact LeftInverse.injective this
+
+-- unused; could move to `SpecificFunctions`
+lemma surjective_mfderiv_of_eventually_rightInverse
+    {f : M → M'} {x : M} {y : M'} (hxy : y = f x) {g : M' → M}
+    (hg : MDiffAt g y) (hf : MDiffAt f x)
+    (hfg : g ∘ f =ᶠ[𝓝 x] id) : Surjective (mfderiv% g y) := by
+  rw [hxy] at hg
+  have := mfderiv_comp x hg hf
+  rw [hfg.mfderiv_eq] at this
+  have : RightInverse (mfderiv% f x) (mfderiv% g (f x)) := by
+    intro u
+    simpa using congr($this u).symm
+  rw [← hxy] at this
+  exact RightInverse.surjective this
+
+end mfderiv
+
+@[expose] public section -- TODO: think if we want to expose all definitions!
+
+section general_lemmas -- those lemmas should move
+
+section linear_algebra
+variable (𝕜 : Type*) [Field 𝕜]
+         {E : Type*} [AddCommGroup E] [Module 𝕜 E]
+         {E' : Type*} [AddCommGroup E'] [Module 𝕜 E']
+
+lemma exists_map_of (u : E) (u' : E') :
+    ∃ φ : E →ₗ[𝕜] E', (u = 0 → u' = 0) → φ u = u' := by
+  by_cases h : u = 0
+  · simp [h]
+    tauto
+  · have indep : LinearIndepOn 𝕜 id {u} := LinearIndepOn.singleton h
+    let s := indep.extend (subset_univ _)
+    have hus : u ∈ s := singleton_subset_iff.mp <| indep.subset_extend (subset_univ _)
+    use (Basis.extend indep).constr (M' := E') (S := 𝕜) fun _ ↦ u'
+    simpa [h, Basis.extend_apply_self] using (Basis.extend indep).constr_basis _ _ ⟨u, hus⟩
+
+open Classical in
+noncomputable def map_of (u : E) (u' : E') : E →ₗ[𝕜] E' := (exists_map_of 𝕜 u u').choose
+
+variable {𝕜}
+lemma map_of_spec (u : E) (u' : E') (h : u = 0 → u' = 0) : map_of 𝕜 u u' u = u' :=
+  (exists_map_of 𝕜 u u').choose_spec h
+end linear_algebra
+
+section
+variable
+  {𝕜 : Type*} [NontriviallyNormedField 𝕜]
+  {E : Type*} [NormedAddCommGroup E] [NormedSpace 𝕜 E]
+  {H : Type*} [TopologicalSpace H] {I : ModelWithCorners 𝕜 E H}
+  {M : Type*} [TopologicalSpace M] [ChartedSpace H M] -- [IsManifold I 0 M]
+  {E' : Type*} [NormedAddCommGroup E'] [NormedSpace 𝕜 E']
+  {H' : Type*} [TopologicalSpace H'] {I' : ModelWithCorners 𝕜 E' H'}
+  {M' : Type*} [TopologicalSpace M'] [ChartedSpace H' M']
+
+variable (𝕜) in
+noncomputable def map_of_loc_one_jet (e u : E) (e' u' : E') : E → E' :=
+  fun x ↦ e' + map_of 𝕜 u u' (x - e)
+
+lemma map_of_loc_one_jet_spec [CompleteSpace 𝕜] [FiniteDimensional 𝕜 E]
+    (e u : E) (e' u' : E') (hu : u = 0 → u' = 0) :
+    map_of_loc_one_jet 𝕜 e u e' u' e = e' ∧
+    DifferentiableAt 𝕜 (map_of_loc_one_jet 𝕜 e u e' u') e ∧
+    fderiv 𝕜 (map_of_loc_one_jet 𝕜 e u e' u') e u = u' := by
+  unfold map_of_loc_one_jet
+  let φ := (map_of 𝕜 u u').toContinuousLinearMap
+  have diff : Differentiable 𝕜 (map_of 𝕜 u u') :=
+    (map_of 𝕜 u u').toContinuousLinearMap.differentiable
+  refine ⟨by simp, ?_, ?_⟩
+  · apply (differentiableAt_const e').add
+    apply diff.differentiableAt.comp
+    fun_prop
+  · simp only [map_sub, fderiv_const_add]
+    rw [fderiv_sub_const]
+    change (fderiv 𝕜 φ e) u = _
+    rw [φ.hasFDerivAt.fderiv]
+    exact map_of_spec u u' hu
+
+noncomputable
+def map_of_one_jet {x : M} (u : TangentSpace I x) {x' : M'} (u' : TangentSpace I' x') :
+    M → M' :=
+  letI ψ := extChartAt I' x'
+  letI φ := extChartAt I x
+  ψ.symm ∘
+  (map_of_loc_one_jet 𝕜 (φ x) (mfderiv% φ x u) (ψ x') (mfderiv% ψ x' u')) ∘
+  φ
+
+-- TODO: version assuming `x` and `x'` are in the interior, or maybe `x` is enough.
+
+/-- For any `(x, u) ∈ TM` and `(x', u') ∈ TM'`, `map_of_one_jet u u'` sends `x` to `x'` and
+its derivative sends `u` to `u'`. We need to assume the target manifold `M'` has no boundary
+since we cannot hope the result is `x` and `x'` are boundary points and `u` is inward
+while `u'` is outward.
+-/
+lemma map_of_one_jet_spec [IsManifold I 1 M] [IsManifold I' 1 M']
+      [BoundarylessManifold I' M']
+      [CompleteSpace 𝕜] [FiniteDimensional 𝕜 E]
+      {x : M} (u : TangentSpace I x) {x' : M'}
+      (u' : TangentSpace I' x') (hu : u = 0 → u' = 0) :
+    map_of_one_jet u u' x = x' ∧
+    MDiffAt (map_of_one_jet u u') x ∧
+    mfderiv% (map_of_one_jet u u') x u = u' := by
+  let ψ := extChartAt I' x'
+  let φ := extChartAt I x
+  let g := map_of_loc_one_jet 𝕜 (φ x) (mfderiv% φ x u) (ψ x') (mfderiv% ψ x' u')
+  have hψ : MDiffAt ψ x' := mdifferentiableAt_extChartAt (ChartedSpace.mem_chart_source x')
+  have hφ : MDiffAt φ x := mdifferentiableAt_extChartAt (ChartedSpace.mem_chart_source x)
+  replace hu : mfderiv% φ x u = 0 → mfderiv% ψ x' u' = 0 := by
+    have : Function.Injective (mfderiv% φ x) :=
+      (isInvertible_mfderiv_extChartAt (mem_extChartAt_source x)).injective
+    rw [injective_iff_map_eq_zero] at this
+    have := map_zero (mfderiv% ψ x')
+    grind
+  rcases map_of_loc_one_jet_spec (𝕜 := 𝕜) (φ x) (mfderiv% φ x u) (ψ x') (mfderiv% ψ x' u') hu with
+    ⟨h : g (φ x) = ψ x', h', h''⟩
+  have hg : MDiffAt g (φ x) := mdifferentiableAt_iff_differentiableAt.mpr h'
+  have hgφ : MDiffAt (g ∘ φ) x := h'.comp_mdifferentiableAt hφ
+  let Ψi : E' → M' := ψ.symm -- FIXME: this is working around a limitation of MDiffAt elaborator
+  have hψi : MDiffAt Ψi (g (φ x)) := by
+    rw [h]
+    have := mdifferentiableWithinAt_extChartAt_symm (I := I') (mem_extChartAt_target x')
+    exact this.mdifferentiableAt (range_mem_nhds_isInteriorPoint <|
+      BoundarylessManifold.isInteriorPoint' x')
+  unfold map_of_one_jet
+  refold_let g φ ψ at *
+  refine ⟨by simp [h, ψ], hψi.comp x hgφ, ?_⟩
+  rw [mfderiv_comp x hψi hgφ, mfderiv_comp x hg hφ, mfderiv_eq_fderiv]
+  change (mfderiv% Ψi (g (φ x))) (fderiv 𝕜 g (φ x) <| mfderiv% φ x u) = u'
+  rw [h] at hψi
+  rw [h'', h, ← mfderiv_comp_apply x' hψi hψ]
+  have : Ψi ∘ ψ =ᶠ[𝓝 x'] id := by
+    have : ∀ᶠ z in 𝓝 x', z ∈ ψ.source := extChartAt_source_mem_nhds x'
+    filter_upwards [this] with z hz
+    exact ψ.left_inv hz
+  simp [this.mfderiv_eq]
+  rfl
+end
+
+end general_lemmas
+
+section linear_algebra_isCompl
+lemma LinearMap.comap_isCompl {R R₂ M M₂ : Type*}
+    [Semiring R] [AddCommMonoid M] [Module R M] [Semiring R₂]
+    {σ₁₂ : R →+* R₂} {σ₂₁ : R₂ →+* R} [RingHomInvPair σ₁₂ σ₂₁] [RingHomInvPair σ₂₁ σ₁₂]
+    [AddCommMonoid M₂] [Module R₂ M₂]
+    {f : M →ₛₗ[σ₁₂] M₂} (hf : Function.Bijective f)
+    {p q : Submodule R₂ M₂} (h : IsCompl p q) :
+    IsCompl (Submodule.comap f p) (Submodule.comap f q) := by
+  rw [isCompl_iff, disjoint_iff, codisjoint_iff] at *
+  constructor
+  · rw [← Submodule.comap_inf, h.1]
+    simp [LinearMap.ker_eq_bot_of_injective hf.1]
+  · rw [← Submodule.comap_sup_of_injective, h.2]
+    · exact Submodule.comap_top f
+    · exact hf.1
+    · intro x hx
+      exact hf.2 x
+    · intro x hx
+      exact hf.2 x
+
+lemma LinearEquiv.comap_isCompl {R R₂ M M₂ : Type*}
+  [Semiring R] [AddCommMonoid M] [Module R M] [Semiring R₂]
+  {σ₁₂ : R →+* R₂} {σ₂₁ : R₂ →+* R} [RingHomInvPair σ₁₂ σ₂₁] [RingHomInvPair σ₂₁ σ₁₂]
+  [AddCommMonoid M₂] [Module R₂ M₂]
+  (f : M ≃ₛₗ[σ₁₂] M₂) {p q : Submodule R₂ M₂} (h : IsCompl p q) :
+    IsCompl (Submodule.comap f.toLinearMap p) (Submodule.comap f.toLinearMap q) := by
+  rw [isCompl_iff, disjoint_iff, codisjoint_iff] at *
+  constructor
+  · rw [← Submodule.comap_inf, h.1]
+    simp
+  · rw [← Submodule.comap_sup_of_injective, h.2]
+    · exact Submodule.comap_top f.toLinearMap
+    · exact f.injective
+    · simp
+    · simp
+
+end linear_algebra_isCompl
diff --git a/Mathlib/Geometry/Manifold/VectorBundle/CovariantDerivative/Torsion2.lean b/Mathlib/Geometry/Manifold/VectorBundle/CovariantDerivative/Torsion2.lean
new file mode 100644
index 00000000000000..ab4ad9662c7ae8
--- /dev/null
+++ b/Mathlib/Geometry/Manifold/VectorBundle/CovariantDerivative/Torsion2.lean
@@ -0,0 +1,116 @@
+/-
+Copyright (c) 2025 Patrick Massot. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Patrick Massot, Michael Rothgang
+-/
+module
+
+public import Mathlib.Geometry.Manifold.VectorBundle.CovariantDerivative.Torsion
+public import Mathlib.Geometry.Manifold.VectorBundle.LocalFrame
+
+/-!
+# More properties about torsion of a covariant derivative
+
+- might and should be refactored!
+- prove: torsion-freeness on `s` can be checked using a local frame on `s`
+
+TODO: add a more complete doc-string
+
+-/
+
+@[expose] public section -- TODO: think if we want to expose all definitions!
+
+open Bundle Filter Module Topology Set
+
+open scoped Bundle Manifold ContDiff
+
+variable {𝕜 : Type*} [NontriviallyNormedField 𝕜]
+  {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] {H : Type*} [TopologicalSpace H]
+  {I : ModelWithCorners ℝ E H} {M : Type*} [TopologicalSpace M] [ChartedSpace H M] {x : M}
+  {F : Type*} [NormedAddCommGroup F] [NormedSpace ℝ F] (n : WithTop ℕ∞) {V : M → Type*}
+  [TopologicalSpace (TotalSpace F V)] [∀ x, AddCommGroup (V x)] [∀ x, Module ℝ (V x)]
+  [∀ x : M, TopologicalSpace (V x)] [FiberBundle F V]
+
+variable
+  {cov cov' : (Π x : M, TangentSpace I x) → (Π x : M, TangentSpace I x →L[ℝ] TangentSpace I x)}
+  {X X' Y : Π x : M, TangentSpace I x}
+
+namespace CovariantDerivative
+
+variable [IsManifold I ∞ M]
+-- The torsion tensor of a covariant derivative on the tangent bundle `TM`.
+variable {cov : CovariantDerivative I E (TangentSpace I : M → Type _)}
+  {U : Set M} (hf : IsCovariantDerivativeOn E cov U)
+
+-- variable {n} in
+-- lemma aux1 {ι : Type*} [Fintype ι]
+--     {f : (Π x : M, TangentSpace I x) → (Π x : M, TangentSpace I x →L[ℝ] TangentSpace I x)}
+--     {U : Set M} {s : ι → (x : M) → TangentSpace I x} (hs : IsLocalFrameOn I E n s U) (hx : x ∈ U)
+--     (X Y : (x : M) → TangentSpace I x) :
+--     torsion f X Y x = ∑ i, (hs.coeff i) x (X x) • torsion f (s i) Y x :=
+--   have hU : U ∈ 𝓝 x := sorry
+--   have aux := hs.eventually_eq_sum_coeff_smul X hU
+--   have hX : X x = ∑ i, (hs.coeff i) x (X x) • s i x := sorry
+--   calc torsion f X Y x
+--     _ = torsion f (fun x ↦ ∑ i, (hs.coeff i) x (X x) • s i x) Y x := by
+--       sorry -- tensoriality and [hX]
+--     _ = ∑ i, (torsion f (fun x ↦ (hs.coeff i) x (X x) • s i x) Y x) := sorry
+--     _ = ∑ i, (hs.coeff i) x (X x) • (torsion f (s i) Y x) := sorry
+--
+-- -- Weaker hypotheses possible, e.g. local frame on U ∈ 𝓝 x, while a cov. derivative on s ∋ x
+-- variable {n} in
+-- lemma aux2 {ι : Type*} [Fintype ι] [CompleteSpace E]
+--     {f : (Π x : M, TangentSpace I x) → (Π x : M, TangentSpace I x →L[ℝ] TangentSpace I x)}
+--     {U : Set M} {s : ι → (x : M) → TangentSpace I x}
+--     (hf : IsCovariantDerivativeOn E f U) (hs : IsLocalFrameOn I E n s U) (hx : x ∈ U)
+--     (X Y : (x : M) → TangentSpace I x) :
+--     torsion f X Y x = ∑ i, (hs.coeff i) x (Y x) • torsion f X (s i) x :=
+--   have hU : U ∈ 𝓝 x := sorry
+--   have aux := hs.eventually_eq_sum_coeff_smul Y hU
+--   have hY : Y x = ∑ i, (hs.coeff i) x (Y x) • s i x := hs.coeff_sum_eq Y hx
+--   calc torsion f X Y x
+--     _ = torsion f X (fun x ↦ ∑ i, (hs.coeff i) x (Y x) • s i x) x := by
+--       sorry -- tensoriality and [hY]
+--     _ = ∑ i, (torsion f X (fun x ↦ (hs.coeff i) x (Y x) • s i x) x) := sorry
+--     _ = ∑ i, (hs.coeff i) x (Y x) • (torsion f X (s i) x) := by
+--       congr with i
+--       have hsi : MDiffAt (LinearMap.piApply (hs.coeff i) Y) x := sorry
+--       have hsi' : MDiffAt (T% (s i)) x := sorry
+--       have := hf.torsion_smul_right_apply X (f := LinearMap.piApply (hs.coeff i) Y) hsi hsi'
+--       erw [← this]
+--       congr
+--
+-- /-- We can test torsion-freeness on a set using a local frame. -/
+-- lemma _root_.IsCovariantDerivativeOn.isTorsionFreeOn_iff_localFrame
+--     {ι : Type*} [Fintype ι] [CompleteSpace E]
+--     {f : (Π x : M, TangentSpace I x) → (Π x : M, TangentSpace I x →L[ℝ] TangentSpace I x)}
+--     {U : Set M} {s : ι → (x : M) → TangentSpace I x}
+--     (hf: IsCovariantDerivativeOn E f U) (hs : IsLocalFrameOn I E n s U) :
+--     IsTorsionFreeOn f U ↔ ∀ i j, ∀ x ∈ U, torsion f (s i) (s j) x = 0 := by
+--   rw [IsTorsionFreeOn]
+--   refine ⟨fun h i j x hx ↦ h x hx (s i) (s j), fun h ↦ ?_⟩
+--   intro x hx X Y
+--   rw [aux1 hs hx]
+--   calc
+--     _ = ∑ i, (hs.coeff i) x (X x) • ∑ j, (hs.coeff j) x (Y x) • torsion f (s i) (s j) x := by
+--       congr!
+--       rw [aux2 hf hs hx]
+--     _ = ∑ i, (hs.coeff i) x (X x) • ∑ j, (hs.coeff j) x (Y x) • 0 := by
+--       congr! with i _ j _
+--       exact h i j x hx
+--     _ = 0 := by simp
+
+-- lemma the trivial connection on a normed space is torsion-free
+-- lemma trivial.isTorsionFree : IsTorsionFree (TangentBundle 𝓘(ℝ, E) E) := sorry
+
+-- lemma: tangent bundle of E is trivial -> there exists a single trivialisation with baseSet univ
+-- make a new abbrev Bundle.Trivial.globalFrame --- which is localFrame for the std basis of F,
+--    w.r.t. to this trivialisation
+-- add lemmas: globalFrame is contMDiff globally
+
+-- proof of above lemma: write sections s and t in the global frame above
+-- by linearity (proven above), suffices to consider s = s^i and t = s^j (two sections in the frame)
+-- compute: their Lie bracket is zero
+-- compute: the other two terms cancel, done
+
+end CovariantDerivative
diff --git a/Mathlib/Geometry/Manifold/VectorBundle/CovariantDerivative/TrivPrelim.lean b/Mathlib/Geometry/Manifold/VectorBundle/CovariantDerivative/TrivPrelim.lean
new file mode 100644
index 00000000000000..8446549efaf9c8
--- /dev/null
+++ b/Mathlib/Geometry/Manifold/VectorBundle/CovariantDerivative/TrivPrelim.lean
@@ -0,0 +1,641 @@
+/-
+Copyright (c) 2025 Patrick Massot. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Patrick Massot, Michael Rothgang
+-/
+module
+
+public import Mathlib.Geometry.Manifold.IsManifold.InteriorBoundary
+public import Mathlib.Geometry.Manifold.MFDeriv.Atlas
+public import Mathlib.Geometry.Manifold.VectorBundle.MDifferentiable
+public import Mathlib.Geometry.Manifold.Notation
+
+/-!
+# Supporting lemmas for CovariantDerivative.Basic trivialization stuff
+
+TODO: PR all this to appropriate places.
+
+-/
+
+@[expose] public section
+
+open Bundle Filter Module Topology Set
+
+open scoped Bundle Manifold ContDiff
+
+namespace Bundle.Trivialization
+
+section trivilization_topology
+
+variable {B F Z : Type*} [TopologicalSpace B]
+  [TopologicalSpace F]
+
+section any_proj
+
+variable [TopologicalSpace Z] {proj : Z → B} (e : Trivialization F proj)
+lemma baseSet_mem_nhds {x : B} (hx : x ∈ e.baseSet) : e.baseSet ∈ 𝓝 x :=
+  e.open_baseSet.mem_nhds_iff.mpr hx
+
+lemma baseSet_prod_univ_mem_nhds {v : Z}
+    (hv : proj v ∈ e.baseSet) : e.baseSet ×ˢ univ ∈ 𝓝 (e v) := by
+  rw [← e.mk_proj_snd' hv]
+  exact prod_mem_nhds (e.baseSet_mem_nhds hv) univ_mem
+
+lemma comp_invFun_eventuallyEq
+    {v : Z} (hv : proj v ∈ e.baseSet) : e ∘ e.invFun =ᶠ[𝓝 (e v)] id := by
+  filter_upwards [e.baseSet_prod_univ_mem_nhds hv] with p hp
+  simp [(e.mem_target).2 hp.1]
+
+end any_proj
+
+section fiber_bundle
+variable {E : B → Type*} [TopologicalSpace (TotalSpace F E)]
+  (e : Trivialization F (π F E))
+
+lemma proj_invFun_eventuallyEq
+    {v : TotalSpace F E} (hv : v.proj ∈ e.baseSet) :
+    (TotalSpace.proj ∘ e.invFun) =ᶠ[𝓝 (e v)] Prod.fst := by
+  filter_upwards [e.baseSet_prod_univ_mem_nhds hv] with ⟨x, f⟩ ⟨hx, hf⟩
+  simp [hx]
+
+lemma injective_symm [(x : B) → Zero (E x)]
+  {v : TotalSpace F E} (hv : v.proj ∈ e.baseSet) :
+    Function.Injective (e.symm v.proj) := by
+  intro f f' hff'
+  simpa [hv] using congr(e $hff')
+
+lemma surjective_symm [(x : B) → Zero (E x)]
+  {v : TotalSpace F E} (hv : v.proj ∈ e.baseSet) :
+    Function.Surjective (e.symm v.proj) :=
+  fun u ↦ ⟨(e u).2, by simp [hv]⟩
+
+lemma bijective_symm [(x : B) → Zero (E x)]
+  {v : TotalSpace F E} (hv : v.proj ∈ e.baseSet) :
+    Function.Bijective (e.symm v.proj) :=
+  ⟨e.injective_symm hv, e.surjective_symm hv⟩
+
+/-- Turn sections of a fiber bundle into function into the model fiber using a trivialization. -/
+def secToFun (σ : (b : B) → E b) : B → F :=
+  fun b ↦ e (σ b) |>.2
+
+@[simp]
+lemma secToFun_apply_of_eq {σ : (b : B) → E b} {v : TotalSpace F E} (h : σ v.proj = v) :
+    e.secToFun σ v.proj = (e v).2 := by
+  simp [secToFun, h]
+
+lemma secToFun_congr {σ σ' : (b : B) → E b} {b : B} (h : σ b = σ' b) :
+    e.secToFun σ b = e.secToFun σ' b := by
+  simp [secToFun, h]
+
+lemma apply_total_eventuallyEq
+    {x : B} (hx : x ∈ e.baseSet) (σ : Π x, E x) :
+    e ∘ T%σ =ᶠ[𝓝 x] fun x ↦ (x, e.secToFun σ x) := by
+  filter_upwards [e.baseSet_mem_nhds hx] with y hy
+  ext
+  · exact e.coe_coe_fst hy
+  · simp [secToFun]
+
+-- @[congr]
+-- lemma secToFun_congr {σ σ' : (b : B) → E b} {b : B} (h : ∀ x, x = b → σ x = σ' x) :
+--     e.secToFun σ b = e.secToFun σ' b := by
+--   simp [secToFun, h]
+--
+-- example  {σ σ' : (b : B) → E b} {b : B} (h : ∀ x, x = b → σ x = σ' x) :
+--     e.secToFun σ b = e.secToFun σ' b := by
+--   simp? +contextual [h]
+section
+variable [(x : B) → Zero (E x)]
+
+/-- Turn functions into the model fiber of a fiber bundle into sections using a trivialization. -/
+noncomputable def funToSec (s : B → F) : (b : B) → E b :=
+  fun b ↦ e.symm b (s b)
+
+lemma totalSpace_mk_funToSec {x : B} (hx : x ∈ e.baseSet) (s : B → F) :
+    T% (e.funToSec s) =ᶠ[𝓝 x] e.invFun ∘ fun x ↦ (x, s x) := by
+  filter_upwards [e.baseSet_mem_nhds hx] with y hy
+  exact mk_symm e hy (s y)
+
+@[simp]
+lemma apply_funToSec {x : B} (hx : x ∈ e.baseSet) (s : B → F) :
+    e ⟨x, e.funToSec s x⟩ = (x, s x) := by
+  simp [funToSec, e.apply_mk_symm hx]
+
+lemma snd_apply_funToSec {x : B} (hx : x ∈ e.baseSet) (s : B → F) :
+    (e ⟨x, e.funToSec s x⟩).2 = s x := by
+  simp [funToSec, e.apply_mk_symm hx]
+
+@[simp]
+lemma funToSec_proj_eq {v : TotalSpace F E} (hv : v.proj ∈ e.baseSet) {s : B → F}
+    (hsv : s v.proj = (e v).2) :
+    e.funToSec s v.proj = v.2 := by
+  simp [funToSec, hsv, e.symm_proj_apply v hv]
+
+@[simp]
+lemma mk_funToSec_of_eq {v : TotalSpace F E} (hv : v.proj ∈ e.baseSet) {s : B → F}
+    (h : s v.proj = (e v).2) : (⟨v.proj, e.funToSec s v.proj⟩ : TotalSpace F E) = v := by
+  simp [funToSec, h, hv]
+
+lemma funToSec_congr {s s' : B → F} {b : B} (h : s b = s' b) :
+    e.funToSec s b = e.funToSec s' b := by
+  simp [funToSec, h]
+
+@[simp]
+lemma secToFun_funToSec_eventuallyEq {x : B} (hx : x ∈ e.baseSet) (s : B → F) :
+    e.secToFun (e.funToSec s) =ᶠ[𝓝 x] s := by
+  filter_upwards [e.baseSet_mem_nhds hx] with y hy
+  simp [secToFun, funToSec, hy]
+
+@[simp]
+lemma secToFun_funToSec {x : B} (hx : x ∈ e.baseSet) (s : B → F) :
+    e.secToFun (e.funToSec s) x = s x :=
+  (e.secToFun_funToSec_eventuallyEq hx s).eq_of_nhds
+  -- TODO: understand why the following fails
+  -- by
+  --   have := e.secToFun_funToSec_eventuallyEq hx s
+  --   apply?
+
+@[simp]
+lemma funToSec_secToFun_eventually_eq {x : B} (hx : x ∈ e.baseSet) (σ : (b : B) → E b) :
+    ∀ᶠ x' in 𝓝 x, e.funToSec (e.secToFun σ) x' = σ x' := by
+  filter_upwards [e.baseSet_mem_nhds hx] with y hy
+  simp [secToFun, funToSec, hy]
+
+@[simp]
+lemma funToSec_secToFun {x : B} (hx : x ∈ e.baseSet) (σ : (b : B) → E b) :
+    e.funToSec (e.secToFun σ) x = σ x :=
+  (e.funToSec_secToFun_eventually_eq hx σ).self_of_nhds
+
+section
+variable (σ : (b : B) → E b)
+
+@[simp]
+lemma total_funToSec_secToFun_eventuallyEq {x : B} (hx : x ∈ e.baseSet) (σ : (b : B) → E b) :
+    T% (e.funToSec <| e.secToFun σ) =ᶠ[𝓝 x] T% σ := by
+  filter_upwards [e.baseSet_mem_nhds hx] with y hy
+  simp [secToFun, funToSec, hy]
+
+@[simp]
+lemma total_funToSec_secToFun_eq {x : B} (hx : x ∈ e.baseSet) (σ : (b : B) → E b) :
+    T% (e.funToSec <| e.secToFun σ) x = T% σ x :=
+  e.total_funToSec_secToFun_eventuallyEq hx σ |>.self_of_nhds
+
+end
+
+@[simp]
+lemma total_secToFun_funToSeq_eventually_eq {x : B} (hx : x ∈ e.baseSet) (s : B → F) :
+    ∀ᶠ x' in 𝓝 x, T% (e.secToFun <| e.funToSec s) x' = T% s x' := by
+  filter_upwards [e.baseSet_mem_nhds hx] with y hy
+  simp [secToFun, funToSec, hy]
+
+@[simp]
+lemma total_secToFun_funToSeq {x : B} (hx : x ∈ e.baseSet) (s : B → F) :
+    T% (e.secToFun <| e.funToSec s) x = T% s x :=
+  e.total_secToFun_funToSeq_eventually_eq hx s |>.self_of_nhds
+
+end
+
+variable [(b : B) → TopologicalSpace (E b)] [FiberBundle F E]
+
+lemma preimage_baseSet_mem_nhds
+    {v : TotalSpace F E} (hv : v.proj ∈ e.baseSet) :
+    TotalSpace.proj ⁻¹' e.baseSet ∈ 𝓝 v :=
+  FiberBundle.continuous_proj F E |>.continuousAt <| e.baseSet_mem_nhds hv
+
+lemma fst_comp_eventuallyEq
+    {v : TotalSpace F E} (hv : v.proj ∈ e.baseSet) :
+    Prod.fst ∘ e =ᶠ[𝓝 v] (π F E) := by
+  filter_upwards [preimage_baseSet_mem_nhds e hv] with y hy using e.coe_fst' hy
+
+lemma invFun_comp_eventuallyEq
+    {v : TotalSpace F E} (hv : v.proj ∈ e.baseSet) :
+    e.invFun ∘ e =ᶠ[𝓝 v] id := by
+  filter_upwards [e.preimage_baseSet_mem_nhds hv] with w hw
+  simp [e.mem_source.mpr hw]
+
+end fiber_bundle
+
+section
+variable {B F : Type*} {E : B → Type*} [TopologicalSpace B]
+  [TopologicalSpace F] [TopologicalSpace (TotalSpace F E)]
+  [(x : B) → Zero (E x)]
+  (e : Trivialization F (π F E))
+
+lemma eq_of {x : B} {v v' : E x} (hx : x ∈ e.baseSet) (hvv' : (e v).2 = (e v').2) :
+    v = v' := by
+  have := e.symm_proj_apply v hx
+  rw [hvv'] at this
+  grind [e.symm_proj_apply v' hx]
+
+end
+
+end trivilization_topology
+
+section topological_vector_bundle
+
+section
+variable {R B F : Type*} {E : B → Type*} [Semiring R]
+  [TopologicalSpace F] [TopologicalSpace B] [TopologicalSpace (TotalSpace F E)]
+  (e : Trivialization F (π F E))
+  [AddCommMonoid F] [Module R F] [(x : B) → AddCommMonoid (E x)] [(x : B) → Module R (E x)]
+
+@[simp]
+lemma linearMapAt_funToSec [Trivialization.IsLinear R e] {x : B} (hx : x ∈ e.baseSet) (s : B → F) :
+    (Trivialization.linearMapAt R e x) (e.funToSec s x) = s x := by
+  simp [funToSec, hx]
+
+lemma map_smul [Trivialization.IsLinear R e]
+    {b : B} (hb : b ∈ e.baseSet) (a : R) (v : E b) :
+    (e ⟨b, a • v⟩).2 = a • (e ⟨b, v⟩).2 :=
+  e.linear R hb |>.map_smul a v
+
+lemma secToFun_map_smul [Trivialization.IsLinear R e] {σ : (b : B) → E b}
+    {b : B} (hb : b ∈ e.baseSet) (a : R) :
+    e.secToFun (a • σ) b = a • e.secToFun σ b := by
+  simp [secToFun, e.map_smul hb]
+
+variable (R)
+
+lemma map_add [Trivialization.IsLinear R e]
+    {b : B} (hb : b ∈ e.baseSet) (v v' : E b) :
+    (e ⟨b, v + v'⟩).2 = (e ⟨b, v⟩).2 + (e ⟨b, v'⟩).2 :=
+  e.linear R hb |>.map_add v v'
+
+lemma secToFun_map_add [Trivialization.IsLinear R e] (σ σ' : (b : B) → E b)
+    {b : B} (hb : b ∈ e.baseSet) :
+    e.secToFun (σ + σ') b = e.secToFun σ b + e.secToFun σ' b := by
+  simp [secToFun, e.map_add R hb]
+
+lemma map_zero [Trivialization.IsLinear R e]
+    {b : B} (hb : b ∈ e.baseSet) :
+    (e ⟨b, 0⟩).2 = 0 :=
+  e.linear R hb |>.map_zero
+
+lemma secToFun_map_zero [Trivialization.IsLinear R e] {b : B} (hb : b ∈ e.baseSet) :
+    e.secToFun 0 b = 0 := by
+  simp [secToFun, e.map_zero R hb]
+end
+
+section
+
+variable (R : Type*) {B F : Type*} {E : B → Type*}
+  [NontriviallyNormedField R] [(x : B) → AddCommMonoid (E x)]
+  [(x : B) → Module R (E x)] [NormedAddCommGroup F]
+  [NormedSpace R F] [TopologicalSpace B] [TopologicalSpace (TotalSpace F E)]
+  [(x : B) → TopologicalSpace (E x)]
+  [FiberBundle F E] (e : Trivialization F (π F E))
+
+lemma symm_map_add [Trivialization.IsLinear R e] {x : B}
+  (f f' : F) :
+    e.symm x (f + f') = e.symm x f + e.symm x f' :=
+  (e.symmL R x).map_add f f'
+
+lemma funToSec_map_add [Trivialization.IsLinear R e] {s s' : B → F} :
+    e.funToSec (s + s') = e.funToSec s + e.funToSec s' := by
+  ext b
+  simp [funToSec, e.symm_map_add R]
+
+@[simp]
+lemma symm_map_zero [Trivialization.IsLinear R e] {x : B} :
+    e.symm x 0 = 0 :=
+  (e.symmL R x).map_zero
+
+@[simp]
+lemma funToSec_map_zero [Trivialization.IsLinear R e] :
+    e.funToSec (0 : B → F) = 0 := by
+  ext b
+  simp [funToSec, e.symm_map_zero R]
+
+variable {R}
+
+lemma symm_map_smul [Trivialization.IsLinear R e] {x : B} (a : R) (f : F) :
+    e.symm x (a • f) = a • e.symm x f :=
+  (e.symmL R x).map_smul a f
+
+lemma funToSec_map_smul_const [Trivialization.IsLinear R e] (a : R) (s : B → F) :
+    e.funToSec (a • s) = a • e.funToSec s := by
+  ext b
+  simp [funToSec, e.symm_map_smul]
+
+lemma funToSec_map_smul [Trivialization.IsLinear R e] (a : B → R) (s : B → F) :
+    e.funToSec (a • s) = a • e.funToSec s := by
+  ext b
+  simp [funToSec, e.symm_map_smul]
+
+end
+
+end topological_vector_bundle
+
+section to_trivialization
+variable {𝕜 : Type*} [NontriviallyNormedField 𝕜]
+  {E : Type*} [NormedAddCommGroup E] [NormedSpace 𝕜 E]
+  {H : Type*} [TopologicalSpace H] {I : ModelWithCorners 𝕜 E H}
+  {M : Type*} [TopologicalSpace M] [ChartedSpace H M]
+
+variable {F : Type*} [NormedAddCommGroup F] [NormedSpace 𝕜 F]
+  -- `F` model fiber
+  (n : WithTop ℕ∞)
+  {V : M → Type*} [TopologicalSpace (TotalSpace F V)]
+  [∀ x, AddCommGroup (V x)] [∀ x, Module 𝕜 (V x)]
+  [∀ x : M, TopologicalSpace (V x)]
+  [FiberBundle F V]
+
+@[simp]
+lemma _root_.mdifferentiableAt_total_trivial_iff {s : M → F} {x : M} :
+    MDiffAt (T% s) x ↔ MDiffAt s x := by
+  rw [mdifferentiableAt_section I]
+  simp
+
+@[simp]
+lemma _root_.mdifferentiableAt_section_trivial_iff {σ : (x : M) → Trivial M F x} {x : M} :
+    MDiffAt (T% σ) x ↔ MDifferentiableAt I 𝓘(𝕜, F) σ x := by
+  rw [mdifferentiableAt_section I]
+  simp
+
+variable (e : Trivialization F (π F V)) [MemTrivializationAtlas e]
+
+lemma mdifferentiableAt
+    [VectorBundle 𝕜 F V] [ContMDiffVectorBundle 1 F V I]
+    {x : M} (hx : x ∈ e.baseSet) (v : V x) :
+    MDifferentiableAt (I.prod 𝓘(𝕜, F)) (I.prod 𝓘(𝕜, F)) e v := by
+  have : ⟨x, v⟩ ∈ e.source := e.coe_mem_source.mpr hx
+  have foo := e.contMDiffOn (IB := I) (n := 1) v this
+  have := foo.contMDiffAt (e.open_source.mem_nhds this)
+  exact this.mdifferentiableAt zero_ne_one.symm
+
+lemma mdifferentiableAt_invFun
+    [VectorBundle 𝕜 F V] [ContMDiffVectorBundle 1 F V I]
+    {x : M} (hx : x ∈ e.baseSet) (f : F) :
+    MDifferentiableAt (I.prod 𝓘(𝕜, F)) (I.prod 𝓘(𝕜, F)) e.invFun (x, f) := by
+  have : ⟨x, f⟩ ∈ e.target := e.mk_mem_target.mpr hx
+  have foo := e.contMDiffOn_symm (IB := I) (n := 1) _ this
+  have := foo.contMDiffAt (e.open_target.mem_nhds this)
+  exact this.mdifferentiableAt zero_ne_one.symm
+
+-- Note: The definition below (ab)uses definitional
+-- equality of `TangentSpace (I.prod 𝓘(𝕜, F)) (↑t v)`
+-- which is $T_{t(v)} (M × F)$ and `TM v.proj × F`
+-- which is $T_{π(v)} M × F$.
+variable (I) in
+noncomputable
+def deriv (v : TotalSpace F V) :
+    TangentSpace (I.prod 𝓘(𝕜, F)) v →L[𝕜] TangentSpace I v.proj × F :=
+  mfderiv (I.prod 𝓘(𝕜, F)) (I.prod 𝓘(𝕜, F)) e v
+
+variable (I) in
+noncomputable
+def derivInv (v : TotalSpace F V) :
+    TangentSpace I v.proj × F →L[𝕜] TangentSpace (I.prod 𝓘(𝕜, F)) v :=
+  mfderiv (I.prod 𝓘(𝕜, F)) (I.prod 𝓘(𝕜, F)) e.invFun (e v)
+
+set_option backward.isDefEq.respectTransparency false in
+@[simp]
+lemma derivInv_deriv
+    [VectorBundle 𝕜 F V] [ContMDiffVectorBundle 1 F V I]
+    {v : TotalSpace F V} (hv : v.proj ∈ e.baseSet) :
+    (e.derivInv I v) ∘L (e.deriv I v) = .id 𝕜 _ := by
+  have D₁ := e.mdifferentiableAt_invFun (I := I) hv (e v).2
+  have D₂ : MDifferentiableAt _ _ e v := e.mdifferentiableAt (I := I) hv v.2
+  have D1' := D₁
+  simp only [PartialEquiv.invFun_as_coe, OpenPartialHomeomorph.coe_coe_symm] at D1'
+  rw [e.mk_proj_snd' hv] at D₁
+  have comp := mfderiv_comp v D₁ D₂
+  rw [(invFun_comp_eventuallyEq e hv).mfderiv_eq, mfderiv_id] at comp
+  simp [deriv, derivInv, comp]
+
+@[simp]
+lemma derivInv_deriv_apply
+    [VectorBundle 𝕜 F V] [ContMDiffVectorBundle 1 F V I]
+    {v : TotalSpace F V} (hv : v.proj ∈ e.baseSet)
+    (u : TangentSpace (I.prod 𝓘(𝕜, F)) v) :
+    (e.derivInv I v (e.deriv I v u)) = u :=
+  show ((e.derivInv I v) ∘L (e.deriv I v)) u = u by simp [hv]
+
+@[simp]
+lemma mfderiv_proj_fst_deriv
+    [VectorBundle 𝕜 F V] [ContMDiffVectorBundle 1 F V I]
+    {v : TotalSpace F V} (hv : v.proj ∈ e.baseSet)
+    (u : TangentSpace (I.prod 𝓘(𝕜, F)) v) :
+    mfderiv (I.prod 𝓘(𝕜, F)) I TotalSpace.proj v u = (e.deriv I v u).1 := by
+  have := e.fst_comp_eventuallyEq hv
+  rw [← this.mfderiv_eq, mfderiv_comp v mdifferentiableAt_fst (e.mdifferentiableAt (I := I) hv v.2)]
+  simp
+  rfl -- TODO: understand why `simp` does not handle `ContinuousLinearMap.fst`
+
+set_option backward.isDefEq.respectTransparency false in
+@[simp]
+lemma mfderiv_proj_derivInv_apply
+    [VectorBundle 𝕜 F V] [ContMDiffVectorBundle 1 F V I]
+    {v : TotalSpace F V} (hv : v.proj ∈ e.baseSet)
+    (u : TangentSpace (I.prod 𝓘(𝕜, F)) v) :
+    mfderiv (I.prod 𝓘(𝕜, F)) I TotalSpace.proj v (e.derivInv I v u) = u.1 := by
+  have D₁ := e.mdifferentiableAt_invFun (I := I) hv (e v).2
+  rw [e.mk_proj_snd' hv] at D₁
+  have diff : MDifferentiableAt (I.prod 𝓘(𝕜, F)) I TotalSpace.proj v :=
+    mdifferentiableAt_proj _
+  have eq : e.invFun (e v) = v := by simp [e.mem_source.mpr hv]
+  rw [← eq] at diff
+  have := mfderiv_comp (e v) diff D₁
+  have C : (TotalSpace.proj ∘ e.invFun) =ᶠ[𝓝 (e v)] Prod.fst := by
+    filter_upwards [e.baseSet_prod_univ_mem_nhds hv] with ⟨x, f⟩ ⟨hx, hf⟩
+    simp [hx]
+  rw [C.mfderiv_eq, eq] at this
+  have := congr($this u).symm
+  change mfderiv (I.prod 𝓘(𝕜, F)) I TotalSpace.proj v _ = _ at this
+  -- Why all this pain??
+  convert this
+  ext x
+  simp
+  rfl
+
+set_option backward.isDefEq.respectTransparency false in
+@[simp]
+lemma deriv_derivInv
+    [VectorBundle 𝕜 F V] [ContMDiffVectorBundle 1 F V I]
+    {v : TotalSpace F V} (hv : v.proj ∈ e.baseSet) :
+    (e.deriv I v) ∘L (e.derivInv I v) = .id 𝕜 _ := by
+  have D₁ := e.mdifferentiableAt_invFun (I := I) hv (e v).2
+  rw [e.mk_proj_snd' hv] at D₁
+  have D₂ : MDifferentiableAt _ _ e v := e.mdifferentiableAt (I := I) hv v.2
+  have : e.invFun (e v) = v := by simp [e.mem_source.mpr hv]
+  rw [← this] at D₂
+  have comp := mfderiv_comp (e v) D₂ D₁
+  rw [(comp_invFun_eventuallyEq e hv).mfderiv_eq, mfderiv_id] at comp
+  symm
+  convert comp <;> rw [this]
+
+@[simp]
+lemma deriv_derivInv_apply
+    [VectorBundle 𝕜 F V] [ContMDiffVectorBundle 1 F V I]
+    {v : TotalSpace F V} (hv : v.proj ∈ e.baseSet)
+    (u : TangentSpace I v.proj × F) :
+    e.deriv I v (e.derivInv I v u) = u :=
+  show ((e.deriv I v) ∘L (e.derivInv I v)) u = u by simp [hv]
+
+lemma bijective_deriv
+    [VectorBundle 𝕜 F V] [ContMDiffVectorBundle 1 F V I]
+    {v : TotalSpace F V} (hv : v.proj ∈ e.baseSet) :
+    Function.Bijective (e.deriv I v) := by
+   refine Function.bijective_iff_has_inverse.mpr ?_
+   use e.derivInv I v
+   constructor
+   all_goals { intro u; simp [hv] }
+
+lemma mdifferentiableAt_funToSec
+    [VectorBundle 𝕜 F V] [ContMDiffVectorBundle 1 F V I]
+    {x : M} (hx : x ∈ e.baseSet) {s : M → F}
+    (hs : MDiffAt s x) :
+    MDiffAt (T% (e.funToSec s)) x := by
+  rw [e.mdifferentiableAt_section_iff (IB := I) _ hx]
+  change MDiffAt (e.secToFun <| e.funToSec s) x
+  have := e.secToFun_funToSec_eventuallyEq hx s
+  exact hs.congr_of_eventuallyEq this
+
+lemma mdifferentiableAt_funToSec'
+    [VectorBundle 𝕜 F V] [ContMDiffVectorBundle 1 F V I]
+    {x : M} (hx : x ∈ e.baseSet) {s : M → F}
+    (hs : MDiffAt (T% s) x) :
+    MDiffAt (T% (e.funToSec s)) x := by
+  rw [mdifferentiableAt_total_trivial_iff] at hs
+  apply mdifferentiableAt_funToSec _ hx hs
+
+lemma mdifferentiableAt_secToFun
+    [VectorBundle 𝕜 F V] [ContMDiffVectorBundle 1 F V I]
+    {x : M} (hx : x ∈ e.baseSet) {σ : (x : M) → V x}
+    (hσ : MDiffAt (T% σ) x) :
+    MDiffAt (e.secToFun σ) x := by
+  rw [e.mdifferentiableAt_section_iff (IB := I) _ hx] at hσ
+  exact hσ
+
+lemma mdifferentiableAt_total_secToFun
+    [VectorBundle 𝕜 F V] [ContMDiffVectorBundle 1 F V I]
+    {x : M} (hx : x ∈ e.baseSet) {σ : (x : M) → V x}
+    (hσ : MDiffAt (T% σ) x) :
+    MDiffAt (T% (e.secToFun σ)) x := by
+  rw [e.mdifferentiableAt_section_iff (IB := I) _ hx] at hσ
+  exact (mdifferentiableAt_section I _).mpr hσ
+
+omit [MemTrivializationAtlas e] [(x : M) → Module 𝕜 (V x)] in
+@[simp]
+lemma mdifferentiableAt_total_funToSec_secToFun
+    {x : M} (hx : x ∈ e.baseSet) {σ : (x : M) → V x} :
+    MDiffAt (T% (e.funToSec <| e.secToFun σ)) x ↔ MDiffAt (T%σ) x := by
+  rw [e.total_funToSec_secToFun_eventuallyEq hx σ |>.mdifferentiableAt_iff]
+
+omit [(x : M) → Module 𝕜 (V x)] [(x : M) → TopologicalSpace (V x)]
+  [FiberBundle F V] [MemTrivializationAtlas e] in
+@[simp]
+lemma mdifferentiableAt_secToFun_funToSec
+    {x : M} (hx : x ∈ e.baseSet) {s : M → F} :
+    MDiffAt (e.secToFun <| e.funToSec s) x ↔ MDiffAt s x :=
+  e.secToFun_funToSec_eventuallyEq hx s |>.mdifferentiableAt_iff
+
+lemma mfderiv_total_funToSec
+    [VectorBundle 𝕜 F V] [ContMDiffVectorBundle 1 F V I]
+    {s : M → F} {x : M} (hs : MDiffAt s x)
+    (hx : x ∈ e.baseSet) :
+    mfderiv% (T% (e.funToSec s)) x =
+      e.derivInv I (e.funToSec s x) ∘L .prod (.id 𝕜 <| TangentSpace I x) (mfderiv% s x) := by
+  -- TODO build a world where this proof is not pure pain.
+  rw [(e.totalSpace_mk_funToSec hx s).mfderiv_eq,
+      mfderiv_comp x (e.mdifferentiableAt_invFun (I := I) hx (s x))]
+  · congr 2
+    · simp [hx]
+    · rw [mfderiv_prodMk]
+      · erw [mfderiv_id]
+        rfl
+      · exact mdifferentiableAt_id
+      · exact hs
+  · exact mdifferentiableAt_id.prodMk hs
+
+
+
+noncomputable def _root_.Bundle.vert (v : TotalSpace F V) :
+    Submodule 𝕜 (TangentSpace (I.prod 𝓘(𝕜, F)) v) :=
+  (mfderiv (I.prod 𝓘(𝕜, F)) I Bundle.TotalSpace.proj v).ker
+
+lemma comap_vert
+    [VectorBundle 𝕜 F V] [ContMDiffVectorBundle 1 F V I]
+    {v : TotalSpace F V} (hv : v.proj ∈ e.baseSet) :
+    Bundle.vert v = Submodule.comap (e.deriv I v).toLinearMap
+      (Submodule.prod ⊥ ⊤) := by
+  ext x
+  have : Prod.fst ∘ e =ᶠ[𝓝 v] TotalSpace.proj := e.fst_comp_eventuallyEq hv
+  unfold vert
+  rw [← this.mfderiv_eq]
+  have mdiffe : MDifferentiableAt (I.prod 𝓘(𝕜, F)) (I.prod 𝓘(𝕜, F)) e v :=
+    e.mdifferentiableAt hv _
+  rw [mfderiv_comp v mdifferentiableAt_fst mdiffe]
+  simp
+  rfl
+
+lemma mfderiv_comp_section
+    [VectorBundle 𝕜 F V] [ContMDiffVectorBundle 1 F V I]
+    {σ : Π x : M, V x} {x : M} (hσ : MDiffAt T%σ x)
+    (u : TangentSpace I x) (hx : x ∈ e.baseSet) :
+    e.deriv I (σ x) ((mfderiv% T%σ x) u) = (u, mfderiv% (e.secToFun σ) x u) := by
+  have mdiffe : MDifferentiableAt (I.prod 𝓘(𝕜, F)) (I.prod 𝓘(𝕜, F)) e (σ x) :=
+    e.mdifferentiableAt hx _
+  have : mfderiv% (e ∘ T%σ) x = (e.deriv I (σ x)) ∘L (mfderiv% T%σ x) :=
+    mfderiv_comp x mdiffe hσ
+  have : mfderiv% (e ∘ T%σ) x u = e.deriv I (σ x) ((mfderiv% T%σ x) u) := by
+    rw [this]
+    rfl
+  erw [← this]
+  rw [(e.apply_total_eventuallyEq hx _).mfderiv_eq]
+  erw [mfderiv_prodMk, mfderiv_id]
+  · -- TODO make sure the `change` below isn’t needed.
+    -- Uncommenting the next lines is meant to help understanding the issue.
+    -- have : ((ContinuousLinearMap.id 𝕜 (TangentSpace I x)).prod
+    --    (mfderiv I 𝓘(𝕜, F) (e.secToFun σ) x)) u =
+    --    (u, (mfderiv I 𝓘(𝕜, F) (e.secToFun σ) x) u) := sorry
+    -- with_reducible exact this
+    change (ContinuousLinearMap.id _ _).prod _ _ = _
+    simp
+  · apply mdifferentiableAt_id
+  · exact (e.mdifferentiableAt_section_iff I σ hx).mp hσ
+
+lemma mfderiv_secToFun_apply
+    [VectorBundle 𝕜 F V] [ContMDiffVectorBundle 1 F V I]
+    {σ : (x : M) → V x} {x : M} (hσ : MDiffAt (T% σ) x) (hx : x ∈ e.baseSet)
+    (u : TangentSpace I x) :
+    mfderiv% (e.secToFun σ) x u =
+      (e.deriv I (σ x) (mfderiv% T%σ x u)).2 := by
+  -- TODO: Fix the erw
+  --  instModuleTangentSpace 𝓘(𝕜, F) (e.secToFun (E := V) σ x)
+  -- and
+  --  NormedSpace.toModule
+  -- are not defeq, but they are at default transparency.
+  -- Does it mean the statement of this lemma is bad?
+  erw [ContinuousLinearMap.comp_apply, ContinuousLinearMap.comp_apply]
+  exact congr(Prod.snd $(e.mfderiv_comp_section hσ u hx)).symm
+
+lemma mfderiv_secToFun
+    [VectorBundle 𝕜 F V] [ContMDiffVectorBundle 1 F V I]
+    {σ : (x : M) → V x} {x : M} (hσ : MDiffAt (T% σ) x) (hx : x ∈ e.baseSet) :
+    mfderiv% (e.secToFun σ) x =
+      .snd 𝕜 (TangentSpace I x) F ∘L (e.deriv I (σ x)) ∘L (mfderiv% T%σ x) :=
+  ContinuousLinearMap.ext fun u ↦ mfderiv_secToFun_apply e hσ hx u
+
+variable {E : Type*} [NormedAddCommGroup E] [NormedSpace 𝕜 E]
+variable {E' : Type*} [NormedAddCommGroup E'] [NormedSpace 𝕜 E']
+
+@[simp]
+theorem Bundle.Trivial.mdifferentiableAt_iff (σ : (x : E) → Trivial E E' x) (e : E) :
+    MDiffAt (T% σ) e ↔ DifferentiableAt 𝕜 σ e := by
+  simp [mdifferentiableAt_totalSpace, mdifferentiableAt_iff_differentiableAt]
+
+-- unused but we need all combinations at some point.
+@[simp]
+theorem Bundle.Trivial.contMDiffOn_iff {n : WithTop ℕ∞} {σ : (x : E) → Trivial E E' x} {s : Set E} :
+    ContMDiffOn 𝓘(𝕜, E) (𝓘(𝕜, E).prod 𝓘(𝕜, E')) n (T% σ) s ↔
+    ContDiffOn 𝕜 n σ s := by
+  sorry
+
+end to_trivialization
+end Bundle.Trivialization
+
+section
+@[simp]
+lemma Bundle.TotalSpace.proj_mk' {B : Type*} {F : Type*} {E : B → Type*} (b : B) (e : E b) :
+    proj (TotalSpace.mk' F b e) = b := rfl
+end
diff --git a/Mathlib/Geometry/Manifold/VectorBundle/CovariantDerivative/Trivial.lean b/Mathlib/Geometry/Manifold/VectorBundle/CovariantDerivative/Trivial.lean
new file mode 100644
index 00000000000000..ec9809c44c54b4
--- /dev/null
+++ b/Mathlib/Geometry/Manifold/VectorBundle/CovariantDerivative/Trivial.lean
@@ -0,0 +1,175 @@
+/-
+Copyright (c) 2025 Patrick Massot. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Patrick Massot, Michael Rothgang
+-/
+module
+
+public import Mathlib.Geometry.Manifold.VectorBundle.CovariantDerivative.Basic
+public import Mathlib.Geometry.Manifold.VectorBundle.CovariantDerivative.TrivPrelim
+
+/-!
+# Everything you always wanted to know about covariant derivatives on the trivial bundle
+
+Don't be afraid to ask. TODO!
+
+-/
+
+open Bundle Filter Module NormedSpace Topology Set
+open scoped Manifold ContDiff
+
+variable {𝕜 : Type*} [NontriviallyNormedField 𝕜]
+
+@[expose] public section
+
+variable {E : Type*} [NormedAddCommGroup E] [NormedSpace 𝕜 E]
+  {H : Type*} [TopologicalSpace H] {I : ModelWithCorners 𝕜 E H}
+  {M : Type*} [TopologicalSpace M] [ChartedSpace H M]
+  {E' : Type*} [NormedAddCommGroup E'] [NormedSpace 𝕜 E']
+  {F : Type*} [NormedAddCommGroup F] [NormedSpace 𝕜 F] (n : WithTop ℕ∞)
+  {V : M → Type*} [TopologicalSpace (TotalSpace F V)] [∀ x, AddCommGroup (V x)]
+  [∀ x, Module 𝕜 (V x)] [∀ x, TopologicalSpace (V x)] [∀ x, IsTopologicalAddGroup (V x)]
+  [∀ x, ContinuousSMul 𝕜 (V x)] [FiberBundle F V]
+  [IsManifold I 1 M]
+
+namespace IsCovariantDerivativeOn
+
+section trivial_bundle
+
+set_option backward.isDefEq.respectTransparency false in
+variable (I M F) in
+@[simps]
+noncomputable def trivial [IsManifold I 1 M] :
+    IsCovariantDerivativeOn F (V := Trivial M F) (fun s x ↦ mfderiv I 𝓘(𝕜, F) s x) univ where
+  add hσ hσ' hx := by
+    rw [mdifferentiableAt_section_trivial_iff] at hσ hσ'
+    rw [mfderiv_add hσ hσ']
+  leibniz hσ hf hx := by
+    rw [mdifferentiableAt_section] at hσ
+    ext1 X₀
+    exact fromTangentSpace_mfderiv_smul_apply hf hσ X₀
+
+lemma of_endomorphism (A : (x : M) → F →L[𝕜] TangentSpace I x →L[𝕜] F) :
+    IsCovariantDerivativeOn F
+      (fun (s : M → F) x ↦ (fromTangentSpace (𝕜 := 𝕜) (s x) ∘L mfderiv% s x) + A x (s x)) univ :=
+  trivial I M F |>.add_one_form A
+
+end trivial_bundle
+
+end IsCovariantDerivativeOn
+
+namespace CovariantDerivative
+
+section trivial_bundle
+
+variable (I M F) in
+@[simps]
+noncomputable def trivial [IsManifold I 1 M] : CovariantDerivative I F (Trivial M F) where
+  toFun s x := mfderiv I 𝓘(𝕜, F) s x
+  isCovariantDerivativeOnUniv := IsCovariantDerivativeOn.trivial ..
+
+end trivial_bundle
+
+variable {E' : Type*} [NormedAddCommGroup E'] [NormedSpace 𝕜 E']
+
+-- TODO: does it make sense to speak of analytic connections? if so, change the definition of
+-- regularity and use ∞ from `open scoped ContDiff` instead.
+
+/-- The trivial connection on the trivial bundle is smooth -/
+lemma trivial_isSmooth :
+    ContMDiffCovariantDerivative (𝕜 := 𝕜) (trivial 𝓘(𝕜, E) E E') (⊤ : ℕ∞) where
+  contMDiff := ⟨by
+    intro σ hσ
+    dsimp only [trivial]
+    sorry /-
+    -- except for local trivialisations, contDiff_infty_iff_fderiv covers this well
+    simp only [trivial]
+    -- use a local trivialisation
+    intro x
+    specialize hX x
+    -- TODO: use contMDiffOn instead, to get something like
+    -- have hX' : ContMDiffOn 𝓘(𝕜, E) (𝓘(𝕜, E).prod 𝓘(𝕜, E')) (∞ + 1)
+    --  (T% σ) (trivializationAt x).baseSet := hX.contMDiffOn
+    -- then want a version contMDiffOn_totalSpace
+    rw [contMDiffAt_totalSpace] at hX ⊢
+    simp only [Trivial.fiberBundle_trivializationAt', Trivial.trivialization_apply]
+    refine ⟨contMDiff_id _, ?_⟩
+    obtain ⟨h₁, h₂⟩ := hX
+    -- ... hopefully telling me
+    -- have h₂scifi : ContMDiffOn 𝓘(𝕜, E) 𝓘(𝕜, E') ∞
+    --   (fun x ↦ σ x) (trivializationAt _).baseSet_ := sorry
+    simp at h₂
+    -- now use ContMDiffOn.congr and contDiff_infty_iff_fderiv,
+    -- or perhaps a contMDiffOn version of this lemma?
+    sorry -/⟩
+
+noncomputable def of_endomorphism (A : E → E' →L[𝕜] E →L[𝕜] E') :
+    CovariantDerivative 𝓘(𝕜, E) E' (Trivial E E') where
+  toFun σ := fun x ↦ fderiv 𝕜 σ x + A x (σ x)
+  isCovariantDerivativeOnUniv := by
+    convert IsCovariantDerivativeOn.of_endomorphism (I := 𝓘(𝕜, E)) A
+    simp [mfderiv_eq_fderiv, NormedSpace.fromTangentSpace]
+    rfl
+
+end CovariantDerivative
+
+section
+
+variable {E : Type*} [NormedAddCommGroup E]
+  [NormedSpace 𝕜 E]
+  {H : Type*} [TopologicalSpace H] {I : ModelWithCorners 𝕜 E H}
+  {M : Type*} [TopologicalSpace M] [ChartedSpace H M] {x : M}
+
+variable {F : Type*} [NormedAddCommGroup F] [NormedSpace 𝕜 F]
+  -- `F` model fiber
+  (n : WithTop ℕ∞)
+  {V : M → Type*} [TopologicalSpace (TotalSpace F V)]
+  [∀ x, AddCommGroup (V x)] [∀ x, Module 𝕜 (V x)]
+  [∀ x : M, TopologicalSpace (V x)] [FiberBundle F V]
+  -- `V` vector bundle
+
+namespace IsCovariantDerivativeOn
+
+-- The classification of real connections over a trivial bundle
+section classification
+
+variable [CompleteSpace 𝕜] [FiniteDimensional 𝕜 F] [IsManifold I 1 M]
+
+/-- Classification of covariant derivatives over a trivial vector bundle: every connection
+is of the form `D + A`, where `D` is the trivial covariant derivative, and `A` a zeroth-order term
+-/
+lemma exists_one_form {cov : (M → F) → (Π x : M, TangentSpace I x →L[𝕜] F)}
+    {s : Set M} (hcov : IsCovariantDerivativeOn F cov s) :
+    ∃ (A : (x : M) → F →L[𝕜] TangentSpace I x →L[𝕜] F),
+    ∀ σ : M → F, ∀ x ∈ s, MDiffAt (T% σ) x →
+    letI d : TangentSpace I x →L[𝕜] F := mfderiv I 𝓘(𝕜, F) σ x
+    cov σ x = d + A x (σ x) := by
+  use hcov.difference (trivial I M F |>.mono <| subset_univ s)
+  intro σ x hx hσ
+  rw [hcov.difference_apply _ (by trivial) hσ]
+  module
+
+noncomputable def one_form {cov : (M → F) → (Π x : M, TangentSpace I x →L[𝕜] F)}
+    {s : Set M} (hcov : IsCovariantDerivativeOn F cov s) :
+    Π x : M, F →L[𝕜] TangentSpace I x →L[𝕜] F :=
+  hcov.exists_one_form.choose
+
+lemma eq_one_form {cov : (M → F) → (Π x : M, TangentSpace I x →L[𝕜] F)}
+    {s : Set M} (hcov : IsCovariantDerivativeOn F cov s)
+    {σ : M → F}
+    {x : M} (hσ : MDiffAt (T% σ) x) (hx : x ∈ s := by trivial) :
+    letI d : TangentSpace I x →L[𝕜] F := mfderiv I 𝓘(𝕜, F) σ x
+    cov σ x = d + hcov.one_form x (σ x) :=
+  hcov.exists_one_form.choose_spec σ x hx hσ
+
+lemma _root_.CovariantDerivative.exists_one_form
+    (cov : CovariantDerivative I F (Bundle.Trivial M F)) :
+    ∃ (A : (x : M) → F →L[𝕜] TangentSpace I x →L[𝕜] F),
+    ∀ σ : M → F, ∀ x, MDiffAt (T% σ) x →
+    letI d : TangentSpace I x →L[𝕜] F := mfderiv I 𝓘(𝕜, F) σ x
+    cov σ x = d + A x (σ x) := by
+  simpa using cov.isCovariantDerivativeOnUniv.exists_one_form
+
+end classification
+
+end IsCovariantDerivativeOn
diff --git a/Mathlib/Geometry/Manifold/VectorBundle/GramSchmidtOrtho.lean b/Mathlib/Geometry/Manifold/VectorBundle/GramSchmidtOrtho.lean
new file mode 100644
index 00000000000000..874c1a5e272fdb
--- /dev/null
+++ b/Mathlib/Geometry/Manifold/VectorBundle/GramSchmidtOrtho.lean
@@ -0,0 +1,410 @@
+/-
+Copyright (c) 2025 Michael Rothgang. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Patrick Massot, Michael Rothgang
+-/
+module
+
+public import Mathlib.Analysis.InnerProductSpace.GramSchmidtOrtho
+public import Mathlib.Analysis.SpecialFunctions.Sqrt
+public import Mathlib.Geometry.Manifold.VectorBundle.Riemannian
+public import Mathlib.Geometry.Manifold.VectorBundle.SmoothSection
+public import Mathlib.Geometry.Manifold.Notation
+
+/-!
+# Gram-Schmidt orthonormalisation on sections of Riemannian vector bundles
+
+In this file, we provide a version of the Gram-Schmidt orthonormalisation procedure
+for sections of Riemannian vector bundles: this produces a system of sections which orthogonal
+with respect to the bundle metric. If the initial sections were linearly independent resp.
+formed a basis at the point, so do the normalised sections.
+
+If the bundle metric is `C^k`, then the procedure preserves regularity of sections:
+if all sections are `C^k`, so are their normalised versions.
+
+This is used in `OrthonormalFrame.lean` to convert a local frame to a local orthonormal frame.
+
+## Implementation note
+
+
+## Tags
+vector bundle, bundle metric, orthonormal frame, Gram-Schmidt
+
+-/
+
+open Manifold Bundle ContinuousLinearMap ENat Bornology
+open scoped ContDiff Topology
+
+@[expose] public section -- FIXME: re-consider if we really want to expose all definitions
+
+-- Let `V` be a smooth vector bundle with a `C^n` Riemannian structure over a `C^k` manifold `B`.
+variable
+  {EB : Type*} [NormedAddCommGroup EB] [NormedSpace ℝ EB]
+  {HB : Type*} [TopologicalSpace HB] {IB : ModelWithCorners ℝ EB HB} {n : WithTop ℕ∞}
+  {B : Type*} [TopologicalSpace B] [ChartedSpace HB B]
+  {F : Type*} [NormedAddCommGroup F] [NormedSpace ℝ F]
+  {E : B → Type*} [TopologicalSpace (TotalSpace F E)] [∀ x, NormedAddCommGroup (E x)]
+  [∀ x, InnerProductSpace ℝ (E x)] [FiberBundle F E] [VectorBundle ℝ F E]
+  [IsManifold IB n B] [ContMDiffVectorBundle n F E IB]
+  [IsContMDiffRiemannianBundle IB n F E]
+
+variable {ι : Type*} [LinearOrder ι] [LocallyFiniteOrderBot ι] [WellFoundedLT ι]
+
+attribute [local instance] IsWellOrder.toHasWellFounded
+
+local notation "⟪" x ", " y "⟫" => inner ℝ x y
+
+open Finset
+
+namespace VectorBundle
+
+open Submodule
+
+/-- The Gram-Schmidt process takes a set of sections as input
+and outputs a set of sections which are point-wise orthogonal with the same span.
+Basically, we apply the Gram-Schmidt algorithm point-wise. -/
+noncomputable def gramSchmidt [WellFoundedLT ι]
+    (s : ι → (x : B) → E x) (n : ι) : (x : B) → E x := fun x ↦
+  InnerProductSpace.gramSchmidt ℝ (s · x) n
+
+-- Let `s i` be a collection of sections in `E`, indexed by `ι`.
+variable {s : ι → (x : B) → E x}
+
+omit [TopologicalSpace B]
+
+variable (s) in
+/-- This lemma uses `∑ i in` instead of `∑ i :`. -/
+theorem gramSchmidt_def (n : ι) (x) :
+    gramSchmidt s n x = s n x - ∑ i ∈ Iio n, (ℝ ∙ gramSchmidt s i x).starProjection (s n x) := by
+  rw [gramSchmidt, InnerProductSpace.gramSchmidt_def]
+  congr
+
+variable (s) in
+theorem gramSchmidt_def' (n : ι) (x) :
+    s n x = gramSchmidt s n x + ∑ i ∈ Iio n, (ℝ ∙ gramSchmidt s i x).starProjection (s n x) := by
+  rw [gramSchmidt_def, sub_add_cancel]
+
+variable (s) in
+theorem gramSchmidt_def'' (n : ι) (x) :
+    s n x = gramSchmidt s n x + ∑ i ∈ Iio n,
+      (⟪gramSchmidt s i x, s n x⟫ / (‖gramSchmidt s i x‖) ^ 2) • gramSchmidt s i x :=
+  InnerProductSpace.gramSchmidt_def'' ℝ (s · x) n
+
+variable (s) in
+@[simp]
+lemma gramSchmidt_apply (n : ι) (x) :
+    gramSchmidt s n x = InnerProductSpace.gramSchmidt ℝ (s · x) n := rfl
+
+variable (s) in
+@[simp]
+theorem gramSchmidt_bot {ι : Type*} [LinearOrder ι] [LocallyFiniteOrder ι] [OrderBot ι]
+    [WellFoundedLT ι] (s : ι → (x : B) → E x) : gramSchmidt s ⊥ = s ⊥ := by
+  ext x
+  apply InnerProductSpace.gramSchmidt_bot
+
+@[simp]
+theorem gramSchmidt_zero (n : ι) : gramSchmidt (0 : ι → (x : B) → E x) n = 0 := by
+  ext x
+  simpa using InnerProductSpace.gramSchmidt_zero ..
+
+variable (s) in
+/-- **Gram-Schmidt Orthogonalisation**: `gramSchmidt` produces a point-wise orthogonal system
+of sections. -/
+theorem gramSchmidt_orthogonal {a b : ι} (h₀ : a ≠ b) (x) :
+    ⟪gramSchmidt s a x, gramSchmidt s b x⟫ = 0 :=
+  InnerProductSpace.gramSchmidt_orthogonal _ _ h₀
+
+variable (s) in
+/-- This is another version of `gramSchmidt_orthogonal` using `Pairwise` instead. -/
+theorem gramSchmidt_pairwise_orthogonal (x) :
+    Pairwise fun a b ↦ ⟪gramSchmidt s a x, gramSchmidt s b x⟫ = 0 :=
+  fun _ _ h ↦ gramSchmidt_orthogonal s h _
+
+variable (s) in
+theorem gramSchmidt_inv_triangular {i j : ι} (hij : i < j) (x) :
+    ⟪gramSchmidt s j x, s i x⟫ = 0 :=
+  InnerProductSpace.gramSchmidt_inv_triangular _ _ hij
+
+open Submodule Set Order
+
+variable (s) in
+theorem mem_span_gramSchmidt {i j : ι} (hij : i ≤ j) (x) :
+    s i x ∈ span ℝ ((gramSchmidt s · x) '' Set.Iic j) :=
+  InnerProductSpace.mem_span_gramSchmidt _ _ hij
+
+variable (s) in
+theorem gramSchmidt_mem_span (x) :
+    ∀ {j i}, i ≤ j → gramSchmidt s i x ∈ span ℝ ((s · x) '' Set.Iic j) :=
+  InnerProductSpace.gramSchmidt_mem_span _ _
+
+variable (s) in
+theorem span_gramSchmidt_Iic (c : ι) (x) :
+    span ℝ ((gramSchmidt s · x) '' Set.Iic c) = span ℝ ((s · x) '' Set.Iic c) :=
+  InnerProductSpace.span_gramSchmidt_Iic ..
+
+variable (s) in
+theorem span_gramSchmidt_Iio (c : ι) (x) :
+    span ℝ ((gramSchmidt s · x) '' Set.Iio c) = span ℝ ((s · x) '' Set.Iio c) :=
+  InnerProductSpace.span_gramSchmidt_Iio _ _ _
+
+variable (s) in
+/-- `gramSchmidt` preserves the point-wise span of sections. -/
+theorem span_gramSchmidt (x : B) :
+    span ℝ (range (gramSchmidt s · x)) = Submodule.span ℝ (range (s · x)) :=
+  InnerProductSpace.span_gramSchmidt ℝ (s · x)
+
+/-- If the section values `s i x` are orthogonal, `gramSchmidt` yields the same values at `x`. -/
+theorem gramSchmidt_of_orthogonal {x} (hs : Pairwise fun i j ↦ ⟪s i x, s j x⟫ = 0) :
+    ∀ i₀, gramSchmidt s i₀ x = s i₀ x:= by
+  simp_rw [gramSchmidt]
+  exact fun i ↦ congrFun (InnerProductSpace.gramSchmidt_of_orthogonal ℝ hs) i
+
+theorem gramSchmidt_ne_zero_coe (n : ι) (x)
+    (h₀ : LinearIndependent ℝ ((s · x) ∘ ((↑) : Set.Iic n → ι))) : gramSchmidt s n x ≠ 0 :=
+  InnerProductSpace.gramSchmidt_ne_zero_coe _ h₀
+
+variable (s) in
+/-- If the input sections of `gramSchmidt` are point-wise linearly independent,
+the resulting sections are non-zero. -/
+theorem gramSchmidt_ne_zero (n : ι) {x} (h₀ : LinearIndependent ℝ (s · x)) :
+    gramSchmidt s n x ≠ 0 :=
+  InnerProductSpace.gramSchmidt_ne_zero _ h₀
+
+-- No version of `gramSchmidt_triangular` at the moment, for technical reasons: it would expect a
+-- `Basis` (of vectors in `E x`) as input, whereas we would want a hypothesis "the section values
+-- `s i x` form a basis" instead.
+
+/-- `gramSchmidt` produces point-wise linearly independent sections when given linearly
+independent sections. -/
+theorem gramSchmidt_linearIndependent {x} (h₀ : LinearIndependent ℝ (s · x)) :
+    LinearIndependent ℝ (gramSchmidt s · x) :=
+  InnerProductSpace.gramSchmidt_linearIndependent h₀
+
+/-- When the sections `s` form a basis at `x`, so do the sections `gramSchmidt s`. -/
+noncomputable def gramSchmidtBasis {x} (hs : LinearIndependent ℝ (s · x))
+    (hs' : ⊤ ≤ Submodule.span ℝ (Set.range (s · x))) :
+    Module.Basis ι ℝ (E x) :=
+  Module.Basis.mk (gramSchmidt_linearIndependent hs)
+    ((span_gramSchmidt s x).trans (eq_top_iff'.mpr fun _ ↦ hs' trivial)).ge
+
+theorem coe_gramSchmidtBasis {x} (hs : LinearIndependent ℝ (s · x))
+    (hs' : ⊤ ≤ Submodule.span ℝ (Set.range (s · x))) :
+    (gramSchmidtBasis hs hs') = (gramSchmidt s · x) :=
+  Module.Basis.coe_mk _ _
+
+noncomputable def gramSchmidtNormed [WellFoundedLT ι]
+    (s : ι → (x : B) → E x) (n : ι) : (x : B) → E x := fun x ↦
+  InnerProductSpace.gramSchmidtNormed ℝ (s · x) n
+
+lemma gramSchmidtNormed_coe {n : ι} {x} :
+    gramSchmidtNormed s n x = ‖gramSchmidt s n x‖⁻¹ • gramSchmidt s n x := by
+  simp [gramSchmidtNormed, InnerProductSpace.gramSchmidtNormed]
+
+variable {x}
+
+theorem gramSchmidtNormed_unit_length_coe (n : ι)
+    (h₀ : LinearIndependent ℝ ((s · x) ∘ ((↑) : Set.Iic n → ι))) :
+    ‖gramSchmidtNormed s n x‖ = 1 :=
+  InnerProductSpace.gramSchmidtNormed_unit_length_coe n h₀
+
+theorem gramSchmidtNormed_unit_length (n : ι) (h₀ : LinearIndependent ℝ (s · x)) :
+    ‖gramSchmidtNormed s n x‖ = 1 :=
+  InnerProductSpace.gramSchmidtNormed_unit_length n h₀
+
+theorem gramSchmidtNormed_unit_length' {n : ι} (hn : gramSchmidtNormed s n x ≠ 0) :
+    ‖gramSchmidtNormed s n x‖ = 1 :=
+  InnerProductSpace.gramSchmidtNormed_unit_length' hn
+
+/-- **Gram-Schmidt Orthonormalization**: `gramSchmidtNormed` applied to a point-wise linearly
+independent set of sections produces a point-wise orthornormal system of sections. -/
+theorem gramSchmidtNormed_orthonormal (h₀ : LinearIndependent ℝ (s · x)) :
+    Orthonormal ℝ (gramSchmidtNormed s · x) :=
+  InnerProductSpace.gramSchmidtNormed_orthonormal h₀
+
+variable (s) in
+/-- **Gram-Schmidt Orthonormalization**: `gramSchmidtNormed` produces a point-wise orthornormal
+system of sections after removing the sections which become zero in the process. -/
+theorem gramSchmidtNormed_orthonormal' (x) :
+    Orthonormal ℝ fun i : { i | gramSchmidtNormed s i x ≠ 0 } => gramSchmidtNormed s i x :=
+  InnerProductSpace.gramSchmidtNormed_orthonormal' _
+
+open Submodule Set Order
+
+variable (s) in
+theorem span_gramSchmidtNormed (t : Set ι) (x) :
+    span ℝ ((gramSchmidtNormed s · x) '' t) = span ℝ ((gramSchmidt s · x) '' t) :=
+  InnerProductSpace.span_gramSchmidtNormed (s · x) t
+
+variable (s) in
+theorem span_gramSchmidtNormed_range (x) :
+    span ℝ (range (gramSchmidtNormed s · x)) = span ℝ (range (gramSchmidt s · x)) := by
+  simpa only [image_univ.symm] using span_gramSchmidtNormed s Set.univ x
+
+/-- `gramSchmidtNormed` applied to linearly independent sections at a point `x` produces
+sections which are linearly independent at `x`. -/
+theorem gramSchmidtNormed_linearIndependent (h₀ : LinearIndependent ℝ (s · x)) :
+    LinearIndependent ℝ (gramSchmidtNormed s · x) := by
+  simp [gramSchmidtNormed, InnerProductSpace.gramSchmidtNormed_linearIndependent h₀]
+
+lemma gramSchmidtNormed_apply_of_orthogonal (hs : Pairwise fun i j ↦ ⟪s i x, s j x⟫ = 0) {i : ι} :
+    gramSchmidtNormed s i x = (‖s i x‖⁻¹ : ℝ) • s i x := by
+  simp_rw [gramSchmidtNormed_coe, gramSchmidt_of_orthogonal hs i]
+
+/-- If the section values `s i x` are orthonormal, applying `gramSchmidtNormed` yields the same
+values at `x`. -/
+lemma gramSchmidtNormed_apply_of_orthonormal {x} (hs : Orthonormal ℝ (s · x)) (i : ι) :
+    gramSchmidtNormed s i x = s i x := by
+  simp [gramSchmidtNormed_apply_of_orthogonal hs.2, hs.1 i]
+
+-- TODO: comment on the different design compared to `InnerProductSpace.gramSchmidtOrthonormalBasis`
+
+/-- When the sections `s` form a basis at `x`, so do the sections `gramSchmidtNormed s`.
+
+Prefer using `gramSchmidtOrthonormalBasis` over this declaration. -/
+noncomputable def gramSchmidtNormedBasis {x} (hs : LinearIndependent ℝ (s · x))
+    (hs' : ⊤ ≤ Submodule.span ℝ (Set.range (s · x))) :
+    Module.Basis ι ℝ (E x) :=
+  Module.Basis.mk (v := fun i ↦ gramSchmidtNormed s i x) (gramSchmidtNormed_linearIndependent hs)
+    (by rw [span_gramSchmidtNormed_range s x, span_gramSchmidt s x]; exact hs')
+
+/-- Prefer using `gramSchmidtOrthonormalBasis` over this declaration. -/
+@[simp]
+theorem coe_gramSchmidtNormedBasis {x} (hs : LinearIndependent ℝ (s · x))
+    (hs' : ⊤ ≤ Submodule.span ℝ (Set.range (s · x))) :
+    (gramSchmidtNormedBasis hs hs' : ι → E x) = (gramSchmidtNormed s · x) :=
+  Module.Basis.coe_mk _ _
+
+noncomputable def gramSchmidtOrthonormalBasis {x} [Fintype ι]
+    (hs : LinearIndependent ℝ (s · x)) (hs' : ⊤ ≤ Submodule.span ℝ (Set.range (s · x))) :
+    OrthonormalBasis ι ℝ (E x) := by
+  apply (gramSchmidtNormedBasis hs hs').toOrthonormalBasis
+  simp [gramSchmidtNormed_orthonormal hs]
+
+@[simp]
+theorem gramSchmidtOrthonormalBasis_coe [Fintype ι] {x} (hs : LinearIndependent ℝ (s · x))
+    (hs' : ⊤ ≤ Submodule.span ℝ (Set.range (s · x))) :
+    (gramSchmidtOrthonormalBasis hs hs' : ι → E x) = (gramSchmidtNormed s · x) := by
+  simp [gramSchmidtOrthonormalBasis]
+
+theorem gramSchmidtOrthonormalBasis_apply_of_orthonormal [Fintype ι] {x}
+    (hs : Orthonormal ℝ (s · x)) (hs' : ⊤ ≤ Submodule.span ℝ (Set.range (s · x))) :
+    (gramSchmidtOrthonormalBasis hs.linearIndependent hs') = (s · x) := by
+  simp [gramSchmidtNormed_apply_of_orthonormal hs]
+
+end VectorBundle
+
+/-! The Gram-Schmidt process preserves smoothness of sections -/
+
+variable {n : WithTop ℕ∞}
+
+variable [IsContMDiffRiemannianBundle IB n F E]
+
+section helper
+
+variable {s t : (x : B) → E x} {u : Set B} {x : B}
+
+-- TODO: give a much better name!
+lemma contMDiffWithinAt_aux
+    (hs : CMDiffAt[u] n (T% s) x) (ht : CMDiffAt[u] n (T% t) x) (hs' : s x ≠ 0) :
+    CMDiffAt[u] n (fun x ↦ ⟪s x, t x⟫ / (‖s x‖ ^ 2)) x := by
+  have := (hs.inner_bundle ht).smul ((hs.inner_bundle hs).inv₀ (inner_self_ne_zero.mpr hs'))
+  apply this.congr
+  · intro y hy
+    congr
+    simp [inner_self_eq_norm_sq_to_K]
+  · congr
+    rw [← real_inner_self_eq_norm_sq]
+
+lemma contMDiffAt_aux (hs : CMDiffAt n (T% s) x) (ht : CMDiffAt n (T% t) x) (hs' : s x ≠ 0) :
+    CMDiffAt n (fun x ↦ ⟪s x, t x⟫ / (‖s x‖ ^ 2)) x := by
+  rw [← contMDiffWithinAt_univ] at hs ht ⊢
+  exact contMDiffWithinAt_aux hs ht hs'
+
+def ContMDiffWithinAt.orthogonalProjection
+    (hs : CMDiffAt[u] n (T% s) x) (ht : CMDiffAt[u] n (T% t) x) (hs' : s x ≠ 0) :
+    CMDiffAt[u] n (T% (fun x ↦ (Submodule.span ℝ {s x}).starProjection (t x))) x := by
+  simp_rw [Submodule.starProjection_singleton]
+  exact (contMDiffWithinAt_aux hs ht hs').smul_section hs
+
+lemma contMDiffWithinAt_inner (hs : CMDiffAt[u] n (T% s) x) (hs' : s x ≠ 0) :
+    CMDiffAt[u] n (‖s ·‖) x := by
+  let F (x) := ⟪s x, s x⟫
+  have aux : CMDiffAt[u] n (Real.sqrt ∘ F) x := by
+    have h1 : CMDiffAt[(F '' u)] n (Real.sqrt) (F x) := by
+      apply ContMDiffAt.contMDiffWithinAt
+      rw [contMDiffAt_iff_contDiffAt]
+      exact Real.contDiffAt_sqrt (by simp [F, hs'])
+    exact h1.comp x (hs.inner_bundle hs) (Set.mapsTo_image _ u)
+  convert aux
+  simp [F]
+
+end helper
+
+variable {s : ι → (x : B) → E x} {u : Set B} {x : B} {i : ι}
+
+lemma gramSchmidt_contMDiffWithinAt (hs : ∀ i, CMDiffAt[u] n (T% (s i)) x)
+    {i : ι} (hs' : LinearIndependent ℝ ((s · x) ∘ ((↑) : Set.Iic i → ι))) :
+    CMDiffAt[u] n (T% (VectorBundle.gramSchmidt s i)) x := by
+  -- XXX: this `suffices` used to be just `simp only [VectorBundle.gramSchmidt_def]`
+  suffices CMDiffAt[u] n (T% (fun x ↦ s i x - ∑ j ∈ Iio i,
+      (ℝ ∙ VectorBundle.gramSchmidt s j x).starProjection (s i x))) x by
+    simp_rw [VectorBundle.gramSchmidt]
+    apply this.congr
+    · intro x hx
+      rw [InnerProductSpace.gramSchmidt_def]; simp
+    · rw [InnerProductSpace.gramSchmidt_def]; simp
+  apply (hs i).sub_section
+  apply ContMDiffWithinAt.sum_section
+  intro i' hi'
+  let aux : { x // x ∈ Set.Iic i' } → { x // x ∈ Set.Iic i } :=
+    fun ⟨x, hx⟩ ↦ ⟨x, hx.trans (Finset.mem_Iio.mp hi').le⟩
+  have : LinearIndependent ℝ ((fun x_1 ↦ s x_1 x) ∘ @Subtype.val ι fun x ↦ x ∈ Set.Iic i') := by
+    apply hs'.comp aux
+    intro ⟨x, hx⟩ ⟨x', hx'⟩ h
+    simp_all only [Subtype.mk.injEq, aux]
+  apply ContMDiffWithinAt.orthogonalProjection (gramSchmidt_contMDiffWithinAt hs this) (hs i)
+  apply VectorBundle.gramSchmidt_ne_zero_coe _ _ this
+termination_by i
+decreasing_by exact (LocallyFiniteOrderBot.finset_mem_Iio i i').mp hi'
+
+lemma gramSchmidt_contMDiffAt (hs : ∀ i, CMDiffAt n (T% (s i)) x)
+    (hs' : LinearIndependent ℝ ((s · x) ∘ ((↑) : Set.Iic i → ι))) :
+    CMDiffAt n (T% (VectorBundle.gramSchmidt s i)) x :=
+  contMDiffWithinAt_univ.mpr <| gramSchmidt_contMDiffWithinAt (fun i ↦ hs i) hs'
+
+lemma gramSchmidt_contMDiffOn (hs : ∀ i, CMDiff[u] n (T% (s i)))
+    (hs' : ∀ x ∈ u, LinearIndependent ℝ ((s · x) ∘ ((↑) : Set.Iic i → ι))) :
+    CMDiff[u] n (T% (VectorBundle.gramSchmidt s i)) :=
+  fun x hx ↦ gramSchmidt_contMDiffWithinAt (fun i ↦ hs i x hx) (hs' _ hx)
+
+lemma gramSchmidt_contMDiff (hs : ∀ i, CMDiff n (T% (s i)))
+    (hs' : ∀ x, LinearIndependent ℝ ((s · x) ∘ ((↑) : Set.Iic i → ι))) :
+    CMDiff n (T% (VectorBundle.gramSchmidt s i)) :=
+  fun x ↦ gramSchmidt_contMDiffAt (fun i ↦ hs i x) (hs' x)
+
+lemma gramSchmidtNormed_contMDiffWithinAt (hs : ∀ i, CMDiffAt[u] n (T% (s i)) x)
+    (hs' : LinearIndependent ℝ ((s · x) ∘ ((↑) : Set.Iic i → ι))) :
+    CMDiffAt[u] n (T% (VectorBundle.gramSchmidtNormed s i)) x := by
+  have : CMDiffAt[u] n (T%
+      (fun x ↦ ‖VectorBundle.gramSchmidt s i x‖⁻¹ • VectorBundle.gramSchmidt s i x)) x := by
+    refine ContMDiffWithinAt.smul_section ?_ (gramSchmidt_contMDiffWithinAt hs hs')
+    refine ContMDiffWithinAt.inv₀ ?_ ?_
+    · refine contMDiffWithinAt_inner (gramSchmidt_contMDiffWithinAt hs hs') ?_
+      simpa using InnerProductSpace.gramSchmidt_ne_zero_coe i hs'
+    · simpa using InnerProductSpace.gramSchmidt_ne_zero_coe i hs'
+  exact this.congr (fun y hy ↦ by congr) (by congr)
+
+lemma gramSchmidtNormed_contMDiffAt (hs : ∀ i, CMDiffAt n (T% (s i)) x)
+    (hs' : LinearIndependent ℝ ((s · x) ∘ ((↑) : Set.Iic i → ι)))
+    : CMDiffAt n (T% (VectorBundle.gramSchmidtNormed s i)) x :=
+  contMDiffWithinAt_univ.mpr <| gramSchmidtNormed_contMDiffWithinAt (fun i ↦ hs i) hs'
+
+lemma gramSchmidtNormed_contMDiffOn (hs : ∀ i, CMDiff[u] n (T% (s i)))
+    (hs' : ∀ x ∈ u, LinearIndependent ℝ ((s · x) ∘ ((↑) : Set.Iic i → ι))) :
+    CMDiff[u] n (T% (VectorBundle.gramSchmidtNormed s i)) :=
+  fun x hx ↦ gramSchmidtNormed_contMDiffWithinAt (fun i ↦ hs i x hx) (hs' _ hx)
+
+lemma gramSchmidtNormed_contMDiff (hs : ∀ i, CMDiff n (T% (s i)))
+    (hs' : ∀ x, LinearIndependent ℝ ((s · x) ∘ ((↑) : Set.Iic i → ι))) :
+    CMDiff n (T% (VectorBundle.gramSchmidtNormed s i)) :=
+  fun x ↦ gramSchmidtNormed_contMDiffAt (fun i ↦ hs i x) (hs' x)
diff --git a/Mathlib/Geometry/Manifold/VectorBundle/Hom.lean b/Mathlib/Geometry/Manifold/VectorBundle/Hom.lean
index be3e858a823f63..c33a2f36d88ea6 100644
--- a/Mathlib/Geometry/Manifold/VectorBundle/Hom.lean
+++ b/Mathlib/Geometry/Manifold/VectorBundle/Hom.lean
@@ -6,6 +6,7 @@ Authors: Floris van Doorn
 module
 
 public import Mathlib.Geometry.Manifold.VectorBundle.Basic
+public import Mathlib.Geometry.Manifold.VectorBundle.Tensoriality
 public import Mathlib.Topology.VectorBundle.Hom
 public import Mathlib.Geometry.Manifold.VectorBundle.MDifferentiable
 public import Mathlib.Geometry.Manifold.Notation
@@ -304,6 +305,22 @@ lemma ContMDiff.clm_bundle_apply
     ContMDiff IM (IB.prod 𝓘(𝕜, F₂)) n (fun m ↦ TotalSpace.mk' F₂ (b m) (ϕ m (v m))) :=
   fun x ↦ (hϕ x).clm_bundle_apply (hv x)
 
+/-- Criterion for a section of a Hom-bundle constructed using the tensoriality criterion to be
+smooth. -/
+theorem TensorialAt.contMDiff_mkHom [CompleteSpace 𝕜] [IsManifold IB 1 B]
+    [FiniteDimensional 𝕜 F₁]
+    [∀ (x : B), IsTopologicalAddGroup (E₁ x)] [∀ (x : B), ContinuousSMul 𝕜 (E₁ x)]
+    [ContMDiffVectorBundle 1 F₁ E₁ IB]
+    (φ : (Π x : B, E₁ x) → (Π x, E₂ x))
+    (hφ : ∀ x, TensorialAt IB F₁ (φ · x) x)
+    -- hopefully this is the correct smoothness criterion!
+    {k} (φ_contMDiff : ∀ (σ : Π x : B, E₁ x), CMDiff k (T% σ) → CMDiff k (T% (φ σ))) :
+    -- elaborators not working here
+    let T (x : B) : TotalSpace (F₁ →L[𝕜] F₂) (fun x ↦ E₁ x →L[𝕜] E₂ x) :=
+      ⟨x, TensorialAt.mkHom (φ · x) x (hφ x)⟩
+    ContMDiff IB (IB.prod 𝓘(𝕜, F₁ →L[𝕜] F₂)) k T := by
+  sorry
+
 end OneVariable
 
 section OneVariable'
diff --git a/Mathlib/Geometry/Manifold/VectorBundle/LocalFrame.lean b/Mathlib/Geometry/Manifold/VectorBundle/LocalFrame.lean
index 81da73c9e73b5f..d1213dd5361671 100644
--- a/Mathlib/Geometry/Manifold/VectorBundle/LocalFrame.lean
+++ b/Mathlib/Geometry/Manifold/VectorBundle/LocalFrame.lean
@@ -32,8 +32,8 @@ complete field). In the planned file `Mathlib/Geometry/Manifold/VectorBundle/Ort
 metric. This includes bundles of finite rank, modelled on a Hilbert space or on a Banach space which
 has smooth partitions of unity.
 
-We will use this to construct local extensions of a vector to a section which is smooth on the
-trivialisation domain.
+We also use this to extend a vector in a single fiber `V x` to a section near `x` which is
+smooth on the trivialisation domain.
 
 ## Main definitions and results
 
@@ -83,6 +83,18 @@ the model fiber `F`.
 * `e.contMDiffOn_iff_localFrame_coeff b`: a section `s` is `C^k` on an open set `t ⊆ e.baseSet`
   iff all of its frame coefficients are
 
+A local frame can be used to extend any single vector `v : V x` to a section which is smooth near
+`x`, such that the construction is linear in `v`.
+* `localExtensionOn b e v`: given a basis `b` and a compatible trivialisation `e` of `V` near `x`,
+  extend the vector `v : V x` to a section of `V` which is smooth on `e.baseSet`
+* `localExtensionOn_apply_self`: `localExtensionOn b e v x = v`, i.e. we really extend `v` at `x`
+* `contMDiffOn_localExtensionOn`: `localExtensionOn b e v` is `C^n` on `e.baseSet`
+* `localExtensionOn_localFrame_coeff`: `localExtensionOn` has constant frame coefficients
+  (knowing this is sometimes useful when working with local extensions for covariant derivatives)
+* `localExtensionOn_add`, `localExtensionOn_zero` and `localExtensionOn_smul` prove that
+  `v ↦ localExtensionON b e v` is a linear map.
+
+
 ## Note
 
 This file proves smoothness criteria in terms of coefficients for local frames induced by a
@@ -93,8 +105,15 @@ trivialization. A fully frame-intrinsic converse for `IsLocalFrameOn` will be ad
 Local frames use the junk value pattern: they are defined on all of `M`, but their value is
 only meaningful on the set on which they are a local frame.
 
+Note that `localExtensionOn` need not be smooth globally; in turn, this definition makes sense over
+any field. In contrast, an extension to a global holomorphic vector field is more delicate for
+complex vector bundles (whereas *locally* holomorphic sections always exist).
+For real bundles, global extensions always exist and can be constructed by scalar multiplication
+of a local extension with a smooth bump function of sufficiently small support.
+
+
 ## Tags
-vector bundle, local frame, smoothness
+vector bundle, local frame, smoothness, local extension of section
 
 -/
 
@@ -569,3 +588,76 @@ lemma mdifferentiableAt_iff_localFrame_coeff (hx : x' ∈ e.baseSet) :
 end MDifferentiable
 
 end
+
+-- local extension of a vector field in a trivialisation's base set
+section localExtensionOn
+
+variable {e : Trivialization F (TotalSpace.proj : TotalSpace F V → M)} [MemTrivializationAtlas e]
+  {ι : Type*} [Fintype ι] {b : Basis ι 𝕜 F} {x x' : M}
+  [VectorBundle 𝕜 F V]
+
+open scoped Classical in
+/-- Extend a vector `v ∈ V x` to a section `s` of the bundle `V` which is smooth near `x`,
+such that `s x = v` and this construction is linear in `v`.
+
+The details of this extension are unspecified (and could be subject to change).
+Currently, we construct this extension using a local frame induced by a choose of basis of the
+fibre `F` and a compatible trivialisation `e` of `V` around `x`.
+(Allowing any local frame near `x` would be easy to implement.)
+Our construction has constant coefficients on `e.baseSet` w.r.t. this local frame, and is zero
+otherwise. In particular, it is smooth on `e.baseSet`, and (globally) linear in `v`.
+
+We choose an extension with these particularly nice properties because this simplifies later
+constructions on covariant derivatives (and in this context, the value at `s` at points other than
+`x` does not matter, but constant frame coefficients are useful).
+-/
+-- XXX: we could generalise this definition to any local frame on `U ∋ x`, with smoothness on `U`.
+-- Would this be useful? Should do this?
+noncomputable def localExtensionOn (b : Basis ι 𝕜 F)
+    (e : Trivialization F (TotalSpace.proj : TotalSpace F V → M)) [MemTrivializationAtlas e]
+    {x : M} : V x →ₗ[𝕜] ((x' : M) → V x') where
+  toFun v := open scoped Classical in
+    fun x' ↦ if hx : x ∈ e.baseSet then ∑ i, (e.basisAt b hx).repr v i • e.localFrame b i x' else 0
+  map_add' v v' := by
+    ext x'
+    by_cases hx: x ∈ e.baseSet; swap
+    · simp [hx]
+    · simp [hx, add_smul, Finset.sum_add_distrib]
+  map_smul' a v := by
+    ext x'
+    by_cases hx: x ∈ e.baseSet; swap
+    · simp [hx]
+    · simp +contextual [hx, Finset.smul_sum, mul_smul a (((e.basisAt b hx).repr v) _)]
+
+variable (b e) in
+@[simp]
+lemma localExtensionOn_apply_self (hx : x ∈ e.baseSet) (v : V x) :
+    (localExtensionOn b e v) x = v := by
+  simp [localExtensionOn, hx]
+
+variable (b) in
+/-- A local extension has constant frame coefficients within its defining trivialisation. -/
+lemma localExtensionOn_localFrame_coeff [ContMDiffVectorBundle 1 F V I]
+    (hx : x ∈ e.baseSet) (hx' : x' ∈ e.baseSet) (v : V x) (i : ι) :
+    (Trivialization.localFrame_coeff I e b i x') ((localExtensionOn b e) v x') =
+    (Trivialization.localFrame_coeff I e b i x) ((localExtensionOn b e) v x) := by
+  -- Combining these into one `simp` call makes these lemmas never fire.
+  rw [e.localFrame_coeff_apply_of_mem_baseSet b hx ((localExtensionOn b e) v) i,
+    e.localFrame_coeff_apply_of_mem_baseSet b hx' ((localExtensionOn b e) v) i]
+  simp [localExtensionOn, hx, hx']
+
+variable (F) in
+lemma contMDiffOn_localExtensionOn [FiniteDimensional 𝕜 F] [CompleteSpace 𝕜]
+    {x : M} (hx : x ∈ e.baseSet) (v : V x) [ContMDiffVectorBundle ∞ F V I] :
+    CMDiff[e.baseSet] ∞ (T% (localExtensionOn b e v)) := by
+  -- The local frame coefficients of `localExtensionOn` w.r.t. the frame induced by `e` are
+  -- constant, hence smoothness follows.
+  rw [contMDiffOn_baseSet_iff_localFrame_coeff b]
+  intro i
+  simp only [LinearMap.piApply_apply]
+  apply (contMDiffOn_const
+    (c := (Trivialization.localFrame_coeff I e b i x) ((localExtensionOn b e) v x))).congr
+  intro y hy
+  rw [localExtensionOn_localFrame_coeff b hx hy v i]
+
+end localExtensionOn
diff --git a/Mathlib/Geometry/Manifold/VectorBundle/MDifferentiable.lean b/Mathlib/Geometry/Manifold/VectorBundle/MDifferentiable.lean
index aec2e6a784de3f..9eaa0acf875db6 100644
--- a/Mathlib/Geometry/Manifold/VectorBundle/MDifferentiable.lean
+++ b/Mathlib/Geometry/Manifold/VectorBundle/MDifferentiable.lean
@@ -17,9 +17,8 @@ import Mathlib.Geometry.Manifold.Notation
 
 public section
 
-open Bundle Set OpenPartialHomeomorph ContinuousLinearMap Pretrivialization Filter
-
-open scoped Manifold Bundle Topology
+open Bundle Set ContinuousLinearMap Pretrivialization Filter
+open scoped Manifold Topology
 
 section
 
diff --git a/Mathlib/Geometry/Manifold/VectorBundle/OrthonormalFrame.lean b/Mathlib/Geometry/Manifold/VectorBundle/OrthonormalFrame.lean
new file mode 100644
index 00000000000000..c40c1046cd0331
--- /dev/null
+++ b/Mathlib/Geometry/Manifold/VectorBundle/OrthonormalFrame.lean
@@ -0,0 +1,243 @@
+/-
+Copyright (c) 2025 Michael Rothgang. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Patrick Massot, Michael Rothgang
+-/
+module
+
+public import Mathlib.Geometry.Manifold.VectorBundle.GramSchmidtOrtho
+public import Mathlib.Geometry.Manifold.VectorBundle.LocalFrame
+
+/-!
+# Existence of orthonormal frames on Riemannian vector bundles
+
+In this file, we prove that a Riemannian vector bundle has orthonormal frames near each point.
+These are constructed by taking any local frame, and applying Gram-Schmidt orthonormalisation
+to it (point-wise). If the bundle metric is `C^k`, the resulting orthonormal frame also is.
+
+TODO: add main results, etc
+
+## Implementation note
+
+Like local frames, orthonormal frames use the junk value pattern: their value is meaningless
+outside of the `baseSet` of the trivialisation used to define them.
+
+## Tags
+vector bundle, local frame, smoothness
+
+-/
+
+open Manifold Bundle ContinuousLinearMap ENat Bornology
+open scoped ContDiff Topology
+
+-- Let `V` be a smooth vector bundle with a `C^n` Riemannian structure over a `C^k` manifold `B`.
+variable
+  {EB : Type*} [NormedAddCommGroup EB] [NormedSpace ℝ EB]
+  {HB : Type*} [TopologicalSpace HB] {IB : ModelWithCorners ℝ EB HB}
+  {B : Type*} [TopologicalSpace B] [ChartedSpace HB B]
+  {F : Type*} [NormedAddCommGroup F] [NormedSpace ℝ F]
+  {E : B → Type*} [TopologicalSpace (TotalSpace F E)] [∀ x, NormedAddCommGroup (E x)]
+  [∀ x, InnerProductSpace ℝ (E x)] [FiberBundle F E] [VectorBundle ℝ F E] {n : WithTop ℕ∞}
+  [IsManifold IB n B] [ContMDiffVectorBundle n F E IB]
+  [IsContMDiffRiemannianBundle IB n F E]
+
+@[expose] public section -- FIXME: think if expose is desired!
+
+local notation "⟪" x ", " y "⟫" => inner ℝ x y
+
+variable {ι : Type*} [LinearOrder ι] [LocallyFiniteOrderBot ι] [WellFoundedLT ι]
+
+variable {s : ι → (x : B) → E x} {u u' : Set B}
+
+variable (IB F n) in
+structure IsOrthonormalFrameOn (s : ι → (x : B) → E x) (u : Set B)
+    extends IsLocalFrameOn IB F n s u where
+  orthonormal {x} : x ∈ u → Orthonormal ℝ (s · x)
+  -- /-- Any two distinct sections are point-wise orthogonal on `u`. -/
+  -- orthogonal {i j : ι} {x : B} : i ≠ j → x ∈ u → ⟪s i x, s j x⟫ = 0
+  -- normalised {i : ι} {x : B} : x ∈ u → ‖s i x‖ = 1
+
+omit [VectorBundle ℝ F E] [IsManifold IB n B] [ContMDiffVectorBundle n F E IB]
+  [IsContMDiffRiemannianBundle IB n F E]
+  [LinearOrder ι] [LocallyFiniteOrderBot ι] [WellFoundedLT ι] in
+lemma IsOrthonormalFrameOn.mono (hs : IsOrthonormalFrameOn IB F n s u) (huu' : u' ⊆ u) :
+    IsOrthonormalFrameOn IB F n s u' where
+  toIsLocalFrameOn := hs.toIsLocalFrameOn.mono huu'
+  orthonormal hx := hs.orthonormal (huu' hx)
+
+/-- Applying the Gram-Schmidt procedure to a local frame yields an orthonormal local frame. -/
+def IsLocalFrameOn.gramSchmidtNormed (hs : IsLocalFrameOn IB F n s u) :
+    IsOrthonormalFrameOn IB F n (VectorBundle.gramSchmidtNormed s) u where
+  linearIndependent := by
+    intro x hx
+    exact VectorBundle.gramSchmidtNormed_linearIndependent <| hs.linearIndependent hx
+  generating := by
+    intro x hx
+    simpa only [VectorBundle.span_gramSchmidtNormed_range, VectorBundle.gramSchmidt_apply,
+      InnerProductSpace.span_gramSchmidt] using hs.generating hx
+  contMDiffOn i := gramSchmidtNormed_contMDiffOn (fun i ↦ hs.contMDiffOn i) <|
+      fun x hx ↦ (hs.linearIndependent hx).comp _ Subtype.val_injective
+  orthonormal hx := (VectorBundle.gramSchmidtNormed_orthonormal (hs.linearIndependent hx))
+
+-- XXX: is this one necessary?
+/-- Applying the normalised Gram-Schmidt procedure to an orthonormal local frame yields
+another orthonormal local frame. -/
+def IsOrthonormalFrameOn.gramSchmidtNormed (hs : IsOrthonormalFrameOn IB F n s u) :
+    IsOrthonormalFrameOn IB F n (VectorBundle.gramSchmidtNormed s) u :=
+  hs.toIsLocalFrameOn.gramSchmidtNormed
+
+/-! # Determining smoothness of a section via its local frame coefficients
+
+We show that for any orthogonal local frame `{s i}` on `u ⊆ B`, a section `t` is smooth on `u`
+if and only if its coefficients in `{s i}` are. This argument crucially depends on the existence of
+a smooth bundle metric on `V` (which always holds in finite dimensions, and in certain important
+infinite-dimensional cases).
+
+See `LocalFrame.lean` for a similar statement, about local frames induced by a local trivialisation
+on finite rank bundles over any complete field.
+
+The orthogonality requirement can be removed, with additional technical effort: see the comment
+below for details. It simplifies the proofs as the local frame coefficients take a particularly
+simple form in orthgonal frames.
+-/
+
+section smoothness
+
+namespace IsOrthonormalFrameOn
+
+omit [IsManifold IB n B] [ContMDiffVectorBundle n F E IB]
+variable [Fintype ι]
+
+variable (hs : IsOrthonormalFrameOn IB F n s u) {t : (x : B) → E x} {x : B}
+
+omit [VectorBundle ℝ F E] [IsManifold IB n B] [ContMDiffVectorBundle n F E IB]
+  [IsContMDiffRiemannianBundle IB n F E] in
+variable (t) in
+lemma coeff_eq_inner' (hs : IsOrthonormalFrameOn IB F n s u) (hx : x ∈ u) (i : ι) :
+    hs.coeff i x (t x) = ⟪s i x, t x⟫ := by
+  let b := VectorBundle.gramSchmidtOrthonormalBasis (hs.linearIndependent hx) (hs.generating hx)
+  have beq (i : ι) : b i = s i x := by
+    simp [b, VectorBundle.gramSchmidtNormed_apply_of_orthonormal (hs.orthonormal hx) i]
+  have heq' : b.toBasis = hs.toBasisAt hx := by
+    ext i
+    simp [b, VectorBundle.gramSchmidtNormed_apply_of_orthonormal (hs.orthonormal hx) i]
+  have aux := b.repr_apply_apply (t x) i
+  rw [beq] at aux
+  simp [← aux, IsLocalFrameOn.coeff, hx, ← heq']
+
+-- This lemma would hold more generally for an *orthogonal frame*.
+-- variable (t) in
+-- lemma coeff_eq_inner (hs : IsOrthonormalFrameOn IB F n s u) (hx : x ∈ u) (i : ι) :
+--     hs.coeff i t x = ⟪s i x, t x⟫ / (‖s i x‖ ^ 2) := by
+--   sorry -- need a version of b.repr_apply_apply for *orthogonal* bases
+
+/-- If `t` is `C^k` at `x`, so is its coefficient `hs.coeff i t` in a local frame s near `x` -/
+lemma contMDiffWithinAt_coeff (ht : CMDiffAt[u] n (T% t) x) (hx : x ∈ u) (i : ι) :
+    CMDiffAt[u] n (LinearMap.piApply (hs.coeff i) t) x :=
+  ((hs.contMDiffOn i x hx).inner_bundle ht).congr_of_mem (fun _ hy ↦ hs.coeff_eq_inner' _ hy _) hx
+
+omit [IsManifold IB n B] [ContMDiffVectorBundle n F E IB] in
+/-- If `t` is `C^k` at `x`, so is its coefficient `hs.coeff i t` in a local frame s near `x` -/
+lemma contMDiffAt_coeff (hu : u ∈ 𝓝 x) (ht : CMDiffAt n (T% t) x) (i : ι) :
+    CMDiffAt n (LinearMap.piApply (hs.coeff i) t) x :=
+  (((hs.contMDiffOn i).contMDiffAt hu).inner_bundle ht).congr_of_eventuallyEq <|
+    Filter.eventually_of_mem hu fun _ hx ↦ hs.coeff_eq_inner' _ hx _
+
+-- Future: prove the same result for all local frames
+-- if `{s i}` is a local frame on `u`, and `{s' i}` are the corresponding orthogonalised frame,
+-- for each `x ∈ u` the vectors `{s i x}` and `{s' i x}` are bases of `E x`,
+-- and the coefficients w.r.t. `s i` and `s' i x` are related by the base change matrix.
+-- This matrix depends smoothly on `x`, hence the frame coefficients w.r.t. `{s i}` are smooth iff
+-- those w.r.t. `{s' i}` are.
+
+/-- If `{s i}` is an orthogonal local frame on a neighbourhood `u` of `x` and `t` is `C^k` on `u`,
+so is its coefficient in the frame `{s i}`. -/
+lemma contMDiffOn_coeff (ht : CMDiff[u] n (T% t)) (i : ι) :
+    CMDiff[u] n (LinearMap.piApply (hs.coeff i) t) :=
+  fun x' hx ↦ hs.contMDiffWithinAt_coeff (ht x' hx) hx _
+
+/-- A section `s` of `V` is `C^k` at `x` iff each of its coefficients in an orthogonal
+local frame near `x` is. -/
+lemma contMDiffAt_iff_coeff [FiniteDimensional ℝ F] (hu : u ∈ 𝓝 x) :
+    CMDiffAt n (T% t) x ↔ ∀ i, CMDiffAt n (LinearMap.piApply (hs.coeff i) t) x :=
+  ⟨fun h i ↦ hs.contMDiffAt_coeff hu h i, fun h ↦ hs.contMDiffAt_of_coeff h hu⟩
+
+/-- If `{s i}` is an orthogonal local frame on `s`, a section `s` of `V` is `C^k` on `u` iff
+each of its coefficients `hs.coeff i s` w.r.t. the local frame `{s i}` is. -/
+lemma contMDiffOn_iff_coeff [FiniteDimensional ℝ F] :
+    CMDiff[u] n (T% t) ↔ ∀ i, CMDiff[u] n (LinearMap.piApply (hs.coeff i) t) :=
+  ⟨fun h i ↦ hs.contMDiffOn_coeff h i, fun hi ↦ hs.contMDiffOn_of_coeff hi⟩
+
+-- unused, just stating for convenience/nice API
+include hs in
+lemma contMDiffAt_iff_coeff' [FiniteDimensional ℝ F] (hu : u ∈ 𝓝 x) :
+    CMDiffAt n (T% t) x ↔ ∀ i, CMDiffAt n (fun x ↦ ⟪s i x, t x⟫) x := by
+  rw [hs.contMDiffAt_iff_coeff hu]
+  have (i : ι) := Filter.eventually_of_mem hu fun x hx ↦ (hs.coeff_eq_inner' t hx i)
+  exact ⟨fun h i ↦ (h i).congr_of_eventuallyEq <| Filter.EventuallyEq.symm (this i),
+    fun h i ↦ (h i).congr_of_eventuallyEq (this i)⟩
+
+-- unused, just stating for convenience/nice API
+lemma contMDiffOn_iff_coeff' :
+    CMDiff[u] n (T% t) ↔ ∀ i, CMDiff[u] n (fun x ↦ ⟪s i x, t x⟫) :=
+  sorry -- similar to the above lemma
+
+end IsOrthonormalFrameOn
+
+end smoothness
+
+namespace Module.Basis
+
+variable {b : Basis ι ℝ F}
+    {e : Trivialization F (Bundle.TotalSpace.proj : Bundle.TotalSpace F E → B)}
+    [MemTrivializationAtlas e] {x : B} -- (hx : x ∈ e.baseSet)
+
+variable (b e) in
+/-- The orthonormal frame associated to the basis `b` and the trivialisation `e`:
+this is obtained by applying the Gram-Schmidt orthonormalisation procedure to `b.localFrame e`.
+In particular, if x is outside of `e.baseSet`, this returns the junk value 0. -/
+noncomputable def orthonormalFrame : ι → (x : B) → E x :=
+  VectorBundle.gramSchmidtNormed (e.localFrame b)
+
+omit [IsManifold IB n B] in
+variable (b e) in
+/-- An orthonormal frame w.r.t. a local trivialisation is an orthonormal local frame. -/
+lemma orthonormalFrame_isOrthonormalFrameOn :
+    IsOrthonormalFrameOn IB F n (b.orthonormalFrame e) e.baseSet :=
+  (e.isLocalFrameOn_localFrame_baseSet IB n b).gramSchmidtNormed
+
+omit [IsManifold IB n B] in
+variable (b e) in
+/-- Each orthonormal frame `s^i ∈ Γ(E)` of a `C^k` vector bundle, defined by a local
+trivialisation `e`, is `C^k` on `e.baseSet`. -/
+lemma contMDiffOn_orthonormalFrame_baseSet (i : ι) :
+    CMDiff[e.baseSet] n (T% (b.orthonormalFrame e i)) := by
+  apply IsLocalFrameOn.contMDiffOn
+  exact (b.orthonormalFrame_isOrthonormalFrameOn e).toIsLocalFrameOn
+
+omit [IsManifold IB n B] in
+variable (b e) in
+lemma _root_.contMDiffAt_orthonormalFrame_of_mem (i : ι) {x : B} (hx : x ∈ e.baseSet) :
+    CMDiffAt n (T% (b.orthonormalFrame e i)) x :=
+  -- bug: if I change this to a by apply, and put #check after the `by`, it works, but #check' fails
+  -- #check' contMDiffOn_orthonormalFrame_baseSet
+  (contMDiffOn_orthonormalFrame_baseSet b e i).contMDiffAt <| e.open_baseSet.mem_nhds hx
+
+-- TODO: add more variants with mdifferentiable!
+omit [ContMDiffVectorBundle n F E IB] [IsContMDiffRiemannianBundle IB n F E] in
+variable [ContMDiffVectorBundle 1 F E IB] [IsContMDiffRiemannianBundle IB 1 F E] in
+variable (b e) in
+lemma _root_.mdifferentiableAt_orthonormalFrame_of_mem (i : ι) {x : B} (hx : x ∈ e.baseSet) :
+    MDiffAt (T% (b.orthonormalFrame e i)) x := by
+  apply ContMDiffAt.mdifferentiableAt _ one_ne_zero
+  exact (contMDiffOn_orthonormalFrame_baseSet b e i).contMDiffAt <| e.open_baseSet.mem_nhds hx
+
+@[simp]
+lemma orthonormalFrame_apply_of_notMem {i : ι} (hx : x ∉ e.baseSet) :
+    b.orthonormalFrame e i x = 0 := by
+  simp only [orthonormalFrame, VectorBundle.gramSchmidtNormed, InnerProductSpace.gramSchmidtNormed,
+    RCLike.ofReal_real_eq_id, id_eq, smul_eq_zero, inv_eq_zero, norm_eq_zero, or_self]
+  convert InnerProductSpace.gramSchmidt_zero ℝ i
+  exact e.localFrame_apply_of_notMem b hx
+
+end Module.Basis
diff --git a/Mathlib/Geometry/Manifold/VectorBundle/SmoothSection.lean b/Mathlib/Geometry/Manifold/VectorBundle/SmoothSection.lean
index 12d21cd26fce89..3eb794b53d0b3f 100644
--- a/Mathlib/Geometry/Manifold/VectorBundle/SmoothSection.lean
+++ b/Mathlib/Geometry/Manifold/VectorBundle/SmoothSection.lean
@@ -7,9 +7,9 @@ module
 
 public import Mathlib.Geometry.Manifold.Algebra.LieGroup
 public import Mathlib.Geometry.Manifold.MFDeriv.Basic
-public import Mathlib.Topology.ContinuousMap.Basic
-public import Mathlib.Geometry.Manifold.VectorBundle.Basic
 public import Mathlib.Geometry.Manifold.Notation
+public import Mathlib.Geometry.Manifold.VectorBundle.Basic
+public import Mathlib.Topology.ContinuousMap.Basic
 
 /-!
 # `C^n` sections
@@ -194,6 +194,16 @@ lemma ContMDiffOn.smul_section_of_tsupport {s : Π (x : M), V x} {ψ : M → 
     simp [image_eq_zero_of_notMem_tsupport hy, zeroSection]
   · exact Set.compl_subset_iff_union.mp <| Set.compl_subset_compl.mpr ht'
 
+-- unused
+/-- The scalar product `ψ • s` of a `C^k` function `ψ: M → 𝕜` and a section `s` of a vector
+bundle `V → M` is `C^k` once `s` is `C^k` at each point in `tsupport ψ`.
+
+This is a vector bundle analogue of `contMDiff_of_tsupport`. -/
+lemma ContMDiff.smul_section_of_tsupport' {s : Π (x : M), V x} {ψ : M → 𝕜} {u : Set M}
+    (hs : ∀ x ∈ tsupport ψ, CMDiffAt n (T% (ψ • s)) x) :
+    CMDiff n (T% (ψ • s)) := by
+  sorry
+
 /-- The sum of a locally finite collection of sections is `C^k` iff each section is.
 Version at a point within a set. -/
 lemma ContMDiffWithinAt.sum_section_of_locallyFinite
diff --git a/Mathlib/Geometry/Manifold/VectorBundle/Tensoriality.lean b/Mathlib/Geometry/Manifold/VectorBundle/Tensoriality.lean
index ef3646bfea0e0c..72d93c26d1cd4a 100644
--- a/Mathlib/Geometry/Manifold/VectorBundle/Tensoriality.lean
+++ b/Mathlib/Geometry/Manifold/VectorBundle/Tensoriality.lean
@@ -59,6 +59,12 @@ variable
   [∀ x, AddCommGroup (V' x)] [∀ x, Module 𝕜 (V' x)] [∀ x : M, TopologicalSpace (V' x)]
   [FiberBundle F' V']
 
+variable
+  (F'' : Type*) [NormedAddCommGroup F''] [NormedSpace 𝕜 F'']
+  {V'' : M → Type*} [TopologicalSpace (TotalSpace F'' V'')]
+  [∀ x, AddCommGroup (V'' x)] [∀ x, Module 𝕜 (V'' x)] [∀ x : M, TopologicalSpace (V'' x)]
+  [FiberBundle F'' V'']
+
 variable {A : Type*} [AddCommGroup A] [Module 𝕜 A]
 
 /-- An operation `Φ` on sections of a vector bundle `V` over `M` is *tensorial* at `x : M`, if it
@@ -68,7 +74,7 @@ structure TensorialAt (Φ : (Π x : M, V x) → A) (x : M) : Prop where
   add : ∀ {σ σ'}, MDiffAt (T% σ) x → MDiffAt (T% σ') x → Φ (σ + σ') = Φ σ + Φ σ'
 
 variable {Φ : (Π x : M, V x) → A} {x : M}
-variable {I F F'}
+variable {I F F' F''}
 
 namespace TensorialAt
 
@@ -96,7 +102,7 @@ protected theorem «local» (hΦ : TensorialAt I F Φ x) {σ σ' : Π x : M, V x
     _ = Φ (ψ • σ') := by rw [funext this]
     _ = Φ σ' := by simp [hΦ.smul hψ' hσ', hψx]
 
-variable [VectorBundle 𝕜 F V] [VectorBundle 𝕜 F' V']
+variable [VectorBundle 𝕜 F V] [VectorBundle 𝕜 F' V'] [VectorBundle 𝕜 F'' V'']
 
 /-- A tensorial operation on sections of a vector bundle respects zero (since it respects scalar
   multiplication). -/
@@ -120,8 +126,10 @@ theorem sum (hΦ : TensorialAt I F Φ x) {ι : Type*} {s : Finset ι} (σ : ι 
       simp only [Finset.sum_insert ha, ← h]
       exact hΦ.add (hσ a) (.sum_section hσ)
 
-variable [CompleteSpace 𝕜] [FiniteDimensional 𝕜 F] [FiniteDimensional 𝕜 F']
+variable [CompleteSpace 𝕜]
+  [FiniteDimensional 𝕜 F] [FiniteDimensional 𝕜 F'] [FiniteDimensional 𝕜 F'']
   [ContMDiffVectorBundle 1 F V I] [ContMDiffVectorBundle 1 F' V' I]
+  [ContMDiffVectorBundle 1 F'' V'' I]
 
 /-- If the operation `Φ` on sections of a vector bundle `V` is tensorial at `x`, then it depends
 only on the value of the section at `x`. -/
@@ -285,4 +293,38 @@ theorem mkHom₂_apply_eq_extend
     mkHom₂ Φ x hΦ₁ hΦ₂ σ τ = Φ (extend F σ) (extend F' τ) :=
   rfl
 
+/-- Given an `A`-valued operation `Φ` on sections of vector bundles `V`, `V'` and `V''` which is
+tensorial at `x` in each argument, the construction `TensorialAt.mkHom₃` provides the associated
+continuous linear map `V x →L[𝕜] V' x →L[𝕜] V'' x →L[𝕜] A`. -/
+noncomputable def mkHom₃
+    -- `Φ` and `x` explicit to make it easier to generate the side conditions at point of use
+    (Φ : (Π x : M, V x) → (Π x : M, V' x) → (Π x : M, V'' x) → A) (x : M)
+    -- TODO: may require further differentiability conditions here, or not!
+    -- if so, propagate down below
+    (hΦ₁ : ∀ τ τ', MDiffAt (T% τ) x → TensorialAt I F (Φ · τ τ') x)
+    (hΦ₂ : ∀ σ τ', MDiffAt (T% σ) x → TensorialAt I F' (Φ σ · τ') x)
+    (hΦ₃ : ∀ σ τ, MDiffAt (T% σ) x → TensorialAt I F'' (Φ σ τ ·) x) :
+    V x →L[𝕜] V' x →L[𝕜] V'' x →L[𝕜] A :=
+  sorry -- TODO: prove mutatis mutandis
+
+theorem mkHom₃_apply
+    {Φ : (Π x : M, V x) → (Π x : M, V' x) → (Π x : M, V'' x) → A} {x}
+    (hΦ₁ : ∀ τ τ', MDiffAt (T% τ) x → TensorialAt I F (Φ · τ τ') x)
+    (hΦ₂ : ∀ σ τ', MDiffAt (T% σ) x → TensorialAt I F' (Φ σ · τ') x)
+    (hΦ₃ : ∀ σ τ, MDiffAt (T% σ) x → TensorialAt I F'' (Φ σ τ ·) x)
+    {σ : Π x : M, V x} (hσ : MDiffAt (T% σ) x) {τ : Π x : M, V' x} (hτ : MDiffAt (T% τ) x)
+    {τ' : Π x : M, V'' x} (hτ : MDiffAt (T% τ') x) :
+    mkHom₃ Φ x hΦ₁ hΦ₂ hΦ₃ (σ x) (τ x) (τ' x) = Φ σ τ τ' :=
+  sorry -- mkHom₂_apply mutatis mutandis
+
+theorem mkHom₃_apply_eq_extend
+    {Φ : (Π x : M, V x) → (Π x : M, V' x) → (Π x : M, V'' x) → A} {x}
+    (hΦ₁ : ∀ τ τ', MDiffAt (T% τ) x → TensorialAt I F (Φ · τ τ') x)
+    (hΦ₂ : ∀ σ τ', MDiffAt (T% σ) x → TensorialAt I F' (Φ σ · τ') x)
+    (hΦ₃ : ∀ σ τ, MDiffAt (T% σ) x → TensorialAt I F'' (Φ σ τ ·) x)
+    (σ : V x) (τ : V' x) (τ' : V'' x) :
+    mkHom₃ Φ x hΦ₁ hΦ₂ hΦ₃ σ τ τ' =
+      Φ (FiberBundle.extend F σ) (FiberBundle.extend F' τ) (FiberBundle.extend F'' τ') :=
+  sorry -- once the above proofs are filled in, this should be try by `rfl`
+
 end TensorialAt
diff --git a/Mathlib/Geometry/Manifold/VectorBundle/Unused.lean b/Mathlib/Geometry/Manifold/VectorBundle/Unused.lean
new file mode 100644
index 00000000000000..38cb8f2b526a18
--- /dev/null
+++ b/Mathlib/Geometry/Manifold/VectorBundle/Unused.lean
@@ -0,0 +1,60 @@
+/-
+Copyright (c) 2025 Patrick Massot. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Patrick Massot, Michael Rothgang
+-/
+module
+
+public import Mathlib.Geometry.Manifold.Notation
+public import Mathlib.Geometry.Manifold.VectorBundle.MDifferentiable
+
+/-!
+# Miscellaneous pre-requisites for covariant derivatives
+
+TODO: this file should not exist; move everything in here to a proper place
+(and PR it accordingly)
+
+-/
+
+@[expose] public section -- TODO: think if we want to expose all definitions!
+
+section prerequisites
+
+open Bundle Filter Function Topology Set
+
+open scoped Bundle Manifold ContDiff
+
+variable {𝕜 : Type*} [NontriviallyNormedField 𝕜]
+
+variable {E : Type*} [NormedAddCommGroup E]
+  [NormedSpace 𝕜 E] {H : Type*} [TopologicalSpace H] {I : ModelWithCorners 𝕜 E H}
+  {M : Type*} [TopologicalSpace M] [ChartedSpace H M]
+
+
+variable {F : Type*} [NormedAddCommGroup F] [NormedSpace 𝕜 F]
+  {V : M → Type*} [TopologicalSpace (TotalSpace F V)]
+  [∀ x : M, TopologicalSpace (V x)] [FiberBundle F V]
+
+
+
+/-- If two sections `σ` and `σ'` are equal on a neighbourhood `s` of `x`,
+if one is differentiable at `x` then so is the other.
+Issue: EventuallyEq does not work for dependent functions. -/
+lemma mdifferentiableAt_dependent_congr {σ σ' : Π x : M, V x} {x : M} {s : Set M} (hs : s ∈ nhds x)
+    (hσ₁ : MDiffAt (T% σ) x) (hσ₂ : ∀ x ∈ s, σ x = σ' x) :
+    MDiffAt (T% σ') x := by
+  apply MDifferentiableAt.congr_of_eventuallyEq hσ₁
+  -- TODO: split off a lemma?
+  apply Set.EqOn.eventuallyEq_of_mem _ hs
+  intro x hx
+  simp [hσ₂, hx]
+
+/-- If two sections `σ` and `σ'` are equal on a neighbourhood `s` of `x`,
+one is differentiable at `x` iff the other is. -/
+lemma mdifferentiable_dependent_congr_iff {σ σ' : Π x : M, V x} {x : M} {s : Set M}
+    (hs : s ∈ nhds x) (hσ : ∀ x ∈ s, σ x = σ' x) :
+    MDiffAt (T% σ) x  ↔ MDiffAt (T% σ') x :=
+  ⟨fun h ↦ mdifferentiableAt_dependent_congr hs h hσ,
+   fun h ↦ mdifferentiableAt_dependent_congr hs h (fun x hx ↦ (hσ x hx).symm)⟩
+
+end prerequisites