File: Mathlib/Analysis/NormedSpace/Multilinear/Curry.lean

full_name: ContinuousLinearMap.norm_map_tail_le
code: theorem ContinuousLinearMap.norm_map_tail_le
    (f : Ei 0 →L[𝕜] ContinuousMultilinearMap 𝕜 (fun i : Fin n => Ei i.succ) G) (m : ∀ i, Ei i) :
    ‖f (m 0) (tail m)‖ ≤ ‖f‖ * ∏ i, ‖m i‖ 
goal: ‖(f (m 0)) (Fin.tail m)‖ ≤ ‖f‖ * ∏ i : Fin n.succ, ‖m i‖

full_name: ContinuousMultilinearMap.norm_map_init_le
code: theorem ContinuousMultilinearMap.norm_map_init_le
    (f : ContinuousMultilinearMap 𝕜 (fun i : Fin n => Ei <| castSucc i) (Ei (last n) →L[𝕜] G))
    (m : ∀ i, Ei i) : ‖f (init m) (m (last n))‖ ≤ ‖f‖ * ∏ i, ‖m i‖ 
goal: ‖(f (Fin.init m)) (m (Fin.last n))‖ ≤ ‖f‖ * ∏ i : Fin n.succ, ‖m i‖

full_name: ContinuousMultilinearMap.norm_map_cons_le
code: theorem ContinuousMultilinearMap.norm_map_cons_le (f : ContinuousMultilinearMap 𝕜 Ei G) (x : Ei 0)
    (m : ∀ i : Fin n, Ei i.succ) : ‖f (cons x m)‖ ≤ ‖f‖ * ‖x‖ * ∏ i, ‖m i‖ 
goal: ‖f (Fin.cons x m)‖ ≤ ‖f‖ * ‖x‖ * ∏ i : Fin n, ‖m i‖

full_name: ContinuousMultilinearMap.norm_map_snoc_le
code: theorem ContinuousMultilinearMap.norm_map_snoc_le (f : ContinuousMultilinearMap 𝕜 Ei G)
    (m : ∀ i : Fin n, Ei <| castSucc i) (x : Ei (last n)) :
    ‖f (snoc m x)‖ ≤ (‖f‖ * ∏ i, ‖m i‖) * ‖x‖ 
goal: ‖f (Fin.snoc m x)‖ ≤ (‖f‖ * ∏ i : Fin n, ‖m i‖) * ‖x‖

full_name: ContinuousLinearMap.uncurryLeft
code: /-- Given a continuous linear map `f` from `E 0` to continuous multilinear maps on `n` variables,
construct the corresponding continuous multilinear map on `n+1` variables obtained by concatenating
the variables, given by `m ↦ f (m 0) (tail m)`-/
def ContinuousLinearMap.uncurryLeft
    (f : Ei 0 →L[𝕜] ContinuousMultilinearMap 𝕜 (fun i : Fin n => Ei i.succ) G) :
    ContinuousMultilinearMap 𝕜 Ei G 
goal: ContinuousMultilinearMap 𝕜 Ei G

full_name: ContinuousLinearMap.uncurryLeft_apply
code: @[simp]
theorem ContinuousLinearMap.uncurryLeft_apply
    (f : Ei 0 →L[𝕜] ContinuousMultilinearMap 𝕜 (fun i : Fin n => Ei i.succ) G) (m : ∀ i, Ei i) :
    f.uncurryLeft m = f (m 0) (tail m) 
goal: f.uncurryLeft m = (f (m 0)) (Fin.tail m)

full_name: ContinuousMultilinearMap.curryLeft
code: /-- 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 
goal: Ei 0 →L[𝕜] ContinuousMultilinearMap 𝕜 (fun i => Ei i.succ) G

full_name: ContinuousMultilinearMap.curryLeft_apply
code: @[simp]
theorem ContinuousMultilinearMap.curryLeft_apply (f : ContinuousMultilinearMap 𝕜 Ei G) (x : Ei 0)
    (m : ∀ i : Fin n, Ei i.succ) : f.curryLeft x m = f (cons x m) 
goal: (f.curryLeft x) m = f (Fin.cons x m)

full_name: ContinuousLinearMap.curry_uncurryLeft
code: @[simp]
theorem ContinuousLinearMap.curry_uncurryLeft
    (f : Ei 0 →L[𝕜] ContinuousMultilinearMap 𝕜 (fun i : Fin n => Ei i.succ) G) :
    f.uncurryLeft.curryLeft = f 
goal: f.uncurryLeft.curryLeft = f

full_name: ContinuousMultilinearMap.uncurry_curryLeft
code: @[simp]
theorem ContinuousMultilinearMap.uncurry_curryLeft (f : ContinuousMultilinearMap 𝕜 Ei G) :
    f.curryLeft.uncurryLeft = f 
goal: f.curryLeft.uncurryLeft = f

full_name: continuousMultilinearCurryLeftEquiv
code: /-- The space of continuous multilinear maps on `Π(i : Fin (n+1)), E i` is canonically isomorphic to
the space of continuous linear maps from `E 0` to the space of continuous multilinear maps on
`Π(i : Fin n), E i.succ`, by separating the first variable. We register this isomorphism in
`continuousMultilinearCurryLeftEquiv 𝕜 E E₂`. The algebraic version (without topology) is given
in `multilinearCurryLeftEquiv 𝕜 E E₂`.

The direct and inverse maps are given by `f.uncurryLeft` and `f.curryLeft`. Use these
unless you need the full framework of linear isometric equivs. -/
def continuousMultilinearCurryLeftEquiv :
    (Ei 0 →L[𝕜] ContinuousMultilinearMap 𝕜 (fun i : Fin n => Ei i.succ) G) ≃ₗᵢ[𝕜]
      ContinuousMultilinearMap 𝕜 Ei G 
goal: (Ei 0 →L[𝕜] ContinuousMultilinearMap 𝕜 (fun i => Ei i.succ) G) ≃ₗᵢ[𝕜] ContinuousMultilinearMap 𝕜 Ei G

full_name: continuousMultilinearCurryLeftEquiv_apply
code: @[simp]
theorem continuousMultilinearCurryLeftEquiv_apply
    (f : Ei 0 →L[𝕜] ContinuousMultilinearMap 𝕜 (fun i : Fin n => Ei i.succ) G) (v : ∀ i, Ei i) :
    continuousMultilinearCurryLeftEquiv 𝕜 Ei G f v = f (v 0) (tail v) 
goal: ((continuousMultilinearCurryLeftEquiv 𝕜 Ei G) f) v = (f (v 0)) (Fin.tail v)

full_name: continuousMultilinearCurryLeftEquiv_symm_apply
code: @[simp]
theorem continuousMultilinearCurryLeftEquiv_symm_apply (f : ContinuousMultilinearMap 𝕜 Ei G)
    (x : Ei 0) (v : ∀ i : Fin n, Ei i.succ) :
    (continuousMultilinearCurryLeftEquiv 𝕜 Ei G).symm f x v = f (cons x v) 
goal: (((continuousMultilinearCurryLeftEquiv 𝕜 Ei G).symm f) x) v = f (Fin.cons x v)

full_name: ContinuousMultilinearMap.curryLeft_norm
code: @[simp]
theorem ContinuousMultilinearMap.curryLeft_norm (f : ContinuousMultilinearMap 𝕜 Ei G) :
    ‖f.curryLeft‖ = ‖f‖ 
goal: ‖f.curryLeft‖ = ‖f‖

full_name: ContinuousLinearMap.uncurryLeft_norm
code: @[simp]
theorem ContinuousLinearMap.uncurryLeft_norm
    (f : Ei 0 →L[𝕜] ContinuousMultilinearMap 𝕜 (fun i : Fin n => Ei i.succ) G) :
    ‖f.uncurryLeft‖ = ‖f‖ 
goal: ‖f.uncurryLeft‖ = ‖f‖

full_name: ContinuousMultilinearMap.uncurryRight
code: /-- Given a continuous linear map `f` from continuous multilinear maps on `n` variables to
continuous linear maps on `E 0`, construct the corresponding continuous multilinear map on `n+1`
variables obtained by concatenating the variables, given by `m ↦ f (init m) (m (last n))`. -/
def ContinuousMultilinearMap.uncurryRight
    (f : ContinuousMultilinearMap 𝕜 (fun i : Fin n => Ei <| castSucc i) (Ei (last n) →L[𝕜] G)) :
    ContinuousMultilinearMap 𝕜 Ei G 
goal: ContinuousMultilinearMap 𝕜 Ei G

full_name: ContinuousMultilinearMap.uncurryRight_apply
code: @[simp]
theorem ContinuousMultilinearMap.uncurryRight_apply
    (f : ContinuousMultilinearMap 𝕜 (fun i : Fin n => Ei <| castSucc i) (Ei (last n) →L[𝕜] G))
    (m : ∀ i, Ei i) : f.uncurryRight m = f (init m) (m (last n)) 
goal: f.uncurryRight m = (f (Fin.init m)) (m (Fin.last n))

full_name: ContinuousMultilinearMap.curryRight
code: /-- Given a continuous multilinear map `f` in `n+1` variables, split the last variable to obtain
a continuous multilinear map in `n` variables into continuous linear maps, given by
`m ↦ (x ↦ f (snoc m x))`. -/
def ContinuousMultilinearMap.curryRight (f : ContinuousMultilinearMap 𝕜 Ei G) :
    ContinuousMultilinearMap 𝕜 (fun i : Fin n => Ei <| castSucc i) (Ei (last n) →L[𝕜] G) 
goal: ContinuousMultilinearMap 𝕜 (fun i => Ei i.castSucc) (Ei (Fin.last n) →L[𝕜] G)

full_name: ContinuousMultilinearMap.curryRight_apply
code: @[simp]
theorem ContinuousMultilinearMap.curryRight_apply (f : ContinuousMultilinearMap 𝕜 Ei G)
    (m : ∀ i : Fin n, Ei <| castSucc i) (x : Ei (last n)) : f.curryRight m x = f (snoc m x) 
goal: (f.curryRight m) x = f (Fin.snoc m x)

full_name: ContinuousMultilinearMap.curry_uncurryRight
code: @[simp]
theorem ContinuousMultilinearMap.curry_uncurryRight
    (f : ContinuousMultilinearMap 𝕜 (fun i : Fin n => Ei <| castSucc i) (Ei (last n) →L[𝕜] G)) :
    f.uncurryRight.curryRight = f 
goal: f.uncurryRight.curryRight = f

full_name: ContinuousMultilinearMap.uncurry_curryRight
code: @[simp]
theorem ContinuousMultilinearMap.uncurry_curryRight (f : ContinuousMultilinearMap 𝕜 Ei G) :
    f.curryRight.uncurryRight = f 
goal: f.curryRight.uncurryRight = f

full_name: continuousMultilinearCurryRightEquiv
code: /--
The space of continuous multilinear maps on `Π(i : Fin (n+1)), Ei i` is canonically isomorphic to
the space of continuous multilinear maps on `Π(i : Fin n), Ei <| castSucc i` with values in the
space of continuous linear maps on `Ei (last n)`, by separating the last variable. We register this
isomorphism as a continuous linear equiv in `continuousMultilinearCurryRightEquiv 𝕜 Ei G`.
The algebraic version (without topology) is given in `multilinearCurryRightEquiv 𝕜 Ei G`.

The direct and inverse maps are given by `f.uncurryRight` and `f.curryRight`. Use these
unless you need the full framework of linear isometric equivs.
-/
def continuousMultilinearCurryRightEquiv :
    ContinuousMultilinearMap 𝕜 (fun i : Fin n => Ei <| castSucc i) (Ei (last n) →L[𝕜] G) ≃ₗᵢ[𝕜]
      ContinuousMultilinearMap 𝕜 Ei G 
goal: ContinuousMultilinearMap 𝕜 (fun i => Ei i.castSucc) (Ei (Fin.last n) →L[𝕜] G) ≃ₗᵢ[𝕜] ContinuousMultilinearMap 𝕜 Ei G

full_name: continuousMultilinearCurryRightEquiv'
code: /-- The space of continuous multilinear maps on `Π(i : Fin (n+1)), G` is canonically isomorphic to
the space of continuous multilinear maps on `Π(i : Fin n), G` with values in the space
of continuous linear maps on `G`, by separating the last variable. We register this
isomorphism as a continuous linear equiv in `continuousMultilinearCurryRightEquiv' 𝕜 n G G'`.
For a version allowing dependent types, see `continuousMultilinearCurryRightEquiv`. When there
are no dependent types, use the primed version as it helps Lean a lot for unification.

The direct and inverse maps are given by `f.uncurryRight` and `f.curryRight`. Use these
unless you need the full framework of linear isometric equivs. -/
def continuousMultilinearCurryRightEquiv' : (G[×n]→L[𝕜] G →L[𝕜] G') ≃ₗᵢ[𝕜] G[×n.succ]→L[𝕜] G' 
goal: ContinuousMultilinearMap 𝕜 (fun i => G) (G →L[𝕜] G') ≃ₗᵢ[𝕜] ContinuousMultilinearMap 𝕜 (fun i => G) G'

full_name: continuousMultilinearCurryRightEquiv_apply
code: @[simp]
theorem continuousMultilinearCurryRightEquiv_apply
    (f : ContinuousMultilinearMap 𝕜 (fun i : Fin n => Ei <| castSucc i) (Ei (last n) →L[𝕜] G))
    (v : ∀ i, Ei i) : (continuousMultilinearCurryRightEquiv 𝕜 Ei G) f v = f (init v) (v (last n)) 
goal: ((continuousMultilinearCurryRightEquiv 𝕜 Ei G) f) v = (f (Fin.init v)) (v (Fin.last n))

full_name: continuousMultilinearCurryRightEquiv_symm_apply
code: @[simp]
theorem continuousMultilinearCurryRightEquiv_symm_apply (f : ContinuousMultilinearMap 𝕜 Ei G)
    (v : ∀ i : Fin n, Ei <| castSucc i) (x : Ei (last n)) :
    (continuousMultilinearCurryRightEquiv 𝕜 Ei G).symm f v x = f (snoc v x) 
goal: (((continuousMultilinearCurryRightEquiv 𝕜 Ei G).symm f) v) x = f (Fin.snoc v x)

full_name: continuousMultilinearCurryRightEquiv_apply'
code: @[simp]
theorem continuousMultilinearCurryRightEquiv_apply' (f : G[×n]→L[𝕜] G →L[𝕜] G')
    (v : Fin (n + 1) → G) :
    continuousMultilinearCurryRightEquiv' 𝕜 n G G' f v = f (init v) (v (last n)) 
goal: ((continuousMultilinearCurryRightEquiv' 𝕜 n G G') f) v = (f (Fin.init v)) (v (Fin.last n))

full_name: continuousMultilinearCurryRightEquiv_symm_apply'
code: @[simp]
theorem continuousMultilinearCurryRightEquiv_symm_apply' (f : G[×n.succ]→L[𝕜] G')
    (v : Fin n → G) (x : G) :
    (continuousMultilinearCurryRightEquiv' 𝕜 n G G').symm f v x = f (snoc v x) 
goal: (((continuousMultilinearCurryRightEquiv' 𝕜 n G G').symm f) v) x = f (Fin.snoc v x)

full_name: ContinuousMultilinearMap.curryRight_norm
code: @[simp]
theorem ContinuousMultilinearMap.curryRight_norm (f : ContinuousMultilinearMap 𝕜 Ei G) :
    ‖f.curryRight‖ = ‖f‖ 
goal: ‖f.curryRight‖ = ‖f‖

full_name: ContinuousMultilinearMap.uncurryRight_norm
code: @[simp]
theorem ContinuousMultilinearMap.uncurryRight_norm
    (f : ContinuousMultilinearMap 𝕜 (fun i : Fin n => Ei <| castSucc i) (Ei (last n) →L[𝕜] G)) :
    ‖f.uncurryRight‖ = ‖f‖ 
goal: ‖f.uncurryRight‖ = ‖f‖

full_name: ContinuousMultilinearMap.uncurry0
code: /-- Associating to a continuous multilinear map in `0` variables the unique value it takes. -/
def ContinuousMultilinearMap.uncurry0 (f : ContinuousMultilinearMap 𝕜 (fun _ : Fin 0 => G) G') :
    G' 
goal: G'

full_name: ContinuousMultilinearMap.curry0
code: /-- Associating to an element `x` of a vector space `E₂` the continuous multilinear map in `0`
variables taking the (unique) value `x` -/
def ContinuousMultilinearMap.curry0 (x : G') : G[×0]→L[𝕜] G' 
goal: ContinuousMultilinearMap 𝕜 (fun i => G) G'

full_name: ContinuousMultilinearMap.curry0_apply
code: @[simp]
theorem ContinuousMultilinearMap.curry0_apply (x : G') (m : Fin 0 → G) :
    ContinuousMultilinearMap.curry0 𝕜 G x m = x 
goal: (ContinuousMultilinearMap.curry0 𝕜 G x) m = x

full_name: ContinuousMultilinearMap.uncurry0_apply
code: @[simp]
theorem ContinuousMultilinearMap.uncurry0_apply (f : G[×0]→L[𝕜] G') : f.uncurry0 = f 0 
goal: f.uncurry0 = f 0

full_name: ContinuousMultilinearMap.apply_zero_curry0
code: @[simp]
theorem ContinuousMultilinearMap.apply_zero_curry0 (f : G[×0]→L[𝕜] G') {x : Fin 0 → G} :
    ContinuousMultilinearMap.curry0 𝕜 G (f x) = f 
goal: ContinuousMultilinearMap.curry0 𝕜 G (f x) = f

full_name: ContinuousMultilinearMap.uncurry0_curry0
code: theorem ContinuousMultilinearMap.uncurry0_curry0 (f : G[×0]→L[𝕜] G') :
    ContinuousMultilinearMap.curry0 𝕜 G f.uncurry0 = f 
goal: ContinuousMultilinearMap.curry0 𝕜 G f.uncurry0 = f

full_name: ContinuousMultilinearMap.curry0_uncurry0
code: theorem ContinuousMultilinearMap.curry0_uncurry0 (x : G') :
    (ContinuousMultilinearMap.curry0 𝕜 G x).uncurry0 = x 
goal: (ContinuousMultilinearMap.curry0 𝕜 G x).uncurry0 = x

full_name: ContinuousMultilinearMap.curry0_norm
code: @[simp]
theorem ContinuousMultilinearMap.curry0_norm (x : G') :
    ‖ContinuousMultilinearMap.curry0 𝕜 G x‖ = ‖x‖ 
goal: ‖ContinuousMultilinearMap.curry0 𝕜 G x‖ = ‖x‖

full_name: ContinuousMultilinearMap.fin0_apply_norm
code: @[simp]
theorem ContinuousMultilinearMap.fin0_apply_norm (f : G[×0]→L[𝕜] G') {x : Fin 0 → G} :
    ‖f x‖ = ‖f‖ 
goal: ‖f x‖ = ‖f‖

full_name: ContinuousMultilinearMap.uncurry0_norm
code: theorem ContinuousMultilinearMap.uncurry0_norm (f : G[×0]→L[𝕜] G') : ‖f.uncurry0‖ = ‖f‖ 
goal: ‖f.uncurry0‖ = ‖f‖

full_name: continuousMultilinearCurryFin0
code: /-- The continuous linear isomorphism between elements of a normed space, and continuous multilinear
maps in `0` variables with values in this normed space.

The direct and inverse maps are `uncurry0` and `curry0`. Use these unless you need the full
framework of linear isometric equivs. -/
def continuousMultilinearCurryFin0 : (G[×0]→L[𝕜] G') ≃ₗᵢ[𝕜] G' 
goal: ContinuousMultilinearMap 𝕜 (fun i => G) G' ≃ₗᵢ[𝕜] G'

full_name: continuousMultilinearCurryFin0_apply
code: @[simp]
theorem continuousMultilinearCurryFin0_apply (f : G[×0]→L[𝕜] G') :
    continuousMultilinearCurryFin0 𝕜 G G' f = f 0 
goal: (continuousMultilinearCurryFin0 𝕜 G G') f = f 0

full_name: continuousMultilinearCurryFin0_symm_apply
code: @[simp]
theorem continuousMultilinearCurryFin0_symm_apply (x : G') (v : Fin 0 → G) :
    (continuousMultilinearCurryFin0 𝕜 G G').symm x v = x 
goal: ((continuousMultilinearCurryFin0 𝕜 G G').symm x) v = x

full_name: continuousMultilinearCurryFin1
code: /-- Continuous multilinear maps from `G^1` to `G'` are isomorphic with continuous linear maps from
`G` to `G'`. -/
def continuousMultilinearCurryFin1 : (G[×1]→L[𝕜] G') ≃ₗᵢ[𝕜] G →L[𝕜] G' 
goal: ContinuousMultilinearMap 𝕜 (fun i => G) G' ≃ₗᵢ[𝕜] G →L[𝕜] G'

full_name: continuousMultilinearCurryFin1_apply
code: @[simp]
theorem continuousMultilinearCurryFin1_apply (f : G[×1]→L[𝕜] G') (x : G) :
    continuousMultilinearCurryFin1 𝕜 G G' f x = f (Fin.snoc 0 x) 
goal: ((continuousMultilinearCurryFin1 𝕜 G G') f) x = f (Fin.snoc 0 x)

full_name: continuousMultilinearCurryFin1_symm_apply
code: @[simp]
theorem continuousMultilinearCurryFin1_symm_apply (f : G →L[𝕜] G') (v : Fin 1 → G) :
    (continuousMultilinearCurryFin1 𝕜 G G').symm f v = f (v 0) 
goal: ((continuousMultilinearCurryFin1 𝕜 G G').symm f) v = f (v 0)

full_name: ContinuousMultilinearMap.norm_domDomCongr
code: @[simp]
theorem norm_domDomCongr (σ : ι ≃ ι') (f : ContinuousMultilinearMap 𝕜 (fun _ : ι => G) G') :
    ‖domDomCongr σ f‖ = ‖f‖ 
goal: ‖ContinuousMultilinearMap.domDomCongr σ f‖ = ‖f‖

full_name: ContinuousMultilinearMap.domDomCongrₗᵢ
code: /-- An equivalence of the index set defines a linear isometric equivalence between the spaces
of multilinear maps. -/
def domDomCongrₗᵢ (σ : ι ≃ ι') :
    ContinuousMultilinearMap 𝕜 (fun _ : ι => G) G' ≃ₗᵢ[𝕜]
      ContinuousMultilinearMap 𝕜 (fun _ : ι' => G) G' 
goal: ContinuousMultilinearMap 𝕜 (fun x => G) G' ≃ₗᵢ[𝕜] ContinuousMultilinearMap 𝕜 (fun x => G) G'

full_name: ContinuousMultilinearMap.currySum
code: /-- A continuous multilinear map with variables indexed by `ι ⊕ ι'` defines a continuous
multilinear map with variables indexed by `ι` taking values in the space of continuous multilinear
maps with variables indexed by `ι'`. -/
def currySum (f : ContinuousMultilinearMap 𝕜 (fun _ : ι ⊕ ι' => G) G') :
    ContinuousMultilinearMap 𝕜 (fun _ : ι => G) (ContinuousMultilinearMap 𝕜 (fun _ : ι' => G) G') 
goal: ContinuousMultilinearMap 𝕜 (fun x => G) (ContinuousMultilinearMap 𝕜 (fun x => G) G')

full_name: ContinuousMultilinearMap.currySum_apply
code: @[simp]
theorem currySum_apply (f : ContinuousMultilinearMap 𝕜 (fun _ : ι ⊕ ι' => G) G') (m : ι → G)
    (m' : ι' → G) : f.currySum m m' = f (Sum.elim m m') 
goal: (f.currySum m) m' = f (Sum.elim m m')

full_name: ContinuousMultilinearMap.uncurrySum
code: /-- A continuous multilinear map with variables indexed by `ι` taking values in the space of
continuous multilinear maps with variables indexed by `ι'` defines a continuous multilinear map with
variables indexed by `ι ⊕ ι'`. -/
def uncurrySum (f : ContinuousMultilinearMap 𝕜 (fun _ : ι => G)
    (ContinuousMultilinearMap 𝕜 (fun _ : ι' => G) G')) :
    ContinuousMultilinearMap 𝕜 (fun _ : ι ⊕ ι' => G) G' 
goal: ContinuousMultilinearMap 𝕜 (fun x => G) G'

full_name: ContinuousMultilinearMap.uncurrySum_apply
code: @[simp]
theorem uncurrySum_apply (f : ContinuousMultilinearMap 𝕜 (fun _ : ι => G)
    (ContinuousMultilinearMap 𝕜 (fun _ : ι' => G) G'))
    (m : ι ⊕ ι' → G) : f.uncurrySum m = f (m ∘ Sum.inl) (m ∘ Sum.inr) 
goal: f.uncurrySum m = (f (m ∘ Sum.inl)) (m ∘ Sum.inr)

full_name: ContinuousMultilinearMap.currySumEquiv
code: /-- 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 _ : ι ⊕ ι' => G) G' ≃ₗᵢ[𝕜]
    ContinuousMultilinearMap 𝕜 (fun _ : ι => G) (ContinuousMultilinearMap 𝕜 (fun _ : ι' => G) G') 
goal: ContinuousMultilinearMap 𝕜 (fun x => G) G' ≃ₗᵢ[𝕜]
  ContinuousMultilinearMap 𝕜 (fun x => G) (ContinuousMultilinearMap 𝕜 (fun x => G) G')

full_name: ContinuousMultilinearMap.curryFinFinset
code: /-- If `s : Finset (Fin n)` is a finite set of cardinality `k` and its complement has cardinality
`l`, then the space of continuous multilinear maps `G [×n]→L[𝕜] G'` of `n` variables is isomorphic
to the space of continuous multilinear maps `G [×k]→L[𝕜] G [×l]→L[𝕜] G'` of `k` variables taking
values in the space of continuous multilinear maps of `l` variables. -/
def curryFinFinset {k l n : ℕ} {s : Finset (Fin n)} (hk : s.card = k) (hl : sᶜ.card = l) :
    (G[×n]→L[𝕜] G') ≃ₗᵢ[𝕜] G[×k]→L[𝕜] G[×l]→L[𝕜] G' 
goal: ContinuousMultilinearMap 𝕜 (fun i => G) G' ≃ₗᵢ[𝕜]
  ContinuousMultilinearMap 𝕜 (fun i => G) (ContinuousMultilinearMap 𝕜 (fun i => G) G')

full_name: ContinuousMultilinearMap.curryFinFinset_apply
code: @[simp]
theorem curryFinFinset_apply (hk : s.card = k) (hl : sᶜ.card = l) (f : G[×n]→L[𝕜] G')
    (mk : Fin k → G) (ml : Fin l → G) : curryFinFinset 𝕜 G G' hk hl f mk ml =
      f fun i => Sum.elim mk ml ((finSumEquivOfFinset hk hl).symm i) 
goal: (((ContinuousMultilinearMap.curryFinFinset 𝕜 G G' hk hl) f) mk) ml =
  f fun i => Sum.elim mk ml ((finSumEquivOfFinset hk hl).symm i)

full_name: ContinuousMultilinearMap.curryFinFinset_symm_apply
code: @[simp]
theorem curryFinFinset_symm_apply (hk : s.card = k) (hl : sᶜ.card = l)
    (f : G[×k]→L[𝕜] G[×l]→L[𝕜] G') (m : Fin n → G) : (curryFinFinset 𝕜 G G' hk hl).symm f m =
      f (fun i => m <| finSumEquivOfFinset hk hl (Sum.inl i)) fun i =>
        m <| finSumEquivOfFinset hk hl (Sum.inr i) 
goal: ((ContinuousMultilinearMap.curryFinFinset 𝕜 G G' hk hl).symm f) m =
  (f fun i => m ((finSumEquivOfFinset hk hl) (Sum.inl i))) fun i => m ((finSumEquivOfFinset hk hl) (Sum.inr i))

full_name: ContinuousMultilinearMap.curryFinFinset_symm_apply_piecewise_const
code: theorem curryFinFinset_symm_apply_piecewise_const (hk : s.card = k) (hl : sᶜ.card = l)
    (f : G[×k]→L[𝕜] G[×l]→L[𝕜] G') (x y : G) :
    (curryFinFinset 𝕜 G G' hk hl).symm f (s.piecewise (fun _ => x) fun _ => y) =
      f (fun _ => x) fun _ => y 
goal: ((ContinuousMultilinearMap.curryFinFinset 𝕜 G G' hk hl).symm f) (s.piecewise (fun x_1 => x) fun x => y) =
  (f fun x_1 => x) fun x => y

full_name: ContinuousMultilinearMap.curryFinFinset_symm_apply_const
code: @[simp]
theorem curryFinFinset_symm_apply_const (hk : s.card = k) (hl : sᶜ.card = l)
    (f : G[×k]→L[𝕜] G[×l]→L[𝕜] G') (x : G) :
    ((curryFinFinset 𝕜 G G' hk hl).symm f fun _ => x) = f (fun _ => x) fun _ => x 
goal: (((ContinuousMultilinearMap.curryFinFinset 𝕜 G G' hk hl).symm f) fun x_1 => x) = (f fun x_1 => x) fun x_1 => x

full_name: ContinuousMultilinearMap.curryFinFinset_apply_const
code: theorem curryFinFinset_apply_const (hk : s.card = k) (hl : sᶜ.card = l) (f : G[×n]→L[𝕜] G')
    (x y : G) : (curryFinFinset 𝕜 G G' hk hl f (fun _ => x) fun _ => y) =
      f (s.piecewise (fun _ => x) fun _ => y) 
goal: ((((ContinuousMultilinearMap.curryFinFinset 𝕜 G G' hk hl) f) fun x_1 => x) fun x => y) =
  f (s.piecewise (fun x_1 => x) fun x => y)