/-- 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
    ext m
    

Proof state:
case H
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
m : (i : Fin n) → M (succ i)
⊢ (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))
      m =
    ((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)
      m

Next tactic:
exact cons_smul f m c x