/-- Linear isometric equivalence between the space of continuous multilinear maps with variables
indexed by `ι ⊕ ι'` and the space of continuous multilinear maps with variables indexed by `ι`
taking values in the space of continuous multilinear maps with variables indexed by `ι'`.

The forward and inverse functions are `ContinuousMultilinearMap.currySum`
and `ContinuousMultilinearMap.uncurrySum`. Use this definition only if you need
some properties of `LinearIsometryEquiv`. -/
def currySumEquiv : ContinuousMultilinearMap 𝕜 (fun _ : Sum ι ι' => G) G' ≃ₗᵢ[𝕜]
    ContinuousMultilinearMap 𝕜 (fun _ : ι => G) (ContinuousMultilinearMap 𝕜 (fun _ : ι' => G) G') :=
  LinearIsometryEquiv.ofBounds
    { toFun := currySum
      invFun := uncurrySum
      map_add' := fun f g => by
        ext
        rfl
      map_smul' := fun c f => by
        ext
        rfl
      left_inv := fun f => by
        ext m
        exact congr_arg f (Sum.elim_comp_inl_inr m)
      right_inv := fun f => by
        ext m₁ m₂
        rfl }
    (fun f => MultilinearMap.mkContinuousMultilinear_norm_le _ (norm_nonneg f) _) fun f => 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 𝕜 (fun x => G) (ContinuousMultilinearMap 𝕜 (fun x => G) G')
⊢ ‖(LinearEquiv.symm
          {
            toLinearMap :=
              {
                toAddHom :=
                  { toFun := currySum,
                    map_add' :=
                      (_ :
                        ∀ (f g : ContinuousMultilinearMap 𝕜 (fun x => G) G'),
                          currySum (f + g) = currySum f + currySum g) },
                map_smul' :=
                  (_ :
                    ∀ (c : 𝕜) (f : ContinuousMultilinearMap 𝕜 (fun x => G) G'),
                      AddHom.toFun
                          { toFun := currySum,
                            map_add' :=
                              (_ :
                                ∀ (f g : ContinuousMultilinearMap 𝕜 (fun x => G) G'),
                                  currySum (f + g) = currySum f + currySum g) }
                          (c • f) =
                        (RingHom.id 𝕜) c •
                          AddHom.toFun
                            { toFun := currySum,
                              map_add' :=
                                (_ :
                                  ∀ (f g : ContinuousMultilinearMap 𝕜 (fun x => G) G'),
                                    currySum (f + g) = currySum f + currySum g) }
                            f) },
            invFun := uncurrySum,
            left_inv :=
              (_ :
                ∀ (f : ContinuousMultilinearMap 𝕜 (fun x => G) G'),
                  uncurrySum
                      (AddHom.toFun
                        {
                            toAddHom :=
                              { toFun := currySum,
                                map_add' :=
                                  (_ :
                                    ∀ (f g : ContinuousMultilinearMap 𝕜 (fun x => G) G'),
                                      currySum (f + g) = currySum f + currySum g) },
                            map_smul' :=
                              (_ :
                                ∀ (c : 𝕜) (f : ContinuousMultilinearMap 𝕜 (fun x => G) G'),
                                  AddHom.toFun
                                      { toFun := currySum,
                                        map_add' :=
                                          (_ :
                                            ∀ (f g : ContinuousMultilinearMap 𝕜 (fun x => G) G'),
                                              currySum (f + g) = currySum f + currySum g) }
                                      (c • f) =
                                    (RingHom.id 𝕜) c •
                                      AddHom.toFun
                                        { toFun := currySum,
                                          map_add' :=
                                            (_ :
                                              ∀ (f g : ContinuousMultilinearMap 𝕜 (fun x => G) G'),
                                                currySum (f + g) = currySum f + currySum g) }
                                        f) }.toAddHom
                        f) =
                    f),
            right_inv :=
              (_ :
                ∀ (f : ContinuousMultilinearMap 𝕜 (fun x => G) (ContinuousMultilinearMap 𝕜 (fun x => G) G')),
                  AddHom.toFun
                      {
                          toAddHom :=
                            { toFun := currySum,
                              map_add' :=
                                (_ :
                                  ∀ (f g : ContinuousMultilinearMap 𝕜 (fun x => G) G'),
                                    currySum (f + g) = currySum f + currySum g) },
                          map_smul' :=
                            (_ :
                              ∀ (c : 𝕜) (f : ContinuousMultilinearMap 𝕜 (fun x => G) G'),
                                AddHom.toFun
                                    { toFun := currySum,
                                      map_add' :=
                                        (_ :
                                          ∀ (f g : ContinuousMultilinearMap 𝕜 (fun x => G) G'),
                                            currySum (f + g) = currySum f + currySum g) }
                                    (c • f) =
                                  (RingHom.id 𝕜) c •
                                    AddHom.toFun
                                      { toFun := currySum,
                                        map_add' :=
                                          (_ :
                                            ∀ (f g : ContinuousMultilinearMap 𝕜 (fun x => G) G'),
                                              currySum (f + g) = currySum f + currySum g) }
                                      f) }.toAddHom
                      (uncurrySum f) =
                    f) })
        f‖ ≤
    ‖f‖

Next tactic:
simp only [LinearEquiv.coe_symm_mk]