/-- Given a multilinear map `f` in `n+1` variables, split the first variable to obtain
a linear map into multilinear maps in `n` variables, given by `x ↦ (m ↦ f (cons x m))`. -/
def MultilinearMap.curryLeft (f : MultilinearMap R M M₂) :
    M 0 →ₗ[R] MultilinearMap R (fun i : Fin n => M i.succ) M₂ where
  toFun x :=
    { toFun := fun m => f (cons x m)
      map_add' := @fun dec m i y y' => by
        -- porting note: `clear` not necessary in Lean 3 due to not being in the instance cache
        rw [Subsingleton.elim dec (by clear dec; infer_instance)]
        simp
      map_smul' := @fun dec m i y c => by
        -- porting note: `clear` not necessary in Lean 3 due to not being in the instance cache
        rw [Subsingleton.elim dec (by clear dec; infer_instance)]
        simp }
  map_add' x y := by
    ext m
    exact cons_add f m x y
  map_smul' c x := by
    

Proof state:
R : Type uR
S : Type uS
ι : Type uι
n : ℕ
M : Fin (Nat.succ n) → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝⁶ : CommSemiring R
inst✝⁵ : (i : Fin (Nat.succ n)) → AddCommMonoid (M i)
inst✝⁴ : AddCommMonoid M'
inst✝³ : AddCommMonoid M₂
inst✝² : (i : Fin (Nat.succ n)) → Module R (M i)
inst✝¹ : Module R M'
inst✝ : Module R M₂
f : MultilinearMap R M M₂
c : R
x : M 0
⊢ AddHom.toFun
      {
        toFun := fun x =>
          { toFun := fun m => f (cons x m),
            map_add' :=
              (_ :
                ∀ (dec : DecidableEq (Fin n)) (m : (i : Fin n) → M (succ i)) (i : Fin n) (y y' : M (succ i)),
                  (fun m => f (cons x m)) (update m i (y + y')) =
                    (fun m => f (cons x m)) (update m i y) + (fun m => f (cons x m)) (update m i y')),
            map_smul' :=
              (_ :
                ∀ (dec : DecidableEq (Fin n)) (m : (i : Fin n) → M (succ i)) (i : Fin n) (y : R) (c : M (succ i)),
                  (fun m => f (cons x m)) (update m i (y • c)) = y • (fun m => f (cons x m)) (update m i c)) },
        map_add' :=
          (_ :
            ∀ (x y : M 0),
              (fun x =>
                    { toFun := fun m => f (cons x m),
                      map_add' :=
                        (_ :
                          ∀ (dec : DecidableEq (Fin n)) (m : (i : Fin n) → M (succ i)) (i : Fin n) (y y' : M (succ i)),
                            (fun m => f (cons x m)) (update m i (y + y')) =
                              (fun m => f (cons x m)) (update m i y) + (fun m => f (cons x m)) (update m i y')),
                      map_smul' :=
                        (_ :
                          ∀ (dec : DecidableEq (Fin n)) (m : (i : Fin n) → M (succ i)) (i : Fin n) (y : R)
                            (c : M (succ i)),
                            (fun m => f (cons x m)) (update m i (y • c)) =
                              y • (fun m => f (cons x m)) (update m i c)) })
                  (x + y) =
                (fun x =>
                      { toFun := fun m => f (cons x m),
                        map_add' :=
                          (_ :
                            ∀ (dec : DecidableEq (Fin n)) (m : (i : Fin n) → M (succ i)) (i : Fin n)
                              (y y' : M (succ i)),
                              (fun m => f (cons x m)) (update m i (y + y')) =
                                (fun m => f (cons x m)) (update m i y) + (fun m => f (cons x m)) (update m i y')),
                        map_smul' :=
                          (_ :
                            ∀ (dec : DecidableEq (Fin n)) (m : (i : Fin n) → M (succ i)) (i : Fin n) (y : R)
                              (c : M (succ i)),
                              (fun m => f (cons x m)) (update m i (y • c)) =
                                y • (fun m => f (cons x m)) (update m i c)) })
                    x +
                  (fun x =>
                      { toFun := fun m => f (cons x m),
                        map_add' :=
                          (_ :
                            ∀ (dec : DecidableEq (Fin n)) (m : (i : Fin n) → M (succ i)) (i : Fin n)
                              (y y' : M (succ i)),
                              (fun m => f (cons x m)) (update m i (y + y')) =
                                (fun m => f (cons x m)) (update m i y) + (fun m => f (cons x m)) (update m i y')),
                        map_smul' :=
                          (_ :
                            ∀ (dec : DecidableEq (Fin n)) (m : (i : Fin n) → M (succ i)) (i : Fin n) (y : R)
                              (c : M (succ i)),
                              (fun m => f (cons x m)) (update m i (y • c)) =
                                y • (fun m => f (cons x m)) (update m i c)) })
                    y) }
      (c • x) =
    (RingHom.id R) c •
      AddHom.toFun
        {
          toFun := fun x =>
            { toFun := fun m => f (cons x m),
              map_add' :=
                (_ :
                  ∀ (dec : DecidableEq (Fin n)) (m : (i : Fin n) → M (succ i)) (i : Fin n) (y y' : M (succ i)),
                    (fun m => f (cons x m)) (update m i (y + y')) =
                      (fun m => f (cons x m)) (update m i y) + (fun m => f (cons x m)) (update m i y')),
              map_smul' :=
                (_ :
                  ∀ (dec : DecidableEq (Fin n)) (m : (i : Fin n) → M (succ i)) (i : Fin n) (y : R) (c : M (succ i)),
                    (fun m => f (cons x m)) (update m i (y • c)) = y • (fun m => f (cons x m)) (update m i c)) },
          map_add' :=
            (_ :
              ∀ (x y : M 0),
                (fun x =>
                      { toFun := fun m => f (cons x m),
                        map_add' :=
                          (_ :
                            ∀ (dec : DecidableEq (Fin n)) (m : (i : Fin n) → M (succ i)) (i : Fin n)
                              (y y' : M (succ i)),
                              (fun m => f (cons x m)) (update m i (y + y')) =
                                (fun m => f (cons x m)) (update m i y) + (fun m => f (cons x m)) (update m i y')),
                        map_smul' :=
                          (_ :
                            ∀ (dec : DecidableEq (Fin n)) (m : (i : Fin n) → M (succ i)) (i : Fin n) (y : R)
                              (c : M (succ i)),
                              (fun m => f (cons x m)) (update m i (y • c)) =
                                y • (fun m => f (cons x m)) (update m i c)) })
                    (x + y) =
                  (fun x =>
                        { toFun := fun m => f (cons x m),
                          map_add' :=
                            (_ :
                              ∀ (dec : DecidableEq (Fin n)) (m : (i : Fin n) → M (succ i)) (i : Fin n)
                                (y y' : M (succ i)),
                                (fun m => f (cons x m)) (update m i (y + y')) =
                                  (fun m => f (cons x m)) (update m i y) + (fun m => f (cons x m)) (update m i y')),
                          map_smul' :=
                            (_ :
                              ∀ (dec : DecidableEq (Fin n)) (m : (i : Fin n) → M (succ i)) (i : Fin n) (y : R)
                                (c : M (succ i)),
                                (fun m => f (cons x m)) (update m i (y • c)) =
                                  y • (fun m => f (cons x m)) (update m i c)) })
                      x +
                    (fun x =>
                        { toFun := fun m => f (cons x m),
                          map_add' :=
                            (_ :
                              ∀ (dec : DecidableEq (Fin n)) (m : (i : Fin n) → M (succ i)) (i : Fin n)
                                (y y' : M (succ i)),
                                (fun m => f (cons x m)) (update m i (y + y')) =
                                  (fun m => f (cons x m)) (update m i y) + (fun m => f (cons x m)) (update m i y')),
                          map_smul' :=
                            (_ :
                              ∀ (dec : DecidableEq (Fin n)) (m : (i : Fin n) → M (succ i)) (i : Fin n) (y : R)
                                (c : M (succ i)),
                                (fun m => f (cons x m)) (update m i (y • c)) =
                                  y • (fun m => f (cons x m)) (update m i c)) })
                      y) }
        x

Next tactic:
ext m