diff --git a/Mathlib.lean b/Mathlib.lean
index a5667796804c28..16abf706f5a11c 100644
--- a/Mathlib.lean
+++ b/Mathlib.lean
@@ -4601,6 +4601,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
@@ -4611,16 +4612,31 @@ public import Mathlib.Geometry.Manifold.StructureGroupoid
 public import Mathlib.Geometry.Manifold.VectorBundle.Basic
 public import Mathlib.Geometry.Manifold.VectorBundle.ContMDiffSection
 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..2bf65c1fdd8f33
--- /dev/null
+++ b/Mathlib/Geometry/Manifold/CheatSheet.md
@@ -0,0 +1,130 @@
+## 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...
+
+
+-- Let `cov` be a covariant derivative on `V`.
+
+
+
+**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 10786df6b91450..8810c5a4330ed3 100644
--- a/Mathlib/Geometry/Manifold/MFDeriv/NormedSpace.lean
+++ b/Mathlib/Geometry/Manifold/MFDeriv/NormedSpace.lean
@@ -17,8 +17,13 @@ providing the same statements for higher smoothness. In this file, we do the sam
 differentiability.
 
 In addition to the above, this file provides
-* results about the differentiability of scalar multiplication (`mfderiv_smul` and friends), and
-* `extDerivFun`: the exterior derivative of a scalar function, as a section of the cotangent bundle
+* results about the differentiability of scalar multiplication (`mfderiv_smul` and friends),
+* `mvfderiv`: the exterior derivative of a vector-valued function, as a section of the
+  cotangent bundle; adds notation `d% f` for `mvfderiv I f` via a custom elaborator scoped to the
+  `Manifold` namespace, with a corresponding delaborator, and
+  adds basic lemmas about `mvfderiv` (such as addition, subtraction, multiplication and constants).
+* `mvfderivWithin` with notation `d[s]f` for `mvfderivWithin I f s` in the `Manifold` namespace:
+  the analogous concept within a set, with analogous API lemmas
 
 -/
 
@@ -84,7 +89,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}
 
@@ -102,7 +107,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 -/
 
@@ -257,6 +262,36 @@ open NormedSpace ContinuousLinearMap
 variable {V : Type*} [NormedAddCommGroup V] [NormedSpace 𝕜 V]
 variable {f : M → 𝕜} {g : M → V}
 
+/-- Given maps `f`, `g` from a manifold into a field `𝕜` and `𝕜`-vector space `V`, respectively, if
+at some point `x`, `f` has differential `f' : TangentSpace I x →L[𝕜] 𝕜` and `g` has differential
+`g' : TangentSpace I x →L[𝕜] V` within `s` (both phrased using the predicate `HasMFDerivWithinAt`),
+it follows that their scalar multiplication `f • g` has differential
+`f x • g' + toSpanSingleton 𝕜 (g x) ∘L f'`.
+
+In fact, the statement above is not literally true, because, for example, the differential of `g`
+really takes values in the tangent space to `V` at `g x`, rather than in `V` itself. Of course, this
+tangent space can be canonically identified with `V`.
+
+This lemma phrases the formula using the equiv `NormedSpace.fromTangentSpace`, which provides this
+canonical identification. (It would also be possible to phrase the formula without this equiv,
+instead using casting and definitional abuse.) -/
+lemma HasMFDerivWithinAt.smul
+    {f' : TangentSpace I x →L[𝕜] 𝕜}
+    (hs : HasMFDerivAt[s] f x ((fromTangentSpace (f x)).symm.toContinuousLinearMap ∘L f'))
+    {g' : TangentSpace I x →L[𝕜] V}
+    (hg : HasMFDerivAt[s] g x ((fromTangentSpace (g x)).symm.toContinuousLinearMap ∘L g')) :
+    -- canonically identify `g'` with a linear map into the tangent space at `(f • g) x`
+    letI g'_ : TangentSpace I x →L[𝕜] TangentSpace 𝓘(𝕜, V) ((f • g) x) :=
+      (fromTangentSpace _).symm.toContinuousLinearMap ∘L g'
+    -- canonically identify `g x` with a linear map into a tangent space at `(f • g) x`
+    letI gx : 𝕜 →L[𝕜] TangentSpace 𝓘(𝕜, V) ((f • g) x) :=
+      toSpanSingleton 𝕜 ((fromTangentSpace _).symm (g x))
+    -- now the main statement typechecks
+    HasMFDerivAt[s] (f • g) x (f x • g'_ + gx ∘L f') := by
+  constructor
+  · exact hs.1.smul hg.1
+  · simpa using hs.2.smul hg.2
+
 /-- Given maps `f`, `g` from a manifold into a field `𝕜` and `𝕜`-vector space `V`, respectively, if
 at some point `x`, `f` has differential `f' : TangentSpace I x →L[𝕜] 𝕜` and `g` has differential
 `g' : TangentSpace I x →L[𝕜] V` (both phrased using the predicate `HasMFDerivAt`), it follows that
@@ -303,6 +338,34 @@ theorem MDifferentiableOn.smul (hf : MDiff[s] f)
 theorem MDifferentiable.smul (hf : MDiff f) (hg : MDiff g) : MDiff fun p ↦ f p • g p :=
   fun x ↦ (hf x).smul (hg x)
 
+/-- Given maps `f`, `g` from a manifold into a field `𝕜` and `𝕜`-vector space `V`, respectively, the
+formula for the `mfderivWithin` (differential) of their scalar multiplication `f • g` within `s`.
+
+Mathematically speaking the formula is `d(f • g) = f • dg + df ⊗ g`, i.e.
+`mfderiv[s] (f • g) x = f x • mfderiv[s] g x + toSpanSingleton 𝕜 (g x) ∘L mfderiv[s] f x`,
+but this doesn't typecheck because `mfderiv[s] (f • g) x` and `mfderiv[s]% g x` take values in
+different tangent spaces --- respectively the tangent spaces to `V` at `(f • g) x` and `g x`.
+Of course, both these tangent spaces can be canonically identified with `V`.
+
+This lemma phrases the formula using the equiv `NormedSpace.fromTangentSpace`, which provides this
+canonical identification. (It would also be possible to phrase the formula without this equiv,
+instead using casting and definitional abuse.)
+
+It is good practice to use the equiv `NormedSpace.fromTangentSpace` throughout a computation. If
+this is done, typically `mfderiv[s] (f • g) x` will only turn up paired with this equiv (i.e., in an
+expression `(fromTangentSpace _) ∘L mfderiv[s] (f • g) x` or `d[s] (f • g) x`),
+and the more convenient lemma `mvderiv_smul` (see below) can be used instead.
+
+This lemma is private: external users should use `mvfderiv_smul` instead. -/
+private lemma mfderivWithin_smul
+    (hf : MDiffAt[s] f x) (hg : MDiffAt[s] g x) (hs : UniqueMDiffWithinAt I s x) :
+    mfderiv[s] (f • g) x
+    = f x • (fromTangentSpace _).symm.toContinuousLinearMap ∘L
+      ((fromTangentSpace (g x)).toContinuousLinearMap ∘L mfderiv[s] g x)
+    + toSpanSingleton 𝕜 ((fromTangentSpace _).symm (g x)) ∘L
+      ((fromTangentSpace (f x)).toContinuousLinearMap ∘L mfderiv[s] f x) :=
+  (hf.hasMFDerivWithinAt.smul hg.hasMFDerivWithinAt).mfderivWithin hs
+
 /-- Given maps `f`, `g` from a manifold into a field `𝕜` and `𝕜`-vector space `V`, respectively, the
 formula for the `mfderiv` (differential) of their scalar multiplication `f • g`.
 
@@ -319,8 +382,10 @@ instead using casting and definitional abuse.)
 It is good practice to use the equiv `NormedSpace.fromTangentSpace` throughout a computation. If
 this is done, typically `mfderiv% (f • g) x` will only turn up paired with this equiv (i.e., in an
 expression `(fromTangentSpace _) ∘L mfderiv% (f • g) x`), and the more convenient lemma
-`fromTangentSpace_mfderiv_smul` (see below) can be used instead. -/
-lemma mfderiv_smul (hf : MDiffAt f x) (hg : MDiffAt g x) :
+`fromTangentSpace_mfderiv_smul` (see below) can be used instead.
+
+This lemma is private: external users should use `mvfderiv_smul` instead. -/
+private lemma mfderiv_smul (hf : MDiffAt f x) (hg : MDiffAt g x) :
     mfderiv% (f • g) x
     = f x • (fromTangentSpace _).symm.toContinuousLinearMap ∘L
       ((fromTangentSpace (g x)).toContinuousLinearMap ∘L mfderiv% g x)
@@ -339,7 +404,9 @@ these tangent spaces can be canonically identified with `V`.
 
 This lemma phrases the formula using the equiv `NormedSpace.fromTangentSpace`, which provides this
 canonical identification. (It would also be possible to phrase the formula without this equiv,
-instead using casting and definitional abuse.) -/
+instead using casting and definitional abuse.)
+
+This lemma is private: external users should use `mvfderiv_smul` instead. -/
 lemma fromTangentSpace_mfderiv_smul (hf : MDiffAt f x) (hg : MDiffAt g x) :
     (fromTangentSpace ((f • g) x)).toContinuousLinearMap ∘L mfderiv% (f • g) x
     = f x • (fromTangentSpace _).toContinuousLinearMap ∘L mfderiv% g x
@@ -347,6 +414,7 @@ lemma fromTangentSpace_mfderiv_smul (hf : MDiffAt f x) (hg : MDiffAt g x) :
   rw [mfderiv_smul hf hg]
   rfl
 
+-- now unused, given that we're using mvfderiv instead \o/
 /-- Given maps `f`, `g` from a manifold into a field `𝕜` and `𝕜`-vector space `V`, respectively, the
 formula for the `mfderiv` (differential) of their scalar multiplication `f • g`.
 
@@ -363,6 +431,42 @@ lemma fromTangentSpace_mfderiv_smul' (hf : MDiffAt f x) (hg : MDiffAt g x) :
     + toSpanSingleton 𝕜 (g x) ∘L (fromTangentSpace _).toContinuousLinearMap ∘L mfderiv% f x :=
   fromTangentSpace_mfderiv_smul hf hg
 
+/-- Given maps `f`, `g` from a manifold into a field `𝕜` and `𝕜`-vector space `V`, respectively, the
+formula for the `mfderiv[s]` (differential) of their scalar multiplication `f • g` within `s`
+in the direction of the tangent vector `v`.
+
+Mathematically speaking the formula is `d(f • g)(v) = f • dg(v) + df(v) • g`, but to get it to
+typecheck we need a phrasing involving the canonical identification `NormedSpace.fromTangentSpace`
+between the vector space `V` and the tangent space to this vector space at any point. This is
+because two different tangent spaces (at `(f • g) x` and `g x`) appear in the equation.
+
+This lemma is private: use `mvfderivWithin_smul` instead. -/
+private lemma fromTangentSpace_mfderivWithin_smul_apply (hf : MDiffAt[s] f x) (hg : MDiffAt[s] g x)
+    (hs : UniqueMDiffWithinAt I s x) (v : TangentSpace I x) :
+    fromTangentSpace _ (mfderiv[s] (f • g) x v)
+    = f x • fromTangentSpace _ (mfderiv[s] g x v) +
+      fromTangentSpace _ (mfderiv[s] f x v) • g x := by
+  rw [mfderivWithin_smul hf hg hs]
+  rfl
+
+-- now unused, given that we're using mvfderiv instead \o/
+/-- Given maps `f`, `g` from a manifold into a field `𝕜` and `𝕜`-vector space `V`, respectively, the
+formula for the `mfderiv` (differential) of their scalar multiplication `f • g` within `s`
+in the direction of the tangent vector `v`.
+
+Mathematically speaking the formula is `d(f • g)(v) = f • dg(v) + df(v) • g`, but to get it to
+typecheck we need a phrasing involving the canonical identification `NormedSpace.fromTangentSpace`
+between the vector space `V` and the tangent space to this vector space at any point. This is
+because two different tangent spaces (at `(f • g) x` and `g x`) appear in the equation.
+
+This is a defeq variant of the main lemma `fromTangentSpace_mfderivWithin_smul_apply`, in which
+we work in the tangent space at `f x • g x` (the simp-normal form) rather than at `(f • g) x`. -/
+private lemma fromTangentSpace_mfderivWithin_smul_apply' (hf : MDiffAt[s] f x) (hg : MDiffAt[s] g x)
+    (hs : UniqueMDiffWithinAt I s x) (v : TangentSpace I x) :
+    fromTangentSpace (f x • g x) (mfderiv[s] (f • g) x v)
+    = f x • fromTangentSpace _ (mfderiv[s] g x v) + fromTangentSpace _ (mfderiv[s] f x v) • g x :=
+  fromTangentSpace_mfderivWithin_smul_apply hf hg hs v
+
 /-- Given maps `f`, `g` from a manifold into a field `𝕜` and `𝕜`-vector space `V`, respectively, the
 formula for the `mfderiv` (differential) of their scalar multiplication `f • g` in the direction of
 the tangent vector `v`.
@@ -370,13 +474,16 @@ the tangent vector `v`.
 Mathematically speaking the formula is `d(f • g)(v) = f • dg(v) + df(v) • g`, but to get it to
 typecheck we need a phrasing involving the canonical identification `NormedSpace.fromTangentSpace`
 between the vector space `V` and the tangent space to this vector space at any point. This is
-because two different tangent spaces (at `(f • g) x` and `g x`) appear in the equation. -/
-lemma fromTangentSpace_mfderiv_smul_apply (hf : MDiffAt f x) (hg : MDiffAt g x)
+because two different tangent spaces (at `(f • g) x` and `g x`) appear in the equation.
+
+This lemma is private: use `mvfderiv_smul` instead (or create an applied version if you need). -/
+private lemma fromTangentSpace_mfderiv_smul_apply (hf : MDiffAt f x) (hg : MDiffAt g x)
     (v : TangentSpace I x) :
     fromTangentSpace _ (mfderiv% (f • g) x v)
     = f x • fromTangentSpace _ (mfderiv% g x v) + fromTangentSpace _ (mfderiv% f x v) • g x := by
   simpa using congr($(fromTangentSpace_mfderiv_smul hf hg) v)
 
+-- now unused, given that we're using mvfderiv instead \o/
 /-- Given maps `f`, `g` from a manifold into a field `𝕜` and `𝕜`-vector space `V`, respectively, the
 formula for the `mfderiv` (differential) of their scalar multiplication `f • g` in the direction of
 the tangent vector `v`.
@@ -388,7 +495,7 @@ because two different tangent spaces (at `(f • g) x` and `g x`) appear in the
 
 This is a defeq variant of the main lemma `fromTangentSpace_mfderiv_smul_apply`, in which we work in
 the tangent space at `f x • g x` (the simp-normal form) rather than at `(f • g) x`. -/
-lemma fromTangentSpace_mfderiv_smul_apply' (hf : MDiffAt f x) (hg : MDiffAt g x)
+private lemma fromTangentSpace_mfderiv_smul_apply' (hf : MDiffAt f x) (hg : MDiffAt g x)
     (v : TangentSpace I x) :
     fromTangentSpace (f x • g x) (mfderiv% (f • g) x v)
     = f x • fromTangentSpace _ (mfderiv% g x v) + fromTangentSpace _ (mfderiv% f x v) • g x :=
@@ -396,23 +503,211 @@ lemma fromTangentSpace_mfderiv_smul_apply' (hf : MDiffAt f x) (hg : MDiffAt g x)
 
 end smul
 
-/-! ### Exterior derivative of a scalar function -/
+/-! ### Exterior derivative of a vector-valued function -/
+
+variable (I) in
+/-- The exterior derivative of a vector-valued function on `M` within a set,
+as a section of the cotangent bundle.
 
-/-- 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[𝕜] 𝕜 :=
+Future: this could be generalised to functions into additive torsors over abelian Lie groups
+-/
+@[expose]
+noncomputable def mvfderivWithin (g : M → F) (s : Set M) :
+    Π x : M, TangentSpace I x →L[𝕜] F :=
+  fun x ↦ (NormedSpace.fromTangentSpace <| g x).toContinuousLinearMap ∘L (mfderiv[s] g x)
+
+variable (I) in
+/-- The exterior derivative of a vector-valued function on `M`,
+as a section of the cotangent bundle.
+
+Future: this could be generalised to functions into additive torsors over abelian Lie groups
+-/
+@[expose]
+noncomputable def mvfderiv (g : M → F) :
+    Π x : M, TangentSpace I x →L[𝕜] F :=
   fun x ↦ (NormedSpace.fromTangentSpace <| g x).toContinuousLinearMap ∘L (mfderiv% g x)
 
+namespace Manifold
+open scoped Bundle Manifold ContDiff
+
+open Lean Meta Elab Tactic
+
+/-- `d[s] f x` (scoped to the `Manifold` namespace) elaborates to `mvfderivWithin I J f s x`,
+trying to determine `I` and `J` from the local context. -/
+scoped elab:max "d[" s:term "]" ppSpace t:term:arg : term => do
+  let es ← Term.elabTerm s none
+  let e ← ensureIsFunction <| ← Term.elabTerm t none
+  let (srcI, _tgtI) ← findModels e none
+  mkAppM ``mvfderivWithin #[srcI, e, es]
+
+-- Options for this case
+-- * doc-string for Y is "given text" prepended to the doc-string of X
+-- * hover is able to recursively specify
+-- * toss the hover information to the infoview (where we can recursively specify)
+set_option doc.verso true in
+/-- Given {given}`f` and {given}`x`,
+`d% f x` (scoped to the {lit}`Manifold` namespace) elaborates to {name}`mvfderiv`,
+trying to determine `I` and `J` from the local context. -/
+scoped elab:max "d%" ppSpace t:term:arg : term => do
+  let e ← ensureIsFunction <| ← Term.elabTerm t none
+  let (srcI, _tgtI) ← findModels e none
+  mkAppM ``mvfderiv #[srcI, e]
+
+open Bundle PrettyPrinter Delaborator SubExpr
+
+/-- Delaborator for `mvfderivWithin`. -/
+-- There is no need to special-case any arguments which could use the T% s elaborator:
+-- the argument to `mvfderivWithin` is a vector-valued function, which a map to a total space
+-- can never be.
+@[app_delab mvfderivWithin] meta def delab_mvfderivWithin : Delab := do
+  whenPPOption getPPNotation do
+  withOverApp 16 do
+  let ss ← withAppArg delab
+  let fs ← withNaryArg 14 <| delab
+  `(d[$ss] $fs) >>= annotateGoToSyntaxDef
+
+/-- Delaborator for `mvfderiv`. -/
+-- There is no need to special-case any arguments which could use the T% s elaborator:
+-- the argument to `mvfderivWithin` is a vector-valued function, which a map to a total space
+-- can never be.
+@[app_delab mvfderiv] meta def delab_mvfderiv : Delab := do
+  whenPPOption getPPNotation do
+  withOverApp 15 do
+  let fs ← withAppArg delab
+  `(d% $fs) >>= annotateGoToSyntaxDef
+
+section tests
+
+variable {f : M → 𝕜}
+
+/-- info: d[s] f : (x : M) → TangentSpace I x →L[𝕜] 𝕜 -/
+#guard_msgs in
+#check mvfderivWithin I f s
+/-- info: d[s] f x : TangentSpace I x →L[𝕜] 𝕜 -/
+#guard_msgs in
+#check mvfderivWithin I f s x
+
+/-- info: d[s] f : (x : M) → TangentSpace I x →L[𝕜] 𝕜 -/
+#guard_msgs in
+#check d[s] f
+/-- info: d[s] f x : TangentSpace I x →L[𝕜] 𝕜 -/
+#guard_msgs in
+#check d[s] f x
+
+/-- info: d% f : (x : M) → TangentSpace I x →L[𝕜] 𝕜 -/
+#guard_msgs in
+#check mvfderiv I f
+/-- info: d% f : (x : M) → TangentSpace I x →L[𝕜] 𝕜 -/
+#guard_msgs in
+#check d% f
+
+/-- info: d% f x : TangentSpace I x →L[𝕜] 𝕜 -/
+#guard_msgs in
+#check mvfderiv I f x
+
+/-- info: d% f x : TangentSpace I x →L[𝕜] 𝕜 -/
+#guard_msgs in
+#check d% f x
+
+end tests
+
+end Manifold
+
+@[simp, mfld_simps] lemma mvfderivWithin_univ {f : M → F} : d[(univ : Set M)] f = d% f := by
+  ext X
+  simp [mvfderiv, mvfderivWithin]
+
+lemma mvfderivWithin_const (c : F) {x : M} : d[s] (fun _ : M ↦ c) x = 0 := by
+  simp [mvfderivWithin, mfderivWithin_const]
+
+@[simp, to_fun mvfderivWithin_fun_add]
+lemma mvfderivWithin_add {g g' : M → F} {x : M}
+    (hg : MDiffAt[s] g x) (hg' : MDiffAt[s] g' x) (hs : UniqueMDiffWithinAt I s x) :
+    d[s](g + g') x = d[s]g x + d[s]g' x := by
+  simp [mvfderivWithin, mfderivWithin_add hg hg' hs]
+  rfl
+
+@[simp, to_fun mvfderivWithin_fun_sub]
+lemma mvfderivWithin_sub {g g' : M → F} {x : M}
+    (hg : MDiffAt[s] g x) (hg' : MDiffAt[s] g' x) (hs : UniqueMDiffWithinAt I s x) :
+    d[s](g - g') x = d[s]g x - d[s]g' x := by
+  simp [mvfderivWithin, mfderivWithin_sub hg hg' hs]
+  rfl
+
+@[simp, to_fun mvfderivWithin_fun_neg]
+lemma mvfderivWithin_neg {g : M → F} {x : M} (hs : UniqueMDiffWithinAt I s x) :
+    d[s](-g) x = -d[s]g x := by
+  simp [mvfderivWithin, mfderivWithin_neg hs]
+  rfl
+
+@[simp, to_fun mvfderivWithin_fun_smul]
+lemma mvfderivWithin_smul {a : M → 𝕜} (ha : MDiffAt[s] a x) {g : M → F} (hg : MDiffAt[s] g x)
+    (hs : UniqueMDiffWithinAt I s x) :
+    d[s](a • g) x =
+      a x • d[s] g x + (d[s] a x).smulRight (g x) := by
+  ext v
+  simp [mvfderivWithin, -Pi.smul_apply', -Pi.smul_apply,
+    fromTangentSpace_mfderivWithin_smul_apply ha hg hs]
+  rfl
+
+@[simp, to_fun mvfderivWithin_fun_mul]
+lemma mvfderivWithin_mul {f g : M → 𝕜} {x : M} (hf : MDiffAt[s] f x) (hg : MDiffAt[s] g x)
+    (hs : UniqueMDiffWithinAt I s x) :
+    d[s](f * g) x = f x • d[s]g x + (g x) • (d[s]f x) := by
+  ext v
+  simp [mvfderivWithin, -Pi.smul_apply', -Pi.smul_apply, ← smul_eq_mul, mfderivWithin_smul hf hg hs]
+  simp [mul_comm _ (g x)]
+
 @[simp]
-lemma extDerivFun_add {g g' : M → 𝕜} {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
+lemma mvfderivWithin_zero {s : Set M} (hs : UniqueMDiffWithinAt I s x) :
+    d[s] (0 : M → F) x = 0 := by
+  have : d[s] (0 : M → F) x + d[s] (0 : M → F) x = d[s] (0 : M → F) x := by
+    rw [← mvfderivWithin_add (by exact mdifferentiableWithinAt_const)
+      (by exact mdifferentiableWithinAt_const) hs]
+    simp
+  simpa using this
+
+lemma mvfderiv_const (c : F) {x : M} : d% (fun _ : M ↦ c) x = 0 := by
+  simp [mvfderiv, mfderiv_const]
+
+@[simp, to_fun mvfderiv_fun_add]
+lemma mvfderiv_add {g g' : M → F} {x : M} (hg : MDiffAt g x) (hg' : MDiffAt g' x) :
+    d% (g + g') x = d% g x + d% g' x := by
+  simp [mvfderiv, mfderiv_add hg hg']
+  rfl
+
+@[simp, to_fun mvfderiv_fun_sub]
+lemma mvfderiv_sub {g g' : M → F} {x : M} (hg : MDiffAt g x) (hg' : MDiffAt g' x) :
+    d% (g - g') x = d% g x - d% g' x := by
+  simp [mvfderiv, mfderiv_sub hg hg']
+  rfl
+
+@[simp, to_fun mvfderiv_fun_neg]
+lemma mvfderiv_neg {g : M → F} {x : M} :
+    d% (-g) x = -d% g x := by
+  simp [mvfderiv, mfderiv_neg]
+  rfl
+
+@[simp, to_fun mvfderiv_fun_smul]
+lemma mvfderiv_smul {x : M} {a : M → 𝕜} (ha : MDiffAt a x) {g : M → F} (hg : MDiffAt g x) :
+    d% (a • g) x =
+      a x • d% g x + (d% a x).smulRight (g x) := by
+  ext v
+  simp [mvfderiv, -Pi.smul_apply', -Pi.smul_apply, fromTangentSpace_mfderiv_smul_apply ha hg]
+  rfl
+
+@[simp, to_fun mvfderiv_fun_mul]
+lemma mvfderiv_mul {f g : M → 𝕜} {x : M} (hf : MDiffAt f x) (hg : MDiffAt g x) :
+    d% (f * g) x = f x • d% g x + (g x) • (d% f x) := by
+  ext v
+  simp [mvfderiv, -Pi.smul_apply', -Pi.smul_apply, ← smul_eq_mul, mfderiv_smul hf hg]
+  simp [mul_comm _ (g x)]
 
 @[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
-    rw [← extDerivFun_add (by exact mdifferentiable_const ..) (by exact mdifferentiable_const ..)]
+lemma mvfderiv_zero {x : M} : d% (0 : M → F) x = 0 := by
+  have : d% (0 : M → F) x + d% (0 : M → F) x = d% (0 : M → F) x := by
+    rw [← mvfderiv_add (by exact mdifferentiable_const ..) (by exact mdifferentiable_const ..)]
     simp
   simpa using this
+
+@[deprecated (since := "2026-05-17")] alias extDerivFun_zero := mvfderiv_zero
diff --git a/Mathlib/Geometry/Manifold/MFDeriv/SpecificFunctions.lean b/Mathlib/Geometry/Manifold/MFDeriv/SpecificFunctions.lean
index 7f4ad4775d421d..6d9320215c76cd 100644
--- a/Mathlib/Geometry/Manifold/MFDeriv/SpecificFunctions.lean
+++ b/Mathlib/Geometry/Manifold/MFDeriv/SpecificFunctions.lean
@@ -796,6 +796,20 @@ theorem mfderivWithin_add (hf : MDiffAt[s] f z) (hg : MDiffAt[s] g z)
       (by exact mfderiv[s] f z) + (by exact mfderiv[s] g z) :=
   (hf.hasMFDerivWithinAt.add hg.hasMFDerivWithinAt).mfderivWithin hs
 
+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'}
 
@@ -878,15 +892,15 @@ theorem mdifferentiableAt_neg : MDiffAt (-f) z ↔ MDiffAt f z :=
 theorem MDifferentiable.neg (hf : MDiff f) : MDiff (-f) := fun x ↦ (hf x).neg
 
 set_option backward.isDefEq.respectTransparency false in
-theorem mfderivWithin_neg (f : M → E') (x : M) (hs : UniqueMDiffWithinAt I s x) :
+theorem mfderivWithin_neg (hs : UniqueMDiffWithinAt I s x) :
     mfderiv[s] (-f) x = -mfderiv[s] f x := by
   simp_rw [mfderivWithin]
   by_cases hf : MDiffAt[s] f x
   · exact hf.hasMFDerivWithinAt.neg.mfderivWithin hs
   · rw [if_neg hf]; rw [← mdifferentiableWithinAt_neg] at hf; rw [if_neg hf, neg_zero]
 
-theorem mfderiv_neg (f : M → E') (x : M) : mfderiv% (-f) x = -mfderiv% f x := by
-  rw [← mfderivWithin_univ, mfderivWithin_neg _ _ (uniqueMDiffWithinAt_univ I), mfderivWithin_univ]
+theorem mfderiv_neg : mfderiv% (-f) x = -mfderiv% f x := by
+  rw [← mfderivWithin_univ, mfderivWithin_neg (uniqueMDiffWithinAt_univ I), mfderivWithin_univ]
 
 theorem HasMFDerivWithinAt.sub (hf : HasMFDerivAt[s] f z f') (hg : HasMFDerivAt[s] g z g') :
     HasMFDerivAt[s] (f - g) z (f' - g') :=
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 620ac719fb7b7a..817d33fd8910b3 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 : ℕ∞ω} {𝕜 B B' F M : Type*} {E : B → Type*}
 
diff --git a/Mathlib/Geometry/Manifold/VectorBundle/ContMDiffSection.lean b/Mathlib/Geometry/Manifold/VectorBundle/ContMDiffSection.lean
index 6d62722d66f4b5..3de1dcfb16012e 100644
--- a/Mathlib/Geometry/Manifold/VectorBundle/ContMDiffSection.lean
+++ b/Mathlib/Geometry/Manifold/VectorBundle/ContMDiffSection.lean
@@ -195,6 +195,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/CovariantDerivative/Basic.lean b/Mathlib/Geometry/Manifold/VectorBundle/CovariantDerivative/Basic.lean
index a6e5c327c556b2..7b41053f0d5930 100644
--- a/Mathlib/Geometry/Manifold/VectorBundle/CovariantDerivative/Basic.lean
+++ b/Mathlib/Geometry/Manifold/VectorBundle/CovariantDerivative/Basic.lean
@@ -96,7 +96,7 @@ structure IsCovariantDerivativeOn
     cov (σ + σ') x = cov σ x + cov σ' x
   leibniz {σ : Π x : M, V x} {g : M → 𝕜} {x}
     (hσ : MDiffAt (T% σ) x) (hg : MDiffAt g x) (hx : x ∈ s := by trivial) :
-    cov (g • σ) x = g x • cov σ x + (extDerivFun g x).smulRight (σ x)
+    cov (g • σ) x = g x • cov σ x + (d% g x).smulRight (σ x)
 
 /--
 A covariant derivative ∇ is called of class `C^k` iff, whenever `X` is a `C^k` section and `σ` a
@@ -104,12 +104,15 @@ A covariant derivative ∇ is called of class `C^k` iff, whenever `X` is a `C^k`
 deduce this automatically. We will prove in a later file that any `C^(k+1)` covariant derivative
 is `C^k`.
 -/
+-- Is this framing correct? It is a pretty weak condition if the space of C^k sections over `u` is
+-- small, which e.g. could happen over `ℂ` when `u` is compact. Not sure whether this definition
+-- retrieves the correct notion of "holomorphic connection" in this case.
 class ContMDiffCovariantDerivativeOn [IsManifold I 1 M] [VectorBundle 𝕜 F V] (k : ℕ∞ω)
     (cov : (Π x : M, V x) → (Π x : M, TangentSpace I x →L[𝕜] V x))
     (u : Set M) where
   contMDiff : ∀ {σ : Π x : M, V x}, CMDiff[u] (k + 1) (T% σ) →
-    letI cov (x : M) : TotalSpace (E →L[𝕜] F) fun x ↦ TangentSpace I x →L[𝕜] V x := ⟨x, cov σ x⟩
-    ContMDiffOn I (I.prod 𝓘(𝕜, E →L[𝕜] F)) k cov u
+    letI covσ (x : M) : TotalSpace (E →L[𝕜] F) fun x ↦ TangentSpace I x →L[𝕜] V x := ⟨x, cov σ x⟩
+    ContMDiffOn I (I.prod 𝓘(𝕜, E →L[𝕜] F)) k covσ u
     -- TODO elaborators are not working here. We want to use `T% (cov σ)` and CMDiff[u] k f
 
 variable {F}
@@ -142,13 +145,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)
@@ -176,14 +176,16 @@ lemma congr_of_eqOn
   -- Then, it's a chain of (dependent) equalities.
   calc cov σ x
     _ = cov ((ψ : M → 𝕜) • σ) x := by
-      simp [hcov.leibniz hσ hψ'.mdifferentiableAt, hψx, extDerivFun, hψ'.mfderiv]
+      simp [hcov.leibniz hσ hψ'.mdifferentiableAt, hψx, mvfderiv, hψ'.mfderiv]
     _ = cov ((ψ : M → 𝕜) • σ') x := by rw [funext H]
     _ = cov σ' x := by
-      simp [hcov.leibniz hσ' hψ'.mdifferentiableAt, hψx, extDerivFun, hψ'.mfderiv]
+      simp [hcov.leibniz hσ' hψ'.mdifferentiableAt, hψx, mvfderiv, hψ'.mfderiv]
 
 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 +197,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,11 +221,25 @@ 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) :
     cov (a • σ) x = a • cov σ x := by
-  simpa [extDerivFun] using hcov.leibniz (g := fun _ ↦ a) hσ mdifferentiableAt_const
+  simpa [mvfderiv] using hcov.leibniz (g := fun _ ↦ a) hσ mdifferentiableAt_const
 
 end computational_properties
 
@@ -270,15 +298,15 @@ lemma finite_affine_combination {ι : Type*} {s : Finset ι}
     rw [← smul_add, (h i).add hσ hσ' hx]
   leibniz {σ g x} hσ hg hx := by
     calc ∑ i ∈ s, f i x • cov i (g • σ) x
-      _ = ∑ i ∈ s, (g x • f i x • cov i σ x + f i x • (extDerivFun g x).smulRight (σ x)) := by
+      _ = ∑ i ∈ s, (g x • f i x • cov i σ x + f i x • (d% g x).smulRight (σ x)) := by
           congr! 1 with i hi
           rw [(h i).leibniz hσ hg]
-          simp [extDerivFun]
+          simp [mvfderiv]
           module
       _ = g x • ∑ i ∈ s, f i x • cov i σ x +
-        (∑ i ∈ s, f i) x • (extDerivFun g x).smulRight (σ x) := by
+        (∑ i ∈ s, f i) x • (d% g x).smulRight (σ x) := by
           rw [Finset.sum_add_distrib, Finset.smul_sum, Finset.sum_apply, Finset.sum_smul]
-      _ = g x • ∑ i ∈ s, f i x • cov i σ x + (extDerivFun g x).smulRight (σ x) := by rw [hf]; simp
+      _ = g x • ∑ i ∈ s, f i x • cov i σ x + (d% g x).smulRight (σ x) := by rw [hf]; simp
 
 /-- An affine combination of finitely many `C^k` connections on `u` is a `C^k` connection on `u`. -/
 lemma _root_.ContMDiffCovariantDerivativeOn.finite_affine_combination [IsManifold I 1 M]
@@ -386,6 +414,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..cedbde5b1c4ace
--- /dev/null
+++ b/Mathlib/Geometry/Manifold/VectorBundle/CovariantDerivative/Curvature.lean
@@ -0,0 +1,274 @@
+/-
+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: this ought to be true (possibly after improving `[IsManifold I 1 M]` to higher regularity),
+-- but maybe the definition of smoothness (i.e. `ContMDiffCovariantDerivativeOn`) needs to be
+-- adjusted to get it -- the current definition is potentially very weak if the space of sections of
+-- `V` over `u` is small.
+-- TODO: move this to `CovariantDerivative.Basic`
+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
+
+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] [VectorBundle 𝕜 F V]
+
+/-! ## 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, V x) → (Π x : M, TangentSpace I x →L[𝕜] V x))
+
+variable {X X' Y : (Π x : M, TangentSpace I x)} (σ : Π x, V 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 σ) x = cov σ 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, V x) → (Π x : M, V x) :=
+  fun X Y σ ↦ (∇ X (∇ Y σ)) - (∇ Y (∇ X σ)) - ∇ (VectorField.mlieBracket I X Y) σ
+
+variable [IsManifold I 2 M]
+  {cov cov' : (Π x : M, V x) → (Π x : M, TangentSpace I x →L[𝕜] V x)}
+  {X X' Y Z : Π x : M, TangentSpace I x}
+
+-- TODO: generalise to C^(k + 1) (not just C^2), and move to `CovariantDerivative.Basic`
+lemma temp
+    {cov : ((x : M) → V x) → (x : M) → TangentSpace I x →L[𝕜] V x}
+    (hcov : IsCovariantDerivativeOn F cov)
+    [hcov' : ContMDiffCovariantDerivativeOn F 1 cov univ] -- is this the right regularity?
+    {x : M} {σ : Π x, V x} {X : (x : M) → TangentSpace I x}
+    (hσ : CMDiffAt 2 (T% σ) x) (hX : CMDiffAt 1 (T% X) x) :
+    CMDiffAt 1 (T% (fun x ↦ (cov σ x) (X x))) x :=
+  (hcov'.contMDiff' hcov hσ).clm_bundle_apply hX
+
+lemma temp_mdiff
+    {cov : ((x : M) → V x) → (x : M) → TangentSpace I x →L[𝕜] V x}
+    (hcov : IsCovariantDerivativeOn F cov)
+    [hcov' : ContMDiffCovariantDerivativeOn F 1 cov univ] -- is this the right regularity?
+    {x : M} {σ : Π x, V x} {X : (x : M) → TangentSpace I x}
+    (hσ : CMDiffAt 2 (T% σ) x) (hX : MDiffAt (T% X) x) :
+    MDiffAt (T% (fun x ↦ (cov σ x) (X x))) x :=
+  -- requires adapting `ContMDiffAt.clm_bundle_apply` to `MDifferentiableAt` hypotheses
+  sorry
+
+-- HM: looks false to me
+-- lemma temp' -- I suspect this one will also work!
+--     {cov : ((x : M) → V x) → (x : M) → TangentSpace I x →L[𝕜] V x}
+--     (hcov : IsCovariantDerivativeOn F cov)
+--     {x : M} {σ : Π x, V x} {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[𝕜] F)) 1
+--       (fun x ↦ TotalSpace.mk' (E →L[𝕜] F) x (cov σ x)) x) :
+--     ContMDiffAt I (I.prod 𝓘(𝕜, F)) 1 (T% (fun 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
+-/
+
+-- HM: don't think this one is needed (or perhaps even true)
+-- lemma aux
+--     (hcov : IsCovariantDerivativeOn F cov) [hcov' : ContMDiffCovariantDerivativeOn F 1 cov univ]
+--     {x : M} {Y Z : (x : M) → TangentSpace I x} {τ : Π x, V x}
+--     (hτ : CMDiffAt 2 (T% τ) x) :
+--     (MDiffAt (T% (fun x ↦ (cov τ x) (VectorField.mlieBracket I Z Y x)))) x := by
+--   apply ContMDiffAt.mdifferentiableAt _ one_ne_zero
+--   apply temp' F hcov ?_ (hcov'.contMDiff' hcov hτ)
+--   apply hτ.of_le
+--   norm_num
+
+variable [CompleteSpace E] [VectorBundle 𝕜 F V]
+
+theorem curvatureTensorAux_tensorial₁ (hcov : IsCovariantDerivativeOn F cov) (x : M)
+    [hcov' : ContMDiffCovariantDerivativeOn F 1 cov univ]
+    (Y : (Π x : M, TangentSpace I x)) (τ : Π x, V x)
+    (hY : MDiffAt (T% Y) x)
+    (hτ : CMDiffAt 2 (T% τ) x) :
+    TensorialAt I E (curvatureTensorAux cov · Y τ x) x where
+  smul {f X} hf hX := by
+    unfold curvatureTensorAux
+    dsimp
+    sorry
+  add {X X'} hX hX' := by
+    unfold curvatureTensorAux
+    simp only [Pi.add_apply, map_add, Pi.sub_apply]
+    rw [VectorField.mlieBracket_add_left hX hX']
+    simp only [map_add]
+    set A := cov (fun x ↦ (cov τ x) (Y x)) x (X x)
+    set B := cov (fun x ↦ (cov τ x) (Y x)) x (X' x)
+    set C := cov (fun x ↦ (cov τ x) (X x)) x
+    set D := cov (fun x ↦ (cov τ x) (X' x)) x
+    have hτX : MDiffAt (T% (fun x ↦ cov τ x (X x))) x := temp_mdiff F hcov hτ hX
+    have hτX' : MDiffAt (T% (fun x ↦ cov τ x (X' x))) x := temp_mdiff F hcov hτ hX'
+    conv =>
+      enter [1, 1, 2]
+      equals (cov (fun x ↦ (cov τ x) (X x)) x) (Y x)
+          + (cov (fun x ↦ (cov τ x) (X' x)) x) (Y x) =>
+        have H := hcov.add hτX hτX'
+        exact congr($H (Y x))
+    abel
+
+-- update hypotheses to match lemma above, once proven!
+theorem curvatureTensorAux_tensorial₂ (hcov : IsCovariantDerivativeOn F cov) (x : M)
+    [hcov' : ContMDiffCovariantDerivativeOn F 1 cov univ]
+    (X : (Π x : M, TangentSpace I x)) (σ : Π x, V x) :
+    TensorialAt I E (curvatureTensorAux cov X · σ x) x :=
+  -- proof is analogous to the version in X
+  sorry
+
+-- update hypotheses to match lemma above, once proven!
+theorem curvatureTensorAux_tensorial₃ (hcov : IsCovariantDerivativeOn F cov) (x : M)
+    [hcov' : ContMDiffCovariantDerivativeOn F 1 cov univ]
+    (X Y : (Π x : M, TangentSpace I x)) :
+    TensorialAt I F (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 F cov) (x : M)
+    [ContMDiffCovariantDerivativeOn F 1 cov univ] :
+    TangentSpace I x →L[𝕜] TangentSpace I x →L[𝕜] V x →L[𝕜] V x :=
+  TensorialAt.mkHom₃ (curvatureTensorAux cov · · · x) x
+    (fun X τ hX hτ ↦ hcov.curvatureTensorAux_tensorial₁ F x X τ hX sorry)
+    -- `hτ` not good enough for the `sorry` above
+    -- HM: looks like we may need a version of `TensorialAt.mkHom₃` in which the tensoriality
+    -- conditions are only proved for C^2 (or C^k) sections
+    (fun X τ _ _ ↦ hcov.curvatureTensorAux_tensorial₂ F x X τ)
+    (fun X Y _ _ ↦ hcov.curvatureTensorAux_tensorial₃ F x X Y)
+
+variable [ContMDiffCovariantDerivativeOn F 1 cov univ]
+
+-- lemmas: curvatureEndomorphismTensor_apply and curvatureEndomorphismTensor_apply_extend
+
+variable (X) in
+@[simp]
+lemma curvatureEndomorphismTensor_self (hcov : IsCovariantDerivativeOn F cov)
+    (X₀ : TangentSpace I x) :
+    hcov.curvatureEndomorphismTensor F x X₀ X₀ = 0 := by
+  sorry
+
+variable (X Y) in
+lemma curvatureEndomorphismTensor_swap (hcov : IsCovariantDerivativeOn F cov)
+    (X₀ Y₀ : TangentSpace I x) :
+    hcov.curvatureEndomorphismTensor F x X₀ Y₀ = - hcov.curvatureEndomorphismTensor F 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.
+
+-- this is the thing whose cohomology class gives a definition of characteristic classes
+-- do something similar (but swap the argument order of the full curvature tensor) for the
+-- Levi-Civita connection to get Ricci curvature
+def traceCurvature [CompleteSpace 𝕜] [FiniteDimensional 𝕜 F] [FiniteDimensional 𝕜 E]
+    (hcov : IsCovariantDerivativeOn F cov) (x : M) :
+    TangentSpace I x →L[𝕜] TangentSpace I x →L[𝕜] 𝕜 :=
+  have : T2Space (V x) := (VectorBundle.continuousLinearEquivAt 𝕜 F V x).toHomeomorph.symm.t2Space
+  have : FiniteDimensional 𝕜 (V x) := VectorBundle.finiteDimensional 𝕜 F V x
+  have : FiniteDimensional 𝕜 (TangentSpace I x) :=
+    VectorBundle.finiteDimensional 𝕜 E (TangentSpace I) x
+  let tr : (TangentSpace I x →ₗ[𝕜] V x →L[𝕜] V x) →ₗ[𝕜] TangentSpace I x →ₗ[𝕜] 𝕜 :=
+    LinearMap.llcomp 𝕜 (TangentSpace I x) _ _
+      (LinearMap.trace 𝕜 (V x) ∘ₗ ContinuousLinearMap.coeLM 𝕜)
+  let Tr : (TangentSpace I x →L[𝕜] V x →L[𝕜] V x) →L[𝕜] TangentSpace I x →L[𝕜] 𝕜 :=
+    (LinearMap.toContinuousLinearMap.toLinearMap ∘ₗ
+      (tr ∘ₗ ContinuousLinearMap.coeLM 𝕜)).toContinuousLinearMap
+  Tr ∘L curvatureEndomorphismTensor F hcov x
+
+-- scalar curvature left to the reader
+-- (for this construction need to set up the typeclasses for a Riemannian manifold)
+
+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..2f3a5f6f9a91e3
--- /dev/null
+++ b/Mathlib/Geometry/Manifold/VectorBundle/CovariantDerivative/Ehresmann.lean
@@ -0,0 +1,393 @@
+/-
+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
+
+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..067dea7d41362c
--- /dev/null
+++ b/Mathlib/Geometry/Manifold/VectorBundle/CovariantDerivative/LeviCivita.lean
@@ -0,0 +1,355 @@
+/-
+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
+
+This file defines the Levi-Civita connection on a (finite-dimensional) Riemannian manifold `(M, g)`.
+A connection `∇` on the tangent bundle of a Riemannian manifold `(M, g)` is called a
+*Levi-Civita connection* 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 VectorField
+
+open scoped Manifold ContDiff
+
+section funpropsetup
+-- In the medium term, `fun_prop` should support `MDifferentiable`, `ContMDiff` and friends fully.
+-- This will require adding a custom discharger for models with corners.
+-- In the mean-time, add the following attributes in this file, as they are too useful to not use.
+
+attribute [fun_prop] MDifferentiable MDifferentiableAt
+  MDifferentiable.add MDifferentiableAt.add
+  mdifferentiableAt_fun_add_section MDifferentiableAt.fun_smul_section
+
+end funpropsetup
+
+-- Let `M` be a `C^2` manifold modeled on `(E, H)`.
+variable
+  {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
+  {H : Type*} [TopologicalSpace H] (I : ModelWithCorners ℝ E H)
+
+-- move this
+variable {M : Type*} [TopologicalSpace M] [ChartedSpace H M] [IsManifold I 1 M] in
+lemma injective_eval_mdifferentiableAt_vectorField (V : Type*) [AddCommGroup V] [Module ℝ V] [TopologicalSpace V]
+    (x : M) :
+    Function.Injective
+      (fun A : TangentSpace I x →L[ℝ] V ↦
+        fun (Z : Π x, TangentSpace I x) (_ : MDiffAt (T% Z) x) ↦ A (Z x)) :=
+  VectorBundle.injective_eval_mdifferentiableAt_sec ..
+
+variable {M : Type*} [EMetricSpace M] [ChartedSpace H M] [IsManifold I 2 M]
+
+-- From now on, `M` is endowed with a Riemannian metric.
+variable
+  [RiemannianBundle (fun (x : M) ↦ TangentSpace I x)]
+  {X X' X'' Y Y' Y'' Z Z' : Π x : M, TangentSpace I x}
+
+open scoped RealInnerProductSpace
+
+-- move this, and think whether it could be more general
+-- Note that Mathlib/Topology/FiberBundle/Basic.lean has a lot of similar lemma but far from enough
+-- imports.
+lemma VectorBundle.completeSpace (R : Type*) [NontriviallyNormedField R]
+    {B : Type*} [TopologicalSpace B]
+    (E : B → Type*) [(x : B) → AddCommGroup (E x)] [(x : B) → Module R (E x)]
+    (F : Type*) [NormedAddCommGroup F] [NormedSpace R F] [CompleteSpace F]
+    [TopologicalSpace (TotalSpace F E)] [(x : B) → UniformSpace (E x)]
+    [(x : B) → IsUniformAddGroup (E x)] [FiberBundle F E] [VectorBundle R F E] (b : B) :
+    CompleteSpace (E b) := by
+  let e := VectorBundle.continuousLinearEquivAt R F E b
+  rwa [completeSpace_congr (e := e.toEquiv) e.isUniformEmbedding]
+
+-- move this, also perhaps generalize to general Riemannian vector bundles,
+-- and write a variant for `CMDiffAt n`
+lemma injective_inner_mdifferentiableAt_vectorField [CompleteSpace E] (x : M) :
+    Function.Injective
+      (fun X₀ : TangentSpace I x ↦
+        fun (Z : Π x, TangentSpace I x) (_ : MDiffAt (T% Z) x) ↦ (⟪X₀, Z x⟫)) := by
+  have := VectorBundle.completeSpace ℝ (TangentSpace I (M := M)) E
+  set Φ := InnerProductSpace.toDual ℝ (TangentSpace I x)
+  exact (injective_eval_mdifferentiableAt_vectorField I ℝ x).comp Φ.injective
+
+-- Let `cov` and `cov'` be covariant derivatives on `TM`.
+variable (cov cov' : CovariantDerivative I E (TangentSpace I : M → Type _))
+
+/-- Local notation for a covariant derivative on a vector bundle acting on a vector field and a
+section. -/
+local syntax:max "∇" term:arg term:arg : term
+local macro_rules | `(∇ $X $σ) => `(fun (x : M) ↦ cov $σ x ($X x))
+local syntax:max "∇'" term:arg term:arg : term
+local macro_rules | `(∇' $X $σ) => `(fun (x : M) ↦ cov' $σ x ($X x))
+
+-- From now on, we assume the Riemannian metric on `M` is `C¹`.
+variable [IsContMDiffRiemannianBundle I 1 E (fun (x : M) ↦ TangentSpace I x)]
+
+-- Local notation for pointwise inner products of vector fields.
+-- Note this does not cause ambiguity with the notation obtained
+-- with `open scoped RealInnerProductSpace.`
+local notation "⟪" X ", " Y "⟫" => fun x ↦ inner ℝ (X x) (Y x)
+
+/- TODO: The next two lemmas are workaround for some version of Lean 4 #9077
+(Instance synthesis sees through type synonyms). They should be removed when that issue will
+be fully solved. -/
+
+variable {I} in
+@[fun_prop] 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
+@[fun_prop] 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
+
+namespace CovariantDerivative
+variable {x : M}
+
+/-- A covariant derivative on a Riemannian bundle `TM` is called a **Levi-Civita connection**
+if it is torsion-free and compatible with `g`.
+Note that the bundle metric on `TM` is implicitly hidden in this definition.
+-/
+@[expose] public def IsLeviCivitaConnection [FiniteDimensional ℝ E] : Prop :=
+  cov.IsCompatible ∧ cov.torsion = 0
+
+section uniqueness
+
+variable {cov cov'}
+
+/-- 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 `∇`. -/
+public lemma IsLeviCivitaConnection.apply_eq [FiniteDimensional ℝ E]
+    (h : cov.IsLeviCivitaConnection)
+    (hX : MDiffAt (T% X) x) (hY : MDiffAt (T% Y) x) (hZ : MDiffAt (T% Z) x) :
+    ⟪∇ X Y, Z⟫ x =
+      (d% ⟪Y, Z⟫ x (X x) + d% ⟪Z, X⟫ x (Y x) - d% ⟪X, Y⟫ x (Z x)
+      - ⟪Y ,(VectorField.mlieBracket I X Z)⟫ x
+      - ⟪Z, (VectorField.mlieBracket I Y X)⟫ x
+      + ⟪X, (VectorField.mlieBracket I Z Y)⟫ x) / 2 := by
+  -- use the compatibility in three ways
+  have eq1a := h.1.mvfderiv_inner_eq X hY hZ
+  have eq2a := h.1.mvfderiv_inner_eq Y hZ hX
+  have eq3a := h.1.mvfderiv_inner_eq Z hX hY
+  -- use the torsion-freeness in three ways
+  have eq1b := congr(inner ℝ (Y x) ($(h.2) x (X x) (Z x)))
+  have eq2b := congr(inner ℝ (Z x) ($(h.2) x (Y x) (X x)))
+  have eq3b := congr(inner ℝ (X x) ($(h.2) x (Z x) (Y x)))
+  -- combine
+  simp (disch := fun_prop) [real_inner_comm, inner_sub_right, torsion_apply] at *
+  linear_combination - (eq1a + eq1b + eq2a + eq2b - eq3a - eq3b) / 2
+
+/-- The Levi-Civita connection on `(M, g)` is uniquely determined on differentiable vector fields.
+
+Note that the differentiability hypotheses are required, since `CovariantDerivative` objects are
+unconstrained in their behaviour on non-differentiable vector fields. -/
+public theorem IsLeviCivitaConnection.uniqueness [FiniteDimensional ℝ E]
+    (hcov : cov.IsLeviCivitaConnection) (hcov' : cov'.IsLeviCivitaConnection)
+    (hX : MDiffAt (T% X) x) (hY : MDiffAt (T% Y) x) :
+    ∇ X Y x = ∇' X Y x := by
+  apply injective_inner_mdifferentiableAt_vectorField; ext Z hZ
+  exact (hcov.apply_eq I hX hY hZ).trans <| hcov'.apply_eq I hX hY hZ |>.symm
+
+end uniqueness
+
+section existence
+
+variable (X Y Z) in
+/-- Auxiliary quantity for the construction of the Levi-Civita connection:
+If `∇` is the Levi-Civita connection on `TM`, this formula will express `⟨∇ X Y, Z⟩`. -/
+noncomputable def leviCivitaAux (x : M) : ℝ :=
+  (d% ⟪Y, Z⟫ x (X x) + d% ⟪Z, X⟫ x (Y x) - d% ⟪X, Y⟫ x (Z x)
+  - ⟪Y ,(VectorField.mlieBracket I X Z)⟫ x
+  - ⟪Z, (VectorField.mlieBracket I Y X)⟫ x
+  + ⟪X, (VectorField.mlieBracket I Z Y)⟫ x) / 2
+
+/-- `leviCivitaAux` is tensorial with respect to its first argument. -/
+theorem leviCivitaAux_tensorial₁ [FiniteDimensional ℝ E]
+    {Y : Π x : M, TangentSpace I x} (x : M) (hY : MDiffAt (T% Y) x) {Z : Π x, TangentSpace I x}
+    (hZ : MDiffAt (T% Z) x) :
+    TensorialAt I E (leviCivitaAux I · Y Z x) x where
+  smul hf hX := by
+    simp (disch := fun_prop) [leviCivitaAux, mvfderiv_fun_mul,
+      mlieBracket_smul_left, mlieBracket_smul_right,
+      inner_add_right, inner_smul_left, inner_smul_right, real_inner_comm]
+    ring
+  add hX₁ hX₂ := by
+    simp (disch := fun_prop) [leviCivitaAux, mlieBracket_add_right, mlieBracket_add_left,
+      mvfderiv_fun_add, inner_add_left, inner_add_right]
+    ring
+
+/-- `leviCivitaAux` is tensorial with respect to its second argument. -/
+theorem leviCivitaAux_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 (leviCivitaAux I X Y · x) x where
+  smul hf hZ := by
+    simp (disch := fun_prop) [leviCivitaAux,
+      mlieBracket_smul_right, mlieBracket_smul_left,
+      mvfderiv_fun_mul,
+      inner_smul_left, inner_smul_right, inner_add_right, real_inner_comm]
+    ring
+  add hZ₁ hZ₂ := by
+    simp (disch := fun_prop) [leviCivitaAux,
+      mlieBracket_add_right, mlieBracket_add_left,
+      mvfderiv_fun_add,
+      inner_add_left, inner_add_right]
+    ring
+
+/-- Almost the underlying function underlying our construction of the Levi-Civita connection:
+this is the desired `(1,1)`-tensor, but without considerations to the junk value when
+applied to non-differentiable vector fields. -/
+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
+    (TensorialAt.mkHom₂ _ (x := x)
+      (fun _Z hZ ↦ leviCivitaAux_tensorial₁ _ _ hY hZ)
+      (fun _X hX ↦ leviCivitaAux_tensorial₂ _ _ hY hX))
+
+set_option backward.isDefEq.respectTransparency false in
+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⟫ = leviCivitaAux I X Y Z x := by
+  unfold lcAux₁
+  simp [TensorialAt.mkHom₂_apply _ _ hX hZ]
+
+open scoped Classical in
+/-- The function underlying our construction of the Levi-Civita connection on `(M,g)` -/
+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) :
+    ⟪lcAux I Y x (X x), Z x⟫ = leviCivitaAux I X Y Z x := by
+  simpa [lcAux, dif_pos hY] using lcAux₁_apply I hX hY hZ
+
+set_option backward.isDefEq.respectTransparency false in
+lemma isCovariantDerivativeOn_lcAux [FiniteDimensional ℝ E] :
+    IsCovariantDerivativeOn E (lcAux I (M := M)) where
+  add {Y Y'} x hY hY' _ := by
+    apply injective_eval_mdifferentiableAt_vectorField; ext X hX
+    apply injective_inner_mdifferentiableAt_vectorField; ext Z hZ
+    simp (disch := fun_prop) [lcAux, dif_pos, TensorialAt.mkHom₂_apply, lcAux₁,
+      leviCivitaAux, mvfderiv_fun_add,
+      mlieBracket_add_left, mlieBracket_add_right,
+      inner_add_left, inner_add_right]
+    ring
+  leibniz {Y f x} hY hf _ := by
+    apply injective_eval_mdifferentiableAt_vectorField; ext X hX
+    apply injective_inner_mdifferentiableAt_vectorField; ext Z hZ
+    simp (disch := fun_prop) [lcAux, dif_pos, lcAux₁, TensorialAt.mkHom₂_apply,
+      leviCivitaAux, mvfderiv_fun_mul,
+      mlieBracket_smul_left, mlieBracket_smul_right,
+      inner_add_left, inner_add_right, inner_smul_left, inner_smul_right, real_inner_comm]
+    ring
+
+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. -/
+public noncomputable def leviCivitaConnection [FiniteDimensional ℝ E] :
+    CovariantDerivative I E (TangentSpace I : M → Type _) where
+  toFun := lcAux I
+  isCovariantDerivativeOnUniv := isCovariantDerivativeOn_lcAux I
+
+public 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) :
+    ⟪leviCivitaConnection I M Y x (X x), Z x⟫ =
+      (d% ⟪Y, Z⟫ x (X x) + d% ⟪Z, X⟫ x (Y x) - d% ⟪X, Y⟫ x (Z x)
+      - ⟪Y, VectorField.mlieBracket I X Z⟫ x
+      - ⟪Z, VectorField.mlieBracket I Y X⟫ x
+      + ⟪X, VectorField.mlieBracket I Z Y⟫ x) / 2 :=
+  lcAux_apply _ hX hY hZ
+
+public theorem leviCivitaConnection_apply_right [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) :
+    ⟪X x, leviCivitaConnection I M Y x (Z x)⟫ =
+      (d% ⟪Y, X⟫ x (Z x) + d% ⟪X, Z⟫ x (Y x) - d% ⟪Z, Y⟫ x (X x)
+      - ⟪Y ,VectorField.mlieBracket I Z X⟫ x
+      - ⟪X, VectorField.mlieBracket I Y Z⟫ x
+      + ⟪Z, VectorField.mlieBracket I X Y⟫ x) / 2 := by
+  rw [real_inner_comm]
+  exact lcAux_apply _ hZ hY hX
+
+public lemma leviCivitaConnection_isCompatible [FiniteDimensional ℝ E] :
+    (leviCivitaConnection I M).IsCompatible := by
+  rw [isCompatible_iff]
+  intro x X Y Z hX hY hZ
+  -- Normalise the expressions by swapping arguments for inner product and mlieBracket,
+  -- until the swappable arguments are in order X < Y < Z.
+  simp (disch := fun_prop) [leviCivitaConnection_apply_right,
+    fun x ↦ real_inner_comm (Z x),
+    fun x ↦ real_inner_comm (Y x) (X x),
+    mlieBracket_swap (V := Z),
+    mlieBracket_swap (V := Y) (W := X)]
+  ring
+
+public lemma leviCivitaConnection_torsion_eq_zero [FiniteDimensional ℝ E] :
+    (leviCivitaConnection I M).torsion = 0 := by
+  rw [CovariantDerivative.torsion_eq_zero_iff]
+  intro X Y x hX hY
+  apply injective_inner_mdifferentiableAt_vectorField; ext Z hZ
+  simp (disch := fun_prop) [leviCivitaConnection_apply I,
+    mlieBracket_swap (V := Y) (W := X), mlieBracket_swap (V := Z) (W := X),
+    mlieBracket_swap (V := Z) (W := Y),
+    real_inner_comm, inner_sub_left]
+  ring
+
+/-- `leviCivitaConnection` is a Levi-Civita connection (i.e., compatible and torsion-free) -/
+public lemma leviCivitaConnection_isLeviCivitaConnection [FiniteDimensional ℝ E] :
+    (leviCivitaConnection I M).IsLeviCivitaConnection :=
+  ⟨leviCivitaConnection_isCompatible I, leviCivitaConnection_torsion_eq_zero I⟩
+
+end existence
+
+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..3c9a64ae1af920
--- /dev/null
+++ b/Mathlib/Geometry/Manifold/VectorBundle/CovariantDerivative/Metric.lean
@@ -0,0 +1,187 @@
+/-
+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
+
+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}
+
+local notation "⟪" σ ", " τ "⟫" => fun x ↦ inner ℝ (σ x) (τ x)
+
+namespace CovariantDerivative
+
+-- Let `cov` be a covariant derivative on `V`.
+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[ℝ] ℝ :=
+  d% ⟪σ, τ⟫ x - innerSL ℝ (τ x) ∘L cov σ x - innerSL ℝ (σ x) ∘L cov τ x
+
+@[simp]
+lemma compatibilityTensorAux_apply (σ τ : Π x : M, V x) {x : M} (X₀ : TangentSpace I x) :
+    compatibilityTensorAux I cov σ τ x X₀ =
+      d% ⟪σ, τ⟫ 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₀
+    simp [mvfderiv_fun_mul hf (hσ.inner_bundle hτ),
+      cov.isCovariantDerivativeOn.leibniz hσ hf, inner_add_left, inner_smul_left]
+    ring
+  add hσ hσ' := by
+    ext X₀
+    simp [mvfderiv_fun_add (hσ.inner_bundle hτ) (hσ'.inner_bundle hτ),
+      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₀
+    simp [mvfderiv_fun_mul hf (hσ.inner_bundle hτ),
+      cov.isCovariantDerivativeOn.leibniz hτ hf, inner_add_right, inner_smul_right]
+    ring
+  add hτ hτ' := by
+    ext X₀
+    simp [mvfderiv_fun_add (hσ.inner_bundle hτ) (hσ.inner_bundle hτ'),
+      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`. -/
+public 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
+public theorem compatibilityTensor_apply [FiniteDimensional ℝ F] (x : M)
+    (hσ : MDiffAt (T% σ) x) (hτ : MDiffAt (T% τ) x) :
+    cov.compatibilityTensor x (σ x) (τ x) (X x) =
+    d% ⟪σ, τ⟫ 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
+public theorem compatibilityTensor_apply_eq_extend [FiniteDimensional ℝ F] (X₀ : TangentSpace I x)
+    (σ₀ τ₀ : V x) :
+    cov.compatibilityTensor x σ₀ τ₀ X₀ =
+      d% ⟪(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]
+
+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 τ⟩`. -/
+public def IsCompatible [FiniteDimensional ℝ F] : Prop := compatibilityTensor cov = 0
+
+variable {I} [ContMDiffVectorBundle 1 F V I]
+
+variable {cov} in
+public lemma IsCompatible.mvfderiv_inner_eq [FiniteDimensional ℝ F] (hcov : cov.IsCompatible)
+    {x : M} (X : Π x, TangentSpace I x) {σ τ : (x : M) → V x}
+    (hσ : MDiffAt (T% σ) x) (hτ : MDiffAt (T% τ) x) :
+    d% ⟪σ, τ⟫ x (X x) = ⟪∇ X σ, τ⟫ x + ⟪σ, ∇ X τ⟫ x := by
+  have H := congr($hcov x (σ x) (τ x) (X x))
+  simp [compatibilityTensor_apply _ _ hσ hτ] at H
+  linear_combination H
+
+variable [IsManifold I 1 M]
+
+public 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 →
+      d% ⟪σ, τ⟫ x (X x) = ⟪∇ X σ, τ⟫ x + ⟪σ, ∇ X τ⟫ x := by
+  refine ⟨fun hcov x X σ τ hX ↦ hcov.mvfderiv_inner_eq X, fun h ↦ ?_⟩
+  ext1 x
+  apply VectorBundle.injective_eval_mdifferentiableAt_sec I F; ext1 σ; ext1 hσ
+  apply VectorBundle.injective_eval_mdifferentiableAt_sec I F; ext1 τ; ext1 hτ
+  apply VectorBundle.injective_eval_mdifferentiableAt_sec I E (TangentSpace I); ext X hX
+  simp (disch := assumption) [compatibilityTensor_apply]
+  linear_combination h hX hσ hτ
+
+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..e48e1836f40927
--- /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 ↦ mvfderiv I s x) univ where
+  add hσ hσ' hx := by
+    rw [mdifferentiableAt_section_trivial_iff] at hσ hσ'
+    rw [mvfderiv_add hσ hσ']
+  leibniz hσ hg hx := by
+    rw [mdifferentiableAt_section] at hσ
+    ext1 X₀
+    simp at hσ
+    simp [mvfderiv_smul hg hσ]
+
+lemma of_endomorphism (A : (x : M) → F →L[𝕜] TangentSpace I x →L[𝕜] F) :
+    IsCovariantDerivativeOn F (fun (s : M → F) x ↦ d% 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
+    ext X -- TODO: missing API lemma, without the ext cannot see through mvfderiv...
+    simp [mvfderiv, 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 → cov σ x = mvfderiv I σ x + 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σ]
+  simp only [mvfderiv]
+  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 20f7437e4eace3..8d04df0f38f6cb 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 ecff97d02c97fe..abd9ab5bfd2313 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 2f1636e1a92737..d9f604c3919dc4 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
 
@@ -358,11 +357,14 @@ lemma mdifferentiableWithinAt_add_section
     · exact fun x hx ↦ (e.linear 𝕜 hx).1 ..
   · exact (e.linear 𝕜 (FiberBundle.mem_baseSet_trivializationAt' x₀)).1 ..
 
+@[to_fun]
 lemma mdifferentiableAt_add_section
     (hs : MDiffAt (T% s) x₀) (ht : MDiffAt (T% t) x₀) :
     MDiffAt (T% (s + t)) x₀ := by
   rw [← mdifferentiableWithinAt_univ] at hs ht ⊢
   apply mdifferentiableWithinAt_add_section hs ht
+-- TODO: remove this once to_fun outputs can be named!
+alias mdifferentiableAt_fun_add_section := fun_mdifferentiableAt_add_section
 
 lemma mdifferentiableOn_add_section
     (hs : MDiff[u] (T% s)) (ht : MDiff[u] (T% t)) : MDiff[u] (T% (s + t)) :=
@@ -426,6 +428,7 @@ lemma MDifferentiableWithinAt.smul_section
     · exact fun x hx ↦ (e.linear 𝕜 hx).2 ..
   · apply (e.linear 𝕜 (FiberBundle.mem_baseSet_trivializationAt' x₀)).2
 
+@[to_fun]
 lemma MDifferentiableAt.smul_section
     (hf : MDiffAt f x₀) (hs : MDiffAt (T% s) x₀) : MDiffAt (T% (f • s)) x₀ := by
   rw [← mdifferentiableWithinAt_univ] at hs ⊢
@@ -715,5 +718,25 @@ lemma mdifferentiableAt_extend {x : M} (σ₀ : V x) :
     MDiffAt (T% (extend F σ₀)) x :=
   (contMDiffAt_extend' (k := 1) I F σ₀).mdifferentiableAt one_ne_zero
 
+variable (V) in
+lemma _root_.VectorBundle.injective_eval_mdifferentiableAt_sec [∀ x, Module 𝕜 (V x)]
+    (W : Type*) [AddCommGroup W] [Module 𝕜 W] [TopologicalSpace W] (x : M) :
+    Function.Injective
+      (fun A : V x →L[𝕜] W ↦
+        fun (Z : Π x, V x) (_ : MDiffAt (T% Z) x) ↦ A (Z x)) := by
+  intro X X' h
+  ext σ₀
+  simpa using congr($h (extend F σ₀) (mdifferentiableAt_extend ..))
+
+variable (V) in
+lemma _root_.VectorBundle.injective_eval_contMDiffAt_sec {n : WithTop ℕ∞} [∀ x, Module 𝕜 (V x)]
+    (W : Type*) [AddCommGroup W] [Module 𝕜 W] [TopologicalSpace W] (x : M) :
+    Function.Injective
+      (fun A : V x →L[𝕜] W ↦
+        fun (Z : Π x, V x) (_ : CMDiffAt n (T% Z) x) ↦ A (Z x)) := by
+  intro X X' h
+  ext σ₀
+  simpa using congr($h (extend F σ₀) (contMDiffAt_extend' ..))
+
 end FiberBundle
 end extend
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/Tensoriality.lean b/Mathlib/Geometry/Manifold/VectorBundle/Tensoriality.lean
index bca580206860da..43fa17d32469b3 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 → MDiffAt (T% υ) x → TensorialAt I F (Φ · τ υ) x)
+    (hΦ₂ : ∀ σ υ, MDiffAt (T% σ) x → MDiffAt (T% υ) x → TensorialAt I F' (Φ σ · υ) x)
+    (hΦ₃ : ∀ σ τ, MDiffAt (T% σ) x → 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 → MDiffAt (T% υ) x → TensorialAt I F (Φ · τ υ) x)
+    (hΦ₂ : ∀ σ υ, MDiffAt (T% σ) x → MDiffAt (T% υ) x → TensorialAt I F' (Φ σ · υ) x)
+    (hΦ₃ : ∀ σ τ, MDiffAt (T% σ) x → 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 → MDiffAt (T% υ) x → TensorialAt I F (Φ · τ υ) x)
+    (hΦ₂ : ∀ σ υ, MDiffAt (T% σ) x → MDiffAt (T% υ) x → TensorialAt I F' (Φ σ · υ) x)
+    (hΦ₃ : ∀ σ τ, MDiffAt (T% σ) x → 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
diff --git a/Mathlib/Geometry/Manifold/VectorField/LieBracket.lean b/Mathlib/Geometry/Manifold/VectorField/LieBracket.lean
index 1053c4a7ac2823..b23b72b0fe42ae 100644
--- a/Mathlib/Geometry/Manifold/VectorField/LieBracket.lean
+++ b/Mathlib/Geometry/Manifold/VectorField/LieBracket.lean
@@ -361,8 +361,7 @@ lemma mlieBracketWithin_smul_right {f : M → 𝕜} (hf : MDiffAt[s] f x)
     (hW : MDiffAt[s] (fun x ↦ (W x : TangentBundle I M)) x)
     (hs : UniqueMDiffWithinAt I s x) :
     mlieBracketWithin I V (f • W) s x =
-      (fromTangentSpace (f x) (mfderiv[s] f x (V x))) • (W x)
-      + (f x) • mlieBracketWithin I V W s x := by
+      (d[s] f x (V x)) • (W x) + (f x) • mlieBracketWithin I V W s x := by
   simp only [mlieBracketWithin, mpullbackWithin_smul]
   -- Simplify local notation a bit.
   set V' := mpullbackWithin 𝓘(𝕜, E) I (extChartAt I x).symm V (range I)
@@ -391,10 +390,9 @@ Product rule for Lie brackets: given two vector fields `V` and `W` on `M` and a
 lemma mlieBracket_smul_right {f : M → 𝕜} (hf : MDiffAt f x)
     (hW : MDiffAt (fun x ↦ (W x : TangentBundle I M)) x) :
     mlieBracket I V (f • W) x =
-      (fromTangentSpace (f x) (mfderiv% f x (V x))) • (W x)
-      + (f x) • mlieBracket I V W x := by
+      d% f x (V x) • (W x) + (f x) • mlieBracket I V W x := by
   rw [← mdifferentiableWithinAt_univ] at hf hW
-  rw [← mlieBracketWithin_univ, ← mfderivWithin_univ]
+  rw [← mlieBracketWithin_univ, ← mvfderivWithin_univ]
   exact mlieBracketWithin_smul_right hf hW (uniqueMDiffWithinAt_univ I)
 
 /--
@@ -405,8 +403,7 @@ lemma mlieBracketWithin_smul_left {f : M → 𝕜} (hf : MDiffAt[s] f x)
     (hV : MDiffAt[s] (fun x ↦ (V x : TangentBundle I M)) x)
     (hs : UniqueMDiffWithinAt I s x) :
     mlieBracketWithin I (f • V) W s x =
-      -(fromTangentSpace (f x) (mfderiv[s] f x (W x))) • (V x)
-      + (f x) • mlieBracketWithin I V W s x := by
+      - d[s] f x (W x) • (V x) + (f x) • mlieBracketWithin I V W s x := by
   rw [mlieBracketWithin_swap, Pi.neg_apply, mlieBracketWithin_smul_right hf hV (V := W) hs,
     mlieBracketWithin_swap]
   simp; abel
@@ -418,16 +415,15 @@ Product rule for Lie brackets: given two vector fields `V` and `W` on `M` and a
 lemma mlieBracket_smul_left {f : M → 𝕜} (hf : MDiffAt f x)
     (hV : MDiffAt (fun x ↦ (V x : TangentBundle I M)) x) :
     mlieBracket I (f • V) W x =
-      - (fromTangentSpace (f x) (mfderiv% f x (W x))) • (V x)
-      + (f x) • mlieBracket I V W x := by
+      - (d% f x (W x)) • (V x) + (f x) • mlieBracket I V W x := by
   rw [← mdifferentiableWithinAt_univ] at hf hV
-  rw [← mlieBracketWithin_univ, ← mfderivWithin_univ]
+  rw [← mlieBracketWithin_univ, mvfderiv, ← mfderivWithin_univ]
   exact mlieBracketWithin_smul_left hf hV (uniqueMDiffWithinAt_univ I)
 
 lemma mlieBracketWithin_const_smul_left
     (hV : MDiffAt[s] (T% V) x) (hs : UniqueMDiffWithinAt I s x) :
     mlieBracketWithin I (c • V) W s x = c • mlieBracketWithin I V W s x := by
-  simpa [mfderivWithin_const] using
+  simpa [mfderivWithin_const, mvfderivWithin] using
     mlieBracketWithin_smul_left (mdifferentiableWithinAt_const (c := c)) (W := W) hV hs
 
 lemma mlieBracket_const_smul_left (hV : MDiffAt (T% V) x) :
@@ -438,7 +434,7 @@ lemma mlieBracket_const_smul_left (hV : MDiffAt (T% V) x) :
 lemma mlieBracketWithin_const_smul_right
     (hW : MDiffAt[s] (T% W) x) (hs : UniqueMDiffWithinAt I s x) :
     mlieBracketWithin I V (c • W) s x = c • mlieBracketWithin I V W s x := by
-  simpa [mfderivWithin_const] using
+  simpa [mfderivWithin_const, mvfderivWithin] using
     mlieBracketWithin_smul_right (mdifferentiableWithinAt_const (c := c)) (V := V) hW hs
 
 lemma mlieBracket_const_smul_right (hW : MDiffAt (T% W) x) :