diff --git a/Mathlib.lean b/Mathlib.lean
index a52b2d3816d854..92156ce96df213 100644
--- a/Mathlib.lean
+++ b/Mathlib.lean
@@ -4397,6 +4397,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
@@ -4405,14 +4406,23 @@ public import Mathlib.Geometry.Manifold.SmoothApprox
 public import Mathlib.Geometry.Manifold.SmoothEmbedding
 public import Mathlib.Geometry.Manifold.StructureGroupoid
 public import Mathlib.Geometry.Manifold.VectorBundle.Basic
+public import Mathlib.Geometry.Manifold.VectorBundle.CovariantDerivative.Basic
+public import Mathlib.Geometry.Manifold.VectorBundle.CovariantDerivative.LeviCivita
+public import Mathlib.Geometry.Manifold.VectorBundle.CovariantDerivative.Lift
+public import Mathlib.Geometry.Manifold.VectorBundle.CovariantDerivative.Prelim
+public import Mathlib.Geometry.Manifold.VectorBundle.CovariantDerivative.Torsion
 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.Misc
+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.VectorField.LieBracket
 public import Mathlib.Geometry.Manifold.VectorField.Pullback
 public import Mathlib.Geometry.Manifold.WhitneyEmbedding
diff --git a/Mathlib/Geometry/Manifold/CheatSheet.md b/Mathlib/Geometry/Manifold/CheatSheet.md
new file mode 100644
index 00000000000000..ede331a4011da6
--- /dev/null
+++ b/Mathlib/Geometry/Manifold/CheatSheet.md
@@ -0,0 +1,127 @@
+## Differential geometry cheat sheet
+
+How do I say certain basic things in Lean?
+For each of them, include a variable block. Can verso do this already?
+
+
+Let M be a C^k manifold.
+```
+variable {𝕜 E M H : Type*} [NontriviallyNormedField 𝕜] [NormedAddCommGroup E]
+  [NormedSpace 𝕜 E] [TopologicalSpace H] [TopologicalSpace M] {k : ℕ} -- more general: take k : WithTop ℕ∞, allows smooth and analytic; remove WithTop to exclude analyticity
+  {I : ModelWithCorners 𝕜 E H} [ChartedSpace H M] [IsManifold I k M]
+```
+
+Let M be a smooth manifold
+```
+variable {𝕜 E M H : Type*} [NontriviallyNormedField 𝕜] [NormedAddCommGroup E]
+  [NormedSpace 𝕜 E] [TopologicalSpace H] [TopologicalSpace M]
+  {I : ModelWithCorners 𝕜 E H} [ChartedSpace H M] [IsManifold I ∞ M]
+```
+
+Let M be a smooth real manifold.
+```
+variable {E M H : Type*} [NormedAddCommGroup E]
+  [NormedSpace ℝ E] [TopologicalSpace H] [TopologicalSpace M]
+  {I : ModelWithCorners ℝ E H} [ChartedSpace H M] [IsManifold I ∞ M] -- test, needs open scoped Manifold??
+```
+
+Let M be an analytic manifold
+```
+open scoped Manifold -- test, necessary?
+
+variable {𝕜 E M H : Type*} [NontriviallyNormedField 𝕜] [NormedAddCommGroup E]
+  [NormedSpace 𝕜 E] [TopologicalSpace H] [TopologicalSpace M]
+  {I : ModelWithCorners 𝕜 E H} [ChartedSpace H M] [IsManifold I ω M]
+```
+
+Differentiability of functions between manifolds
+```
+import Mathlib.Geometry.Manifold.MFDeriv.Defs
+import Mathlib.Geometry.Manifold.ContMDiff.Defs
+
+variable
+  -- Given a non-trivially normed field 𝕜
+  {𝕜 : Type*} [NontriviallyNormedField 𝕜]
+  -- A manifold M over 𝕜
+  {E : Type*} [NormedAddCommGroup E] [NormedSpace 𝕜 E]
+  {H : Type*} [TopologicalSpace H] (I : ModelWithCorners 𝕜 E H)
+  {M : Type*} [TopologicalSpace M] [ChartedSpace H M]
+  -- A manifold M' over 𝕜
+  {E' : Type*} [NormedAddCommGroup E'] [NormedSpace 𝕜 E']
+  {H' : Type*} [TopologicalSpace H'] (I' : ModelWithCorners 𝕜 E' H')
+  {M' : Type*} [TopologicalSpace M'] [ChartedSpace H' M']
+  -- A function from M to M' and x in M
+  (f : M → M') (x : M)
+
+variable (x : M) in
+-- f is differentiable at x
+#check MDifferentiableAt I I' f x
+
+variable (n : WithTop ℕ∞) in -- A natural number or ∞ or ω
+#check ContMDiff I I' n f
+
+
+variable
+  {F : Type*} [NormedAddCommGroup F] [NormedSpace 𝕜 F]
+  (g : M → F) in
+open scoped Manifold in
+#check ContMDiff I 𝓘(𝕜, F) n g  -- g is n times continuously differentiable
+```
+
+Consider the product manifold M \times N.
+
+
+Let \phi be the preferred chart at x\in M.
+
+Let \phi be any (compatible) chart on M.
+
+--------
+
+Let E\to M be a topological vector bundle.
+
+Let E\to M be a smooth vector bundle.
+
+Let s be a section of E.
+```
+variable (s : Π x : M, V x)
+```
+Let X be a vector field on `M`
+```
+(X : Π x : M, TangentSpace I x)
+```
+
+Let s be a C^k section of E. / The section s of E is C^k.
+```
+ContMDiff I (I.prod 𝓘(𝕜, F)) (k + 1) (fun x ↦ TotalSpace.mk' F x (σ x))
+```
+
+Let `X` be a C^k vector field on M.
+```
+variable {X : Π x : M, TangentSpace I x}
+-- TODO: this doesn't work!
+-- variable (___hX: ContMDiff I I.tangent 2 (fun x ↦ (X x : TangentBundle I M)))
+```
+
+Let \phi be the preferred local trivialisation at x\in E.
+Let \phi be any compatible trivialisation on M.
+
+Consider the tangent bundle TM of M.
+
+Let X be a C^k vector field on M.
+
+explain TotalSpace.mk' somewhere in here...
+
+
+
+**Basic API lemmas**
+- testing smoothness of a map in charts: the standard charts; any charts
+
+- testing smoothness of a section in trivialisations: the standard charts; any charts
+
+
+**constructions**
+- product manifold (tricky!)
+- disjoint union
+
+- product bundle (how difficult?)
+- Lie bracket of vector fields
diff --git a/Mathlib/Geometry/Manifold/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 5a9508233dce83..a928c9066135d6 100644
--- a/Mathlib/Geometry/Manifold/VectorBundle/Basic.lean
+++ b/Mathlib/Geometry/Manifold/VectorBundle/Basic.lean
@@ -61,6 +61,18 @@ fields, etc.
 
 @[expose] public section
 
+-- Kyle’s #check' command. This has nothing to do here but will be convenient for us
+open Lean Elab Command PrettyPrinter Delaborator in
+elab tk:"#check' " name:ident : command => runTermElabM fun _ => do
+  for c in (← realizeGlobalConstWithInfos name) do
+    addCompletionInfo <| .id name name.getId (danglingDot := false) {} none
+    let info ← getConstInfo c
+    let delab : Delab := do
+      delabForallParamsWithSignature fun binders type => do
+        let binders := binders.filter fun binder => binder.raw.isOfKind ``Parser.Term.explicitBinder
+        return ⟨← `(declSigWithId| $(mkIdent c) $binders* : $type)⟩
+    logInfoAt tk <| .ofFormatWithInfosM (PrettyPrinter.ppExprWithInfos (delab := delab) info.type)
+
 assert_not_exists mfderiv
 
 open Bundle Set OpenPartialHomeomorph
diff --git a/Mathlib/Geometry/Manifold/VectorBundle/CovariantDerivative/Basic.lean b/Mathlib/Geometry/Manifold/VectorBundle/CovariantDerivative/Basic.lean
new file mode 100644
index 00000000000000..c13639bb638a7b
--- /dev/null
+++ b/Mathlib/Geometry/Manifold/VectorBundle/CovariantDerivative/Basic.lean
@@ -0,0 +1,1237 @@
+/-
+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.SmoothSection
+public import Mathlib.Geometry.Manifold.VectorBundle.Tangent
+public import Mathlib.Geometry.Manifold.MFDeriv.FDeriv
+public import Mathlib.Geometry.Manifold.MFDeriv.SpecificFunctions
+public import Mathlib.Geometry.Manifold.BumpFunction
+public import Mathlib.Geometry.Manifold.Notation
+public import Mathlib.Geometry.Manifold.VectorBundle.Misc
+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.Prelim
+
+/-!
+# Covariant derivatives
+
+TODO: add a more complete doc-string
+
+-/
+
+open Bundle Filter Module Topology Set
+
+open scoped Bundle Manifold ContDiff
+
+
+
+variable {𝕜 : Type*} [NontriviallyNormedField 𝕜]
+
+@[expose] public section -- TODO: think if we want to expose all definitions!
+
+section any_field
+variable {E : Type*} [NormedAddCommGroup E] [NormedSpace 𝕜 E] -- [FiniteDimensional 𝕜 E]
+  {H : Type*} [TopologicalSpace H] {I : ModelWithCorners 𝕜 E H}
+  {M : Type*} [TopologicalSpace M] [ChartedSpace H M]
+
+variable {E' : Type*} [NormedAddCommGroup E'] [NormedSpace 𝕜 E']
+
+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)]
+  -- [∀ x, IsTopologicalAddGroup (V x)] [∀ x, ContinuousSMul 𝕜 (V x)]
+  [FiberBundle F V] --[VectorBundle 𝕜 F V]
+  -- `V` vector bundle
+
+structure IsCovariantDerivativeOn [IsManifold I 1 M]
+    (f : (Π x : M, TangentSpace I x) → (Π x : M, V x) → (Π x : M, V x))
+    (s : Set M := Set.univ) : Prop where
+  -- All the same axioms as CovariantDerivative, but restricted to the set s.
+  addX (f) {X X' : Π x : M, TangentSpace I x} {σ : Π x : M, V x} {x : M}
+    (hX : MDiffAt (T% X) x) (hX' : MDiffAt (T% X') x) (hσ : MDiffAt (T% σ) x)
+    (hx : x ∈ s := by trivial) :
+    f (X + X') σ x = f X σ x + f X' σ x
+  smulX {X : Π x : M, TangentSpace I x} {σ : Π x : M, V x} {g : M → 𝕜} {x : M}
+    (hX : MDiffAt (T% X) x) (hσ : MDiffAt (T% σ) x) (hg : MDiffAt g x) (hx : x ∈ s := by trivial) :
+    f (g • X) σ x = g x • f X σ x
+  addσ {X : Π x : M, TangentSpace I x} {σ σ' : Π x : M, V x} {x}
+    (hX : MDiffAt (T% X) x) (hσ : MDiffAt (T% σ) x) (hσ' : MDiffAt (T% σ') x)
+    (hx : x ∈ s := by trivial) :
+    f X (σ + σ') x = f X σ x + f X σ' x
+  leibniz {X : Π x : M, TangentSpace I x} {σ : Π x : M, V x} {g : M → 𝕜} {x}
+    (hX : MDiffAt (T% X) x) (hσ : MDiffAt (T% σ) x) (hg : MDiffAt g x) (hx : x ∈ s := by trivial):
+    f X (g • σ) x = (g • f X σ) x + ((bar _).toFun (mfderiv% g x (X x))) • σ x
+  smul_const_σ {X : Π x : M, TangentSpace I x} {σ : Π x : M, V x} {x} (a : 𝕜)
+    (hX : MDiffAt (T% X) x) (hσ : MDiffAt (T% σ) x) (hx : x ∈ s := by trivial) :
+    f X (a • σ) x = a • f X σ x
+
+/--
+A covariant derivative ∇ is called of class `C^k` iff,
+whenever `X` is a `C^k` section and `σ` a `C^{k+1}` section, the result `∇ X σ` is a `C^k` section.
+This is a class so typeclass inference can deduce this automatically.
+-/
+class ContMDiffCovariantDerivativeOn [IsManifold I 1 M] (k : ℕ∞)
+    (cov : (Π x : M, TangentSpace I x) → (Π x : M, V x) → (Π x : M, V x))
+    (u : Set M) where
+  contMDiff : ∀ {X : Π x : M, TangentSpace I x} {σ : Π x : M, V x},
+    CMDiff[u] (k + 1) (T% σ) → CMDiff[u] k (T% X) →
+    CMDiff[u] k (T% (cov X σ))
+
+variable {F}
+
+namespace IsCovariantDerivativeOn
+
+variable [IsManifold I 1 M]
+
+variable (E) in
+/-- If `E` is the trivial vector space, the axioms of a covariant derivative are vacuous. -/
+lemma of_subsingleton [hE : Subsingleton E]
+    (f : ((x : M) → TangentSpace I x) → ((x : M) → TangentSpace I x) →
+      ((x : M) → TangentSpace I x)) :
+    IsCovariantDerivativeOn E f Set.univ := by
+  have (X) (Y) (x) : f X Y x = 0 := by
+    have : Subsingleton (TangentSpace I x) := inferInstanceAs (Subsingleton E)
+    exact Subsingleton.eq_zero _
+  exact {
+    addX {_X _X' _σ x} hX hX' hσ hx := by simp [this]
+    smulX {_X _σ _g _x} hX hσ hg hx := by simp [this]
+    smul_const_σ {X _σ x} a hX hσ hx := by simp [this]
+    addσ {X σ σ' x} hX hσ hσ' hx := by simp [this]
+    leibniz {X σ g x} hX hσ hg hx := by
+      have hσ : σ x = 0 := by
+        have : Subsingleton (TangentSpace I x) := inferInstanceAs (Subsingleton E)
+        exact Subsingleton.eq_zero _
+      simp [this, hσ] }
+
+section changing_set
+/-! Changing set
+
+In this changing we change `s` in `IsCovariantDerivativeOn F f s`.
+
+-/
+lemma mono
+    {f : (Π x : M, TangentSpace I x) → (Π x : M, V x) → (Π x : M, V x)} {s t : Set M}
+    (hf : IsCovariantDerivativeOn F f t) (hst : s ⊆ t) : IsCovariantDerivativeOn F f s where
+  addX {_X _X' _σ} _x hX hX' hσ hx := hf.addX hX hX' hσ (hst hx)
+  smulX {_X _σ _g} _x hX hσ hg hx := hf.smulX hX hσ hg (hst hx)
+  addσ {_X _σ _σ' _x} hX hσ hσ' hx := hf.addσ hX hσ hσ' (hst hx)
+  leibniz {_X _σ _f _x} hX hσ hf' hx := hf.leibniz hX hσ hf' (hst hx)
+  smul_const_σ {_X _σ _x} a hX hσ hx := hf.smul_const_σ a hX hσ (hst hx)
+
+lemma iUnion {ι : Type*}
+    {f : (Π x : M, TangentSpace I x) → (Π x : M, V x) → (Π x : M, V x)} {s : ι → Set M}
+    (hf : ∀ i, IsCovariantDerivativeOn F f (s i)) : IsCovariantDerivativeOn F f (⋃ i, s i) where
+  addX {_X _X' _σ _x} hX hX' hσ hx := by
+    obtain ⟨si, ⟨i, rfl⟩, hxsi⟩ := hx
+    exact (hf i).addX hX hX' hσ hxsi
+  smulX {_X _σ _g _x} hX hσ hg hx := by
+    obtain ⟨si, ⟨i, rfl⟩, hxsi⟩ := hx
+    exact (hf i).smulX hX hσ hg hxsi
+  addσ {_X _σ _σ' _x} hX hσ hσ' hx := by
+    obtain ⟨si, ⟨i, rfl⟩, hxsi⟩ := hx
+    exact (hf i).addσ hX hσ hσ'
+  leibniz {X σ f x} hX hσ hf' hx := by
+    obtain ⟨si, ⟨i, rfl⟩, hxsi⟩ := hx
+    exact (hf i).leibniz hX hσ hf'
+  smul_const_σ {_X _σ _x} a hX hσ hx := by
+    obtain ⟨si, ⟨i, rfl⟩, hxsi⟩ := hx
+    exact (hf i).smul_const_σ _ hX hσ
+
+end changing_set
+
+/- Congruence properties -/
+section
+
+lemma congr {f g : (Π x : M, TangentSpace I x) → (Π x : M, V x) → (Π x : M, V x)} {s : Set M}
+    (hf : IsCovariantDerivativeOn F f s)
+    -- Is this too strong? Will see!
+    (hfg : ∀ {X : Π x : M, TangentSpace I x},
+      ∀ {σ : Π x : M, V x}, ∀ {x}, x ∈ s → f X σ x = g X σ x) :
+    IsCovariantDerivativeOn F g s where
+  addX hX hX' hσ hx := by simp [← hfg hx, hf.addX hX hX' hσ]
+  smulX hX hσ hg hx := by simp [← hfg hx, hf.smulX hX hσ hg]
+  addσ hX hσ hσ' hx := by simp [← hfg hx, hf.addσ hX hσ hσ']
+  leibniz hX hσ hf' hx := by simp [← hfg hx, hf.leibniz hX hσ hf']
+  smul_const_σ a hX hσ hx := by simp [← hfg hx, hf.smul_const_σ a hX hσ]
+
+end
+
+section computational_properties
+
+lemma smul_const_X
+    {f : (Π x : M, TangentSpace I x) → (Π x : M, V x) → (Π x : M, V x)}
+    {s : Set M} (h : IsCovariantDerivativeOn F f s) {x} (a : 𝕜)
+    {X : Π x, TangentSpace I x} {σ : Π x, V x} (hX : MDiffAt (T% X) x) (hσ : MDiffAt (T% σ) x)
+    (hx : x ∈ s := by trivial) :
+    f (a • X) σ x = a • f X σ x :=
+  h.smulX hX hσ mdifferentiableAt_const
+
+variable {f : (Π x : M, TangentSpace I x) → (Π x : M, V x) → (Π x : M, V x)} {s : Set M}
+
+@[simp]
+lemma zeroX (hf : IsCovariantDerivativeOn F f s)
+    {x : M} (hx : x ∈ s := by trivial)
+    {σ : Π x : M, V x} (hσ : MDiffAt (T% σ) x) : f 0 σ x = 0 := by
+  -- TODO: writing MDiffAt here yields an error!
+  have : MDifferentiableAt I (I.prod 𝓘(𝕜, E)) (T% (fun x ↦ (0 : TangentSpace I x))) x :=
+    -- TODO: add mdifferentiable{,At}_zeroSection
+    (contMDiff_zeroSection _ _).mdifferentiableAt one_ne_zero
+  simpa using IsCovariantDerivativeOn.addX f hf (X := 0) this this hσ
+
+@[simp]
+lemma zeroσ [VectorBundle 𝕜 F V] (hf : IsCovariantDerivativeOn F f s)
+    {X : Π x : M, TangentSpace I x} {x} (hX : MDiffAt (T% X) x) (hx : x ∈ s := by trivial) :
+    f X 0 x = 0 := by
+  simpa using (hf.addσ hX (mdifferentiableAt_zeroSection ..)
+    (mdifferentiableAt_zeroSection ..) : f X (0 + 0) x = _)
+
+lemma sum_X (hf : IsCovariantDerivativeOn F f s)
+    {ι : Type*} {u : Finset ι} {X : ι → Π x : M, TangentSpace I x} {σ : Π x : M, V x}
+    {x} (hx : x ∈ s) (hX : ∀ i, MDiffAt (T% (X i)) x) (hσ : MDiffAt (T% σ) x) :
+    f (∑ i ∈ u, X i) σ x = ∑ i ∈ u, f (X i) σ x := by
+  classical
+  have := hf.zeroX hx hσ
+  induction u using Finset.induction_on with
+  | empty => simp [hf.zeroX hx hσ]
+  | insert a u ha h =>
+    have : MDiffAt (T% (∑ i ∈ u, X i)) x := by simpa using MDifferentiableAt.sum_section (s := u) hX
+    simp [Finset.sum_insert ha, ← h, hf.addX (hX a) this hσ hx]
+
+end computational_properties
+
+section operations
+
+variable {s : Set M}
+    {f : (Π x : M, TangentSpace I x) → (Π x : M, V x) → (Π x : M, V x)}
+
+/-- An affine combination of covariant derivatives is a covariant derivative. -/
+@[simps]
+def affineCombination
+    {f' : (Π x : M, TangentSpace I x) → (Π x : M, V x) → (Π x : M, V x)}
+    (hf : IsCovariantDerivativeOn F f s) (hf' : IsCovariantDerivativeOn F f' s) (g : M → 𝕜) :
+    IsCovariantDerivativeOn F (fun X σ ↦ (g • (f X σ)) + (1 - g) • (f' X σ)) s where
+  addX {X X' σ} x hX hX' hσ hx := by simp [hf.addX hX hX' hσ, hf'.addX hX hX' hσ]; module
+  smulX {_X _σ _φ} x hX hσ hφ hx := by simp [hf.smulX hX hσ hφ, hf'.smulX hX hσ hφ]; module
+  addσ {_X _σ _σ' x} hX hσ hσ' hx := by
+    simp [hf.addσ hX hσ hσ', hf'.addσ hX hσ hσ']
+    module
+  smul_const_σ {_X _σ _x} a hX hσ hx := by
+    simp [hf.smul_const_σ a hX hσ, hf'.smul_const_σ a hX hσ]
+    module
+  leibniz {X σ φ x} hX hσ hφ hx := by
+    simp [hf.leibniz hX hσ hφ, hf'.leibniz hX hσ hφ]
+    module
+
+/-- An affine combination of two `C^k` connections is a `C^k` connection. -/
+lemma _root_.ContMDiffCovariantDerivativeOn.affineCombination
+    [VectorBundle 𝕜 F V]
+    {cov cov' : (Π x : M, TangentSpace I x) → (Π x : M, V x) → (Π x : M, V x)}
+    {u: Set M} {f : M → 𝕜} {n : ℕ∞} (hf : CMDiff[u] n f)
+    (Hcov : ContMDiffCovariantDerivativeOn (F := F) n cov u)
+    (Hcov' : ContMDiffCovariantDerivativeOn (F := F) n cov' u) :
+    ContMDiffCovariantDerivativeOn F n (fun X σ ↦ (f • (cov X σ)) + (1 - f) • (cov' X σ)) u where
+  contMDiff hX hσ := by
+    apply ContMDiffOn.add_section
+    · exact hf.smul_section <| Hcov.contMDiff hX hσ
+    · exact (contMDiffOn_const.sub hf).smul_section <| Hcov'.contMDiff hX hσ
+
+/-- A finite affine combination of covariant derivatives is a covariant derivative. -/
+def affineCombination' {ι : Type*} {s : Finset ι} [Nonempty s]
+    {u : Set M} {cov : ι → (Π x : M, TangentSpace I x) → (Π x : M, V x) → (Π x : M, V x)}
+    (h : ∀ i, IsCovariantDerivativeOn F (cov i) u) {f : ι → M → 𝕜} (hf : ∑ i ∈ s, f i = 1) :
+    IsCovariantDerivativeOn F (fun X σ x ↦ ∑ i ∈ s, (f i x) • (cov i) X σ x) u where
+  addX {_X _X' _σ} x hx hX hX' hσ := by
+    rw [← Finset.sum_add_distrib]
+    congr
+    ext i
+    simp [(h i).addX hx hX hX' hσ]
+  smulX {_X _σ _g} x hx hX hσ hg := by
+    rw [Finset.smul_sum]
+    congr
+    ext i
+    simp [(h i).smulX hx hX hσ hg]
+    module
+  addσ {_X _σ _σ' _x} hX hσ hσ' hx := by
+    rw [← Finset.sum_add_distrib]
+    congr
+    ext i
+    rw [← smul_add, (h i).addσ hX hσ hσ' hx]
+  smul_const_σ {_X _σ _x} a hX hσ hx := by
+    rw [Finset.smul_sum]
+    congr
+    ext i
+    simp [(h i).smul_const_σ a hX hσ]
+    module
+  leibniz {X σ g x} hX hσ hg hx := by
+    calc ∑ i ∈ s, f i x • (cov i) X (g • σ) x
+      _ = ∑ i ∈ s, ((g • (f i • (cov i) X σ)) x
+            + f i x • (bar (g x)) ((mfderiv% g x) (X x)) • σ x) := by
+        congr
+        ext i
+        rw [(h i).leibniz hX hσ hg]
+        simp_rw [Pi.smul_apply', smul_add]
+        dsimp
+        rw [smul_comm]
+      _ = ∑ i ∈ s, ((g • (f i • (cov i) X σ)) x)
+        + ∑ i ∈ s, f i x • (bar (g x)) ((mfderiv% g x) (X x)) • σ x := by
+        rw [Finset.sum_add_distrib]
+      _ = (g • ∑ i ∈ s, f i • (cov i) X σ) x + (bar (g x)) ((mfderiv% g x) (X x)) • σ x := by
+        -- There has to be a shorter proof!
+        simp only [Finset.smul_sum, Pi.smul_apply', Finset.sum_apply, add_right_inj]
+        set B := (bar (g x)) ((mfderiv% g x) (X x)) • σ x
+        trans (∑ i ∈ s, f i x) • B
+        · rw [Finset.sum_smul]
+        have : ∑ i ∈ s, f i x = 1 := by convert congr_fun hf x; simp
+        rw [this, one_smul]
+    simp
+
+/-- An affine combination of finitely many `C^k` connections on `u` is a `C^k` connection on `u`. -/
+lemma _root_.ContMDiffCovariantDerivativeOn.affineCombination' {n : ℕ∞}
+    [VectorBundle 𝕜 F V] {ι : Type*} {s : Finset ι} {u : Set M}
+    {cov : ι → (Π x : M, TangentSpace I x) → (Π x : M, V x) → (Π x : M, V x)}
+    (hcov : ∀ i ∈ s, ContMDiffCovariantDerivativeOn F n (cov i) u)
+    {f : ι → M → 𝕜} (hf : ∀ i ∈ s, CMDiff[u] n (f i)) :
+    ContMDiffCovariantDerivativeOn F n (fun X σ x ↦ ∑ i ∈ s, (f i x) • (cov i) X σ x) u where
+  contMDiff hσ hX :=
+    ContMDiffOn.sum_section (fun i hi ↦ (hf i hi).smul_section <| (hcov i hi).contMDiff hσ hX)
+
+variable {s : Set M}
+    {f : (Π x : M, TangentSpace I x) → (Π x : M, V x) → (Π x : M, V x)}
+
+lemma add_one_form [∀ (x : M), IsTopologicalAddGroup (V x)]
+    [∀ (x : M), ContinuousSMul 𝕜 (V x)] (hf : IsCovariantDerivativeOn F f s)
+    (A : Π x : M, TangentSpace I x →L[𝕜] V x →L[𝕜] V x) :
+    IsCovariantDerivativeOn F (fun X σ x ↦ f X σ x + A x (X x) (σ x)) s where
+  addX {_X _X' _σ} x hx hX hX' hσ := by
+    simp [hf.addX hx hX hX' hσ]
+    abel
+  smulX {_X _σ _g} x hx hX hσ hg := by
+    simp [hf.smulX hx hX hσ hg]
+  addσ {_X _σ _σ' _x} hX hσ hσ' hx := by
+    simp [hf.addσ hX hσ hσ']
+    abel
+  smul_const_σ {_X _σ _x} a hX hσ hx := by simp [hf.smul_const_σ a hX hσ]
+  leibniz {X σ g x} hX hσ hg hx := by
+    simp [hf.leibniz hX hσ hg]
+    module
+
+end operations
+
+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)
+      -- TODO: mfderiv% does not work here; `s` is a section into the trivial bundle
+      (fun X s x ↦ mfderiv I 𝓘(𝕜, F) s x (X x)) univ where
+  addX {_X _X' _σ} x _ hX hX' hσ := by simp
+  smulX {_X _σ} c' x _ := by simp
+  addσ {_X σ σ' x} hX hσ hσ' hx := by
+    rw [mdifferentiableAt_section] at hσ hσ'
+    -- TODO: specialize mdifferentiableAt_section to trivial bundles?
+    change MDifferentiableAt I 𝓘(𝕜, F) σ x at hσ
+    change MDifferentiableAt I 𝓘(𝕜, F) σ' x at hσ'
+    rw [mfderiv_add hσ hσ']
+    rfl
+  smul_const_σ {_X _σ _x} a hX hσ hx := by rw [mfderiv_const_smul]
+  leibniz {X σ f x} hX hσ hf hx := by
+    rw [mdifferentiableAt_section] at hσ
+    exact mfderiv_smul hσ hf (X x)
+
+lemma of_endomorphism (A : (x : M) → TangentSpace I x →L[𝕜] F →L[𝕜] F) :
+    IsCovariantDerivativeOn F
+      (fun (X : Π x : M, TangentSpace I x) (s : M → F) x ↦
+        letI d : F := mfderiv% s x (X x)
+        d + A x (X x) (s x)) univ :=
+  trivial I M F |>.add_one_form A
+
+end trivial_bundle
+
+end IsCovariantDerivativeOn
+
+/-! Bundled global covariant derivatives -/
+
+variable (I F V) in
+@[ext]
+structure CovariantDerivative [IsManifold I 1 M] where
+  toFun : (Π x : M, TangentSpace I x) → (Π x : M, V x) → (Π x : M, V x)
+  isCovariantDerivativeOn : IsCovariantDerivativeOn F toFun Set.univ
+
+namespace CovariantDerivative
+
+attribute [coe] toFun
+
+variable [IsManifold I 1 M]
+
+/-- Coercion of a `CovariantDerivative` to function -/
+instance : CoeFun (CovariantDerivative I F V)
+    fun _ ↦ (Π x : M, TangentSpace I x) → (Π x : M, V x) → (Π x : M, V x) :=
+  ⟨fun e ↦ e.toFun⟩
+
+instance (cov : CovariantDerivative I F V) {s : Set M} :
+    IsCovariantDerivativeOn F cov s := by
+  apply cov.isCovariantDerivativeOn.mono (fun ⦃a⦄ a ↦ trivial)
+
+/-- If `f : Vec(M) × Γ(E) → Vec(M)` 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}
+    {f : (Π x : M, TangentSpace I x) → (Π x : M, V x) → (Π x : M, V x)}
+    (hf : ∀ i, IsCovariantDerivativeOn F f (s i)) (hs : ⋃ i, s i = Set.univ) :
+    CovariantDerivative I F V :=
+  ⟨f, hs ▸ IsCovariantDerivativeOn.iUnion hf⟩
+
+@[simp]
+lemma of_isCovariantDerivativeOn_of_open_cover_coe {ι : Type*} {s : ι → Set M}
+    {f : (Π x : M, TangentSpace I x) → (Π x : M, V x) → (Π x : M, V x)}
+    (hf : ∀ i, IsCovariantDerivativeOn F f (s i)) (hs : ⋃ i, s i = Set.univ) :
+    of_isCovariantDerivativeOn_of_open_cover hf hs = f := rfl
+
+
+/--
+A covariant derivative ∇ is called of class `C^k` iff,
+whenever `X` is a `C^k` section and `σ` a `C^{k+1}` section, the result `∇ X σ` is a `C^k` section.
+This is a class so typeclass inference can deduce this automatically.
+-/
+class ContMDiffCovariantDerivative (cov : CovariantDerivative I F V) (k : ℕ∞) where
+  contMDiff : ContMDiffCovariantDerivativeOn F k cov.toFun Set.univ
+
+@[simp]
+lemma contMDiffCovariantDerivativeOn_univ_iff {cov : CovariantDerivative I F V} {k : ℕ∞} :
+    ContMDiffCovariantDerivativeOn F k cov.toFun Set.univ ↔ ContMDiffCovariantDerivative cov k :=
+  ⟨fun h ↦ ⟨h⟩, fun h ↦ h.contMDiff⟩
+
+-- future: if g is a C^k metric on a manifold M, the corresponding Levi-Civita connection
+-- is of class C^k (up to off-by-one errors)
+
+section computational_properties
+
+@[simp]
+lemma zeroX (cov : CovariantDerivative I F V) {σ : Π x : M, V x} (hσ : MDiff (T% σ)) :
+    cov 0 σ = 0 := by
+  ext x
+  exact cov.isCovariantDerivativeOn.zeroX (by trivial) (hσ x)
+
+@[simp]
+lemma zeroσ [VectorBundle 𝕜 F V] (cov : CovariantDerivative I F V)
+    {X : Π x : M, TangentSpace I x} (hX : MDiff (T% X)) : cov X 0 = 0 := by
+  ext x
+  exact cov.isCovariantDerivativeOn.zeroσ (hX x)
+
+lemma sum_X (cov : CovariantDerivative I F V)
+    {ι : Type*} {s : Finset ι} {X : ι → Π x : M, TangentSpace I x} {σ : Π x : M, V x}
+    (hX : ∀ i, MDiff (T% (X i))) (hσ : MDiff (T% σ)):
+    cov (∑ i ∈ s, X i) σ = ∑ i ∈ s, cov (X i) σ := by
+  ext x
+  simpa using cov.isCovariantDerivativeOn.sum_X trivial (fun i ↦ hX i x) (hσ x)
+
+end computational_properties
+
+section operations
+
+/-- An affine combination of covariant derivatives is a covariant derivative. -/
+@[simps]
+def affineCombination (cov cov' : CovariantDerivative I F V) (g : M → 𝕜) :
+    CovariantDerivative I F V where
+  toFun := fun X σ ↦ (g • (cov X σ)) + (1 - g) • (cov' X σ)
+  isCovariantDerivativeOn :=
+    cov.isCovariantDerivativeOn.affineCombination cov'.isCovariantDerivativeOn _
+
+/-- A finite affine combination of covariant derivatives is a covariant derivative. -/
+def affineCombination' {ι : Type*} {s : Finset ι} [Nonempty s]
+    (cov : ι → CovariantDerivative I F V) {f : ι → M → 𝕜} (hf : ∑ i ∈ s, f i = 1) :
+    CovariantDerivative I F V where
+  toFun X t x := ∑ i ∈ s, (f i x) • (cov i) X t x
+  isCovariantDerivativeOn := IsCovariantDerivativeOn.affineCombination'
+    (fun i ↦ (cov i).isCovariantDerivativeOn) hf
+
+/-- An affine combination of two `C^k` connections is a `C^k` connection. -/
+lemma ContMDiffCovariantDerivative.affineCombination [VectorBundle 𝕜 F V]
+  (cov cov' : CovariantDerivative I F V)
+    {f : M → 𝕜} {n : ℕ∞} (hf : ContMDiff I 𝓘(𝕜) n f)
+    (hcov : ContMDiffCovariantDerivative cov n) (hcov' : ContMDiffCovariantDerivative cov' n) :
+    ContMDiffCovariantDerivative (affineCombination cov cov' f) n where
+  contMDiff :=
+    ContMDiffCovariantDerivativeOn.affineCombination hf.contMDiffOn hcov.contMDiff hcov'.contMDiff
+
+/-- An affine combination of finitely many `C^k` connections is a `C^k` connection. -/
+lemma ContMDiffCovariantDerivative.affineCombination' [VectorBundle 𝕜 F V]
+    {ι : Type*} {s : Finset ι} [Nonempty s]
+    (cov : ι → CovariantDerivative I F V) {f : ι → M → 𝕜} (hf : ∑ i ∈ s, f i = 1) {n : ℕ∞}
+    (hf' : ∀ i ∈ s, ContMDiff I 𝓘(𝕜) n (f i))
+    (hcov : ∀ i ∈ s, ContMDiffCovariantDerivative (cov i) n) :
+    ContMDiffCovariantDerivative (affineCombination' cov hf) n where
+  contMDiff :=
+    ContMDiffCovariantDerivativeOn.affineCombination'
+      (fun i hi ↦ (hcov i hi).contMDiff) (fun i hi ↦ (hf' i hi).contMDiffOn)
+
+-- Future: prove a version with a locally finite sum, and deduce that C^k connections always
+-- exist (using a partition of unity argument)
+
+end operations
+
+section trivial_bundle
+
+set_option backward.isDefEq.respectTransparency false in
+variable (I M F) in
+@[simps]
+noncomputable def trivial [IsManifold I 1 M] : CovariantDerivative I F (Trivial M F) where
+  toFun X s x := mfderiv I 𝓘(𝕜, F) s x (X x)
+  isCovariantDerivativeOn := -- TODO use previous work
+  { addX {_X _X' _σ} x _ hX hX' hσ := by simp
+    smulX {_X _σ} c' x _ := by simp
+    addσ {_X σ σ' x} hX hσ hσ' hx := by
+      rw [mdifferentiableAt_section] at hσ hσ'
+      -- TODO: specialize mdifferentiableAt_section to trivial bundles?
+      change MDifferentiableAt I 𝓘(𝕜, F) σ x at hσ
+      change MDifferentiableAt I 𝓘(𝕜, F) σ' x at hσ'
+      rw [mfderiv_add hσ hσ']
+      rfl
+    smul_const_σ {_X _σ _x} a hX hσ hx := by rw [mfderiv_const_smul]
+    leibniz {X σ f x} hX hσ hf hx := by
+      rw [mdifferentiableAt_section] at hσ
+      exact mfderiv_smul hσ hf (X x) }
+
+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 -- {X σ} hX hσ
+    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 X σ := fun x ↦ fderiv 𝕜 σ x (X x) + A x (X x) (σ x)
+  isCovariantDerivativeOn := by
+    convert IsCovariantDerivativeOn.of_endomorphism (I := 𝓘(𝕜, E)) A
+    ext f x v
+    rw [mfderiv_eq_fderiv]
+end CovariantDerivative
+end any_field
+
+section real
+
+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
+
+/-- `cov X σ x` only depends on `X` via `X x` -/
+lemma congr_X_at [FiniteDimensional ℝ E] [T2Space M] [IsManifold I ∞ M] [VectorBundle ℝ F V]
+    {cov : (Π x : M, TangentSpace I x) → (Π x : M, V x) → (Π x : M, V x)}
+    {u : Set M} (hcov : IsCovariantDerivativeOn F cov u)
+    {X X' : Π x : M, TangentSpace I x}
+    {σ : Π x : M, V x} {x : M}
+    (hX : MDiffAt (T% X) x) (hX' : MDiffAt (T% X') x)
+    (hσ : MDiffAt (T% σ) x)
+    (hx : x ∈ u) (hXX' : X x = X' x) :
+    cov X σ x = cov X' σ x := by
+  refine tensoriality_criterion I E (TangentSpace I) (φ := fun X ↦ cov X σ)  F V hX hX' hXX' ?_ ?_
+  · intro f X hf hX
+    exact hcov.smulX hX hσ hf hx
+  · intro X X' hX hX'
+    exact hcov.addX hX hX' hσ hx
+
+lemma congr_σ_smoothBumpFunction [T2Space M] [IsManifold I ∞ M]
+    [FiniteDimensional ℝ E]
+    {cov : (Π x : M, TangentSpace I x) → (Π x : M, V x) → (Π x : M, V x)}
+    {u : Set M} (hcov : IsCovariantDerivativeOn F cov u)
+    (X : Π x : M, TangentSpace I x) {σ : Π x : M, V x}
+    (hX : MDiffAt (T% X) x)
+    (hσ : MDiffAt (T% σ) x)
+    (f : SmoothBumpFunction I x)
+    (hx : x ∈ u) :
+    cov X ((f : M → ℝ) • σ) x = cov X σ x := by
+  have hf : MDiffAt f x := f.contMDiffAt.mdifferentiableAt (by simp)
+  have := hcov.leibniz hX hσ hf hx
+  rw [hcov.leibniz hX hσ _ hx]
+  swap; · apply f.contMDiff.mdifferentiable (by norm_num)
+  calc _
+    _ = cov X σ x + 0 := ?_
+    _ = cov X σ x := by rw [add_zero]
+  suffices mfderiv% (1 : M → ℝ) x (X x) = 0 ∨ σ x = 0 by
+    simpa [f.eq_one, f.eventuallyEq_one.mfderiv_eq]
+  rw [show mfderiv I 𝓘(ℝ) 1 x = 0 by apply mfderiv_const]
+  left
+  rfl
+
+lemma congr_σ_of_eqOn [FiniteDimensional ℝ E] [T2Space M] [IsManifold I ∞ M] [VectorBundle ℝ F V]
+    {cov : (Π x : M, TangentSpace I x) → (Π x : M, V x) → (Π x : M, V x)}
+    {s : Set M} (hcov : IsCovariantDerivativeOn F cov s)
+    {X : Π x : M, TangentSpace I x} {σ σ' : Π x : M, V x}
+    (hX : MDiffAt (T% X) x)
+    (hσ : MDiffAt (T% σ) x)
+    (hσ' : MDiffAt (T% σ') x)
+    (hxs : s ∈ 𝓝 x)
+    (hσσ' : ∀ x ∈ s, σ x = σ' x) :
+    cov X σ x = cov X σ' x := by
+  -- Choose a smooth bump function ψ with support around `x` contained in `s`
+  obtain ⟨ψ, _, hψ⟩ := (SmoothBumpFunction.nhds_basis_support (I := I) hxs).mem_iff.1 hxs
+  -- Observe that `ψ • σ = ψ • σ'` as dependent functions.
+  have (x : M) : ((ψ : M → ℝ) • σ) x = ((ψ : M → ℝ) • σ') x := by
+    by_cases h : x ∈ s
+    · simp [hσσ' x h]
+    · simp [Function.notMem_support.mp fun a ↦ h (hψ a)]
+  -- Then, it's a chain of (dependent) equalities.
+  calc cov X σ x
+    _ = cov X ((ψ : M → ℝ) • σ) x := by
+          rw [hcov.congr_σ_smoothBumpFunction X hX hσ ψ (mem_of_mem_nhds hxs)]
+    _ = cov X ((ψ : M → ℝ) • σ') x := by rw [funext this]
+    _ = cov X σ' x := by
+          rw [hcov.congr_σ_smoothBumpFunction X hX hσ' ψ (mem_of_mem_nhds hxs)]
+
+-- TODO: prove that `cov X σ x` depends on σ only via σ(X) and the 1-jet of σ at x
+-- this should be easy using the projection formula below.
+
+/-- The difference of two covariant derivatives, as a function `Γ(TM) × Γ(E) → Γ(E)`.
+Future lemmas will upgrade this to a map `TM ⊕ E → E`. -/
+def differenceAux (cov cov' : (Π x : M, TangentSpace I x) → (Π x : M, V x) → (Π x : M, V x)) :
+    (Π x : M, TangentSpace I x) → (Π x : M, V x) → (Π x : M, V x) :=
+  fun X σ ↦ cov X σ - cov' X σ
+
+omit [(x : M) → Module ℝ (V x)] [(x : M) → TopologicalSpace (V x)] in
+@[simp]
+lemma differenceAux_apply
+    (cov cov' : (Π x : M, TangentSpace I x) → (Π x : M, V x) → (Π x : M, V x))
+    (X : Π x : M, TangentSpace I x) (σ : Π x : M, V x) :
+    differenceAux cov cov' X σ = cov X σ - cov' X σ := rfl
+
+variable [IsManifold I 1 M]
+
+lemma differenceAux_smul_eq
+    {cov cov' : (Π x : M, TangentSpace I x) → (Π x : M, V x) → (Π x : M, V x)}
+    {u : Set M} (hcov : IsCovariantDerivativeOn F cov u)
+    (hcov' : IsCovariantDerivativeOn F cov' u)
+    {X : Π x : M, TangentSpace I x} (σ : Π x : M, V x) (f : M → ℝ)
+    {x : M} (hx : x ∈ u := by trivial)
+    (hX : MDiffAt (T% X) x)
+    (hσ : MDiffAt (T% σ) x)
+    (hf : MDiffAt f x) :
+    differenceAux cov cov' X ((f : M → ℝ) • σ) x = f x • differenceAux cov cov' X σ x:=
+  calc _
+    _ = cov X ((f : M → ℝ) • σ) x - cov' X ((f : M → ℝ) • σ) x := rfl
+    _ = (f x • cov X σ x +  ((bar _).toFun <| mfderiv% f x (X x)) • σ x)
+        - (f x • cov' X σ x +  ((bar _).toFun <| mfderiv% f x (X x)) • σ x) := by
+      simp [hcov.leibniz hX hσ hf, hcov'.leibniz hX hσ hf]
+    _ = f x • cov X σ x - f x • cov' X σ x := by simp
+    _ = f x • (cov X σ x - cov' X σ x) := by simp [smul_sub]
+    _ = _ := rfl
+
+lemma differenceAux_smul_eq'
+    {cov cov' : (Π x : M, TangentSpace I x) → (Π x : M, V x) → (Π x : M, V x)}
+    {u : Set M} (hcov : IsCovariantDerivativeOn F cov u)
+    (hcov' : IsCovariantDerivativeOn F cov' u)
+    {X : Π x : M, TangentSpace I x}
+    (hX : MDiffAt (T% X) x)
+    {σ : Π x : M, V x} (hσ : MDiffAt (T% σ) x)
+    {f : M → ℝ} (hf : MDiffAt f x)
+    (hx : x ∈ u := by trivial) :
+    differenceAux cov cov' (f • X) σ x = f x • differenceAux cov cov' X σ x := by
+  simp [differenceAux, hcov.smulX hX hσ hf, hcov'.smulX hX hσ hf, smul_sub]
+
+/-- The value of `differenceAux cov cov' X σ` at `x₀` depends only on `X x₀` and `σ x₀`. -/
+lemma differenceAux_tensorial
+    {cov cov' : (Π x : M, TangentSpace I x) → (Π x : M, V x) → (Π x : M, V x)}
+    {u : Set M} (hcov : IsCovariantDerivativeOn F cov u)
+    (hcov' : IsCovariantDerivativeOn F cov' u)
+    [T2Space M] [IsManifold I ∞ M] [FiniteDimensional ℝ E]
+    [FiniteDimensional ℝ F] [VectorBundle ℝ F V] [ContMDiffVectorBundle 1 F V I]
+    {X X' : Π x : M, TangentSpace I x} {σ σ' : Π x : M, V x} {x₀ : M}
+    (hX : MDiffAt (T% X) x₀) -- TODO: is this hypotheses truly necessary?
+    (hX' : MDiffAt (T% X') x₀)
+    (hσ : MDiffAt (T% σ) x₀)
+    (hσ' : MDiffAt (T% σ') x₀)
+    (hXX' : X x₀ = X' x₀) (hσσ' : σ x₀ = σ' x₀) (hx : x₀ ∈ u := by trivial) :
+    differenceAux cov cov' X σ x₀ = differenceAux cov cov' X' σ' x₀ := by
+  trans differenceAux cov cov' X' σ x₀
+  · let φ : (Π x : M, TangentSpace I x) → (Π x, V x) := fun X ↦ differenceAux cov cov' X σ
+    change φ X x₀ = φ X' x₀
+    -- TODO: is there a version of `tensoriality_criterion` which does not require `hX`?
+    apply tensoriality_criterion (E := E) (I := I) E (TangentSpace I) F V hX hX' hXX'
+    · intro f X hf hX
+      exact hcov.differenceAux_smul_eq' hcov' hX hσ hf
+    · intro X X' hX hX'
+      unfold φ differenceAux
+      simp only [Pi.sub_apply, hcov.addX hX hX' hσ, hcov'.addX hX hX' hσ]
+      abel
+  · let φ : (Π x : M, V x) → (Π x, V x) := fun σ ↦ differenceAux cov cov' X' σ
+    change φ σ x₀ = φ σ' x₀
+    apply tensoriality_criterion (E := E) (I := I) F V F V hσ hσ' hσσ'
+    · intro f σ x hf
+      exact hcov.differenceAux_smul_eq hcov' σ f hx hX' hf x
+    · intro σ σ' hσ hσ'
+      unfold φ differenceAux
+      simp only [Pi.sub_apply]
+      rw [hcov.addσ, hcov'.addσ] <;> try assumption
+      abel
+
+lemma isBilinearMap_differenceAux
+    [FiniteDimensional ℝ F] [T2Space M] [FiniteDimensional ℝ E] [IsManifold I ∞ M]
+    [VectorBundle ℝ F V] [ContMDiffVectorBundle ∞ F V I] {s : Set M} {cov cov'} {x : M}
+    (hcov : IsCovariantDerivativeOn F cov s)
+    (hcov' : IsCovariantDerivativeOn F cov' s) (hx : x ∈ s := by trivial) :
+    IsBilinearMap ℝ (fun (X₀ : TangentSpace I x) (σ₀ : V x) ↦
+      differenceAux cov cov' (extend I E X₀) (extend I F σ₀) x) where
+  add_left u v w := by
+    simp only [differenceAux, extend_add, Pi.sub_apply]
+    rw [hcov.addX, hcov'.addX]; · abel
+    all_goals apply mdifferentiable_extend
+  add_right u v w := by
+    simp only [differenceAux, extend_add, Pi.sub_apply]
+    rw [hcov.addσ, hcov'.addσ]; · abel
+    all_goals apply mdifferentiable_extend
+  smul_left a u v := by
+    simp only [differenceAux, extend_smul, Pi.sub_apply]
+    rw [hcov.smul_const_X, hcov'.smul_const_X]; · module
+    all_goals apply mdifferentiable_extend
+  smul_right a u v := by
+    simp only [differenceAux, extend_smul, Pi.sub_apply]
+    rw [hcov.smul_const_σ, hcov'.smul_const_σ]; · module
+    all_goals apply mdifferentiable_extend
+
+variable [∀ x, IsTopologicalAddGroup (V x)] [∀ x, ContinuousSMul ℝ (V x)]
+
+/-- The difference of two covariant derivatives, as a tensorial map -/
+noncomputable def difference [∀ x, FiniteDimensional ℝ (V x)] [∀ x, T2Space (V x)]
+    [FiniteDimensional ℝ F] [T2Space M] [FiniteDimensional ℝ E] [IsManifold I ∞ M]
+    [FiniteDimensional ℝ E] [VectorBundle ℝ F V] [ContMDiffVectorBundle ∞ F V I]
+    {cov cov' : (Π x : M, TangentSpace I x) → (Π x : M, V x) → (Π x : M, V x)}
+    {s : Set M}
+    (hcov : IsCovariantDerivativeOn F cov s)
+    (hcov' : IsCovariantDerivativeOn F cov' s)
+    (x : M) : TangentSpace I x →L[ℝ] V x →L[ℝ] V x :=
+  haveI : FiniteDimensional ℝ (TangentSpace I x) := by assumption
+  open Classical in
+  if hx : x ∈ s then (isBilinearMap_differenceAux (F := F) hcov hcov').toContinuousLinearMap
+  else 0
+
+lemma difference_def [∀ x, FiniteDimensional ℝ (V x)] [∀ x, T2Space (V x)]
+    [FiniteDimensional ℝ F] [T2Space M] [IsManifold I ∞ M] [FiniteDimensional ℝ E]
+    [VectorBundle ℝ F V] [ContMDiffVectorBundle ∞ F V I]
+    {cov cov' : (Π x : M, TangentSpace I x) → (Π x : M, V x) → (Π x : M, V x)}
+    {s : Set M} {x : M}
+    (hcov : IsCovariantDerivativeOn F cov s)
+    (hcov' : IsCovariantDerivativeOn F cov' s)
+    (hx : x ∈ s := by trivial) (X₀ : TangentSpace I x) (σ₀ : V x) :
+    difference hcov hcov' x X₀ σ₀ =
+      cov (extend I E X₀) (extend I F σ₀) x - cov' (extend I E X₀) (extend I F σ₀) x := by
+  simp only [difference, hx, reduceDIte]
+  rfl
+
+@[simp]
+lemma difference_apply [∀ x, FiniteDimensional ℝ (V x)] [∀ x, T2Space (V x)]
+    [FiniteDimensional ℝ F] [T2Space M] [IsManifold I ∞ M] [FiniteDimensional ℝ E]
+    [VectorBundle ℝ F V] [ContMDiffVectorBundle ∞ F V I]
+    {cov cov' : (Π x : M, TangentSpace I x) → (Π x : M, V x) → (Π x : M, V x)}
+    {s : Set M} {x : M}
+    (hcov : IsCovariantDerivativeOn F cov s)
+    (hcov' : IsCovariantDerivativeOn F cov' s)
+    (hx : x ∈ s := by trivial) {X : Π x, TangentSpace I x} {σ : Π x, V x}
+    (hX : MDiffAt (T% X) x) (hσ : MDiffAt (T% σ) x) :
+    difference hcov hcov' x (X x) (σ x) =
+      cov X σ x - cov' X σ x := by
+  simp only [difference, hx, reduceDIte]
+  exact hcov.differenceAux_tensorial hcov' (mdifferentiable_extend ..) hX
+    (mdifferentiable_extend ..) hσ (extend_apply_self _) (extend_apply_self _) hx
+
+-- The classification of real connections over a trivial bundle
+section classification
+
+variable [FiniteDimensional ℝ E] [FiniteDimensional ℝ F] [T2Space M] [IsManifold I ∞ 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 : (Π x : M, TangentSpace I x) → (M → F) → (M → F)}
+    {s : Set M} (hcov : IsCovariantDerivativeOn F cov s) :
+    ∃ (A : (x : M) → TangentSpace I x →L[ℝ] F →L[ℝ] F),
+    ∀ X : (x : M) → TangentSpace I x, ∀ σ : M → F, ∀ x ∈ s,
+    MDiffAt (T% X) x → MDiffAt (T% σ) x →
+    letI d : F := mfderiv% σ x (X x)
+    cov X σ x = d + A x (X x) (σ x) := by
+  use fun x ↦ hcov.difference (trivial I M F |>.mono <| subset_univ s) x
+  intro X σ x hx hX hσ
+  rw [hcov.difference_apply _ (by trivial) hX hσ]
+  module
+
+noncomputable def one_form {cov : (Π x : M, TangentSpace I x) → (M → F) → (M → F)}
+    {s : Set M} (hcov : IsCovariantDerivativeOn F cov s) :
+    Π x : M, TangentSpace I x →L[ℝ] F →L[ℝ] F :=
+  hcov.exists_one_form.choose
+
+lemma eq_one_form {cov : (Π x : M, TangentSpace I x) → (M → F) → (M → F)}
+    {s : Set M} (hcov : IsCovariantDerivativeOn F cov s)
+    {X : (x : M) → TangentSpace I x} {σ : M → F}
+    {x : M} (hX : MDiffAt (T% X) x) (hσ : MDiffAt (T% σ) x) (hx : x ∈ s := by trivial) :
+    letI d : F := mfderiv% σ x (X x)
+    cov X σ x = d + hcov.one_form x (X x) (σ x) :=
+  hcov.exists_one_form.choose_spec X σ x hx hX hσ
+
+lemma _root_.CovariantDerivative.exists_one_form
+    (cov : CovariantDerivative I F (Bundle.Trivial M F)) :
+    ∃ (A : (x : M) → TangentSpace I x →L[ℝ] F →L[ℝ] F),
+    ∀ X : (x : M) → TangentSpace I x, ∀ σ : M → F, ∀ x,
+    MDiffAt (T% X) x → MDiffAt (T% σ) x →
+    letI d : F := mfderiv% σ x (X x)
+    cov X σ x = d + A x (X x) (σ x) := by
+  simpa using cov.isCovariantDerivativeOn.exists_one_form
+
+end classification
+
+section projection_trivial_bundle
+
+variable [FiniteDimensional ℝ E] [FiniteDimensional ℝ F]
+    [T2Space M] [IsManifold I ∞ M]
+
+local notation "TM" => TangentSpace I
+
+variable {cov : (Π x : M, TangentSpace I x) → (M → F) → (M → 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 + (evalL ℝ F F f ∘L hcov.one_form x ∘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 v f := rfl
+
+lemma cov_eq_proj (hcov : IsCovariantDerivativeOn F cov s) (X : Π x : M, TM x) (σ : M → F)
+    {x : M} (hX : MDiffAt (T% X) x) (hσ : MDiffAt (T% σ) x) (hx : x ∈ s := by trivial) :
+    cov X σ x = hcov.projection x (σ x) (X x, mfderiv% σ x (X x)) := by
+  simpa using hcov.eq_one_form hX hσ
+
+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 (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 ↔
+    ∃ σ : M → F, MDiffAt (T% σ) x ∧
+                 σ x = f ∧
+                 mfderiv% σ x u = v ∧
+                 cov (extend I E u) σ x = 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 [hcov.zeroX, mdifferentiableAt_section,  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''
+    · rw [hcov.eq_one_form (mdifferentiable_extend ..)]
+      · simp [w, h'', h, huv]
+      · rwa [mdifferentiableAt_section]
+    · rwa [mdifferentiableAt_section]
+  · rintro ⟨σ, σ_diff, rfl, rfl, covσ⟩
+    simp only [horiz, LinearMap.mem_ker, ContinuousLinearMap.coe_coe, projection_apply, ← covσ]
+    rw [hcov.eq_one_form (mdifferentiable_extend ..) σ_diff, extend_apply_self]
+
+end projection_trivial_bundle
+
+end IsCovariantDerivativeOn
+
+section to_trivialization
+
+namespace Bundle.Trivialization
+
+variable (e : Trivialization F (π F V)) [MemTrivializationAtlas e] [IsManifold I 1 M]
+
+noncomputable
+def pushCovDer
+    (cov : (Π x : M, TangentSpace I x) → (Π x : M, V x) → (Π x : M, V x)) :
+    (Π x : M, TangentSpace I x) → (M → F) → (M → F) :=
+  fun X σ x ↦ e (cov X (fun x' ↦ e.symm x' <| σ x') x) |>.2
+
+omit [MemTrivializationAtlas e] in
+lemma pushCovDer_ofSect [FiniteDimensional ℝ E] [FiniteDimensional ℝ F]
+    [T2Space M] [IsManifold I ∞ M]
+    [VectorBundle ℝ F V] [ContMDiffVectorBundle 1 F V I]
+    {cov : (Π x : M, TangentSpace I x) → (Π x : M, V x) → (Π x : M, V x)}
+    (hcov : IsCovariantDerivativeOn F cov e.baseSet)
+    {X : Π x : M, TangentSpace I x} {σ : Π x : M, V x} {x : M}
+    (hX : MDiffAt T%X x) (hσ : MDiffAt T%σ x)
+    (hx : x ∈ e.baseSet := by assumption) :
+    (e.pushCovDer cov) X (fun x ↦ (e (σ x)).2) x = (e (cov X σ x)).2 := by
+  have : cov X (fun x' ↦ e.symm x' (e (T% σ x')).2) x = cov X σ x := by
+    apply hcov.congr_σ_of_eqOn hX _ hσ (e.baseSet_mem_nhds hx)
+    · exact fun y hy ↦ by simp [hy] --FIXME extract as lemma?
+    · rwa [(e.symm_apply_apply_mk_eventuallyEq hx σ).mdifferentiableAt_iff]
+  unfold pushCovDer
+  rw [this]
+
+
+variable {cov : (Π x : M, TangentSpace I x) → (Π x : M, V x) → (Π x : M, V x)}
+    -- {s : Set M} (hcov : IsCovariantDerivativeOn F cov s)
+
+lemma pushCovDer_isCovariantDerivativeOn
+    [VectorBundle ℝ F V] [ContMDiffVectorBundle 1 F V I]
+    {u : Set M} (hu : u ⊆ e.baseSet)
+    (hcov : IsCovariantDerivativeOn F cov u) :
+    IsCovariantDerivativeOn F (e.pushCovDer cov) u where
+  addX {X X' σ x} hX hX' hσ hx := by
+    set s := (fun x' ↦ e.symm x' (σ x'))
+    have hs : MDiffAt (T% s) x :=
+      e.mdifferentiableAt_section_of_function (hu hx) <| mdifferentiableAt_section_trivial_iff.1 hσ
+    unfold pushCovDer
+    rw [hcov.addX hX hX' hs, e.map_add ℝ (hu hx)]
+  smulX {X σ g x} hX hσ hg hx := by
+    set s := (fun x' ↦ e.symm x' (σ x'))
+    have hs : MDiffAt (T% s) x :=
+      e.mdifferentiableAt_section_of_function (hu hx) <| mdifferentiableAt_section_trivial_iff.1 hσ
+    unfold pushCovDer
+    rw [hcov.smulX hX hs hg, e.map_smul (hu hx)]
+  smul_const_σ {X σ x} a hX hσ hx := by
+    set s := (fun x' ↦ e.symm x' (σ x'))
+    have hs : MDiffAt (T% s) x :=
+      e.mdifferentiableAt_section_of_function (hu hx) <| mdifferentiableAt_section_trivial_iff.1 hσ
+    unfold pushCovDer
+    rw [← e.map_smul (hu hx), ← hcov.smul_const_σ a hX hs hx]
+    congr
+    ext y
+    simp [e.symm_map_smul, s]
+  addσ {X σ σ' x} hX hσ hσ' hx := by
+    set s := (fun x' ↦ e.symm x' (σ x'))
+    have hs : MDiffAt (T% s) x :=
+      e.mdifferentiableAt_section_of_function (hu hx) <| mdifferentiableAt_section_trivial_iff.1 hσ
+    set s' := (fun x' ↦ e.symm x' (σ' x'))
+    have hs' : MDiffAt (T% s') x :=
+      e.mdifferentiableAt_section_of_function (hu hx) <| mdifferentiableAt_section_trivial_iff.1
+      hσ'
+    unfold pushCovDer
+    rw [← e.map_add ℝ (hu hx)]
+    congr
+    rw [← hcov.addσ hX hs hs' hx]
+    congr
+    ext y
+    simp [e.symm_map_add ℝ, s, s']
+  leibniz {X σ g x} hX hσ hg hx := by
+    set s := (fun x' ↦ e.symm x' (σ x'))
+    have hs : MDiffAt (T% s) x :=
+      e.mdifferentiableAt_section_of_function (hu hx) <| mdifferentiableAt_section_trivial_iff.1 hσ
+    unfold pushCovDer
+    have : (fun x' ↦ e.symm x' ((g • σ) x')) = g • s := by
+      ext y
+      simp [s, e.symm_map_smul]
+    rw [this, hcov.leibniz hX hs hg hx]
+    suffices g x • (e ⟨x, cov X s x⟩).2 + (bar (g x)) ((mfderiv% g x) (X x)) • (e ⟨x, s x⟩).2 =
+      g x • (e ⟨x, cov X (fun x' ↦ e.symm x' (σ x')) x⟩).2 +
+      (bar (g x)) ((mfderiv% g x) (X x)) • σ x by simpa [e.map_add ℝ (hu hx), e.map_smul (hu hx)]
+    congr
+    rw [e.apply_mk_symm (hu hx)]
+
+variable {e} in
+lemma coordChangeL_pushCovDer
+    [FiniteDimensional ℝ E] [T2Space M] [IsManifold I ∞ M]
+    {e' : Trivialization F (π F V)} [MemTrivializationAtlas e']
+    [VectorBundle ℝ F V] [ContMDiffVectorBundle 1 F V I]
+    (hcov : IsCovariantDerivativeOn F cov <| e.baseSet ∩ e'.baseSet)
+    {x : M} (hx : x ∈ e.baseSet ∩ e'.baseSet)
+    {X : Π x : M, TangentSpace I x} (hX : MDiffAt (T% X) x)
+    {s : M → F} (hs : MDiffAt s x) :
+    e.coordChangeL ℝ e' x (e.pushCovDer cov X s x) =
+      e'.pushCovDer cov X (fun x ↦ e.coordChangeL ℝ e' x (s x)) x := by
+  unfold pushCovDer
+  let σ := (fun x' ↦ e.symm x' (s x'))
+  rw [coordChangeL_apply e e' hx]
+  refold_let σ
+  have : e.symm x (e ⟨x, cov X σ x⟩).2 = cov X σ x := by simp [hx.1]
+  rw [this]
+  -- TODO: extract lemma?
+  have : ∀ x' ∈ e.baseSet ∩ e'.baseSet, σ x' =
+      e'.symm x' ((fun x ↦ (coordChangeL ℝ e e' x) (s x)) x') := by
+    rintro x' ⟨hx'e, hx'e'⟩
+    simp only
+    rw [coordChangeL_apply e e' ⟨hx'e, hx'e'⟩]
+    -- simp [hx'e'] -- TODO doesn’t work
+    rw [symm_apply_apply_mk e' hx'e']
+  have mem : e.baseSet ∩ e'.baseSet ∈ 𝓝 x := by
+    -- FIXME: make sure grind can do this proof
+    exact inter_mem (baseSet_mem_nhds e (mem_of_mem_inter_left hx))
+        (baseSet_mem_nhds e' (mem_of_mem_inter_right hx))
+  have hσ : MDiffAt (T% σ) x :=
+    mdifferentiableAt_section_of_function e hx.1 hs
+  rw [hcov.congr_σ_of_eqOn hX hσ ?_ mem this]
+  -- TODO have automatation doing the next three lines…
+  apply mdifferentiableAt_section_of_function e' hx.2
+  have := contMDiffAt_coordChangeL (n := 1) (IB := I) hx.1 hx.2
+  exact this.mdifferentiableAt (zero_ne_one.symm) |>.clm_apply hs
+
+variable {e} in
+lemma coordChangeL_mem_horiz
+    [FiniteDimensional ℝ E] [T2Space M] [IsManifold I ∞ M] [FiniteDimensional ℝ F]
+    {e' : Trivialization F (π F V)} [MemTrivializationAtlas e']
+    [VectorBundle ℝ F V] [ContMDiffVectorBundle 1 F V I]
+    (hcov : IsCovariantDerivativeOn F cov <| e.baseSet ∩ e'.baseSet)
+    {x : M} (hx : x ∈ e.baseSet ∩ e'.baseSet) {u : TangentSpace I x} {v w : F} :
+    haveI hcove := e.pushCovDer_isCovariantDerivativeOn inter_subset_left hcov
+    haveI hcove' := e'.pushCovDer_isCovariantDerivativeOn inter_subset_right hcov
+    (u, w) ∈ hcove.horiz x v →
+    (u, e.coordChangeL ℝ e' x w) ∈ hcove'.horiz x (e.coordChangeL ℝ e' x v) := by
+  have hcove := e.pushCovDer_isCovariantDerivativeOn inter_subset_left hcov
+  have hcove' := e'.pushCovDer_isCovariantDerivativeOn inter_subset_right hcov
+  rw [hcove.mem_horiz_iff_exists, hcove'.mem_horiz_iff_exists]
+  rintro ⟨s, sdiff, sxv, sxuw, covs⟩
+  use fun x ↦ e.coordChangeL ℝ e' x (s x), ?_, ?_, ?_
+  · let X := extend I E u
+    have hX : MDiffAt (T% X) x := by
+      -- TODO: extract as lemma?
+      exact (mdifferentiable_extend I E u).mdifferentiableAt
+    -- TODO: investigate whether the following line comes from inconsistent ways to
+    -- state assumptions
+    rw [mdifferentiableAt_section_trivial_iff] at sdiff
+    rw [← e.coordChangeL_pushCovDer hcov hx hX sdiff, covs]
+    simp
+  · sorry
+  · congr
+  · rw [← sxuw]
+    sorry
+
+-- This is PAIIIIINNNN
+variable {e} in
+lemma coordChangeL_coordChangeL
+    [VectorBundle ℝ F V]
+    {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
+
+variable {e} in
+lemma coordChangeL_mem_horiz_iff
+    [FiniteDimensional ℝ E] [T2Space M] [IsManifold I ∞ M] [FiniteDimensional ℝ F]
+    {e' : Trivialization F (π F V)} [MemTrivializationAtlas e']
+    [VectorBundle ℝ F V] [ContMDiffVectorBundle 1 F V I]
+    (hcov : IsCovariantDerivativeOn F cov <| e.baseSet ∩ e'.baseSet)
+    {x : M} (hx : x ∈ e.baseSet ∩ e'.baseSet) {u : TangentSpace I x} {v w : F} :
+    haveI hcove := e.pushCovDer_isCovariantDerivativeOn inter_subset_left hcov
+    haveI hcove' := e'.pushCovDer_isCovariantDerivativeOn inter_subset_right hcov
+    (u, w) ∈ hcove.horiz x v ↔
+    (u, e.coordChangeL ℝ e' x w) ∈ hcove'.horiz x (e.coordChangeL ℝ e' x v) := by
+  refine ⟨e.coordChangeL_mem_horiz hcov hx, fun hu ↦ ?_⟩
+  let v' := e.coordChangeL ℝ e' x v
+  let w' := e.coordChangeL ℝ e' x w
+  rw [inter_comm] at hx hcov
+  have hx' := inter_comm _ _ ▸ hx
+  have hvv' : v = e'.coordChangeL ℝ e x v' := (coordChangeL_coordChangeL hx' v).symm
+  have hww' : w = e'.coordChangeL ℝ e x w' := (coordChangeL_coordChangeL hx' w).symm
+  have key := e'.coordChangeL_mem_horiz hcov hx (w := w') (u := u) (v := v') ?_
+  · rw [← hvv', ← hww'] at key
+    convert key using 2
+    apply inter_comm
+  · convert hu using 2
+    apply inter_comm
+
+end Bundle.Trivialization
+
+end to_trivialization
+
+section horiz
+namespace CovariantDerivative
+
+variable [FiniteDimensional ℝ E] [FiniteDimensional ℝ F]
+    [T2Space M] [IsManifold I ∞ M]
+    [VectorBundle ℝ F V] [ContMDiffVectorBundle 1 F V I]
+
+local notation "TM" => TangentSpace I
+
+-- FIXME the statement of CovariantDerivative.isCovariantDerivativeOn should work on any set
+
+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.mono fun _ _ ↦ mem_univ _)
+  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 ℝ E] [FiniteDimensional ℝ F] [T2Space 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 [IsManifold I 1 M]
+variable {cov : CovariantDerivative I F V}
+
+set_option backward.isDefEq.respectTransparency false in
+omit [ContMDiffVectorBundle 1 F V I] in
+lemma proj_mderiv [ContMDiffVectorBundle 1 F V I]
+    {X : Π x : M, TangentSpace I x} {σ : Π x : M, V x} (x : M)
+    (hX : MDiffAt (T% X) x)
+    (hσ : MDiffAt (T% σ) x) :
+    cov X σ x = cov.proj (σ x) (mfderiv% (T% σ) x (X x)) := by
+  let t := trivializationAt F V x
+  let s := fun x ↦ (t (σ x)).2
+  let Tσx := mfderiv% (T% σ) x
+  -- FIXME `mfderiv%` fails on the next line
+  let Ttσx := mfderiv (I.prod 𝓘(ℝ, F)) (I.prod 𝓘(ℝ, F)) t (σ x)
+  change cov X σ x = (cov.proj (T% σ x)) ((mfderiv% (T% σ) x) (X x))
+  have hcov := cov.isCovariantDerivativeOn_pushCovDer t
+  have hx := mem_baseSet_trivializationAt F V x
+  have hs : MDiffAt (T% s) x := by
+    rw [t.mdifferentiableAt_section_iff I σ hx] at hσ
+    exact (mdifferentiableAt_section I s).mpr hσ
+  apply t.eq_of hx
+  erw  [cov.snd_triv_proj (T% σ x),
+       ← t.pushCovDer_ofSect (cov.isCovariantDerivativeOn.mono fun _ _ ↦ mem_univ _) hX hσ,
+       hcov.cov_eq_proj X s hX hs, t.mfderiv_comp_section hσ _ hx]
+
+end CovariantDerivative
+end horiz
+
+end real
+
+-- 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_const_σ X σ 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 }
diff --git a/Mathlib/Geometry/Manifold/VectorBundle/CovariantDerivative/LeviCivita.lean b/Mathlib/Geometry/Manifold/VectorBundle/CovariantDerivative/LeviCivita.lean
new file mode 100644
index 00000000000000..925230013ea061
--- /dev/null
+++ b/Mathlib/Geometry/Manifold/VectorBundle/CovariantDerivative/LeviCivita.lean
@@ -0,0 +1,1188 @@
+/-
+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.CovariantDerivative.Torsion
+public import Mathlib.Geometry.Manifold.VectorBundle.OrthonormalFrame
+public import Mathlib.Geometry.Manifold.VectorBundle.Tangent
+public import Mathlib.Geometry.Manifold.VectorBundle.Riemannian
+public import Mathlib.Util.PrintSorries
+
+/-!
+# The Levi-Civita connection
+
+This file will define the Levi-Civita connection on any Riemannian manifold.
+Details to be written!
+
+TODO: refactor this file, to make Levi-Civita take a Riemannian metric instead!
+
+
+TODO: more generally, define a notion of metric connections (e.g., those whose parallel transport
+is an isometry) and prove the Levi-Civita connection is a metric connection
+
+-/
+
+open Bundle Filter Function Module Topology
+
+open scoped Bundle Manifold ContDiff
+
+@[expose] public section -- TODO: think if we want to expose all definitions!
+
+-- TODO: investigate the need for this option, once the dust has settled and we are happy with
+-- how this file has been refactored
+set_option backward.isDefEq.respectTransparency false
+
+-- Let M be a C^k real manifold modeled on (E, H), endowed with a Riemannian metric.
+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 ∞ M]
+  [RiemannianBundle (fun (x : M) ↦ TangentSpace I x)]
+  -- don't need this assumption (yet?)
+  -- [IsRiemannianManifold I M]
+
+variable {E' : Type*} [NormedAddCommGroup E'] [NormedSpace ℝ E']
+
+/-! Compatible connections: a connection on TM is compatible with the metric on M iff
+`∇ X ⟨Y, Z⟩ = ⟨∇ X Y, Z⟩ + ⟨Y, ∇ X Z⟩` holds for all vector fields X, Y and Z on `M`.
+The left hand side is the pushforward of the function `⟨Y, Z⟩` along the vector field `X`:
+the left hand side at `X` is `df(X x)`, where `f := ⟨Y, Z⟩`. -/
+
+variable {X X' X'' Y Y' Y'' Z Z' : Π x : M, TangentSpace I x}
+
+/-- The scalar product of two vector fields -/
+noncomputable abbrev product (X Y : Π x : M, TangentSpace I x) : M → ℝ :=
+  fun x ↦ inner ℝ (X x) (Y x)
+-- Riemannian.lean shows that `product` is C^k if X and Y are
+
+local notation "⟪" X ", " Y "⟫" => product I X Y
+
+-- Basic API for the product of two vector fields.
+section product
+
+omit [IsManifold I ∞ M]
+
+lemma product_apply (x) : ⟪X, Y⟫ x = inner ℝ (X x) (Y x) := rfl
+
+variable (X Y) in
+lemma product_swap : ⟪Y, X⟫ = ⟪X, Y⟫ := by
+  ext x
+  apply real_inner_comm
+
+variable (X) in
+@[simp]
+lemma product_zero_left : ⟪0, X⟫ = 0 := by
+  ext x
+  simp [product]
+
+@[simp]
+lemma product_zero_right : ⟪X, 0⟫ = 0 := by rw [product_swap, product_zero_left]
+
+variable (X X' Y) in
+lemma product_add_left : ⟪X + X', Y⟫ = ⟪X, Y⟫ + ⟪X', Y⟫ := by
+  ext x
+  simp [product, InnerProductSpace.add_left]
+
+variable (X X' Y) in
+@[simp]
+lemma product_add_left_apply (x) : ⟪X + X', Y⟫ x = ⟪X, Y⟫ x + ⟪X', Y⟫ x := by
+  simp [product, InnerProductSpace.add_left]
+
+variable (X Y Y') in
+lemma product_add_right : ⟪X, Y + Y'⟫ = ⟪X, Y⟫ + ⟪X, Y'⟫ := by
+  rw [product_swap, product_swap _ Y, product_swap _ Y', product_add_left]
+
+variable (X X' Y) in
+@[simp]
+lemma product_add_right_apply (x) : ⟪X, Y + Y'⟫ x = ⟪X, Y⟫ x + ⟪X, Y'⟫ x := by
+  rw [product_swap, product_swap _ Y, product_swap _ Y', product_add_left_apply]
+
+variable (X Y) in
+@[simp] lemma product_neg_left : ⟪-X, Y⟫ = -⟪X, Y⟫ := by ext x; simp [product]
+
+variable (X Y) in
+@[simp] lemma product_neg_right : ⟪X, -Y⟫ = -⟪X, Y⟫ := by ext x; simp [product]
+
+variable (X X' Y) in
+lemma product_sub_left : ⟪X - X', Y⟫ = ⟪X, Y⟫ - ⟪X', Y⟫ := by
+  ext x
+  simp [product, inner_sub_left]
+
+variable (X Y Y') in
+lemma product_sub_right : ⟪X, Y - Y'⟫ = ⟪X, Y⟫ - ⟪X, Y'⟫ := by
+  ext x
+  simp [product, inner_sub_right]
+
+variable (X Y) in
+lemma product_smul_left (f : M → ℝ) : product I (f • X) Y = f • product I X Y := by
+  ext x
+  simp [product, real_inner_smul_left]
+
+variable (X Y) in
+@[simp]
+lemma product_smul_const_left (a : ℝ) : product I (a • X) Y = a • product I X Y := by
+  ext x
+  simp [product, real_inner_smul_left]
+
+variable (X Y) in
+lemma product_smul_right (f : M → ℝ) : product I X (f • Y) = f • product I X Y := by
+  ext x
+  simp [product, real_inner_smul_right]
+
+variable (X Y) in
+@[simp]
+lemma product_smul_const_right (a : ℝ) : product I X (a • Y) = a • product I X Y := by
+  ext x
+  simp [product, real_inner_smul_right]
+
+end product
+
+-- These lemmas are necessary as my Lie bracket identities (assuming minimal differentiability)
+-- only hold point-wise. They abstract the expanding and unexpanding of `product`.
+omit [IsManifold I ∞ M] in
+lemma product_congr_left {x} (h : X x = X' x) : product I X Y x = product I X' Y x := by
+  rw [product_apply, h, ← product_apply]
+
+omit [IsManifold I ∞ M] in
+lemma product_congr_left₂ {x} (h : X x = X' x + X'' x) :
+    product I X Y x = product I X' Y x + product I X'' Y x := by
+  rw [product_apply, h, inner_add_left, ← product_apply]
+omit [IsManifold I ∞ M] in
+lemma product_congr_right {x} (h : Y x = Y' x) : product I X Y x = product I X Y' x := by
+  rw [product_apply, h, ← product_apply]
+
+omit [IsManifold I ∞ M] in
+lemma product_congr_right₂ {x} (h : Y x = Y' x + Y'' x) :
+    product I X Y x = product I X Y' x + product I X Y'' x := by
+  rw [product_apply, h, inner_add_right, ← product_apply]
+
+/- XXX: writing `hY.inner_bundle hZ` or writing `by apply MDifferentiable.inner_bundle hY hZ`
+yields an error
+synthesized type class instance is not definitionally equal to expression inferred by typing rules,
+synthesized
+  fun x ↦ instNormedAddCommGroupOfRiemannianBundle x
+inferred
+  fun b ↦ inst✝⁷ -/
+-- TODO: diagnose and fix this, and replace by `MDifferentiable(At).inner_bundle!
+
+variable [IsContMDiffRiemannianBundle I 1 E (fun (x : M) ↦ TangentSpace I x)] {I} in
+lemma MDifferentiable.inner_bundle' (hY : MDiff (T% Y)) (hZ : MDiff (T% Z)) : MDiff ⟪Y, Z⟫ :=
+  MDifferentiable.inner_bundle hY hZ
+
+variable [IsContMDiffRiemannianBundle I 1 E (fun (x : M) ↦ TangentSpace I x)] {I} in
+lemma MDifferentiableAt.inner_bundle' {x} (hY : MDiffAt (T% Y) x) (hZ : MDiffAt (T% Z) x) :
+    MDiffAt ⟪Y, Z⟫ x :=
+  MDifferentiableAt.inner_bundle hY hZ
+
+namespace CovariantDerivative
+
+-- Let `cov` be a covariant derivative on `TM`.
+-- TODO: include in cheat sheet!
+variable (cov : CovariantDerivative I E (TangentSpace I : M → Type _))
+
+/-- Predicate saying for a connection `∇` on a Riemannian manifold `M`  to be compatible with the
+ambient metric, i.e. for all smooth vector fields `X`, `Y` and `Z` on `M`, we have
+`X ⟨Y, Z⟩ = ⟨∇ X Y, Z⟩ + ⟨Y, ∇ X Z⟩`. -/
+def IsCompatible : Prop :=
+  ∀ X Y Z : Π x : M, TangentSpace I x, -- XXX: missing differentiability hypotheses!
+  ∀ x : M,
+  mfderiv% ⟪Y, Z⟫ x (X x) = ⟪cov X Y, Z⟫ x + ⟪Y, cov X Z⟫ x
+
+/-- A covariant derivative on a Riemannian bundle `TM` is called the **Levi-Civita connection**
+iff it is torsion-free and compatible with `g`.
+Note that the bundle metric on `TM` is implicitly hidden in this definition. See `TODO` for a
+version depending on a choice of Riemannian metric on `M`.
+-/
+def IsLeviCivitaConnection : Prop := cov.IsCompatible ∧ cov.IsTorsionFree
+
+variable (X Y Z) in
+/-- The first term in the definition of the candidate Levi-Civita connection:
+`rhs_aux I X Y Z = X ⟨Y, Z⟩ = x ↦ d(⟨Y, Z⟩)_x (X x)`.
+
+This definition contains mild defeq abuse, which is invisible on paper:
+The function `⟨Y, Z⟩` maps `M` into `ℝ`, hence its differential at a point `x` maps `T_p M`
+to an element of the tangent space of `ℝ`. A summand `⟨Y, [X, Z]⟩`, however, yields an honest
+real number: Lean complains that these have different types.
+Fortunately, `ℝ` is defeq to its own tangent space; casting `rhs_aux` to the real numbers
+allows the addition to type-check. -/
+noncomputable abbrev rhs_aux : M → ℝ := fun x ↦ (mfderiv% ⟪Y, Z⟫ x (X x))
+
+section rhs_aux
+
+variable (Y Z) in
+omit [IsManifold I ∞ M] in
+lemma rhs_aux_swap : rhs_aux I X Y Z = rhs_aux I X Z Y := by
+  ext x
+  simp only [rhs_aux]
+  congr 2
+  exact product_swap I Z Y
+
+omit [IsManifold I ∞ M] in
+variable (X X' Y Z) in
+lemma rhs_aux_addX : rhs_aux I (X + X') Y Z = rhs_aux I X Y Z + rhs_aux I X' Y Z := by
+  ext x
+  simp [rhs_aux]
+
+variable [IsContMDiffRiemannianBundle I 1 E (fun (x : M) ↦ TangentSpace I x)] {x}
+
+variable (X) in
+@[simp]
+lemma rhs_aux_addY_apply (hY : MDiffAt (T% Y) x) (hY' : MDiffAt (T% Y') x) (hZ : MDiffAt (T% Z) x) :
+    rhs_aux I X (Y + Y') Z x = rhs_aux I X Y Z x + rhs_aux I X Y' Z x := by
+  simp only [rhs_aux]
+  rw [product_add_left, mfderiv_add (hY.inner_bundle' hZ) (hY'.inner_bundle' hZ)]
+  simp; congr
+
+variable (X) in
+lemma rhs_aux_addY (hY : MDiff (T% Y)) (hY' : MDiff (T% Y')) (hZ : MDiff (T% Z)) :
+    rhs_aux I X (Y + Y') Z = rhs_aux I X Y Z + rhs_aux I X Y' Z := by
+  ext x
+  exact rhs_aux_addY_apply I X (hY x) (hY' x) (hZ x)
+
+variable (X) in
+@[simp]
+lemma rhs_aux_addZ_apply (hY : MDiffAt (T% Y) x) (hZ : MDiffAt (T% Z) x) (hZ' : MDiffAt (T% Z') x) :
+  rhs_aux I X Y (Z + Z') x = rhs_aux I X Y Z x + rhs_aux I X Y Z' x := by
+  unfold rhs_aux
+  rw [product_add_right, mfderiv_add (hY.inner_bundle' hZ) (hY.inner_bundle' hZ')]; simp; congr
+
+variable (X) in
+lemma rhs_aux_addZ (hY : MDiff (T% Y)) (hZ : MDiff (T% Z)) (hZ' : MDiff (T% Z')) :
+    rhs_aux I X Y (Z + Z') = rhs_aux I X Y Z + rhs_aux I X Y Z' := by
+  ext x
+  exact rhs_aux_addZ_apply I X (hY x) (hZ x) (hZ' x)
+
+omit [IsManifold I ∞ M] in
+variable (X Y Z) in
+lemma rhs_aux_smulX_apply (f : M → ℝ) (x) : rhs_aux I (f • X) Y Z x = f x • rhs_aux I X Y Z x := by
+  simp [rhs_aux]
+
+omit [IsManifold I ∞ M] in
+variable (X Y Z) in
+lemma rhs_aux_smulX (f : M → ℝ) : rhs_aux I (f • X) Y Z = f • rhs_aux I X Y Z := by
+  ext x
+  exact rhs_aux_smulX_apply ..
+
+variable (X) in
+lemma rhs_aux_smulY_apply {f : M → ℝ}
+    (hf : MDiffAt f x) (hY : MDiffAt (T% Y) x) (hZ : MDiffAt (T% Z) x) :
+    letI A (x) : ℝ := (mfderiv% f x) (X x)
+    rhs_aux I X (f • Y) Z x = f x • rhs_aux I X Y Z x + A x • ⟪Y, Z⟫ x := by
+  rw [rhs_aux, product_smul_left, mfderiv_smul (hY.inner_bundle' hZ) hf]
+
+variable (X) in
+lemma rhs_aux_smulY {f : M → ℝ} (hf : MDiff f) (hY : MDiff (T% Y)) (hZ : MDiff (T% Z)) :
+    letI A (x) : ℝ := (mfderiv% f x) (X x)
+    rhs_aux I X (f • Y) Z = f • rhs_aux I X Y Z + A • ⟪Y, Z⟫ := by
+  ext x
+  simp [rhs_aux_smulY_apply I X (hf x) (hY x) (hZ x)]
+
+variable (X) in
+lemma rhs_aux_smulY_const_apply {a : ℝ} (hY : MDiffAt (T% Y) x) (hZ : MDiffAt (T% Z) x) :
+    rhs_aux I X (a • Y) Z x = a • rhs_aux I X Y Z x := by
+  let f : M → ℝ := fun _ ↦ a
+  have h1 : rhs_aux I X (a • Y) Z x = rhs_aux I X (f • Y) Z x := by simp only [f]; congr
+  rw [h1, rhs_aux_smulY_apply I X mdifferentiableAt_const hY hZ]
+  simp [mfderiv_const]
+
+variable (X) in
+lemma rhs_aux_smulY_const {a : ℝ} (hY : MDiff (T% Y)) (hZ : MDiff (T% Z)) :
+    rhs_aux I X (a • Y) Z = a • rhs_aux I X Y Z := by
+  ext x
+  apply rhs_aux_smulY_const_apply I X (hY x) (hZ x)
+
+variable (X) in
+lemma rhs_aux_smulZ_apply {f : M → ℝ}
+    (hf : MDiffAt f x) (hY : MDiffAt (T% Y) x) (hZ : MDiffAt (T% Z) x) :
+    letI A (x) : ℝ := (mfderiv% f x) (X x)
+    rhs_aux I X Y (f • Z) x = f x • rhs_aux I X Y Z x + A x • ⟪Y, Z⟫ x := by
+  rw [rhs_aux_swap, rhs_aux_smulY_apply, rhs_aux_swap, product_swap]
+  exacts [hf, hZ, hY]
+
+variable (X) in
+lemma rhs_aux_smulZ {f : M → ℝ} (hf : MDiff f) (hY : MDiff (T% Y)) (hZ : MDiff (T% Z)) :
+    letI A (x) : ℝ := (mfderiv% f x) (X x)
+    rhs_aux I X Y (f • Z) = f • rhs_aux I X Y Z + A • ⟪Y, Z⟫ := by
+  rw [rhs_aux_swap, rhs_aux_smulY, rhs_aux_swap, product_swap]
+  exacts [hf, hZ, hY]
+
+variable (X) in
+lemma rhs_aux_smulZ_const_apply {a : ℝ} (hY : MDiffAt (T% Y) x) (hZ : MDiffAt (T% Z) x) :
+    rhs_aux I X Y (a • Z) x = a • rhs_aux I X Y Z x := by
+  let f : M → ℝ := fun _ ↦ a
+  have h1 : rhs_aux I X Y (a • Z) x = rhs_aux I X Y (f • Z) x := by simp only [f]; congr
+  rw [h1, rhs_aux_smulZ_apply I X mdifferentiableAt_const hY hZ]
+  simp [mfderiv_const]
+
+variable (X) in
+lemma rhs_aux_smulZ_const {a : ℝ} (hY : MDiff (T% Y)) (hZ : MDiff (T% Z)) :
+    rhs_aux I X Y (a • Z) = a • rhs_aux I X Y Z := by
+  ext x
+  exact rhs_aux_smulZ_const_apply I X (hY x) (hZ x)
+
+end rhs_aux
+
+variable {x : M}
+
+variable (X Y Z) in
+/-- Auxiliary quantity used in the uniqueness proof of the Levi-Civita connection:
+If ∇ is a Levi-Civita connection on `TM`, then
+`2 ⟨∇ X Y, Z⟩ = leviCivitaRhs' I X Y Z` for all vector fields `Z`. -/
+noncomputable def leviCivitaRhs' : M → ℝ :=
+  rhs_aux I X Y Z + rhs_aux I Y Z X - rhs_aux I Z X Y
+  - ⟪Y ,(VectorField.mlieBracket I X Z)⟫
+  - ⟪Z, (VectorField.mlieBracket I Y X)⟫
+  + ⟪X, (VectorField.mlieBracket I Z Y)⟫
+
+variable (X Y Z) in
+/-- Auxiliary quantity used in the uniqueness proof of the Levi-Civita connection:
+If `∇` is a Levi-Civita connection on `TM`, then
+`⟨∇ X Y, Z⟩ = leviCivitaRhs I X Y Z` for all smooth vector fields `X`, `Y` and `Z`. -/
+noncomputable def leviCivitaRhs : M → ℝ := (1 / 2 : ℝ) • leviCivitaRhs' I X Y Z
+
+omit [IsManifold I ∞ M] in
+lemma leviCivitaRhs_apply : leviCivitaRhs I X Y Z x = (1 / 2 : ℝ) • leviCivitaRhs' I X Y Z x :=
+  rfl
+
+section leviCivitaRhs
+
+variable [IsContMDiffRiemannianBundle I 1 E (fun (x : M) ↦ TangentSpace I x)]
+
+@[simp]
+lemma leviCivitaRhs'_addX_apply [CompleteSpace E]
+    (hX : MDiffAt (T% X) x) (hX' : MDiffAt (T% X') x)
+    (hY : MDiffAt (T% Y) x) (hZ : MDiffAt (T% Z) x) :
+    leviCivitaRhs' I (X + X') Y Z x =
+      leviCivitaRhs' I X Y Z x + leviCivitaRhs' I X' Y Z x := by
+  simp only [leviCivitaRhs', rhs_aux_addX, Pi.add_apply, Pi.sub_apply]
+  -- We have to rewrite back and forth: the Lie bracket is only additive at x,
+  -- as we are only asking for differentiability at x.
+  -- Fortunately, the `product_congr_right₂` lemma abstracts this very well.
+  rw [product_congr_right₂ I (VectorField.mlieBracket_add_right (V := Y) hX hX'),
+    product_congr_right₂ I (VectorField.mlieBracket_add_left (W := Z) hX hX'),
+    product_add_left_apply, rhs_aux_addY_apply, rhs_aux_addZ_apply] <;> try assumption
+  abel
+
+lemma leviCivitaRhs'_addX [CompleteSpace E]
+    (hX : MDiff (T% X)) (hX' : MDiff (T% X')) (hY : MDiff (T% Y)) (hZ : MDiff (T% Z)) :
+    leviCivitaRhs' I (X + X') Y Z =
+      leviCivitaRhs' I X Y Z + leviCivitaRhs' I X' Y Z := by
+  ext x
+  simp [leviCivitaRhs'_addX_apply _ (hX x) (hX' x) (hY x) (hZ x)]
+
+lemma leviCivitaRhs_addX_apply [CompleteSpace E]
+    (hX : MDiffAt (T% X) x) (hX' : MDiffAt (T% X') x)
+    (hY : MDiffAt (T% Y) x) (hZ : MDiffAt (T% Z) x) :
+    leviCivitaRhs I (X + X') Y Z x = leviCivitaRhs I X Y Z x + leviCivitaRhs I X' Y Z x := by
+  simp [leviCivitaRhs, leviCivitaRhs'_addX_apply I hX hX' hY hZ, left_distrib]
+
+lemma leviCivitaRhs_addX [CompleteSpace E]
+    (hX : MDiff (T% X)) (hX' : MDiff (T% X')) (hY : MDiff (T% Y)) (hZ : MDiff (T% Z)) :
+    leviCivitaRhs I (X + X') Y Z = leviCivitaRhs I X Y Z + leviCivitaRhs I X' Y Z := by
+  ext x
+  simp [leviCivitaRhs_addX_apply _ (hX x) (hX' x) (hY x) (hZ x)]
+
+open VectorField
+
+variable {I} in
+lemma leviCivitaRhs'_smulX_apply [CompleteSpace E] {f : M → ℝ}
+    (hf : MDiffAt f x) (hX : MDiffAt (T% X) x) (hY : MDiffAt (T% Y) x) (hZ : MDiffAt (T% Z) x) :
+    leviCivitaRhs' I (f • X) Y Z x = f x • leviCivitaRhs' I X Y Z x := by
+  unfold leviCivitaRhs'
+  simp only [Pi.add_apply, Pi.sub_apply]
+  rw [rhs_aux_smulX, rhs_aux_smulY_apply, rhs_aux_smulZ_apply] <;> try assumption
+  -- TODO: add the right congr_right lemma to avoid the product_apply, ← product_apply dance!
+  simp only [product_apply, mlieBracket_smul_left (W := Z) hf hX,
+    mlieBracket_smul_right (V := Y) hf hX, inner_add_right]
+  -- Combining this line with the previous one fails.
+  simp only [← product_apply, neg_smul, inner_neg_right]
+  have h1 :
+      letI dfZ : ℝ := (mfderiv% f x) (Z x);
+      inner ℝ (Y x) ((mfderiv% f x) (Z x) • X x) = dfZ * ⟪X, Y⟫ x := by
+    simp only [product]
+    rw [← real_inner_smul_left, real_inner_smul_right, real_inner_smul_left, real_inner_comm]
+  have h2 :
+      letI dfZ : ℝ := (mfderiv% f x) (Y x);
+      inner ℝ (Z x) ((mfderiv% f x) (Y x) • X x) = dfZ * ⟪Z, X⟫ x := by
+    simp only [product]
+    rw [← real_inner_smul_left, real_inner_smul_right, real_inner_smul_left]
+  simp only [h1, h2]
+  set dfY : ℝ := (mfderiv% f x) (Y x)
+  set dfZ : ℝ := (mfderiv% f x) (Z x)
+  have h3 : ⟪f • X, mlieBracket I Z Y⟫ x = f x * ⟪X, mlieBracket I Z Y⟫ x := by
+    rw [product_apply, Pi.smul_apply', real_inner_smul_left]
+  have h4 : inner ℝ (Z x) (f x • mlieBracket I Y X x) = f x * ⟪Z, mlieBracket I Y X⟫ x := by
+    rw [product_apply, real_inner_smul_right]
+  rw [real_inner_smul_right (Y x), h3]--, h4]
+  -- set A := ⟪Y, mlieBracket I X Z⟫ with hA
+  -- set B := ⟪Z, mlieBracket I X Y⟫
+  -- set C := ⟪X, mlieBracket I Z Y⟫
+  -- set R := dfZ * ⟪X, Y⟫ x with hR
+  -- set R' := dfY * ⟪Z, X⟫ x with hR'
+  -- set E := rhs_aux I X Y Z x
+  -- set F := rhs_aux I Y Z X x
+  -- set G := rhs_aux I Z X Y x
+  -- Push all applications of `x` inwards, then it's indeed obvious.
+  simp
+  ring_nf
+  congr
+
+variable {I} in
+lemma leviCivitaRhs_smulX_apply [CompleteSpace E] {f : M → ℝ}
+    (hf : MDiffAt f x) (hX : MDiffAt (T% X) x) (hY : MDiffAt (T% Y) x) (hZ : MDiffAt (T% Z) x) :
+    leviCivitaRhs I (f • X) Y Z x = f x • leviCivitaRhs I X Y Z x := by
+  simp only [leviCivitaRhs, one_div, Pi.smul_apply, smul_eq_mul]
+  simp_rw [leviCivitaRhs'_smulX_apply (I := I) hf hX hY hZ]
+  rw [← mul_assoc, mul_comm (f x), smul_eq_mul]
+  ring
+
+variable {I} in
+lemma leviCivitaRhs_smulX [CompleteSpace E] {f : M → ℝ}
+    (hf : MDiff f) (hX : MDiff (T% X)) (hY : MDiff (T% Y)) (hZ : MDiff (T% Z)) :
+    leviCivitaRhs I (f • X) Y Z = f • leviCivitaRhs I X Y Z := by
+  ext x
+  exact leviCivitaRhs_smulX_apply (hf x) (hX x) (hY x) (hZ x)
+
+lemma leviCivitaRhs'_addY_apply [CompleteSpace E]
+    (hX : MDiffAt (T% X) x) (hY : MDiffAt (T% Y) x)
+    (hY' : MDiffAt (T% Y') x) (hZ : MDiffAt (T% Z) x) :
+    leviCivitaRhs' I X (Y + Y') Z x = leviCivitaRhs' I X Y Z x + leviCivitaRhs' I X Y' Z x := by
+  simp only [leviCivitaRhs', Pi.add_apply, Pi.sub_apply, product_add_left_apply]
+  rw [rhs_aux_addX, rhs_aux_addY_apply, rhs_aux_addZ_apply] <;> try assumption
+  -- We have to rewrite back and forth: the Lie bracket is only additive at x,
+  -- as we are only asking for differentiability at x.
+  rw [product_congr_right₂ I (mlieBracket_add_left (W := X) hY hY')]
+  rw [product_congr_right₂ I (VectorField.mlieBracket_add_right (V := Z) hY hY')]
+  simp only [Pi.add_apply]
+  abel
+
+lemma leviCivitaRhs_addY_apply [CompleteSpace E]
+    (hX : MDiffAt (T% X) x) (hY : MDiffAt (T% Y) x)
+    (hY' : MDiffAt (T% Y') x) (hZ : MDiffAt (T% Z) x) :
+    leviCivitaRhs I X (Y + Y') Z x = leviCivitaRhs I X Y Z x + leviCivitaRhs I X Y' Z x := by
+  simp [leviCivitaRhs, leviCivitaRhs'_addY_apply I hX hY hY' hZ, left_distrib]
+
+lemma leviCivitaRhs_addY [CompleteSpace E]
+    (hX : MDiff (T% X)) (hY : MDiff (T% Y)) (hY' : MDiff (T% Y')) (hZ : MDiff (T% Z)) :
+    leviCivitaRhs I X (Y + Y') Z = leviCivitaRhs I X Y Z + leviCivitaRhs I X Y' Z := by
+  ext x
+  simp [leviCivitaRhs_addY_apply I (hX x) (hY x) (hY' x) (hZ x)]
+
+variable {I} in
+lemma leviCivitaRhs'_smulY_const_apply [CompleteSpace E] {a : ℝ}
+    (hX : MDiffAt (T% X) x) (hY : MDiffAt (T% Y) x) (hZ : MDiffAt (T% Z) x) :
+    leviCivitaRhs' I X (a • Y) Z x = a • leviCivitaRhs' I X Y Z x := by
+  simp only [leviCivitaRhs']
+  simp only [product_smul_const_left, Pi.add_apply, Pi.sub_apply, Pi.smul_apply]
+  rw [rhs_aux_smulY_const_apply I X hY hZ]
+  -- TODO: clean up this proof!
+  let f : M → ℝ := fun _ ↦ a
+  have : rhs_aux I (a • Y) Z X x = a • rhs_aux I Y Z X x := by
+    trans rhs_aux I (f • Y) Z X x
+    · rfl
+    rw [rhs_aux_smulX I Y (f := f) (Y := Z) (Z := X)]
+    rfl
+  rw [this, rhs_aux_smulZ_const_apply I _ hX hY]
+  -- is there a better abstraction for "Lie bracket conv mode"?
+  have : ⟪Z, mlieBracket I (a • Y) X⟫ x = a • ⟪Z, mlieBracket I Y X⟫ x := by
+    simp_rw [product_apply, mlieBracket_const_smul_left (W := X) hY, inner_smul_right_eq_smul]
+  rw [this]
+  have aux2 : ⟪X, mlieBracket I Z (a • Y)⟫ x = a • ⟪X, mlieBracket I Z Y⟫ x := by
+    simp_rw [product_apply,  mlieBracket_const_smul_right (V := Z) hY, inner_smul_right_eq_smul]
+  rw [aux2]
+  simp
+  ring
+
+variable {I} in
+lemma leviCivitaRhs_smulY_const_apply [CompleteSpace E] {a : ℝ}
+    (hX : MDiffAt (T% X) x) (hY : MDiffAt (T% Y) x) (hZ : MDiffAt (T% Z) x) :
+    leviCivitaRhs I X (a • Y) Z x = a • leviCivitaRhs I X Y Z x := by
+  simp_rw [leviCivitaRhs, Pi.smul_apply]; rw [smul_comm]
+  congr
+  exact leviCivitaRhs'_smulY_const_apply hX hY hZ
+
+variable {I} in
+lemma leviCivitaRhs_smulY_const [CompleteSpace E] {a : ℝ}
+    (hX : MDiff (T% X)) (hY : MDiff (T% Y)) (hZ : MDiff (T% Z)) :
+    leviCivitaRhs I X (a • Y) Z = a • leviCivitaRhs I X Y Z := by
+  ext x
+  exact leviCivitaRhs_smulY_const_apply (hX x) (hY x) (hZ x)
+
+lemma leviCivitaRhs'_smulY_apply [CompleteSpace E] {f : M → ℝ}
+    (hf : MDiffAt f x) (hX : MDiffAt (T% X) x) (hY : MDiffAt (T% Y) x) (hZ : MDiffAt (T% Z) x) :
+    leviCivitaRhs' I X (f • Y) Z x =
+      f x • leviCivitaRhs' I X Y Z x + ((bar _).toFun <| mfderiv% f x (X x)) • 2 * ⟪Y, Z⟫ x := by
+  simp only [leviCivitaRhs']
+  simp_rw [rhs_aux_smulX I Y Z X f]
+  simp only [product_smul_left, Pi.add_apply, Pi.sub_apply, smul_eq_mul, Pi.mul_apply]
+  rw [rhs_aux_smulY_apply I X hf hY hZ, rhs_aux_smulZ_apply I Z hf hX hY]
+  -- TODO: is there a better abstraction for this kind of "Lie bracket conv mode"?
+  have h1 : ⟪Z, mlieBracket I (f • Y) X⟫ x =
+      - (bar _).toFun (((mfderiv% f x) (X x))) • ⟪Z, Y⟫ x + f x • ⟪Z, mlieBracket I Y X⟫ x := by
+    simp_rw [product_apply, mlieBracket_smul_left (W := X) hf hY, inner_add_right]
+    congr
+    · simp only [neg_smul, inner_neg_right, bar, AddHom.toFun_eq_coe, AddHom.coe_mk, smul_eq_mul,
+      neg_mul, neg_inj]
+      rw [real_inner_smul_right]
+    · rw [inner_smul_right_eq_smul]
+  have h2 : ⟪X, mlieBracket I Z (f • Y)⟫ x =
+      (bar _).toFun (((mfderiv% f x) (Z x))) • ⟪X, Y⟫ x + f x • ⟪X, mlieBracket I Z Y⟫ x := by
+    simp_rw [product_apply, mlieBracket_smul_right (V := Z) hf hY, inner_add_right]
+    congr
+    · simp only [bar, AddHom.toFun_eq_coe, AddHom.coe_mk, smul_eq_mul]; rw [real_inner_smul_right]
+    · rw [inner_smul_right_eq_smul]
+  rw [h1, h2, product_swap I Y Z]
+  set A := rhs_aux I X Y Z x
+  set B := rhs_aux I Y Z X x
+  set C := rhs_aux I Z X Y x
+  set D := ⟪Y, mlieBracket I X Z⟫ x
+  set E := ⟪Z, mlieBracket I Y X⟫ x
+  set F := ⟪X, mlieBracket I Z Y⟫ x
+  set G1 := ⟪Y, Z⟫ x
+  set G2 := ⟪X, Y⟫ x
+  set dfx := (mfderiv% f x)
+  set H := (bar (f x)) (dfx (X x)) with H_eq
+  set K := (bar (f x)) (dfx (Z x)) with K_eq
+  change f x * A + (bar _).toFun (dfx (X x)) * G1 + f x * B
+    - (f x * C + (bar _).toFun (dfx (Z x)) * G2)
+    - f x * D - (-H * G1 + f x * E) + (K * G2 + f x * F) = _
+  dsimp
+  rw [← H_eq, ← K_eq]
+  ring
+
+lemma leviCivitaRhs_smulY_apply [CompleteSpace E] {f : M → ℝ}
+    (hf : MDiffAt f x) (hX : MDiffAt (T% X) x) (hY : MDiffAt (T% Y) x) (hZ : MDiffAt (T% Z) x) :
+    leviCivitaRhs I X (f • Y) Z x =
+      f x • leviCivitaRhs I X Y Z x + ((bar _).toFun <| mfderiv% f x (X x)) • ⟪Y, Z⟫ x := by
+  simp only [leviCivitaRhs, Pi.smul_apply, leviCivitaRhs'_smulY_apply I hf hX hY hZ]
+  rw [smul_add, smul_comm]
+  congr 1
+  rw [← smul_eq_mul]
+  dsimp
+  field_simp
+
+lemma leviCivitaRhs'_addZ_apply [CompleteSpace E]
+    (hX : MDiffAt (T% X) x) (hY : MDiffAt (T% Y) x)
+    (hZ : MDiffAt (T% Z) x) (hZ' : MDiffAt (T% Z') x) :
+    leviCivitaRhs' I X Y (Z + Z') x =
+      leviCivitaRhs' I X Y Z x + leviCivitaRhs' I X Y Z' x := by
+  simp only [leviCivitaRhs', rhs_aux_addX, Pi.add_apply, Pi.sub_apply, product_add_left_apply]
+  rw [product_congr_right₂ I (VectorField.mlieBracket_add_right (V := X) hZ hZ'),
+    product_congr_right₂ I (VectorField.mlieBracket_add_left (W := Y) hZ hZ'),
+    rhs_aux_addY_apply, rhs_aux_addZ_apply] <;> try assumption
+  abel
+
+lemma leviCivitaRhs'_addZ [CompleteSpace E]
+    (hX : MDiff (T% X)) (hY : MDiff (T% Y)) (hZ : MDiff (T% Z)) (hZ' : MDiff (T% Z')) :
+    leviCivitaRhs' I X Y (Z + Z') =
+      leviCivitaRhs' I X Y Z + leviCivitaRhs' I X Y Z' := by
+  ext x
+  exact leviCivitaRhs'_addZ_apply I (hX x) (hY x) (hZ x) (hZ' x)
+
+lemma leviCivitaRhs_addZ_apply [CompleteSpace E]
+    (hX : MDiffAt (T% X) x) (hY : MDiffAt (T% Y) x)
+    (hZ : MDiffAt (T% Z) x) (hZ' : MDiffAt (T% Z') x) :
+    leviCivitaRhs I X Y (Z + Z') x = leviCivitaRhs I X Y Z x + leviCivitaRhs I X Y Z' x := by
+  simp [leviCivitaRhs, leviCivitaRhs'_addZ_apply I hX hY hZ hZ', left_distrib]
+
+lemma leviCivitaRhs_addZ [CompleteSpace E]
+    (hX : MDiff (T% X)) (hY : MDiff (T% Y)) (hZ : MDiff (T% Z)) (hZ' : MDiff (T% Z')) :
+    leviCivitaRhs I X Y (Z + Z') = leviCivitaRhs I X Y Z + leviCivitaRhs I X Y Z' := by
+  ext x
+  exact leviCivitaRhs_addZ_apply I (hX x) (hY x) (hZ x) (hZ' x)
+
+lemma leviCivitaRhs'_smulZ_apply [CompleteSpace E] {f : M → ℝ}
+    (hf : MDiffAt f x) (hX : MDiffAt (T% X) x) (hY : MDiffAt (T% Y) x) (hZ : MDiffAt (T% Z) x) :
+    leviCivitaRhs' I X Y (f • Z) x = f x • leviCivitaRhs' I X Y Z x := by
+  simp only [leviCivitaRhs', rhs_aux_smulX, Pi.add_apply, Pi.sub_apply]
+  rw [rhs_aux_smulY_apply _ _ hf hZ hX, rhs_aux_smulZ_apply _ _ hf hY hZ]
+  -- Apply the product rule for the lie bracket.
+  -- Let's encapsulate the going into the product and back out again.
+  have h1 : ⟪Y, mlieBracket I X (f • Z)⟫ x =
+      f x • ⟪Y, mlieBracket I X Z⟫ x + ⟪Y, mfderiv% f x (X x) • Z⟫ x := by
+    rw [product_apply, VectorField.mlieBracket_smul_right hf hZ, inner_add_right, add_comm,
+      inner_smul_right]
+    congr
+  have h2 : letI dfY : ℝ :=  (mfderiv% f x) (Y x);
+      ⟪X, mlieBracket I (f • Z) Y⟫ x = - dfY • ⟪X, Z⟫ x + f x • ⟪X, mlieBracket I Z Y⟫ x := by
+    rw [product_apply, VectorField.mlieBracket_smul_left hf hZ, inner_add_right, inner_smul_right,
+      inner_smul_right]
+    congr
+  rw [h1, h2, product_smul_left, product_swap I X Z]
+  erw [product_smul_right]
+  simp
+  -- set A := rhs_aux I X Y Z x
+  -- set B := rhs_aux I Y Z X x
+  -- set C := rhs_aux I Z X Y x
+  -- set D := ⟪Y, mlieBracket I X Z⟫ x
+  -- set E := ⟪Z, mlieBracket I Y X⟫ x with E_eq
+  -- set F := ⟪X, mlieBracket I Z Y⟫ x
+  -- letI dfX : ℝ := (mfderiv% f x) (X x)
+  -- set G := dfX * ⟪Y, Z⟫ x
+  -- letI dfY : ℝ := (mfderiv% f x) (Y x)
+  -- set H := dfY * ⟪X, Z⟫ x
+  ring
+
+lemma leviCivitaRhs'_smulZ [CompleteSpace E] {f : M → ℝ}
+    (hf : MDiff f) (hX : MDiff (T% X)) (hY : MDiff (T% Y)) (hZ : MDiff (T% Z)) :
+    leviCivitaRhs' I X Y (f • Z) = f • leviCivitaRhs' I X Y Z := by
+  ext x
+  exact leviCivitaRhs'_smulZ_apply I (hf x) (hX x) (hY x) (hZ x)
+
+lemma leviCivitaRhs_smulZ [CompleteSpace E] {f : M → ℝ}
+    (hf : MDiff f) (hX : MDiff (T% X)) (hY : MDiff (T% Y)) (hZ : MDiff (T% Z)) :
+    leviCivitaRhs I X Y (f • Z) = f • leviCivitaRhs I X Y Z := by
+  simp only [leviCivitaRhs]
+  rw [smul_comm, leviCivitaRhs'_smulZ I hf hX hY hZ]
+
+end leviCivitaRhs
+
+variable (X Y Z) in
+lemma aux (h : cov.IsLeviCivitaConnection) : rhs_aux I X Y Z =
+    ⟪cov X Y, Z⟫ + ⟪Y, cov Z X⟫ + ⟪Y, VectorField.mlieBracket I X Z⟫ := by
+  trans ⟪cov X Y, Z⟫ + ⟪Y, cov X Z⟫
+  · ext x
+    exact h.1 X Y Z x
+  · simp [← isTorsionFree_iff.mp h.2 X Z, product_sub_right]
+
+lemma isolate_aux {α : Type*} [AddCommGroup α]
+    (A D E F X Y Z : α) (h : X + Y - Z = A + A + D + E - F) :
+    A + A = X + Y - Z - D - E + F := by
+  rw [h]; abel
+
+variable (X Y Z) {cov} in
+/-- Auxiliary lemma towards the uniquness of the Levi-Civita connection: expressing the term
+⟨∇ X Y, Z⟩ for all differentiable vector fields X, Y and Z, without reference to ∇. -/
+lemma IsLeviCivitaConnection.eq_leviCivitaRhs (h : cov.IsLeviCivitaConnection) :
+    ⟪cov X Y, Z⟫ = leviCivitaRhs I X Y Z := by
+  set A := ⟪cov X Y, Z⟫
+  set B := ⟪cov Z X, Y⟫
+  set C := ⟪cov Y Z, X⟫
+  set D := ⟪Y, VectorField.mlieBracket I X Z⟫ with D_eq
+  set E := ⟪Z, VectorField.mlieBracket I Y X⟫ with E_eq
+  set F := ⟪X, VectorField.mlieBracket I Z Y⟫ with F_eq
+  have eq1 : rhs_aux I X Y Z = A + B + D := by
+    simp only [aux I X Y Z cov h, A, B, D, product_swap _ Y (cov Z X)]
+  have eq2 : rhs_aux I Y Z X = C + A + E := by
+    simp only [aux I Y Z X cov h, A, C, E, product_swap _ (cov X Y) Z]
+  have eq3 : rhs_aux I Z X Y = B + C + F := by
+    simp only [aux I Z X Y cov h, B, C, F, product_swap _ X (cov Y Z)]
+  -- Add eq1 and eq2 and subtract eq3.
+  have : rhs_aux I X Y Z + rhs_aux I Y Z X - rhs_aux I Z X Y = A + A + D + E - F := by
+    rw [eq1, eq2, eq3]; abel
+  -- Solve for ⟪cov X Y, Z⟫ and obtain the claim.
+  have almost := isolate_aux A D E F (rhs_aux I X Y Z) (rhs_aux I Y Z X) (rhs_aux I Z X Y)
+    (by simp [this])
+  have almoster : A + A = leviCivitaRhs' I X Y Z := by simp only [leviCivitaRhs', *]
+  simp only [leviCivitaRhs, ← almoster, smul_add]
+  ext; simp; ring
+
+section
+
+attribute [local instance] Fintype.toOrderBot Fintype.toLocallyFiniteOrder
+
+variable [IsContMDiffRiemannianBundle I 1 E (fun (x : M) ↦ TangentSpace I x)]
+
+variable {I} in
+/-- If two vector fields `X` and `X'` on `M` satisfy the relation `⟨X, Z⟩ = ⟨X', Z⟩` for all
+vector fields `Z`, then `X = X'`. XXX up to differentiability? -/
+-- TODO: is this true if E is infinite-dimensional? trace the origin of the `Fintype` assumptions!
+lemma congr_of_forall_product [FiniteDimensional ℝ E]
+    (h : ∀ Z : Π x : M, TangentSpace I x, ⟪X, Z⟫ = ⟪X', Z⟫) : X = X' := by
+  obtain (_hE | hE) := subsingleton_or_nontrivial E
+  · ext x
+    have : Subsingleton (TangentSpace I x) := inferInstanceAs (Subsingleton E)
+    apply Subsingleton.allEq _
+  ext x
+  let b := Basis.ofVectorSpace ℝ E
+  let t := trivializationAt E (TangentSpace I : M → Type _) x
+  have hx : x ∈ t.baseSet := FiberBundle.mem_baseSet_trivializationAt' x
+  have : Nonempty ↑(Basis.ofVectorSpaceIndex ℝ E) := 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 ↑(Basis.ofVectorSpaceIndex ℝ E) := by
+    choose r wo using exists_wellOrder _
+    exact r
+  have : LocallyFiniteOrderBot ↑(Basis.ofVectorSpaceIndex ℝ E) := inferInstance
+  -- Choose an orthonormal frame (s i) near x w.r.t. to this trivialisation, and the metric g
+  let real := b.orthonormalFrame t
+  have hframe := b.orthonormalFrame_isOrthonormalFrameOn t (F := E) (IB := I) (n := 1)
+  rw [hframe.eq_iff_coeff hx]
+  intro i
+  have h₁ : ⟪X, real i⟫ x = hframe.coeff i x (X x) := by
+    rw [hframe.coeff_eq_inner' _ hx]
+    simp [real, real_inner_comm]
+  have h₂ : ⟪X', real i⟫ x = hframe.coeff i x (X' x) := by
+    rw [hframe.coeff_eq_inner' _ hx]
+    simp [real, real_inner_comm]
+  rw [← h₁, ← h₂, h (real i)]
+
+/-- The Levi-Civita connection on `(M, g)` is uniquely determined,
+at least on differentiable vector fields. -/
+-- (probably not everywhere, as addition rules apply only for differentiable vector fields?)
+theorem IsLeviCivitaConnection.uniqueness [FiniteDimensional ℝ E]
+    {cov cov' : CovariantDerivative I E (TangentSpace I : M → Type _)}
+    (hcov : cov.IsLeviCivitaConnection) (hcov' : cov'.IsLeviCivitaConnection) :
+    -- almost, only agree on smooth functions
+    cov = cov' := by
+  ext X σ x
+  apply congrFun
+  apply congr_of_forall_product fun Z ↦ ?_
+  trans leviCivitaRhs I X σ Z
+  · exact hcov.eq_leviCivitaRhs I X σ Z
+  · exact (hcov'.eq_leviCivitaRhs I X σ Z ).symm
+
+/-- Auxiliary definition towards defining the Levi-Civita connection on `M`:
+given a trivialisation `e` and a choice `o` of linear order on the standard basis of `E`,
+we take the expression defined by the Koszul formula (using the orthonormal frame determined by `e`
+and `o`). -/
+noncomputable def lcCandidateAux [FiniteDimensional ℝ E]
+    (e : Trivialization E (TotalSpace.proj : TangentBundle I M → M)) [MemTrivializationAtlas e]
+    (o : LinearOrder ↑(Basis.ofVectorSpaceIndex ℝ E)) :
+    ((x : M) → TangentSpace I x) → ((x : M) → TangentSpace I x) → (x : M) → TangentSpace I x :=
+  open scoped Classical in
+  fun X Y x ↦
+  if hE : Subsingleton E then X x else
+  -- Choose a trivialisation of `TM` near `x`.
+  -- Since `E` is non-trivial, `b` is non-empty.
+  let b := Basis.ofVectorSpace ℝ E
+  have : Nontrivial E := not_subsingleton_iff_nontrivial.mp hE
+  have : Nonempty ↑(Basis.ofVectorSpaceIndex ℝ E) := b.index_nonempty
+  have : LocallyFiniteOrderBot ↑(Basis.ofVectorSpaceIndex ℝ E) := inferInstance
+  letI frame := b.orthonormalFrame e
+  -- The coefficient of the desired tangent vector `∇ X Y x` w.r.t. `s i`
+  -- is given by `leviCivitaRhs X Y (s i)`.
+  ∑ i, ((leviCivitaRhs I X Y (frame i)) x) • (frame i x)
+
+variable (M) in
+-- TODO: make g part of the notation!
+/-- Given two vector fields X and Y on TM, compute
+the candidate definition for the Levi-Civita connection on `TM`. -/
+noncomputable def lcCandidate [FiniteDimensional ℝ E]
+    (o : LinearOrder ↑(Basis.ofVectorSpaceIndex ℝ E)) :
+    (Π x : M, TangentSpace I x) → (Π x : M, TangentSpace I x) → (Π x : M, TangentSpace I x) :=
+  -- Use the preferred trivialisation at `x` to write down a candidate for the existence.
+  fun X Y x ↦ lcCandidateAux I (trivializationAt E (TangentSpace I : M → Type _) x) o X Y x
+
+variable (X Y) in
+/-- The definition `lcCandidate` behaves well: for each compatible trivialisation `e`,
+the candidate definition using `e` agrees with `lcCandidate` on `e.baseSet`. -/
+lemma lcCandidate_eq_lcCandidateAux [FiniteDimensional ℝ E]
+    (e : Trivialization E (TotalSpace.proj : TangentBundle I M → M)) [MemTrivializationAtlas e]
+    {o : LinearOrder ↑(Basis.ofVectorSpaceIndex ℝ E)} {x : M} (hx : x ∈ e.baseSet) :
+    lcCandidate I M o X Y x = lcCandidateAux I e o X Y x := by
+  by_cases hE : Subsingleton E
+  · simp [lcCandidate, lcCandidateAux, hE]
+  · simp only [lcCandidate, lcCandidateAux, hE, ↓reduceDIte]
+    -- Now, start the real proof.
+    sorry
+
+lemma isCovariantDerivativeOn_lcCandidateAux_of_nonempty [FiniteDimensional ℝ E]
+    (hE : ¬(Subsingleton E)) [Nontrivial E]
+    (e : Trivialization E (TotalSpace.proj : TangentBundle I M → M)) [MemTrivializationAtlas e]
+    {o : LinearOrder ↑(Basis.ofVectorSpaceIndex ℝ E)} :
+    IsCovariantDerivativeOn E (lcCandidateAux I (M := M) e o) e.baseSet where
+  addX {_X _X' _σ x} hX hX' hσ hx := by
+    simp only [lcCandidateAux, hE, ↓reduceDIte]
+    simp only [← Finset.sum_add_distrib, ← add_smul]
+    congr; ext i
+    rw [leviCivitaRhs_addX_apply] <;> try assumption
+    let b := Basis.ofVectorSpace ℝ E
+    have : Nonempty ↑(Basis.ofVectorSpaceIndex ℝ E) := b.index_nonempty
+    exact mdifferentiableAt_orthonormalFrame_of_mem b e i hx
+  smulX {_X _σ _g _x} hX hσ hg hx := by
+    simp only [lcCandidateAux, hE, ↓reduceDIte]
+    rw [Finset.smul_sum]
+    congr; ext i
+    rw [leviCivitaRhs_smulX_apply] <;> try assumption
+    · simp [← smul_assoc]
+    · let b := Basis.ofVectorSpace ℝ E
+      have : Nonempty ↑(Basis.ofVectorSpaceIndex ℝ E) := b.index_nonempty
+      exact mdifferentiableAt_orthonormalFrame_of_mem b e i hx
+  smul_const_σ {X _σ x} a hX hσ hx := by
+    simp only [lcCandidateAux, hE, ↓reduceDIte]
+    rw [Finset.smul_sum]; congr; ext i
+    rw [leviCivitaRhs_smulY_const_apply hX hσ, ← smul_assoc]
+    · let b := Basis.ofVectorSpace ℝ E
+      have : Nonempty ↑(Basis.ofVectorSpaceIndex ℝ E) := b.index_nonempty
+      exact mdifferentiableAt_orthonormalFrame_of_mem b e i hx
+  addσ {X σ σ' x} hX hσ hσ' hx := by
+    simp only [lcCandidateAux, hE, ↓reduceDIte]
+    simp only [← Finset.sum_add_distrib, ← add_smul]
+    congr; ext i
+    rw [leviCivitaRhs_addY_apply] <;> try assumption
+    let b := Basis.ofVectorSpace ℝ E
+    have : Nonempty ↑(Basis.ofVectorSpaceIndex ℝ E) := b.index_nonempty
+    exact mdifferentiableAt_orthonormalFrame_of_mem b e i hx
+  leibniz {X σ g x} hX hσ hg hx := by
+    simp only [lcCandidateAux, hE, ↓reduceDIte]
+    let b := Basis.ofVectorSpace ℝ E
+    have : Nonempty ↑(Basis.ofVectorSpaceIndex ℝ E) := b.index_nonempty
+    let Z (i : (Basis.ofVectorSpaceIndex ℝ E)) := ((Basis.ofVectorSpace ℝ E).orthonormalFrame e i)
+    have hZ : IsOrthonormalFrameOn I E 1 Z e.baseSet :=
+      (Basis.ofVectorSpace ℝ E).orthonormalFrame_isOrthonormalFrameOn e
+    have hZ' : ∑ i, ⟪σ, Z i⟫ x • Z i x = σ x := by
+      calc _
+        _ = ∑ i, hZ.coeff i x (σ x) • Z i x := by
+          congr; ext i
+          rw [hZ.coeff_eq_inner' σ hx i, product_swap]
+        _ = σ x := (hZ.toIsLocalFrameOn.coeff_sum_eq _ hx).symm
+    trans ∑ i, leviCivitaRhs I X (g • σ) (Z i) x • (Z i) x
+    · congr
+    have (i : (Basis.ofVectorSpaceIndex ℝ E)) : MDiffAt (T% (Z i)) x :=
+      mdifferentiableAt_orthonormalFrame_of_mem _ _ i hx
+    have aux (i) := leviCivitaRhs_smulY_apply I hg hX hσ (this i)
+    simp_rw [aux]
+    trans ∑ i, (g x • leviCivitaRhs I X σ (Z i) x • Z i x)
+        + ∑ i, ((bar (g x)) ((mfderiv% g x) (X x)) • ⟪σ, Z i⟫ x) • Z i x
+    · simp only [← Finset.sum_add_distrib, add_smul, smul_assoc]
+      dsimp
+    have : ∑ i, g x • leviCivitaRhs I X σ (Z i) x • Z i x = (g • lcCandidateAux I e o X σ) x := by
+      simp only [lcCandidateAux, hE, ↓reduceDIte, Pi.smul_apply', Finset.smul_sum]
+      congr
+    rw [this]
+    simp_rw [← hZ', smul_assoc, Finset.smul_sum]
+    dsimp
+
+/-- The candidate definition `lcCandidateAux` is a covariant derivative
+on each local trivialisation's domain. -/
+lemma isCovariantDerivativeOn_lcCandidateAux [FiniteDimensional ℝ E]
+    (e : Trivialization E (TotalSpace.proj : TangentBundle I M → M)) [MemTrivializationAtlas e]
+    {o : LinearOrder ↑(Basis.ofVectorSpaceIndex ℝ E)} :
+    IsCovariantDerivativeOn E (lcCandidateAux I (M := M) e o) e.baseSet := by
+  by_cases hE : Subsingleton E
+  · exact (IsCovariantDerivativeOn.of_subsingleton E _).mono (Set.subset_univ _)
+  · have : Nontrivial E := not_subsingleton_iff_nontrivial.mp hE
+    exact isCovariantDerivativeOn_lcCandidateAux_of_nonempty I hE e
+
+-- The candidate definition is a covariant derivative on each local frame's domain.
+lemma isCovariantDerivativeOn_lcCandidate [FiniteDimensional ℝ E]
+    (e : Trivialization E (TotalSpace.proj : TangentBundle I M → M)) [MemTrivializationAtlas e]
+    {o : LinearOrder ↑(Basis.ofVectorSpaceIndex ℝ E)} :
+    IsCovariantDerivativeOn E (lcCandidate I M o) e.baseSet := by
+  apply IsCovariantDerivativeOn.congr (isCovariantDerivativeOn_lcCandidateAux I e (o := o))
+  intro X σ x hx
+  exact (lcCandidate_eq_lcCandidateAux I X σ e hx).symm
+
+end
+
+variable [IsContMDiffRiemannianBundle I 1 E (fun (x : M) ↦ TangentSpace I x)]
+
+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. -/
+@[no_expose] noncomputable def LeviCivitaConnection_aux [FiniteDimensional ℝ E]
+    (o : LinearOrder ↑(Basis.ofVectorSpaceIndex ℝ E)) :
+    CovariantDerivative I E (TangentSpace I : M → Type _) where
+  -- This is the existence part of the proof: take the formula derived above
+  -- and prove it satisfies all the conditions.
+  toFun := lcCandidate I M o
+  isCovariantDerivativeOn := by
+    rw [← iUnion_source_chartAt H M]
+    let t := fun x ↦ trivializationAt E (TangentSpace I : M → Type _) x
+    apply IsCovariantDerivativeOn.iUnion (s := fun i ↦ (t i).baseSet) fun i ↦ ?_
+    exact isCovariantDerivativeOn_lcCandidate I _
+
+-- TODO: make g part of the notation!
+variable (M) in
+/-- A choice of Levi-Civita connection on the tangent bundle `TM` of a Riemannian manifold `(M, g)`:
+this is unique up to the value on non-differentiable vector fields.
+If you know the Levi-Civita connection already, you can use `IsLeviCivitaConnection` instead. -/
+noncomputable def LeviCivitaConnection [FiniteDimensional ℝ E] :
+    CovariantDerivative I E (TangentSpace I : M → Type _) :=
+  LeviCivitaConnection_aux I M (Classical.choose (exists_wellOrder _))
+
+-- 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) → (Π x : M, 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)) (f (s i) (s j))
+
+-- special case of `foobar` below; needed?
+lemma ChristoffelSymbol.sum_eq
+    (f : (Π x : M, TangentSpace I x) → (Π x : M, TangentSpace I x) → (Π x : M, 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) (s j) x = ∑ k, (ChristoffelSymbol I f hs i j k x) • (s k) x := by
+  simp only [ChristoffelSymbol]
+  exact hs.coeff_sum_eq _ hx
+
+variable {U : Set M}
+  {f g : (Π x : M, TangentSpace I x) → (Π x : M, TangentSpace I x) → (Π x : M, 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 = ⟪f (s i) (s j), (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
+  dsimp [ChristoffelSymbol] -- simplify the piApply in the definition above
+  rw [hs.coeff_eq_inner' (f (s i) (s j)) hx k, real_inner_comm]
+
+-- 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 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 Y x = f X (fun x ↦ ∑ i, hs.coeff i x (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 Y x = g 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 Y x = g 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
+  ext; 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) → (Π x : M, TangentSpace I x)}
+
+-- 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*} [Finite ι]
+    [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
+  have := Fintype.ofFinite ι
+  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) (s j) x - f (s j) (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) := (t x).isLocalFrameOn_localFrame_baseSet I 1 (Basis.ofVectorSpace ℝ E)
+
+  -- 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 [lcCandidateAux, hE, ↓reduceDIte]
+
+    letI t := trivializationAt E (TangentSpace I) x;
+    letI hs := t.isLocalFrameOn_localFrame_baseSet I 1 (Basis.ofVectorSpace ℝ E)
+    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 [lcCandidateAux, 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'] says
+        simp only [one_div, leviCivitaRhs', Pi.smul_apply, Pi.add_apply, Pi.sub_apply, smul_eq_mul,
+          mul_eq_mul_left_iff, inv_eq_zero, OfNat.ofNat_ne_zero, or_false]
+      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
+
+lemma baz [FiniteDimensional ℝ E] : (LeviCivitaConnection I M).IsLeviCivitaConnection := by
+  -- If `E` is trivial, the Levi-Civita connection is always zero and all proofs are trivial.
+  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
+    refine ⟨?_, ?_⟩
+    · intro X Y Z x
+      simp only [LeviCivitaConnection, LeviCivitaConnection_aux]
+      unfold lcCandidate
+      simp [this]
+    · simp only [isTorsionFree_def, LeviCivitaConnection, LeviCivitaConnection_aux]
+      unfold lcCandidate torsion
+      ext; simp [this]
+  refine ⟨?_, ?_⟩
+  · intro X Y Z x
+    unfold LeviCivitaConnection LeviCivitaConnection_aux lcCandidate
+    simp only [lcCandidateAux, hE, ↓reduceDIte]
+    --simp [product_apply]
+    sorry -- compatible
+  · let s : M → Set M := fun x ↦ (trivializationAt E (fun (x : M) ↦ TangentSpace I x) x).baseSet
+    apply (LeviCivitaConnection I M).of_isTorsionFreeOn_of_open_cover (s := s) ?_ (by aesop)
+    intro x
+    simp only [s]
+    set t := fun x ↦ trivializationAt E (TangentSpace I : M → Type _) x with t_eq
+    have : IsCovariantDerivativeOn E (LeviCivitaConnection I M) (t x).baseSet :=
+      isCovariantDerivativeOn_lcCandidate _ (t x)
+    rw [isTorsionFree_iff_christoffelSymbols' _ this]
+    intro x' hx' i j k
+    -- Now, compute christoffel symbols and be happy.
+    have := LeviCivitaConnection.christoffelSymbol_symm I x  x' hx' i j k
+    sorry -- almost there, except x vs x' convert this
+
+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..83b5d8e281e722
--- /dev/null
+++ b/Mathlib/Geometry/Manifold/VectorBundle/CovariantDerivative/Lift.lean
@@ -0,0 +1,382 @@
+/-
+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.IntegralCurve.Basic
+/-!
+# Lifting vectors using covariant derivatives
+
+TODO: add a more complete doc-string
+
+-/
+
+@[expose] public section
+
+@[expose] public section delaborators
+
+-- TODO: decide whether we want this and move
+-- This delaborates `TotalSpace.mk x v` to `⟨x, v⟩`
+open Lean PrettyPrinter Delaborator SubExpr
+
+@[app_delab mfderiv] meta def delab_mfderiv : Delab := do
+  whenPPOption getPPNotation do
+  let args := (← getExpr).getAppArgs
+  if args.size < 22 then failure
+  let pt : Term ← withNaryArg 21 <| delab
+  let f := args[20]!
+  let m := mkIdent (.mkSimple "mfderiv%")
+  let T := mkIdent (.mkSimple "T%")
+  try
+    if let .lam _ _ b _ := f then
+      if b.isAppOf ``Bundle.TotalSpace.mk' then
+        let s := b.getAppArgs[4]!.getAppFn
+        if s matches .fvar .. then
+          let ss ← PrettyPrinter.delab s
+          return ← `($m ($T $ss) $pt)
+    throwError "nope"
+  catch _ =>
+    let x : Term ← withNaryArg 20 <| delab
+    return ← `($m $x $pt)
+
+@[app_delab Bundle.TotalSpace.mk'] meta def delabTotalSpace_mk' : Delab := do
+  whenPPOption getPPNotation do
+  let #[_B, _F, _E, _b, _v] := (← getExpr).getAppArgs | failure
+  let bd : Term ← withNaryArg 3 <| delab
+  let vd : Term ← withNaryArg 4 <| delab
+  `(⟨$bd, $vd⟩)
+
+end delaborators
+
+open Bundle Filter Module Topology Set
+
+open scoped Bundle Manifold ContDiff
+
+section
+variable {B : Type*} (E : B → Type*) {F : Type*}
+
+/-- Given a bundle `π : E → B`, the diagonal section of `π^*E → E`. -/
+def Bundle.pullback_diag (e : TotalSpace F E) : (TotalSpace.proj *ᵖ E) e :=
+  e.2
+end
+
+
+section
+variable
+  {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 ℝ E]
+  [FiniteDimensional ℝ F] [T2Space M] [IsManifold I ∞ M]
+  {cov : ((x : M) → TangentSpace I x) → (M → F) → M → 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 ℝ _) (-evalL ℝ F F f ∘L hcov.one_form x)
+
+@[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 u f) :=
+  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_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
+{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] [FiniteDimensional ℝ E]
+  [FiniteDimensional ℝ F] [T2Space M]
+  [IsManifold I ∞ 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
+
+/-- 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 {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
+  rw [cov.lift_vec_apply]
+  set t := trivializationAt F V v.proj
+  have hcov := cov.isCovariantDerivativeOn_pushCovDer t
+  refold_let t
+  sorry
+
+@[simp]
+lemma CovariantDerivative.lift_vec_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_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]
+
+-- noncomputable
+-- def CovariantDerivative.lift_vec'
+--   (p : TotalSpace E ((TotalSpace.proj : (TotalSpace F V → M)) *ᵖ (TangentSpace I))) :
+--     TangentSpace (I.prod 𝓘(ℝ, F)) p.1 :=
+--   letI t := trivializationAt F V p.1.proj
+--   haveI d_covDerOn := t.pushCovDer_isCovariantDerivativeOn
+--     (cov.isCovariantDerivativeOn.mono fun _ _ ↦ mem_univ _)
+--   letI tlift := d_covDerOn.lift_vec p.1.proj (t p.1).2
+--   t.derivInv I p.1 (tlift p.2)
+end
+
+section integralCurve
+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 ∞ 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
+
+end integralCurve
+
+section geodesics
+
+variable
+  {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] [FiniteDimensional ℝ E]
+  {H : Type*} [TopologicalSpace H] {I : ModelWithCorners ℝ E H} {M : Type*} [TopologicalSpace M]
+  [ChartedSpace H M] [T2Space M]
+  [IsManifold I ∞ M]
+  (cov : CovariantDerivative I E (TangentSpace I : M → Type _))
+
+-- FIXME: bug in `mfderiv%`?
+-- FIXME: missing elaborator support to find I.tangent
+omit [FiniteDimensional ℝ E] [T2Space M] in
+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
+
+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 X (γ t₀) := by
+  rw [hγX.acceleration hX, cov.proj_mderiv _ hX hX]
+
+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 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]
+
+end geodesics
diff --git a/Mathlib/Geometry/Manifold/VectorBundle/CovariantDerivative/Prelim.lean b/Mathlib/Geometry/Manifold/VectorBundle/CovariantDerivative/Prelim.lean
new file mode 100644
index 00000000000000..562acf24f90785
--- /dev/null
+++ b/Mathlib/Geometry/Manifold/VectorBundle/CovariantDerivative/Prelim.lean
@@ -0,0 +1,783 @@
+/-
+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.SmoothSection
+public import Mathlib.Geometry.Manifold.VectorBundle.Tangent
+public import Mathlib.Geometry.Manifold.MFDeriv.FDeriv
+public import Mathlib.Geometry.Manifold.MFDeriv.SpecificFunctions
+public import Mathlib.Geometry.Manifold.BumpFunction
+public import Mathlib.Geometry.Manifold.Notation
+public import Mathlib.Geometry.Manifold.VectorBundle.Misc
+public import Mathlib.Geometry.Manifold.VectorBundle.Tensoriality
+public import Mathlib.Geometry.Manifold.VectorField.LieBracket
+public import Mathlib.Geometry.Manifold.IsManifold.InteriorBoundary
+
+/-!
+# 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 delaborators
+
+-- TODO: decide whether we want this and move
+-- This delaborates `TotalSpace.mk x v` to `⟨x, v⟩`
+open Lean PrettyPrinter Delaborator SubExpr
+
+@[app_delab TotalSpace.mk] meta def delabTotalSpace_mk : Delab := do
+  whenPPOption getPPNotation do
+  let #[_B, _F, _E, _b, _v] := (← getExpr).getAppArgs | failure
+  let bd : Term ← withNaryArg 3 <| delab
+  let vd : Term ← withNaryArg 4 <| delab
+  `(⟨$bd, $vd⟩)
+
+@[app_delab MDifferentiableAt] meta def delabMDifferentiableAt : Delab := do
+  whenPPOption getPPNotation do
+  let args := (← getExpr).getAppArgs
+  if args.size < 22 then failure
+  let pt : Term ← withNaryArg 21 <| delab
+  let f := args[20]!
+  try
+    if let .lam _ _ b _ := f then
+      if b.isAppOf ``Bundle.TotalSpace.mk' then
+        let s := b.getAppArgs[4]!.getAppFn
+        if s matches .fvar .. then
+          let ss ← PrettyPrinter.delab s
+          return ← `(MDiffAt (T% $ss) $pt)
+    throwError "nope"
+  catch _ =>
+    let x : Term ← withNaryArg 20 <| delab
+    return ← `(MDiffAt $x $pt)
+
+end delaborators
+
+@[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
+
+variable {F : Type*} [NormedAddCommGroup F] [NormedSpace 𝕜 F]
+
+set_option backward.isDefEq.respectTransparency false in
+-- cleaned up and PRed in #34262
+lemma mfderiv_const_smul (s : M → F) {x : M} (a : 𝕜) (v : TangentSpace I x) :
+    mfderiv% (a • s) x v = a • mfderiv% s x v := by
+  by_cases hs : MDiffAt s x
+  · have hs' := hs.const_smul a
+    suffices
+      (fderivWithin 𝕜 ((a • s) ∘ (chartAt H x).symm ∘ I.symm) (range I) (I ((chartAt H x) x))) v =
+       a • (fderivWithin 𝕜 (s ∘ (chartAt H x).symm ∘ I.symm) (range I)
+       (I ((chartAt H x) x))) v by simpa [mfderiv, hs, hs']
+    change fderivWithin 𝕜 (a • (s ∘ ↑(chartAt H x).symm ∘ ↑I.symm)) _ _ _ = _
+    rw [fderivWithin_const_smul_field _ I.uniqueDiffWithinAt_image ]
+    rfl
+  · by_cases ha : a = 0
+    · have : a • s = 0 := by ext; simp [ha]
+      rw [this, ha]
+      change (mfderiv I 𝓘(𝕜, F) (fun _ ↦ 0) x) v = _
+      simp
+    have hs' : ¬ MDiffAt (a • s) x :=
+      fun h ↦ hs (by simpa [ha] using h.const_smul a⁻¹)
+    rw [mfderiv_zero_of_not_mdifferentiableAt hs, mfderiv_zero_of_not_mdifferentiableAt hs']
+    simp
+    rfl
+
+-- PRed and cleaned up in #34263
+set_option linter.flexible false in -- FIXME
+lemma mfderiv_smul [IsManifold I 1 M] {f : M → F} {s : M → 𝕜} {x : M} (hf : MDiffAt f x)
+    (hs : MDiffAt s x) (v : TangentSpace I x) :
+    letI dsxv : 𝕜 := mfderiv% s x v
+    letI dfxv : F := mfderiv% f x v
+    mfderiv% (s • f) x v = (s x) • dfxv + dsxv • f x := by
+  set φ := chartAt H x
+  -- TODO: the next two have should be special cases of the same lemma
+  have hs' : DifferentiableWithinAt 𝕜 (s ∘ φ.symm ∘ I.symm) (range I) (I (φ x)) := by
+    have hφ := mdifferentiableWithinAt_extChartAt_symm (mem_extChartAt_target x) (I := I)
+    have : (extChartAt I x).symm (extChartAt I x x) = x := extChartAt_to_inv x
+    rw [← this] at hs
+    have := hs.comp_mdifferentiableWithinAt (extChartAt I x x) hφ
+    exact mdifferentiableWithinAt_iff_differentiableWithinAt.mp this
+  have hf' : DifferentiableWithinAt 𝕜 (f ∘ φ.symm ∘ I.symm) (range I) (I (φ x)) := by
+    have hφ := mdifferentiableWithinAt_extChartAt_symm (mem_extChartAt_target x) (I := I)
+    have : (extChartAt I x).symm (extChartAt I x x) = x := extChartAt_to_inv x
+    rw [← this] at hf
+    have := hf.comp_mdifferentiableWithinAt (extChartAt I x x) hφ
+    exact mdifferentiableWithinAt_iff_differentiableWithinAt.mp this
+  have hsf : MDiffAt (s • f) x := hs.smul hf
+  simp [mfderiv, hsf, hs, hf]
+  have uniq : UniqueDiffWithinAt 𝕜 (range I) (I (φ x)) :=
+    ModelWithCorners.uniqueDiffWithinAt_image I
+  erw [fderivWithin_smul uniq hs' hf']
+  simp [φ.left_inv (ChartedSpace.mem_chart_source x)]
+  rfl
+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 extend
+variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] [FiniteDimensional ℝ 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] [VectorBundle ℝ F V]
+  -- `V` vector bundle
+
+-- TODO: either change `localFrame` to make sure it is everywhere smooth
+-- or introduce a cut-off here. First option is probaly better.
+-- TODO: comment why we chose the second option in the end, and adapt the definition accordingly
+-- new definition: smooth a bump function, then smul with localExtensionOn
+/-- Extend a vector `v ∈ V x` to a section of the bundle `V`, whose value at `x` is `v`.
+The details of the extension are mostly unspecified: for covariant derivatives, the value of
+`s` at points other than `x` will not matter (except for shorter proofs).
+Thus, we choose `s` to be somewhat nice: our chosen construction is linear in `v`.
+-/
+noncomputable def extend [FiniteDimensional ℝ F] [T2Space M] {x : M} (v : V x) :
+    (x' : M) → V x' :=
+  letI b := Basis.ofVectorSpace ℝ F
+  letI t := trivializationAt F V x
+  -- Choose a smooth bump function ψ near `x`, supported within t.baseSet
+  -- and return ψ • V₀ instead.
+  letI ht := t.open_baseSet.mem_nhds (FiberBundle.mem_baseSet_trivializationAt' x)
+  let ψ := Classical.choose <| (SmoothBumpFunction.nhds_basis_support (I := I) ht).mem_iff.1 ht
+  ψ.toFun • localExtensionOn b t v
+
+variable {I F}
+
+-- NB. These two lemmas don't hold for *any* choice of extension of `v`, but they hold for
+-- *well-chosen* extensions (such as ours).
+-- so, one may argue this is mathematically wrong, but it encodes the "choice some extension
+-- with this and that property" nicely
+-- a different proof would be to argue only the value at a point matters for cov
+@[simp]
+lemma extend_add [FiniteDimensional ℝ F] [T2Space M] {x : M} (v v' : V x) :
+    extend I F (v + v') = extend I F v + extend I F v' := by
+  simp [extend]
+
+@[simp]
+lemma extend_smul [FiniteDimensional ℝ F] [T2Space M] {a : ℝ} {x : M} (v : V x) :
+  extend I F (a • v) = a • extend I F v := by simp [extend]; module
+
+@[simp]
+lemma extend_zero [FiniteDimensional ℝ F] [T2Space M] (x : M) :
+  extend I F (0 : V x) = 0 := by simp [extend]
+
+@[simp] lemma extend_apply_self [FiniteDimensional ℝ F] [T2Space M] {x : M} (v : V x) :
+    extend I F v x = v := by
+  simpa [extend] using
+    localExtensionOn_apply_self _ _ (FiberBundle.mem_baseSet_trivializationAt' x) v
+
+variable (I F)
+
+lemma contMDiff_extend [IsManifold I ∞ M] [FiniteDimensional ℝ F] [T2Space M]
+    [ContMDiffVectorBundle ∞ F V I] {x : M} (σ₀ : V x) :
+    CMDiff ∞ (T% (extend I F σ₀)) := by
+  letI t := trivializationAt F V x
+  letI ht := t.open_baseSet.mem_nhds (FiberBundle.mem_baseSet_trivializationAt' x)
+  have hx : x ∈ t.baseSet := FiberBundle.mem_baseSet_trivializationAt' x
+  let ψ := Classical.choose <| (SmoothBumpFunction.nhds_basis_support (I := I) ht).mem_iff.1 ht
+  let hψ :=
+    Classical.choose_spec <| (SmoothBumpFunction.nhds_basis_support (I := I) ht).mem_iff.1 ht
+  exact ContMDiffOn.smul_section_of_tsupport ψ.contMDiff.contMDiffOn t.open_baseSet hψ.1
+    (contMDiffOn_localExtensionOn _ hx _)
+
+lemma mdifferentiable_extend [IsManifold I ∞ M] [FiniteDimensional ℝ F] [T2Space M]
+    [ContMDiffVectorBundle ∞ F V I] {x : M} (σ₀ : V x) :
+    MDiff (T% (extend I F σ₀)) :=
+  contMDiff_extend I F σ₀ |>.mdifferentiable (by simp)
+
+theorem contDiff_extend
+    {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] [FiniteDimensional ℝ E]
+    {E' : Type*} [NormedAddCommGroup E'] [NormedSpace ℝ E'] [FiniteDimensional ℝ E']
+    (x : E) (y : E') : ContDiff ℝ ∞ (extend 𝓘(ℝ, E) E' y (x := x)) := by
+  rw [contDiff_iff_contDiffAt]
+  intro x'
+  rw [← contMDiffAt_iff_contDiffAt]
+  simpa [contMDiffAt_section] using contMDiff_extend (V := Trivial E E') _ _ y x'
+
+end extend
+
+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 [← mk_proj_snd' e 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
+    using by simp [(mem_target e).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 [*]⟩
+
+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⟩
+
+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 coe_fst' e 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 using
+    by simp [(mem_source e).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]
+
+@[simp]
+lemma apply_symm_eventuallyEq {x : B} (hx : x ∈ e.baseSet) (s : B → F) :
+  (fun x ↦ (e ⟨x, e.symm x (s x)⟩).2) =ᶠ[𝓝 x] s := by
+    filter_upwards [e.baseSet_mem_nhds hx] with y hy using by simp [hy]
+
+variable [(b : B) → TopologicalSpace (E b)] [FiberBundle F E]
+
+-- FIXME super weird elaborator bug: removing the
+-- omitted assumption from the variable line breaks the lemma
+omit [(b : B) → TopologicalSpace (E b)] [FiberBundle F E] in
+lemma symm_apply_apply_mk_eventuallyEq
+    {b : B} (hb : b ∈ e.baseSet) (σ : Π x, E x) :
+    (T% fun x' ↦ e.symm x' (e (T% σ x')).2) =ᶠ[𝓝 b] T% σ := by
+  filter_upwards [e.baseSet_mem_nhds hb] with y hy using by simp [*]
+
+-- FIXME super weird elaborator bug: removing the
+-- omitted assumption from the variable line breaks the lemma
+omit [(x : B) → Zero (E x)] [(b : B) → TopologicalSpace (E b)] [FiberBundle F E] in
+lemma apply_section_eventuallyEq
+    {x : B} (hx : x ∈ e.baseSet) (σ : Π x, E x) :
+    e ∘ T%σ =ᶠ[𝓝 x] fun x ↦ ⟨x, (e (σ x)).2⟩ := by
+  filter_upwards [e.baseSet_mem_nhds hx] with y hy
+  ext
+  · exact coe_coe_fst e hy
+  · simp
+
+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)]
+
+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
+
+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'
+
+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' :=
+  (symmL R e x).map_add f f'
+
+@[simp]
+lemma symm_map_zero [Trivialization.IsLinear R e] {x : B} :
+    e.symm x 0 = 0 :=
+  (symmL R e x).map_zero
+
+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 :=
+  (symmL R e x).map_smul a f
+
+end
+
+end topological_vector_bundle
+
+section to_trivialization
+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]
+  -- `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]
+
+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 := (coe_mem_source e).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 := (mk_mem_target e).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)
+
+@[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 [mk_proj_snd' e 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]
+  rfl
+
+@[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 [mk_proj_snd' e hv] at D₁
+  have diff : MDifferentiableAt (I.prod 𝓘(ℝ, F)) I TotalSpace.proj v :=
+    mdifferentiableAt_proj _
+  have eq : e.invFun (e v) = v := by simp [((mem_source e).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 [mk_proj_snd' e hv] at D₁
+  have D₂ : MDifferentiableAt _ _ e v := e.mdifferentiableAt (I := I) hv v.2
+  have : e.invFun (e v) = v := by simp [(mem_source e).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_section_of_function
+    [VectorBundle ℝ F V] [ContMDiffVectorBundle 1 F V I]
+    {x : M} (hx : x ∈ e.baseSet) {s : M → F}
+    (hs : MDiffAt s x) :
+    MDiffAt ((fun x' ↦ (⟨x', e.symm x' (s x')⟩ : TotalSpace F V))) x := by
+  rw [e.mdifferentiableAt_section_iff (IB := I) _ hx]
+  have := e.apply_symm_eventuallyEq hx s
+  exact hs.congr_of_eventuallyEq this
+
+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) :
+    letI s := fun x ↦ (e (σ x)).2
+    (e.deriv I (σ x)).toLinearMap ((mfderiv% T%σ x) u) = (u, mfderiv% s 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]
+  let s := fun x ↦ (e (σ x)).2
+  change mfderiv% (e ∘ T%σ) x u = (u, mfderiv% s x u)
+  rw [(e.apply_section_eventuallyEq hx _).mfderiv_eq]
+  erw [mfderiv_prodMk, mfderiv_id]
+  · change (ContinuousLinearMap.id _ _).prod (mfderiv% s x) u = _
+    simp
+  · apply mdifferentiableAt_id
+  · exact (mdifferentiableAt_section_iff I e σ hx).mp hσ
+
+@[simp]
+lemma _root_.mdifferentiableAt_section_trivial_iff {s : M → F} {x : M} :
+    MDiffAt (T% s) x ↔ MDiffAt s x := by
+  rw [mdifferentiableAt_section I]
+  simp
+
+end to_trivialization
+
+end Bundle.Trivialization
+
+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/Torsion.lean b/Mathlib/Geometry/Manifold/VectorBundle/CovariantDerivative/Torsion.lean
new file mode 100644
index 00000000000000..84b37aba789f3b
--- /dev/null
+++ b/Mathlib/Geometry/Manifold/VectorBundle/CovariantDerivative/Torsion.lean
@@ -0,0 +1,320 @@
+/-
+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
+
+/-!
+# Torsion of a covariant derivative
+
+- define torsion of a covariant derivative (and its local version)
+- torsion-free ness (local and global version)
+- 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]
+
+-- TODO: where is a good namespace for this?
+/-- The torsion of a covariant derivative on the tangent bundle `TM` -/
+noncomputable def Bundle.torsion
+    (f : (Π x : M, TangentSpace I x) → (Π x : M, TangentSpace I x) → (Π x : M, TangentSpace I x)) :
+    (Π x : M, TangentSpace I x) → (Π x : M, TangentSpace I x) → (Π x : M, TangentSpace I x) :=
+  fun X Y ↦ f X Y - f Y X - VectorField.mlieBracket I X Y
+
+variable
+  {f g : (Π x : M, TangentSpace I x) → (Π x : M, TangentSpace I x) → (Π x : M, TangentSpace I x)}
+  {X X' Y : Π x : M, TangentSpace I x}
+
+variable (f X) in
+lemma torsion_self : torsion f X X = 0 := by
+  simp [torsion]
+
+variable (X Y) in
+lemma torsion_antisymm : torsion f X Y = - torsion f Y X := by
+  simp only [torsion]
+  rw [VectorField.mlieBracket_swap]
+  module
+
+namespace IsCovariantDerivativeOn
+
+variable [h : IsManifold I ∞ M]
+variable {U : Set M} (hf : IsCovariantDerivativeOn E f U)
+
+variable (Y) in
+lemma torsion_add_left_apply [CompleteSpace E]
+    (hf : IsCovariantDerivativeOn E f U) (hx : x ∈ U)
+    (hX : MDiffAt (T% X) x) (hX' : MDiffAt (T% X') x) :
+    torsion f (X + X') Y x = torsion f X Y x + torsion f X' Y x := by
+  sorry -- simp [torsion, hf.addX (x := x) (hx := sorry) hX hX']
+  -- rw [hf.addσ Y hX hX', VectorField.mlieBracket_add_left hX hX']
+  -- module
+
+lemma torsion_add_right_apply [CompleteSpace E] (hf : IsCovariantDerivativeOn E f U) (hx : x ∈ U)
+    (hX : MDiffAt (T% X) x)
+    (hX' : MDiffAt (T% X') x) :
+    torsion f Y (X + X') x = torsion f Y X x + torsion f Y X' x := by
+  rw [torsion_antisymm, Pi.neg_apply,
+    hf.torsion_add_left_apply _ hx hX hX', torsion_antisymm Y, torsion_antisymm Y]
+  simp; abel
+
+variable (Y) in
+lemma torsion_smul_left_apply [CompleteSpace E]
+    {F : ((x : M) → TangentSpace I x) → ((x : M) → TangentSpace I x) → (x : M) → TangentSpace I x}
+    (hF : IsCovariantDerivativeOn E F U) (hx : x ∈ U)
+    -- TODO: making hx an auto-param := by trivial doesn't fire at the application sites below
+    {f : M → ℝ} (hf : MDiffAt f x) (hX : MDiffAt (T% X) x) :
+    torsion F (f • X) Y x = f x • torsion F X Y x := by
+  sorry /-simp only [torsion, Pi.sub_apply, hF.smulX (X := X) (σ := Y) (f := f)]
+  rw [hF.leibniz Y hX hf hx, VectorField.mlieBracket_smul_left hf hX]
+  simp [bar, smul_sub]
+  abel -/
+
+variable (X) in
+lemma torsion_smul_right_apply [CompleteSpace E]
+    {F : ((x : M) → TangentSpace I x) → ((x : M) → TangentSpace I x) → (x : M) → TangentSpace I x}
+    (hF : IsCovariantDerivativeOn E F U) (hx : x ∈ U)
+    {f : M → ℝ} (hf : MDiffAt f x) (hX : MDiffAt (T% Y) x) :
+    torsion F X (f • Y) x = f x • torsion F X Y x := by
+  rw [torsion_antisymm, Pi.neg_apply, hF.torsion_smul_left_apply X hx hf hX, torsion_antisymm X]
+  simp
+
+end IsCovariantDerivativeOn
+
+/-- `f` is torsion-free on `U` if its torsion vanishes at each `x ∈ U` -/
+noncomputable def IsTorsionFreeOn
+    (f : (Π x : M, TangentSpace I x) → (Π x : M, TangentSpace I x) → (Π x : M, TangentSpace I x))
+    (U : Set M) : Prop :=
+  ∀ x ∈ U, ∀ X Y : Π x : M, TangentSpace I x, torsion f 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 f (⋃ i, s i) := by
+  rintro x ⟨si, ⟨i, hi⟩, hxsi⟩ X Y
+  exact hf i x (by simp [hi, hxsi]) X Y
+
+end changing_set
+
+/- Congruence properties -/
+section
+
+-- unused?
+lemma congr {s : Set M} (h : IsTorsionFreeOn f s)
+    (hfg : ∀ {X Y : Π x : M, TangentSpace I x}, ∀ {x}, x ∈ s → f X Y x = g X Y x) :
+    IsTorsionFreeOn g s := by
+  intro x hx X Y
+  specialize h x hx X Y
+  -- now, use torsion congruence lemma, i.e. tensoriality of sorts!
+  -- TODO: generalise tensoriality to the local setting!
+  sorry
+
+end
+
+end IsTorsionFreeOn
+
+namespace CovariantDerivative
+
+variable [h : IsManifold I ∞ M]
+-- The torsion tensor of a covariant derivative on the tangent bundle `TM`.
+variable {cov : CovariantDerivative I E (TangentSpace I : M → Type _)}
+
+variable {U : Set M} (hf : IsCovariantDerivativeOn E f U)
+
+-- TODO: prove applied versions of these, for IsCovariantDerivativeOn --- using tensoriality, later!
+variable (f) in
+@[simp]
+lemma torsion_zero (hX : MDiff T% X) : torsion cov 0 X = 0 := by
+  simp [torsion, cov.zeroX hX, cov.zeroσ hX]
+
+
+@[simp]
+lemma torsion_zero' (hX : MDiff T% X) : torsion cov X 0 = 0 := by
+  rw [torsion_antisymm, torsion_zero hX]; simp
+
+variable (Y) in
+lemma torsion_add_left [CompleteSpace E]
+    (hX : MDiff (T% X)) (hX' : MDiff (T% X')) :
+    torsion cov (X + X') Y = torsion cov X Y + torsion cov X' Y := by
+  ext x
+  exact cov.isCovariantDerivativeOn.torsion_add_left_apply _ (by trivial) (hX x) (hX' x)
+
+lemma torsion_add_right [CompleteSpace E]
+    (hX : MDiff (T% X)) (hX' : MDiff (T% X')) :
+    torsion cov Y (X + X') = torsion cov Y X + torsion cov Y X' := by
+  rw [torsion_antisymm, torsion_add_left _ hX hX', torsion_antisymm X, torsion_antisymm X']; module
+
+variable (Y) in
+lemma torsion_smul_left [CompleteSpace E] {f : M → ℝ} (hf : MDiff f) (hX : MDiff (T% X)) :
+    torsion cov (f • X) Y = f • torsion cov X Y := by
+  ext x
+  exact cov.isCovariantDerivativeOn.torsion_smul_left_apply _ (by trivial) (hf x) (hX x)
+
+variable (X) in
+lemma torsion_smul_right [CompleteSpace E] {f : M → ℝ} (hf : MDiff f) (hY : MDiff (T% Y)) :
+    torsion cov X (f • Y) = f • torsion cov X Y := by
+  ext x
+  exact cov.isCovariantDerivativeOn.torsion_smul_right_apply _ (by trivial) (hf x) (hY x)
+
+/-- The torsion of a covariant derivative is tensorial:
+the value of `torsion cov X Y` at `x₀` depends only on `X x₀` and `Y x₀`. -/
+def torsion_tensorial [T2Space M] [IsManifold I ∞ M] [FiniteDimensional ℝ E]
+    [FiniteDimensional ℝ F] [VectorBundle ℝ F V] [ContMDiffVectorBundle 1 F V I]
+    {X X' Y Y' : Π x : M, TangentSpace I x} {x₀ : M}
+    (hX : MDiffAt (T% X) x₀) (hX' : MDiffAt (T% X') x₀)
+    (hY : MDiffAt (T% Y) x₀) (hY' : MDiffAt (T% Y') x₀)
+    (hXX' : X x₀ = X' x₀) (hYY' : Y x₀ = Y' x₀) :
+    (torsion cov X Y) x₀ = (torsion cov X' Y') x₀ := by
+  apply tensoriality_criterion₂ I E (TangentSpace I) E (TangentSpace I) hX hX' hY hY' hXX' hYY'
+  · intro f σ τ hf hσ
+    exact cov.isCovariantDerivativeOn.torsion_smul_left_apply _ (by trivial) hf hσ
+  · intro σ σ' τ hσ hσ'
+    exact cov.isCovariantDerivativeOn.torsion_add_left_apply _ (by trivial) hσ hσ'
+  · intros f σ σ' hf hσ'
+    exact cov.isCovariantDerivativeOn.torsion_smul_right_apply _ (by trivial) hf hσ'
+  · intro σ τ τ' hτ hτ'
+    exact cov.isCovariantDerivativeOn.torsion_add_right_apply (by trivial) hτ hτ'
+
+-- TODO: define a torsion tensor of a covariant derivative,
+-- and related torsion-freeness to this
+-- (That will not work for torsion-freeness on a set, though.)
+
+-- TODO: generalise tensoriality result above to `IsCovariantDerivativeOn`,
+-- so it would apply here as well
+
+variable (cov) in
+/-- A covariant derivation is called **torsion-free** iff its torsion tensor vanishes. -/
+def IsTorsionFree : Prop := torsion cov = 0
+
+@[simp]
+lemma isTorsionFreeOn_univ : IsTorsionFreeOn cov univ ↔ IsTorsionFree cov := by
+  simp only [IsTorsionFree, IsTorsionFreeOn]
+  refine ⟨fun h ↦ ?_, fun h ↦ by simp [h]⟩
+  ext X Y x
+  simp [h x]
+
+/-- If a covariant derivative `cov` is torsion-free on each set in an open cover,
+it is torsion-free. -/
+def of_isTorsionFreeOn_of_open_cover {ι : Type*} {s : ι → Set M}
+    (hf : ∀ i, IsTorsionFreeOn cov (s i)) (hs : ⋃ i, s i = Set.univ) :
+    IsTorsionFree cov := by
+  rw [← isTorsionFreeOn_univ, ← hs]
+  exact IsTorsionFreeOn.iUnion hf
+
+lemma isTorsionFree_def : IsTorsionFree cov ↔ torsion cov = 0 := by simp [IsTorsionFree]
+
+-- This should be obvious; am I doing something wrong?
+lemma isTorsionFree_iff : IsTorsionFree cov ↔
+    ∀ X Y, cov X Y - cov Y X = VectorField.mlieBracket I X Y := by
+  simp only [IsTorsionFree]
+  constructor
+  · intro h X Y
+    have : torsion cov X Y = 0 := by simp [h]
+    -- XXX: abel, ring, module and grind all fail here
+    exact eq_of_sub_eq_zero this
+  · intro h
+    ext X Y x
+    specialize h X Y
+    apply congr_fun
+    simp_all [torsion]
+
+variable {n} in
+lemma aux1 {ι : Type*} [Fintype ι]
+    {f : (Π x : M, TangentSpace I x) → (Π x : M, TangentSpace I x) → (Π x : M, 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 := by
+  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) → (Π x : M, 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 := X) (Y := s i)
+        (f := (LinearMap.piApply (hs.coeff i)) Y) hx hsi hsi'
+      dsimp at this
+      rw [← this]
+      congr
+
+/-- We can test torsion-freeness on a set using a local frame. -/
+lemma _root_.IsCovariantDerivativeOn.isTorsionFreeOn_iff_localFrame
+    {ι : Type*} [Finite ι] [CompleteSpace E]
+    {f : (Π x : M, TangentSpace I x) → (Π x : M, TangentSpace I x) → (Π x : M, 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
+  have := Fintype.ofFinite ι
+  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/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/LocalFrame.lean b/Mathlib/Geometry/Manifold/VectorBundle/LocalFrame.lean
index e97d641a462961..16743c15ea6d1d 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
 
 -/
 
@@ -568,3 +587,79 @@ 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]
+
+-- TODO: fix this proof!
+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 : ι) (y : M) :
+    (Trivialization.localFrame_coeff I e b i y) ((localExtensionOn b e) v y) =
+    (Trivialization.localFrame_coeff I e b i x) ((localExtensionOn b e) v x) := by
+-- statement used to be
+--  e.localFrame_coeff I b i (LinearMap.piApply (localExtensionOn b e v)) x' =
+--   e.localFrame_coeff I b i (localExtensionOn b e v) x := by
+  simp [localExtensionOn, hx]
+  -- XXX: original proof passed hx' and was done now
+  sorry
+
+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 1ceadc7c458466..7ce86f5133c466 100644
--- a/Mathlib/Geometry/Manifold/VectorBundle/MDifferentiable.lean
+++ b/Mathlib/Geometry/Manifold/VectorBundle/MDifferentiable.lean
@@ -6,8 +6,10 @@ Authors: Sébastien Gouëzel, Patrick Massot, Michael Rothgang
 module
 
 public import Mathlib.Geometry.Manifold.VectorBundle.Basic
+public import Mathlib.Geometry.Manifold.Algebra.Monoid
 public import Mathlib.Geometry.Manifold.MFDeriv.NormedSpace
 public import Mathlib.Geometry.Manifold.MFDeriv.SpecificFunctions
+public import Mathlib.Geometry.Manifold.Notation
 
 /-!
 # Differentiability of functions in vector bundles
@@ -63,15 +65,14 @@ theorem mdifferentiableWithinAt_totalSpace (f : M → TotalSpace F E) {s : Set M
 Version at a point -/
 theorem mdifferentiableAt_totalSpace (f : M → TotalSpace F E) {x₀ : M} :
     MDifferentiableAt IM (IB.prod 𝓘(𝕜, F)) f x₀ ↔
-      MDifferentiableAt IM IB (fun x => (f x).proj) x₀ ∧
-      MDifferentiableAt IM 𝓘(𝕜, F)
-        (fun x ↦ (trivializationAt F E (f x₀).proj (f x)).2) x₀ := by
+      MDiffAt (fun x => (f x).proj) x₀ ∧
+      MDiffAt (fun x ↦ (trivializationAt F E (f x₀).proj (f x)).2) x₀ := by
   simpa [← mdifferentiableWithinAt_univ] using mdifferentiableWithinAt_totalSpace _ f
 
 /-- Characterization of differentiable sections of a vector bundle at a point within a set
 in terms of the preferred trivialization at that point. -/
 theorem mdifferentiableWithinAt_section (s : Π b, E b) {u : Set B} {b₀ : B} :
-    MDifferentiableWithinAt IB (IB.prod 𝓘(𝕜, F)) (fun b ↦ TotalSpace.mk' F b (s b)) u b₀ ↔
+    MDifferentiableWithinAt IB (IB.prod 𝓘(𝕜, F)) (T% s) u b₀ ↔
       MDifferentiableWithinAt IB 𝓘(𝕜, F) (fun b ↦ (trivializationAt F E b₀ (s b)).2) u b₀ := by
   rw [mdifferentiableWithinAt_totalSpace]
   change MDifferentiableWithinAt _ _ id _ _ ∧ _ ↔ _
@@ -80,8 +81,7 @@ theorem mdifferentiableWithinAt_section (s : Π b, E b) {u : Set B} {b₀ : B} :
 /-- Characterization of differentiable sections of a vector bundle at a point within a set
 in terms of the preferred trivialization at that point. -/
 theorem mdifferentiableAt_section (s : Π b, E b) {b₀ : B} :
-    MDifferentiableAt IB (IB.prod 𝓘(𝕜, F)) (fun b ↦ TotalSpace.mk' F b (s b)) b₀ ↔
-      MDifferentiableAt IB 𝓘(𝕜, F) (fun b ↦ (trivializationAt F E b₀ (s b)).2) b₀ := by
+    MDiffAt (T% s) b₀ ↔ MDiffAt (fun b ↦ (trivializationAt F E b₀ (s b)).2) b₀ := by
   simpa [← mdifferentiableWithinAt_univ] using mdifferentiableWithinAt_section _ _
 
 namespace Bundle
@@ -108,7 +108,7 @@ theorem mdifferentiableWithinAt_proj {s : Set (TotalSpace F E)} {p : TotalSpace
 variable (𝕜) [∀ x, AddCommMonoid (E x)]
 variable [∀ x, Module 𝕜 (E x)] [VectorBundle 𝕜 F E]
 
-theorem mdifferentiable_zeroSection : MDifferentiable IB (IB.prod 𝓘(𝕜, F)) (zeroSection F E) := by
+theorem mdifferentiable_zeroSection : MDiff (zeroSection F E) := by
   intro x
   unfold zeroSection
   rw [mdifferentiableAt_section]
@@ -117,16 +117,14 @@ theorem mdifferentiable_zeroSection : MDifferentiable IB (IB.prod 𝓘(𝕜, F))
     (mem_baseSet_trivializationAt F E x)] with y hy
     using congr_arg Prod.snd <| (trivializationAt F E x).zeroSection 𝕜 hy
 
-theorem mdifferentiableOn_zeroSection {t : Set B} :
-    MDifferentiableOn IB (IB.prod 𝓘(𝕜, F)) (zeroSection F E) t :=
+theorem mdifferentiableOn_zeroSection {t : Set B} : MDiff[t] (zeroSection F E) :=
   (mdifferentiable_zeroSection _ _).mdifferentiableOn
 
-theorem mdifferentiableAt_zeroSection {x : B} :
-    MDifferentiableAt IB (IB.prod 𝓘(𝕜, F)) (zeroSection F E) x :=
+theorem mdifferentiableAt_zeroSection {x : B} : MDiffAt (zeroSection F E) x :=
   (mdifferentiable_zeroSection _ _).mdifferentiableAt
 
 theorem mdifferentiableWithinAt_zeroSection {t : Set B} {x : B} :
-    MDifferentiableWithinAt IB (IB.prod 𝓘(𝕜, F)) (zeroSection F E) t x :=
+    MDiffAt[t] (zeroSection F E) x :=
   (mdifferentiable_zeroSection _ _ x).mdifferentiableWithinAt
 
 end Bundle
@@ -157,14 +155,14 @@ theorem mdifferentiableAt_coordChangeL {x : B}
 
 variable {s : Set M} {f : M → B} {g : M → F} {x : M}
 
-protected theorem MDifferentiableWithinAt.coordChangeL (hf : MDifferentiableWithinAt IM IB f s x)
+protected theorem MDifferentiableWithinAt.coordChangeL (hf : MDiffAt[s] f x)
     (he : f x ∈ e.baseSet) (he' : f x ∈ e'.baseSet) :
     MDifferentiableWithinAt IM 𝓘(𝕜, F →L[𝕜] F)
       (fun y ↦ (e.coordChangeL 𝕜 e' (f y) : F →L[𝕜] F)) s x :=
   (mdifferentiableAt_coordChangeL he he').comp_mdifferentiableWithinAt _ hf
 
 protected theorem MDifferentiableAt.coordChangeL
-    (hf : MDifferentiableAt IM IB f x) (he : f x ∈ e.baseSet) (he' : f x ∈ e'.baseSet) :
+    (hf : MDiffAt f x) (he : f x ∈ e.baseSet) (he' : f x ∈ e'.baseSet) :
     MDifferentiableAt IM 𝓘(𝕜, F →L[𝕜] F) (fun y ↦ (e.coordChangeL 𝕜 e' (f y) : F →L[𝕜] F)) x :=
   MDifferentiableWithinAt.coordChangeL hf he he'
 
@@ -174,14 +172,14 @@ protected theorem MDifferentiableOn.coordChangeL
   fun x hx ↦ (hf x hx).coordChangeL (he hx) (he' hx)
 
 protected theorem MDifferentiable.coordChangeL
-    (hf : MDifferentiable IM IB f) (he : ∀ x, f x ∈ e.baseSet) (he' : ∀ x, f x ∈ e'.baseSet) :
+    (hf : MDiff f) (he : ∀ x, f x ∈ e.baseSet) (he' : ∀ x, f x ∈ e'.baseSet) :
     MDifferentiable IM 𝓘(𝕜, F →L[𝕜] F) (fun y ↦ (e.coordChangeL 𝕜 e' (f y) : F →L[𝕜] F)) := fun x ↦
   (hf x).coordChangeL (he x) (he' x)
 
 protected theorem MDifferentiableWithinAt.coordChange
-    (hf : MDifferentiableWithinAt IM IB f s x) (hg : MDifferentiableWithinAt IM 𝓘(𝕜, F) g s x)
+    (hf : MDiffAt[s] f x) (hg : MDiffAt[s] g x)
     (he : f x ∈ e.baseSet) (he' : f x ∈ e'.baseSet) :
-    MDifferentiableWithinAt IM 𝓘(𝕜, F) (fun y ↦ e.coordChange e' (f y) (g y)) s x := by
+    MDiffAt[s] (fun y ↦ e.coordChange e' (f y) (g y)) x := by
   refine ((hf.coordChangeL he he').clm_apply hg).congr_of_eventuallyEq ?_ ?_
   · have : e.baseSet ∩ e'.baseSet ∈ 𝓝 (f x) :=
      (e.open_baseSet.inter e'.open_baseSet).mem_nhds ⟨he, he'⟩
@@ -190,21 +188,20 @@ protected theorem MDifferentiableWithinAt.coordChange
   · exact (Trivialization.coordChangeL_apply' e e' ⟨he, he'⟩ (g x)).symm
 
 protected theorem MDifferentiableAt.coordChange
-    (hf : MDifferentiableAt IM IB f x) (hg : MDifferentiableAt IM 𝓘(𝕜, F) g x)
+    (hf : MDiffAt f x) (hg : MDiffAt g x)
     (he : f x ∈ e.baseSet) (he' : f x ∈ e'.baseSet) :
-    MDifferentiableAt IM 𝓘(𝕜, F) (fun y ↦ e.coordChange e' (f y) (g y)) x :=
+    MDiffAt (fun y ↦ e.coordChange e' (f y) (g y)) x :=
   MDifferentiableWithinAt.coordChange hf hg he he'
 
 protected theorem MDifferentiableOn.coordChange
-    (hf : MDifferentiableOn IM IB f s) (hg : MDifferentiableOn IM 𝓘(𝕜, F) g s)
+    (hf : MDiff[s] f) (hg : MDiff[s] g)
     (he : MapsTo f s e.baseSet) (he' : MapsTo f s e'.baseSet) :
-    MDifferentiableOn IM 𝓘(𝕜, F) (fun y ↦ e.coordChange e' (f y) (g y)) s := fun x hx ↦
+    MDiff[s] (fun y ↦ e.coordChange e' (f y) (g y)) := fun x hx ↦
   (hf x hx).coordChange (hg x hx) (he hx) (he' hx)
 
 protected theorem MDifferentiable.coordChange
-    (hf : MDifferentiable IM IB f) (hg : MDifferentiable IM 𝓘(𝕜, F) g)
-    (he : ∀ x, f x ∈ e.baseSet) (he' : ∀ x, f x ∈ e'.baseSet) :
-    MDifferentiable IM 𝓘(𝕜, F) (fun y ↦ e.coordChange e' (f y) (g y)) := fun x ↦
+    (hf : MDiff f) (hg : MDiff g) (he : ∀ x, f x ∈ e.baseSet) (he' : ∀ x, f x ∈ e'.baseSet) :
+    MDiff (fun y ↦ e.coordChange e' (f y) (g y)) := fun x ↦
   (hf x).coordChange (hg x) (he x) (he' x)
 
 end coordChange
@@ -216,10 +213,9 @@ lemma MDifferentiableWithinAt.change_section_trivialization
     {e : Trivialization F TotalSpace.proj} [MemTrivializationAtlas e]
     {e' : Trivialization F TotalSpace.proj} [MemTrivializationAtlas e']
     {f : M → TotalSpace F E} {s : Set M} {x₀ : M}
-    (hf : MDifferentiableWithinAt IM IB (π F E ∘ f) s x₀)
-    (he'f : MDifferentiableWithinAt IM 𝓘(𝕜, F) (fun x ↦ (e (f x)).2) s x₀)
+    (hf : MDiffAt[s] (π F E ∘ f) x₀) (he'f : MDiffAt[s] (fun x ↦ (e (f x)).2) x₀)
     (he : f x₀ ∈ e.source) (he' : f x₀ ∈ e'.source) :
-    MDifferentiableWithinAt IM 𝓘(𝕜, F) (fun x ↦ (e' (f x)).2) s x₀ := by
+    MDiffAt[s] (fun x ↦ (e' (f x)).2) x₀ := by
   rw [Trivialization.mem_source] at he he'
   refine (hf.coordChange he'f he he').congr_of_eventuallyEq ?_ ?_
   · filter_upwards [hf.continuousWithinAt (e.open_baseSet.mem_nhds he)] with y hy
@@ -232,9 +228,8 @@ theorem mdifferentiableWithinAt_snd_comp_iff₂
     {e e' : Trivialization F TotalSpace.proj} [MemTrivializationAtlas e] [MemTrivializationAtlas e']
     {f : M → TotalSpace F E} {s : Set M} {x₀ : M}
     (hex₀ : f x₀ ∈ e.source) (he'x₀ : f x₀ ∈ e'.source)
-    (hf : MDifferentiableWithinAt IM IB (π F E ∘ f) s x₀) :
-    MDifferentiableWithinAt IM 𝓘(𝕜, F) (fun x ↦ (e (f x)).2) s x₀ ↔
-    MDifferentiableWithinAt IM 𝓘(𝕜, F) (fun x ↦ (e' (f x)).2) s x₀ :=
+    (hf : MDiffAt[s] (π F E ∘ f) x₀) :
+    MDiffAt[s] (fun x ↦ (e (f x)).2) x₀ ↔ MDiffAt[s] (fun x ↦ (e' (f x)).2) x₀ :=
   ⟨(hf.change_section_trivialization IB · hex₀ he'x₀),
    (hf.change_section_trivialization IB · he'x₀ hex₀)⟩
 
@@ -244,9 +239,8 @@ theorem mdifferentiableAt_snd_comp_iff₂
     {e e' : Trivialization F TotalSpace.proj} [MemTrivializationAtlas e] [MemTrivializationAtlas e']
     {f : M → TotalSpace F E} {x₀ : M}
     (he : f x₀ ∈ e.source) (he' : f x₀ ∈ e'.source)
-    (hf : MDifferentiableAt IM IB (fun x ↦ (f x).proj) x₀) :
-    MDifferentiableAt IM 𝓘(𝕜, F) (fun x ↦ (e (f x)).2) x₀ ↔
-    MDifferentiableAt IM 𝓘(𝕜, F) (fun x ↦ (e' (f x)).2) x₀ := by
+    (hf : MDiffAt (fun x ↦ (f x).proj) x₀) :
+    MDiffAt (fun x ↦ (e (f x)).2) x₀ ↔ MDiffAt (fun x ↦ (e' (f x)).2) x₀ := by
   simpa [← mdifferentiableWithinAt_univ] using
     e.mdifferentiableWithinAt_snd_comp_iff₂ IB he he' hf
 
@@ -257,9 +251,7 @@ theorem mdifferentiableWithinAt_totalSpace_iff
     (f : M → TotalSpace F E) {s : Set M} {x₀ : M}
     (he : f x₀ ∈ e.source) :
     MDifferentiableWithinAt IM (IB.prod 𝓘(𝕜, F)) f s x₀ ↔
-      MDifferentiableWithinAt IM IB (fun x => (f x).proj) s x₀ ∧
-      MDifferentiableWithinAt IM 𝓘(𝕜, F)
-        (fun x ↦ (e (f x)).2) s x₀ := by
+      MDiffAt[s] (fun x => (f x).proj) x₀ ∧ MDiffAt[s] (fun x ↦ (e (f x)).2) x₀ := by
   rw [mdifferentiableWithinAt_totalSpace]
   apply and_congr_right
   intro hf
@@ -273,9 +265,7 @@ theorem mdifferentiableAt_totalSpace_iff
     (f : M → TotalSpace F E) {x₀ : M}
     (he : f x₀ ∈ e.source) :
     MDifferentiableAt IM (IB.prod 𝓘(𝕜, F)) f x₀ ↔
-      MDifferentiableAt IM IB (fun x => (f x).proj) x₀ ∧
-      MDifferentiableAt IM 𝓘(𝕜, F)
-        (fun x ↦ (e (f x)).2) x₀ := by
+      MDiffAt (fun x => (f x).proj) x₀ ∧ MDiffAt (fun x ↦ (e (f x)).2) x₀ := by
   rw [mdifferentiableAt_totalSpace]
   apply and_congr_right
   intro hf
@@ -288,8 +278,7 @@ theorem mdifferentiableWithinAt_section_iff
     (e : Trivialization F (TotalSpace.proj : TotalSpace F E → B)) [MemTrivializationAtlas e]
     (s : Π b : B, E b) {u : Set B} {b₀ : B}
     (hex₀ : b₀ ∈ e.baseSet) :
-    MDifferentiableWithinAt IB (IB.prod 𝓘(𝕜, F)) (fun b ↦ TotalSpace.mk' F b (s b)) u b₀ ↔
-      MDifferentiableWithinAt IB 𝓘(𝕜, F) (fun x ↦ (e (s x)).2) u b₀ := by
+    MDiffAt[u] (T% s) b₀ ↔ MDiffAt[u] (fun x ↦ (e (s x)).2) b₀ := by
   rw [e.mdifferentiableWithinAt_totalSpace_iff IB]
   · change MDifferentiableWithinAt IB IB id u b₀ ∧ _ ↔ _
     simp [mdifferentiableWithinAt_id]
@@ -301,8 +290,7 @@ theorem mdifferentiableAt_section_iff
     (e : Trivialization F (TotalSpace.proj : TotalSpace F E → B)) [MemTrivializationAtlas e]
     (s : Π b : B, E b) {b₀ : B}
     (hex₀ : b₀ ∈ e.baseSet) :
-    MDifferentiableAt IB (IB.prod 𝓘(𝕜, F)) (fun b ↦ TotalSpace.mk' F b (s b)) b₀ ↔
-      MDifferentiableAt IB 𝓘(𝕜, F) (fun x ↦ (e (s x)).2) b₀ := by
+    MDiffAt (T% s) b₀ ↔ MDiffAt (fun x ↦ (e (s x)).2) b₀ := by
   simpa [← mdifferentiableWithinAt_univ] using e.mdifferentiableWithinAt_section_iff IB s hex₀
 
 variable {IB} in
@@ -311,7 +299,7 @@ using any trivialisation whose `baseSet` contains `s`. -/
 theorem mdifferentiableOn_section_iff {s : ∀ x, E x} {a : Set B}
     (e : Trivialization F (Bundle.TotalSpace.proj : Bundle.TotalSpace F E → B))
     [MemTrivializationAtlas e] (ha : IsOpen a) (ha' : a ⊆ e.baseSet) :
-    MDifferentiableOn IB (IB.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x (s x)) a ↔
+    MDifferentiableOn IB (IB.prod 𝓘(𝕜, F)) (T% s) a ↔
       MDifferentiableOn IB 𝓘(𝕜, F) (fun x ↦ (e ⟨x, s x⟩).2) a := by
   refine ⟨fun h x hx ↦ ?_, fun h x hx ↦ ?_⟩ <;>
   have := (h x hx).mdifferentiableAt <| ha.mem_nhds hx
@@ -324,7 +312,7 @@ can be determined using `e`. -/
 theorem mdifferentiableOn_section_baseSet_iff {s : ∀ x, E x}
     (e : Trivialization F (Bundle.TotalSpace.proj : Bundle.TotalSpace F E → B))
     [MemTrivializationAtlas e] :
-    MDifferentiableOn IB (IB.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x (s x)) e.baseSet ↔
+    MDifferentiableOn IB (IB.prod 𝓘(𝕜, F)) (T% s) e.baseSet ↔
       MDifferentiableOn IB 𝓘(𝕜, F) (fun x ↦ (e ⟨x, s x⟩).2) e.baseSet :=
   e.mdifferentiableOn_section_iff e.open_baseSet subset_rfl
 
@@ -367,9 +355,8 @@ variable
 variable {f : B → 𝕜} {a : 𝕜} {s t : Π x : B, E x} {u : Set B} {x₀ : B}
 
 lemma mdifferentiableWithinAt_add_section
-    (hs : MDifferentiableWithinAt I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x (s x)) u x₀)
-    (ht : MDifferentiableWithinAt I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x (t x)) u x₀) :
-    MDifferentiableWithinAt I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x ((s + t) x)) u x₀ := by
+    (hs : MDiffAt[u] (T% s) x₀) (ht : MDiffAt[u] (T% t) x₀) :
+    MDiffAt[u] (T% (s + t)) x₀ := by
   rw [mdifferentiableWithinAt_section] at hs ht ⊢
   set e := trivializationAt F E x₀
   refine (hs.add ht).congr_of_eventuallyEq ?_ ?_
@@ -380,27 +367,21 @@ lemma mdifferentiableWithinAt_add_section
   · exact (e.linear 𝕜 (FiberBundle.mem_baseSet_trivializationAt' x₀)).1 ..
 
 lemma mdifferentiableAt_add_section
-    (hs : MDifferentiableAt I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x (s x)) x₀)
-    (ht : MDifferentiableAt I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x (t x)) x₀) :
-    MDifferentiableAt I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x ((s + t) x)) x₀ := by
+    (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
 
 lemma mdifferentiableOn_add_section
-    (hs : MDifferentiableOn I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x (s x)) u)
-    (ht : MDifferentiableOn I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x (t x)) u) :
-    MDifferentiableOn I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x ((s + t) x)) u :=
+    (hs : MDiff[u] (T% s)) (ht : MDiff[u] (T% t)) : MDiff[u] (T% (s + t)) :=
   fun x₀ hx₀ ↦ mdifferentiableWithinAt_add_section (hs x₀ hx₀) (ht x₀ hx₀)
 
 lemma mdifferentiable_add_section
-    (hs : MDifferentiable I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x (s x)))
-    (ht : MDifferentiable I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x (t x))) :
-    MDifferentiable I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x ((s + t) x)) :=
+    (hs : MDiff (T% s)) (ht : MDiff (T% t)) : MDiff (T% (s + t)) :=
   fun x₀ ↦ mdifferentiableAt_add_section (hs x₀) (ht x₀)
 
 lemma mdifferentiableWithinAt_neg_section
-    (hs : MDifferentiableWithinAt I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x (s x)) u x₀) :
-    MDifferentiableWithinAt I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x (- s x)) u x₀ := by
+    (hs : MDiffAt[u] (T% s) x₀) : MDiffAt[u] (T% (-s)) x₀ := by
   rw [mdifferentiableWithinAt_section] at hs ⊢
   set e := trivializationAt F E x₀
   refine hs.neg.congr_of_eventuallyEq ?_ ?_
@@ -411,51 +392,39 @@ lemma mdifferentiableWithinAt_neg_section
   · exact (e.linear 𝕜 (FiberBundle.mem_baseSet_trivializationAt' x₀)).map_neg ..
 
 lemma mdifferentiableAt_neg_section
-    (hs : MDifferentiableAt I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x (s x)) x₀) :
-    MDifferentiableAt I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x (- s x)) x₀ := by
+    (hs : MDiffAt (T% s) x₀) : MDiffAt (T% (-s)) x₀ := by
   rw [← mdifferentiableWithinAt_univ] at hs ⊢
   exact mdifferentiableWithinAt_neg_section hs
 
 lemma mdifferentiableOn_neg_section
-    (hs : MDifferentiableOn I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x (s x)) u) :
-    MDifferentiableOn I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x (-s x)) u :=
+    (hs : MDiff[u] (T% s)) : MDiff[u] (T% (-s)) :=
   fun x₀ hx₀ ↦ mdifferentiableWithinAt_neg_section (hs x₀ hx₀)
 
-lemma mdifferentiable_neg_section
-    (hs : MDifferentiable I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x (s x))) :
-    MDifferentiable I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x (-s x)) :=
+lemma mdifferentiable_neg_section (hs : MDiff (T% s)) : MDiff (T% (-s)) :=
   fun x₀ ↦ mdifferentiableAt_neg_section (hs x₀)
 
 lemma mdifferentiableWithinAt_sub_section
-    (hs : MDifferentiableWithinAt I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x (s x)) u x₀)
-    (ht : MDifferentiableWithinAt I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x (t x)) u x₀) :
-    MDifferentiableWithinAt I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x ((s - t) x)) u x₀ := by
+    (hs : MDiffAt[u] (T% s) x₀) (ht : MDiffAt[u] (T% t) x₀) :
+    MDiffAt[u] (T% (s - t)) x₀ := by
   rw [sub_eq_add_neg]
   apply mdifferentiableWithinAt_add_section hs <| mdifferentiableWithinAt_neg_section ht
 
 lemma mdifferentiableAt_sub_section
-    (hs : MDifferentiableAt I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x (s x)) x₀)
-    (ht : MDifferentiableAt I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x (t x)) x₀) :
-    MDifferentiableAt I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x ((s - t) x)) x₀ := by
+    (hs : MDiffAt (T% s) x₀) (ht : MDiffAt (T% t) x₀) :
+    MDiffAt (T% (s - t)) x₀ := by
   rw [sub_eq_add_neg]
   apply mdifferentiableAt_add_section hs <| mdifferentiableAt_neg_section ht
 
 lemma mDifferentiableOn_sub_section
-    (hs : MDifferentiableOn I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x (s x)) u)
-    (ht : MDifferentiableOn I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x (t x)) u) :
-    MDifferentiableOn I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x ((s - t) x)) u :=
+    (hs : MDiff[u] (T% s)) (ht : MDiff[u] (T% t)) : MDiff[u] (T% (s - t)) :=
   fun x₀ hx₀ ↦ mdifferentiableWithinAt_sub_section (hs x₀ hx₀) (ht x₀ hx₀)
 
 lemma mdifferentiable_sub_section
-    (hs : MDifferentiable I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x (s x)))
-    (ht : MDifferentiable I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x (t x))) :
-    MDifferentiable I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x ((s - t) x)) :=
+    (hs : MDiff (T% s)) (ht : MDiff (T% t)) : MDiff (T% (s - t)) :=
   fun x₀ ↦ mdifferentiableAt_sub_section (hs x₀) (ht x₀)
 
 lemma MDifferentiableWithinAt.smul_section
-    (hf : MDifferentiableWithinAt I 𝓘(𝕜) f u x₀)
-    (hs : MDifferentiableWithinAt I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x (s x)) u x₀) :
-    MDifferentiableWithinAt I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x (f x • s x)) u x₀ := by
+    (hf : MDiffAt[u] f x₀) (hs : MDiffAt[u] (T% s) x₀) : MDiffAt[u] (T% (f • s)) x₀ := by
   rw [mdifferentiableWithinAt_section] at hs ⊢
   set e := trivializationAt F E x₀
   refine (hf.smul hs).congr_of_eventuallyEq ?_ ?_
@@ -465,47 +434,39 @@ lemma MDifferentiableWithinAt.smul_section
     · exact fun x hx ↦ (e.linear 𝕜 hx).2 ..
   · apply (e.linear 𝕜 (FiberBundle.mem_baseSet_trivializationAt' x₀)).2
 
-lemma MDifferentiableAt.smul_section (hf : MDifferentiableAt I 𝓘(𝕜) f x₀)
-    (hs : MDifferentiableAt I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x (s x)) x₀) :
-    MDifferentiableAt I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x (f x • s x)) x₀ := by
+lemma MDifferentiableAt.smul_section
+    (hf : MDiffAt f x₀) (hs : MDiffAt (T% s) x₀) : MDiffAt (T% (f • s)) x₀ := by
   rw [← mdifferentiableWithinAt_univ] at hs ⊢
   exact .smul_section hf hs
 
-lemma MDifferentiableOn.smul_section (hf : MDifferentiableOn I 𝓘(𝕜) f u)
-    (hs : MDifferentiableOn I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x (s x)) u) :
-    MDifferentiableOn I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x (f x • s x)) u :=
+lemma MDifferentiableOn.smul_section
+    (hf : MDiff[u] f) (hs : MDiff[u] (T% s)) : MDiff[u] (T% (f • s)) :=
   fun x₀ hx₀ ↦ .smul_section (hf x₀ hx₀) (hs x₀ hx₀)
 
-lemma mdifferentiable_smul_section (hf : MDifferentiable I 𝓘(𝕜) f)
-    (hs : MDifferentiable I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x (s x))) :
-    MDifferentiable I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x (f x • s x)) :=
+lemma mdifferentiable_smul_section
+    (hf : MDiff f) (hs : MDiff (T% s)) : MDiff (T% (f • s)) :=
   fun x₀ ↦ (hf x₀).smul_section (hs x₀)
 
 lemma mdifferentiableWithinAt_smul_const_section
-    (hs : MDifferentiableWithinAt I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x (s x)) u x₀) :
-    MDifferentiableWithinAt I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x (a • s x)) u x₀ :=
+    (hs : MDiffAt[u] (T% s) x₀) :
+    MDiffAt[u] (T% (a • s)) x₀ :=
   .smul_section mdifferentiableWithinAt_const hs
 
 lemma MDifferentiableAt.smul_const_section
-    (hs : MDifferentiableAt I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x (s x)) x₀) :
-    MDifferentiableAt I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x (a • s x)) x₀ :=
+    (hs : MDiffAt (T% s) x₀) : MDiffAt (T% (a • s)) x₀ :=
   .smul_section mdifferentiableAt_const hs
 
 lemma MDifferentiableOn.smul_const_section
-    (hs : MDifferentiableOn I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x (s x)) u) :
-    MDifferentiableOn I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x (a • s x)) u :=
+    (hs : MDiff[u] (T% s)) : MDiff[u] (T% (a • s)) :=
   .smul_section mdifferentiableOn_const hs
 
 lemma mdifferentiable_smul_const_section
-    (hs : MDifferentiable I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x (s x))) :
-    MDifferentiable I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x (a • s x)) :=
+    (hs : MDiff (T% s)) : MDiff (T% (a • s)) :=
   fun x₀ ↦ (hs x₀).smul_const_section
 
 lemma MDifferentiableWithinAt.sum_section {ι : Type*} {s : Finset ι} {t : ι → (x : B) → E x}
-    (hs : ∀ i, MDifferentiableWithinAt I (I.prod 𝓘(𝕜, F))
-                 (fun x ↦ TotalSpace.mk' F x (t i x)) u x₀) :
-    MDifferentiableWithinAt I (I.prod 𝓘(𝕜, F))
-      (fun x ↦ TotalSpace.mk' F x (∑ i ∈ s, (t i x))) u x₀ := by
+    (hs : ∀ i, MDiffAt[u] (T% (t i ·)) x₀) :
+    MDiffAt[u] (fun x ↦ TotalSpace.mk' F x (∑ i ∈ s, (t i x))) x₀ := by
   classical
   induction s using Finset.induction_on with
   | empty => simpa using (contMDiffWithinAt_zeroSection 𝕜 E).mdifferentiableWithinAt one_ne_zero
@@ -513,19 +474,19 @@ lemma MDifferentiableWithinAt.sum_section {ι : Type*} {s : Finset ι} {t : ι 
     simpa [Finset.sum_insert hi] using mdifferentiableWithinAt_add_section (hs i) h
 
 lemma MDifferentiableAt.sum_section {ι : Type*} {s : Finset ι} {t : ι → (x : B) → E x} {x₀ : B}
-    (hs : ∀ i, MDifferentiableAt I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x (t i x)) x₀) :
-    MDifferentiableAt I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x (∑ i ∈ s, (t i x))) x₀ := by
+    (hs : ∀ i, MDiffAt (T% (t i ·)) x₀) :
+    MDiffAt (fun x ↦ TotalSpace.mk' F x (∑ i ∈ s, (t i x))) x₀ := by
   simp_rw [← mdifferentiableWithinAt_univ] at hs ⊢
   exact MDifferentiableWithinAt.sum_section hs
 
 lemma MDifferentiableOn.sum_section {ι : Type*} {s : Finset ι} {t : ι → (x : B) → E x}
-    (hs : ∀ i, MDifferentiableOn I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x (t i x)) u) :
-    MDifferentiableOn I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x (∑ i ∈ s, (t i x))) u :=
+    (hs : ∀ i, MDiff[u] (T% (t i ·))) :
+    MDiff[u] (fun x ↦ TotalSpace.mk' F x (∑ i ∈ s, (t i x))) :=
   fun x₀ hx₀ ↦ .sum_section fun i ↦ hs i x₀ hx₀
 
 lemma MDifferentiable.sum_section {ι : Type*} {s : Finset ι} {t : ι → (x : B) → E x}
-    (hs : ∀ i, MDifferentiable I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x (t i x))) :
-    MDifferentiable I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x (∑ i ∈ s, (t i x))) :=
+    (hs : ∀ i, MDiff (T% (t i ·))) :
+    MDiff (fun x ↦ TotalSpace.mk' F x (∑ i ∈ s, (t i x))) :=
   fun x₀ ↦ .sum_section fun i ↦ (hs i) x₀
 
 /-- The scalar product `ψ • s` of a differentiable function `ψ : M → 𝕜` and a section `s` of a
@@ -534,9 +495,8 @@ vector bundle `V → M` is differentiable once `s` is differentiable on an open
 
 See `ContMDiffOn.smul_section_of_tsupport` for the analogous result about `C^n` sections. -/
 lemma MDifferentiableOn.smul_section_of_tsupport {s : Π (x : B), E x} {ψ : B → 𝕜}
-    (hψ : MDifferentiableOn I 𝓘(𝕜) ψ u) (ht : IsOpen u) (ht' : tsupport ψ ⊆ u)
-    (hs : MDifferentiableOn I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x (s x)) u) :
-    MDifferentiable I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x (ψ x • s x)) := by
+    (hψ : MDiff[u] ψ) (ht : IsOpen u) (ht' : tsupport ψ ⊆ u) (hs : MDiff[u] (T% s)) :
+    MDiff (T% (ψ • s)) := by
   apply mdifferentiable_of_mdifferentiableOn_union_of_isOpen (hψ.smul_section hs) ?_ ?_ ht
       (isOpen_compl_iff.mpr <| isClosed_tsupport ψ)
   · apply ((mdifferentiable_zeroSection _ _).mdifferentiableOn (s := (tsupport ψ)ᶜ)).congr
@@ -552,18 +512,15 @@ open Function
 Version at a point within a set. -/
 lemma MDifferentiableWithinAt.sum_section_of_locallyFinite
     (ht : LocallyFinite fun i ↦ {x : B | t i x ≠ 0})
-    (ht' : ∀ i, MDifferentiableWithinAt I (I.prod 𝓘(𝕜, F))
-      (fun x ↦ TotalSpace.mk' F x (t i x)) u x₀) :
-    MDifferentiableWithinAt I (I.prod 𝓘(𝕜, F))
-      (fun x ↦ TotalSpace.mk' F x (∑' i, (t i x))) u x₀ := by
+    (ht' : ∀ i, MDiffAt[u] (T% (t i ·)) x₀) :
+    MDiffAt[u] (fun x ↦ TotalSpace.mk' F x (∑' i, (t i x))) x₀ := by
   obtain ⟨u', hu', hfin⟩ := ht x₀
   -- All sections `t i` but a finite set `s` vanish near `x₀`: choose a neighbourhood `u` of `x₀`
   -- and a finite set `s` of sections which don't vanish.
   let s := {i | ((fun i ↦ {x | t i x ≠ 0}) i ∩ u').Nonempty}
   have := hfin.fintype
-  have : MDifferentiableWithinAt I (I.prod 𝓘(𝕜, F))
-      (fun x ↦ TotalSpace.mk' F x (∑ i ∈ s, (t i x))) (u ∩ u') x₀ :=
-     MDifferentiableWithinAt.sum_section fun i ↦ ((ht' i).mono inter_subset_left)
+  have : MDiffAt[u ∩ u'] (fun x ↦ TotalSpace.mk' F x (∑ i ∈ s, (t i x))) x₀ :=
+     .sum_section fun i ↦ ((ht' i).mono inter_subset_left)
   apply (mdifferentiableWithinAt_inter hu').mp
   apply this.congr' (fun y hy ↦ ?_) inter_subset_right (mem_of_mem_nhds hu')
   rw [TotalSpace.mk_inj, tsum_eq_sum']
@@ -580,8 +537,8 @@ lemma MDifferentiableWithinAt.sum_section_of_locallyFinite
 if each section is. -/
 lemma MDifferentiableAt.sum_section_of_locallyFinite
     (ht : LocallyFinite fun i ↦ {x : B | t i x ≠ 0})
-    (ht' : ∀ i, MDifferentiableAt I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x (t i x)) x₀) :
-    MDifferentiableAt I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x (∑' i, (t i x))) x₀ := by
+    (ht' : ∀ i, MDiffAt (T% (t i ·)) x₀) :
+    MDiffAt (fun x ↦ TotalSpace.mk' F x (∑' i, (t i x))) x₀ := by
   simp_rw [← mdifferentiableWithinAt_univ] at ht' ⊢
   exact .sum_section_of_locallyFinite ht ht'
 
@@ -589,22 +546,20 @@ lemma MDifferentiableAt.sum_section_of_locallyFinite
 if each section is. -/
 lemma MDifferentiableOn.sum_section_of_locallyFinite
     (ht : LocallyFinite fun i ↦ {x : B | t i x ≠ 0})
-    (ht' : ∀ i, MDifferentiableOn I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x (t i x)) u) :
-    MDifferentiableOn I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x (∑' i, (t i x))) u :=
+    (ht' : ∀ i, MDiff[u] (T% (t i ·))) :
+    MDiff[u] (fun x ↦ TotalSpace.mk' F x (∑' i, (t i x))) :=
   fun x hx ↦ .sum_section_of_locallyFinite ht (ht' · x hx)
 
 /-- The sum of a locally finite collection of sections is differentiable if each section is. -/
 lemma MDifferentiable.sum_section_of_locallyFinite (ht : LocallyFinite fun i ↦ {x : B | t i x ≠ 0})
-    (ht' : ∀ i, MDifferentiable I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x (t i x))) :
-    MDifferentiable I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x (∑' i, (t i x))) :=
+    (ht' : ∀ i, MDiff (T% (t i ·))) :
+    MDiff (fun x ↦ TotalSpace.mk' F x (∑' i, (t i x))) :=
   fun x ↦ .sum_section_of_locallyFinite ht fun i ↦ ht' i x
 
 lemma MDifferentiableWithinAt.finsum_section_of_locallyFinite
     (ht : LocallyFinite fun i ↦ {x : B | t i x ≠ 0})
-    (ht' : ∀ i, MDifferentiableWithinAt I (I.prod 𝓘(𝕜, F))
-      (fun x ↦ TotalSpace.mk' F x (t i x)) u x₀) :
-    MDifferentiableWithinAt I (I.prod 𝓘(𝕜, F))
-      (fun x ↦ TotalSpace.mk' F x (∑ᶠ i, t i x)) u x₀ := by
+    (ht' : ∀ i, MDiffAt[u] (T% (t i ·)) x₀) :
+    MDiffAt[u] (fun x ↦ TotalSpace.mk' F x (∑ᶠ i, t i x)) x₀ := by
   apply (MDifferentiableWithinAt.sum_section_of_locallyFinite ht ht').congr' (t := Set.univ)
       (fun y hy ↦ ?_) (by grind) trivial
   choose U hu hfin using ht y
@@ -617,21 +572,19 @@ lemma MDifferentiableWithinAt.finsum_section_of_locallyFinite
 
 lemma MDifferentiableAt.finsum_section_of_locallyFinite
     (ht : LocallyFinite fun i ↦ {x : B | t i x ≠ 0})
-    (ht' : ∀ i, MDifferentiableAt I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x (t i x)) x₀) :
-    MDifferentiableAt I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x (∑ᶠ i, t i x)) x₀ := by
+    (ht' : ∀ i, MDiffAt (T% (t i ·)) x₀) :
+    MDiffAt (fun x ↦ TotalSpace.mk' F x (∑ᶠ i, t i x)) x₀ := by
   simp_rw [← mdifferentiableWithinAt_univ] at ht' ⊢
   exact .finsum_section_of_locallyFinite ht ht'
 
 lemma MDifferentiableOn.finsum_section_of_locallyFinite
-    (ht : LocallyFinite fun i ↦ {x : B | t i x ≠ 0})
-    (ht' : ∀ i, MDifferentiableOn I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x (t i x)) u) :
-    MDifferentiableOn I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x (∑ᶠ i, t i x)) u :=
+    (ht : LocallyFinite fun i ↦ {x : B | t i x ≠ 0}) (ht' : ∀ i, MDiff[u] (T% (t i ·))) :
+    MDiff[u] (fun x ↦ TotalSpace.mk' F x (∑ᶠ i, t i x)) :=
   fun x hx ↦ .finsum_section_of_locallyFinite ht fun i ↦ ht' i x hx
 
 lemma MDifferentiable.finsum_section_of_locallyFinite
-    (ht : LocallyFinite fun i ↦ {x : B | t i x ≠ 0})
-    (ht' : ∀ i, MDifferentiable I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x (t i x))) :
-    MDifferentiable I (I.prod 𝓘(𝕜, F)) (fun x ↦ TotalSpace.mk' F x (∑ᶠ i, t i x)) :=
+    (ht : LocallyFinite fun i ↦ {x : B | t i x ≠ 0}) (ht' : ∀ i, MDiff (T% (t i ·))) :
+    MDiff (fun x ↦ TotalSpace.mk' F x (∑ᶠ i, t i x)) :=
   fun x ↦ .finsum_section_of_locallyFinite ht fun i ↦ ht' i x
 
 end operations
@@ -680,7 +633,7 @@ lemma MDifferentiableWithinAt.clm_apply_of_inCoordinates
     (hϕ : MDifferentiableWithinAt IM 𝓘(𝕜, F₁ →L[𝕜] F₂)
       (fun m ↦ inCoordinates F₁ E₁ F₂ E₂ (b₁ m₀) (b₁ m) (b₂ m₀) (b₂ m) (ϕ m)) s m₀)
     (hv : MDifferentiableWithinAt IM (IB₁.prod 𝓘(𝕜, F₁)) (fun m ↦ (v m : TotalSpace F₁ E₁)) s m₀)
-    (hb₂ : MDifferentiableWithinAt IM IB₂ b₂ s m₀) :
+    (hb₂ : MDiffAt[s] b₂ m₀) :
     MDifferentiableWithinAt IM (IB₂.prod 𝓘(𝕜, F₂))
       (fun m ↦ (ϕ m (v m) : TotalSpace F₂ E₂)) s m₀ := by
   rw [mdifferentiableWithinAt_totalSpace] at hv ⊢
@@ -715,7 +668,7 @@ lemma MDifferentiableAt.clm_apply_of_inCoordinates
     (hϕ : MDifferentiableAt IM 𝓘(𝕜, F₁ →L[𝕜] F₂)
       (fun m ↦ inCoordinates F₁ E₁ F₂ E₂ (b₁ m₀) (b₁ m) (b₂ m₀) (b₂ m) (ϕ m)) m₀)
     (hv : MDifferentiableAt IM (IB₁.prod 𝓘(𝕜, F₁)) (fun m ↦ (v m : TotalSpace F₁ E₁)) m₀)
-    (hb₂ : MDifferentiableAt IM IB₂ b₂ m₀) :
+    (hb₂ : MDiffAt b₂ m₀) :
     MDifferentiableAt IM (IB₂.prod 𝓘(𝕜, F₂)) (fun m ↦ (ϕ m (v m) : TotalSpace F₂ E₂)) m₀ := by
   rw [← mdifferentiableWithinAt_univ] at hϕ hv hb₂ ⊢
   exact MDifferentiableWithinAt.clm_apply_of_inCoordinates hϕ hv hb₂
diff --git a/Mathlib/Geometry/Manifold/VectorBundle/Misc.lean b/Mathlib/Geometry/Manifold/VectorBundle/Misc.lean
new file mode 100644
index 00000000000000..f751f402d1a17a
--- /dev/null
+++ b/Mathlib/Geometry/Manifold/VectorBundle/Misc.lean
@@ -0,0 +1,152 @@
+/-
+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 -- Building continuous bilinear maps
+
+structure IsBilinearMap (R : Type*) {E F G : Type*} [Semiring R]
+  [AddCommMonoid E] [AddCommMonoid F] [AddCommMonoid G]
+  [Module R E] [Module R F] [Module R G] (f : E → F → G) : Prop where
+  add_left : ∀ (x₁ x₂ : E) (y : F), f (x₁ + x₂) y = f x₁ y + f x₂ y
+  smul_left : ∀ (c : R) (x : E) (y : F), f (c • x) y = c • f x y
+  add_right : ∀ (x : E) (y₁ y₂ : F), f x (y₁ + y₂) = f x y₁ + f x y₂
+  smul_right : ∀ (c : R) (x : E) (y : F), f x (c • y) = c • f x y
+
+def IsBilinearMap.toLinearMap {R : Type*} {E F G : Type*} [CommSemiring R]
+    [AddCommMonoid E] [AddCommMonoid F] [AddCommMonoid G]
+    [Module R E] [Module R F] [Module R G] {f : E → F → G} (hf : IsBilinearMap R f) :
+    E →ₗ[R] F →ₗ[R] G :=
+  LinearMap.mk₂ _ f hf.add_left hf.smul_left hf.add_right hf.smul_right
+
+lemma isBilinearMap_eval (R : Type*) (E F : Type*) [CommSemiring R]
+    [AddCommMonoid E] [AddCommMonoid F] [Module R E] [Module R F] :
+    IsBilinearMap R (fun (e : E) (φ : E →ₗ[R] F) ↦ φ e) := by
+  constructor <;> simp
+
+def IsBilinearMap.toContinuousLinearMap
+    {𝕜 : Type*} [NontriviallyNormedField 𝕜] [CompleteSpace 𝕜]
+    {E : Type*} [AddCommGroup E] [Module 𝕜 E] [TopologicalSpace E]
+    [IsTopologicalAddGroup E] [ContinuousSMul 𝕜 E] [FiniteDimensional 𝕜 E]
+    [T2Space E]
+    {F : Type*} [AddCommGroup F] [Module 𝕜 F] [TopologicalSpace F]
+    [IsTopologicalAddGroup F] [ContinuousSMul 𝕜 F] [FiniteDimensional 𝕜 F]
+    [T2Space F]
+    {G : Type*} [AddCommGroup G] [Module 𝕜 G] [TopologicalSpace G]
+    [IsTopologicalAddGroup G] [ContinuousSMul 𝕜 G]
+    {f : E → F → G} (h : IsBilinearMap 𝕜 f) : E →L[𝕜] F →L[𝕜] G :=
+  IsLinearMap.mk' (fun x : E ↦ h.toLinearMap x |>.toContinuousLinearMap)
+      (by constructor <;> (intros;simp)) |>.toContinuousLinearMap
+
+def isBilinearMap_evalL
+    (𝕜 : Type*) [NontriviallyNormedField 𝕜] [CompleteSpace 𝕜]
+    (E : Type*) [AddCommGroup E] [Module 𝕜 E] [TopologicalSpace E]
+    [IsTopologicalAddGroup E] [ContinuousSMul 𝕜 E] [FiniteDimensional 𝕜 E]
+    [T2Space E]
+    (F : Type*) [AddCommGroup F] [Module 𝕜 F] [TopologicalSpace F]
+    [IsTopologicalAddGroup F] [ContinuousSMul 𝕜 F] [FiniteDimensional 𝕜 F]
+    [T2Space F] :
+    IsBilinearMap 𝕜 (fun (e : E) (φ : E →L[𝕜] F) ↦ φ e) := by
+  constructor <;> simp
+
+def evalL
+    (𝕜 : Type*) [NontriviallyNormedField 𝕜] [CompleteSpace 𝕜]
+    (E : Type*) [AddCommGroup E] [Module 𝕜 E] [TopologicalSpace E]
+    [IsTopologicalAddGroup E] [ContinuousSMul 𝕜 E] [FiniteDimensional 𝕜 E]
+    [T2Space E]
+    (F : Type*) [AddCommGroup F] [Module 𝕜 F] [TopologicalSpace F]
+    [IsTopologicalAddGroup F] [ContinuousSMul 𝕜 F] [FiniteDimensional 𝕜 F]
+    [T2Space F] : E →L[𝕜] (E →L[𝕜] F) →L[𝕜] F :=
+  (isBilinearMap_evalL 𝕜 E F).toContinuousLinearMap
+end
+
+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] [IsManifold I 0 M]
+
+variable {E' : Type*} [NormedAddCommGroup E'] [NormedSpace 𝕜 E']
+
+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)] [∀ x, IsTopologicalAddGroup (V x)]
+  [∀ x, ContinuousSMul 𝕜 (V x)]
+  [FiberBundle F V] [VectorBundle 𝕜 F V]
+  -- `V` vector bundle
+
+set_option backward.isDefEq.respectTransparency false in
+def bar (a : 𝕜) : TangentSpace 𝓘(𝕜) a ≃L[𝕜] 𝕜 where
+  toFun v := v
+  invFun v := v
+  map_add' := by simp
+  map_smul' := by simp
+
+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]
+
+attribute [simp] mdifferentiableAt_iff_differentiableAt
+
+lemma FiberBundle.trivializationAt.baseSet_mem_nhds {B : Type*} (F : Type*)
+    [TopologicalSpace B] [TopologicalSpace F]
+    (E : B → Type*) [TopologicalSpace (TotalSpace F E)] [(b : B) → TopologicalSpace (E b)]
+    [FiberBundle F E] (b : B) : (trivializationAt F E b |>.baseSet) ∈ 𝓝 b :=
+  (trivializationAt F E b).open_baseSet.eventually_mem (FiberBundle.mem_baseSet_trivializationAt' b)
+
+omit [IsManifold I 0 M] [∀ (x : M), IsTopologicalAddGroup (V x)] [(x : M) → Module 𝕜 (V x)]
+     [(x : M) → AddCommGroup (V x)]
+     [∀ (x : M), ContinuousSMul 𝕜 (V x)] [VectorBundle 𝕜 F V] in
+variable {I F V x} in
+/-- 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} {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]
+
+omit [IsManifold I 0 M] [∀ (x : M), IsTopologicalAddGroup (V x)] [(x : M) → Module 𝕜 (V x)]
+     [∀ (x : M), ContinuousSMul 𝕜 (V x)] [VectorBundle 𝕜 F V] [(x : M) → AddCommGroup (V x)] in
+variable {I F V x} in
+/-- 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} {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/VectorBundle/OrthonormalFrame.lean b/Mathlib/Geometry/Manifold/VectorBundle/OrthonormalFrame.lean
new file mode 100644
index 00000000000000..40bbe8f86cc012
--- /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 [Finite ι] (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 := Fintype.ofFinite ι
+  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}
+
+variable (b e) in
+/-- The orthonormal frame associated to the basis `b` and the trivialisation `e`:
+this is obtained by applying the Gram-Schmidt orthonormalisation procedure to `b.localFrame e`.
+In particular, if x is outside of `e.baseSet`, this returns the junk value 0. -/
+noncomputable def orthonormalFrame : ι → (x : B) → E x :=
+  VectorBundle.gramSchmidtNormed (e.localFrame b)
+
+omit [IsManifold IB n B] in
+variable (b e) in
+/-- An orthonormal frame w.r.t. a local trivialisation is an orthonormal local frame. -/
+lemma orthonormalFrame_isOrthonormalFrameOn :
+    IsOrthonormalFrameOn IB F n (b.orthonormalFrame e) e.baseSet :=
+  (e.isLocalFrameOn_localFrame_baseSet IB n b).gramSchmidtNormed
+
+omit [IsManifold IB n B] in
+variable (b e) in
+/-- Each orthonormal frame `s^i ∈ Γ(E)` of a `C^k` vector bundle, defined by a local
+trivialisation `e`, is `C^k` on `e.baseSet`. -/
+lemma contMDiffOn_orthonormalFrame_baseSet (i : ι) :
+    CMDiff[e.baseSet] n (T% (b.orthonormalFrame e i)) := by
+  apply IsLocalFrameOn.contMDiffOn
+  exact (b.orthonormalFrame_isOrthonormalFrameOn e).toIsLocalFrameOn
+
+omit [IsManifold IB n B] in
+variable (b e) in
+lemma _root_.contMDiffAt_orthonormalFrame_of_mem (i : ι) {x : B} (hx : x ∈ e.baseSet) :
+    CMDiffAt n (T% (b.orthonormalFrame e i)) x :=
+  -- bug: if I change this to a by apply, and put #check after the `by`, it works, but #check' fails
+  -- #check' contMDiffOn_orthonormalFrame_baseSet
+  (contMDiffOn_orthonormalFrame_baseSet b e i).contMDiffAt <| e.open_baseSet.mem_nhds hx
+
+-- TODO: add more variants with mdifferentiable!
+omit [ContMDiffVectorBundle n F E IB] [IsContMDiffRiemannianBundle IB n F E] in
+variable [ContMDiffVectorBundle 1 F E IB] [IsContMDiffRiemannianBundle IB 1 F E] in
+variable (b e) in
+lemma _root_.mdifferentiableAt_orthonormalFrame_of_mem (i : ι) {x : B} (hx : x ∈ e.baseSet) :
+    MDiffAt (T% (b.orthonormalFrame e i)) x := by
+  apply ContMDiffAt.mdifferentiableAt _ one_ne_zero
+  exact (contMDiffOn_orthonormalFrame_baseSet b e i).contMDiffAt <| e.open_baseSet.mem_nhds hx
+
+@[simp]
+lemma orthonormalFrame_apply_of_notMem {i : ι} (hx : x ∉ e.baseSet) :
+    b.orthonormalFrame e i x = 0 := by
+  simp only [orthonormalFrame, VectorBundle.gramSchmidtNormed, InnerProductSpace.gramSchmidtNormed,
+    RCLike.ofReal_real_eq_id, id_eq, smul_eq_zero, inv_eq_zero, norm_eq_zero, or_self]
+  convert InnerProductSpace.gramSchmidt_zero ℝ i
+  exact e.localFrame_apply_of_notMem b hx
+
+end Module.Basis
diff --git a/Mathlib/Geometry/Manifold/VectorBundle/SmoothSection.lean b/Mathlib/Geometry/Manifold/VectorBundle/SmoothSection.lean
index 12d21cd26fce89..3eb794b53d0b3f 100644
--- a/Mathlib/Geometry/Manifold/VectorBundle/SmoothSection.lean
+++ b/Mathlib/Geometry/Manifold/VectorBundle/SmoothSection.lean
@@ -7,9 +7,9 @@ module
 
 public import Mathlib.Geometry.Manifold.Algebra.LieGroup
 public import Mathlib.Geometry.Manifold.MFDeriv.Basic
-public import Mathlib.Topology.ContinuousMap.Basic
-public import Mathlib.Geometry.Manifold.VectorBundle.Basic
 public import Mathlib.Geometry.Manifold.Notation
+public import Mathlib.Geometry.Manifold.VectorBundle.Basic
+public import Mathlib.Topology.ContinuousMap.Basic
 
 /-!
 # `C^n` sections
@@ -194,6 +194,16 @@ lemma ContMDiffOn.smul_section_of_tsupport {s : Π (x : M), V x} {ψ : M → 
     simp [image_eq_zero_of_notMem_tsupport hy, zeroSection]
   · exact Set.compl_subset_iff_union.mp <| Set.compl_subset_compl.mpr ht'
 
+-- unused
+/-- The scalar product `ψ • s` of a `C^k` function `ψ: M → 𝕜` and a section `s` of a vector
+bundle `V → M` is `C^k` once `s` is `C^k` at each point in `tsupport ψ`.
+
+This is a vector bundle analogue of `contMDiff_of_tsupport`. -/
+lemma ContMDiff.smul_section_of_tsupport' {s : Π (x : M), V x} {ψ : M → 𝕜} {u : Set M}
+    (hs : ∀ x ∈ tsupport ψ, CMDiffAt n (T% (ψ • s)) x) :
+    CMDiff n (T% (ψ • s)) := by
+  sorry
+
 /-- The sum of a locally finite collection of sections is `C^k` iff each section is.
 Version at a point within a set. -/
 lemma ContMDiffWithinAt.sum_section_of_locallyFinite
diff --git a/Mathlib/Geometry/Manifold/VectorBundle/Tensoriality.lean b/Mathlib/Geometry/Manifold/VectorBundle/Tensoriality.lean
new file mode 100644
index 00000000000000..e8e4c370b175d6
--- /dev/null
+++ b/Mathlib/Geometry/Manifold/VectorBundle/Tensoriality.lean
@@ -0,0 +1,268 @@
+/-
+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.BumpFunction
+public import Mathlib.Geometry.Manifold.MFDeriv.Basic
+public import Mathlib.Geometry.Manifold.Notation
+public import Mathlib.Geometry.Manifold.VectorBundle.LocalFrame
+public import Mathlib.Geometry.Manifold.VectorBundle.MDifferentiable
+
+/-!
+# The tensoriality criterion
+
+-/
+open Bundle Filter Function Topology Module
+
+open scoped Bundle Manifold ContDiff
+
+@[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] [IsManifold I 1 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)]
+  -- [∀ x, IsTopologicalAddGroup (V x)] [∀ x, ContinuousSMul ℝ (V x)]
+  [FiberBundle F V] [VectorBundle ℝ F V]
+  -- `V` vector bundle
+
+variable (F' : Type*) [NormedAddCommGroup F'] [NormedSpace ℝ F']
+  (m : WithTop ℕ∞)
+  (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)]
+
+omit [IsManifold I 1 M] [FiberBundle F V] [VectorBundle ℝ F V] in
+lemma tensoriality_criterion [FiberBundle F V] [VectorBundle ℝ F V]
+    [ContMDiffVectorBundle 1 F V I] [FiniteDimensional ℝ E]
+    [FiniteDimensional ℝ F] [FiberBundle F' V'] [VectorBundle ℝ F' V'] [T2Space M]
+    [IsManifold I ∞ M]
+    {φ : (Π x : M, V x) → (Π x, V' x)} {x}
+    {σ σ' : Π x : M, V x} (hσ : MDiffAt (T% σ) x) (hσ' : MDiffAt (T% σ') x)
+    (hσσ' : σ x = σ' x)
+    (φ_smul : ∀ f : M → ℝ, ∀ σ, MDiffAt f x → MDiffAt (T% σ) x →
+      φ (f • σ) x = f x • φ σ x)
+    (φ_add : ∀ σ σ', MDiffAt (T% σ) x → MDiffAt (T% σ') x →
+      φ (σ + σ') x = φ σ x + φ σ' x) : φ σ x = φ σ' x := by
+  have locality {σ σ'} (hσ : MDiffAt (T% σ) x) (hσ' : MDiffAt (T% σ') x)
+      (hσσ' : ∀ᶠ x' in 𝓝 x, σ x' = σ' x') : φ σ x = φ σ' x := by
+    obtain ⟨ψ, _, hψ⟩ := (SmoothBumpFunction.nhds_basis_support (I := I) hσσ').mem_iff.1 hσσ'
+    have (x : M) : ((ψ : M → ℝ) • σ) x = ((ψ : M → ℝ) • σ') x := by
+      by_cases h : σ x = σ' x
+      · rw [Pi.smul_apply', Pi.smul_apply', h]
+      · simp [notMem_support.mp fun a ↦ h (hψ a)]
+    have hψ' : MDifferentiableAt I 𝓘(ℝ) ψ x :=
+       ψ.contMDiffAt.mdifferentiableAt (by simp)
+    calc φ σ x
+      _ = φ ((ψ : M → ℝ) • σ) x := by simp [φ_smul _ _ hψ' hσ]
+      _ = φ ((ψ : M → ℝ) • σ') x := by rw [funext this]
+      _ = φ σ' x := by simp [φ_smul _ _ hψ' hσ']
+  let ι : Type _ := Basis.ofVectorSpaceIndex ℝ F
+  classical
+  have sum_phi {s : Finset ι} (σ : ι → Π x : M, V x)
+      (hσ : ∀ i, MDiffAt  (T% (σ i)) x):
+      φ (fun x' ↦ ∑ i ∈ s, σ i x') x = ∑ i ∈ s, φ (σ i) x := by
+    induction s using Finset.induction_on with
+    | empty =>
+       simp only [Finset.sum_empty]
+       have h₁ : MDiffAt (fun x' : M ↦ (0 : ℝ)) x := mdifferentiableAt_const
+       rw [show (fun x' : M ↦ (0 : V x')) = (0 : M → ℝ) • fun x' ↦ 0 by simp;rfl]
+       rw [φ_smul]
+       · simp
+       · exact h₁
+       -- TODO: add mdifferentiable_zeroSection and/or use it!
+       apply (contMDiff_zeroSection _ _).mdifferentiableAt one_ne_zero
+    | insert a s ha h =>
+        change φ (fun x' : M ↦ ∑ i ∈ (insert a s : Finset ι), σ i x') x = _
+        simp only [Finset.sum_insert ha, ← h]
+        exact φ_add _ _ (hσ a) (.sum_section hσ)
+  have x_mem := (FiberBundle.mem_baseSet_trivializationAt F V x)
+  let b := Basis.ofVectorSpace ℝ F
+  let t := trivializationAt F V x
+  let s := t.localFrame b
+  let c := t.localFrame_coeff I b
+  have hs (i) : MDiffAt (T% (s i)) x:=
+    (contMDiffAt_localFrame_of_mem 1 _ b i x_mem).mdifferentiableAt (by simp)
+  have hc {σ : (x : M) → V x} (hσ : MDiffAt (T% σ) x) (i) :
+      MDiffAt ((LinearMap.piApply (c i)) σ) x :=
+    mdifferentiableAt_localFrame_coeff b x_mem hσ i
+  have hφ {σ : (x : M) → V x} (hσ : MDiffAt (T% σ) x) :
+      φ σ x = φ (fun x' ↦ ∑ i, c i x' (σ x') • s i x') x := by
+    exact
+      locality hσ
+        (.sum_section fun i ↦ (hc hσ i).smul_section (hs i))
+        (t.eventually_eq_localFrame_sum_coeff_smul b x_mem)
+  rw [hφ hσ, hφ hσ', sum_phi, sum_phi]
+  · change ∑ i, φ (((LinearMap.piApply (c i)) σ) • (s i)) x =
+      ∑ i, φ (((LinearMap.piApply (c i)) σ') • (s i)) x
+    congr
+    ext i
+    rw [φ_smul _ _ (hc hσ i) (hs i), φ_smul _ _ (hc hσ' i) (hs i)]
+    simp [hσσ']
+  · exact fun i ↦ (hc hσ' i).smul_section (hs i)
+  · exact fun i ↦ (hc hσ i).smul_section (hs i)
+
+include I in
+omit [IsManifold I 1 M] [FiberBundle F V] [VectorBundle ℝ F V] in
+lemma tensoriality_criterion' [FiberBundle F V] [VectorBundle ℝ F V] [FiniteDimensional ℝ E]
+    [FiniteDimensional ℝ F] [FiberBundle F' V'] [VectorBundle ℝ F' V'] [T2Space M]
+    [ContMDiffVectorBundle 1 F V I]
+    {φ : (Π x : M, V x) → (Π x, V' x)} {x}
+    {σ σ' : Π x : M, V x}
+    (hσσ' : σ x = σ' x)
+    (φ_smul : ∀ f : M → ℝ, ∀ σ, φ (f • σ) x = f x • φ σ x)
+    (φ_add : ∀ σ σ', φ (σ + σ') x = φ σ x + φ σ' x) : φ σ x = φ σ' x := by
+  have locality {σ σ'} (hσσ' : ∀ᶠ x' in 𝓝 x, σ x' = σ' x') :
+      φ σ x = φ σ' x := by
+    obtain ⟨ψ, _, hψ⟩ := (SmoothBumpFunction.nhds_basis_support (I := I) hσσ').mem_iff.1 hσσ'
+    have (x : M) : ((ψ : M → ℝ) • σ) x = ((ψ : M → ℝ) • σ') x := by
+      by_cases h : σ x = σ' x
+      · rw [Pi.smul_apply', Pi.smul_apply', h]
+      · simp [notMem_support.mp fun a ↦ h (hψ a)]
+    calc φ σ x
+      _ = φ ((ψ : M → ℝ) • σ) x := by simp [φ_smul]
+      _ = φ ((ψ : M → ℝ) • σ') x := by rw [funext this]
+      _ = φ σ' x := by simp [φ_smul]
+  let ι : Type _ := Basis.ofVectorSpaceIndex ℝ F
+  classical
+  have sum_phi {s : Finset ι} (σ : ι → Π x : M, V x) :
+      φ (fun x' ↦ ∑ i ∈ s, σ i x') x = ∑ i ∈ s, φ (σ i) x := by
+    induction s using Finset.induction_on with
+    | empty =>
+       simp only [Finset.sum_empty]
+       rw [show (fun x' : M ↦ (0 : V x')) = (0 : M → ℝ) • fun x' ↦ 0 by simp;rfl, φ_smul]
+       simp
+    | insert a s ha h =>
+      change φ (fun x' : M ↦ ∑ i ∈ (insert a s : Finset ι), σ i x') x = _
+      simp only [Finset.sum_insert ha, ← h]
+      erw [φ_add]
+  have x_mem := (FiberBundle.mem_baseSet_trivializationAt F V x)
+  let b := Basis.ofVectorSpace ℝ F
+  let t := trivializationAt F V x
+  let s := t.localFrame b
+  let c := t.localFrame_coeff (I := I) b
+  rw [locality (t.eventually_eq_localFrame_sum_coeff_smul (I := I) b x_mem)]
+  nth_rw 2 [locality (t.eventually_eq_localFrame_sum_coeff_smul (I := I) b x_mem)]
+  rw [sum_phi, sum_phi]
+  -- FIXME: the `erw` below can be made an `rw` by uncommenting this `change`
+  --change ∑ i, φ (((LinearMap.piApply (c i)) σ) • (s i)) x =
+  --  ∑ i, φ (((LinearMap.piApply (c i)) σ') • (s i)) x
+  congr with i
+  -- `erw?` says this is because of smul with a constant vs. a function `M → ℝ`
+  erw [φ_smul, φ_smul]
+  congr
+
+include I in
+omit [IsManifold I 1 M] [FiberBundle F V] [VectorBundle ℝ F V] in
+lemma tensoriality_criterion₂' [FiberBundle F V] [VectorBundle ℝ F V]
+    [FiniteDimensional ℝ E] [FiniteDimensional ℝ F] [T2Space M] [ContMDiffVectorBundle 1 F V I]
+    [FiberBundle F' V'] [VectorBundle ℝ F' V']
+    {φ : (Π x : M, V x) → (Π x : M, V x) → (Π x, V' x)} {x}
+    {σ σ' τ τ' : Π x : M, V x}
+    (hσσ' : σ x = σ' x)
+    (hττ' : τ x = τ' x)
+    (φ_smul : ∀ f : M → ℝ, ∀ σ τ, φ (f • σ) τ x = f x • φ σ τ x)
+    (φ_add : ∀ σ σ' τ, φ (σ + σ') τ x = φ σ τ x + φ σ' τ x)
+    (τ_smul : ∀ f : M → ℝ, ∀ σ τ, φ σ (f • τ) x = f x • φ σ τ x)
+    (τ_add : ∀ σ τ τ', φ σ (τ + τ') x = φ σ τ x + φ σ τ' x) : φ σ τ x = φ σ' τ' x := by
+  trans φ σ' τ x
+  · let φ1 : (Π x : M, V x) → (Π x, V' x) := fun X ↦ φ X τ
+    change φ1 σ x = φ1 σ' x
+    exact tensoriality_criterion' I F V F' V' hσσ' (by simp [φ_smul, φ1]) (by simp [φ_add, φ1])
+  · let φ1 : (Π x : M, V x) → (Π x, V' x) := fun X ↦ φ σ' X
+    change φ1 τ x = φ1 τ' x
+    exact tensoriality_criterion' I F V F' V' hττ' (by simp [τ_smul, φ1]) (by simp [τ_add, φ1])
+
+include I in
+omit [IsManifold I 1 M] in
+lemma tensoriality_criterion₂ [ContMDiffVectorBundle 1 F V I] [IsManifold I ∞ M]
+    [FiniteDimensional ℝ E] [FiniteDimensional ℝ F] [T2Space M]
+    [FiberBundle F' V'] [VectorBundle ℝ F' V']
+    {φ : (Π x : M, V x) → (Π x : M, V x) → (Π x, V' x)} {x}
+    {σ σ' τ τ' : Π x : M, V x}
+    (hσ : MDiffAt (T% σ) x) (hσ' : MDiffAt (T% σ') x)
+    (hτ : MDiffAt (T% τ) x) (hτ' : MDiffAt (T% τ') x)
+    (hσσ' : σ x = σ' x)
+    (hττ' : τ x = τ' x)
+    (φ_smul : ∀ {f : M → ℝ}, ∀ {σ τ}, MDiffAt f x → MDiffAt (T% σ) x →
+      φ (f • σ) τ x = f x • φ σ τ x)
+    (φ_add : ∀ {σ σ' τ}, MDiffAt (T% σ) x → MDiffAt (T% σ') x →
+      φ (σ + σ') τ x = φ σ τ x + φ σ' τ x)
+    (τ_smul : ∀ {f : M → ℝ}, ∀ {σ τ}, MDiffAt f x → MDiffAt (T% τ) x →
+        φ σ (f • τ) x = f x • φ σ τ x)
+    (τ_add : ∀ {σ τ τ'}, MDiffAt (T% τ) x → MDiffAt (T% τ') x →
+        φ σ (τ + τ') x = φ σ τ x + φ σ τ' x) : φ σ τ x = φ σ' τ' x := by
+  trans φ σ' τ x
+  · let φ1 : (Π x : M, V x) → (Π x, V' x) := fun X ↦ φ X τ
+    change φ1 σ x = φ1 σ' x
+    apply tensoriality_criterion I F V F' V' hσ hσ' hσσ'
+    exacts [fun f σ hf hσ ↦ φ_smul hf hσ, fun σ σ' hσ hσ' ↦ φ_add hσ hσ']
+  · let φ1 : (Π x : M, V x) → (Π x, V' x) := fun X ↦ φ σ' X
+    change φ1 τ x = φ1 τ' x
+    apply tensoriality_criterion I F V F' V' hτ hτ' hττ'
+    exacts [fun f τ hf hτ ↦ τ_smul hf hτ, fun τ τ' hτ hτ' ↦ τ_add hτ hτ']
+
+/- include I in
+lemma tensoriality_criterion'' [FiberBundle F V] [VectorBundle ℝ F V] [FiniteDimensional ℝ E]
+    [FiniteDimensional ℝ F] [FiberBundle F' V'] [VectorBundle ℝ F' V'] [T2Space M]
+    {φ : (Π x : M, V x) → (Π x, V' x)} {x}
+    {σ σ' : Π x : M, V x}
+    {Pσ : (Π x : M, V x) → Prop}
+    {Pσ_loc : ∀ σ σ', (∀ᶠ x' in 𝓝 x, σ x' = σ' x') → Pσ σ → Pσ σ'}
+    (hσ : Pσ σ)
+    (hσ' : Pσ σ')
+    {Pf : (M → ℝ) → Prop}
+    {Pf_loc : ∀ f f', (∀ᶠ x' in 𝓝 x, f x' = f' x') → Pf f → Pf f'}
+    (Pf_smooth : ∀ f, MDifferentiableAt I 𝓘(ℝ) f x → Pf f)
+    (hσσ' : σ x = σ' x)
+    (φ_smul : ∀ f : M → ℝ, ∀ σ, Pf f → Pσ σ → φ (f • σ) x = f x • φ σ x)
+    (φ_add : ∀ σ σ', Pσ σ → Pσ σ → φ (σ + σ') x = φ σ x + φ σ' x) : φ σ x = φ σ' x := by
+  have locality {σ σ'} (hσσ' : ∀ᶠ x' in 𝓝 x, σ x' = σ' x') :
+      φ σ x = φ σ' x := by
+    obtain ⟨ψ, _, hψ⟩ := (SmoothBumpFunction.nhds_basis_support (I := I) hσσ').mem_iff.1 hσσ'
+    have (x : M) : ((ψ : M → ℝ) • σ) x = ((ψ : M → ℝ) • σ') x := by
+      by_cases h : σ x = σ' x
+      · rw [Pi.smul_apply', Pi.smul_apply', h]
+      · simp [notMem_support.mp fun a ↦ h (hψ a)]
+    calc φ σ x
+      _ = φ ((ψ : M → ℝ) • σ) x := by simp [φ_smul]
+      _ = φ ((ψ : M → ℝ) • σ') x := by rw [funext this]
+      _ = φ σ' x := by simp [φ_smul]
+  let ι : Type _ := Basis.ofVectorSpaceIndex ℝ F
+  classical
+  have sum_phi {s : Finset ι} (σ : ι → Π x : M, V x) :
+      φ (fun x' ↦ ∑ i ∈ s, σ i x') x = ∑ i ∈ s, φ (σ i) x := by
+    induction s using Finset.induction_on with
+    | empty =>
+       simp only [Finset.sum_empty]
+       rw [show (fun x' : M ↦ (0 : V x')) = (0 : M → ℝ) • fun x' ↦ 0 by simp;rfl, φ_smul]
+       simp
+    | insert a s ha h =>
+        change φ (fun x' : M ↦ ∑ i ∈ (insert a s : Finset ι), σ i x') x = _
+        simp [Finset.sum_insert ha, Finset.sum_insert ha, ← h]
+        erw [φ_add]
+  have x_mem := (FiberBundle.mem_baseSet_trivializationAt F V x)
+  let b := Basis.ofVectorSpace ℝ F
+  let t := trivializationAt F V x
+  let s := b.localFrame (trivializationAt F V x)
+  let c := Basis.localFrame_coeff t b
+  rw [locality (b.localFrame_eventually_eq_sum_coeff_smul x_mem σ),
+      locality (b.localFrame_eventually_eq_sum_coeff_smul x_mem σ'), sum_phi, sum_phi]
+  change ∑ i, φ ((c i σ) • (s i)) x = ∑ i, φ ((c i σ') • (s i)) x
+  congr
+  ext i
+  rw [φ_smul, φ_smul]
+  congr
+  apply b.localFrame_coeff_congr
+  assumption
+ -/
diff --git a/Mathlib/Geometry/Manifold/VectorField/LieBracket.lean b/Mathlib/Geometry/Manifold/VectorField/LieBracket.lean
index 818e52d1557644..766e8dabaf7713 100644
--- a/Mathlib/Geometry/Manifold/VectorField/LieBracket.lean
+++ b/Mathlib/Geometry/Manifold/VectorField/LieBracket.lean
@@ -314,14 +314,200 @@ lemma _root_.MDifferentiableWithinAt.differentiableWithinAt_mpullbackWithin_vect
   exact ((contMDiff_snd_tangentBundle_modelSpace E 𝓘(𝕜, E)).contMDiffAt.mdifferentiableAt
     one_ne_zero).comp_mdifferentiableWithinAt _ this
 
+variable (W x) in
+omit [CompleteSpace E] in
+lemma aux_computation :
+    (mfderiv I 𝓘(𝕜, E) (extChartAt I x) x).inverse
+      ((mfderivWithin 𝓘(𝕜, E) I ((extChartAt I x).symm) (range I) ((extChartAt I x) x)).inverse
+        (W ((extChartAt I x).symm ((extChartAt I x) x))))
+      = W x := by
+  set φ := extChartAt I x
+  set x' := (extChartAt I x) x
+  rw [extChartAt_to_inv x]
+  calc
+    _ = ((mfderiv I 𝓘(𝕜, E) φ x).inverse.comp
+      (mfderivWithin 𝓘(𝕜, E) I φ.symm (range I) x').inverse) (W x) := rfl
+    _ = (ContinuousLinearMap.id 𝕜 _) (W x) := by
+      congr
+      rw [← ContinuousLinearMap.IsInvertible.inverse_comp_of_left,
+        ← ContinuousLinearMap.inverse_id,
+        mfderivWithin_extChartAt_symm_comp_mfderiv_extChartAt' (mem_extChartAt_source x)]
+      · rfl
+      exact isInvertible_mfderivWithin_extChartAt_symm (mem_extChartAt_target x)
+    _ = W x := by simp
+
+-- does this version suffice for my purposes below?
+variable (x V) in
+omit [CompleteSpace E] in
+lemma aux_computation2' :
+    letI φ := extChartAt I x
+    (mfderivWithin 𝓘(𝕜, E) I φ.symm φ.target (φ x)).inverse (V x) = V x := by
+  set φ := extChartAt I x
+  set x' := (extChartAt I x) x
+  have : mfderivWithin 𝓘(𝕜, E) I φ.symm φ.target (φ x) = ContinuousLinearMap.id 𝕜 _ := by
+    rw [mfderivWithin]
+    have : MDifferentiableWithinAt 𝓘(𝕜, E) I φ.symm φ.target (φ x) := by
+      have := mdifferentiableWithinAt_extChartAt_symm (I := I) (mem_extChartAt_target x)
+      exact this.mono (extChartAt_target_subset_range x)
+    simp only [this, ↓reduceIte, writtenInExtChartAt, extChartAt, OpenPartialHomeomorph.extend,
+      PartialEquiv.coe_trans, ModelWithCorners.toPartialEquiv_coe,
+      OpenPartialHomeomorph.toFun_eq_coe, modelWithCornersSelf_coe, range_id, inter_univ]
+    rw [extChartAt_to_inv x, ← extChartAt_coe]
+    -- debug why this line is needed!
+    change fderivWithin 𝕜 (↑(extChartAt I x) ∘ ↑φ.symm) (extChartAt I x).target (φ x) = _
+    have : fderivWithin 𝕜 (φ ∘ φ.symm) (extChartAt I x).target (φ x) =
+        fderivWithin 𝕜 id (extChartAt I x).target (φ x) :=
+      fderivWithin_congr' (fun x' hx' ↦ PartialEquiv.right_inv φ hx') (mem_extChartAt_target x)
+    rw [this]
+    exact fderivWithin_id (uniqueDiffWithinAt_extChartAt_target x)
+  rw [this]
+  erw [ContinuousLinearMap.inverse_id]
+  rfl
+
+set_option backward.isDefEq.respectTransparency false in
+variable (x V) in
+omit [CompleteSpace E] in
+lemma aux_computation2 :
+    letI φ := extChartAt I x
+    (mfderivWithin 𝓘(𝕜, E) I φ.symm (range I) (φ x)).inverse (V x) = V x := by
+  set φ := extChartAt I x
+  set x' := (extChartAt I x) x
+  -- this is almost true: it is true within a smaller set (namely extChartAt I x).target...
+  have : mfderivWithin 𝓘(𝕜, E) I φ.symm (range I) (φ x) = ContinuousLinearMap.id 𝕜 _ := by
+    rw [mfderivWithin]
+    have : MDifferentiableWithinAt 𝓘(𝕜, E) I (↑φ.symm) (range ↑I) (φ x) :=
+      mdifferentiableWithinAt_extChartAt_symm (mem_extChartAt_target x)
+    simp only [this, ↓reduceIte, writtenInExtChartAt, extChartAt, OpenPartialHomeomorph.extend,
+      PartialEquiv.coe_trans, ModelWithCorners.toPartialEquiv_coe,
+      OpenPartialHomeomorph.toFun_eq_coe, OpenPartialHomeomorph.refl_partialEquiv,
+      PartialEquiv.refl_source, OpenPartialHomeomorph.singletonChartedSpace_chartAt_eq,
+      modelWithCornersSelf_partialEquiv, PartialEquiv.trans_refl, PartialEquiv.refl_symm,
+      PartialEquiv.refl_coe, CompTriple.comp_eq, preimage_id_eq, id_eq, modelWithCornersSelf_coe,
+      range_id, inter_univ]
+    rw [extChartAt_to_inv x, ← extChartAt_coe]
+    have : fderivWithin 𝕜 (φ ∘ φ.symm) (range I) (φ x) = fderivWithin 𝕜 id (range I) (φ x) := by
+      refine fderivWithin_congr' ?_ ?_
+      · intro x' hx'
+        simp only [comp_apply, id_eq]
+        refine PartialEquiv.right_inv φ ?_
+        rw [extChartAt_target]
+        refine ⟨?_, hx'⟩
+        rw [mem_preimage] -- not necessarily true, though...
+        sorry
+      · sorry
+    rw [this]
+    exact fderivWithin_id <| I.uniqueDiffOn.uniqueDiffWithinAt (mem_range_self _)
+  rw [this, ContinuousLinearMap.inverse_id]
+  exact rfl
+
+set_option backward.isDefEq.respectTransparency false in
+/--
+Product rule for Lie brackets: given two vector fields `V` and `W` on `M` and a function
+`f : M → 𝕜`, we have `[V, f • W] = (df V) • W + f • [V, W]`. Version within a set.
+-/
+lemma mlieBracketWithin_smul_right {f : M → 𝕜} (hf : MDifferentiableWithinAt I 𝓘(𝕜) f s x)
+    (hW : MDifferentiableWithinAt I I.tangent (fun x ↦ (W x : TangentBundle I M)) s x)
+    (hs : UniqueMDiffWithinAt I s x) :
+    mlieBracketWithin I V (f • W) s x =
+      (mfderivWithin I 𝓘(𝕜) f s x) (V x) • (W x) + (f x) • mlieBracketWithin I V W s x := by
+  simp only [mlieBracketWithin]
+  rw [mpullbackWithin_smul]
+  -- Simplify local notation a bit.
+  set V' := mpullbackWithin 𝓘(𝕜, E) I (extChartAt I x).symm V (range I)
+  set W' := mpullbackWithin 𝓘(𝕜, E) I (extChartAt I x).symm W (range I)
+  set f' := f ∘ (extChartAt I x).symm
+  set s' := (extChartAt I x).symm ⁻¹' s ∩ range I
+  set x' := (extChartAt I x) x
+  change mpullback I 𝓘(𝕜, E) ((extChartAt I x)) (lieBracketWithin 𝕜 V' (fun y ↦ f' y • W' y) s') x =
+    (mfderivWithin I 𝓘(𝕜, 𝕜) f s x) (V x) • W x +
+    f x • mpullback I 𝓘(𝕜, E) ((extChartAt I x)) (lieBracketWithin 𝕜 V' W' s') x
+  -- Step 1: rewrite using lieBracketWithin_smul_right
+  have hf' : DifferentiableWithinAt 𝕜 f' s' x' := by
+    -- Is this worth a separate lemma?
+    obtain ⟨_, hf⟩ := mdifferentiableWithinAt_iff.mp hf
+    rwa [extChartAt_self_eq] at hf
+  let aux := lieBracketWithin_smul_right (V := V') hf'
+    hW.differentiableWithinAt_mpullbackWithin_vectorField hs
+  -- rw [← Pi.smul_def']
+  -- We need the cast, since on the nose `B` is a map `E → E`,
+  -- while we need a map between tangent spaces.
+  let A (x₀) := (fderivWithin 𝕜 f' s' x₀) (V' x₀) • W' x₀
+  let B (x₀) : TangentSpace 𝓘(𝕜, E) x₀ := f' x₀ • lieBracketWithin 𝕜 V' W' s' x₀
+  trans mpullback I 𝓘(𝕜, E) ((extChartAt I x)) (fun y ↦ A y + B y) x
+  · simp only [mpullback_apply]
+    congr
+  -- We prove the equality of each summand separately.
+  rw [← Pi.add_def, mpullback_add_apply]; congr; swap
+  · simp [B, ← Pi.smul_def', mpullback_smul (V := lieBracketWithin 𝕜 V' W' s'), f']
+  -- This part is still TODO/ in progress!!
+  unfold A
+  simp only [mpullback, extChartAt.eq_1, OpenPartialHomeomorph.extend.eq_1, PartialEquiv.coe_trans,
+    ModelWithCorners.toPartialEquiv_coe, OpenPartialHomeomorph.toFun_eq_coe, comp_apply, extChartAt,
+    OpenPartialHomeomorph.extend, map_smul, mfderivWithin, hf, ↓reduceIte, writtenInExtChartAt,
+    OpenPartialHomeomorph.refl_partialEquiv, PartialEquiv.refl_source,
+    OpenPartialHomeomorph.singletonChartedSpace_chartAt_eq, modelWithCornersSelf_partialEquiv,
+    PartialEquiv.trans_refl, PartialEquiv.refl_coe, PartialEquiv.coe_trans_symm,
+    OpenPartialHomeomorph.coe_coe_symm, ModelWithCorners.toPartialEquiv_coe_symm,
+    CompTriple.comp_eq]
+  have cleanup1 : I ((chartAt H x) x) = x' := rfl
+  have cleanup2 : f ∘ (chartAt H x).symm ∘ I.symm = f' := rfl
+  rw [cleanup1, cleanup2, ← aux_computation x W]
+  congr -- congr 1 is less strong
+  -- This statement is not fully true, but I only need a weaker version...
+  -- if V' x' is a tangent vector within s, i.e. my aux_computation' should suffice!
+  -- Make this intuition hunch rigorous!
+  have : V' x' = V x := by
+    simp only [V', x', mpullbackWithin]
+    rw [extChartAt_to_inv x]
+    exact aux_computation2 x V
+  exact this
+
+set_option backward.isDefEq.respectTransparency false in
+/--
+Product rule for Lie brackets: given two vector fields `V` and `W` on `M` and a function
+`f : M → 𝕜`, we have `[V, f • W] = (df V) • W + f • [V, W]`.
+-/
+lemma mlieBracket_smul_right {f : M → 𝕜} (hf : MDifferentiableAt I 𝓘(𝕜) f x)
+    (hW : MDifferentiableAt I I.tangent (fun x ↦ (W x : TangentBundle I M)) x) :
+    mlieBracket I V (f • W) x =
+      (mfderiv I 𝓘(𝕜) 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]
+  exact mlieBracketWithin_smul_right hf hW (uniqueMDiffWithinAt_univ I)
+
+set_option backward.isDefEq.respectTransparency false in
+/--
+Product rule for Lie brackets: given two vector fields `V` and `W` on `M` and a function
+`f : M → 𝕜`, we have `[f • V, W] = -(df W) • V + f • [V, W]`. Version within a set.
+-/
+lemma mlieBracketWithin_smul_left {f : M → 𝕜} (hf : MDifferentiableWithinAt I 𝓘(𝕜) f s x)
+    (hV : MDifferentiableWithinAt I I.tangent (fun x ↦ (V x : TangentBundle I M)) s x)
+    (hs : UniqueMDiffWithinAt I s x) :
+    mlieBracketWithin I (f • V) W s x =
+      -(mfderivWithin I 𝓘(𝕜) f s 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
+
+set_option backward.isDefEq.respectTransparency false in
+/--
+Product rule for Lie brackets: given two vector fields `V` and `W` on `M` and a function
+`f : M → 𝕜`, we have `[f • V, W] = -(df W) • V + f • [V, W]`.
+-/
+lemma mlieBracket_smul_left {f : M → 𝕜} (hf : MDifferentiableAt I 𝓘(𝕜) f x)
+    (hV : MDifferentiableAt I I.tangent (fun x ↦ (V x : TangentBundle I M)) x) :
+    mlieBracket I (f • V) W x =
+      -(mfderiv I 𝓘(𝕜) 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]
+  exact mlieBracketWithin_smul_left hf hV (uniqueMDiffWithinAt_univ I)
+
 set_option backward.isDefEq.respectTransparency false in
 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
-  simp only [mlieBracketWithin_apply]
-  rw [← map_smul, mpullbackWithin_smul, lieBracketWithin_const_smul_left]
-  · exact hV.differentiableWithinAt_mpullbackWithin_vectorField
-  · exact uniqueMDiffWithinAt_iff_inter_range.1 hs
+  have aux := mlieBracketWithin_smul_left (mdifferentiableWithinAt_const (c := c)) (W := W) hV hs
+  simpa [mfderivWithin_const] using aux
 
 lemma mlieBracket_const_smul_left (hV : MDiffAt (T% V) x) :
     mlieBracket I (c • V) W x = c • mlieBracket I V W x := by
@@ -332,10 +518,8 @@ set_option backward.isDefEq.respectTransparency false in
 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
-  simp only [mlieBracketWithin_apply]
-  rw [← map_smul, mpullbackWithin_smul, lieBracketWithin_const_smul_right]
-  · exact hW.differentiableWithinAt_mpullbackWithin_vectorField
-  · exact uniqueMDiffWithinAt_iff_inter_range.1 hs
+  have aux := mlieBracketWithin_smul_right (mdifferentiableWithinAt_const (c := c)) (V := V) hW hs
+  simpa [mfderivWithin_const] using aux
 
 lemma mlieBracket_const_smul_right (hW : MDiffAt (T% W) x) :
     mlieBracket I V (c • W) x = c • mlieBracket I V W x := by
diff --git a/Mathlib/Geometry/Manifold/VectorField/Pullback.lean b/Mathlib/Geometry/Manifold/VectorField/Pullback.lean
index 7aa48da602a394..88351e95ab0cfb 100644
--- a/Mathlib/Geometry/Manifold/VectorField/Pullback.lean
+++ b/Mathlib/Geometry/Manifold/VectorField/Pullback.lean
@@ -109,15 +109,23 @@ def mpullback (f : M → M') (V : Π (x : M'), TangentSpace I' x) (x : M) :
 lemma mpullbackWithin_apply :
     mpullbackWithin I I' f V s x = (mfderivWithin I I' f s x).inverse (V (f x)) := rfl
 
-lemma mpullbackWithin_smul_apply :
+lemma mpullbackWithin_const_smul_apply :
     mpullbackWithin I I' f (c • V) s x = c • mpullbackWithin I I' f V s x := by
   simp [mpullbackWithin_apply]
 
-lemma mpullbackWithin_smul :
+lemma mpullbackWithin_smul_apply {g : M' → 𝕜} :
+    mpullbackWithin I I' f (g • V) s x = g (f x) • mpullbackWithin I I' f V s x := by
+  simp [mpullbackWithin_apply]
+
+lemma mpullbackWithin_const_smul :
     mpullbackWithin I I' f (c • V) s = c • mpullbackWithin I I' f V s := by
   ext x
   simp [mpullbackWithin_apply]
 
+lemma mpullbackWithin_smul {g : M' → 𝕜} :
+    mpullbackWithin I I' f (g • V) s = (g ∘ f) • mpullbackWithin I I' f V s := by
+  ext; simp [mpullbackWithin_apply]
+
 lemma mpullbackWithin_add_apply :
     mpullbackWithin I I' f (V + V₁) s x =
       mpullbackWithin I I' f V s x + mpullbackWithin I I' f V₁ s x := by
@@ -151,15 +159,24 @@ lemma mpullbackWithin_id {V : Π (x : M), TangentSpace I x} (h : UniqueMDiffWith
 lemma mpullback_apply :
     mpullback I I' f V x = (mfderiv I I' f x).inverse (V (f x)) := rfl
 
-lemma mpullback_smul_apply :
+lemma mpullback_const_smul_apply :
     mpullback I I' f (c • V) x = c • mpullback I I' f V x := by
   simp [mpullback]
 
-lemma mpullback_smul :
+lemma mpullback_const_smul :
     mpullback I I' f (c • V) = c • mpullback I I' f V := by
   ext x
   simp [mpullback_apply]
 
+lemma mpullback_smul_apply {g : M' → 𝕜} :
+    mpullback I I' f (g • V) x = g (f x) • mpullback I I' f V x := by
+  simp [mpullback]
+
+lemma mpullback_smul {g : M' → 𝕜} :
+    mpullback I I' f (g • V) = (g ∘ f) • mpullback I I' f V := by
+  ext x
+  simp [mpullback_apply]
+
 lemma mpullback_add_apply :
     mpullback I I' f (V + V₁) x = mpullback I I' f V x + mpullback I I' f V₁ x := by
   simp [mpullback_apply]