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

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₂
x y : M 0
m : (i : Fin n) → M (succ i)
⊢ ((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))
      m =
    ((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)
      m

Next tactic:
exact cons_add f m x y