/-- Build a map out of the exterior algebra given a collection of alternating maps acting on each
exterior power -/
def liftAlternating : (∀ i, M [Λ^Fin i]→ₗ[R] N) →ₗ[R] ExteriorAlgebra R M →ₗ[R] N := by
  suffices
    (∀ i, M [Λ^Fin i]→ₗ[R] N) →ₗ[R]
      ExteriorAlgebra R M →ₗ[R] ∀ i, M [Λ^Fin i]→ₗ[R] N by
    refine' LinearMap.compr₂ this _
    refine' (LinearEquiv.toLinearMap _).comp (LinearMap.proj 0)
    exact AlternatingMap.constLinearEquivOfIsEmpty.symm
  refine' CliffordAlgebra.foldl _ _ _
  · refine'
      LinearMap.mk₂ R (fun m f i => (f i.succ).curryLeft m) (fun m₁ m₂ f => _) (fun c m f => _)
        (fun m f₁ f₂ => _) fun c m f => _
    all_goals
      ext i : 1
      simp only [map_smul, map_add, Pi.add_apply, Pi.smul_apply, AlternatingMap.curryLeft_add,
        AlternatingMap.curryLeft_smul, map_add, map_smul, LinearMap.add_apply, LinearMap.smul_apply]
  · -- when applied twice with the same `m`, this recursive step produces 0
    intro m x
    

Proof state:
case refine'_2
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
m : M
x : (i : ℕ) → M [Λ^Fin i]→ₗ[R] N
⊢ ((LinearMap.mk₂ R (fun m f i => (AlternatingMap.curryLeft (f (Nat.succ i))) m)
          (_ :
            ∀ (m₁ m₂ : M) (f : (i : ℕ) → M [Λ^Fin i]→ₗ[R] N),
              (fun m f i => (AlternatingMap.curryLeft (f (Nat.succ i))) m) (m₁ + m₂) f =
                (fun m f i => (AlternatingMap.curryLeft (f (Nat.succ i))) m) m₁ f +
                  (fun m f i => (AlternatingMap.curryLeft (f (Nat.succ i))) m) m₂ f)
          (_ :
            ∀ (c : R) (m : M) (f : (i : ℕ) → M [Λ^Fin i]→ₗ[R] N),
              (fun m f i => (AlternatingMap.curryLeft (f (Nat.succ i))) m) (c • m) f =
                c • (fun m f i => (AlternatingMap.curryLeft (f (Nat.succ i))) m) m f)
          (_ :
            ∀ (m : M) (f₁ f₂ : (i : ℕ) → M [Λ^Fin i]→ₗ[R] N),
              (fun m f i => (AlternatingMap.curryLeft (f (Nat.succ i))) m) m (f₁ + f₂) =
                (fun m f i => (AlternatingMap.curryLeft (f (Nat.succ i))) m) m f₁ +
                  (fun m f i => (AlternatingMap.curryLeft (f (Nat.succ i))) m) m f₂)
          (_ :
            ∀ (c : R) (m : M) (f : (i : ℕ) → M [Λ^Fin i]→ₗ[R] N),
              (fun m f i => (AlternatingMap.curryLeft (f (Nat.succ i))) m) m (c • f) =
                c • (fun m f i => (AlternatingMap.curryLeft (f (Nat.succ i))) m) m f))
        m)
      (((LinearMap.mk₂ R (fun m f i => (AlternatingMap.curryLeft (f (Nat.succ i))) m)
            (_ :
              ∀ (m₁ m₂ : M) (f : (i : ℕ) → M [Λ^Fin i]→ₗ[R] N),
                (fun m f i => (AlternatingMap.curryLeft (f (Nat.succ i))) m) (m₁ + m₂) f =
                  (fun m f i => (AlternatingMap.curryLeft (f (Nat.succ i))) m) m₁ f +
                    (fun m f i => (AlternatingMap.curryLeft (f (Nat.succ i))) m) m₂ f)
            (_ :
              ∀ (c : R) (m : M) (f : (i : ℕ) → M [Λ^Fin i]→ₗ[R] N),
                (fun m f i => (AlternatingMap.curryLeft (f (Nat.succ i))) m) (c • m) f =
                  c • (fun m f i => (AlternatingMap.curryLeft (f (Nat.succ i))) m) m f)
            (_ :
              ∀ (m : M) (f₁ f₂ : (i : ℕ) → M [Λ^Fin i]→ₗ[R] N),
                (fun m f i => (AlternatingMap.curryLeft (f (Nat.succ i))) m) m (f₁ + f₂) =
                  (fun m f i => (AlternatingMap.curryLeft (f (Nat.succ i))) m) m f₁ +
                    (fun m f i => (AlternatingMap.curryLeft (f (Nat.succ i))) m) m f₂)
            (_ :
              ∀ (c : R) (m : M) (f : (i : ℕ) → M [Λ^Fin i]→ₗ[R] N),
                (fun m f i => (AlternatingMap.curryLeft (f (Nat.succ i))) m) m (c • f) =
                  c • (fun m f i => (AlternatingMap.curryLeft (f (Nat.succ i))) m) m f))
          m)
        x) =
    0 m • x

Next tactic:
dsimp only [LinearMap.mk₂_apply, QuadraticForm.coeFn_zero, Pi.zero_apply]