/-- Flip arguments in `f : G →L[𝕜] ContinuousMultilinearMap 𝕜 E G'` to get
`ContinuousMultilinearMap 𝕜 E (G →L[𝕜] G')` -/
@[simps! apply_apply]
def flipMultilinear (f : G →L[𝕜] ContinuousMultilinearMap 𝕜 E G') :
    ContinuousMultilinearMap 𝕜 E (G →L[𝕜] G') :=
  MultilinearMap.mkContinuous
    { toFun := fun m =>
        LinearMap.mkContinuous
          { toFun := fun x => f x m
            map_add' := fun x y => by simp only [map_add, ContinuousMultilinearMap.add_apply]
            map_smul' := fun c x => by
              simp only [ContinuousMultilinearMap.smul_apply, map_smul, RingHom.id_apply] }
          (‖f‖ * ∏ i, ‖m i‖) fun x => by
          rw [mul_right_comm]
          exact (f x).le_of_op_norm_le _ (f.le_op_norm x)
      map_add' := fun m i x y => by
        ext1
        simp only [add_apply, ContinuousMultilinearMap.map_add, LinearMap.coe_mk,
          LinearMap.mkContinuous_apply, AddHom.coe_mk]
      map_smul' := fun m i c x => by
        ext1
        simp only [coe_smul', ContinuousMultilinearMap.map_smul, LinearMap.coe_mk,
          LinearMap.mkContinuous_apply, Pi.smul_apply, AddHom.coe_mk] }
    ‖f‖ fun m => 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 : G →L[𝕜] ContinuousMultilinearMap 𝕜 E G'
m : (i : ι) → E i
⊢ ‖{
          toFun := fun m =>
            LinearMap.mkContinuous
              {
                toAddHom :=
                  { toFun := fun x => (f x) m, map_add' := (_ : ∀ (x y : G), (f (x + y)) m = (f x) m + (f y) m) },
                map_smul' := (_ : ∀ (c : 𝕜) (x : G), (f (c • x)) m = c • (f x) m) }
              (‖f‖ * ∏ i : ι, ‖m i‖)
              (_ :
                ∀ (x : G),
                  ‖{
                          toAddHom :=
                            { toFun := fun x => (f x) m,
                              map_add' := (_ : ∀ (x y : G), (f (x + y)) m = (f x) m + (f y) m) },
                          map_smul' := (_ : ∀ (c : 𝕜) (x : G), (f (c • x)) m = c • (f x) m) }
                        x‖ ≤
                    (‖f‖ * ∏ i : ι, ‖m i‖) * ‖x‖),
          map_add' :=
            (_ :
              ∀ [inst : DecidableEq ι] (m : (i : ι) → E i) (i : ι) (x y : E i),
                (fun m =>
                      LinearMap.mkContinuous
                        {
                          toAddHom :=
                            { toFun := fun x => (f x) m,
                              map_add' := (_ : ∀ (x y : G), (f (x + y)) m = (f x) m + (f y) m) },
                          map_smul' := (_ : ∀ (c : 𝕜) (x : G), (f (c • x)) m = c • (f x) m) }
                        (‖f‖ * ∏ i : ι, ‖m i‖)
                        (_ :
                          ∀ (x : G),
                            ‖{
                                    toAddHom :=
                                      { toFun := fun x => (f x) m,
                                        map_add' := (_ : ∀ (x y : G), (f (x + y)) m = (f x) m + (f y) m) },
                                    map_smul' := (_ : ∀ (c : 𝕜) (x : G), (f (c • x)) m = c • (f x) m) }
                                  x‖ ≤
                              (‖f‖ * ∏ i : ι, ‖m i‖) * ‖x‖))
                    (Function.update m i (x + y)) =
                  (fun m =>
                        LinearMap.mkContinuous
                          {
                            toAddHom :=
                              { toFun := fun x => (f x) m,
                                map_add' := (_ : ∀ (x y : G), (f (x + y)) m = (f x) m + (f y) m) },
                            map_smul' := (_ : ∀ (c : 𝕜) (x : G), (f (c • x)) m = c • (f x) m) }
                          (‖f‖ * ∏ i : ι, ‖m i‖)
                          (_ :
                            ∀ (x : G),
                              ‖{
                                      toAddHom :=
                                        { toFun := fun x => (f x) m,
                                          map_add' := (_ : ∀ (x y : G), (f (x + y)) m = (f x) m + (f y) m) },
                                      map_smul' := (_ : ∀ (c : 𝕜) (x : G), (f (c • x)) m = c • (f x) m) }
                                    x‖ ≤
                                (‖f‖ * ∏ i : ι, ‖m i‖) * ‖x‖))
                      (Function.update m i x) +
                    (fun m =>
                        LinearMap.mkContinuous
                          {
                            toAddHom :=
                              { toFun := fun x => (f x) m,
                                map_add' := (_ : ∀ (x y : G), (f (x + y)) m = (f x) m + (f y) m) },
                            map_smul' := (_ : ∀ (c : 𝕜) (x : G), (f (c • x)) m = c • (f x) m) }
                          (‖f‖ * ∏ i : ι, ‖m i‖)
                          (_ :
                            ∀ (x : G),
                              ‖{
                                      toAddHom :=
                                        { toFun := fun x => (f x) m,
                                          map_add' := (_ : ∀ (x y : G), (f (x + y)) m = (f x) m + (f y) m) },
                                      map_smul' := (_ : ∀ (c : 𝕜) (x : G), (f (c • x)) m = c • (f x) m) }
                                    x‖ ≤
                                (‖f‖ * ∏ i : ι, ‖m i‖) * ‖x‖))
                      (Function.update m i y)),
          map_smul' :=
            (_ :
              ∀ [inst : DecidableEq ι] (m : (i : ι) → E i) (i : ι) (c : 𝕜) (x : E i),
                (fun m =>
                      LinearMap.mkContinuous
                        {
                          toAddHom :=
                            { toFun := fun x => (f x) m,
                              map_add' := (_ : ∀ (x y : G), (f (x + y)) m = (f x) m + (f y) m) },
                          map_smul' := (_ : ∀ (c : 𝕜) (x : G), (f (c • x)) m = c • (f x) m) }
                        (‖f‖ * ∏ i : ι, ‖m i‖)
                        (_ :
                          ∀ (x : G),
                            ‖{
                                    toAddHom :=
                                      { toFun := fun x => (f x) m,
                                        map_add' := (_ : ∀ (x y : G), (f (x + y)) m = (f x) m + (f y) m) },
                                    map_smul' := (_ : ∀ (c : 𝕜) (x : G), (f (c • x)) m = c • (f x) m) }
                                  x‖ ≤
                              (‖f‖ * ∏ i : ι, ‖m i‖) * ‖x‖))
                    (Function.update m i (c • x)) =
                  c •
                    (fun m =>
                        LinearMap.mkContinuous
                          {
                            toAddHom :=
                              { toFun := fun x => (f x) m,
                                map_add' := (_ : ∀ (x y : G), (f (x + y)) m = (f x) m + (f y) m) },
                            map_smul' := (_ : ∀ (c : 𝕜) (x : G), (f (c • x)) m = c • (f x) m) }
                          (‖f‖ * ∏ i : ι, ‖m i‖)
                          (_ :
                            ∀ (x : G),
                              ‖{
                                      toAddHom :=
                                        { toFun := fun x => (f x) m,
                                          map_add' := (_ : ∀ (x y : G), (f (x + y)) m = (f x) m + (f y) m) },
                                      map_smul' := (_ : ∀ (c : 𝕜) (x : G), (f (c • x)) m = c • (f x) m) }
                                    x‖ ≤
                                (‖f‖ * ∏ i : ι, ‖m i‖) * ‖x‖))
                      (Function.update m i x)) }
        m‖ ≤
    ‖f‖ * ∏ i : ι, ‖m i‖

Next tactic:
dsimp only [MultilinearMap.coe_mk]