/-- Given a continuous multilinear map `f` in `n+1` variables, split the first variable to obtain
a continuous linear map into continuous multilinear maps in `n` variables, given by
`x ↦ (m ↦ f (cons x m))`. -/
def ContinuousMultilinearMap.curryLeft (f : ContinuousMultilinearMap 𝕜 Ei G) :
    Ei 0 →L[𝕜] ContinuousMultilinearMap 𝕜 (fun i : Fin n => Ei i.succ) G :=
  LinearMap.mkContinuous
    { -- define a linear map into `n` continuous multilinear maps
      -- from an `n+1` continuous multilinear map
      toFun := fun x =>
        (f.toMultilinearMap.curryLeft x).mkContinuous (‖f‖ * ‖x‖) (f.norm_map_cons_le x)
      map_add' := fun x y => by
        ext m
        exact f.cons_add m x y
      map_smul' := fun c x => by
        ext m
        exact
          f.cons_smul m c x }-- then register its continuity thanks to its boundedness properties.
    ‖f‖ fun x => by
      

Proof state:
𝕜 : Type u
ι : Type v
ι' : Type v'
n : ℕ
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
Ei : Fin (Nat.succ n) → Type wEi
G : Type wG
G' : Type wG'
inst✝¹⁴ : Fintype ι
inst✝¹³ : Fintype ι'
inst✝¹² : NontriviallyNormedField 𝕜
inst✝¹¹ : (i : ι) → NormedAddCommGroup (E i)
inst✝¹⁰ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝⁹ : (i : ι) → NormedAddCommGroup (E₁ i)
inst✝⁸ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁷ : (i : ι') → NormedAddCommGroup (E' i)
inst✝⁶ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁵ : (i : Fin (Nat.succ n)) → NormedAddCommGroup (Ei i)
inst✝⁴ : (i : Fin (Nat.succ n)) → NormedSpace 𝕜 (Ei i)
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f : ContinuousMultilinearMap 𝕜 Ei G
x : Ei 0
⊢ ‖{
          toAddHom :=
            {
              toFun := fun x =>
                MultilinearMap.mkContinuous ((MultilinearMap.curryLeft f.toMultilinearMap) x) (‖f‖ * ‖x‖)
                  (_ : ∀ (m : (i : Fin n) → Ei (succ i)), ‖f (Fin.cons x m)‖ ≤ ‖f‖ * ‖x‖ * ∏ i : Fin n, ‖m i‖),
              map_add' :=
                (_ :
                  ∀ (x y : Ei 0),
                    (fun x =>
                          MultilinearMap.mkContinuous ((MultilinearMap.curryLeft f.toMultilinearMap) x) (‖f‖ * ‖x‖)
                            (_ :
                              ∀ (m : (i : Fin n) → Ei (succ i)), ‖f (Fin.cons x m)‖ ≤ ‖f‖ * ‖x‖ * ∏ i : Fin n, ‖m i‖))
                        (x + y) =
                      (fun x =>
                            MultilinearMap.mkContinuous ((MultilinearMap.curryLeft f.toMultilinearMap) x) (‖f‖ * ‖x‖)
                              (_ :
                                ∀ (m : (i : Fin n) → Ei (succ i)), ‖f (Fin.cons x m)‖ ≤ ‖f‖ * ‖x‖ * ∏ i : Fin n, ‖m i‖))
                          x +
                        (fun x =>
                            MultilinearMap.mkContinuous ((MultilinearMap.curryLeft f.toMultilinearMap) x) (‖f‖ * ‖x‖)
                              (_ :
                                ∀ (m : (i : Fin n) → Ei (succ i)), ‖f (Fin.cons x m)‖ ≤ ‖f‖ * ‖x‖ * ∏ i : Fin n, ‖m i‖))
                          y) },
          map_smul' :=
            (_ :
              ∀ (c : 𝕜) (x : Ei 0),
                AddHom.toFun
                    {
                      toFun := fun x =>
                        MultilinearMap.mkContinuous ((MultilinearMap.curryLeft f.toMultilinearMap) x) (‖f‖ * ‖x‖)
                          (_ : ∀ (m : (i : Fin n) → Ei (succ i)), ‖f (Fin.cons x m)‖ ≤ ‖f‖ * ‖x‖ * ∏ i : Fin n, ‖m i‖),
                      map_add' :=
                        (_ :
                          ∀ (x y : Ei 0),
                            (fun x =>
                                  MultilinearMap.mkContinuous ((MultilinearMap.curryLeft f.toMultilinearMap) x)
                                    (‖f‖ * ‖x‖)
                                    (_ :
                                      ∀ (m : (i : Fin n) → Ei (succ i)),
                                        ‖f (Fin.cons x m)‖ ≤ ‖f‖ * ‖x‖ * ∏ i : Fin n, ‖m i‖))
                                (x + y) =
                              (fun x =>
                                    MultilinearMap.mkContinuous ((MultilinearMap.curryLeft f.toMultilinearMap) x)
                                      (‖f‖ * ‖x‖)
                                      (_ :
                                        ∀ (m : (i : Fin n) → Ei (succ i)),
                                          ‖f (Fin.cons x m)‖ ≤ ‖f‖ * ‖x‖ * ∏ i : Fin n, ‖m i‖))
                                  x +
                                (fun x =>
                                    MultilinearMap.mkContinuous ((MultilinearMap.curryLeft f.toMultilinearMap) x)
                                      (‖f‖ * ‖x‖)
                                      (_ :
                                        ∀ (m : (i : Fin n) → Ei (succ i)),
                                          ‖f (Fin.cons x m)‖ ≤ ‖f‖ * ‖x‖ * ∏ i : Fin n, ‖m i‖))
                                  y) }
                    (c • x) =
                  (RingHom.id 𝕜) c •
                    AddHom.toFun
                      {
                        toFun := fun x =>
                          MultilinearMap.mkContinuous ((MultilinearMap.curryLeft f.toMultilinearMap) x) (‖f‖ * ‖x‖)
                            (_ :
                              ∀ (m : (i : Fin n) → Ei (succ i)), ‖f (Fin.cons x m)‖ ≤ ‖f‖ * ‖x‖ * ∏ i : Fin n, ‖m i‖),
                        map_add' :=
                          (_ :
                            ∀ (x y : Ei 0),
                              (fun x =>
                                    MultilinearMap.mkContinuous ((MultilinearMap.curryLeft f.toMultilinearMap) x)
                                      (‖f‖ * ‖x‖)
                                      (_ :
                                        ∀ (m : (i : Fin n) → Ei (succ i)),
                                          ‖f (Fin.cons x m)‖ ≤ ‖f‖ * ‖x‖ * ∏ i : Fin n, ‖m i‖))
                                  (x + y) =
                                (fun x =>
                                      MultilinearMap.mkContinuous ((MultilinearMap.curryLeft f.toMultilinearMap) x)
                                        (‖f‖ * ‖x‖)
                                        (_ :
                                          ∀ (m : (i : Fin n) → Ei (succ i)),
                                            ‖f (Fin.cons x m)‖ ≤ ‖f‖ * ‖x‖ * ∏ i : Fin n, ‖m i‖))
                                    x +
                                  (fun x =>
                                      MultilinearMap.mkContinuous ((MultilinearMap.curryLeft f.toMultilinearMap) x)
                                        (‖f‖ * ‖x‖)
                                        (_ :
                                          ∀ (m : (i : Fin n) → Ei (succ i)),
                                            ‖f (Fin.cons x m)‖ ≤ ‖f‖ * ‖x‖ * ∏ i : Fin n, ‖m i‖))
                                    y) }
                      x) }
        x‖ ≤
    ‖f‖ * ‖x‖

Next tactic:
rw [LinearMap.coe_mk, AddHom.coe_mk]