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

Proof state:
case h
𝕜 : 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'
inst✝ : DecidableEq ι
m : (i : ι) → E i
i : ι
c : 𝕜
x : E i
x✝ : G
⊢ ((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)))
      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))
      x✝

Next tactic:
simp only [coe_smul', ContinuousMultilinearMap.map_smul, LinearMap.coe_mk,
          LinearMap.mkContinuous_apply, Pi.smul_apply, AddHom.coe_mk]