File: Mathlib/Topology/Algebra/Module/Multilinear/Basic.lean

full_name: ContinuousMultilinearMap.cont
code: /-- Continuous multilinear maps over the ring `R`, from `∀ i, M₁ i` to `M₂` where `M₁ i` and `M₂`
are modules over `R` with a topological structure. In applications, there will be compatibility
conditions between the algebraic and the topological structures, but this is not needed for the
definition. -/
structure ContinuousMultilinearMap (R : Type u) {ι : Type v} (M₁ : ι → Type w₁) (M₂ : Type w₂)
  [Semiring R] [∀ i, AddCommMonoid (M₁ i)] [AddCommMonoid M₂] [∀ i, Module R (M₁ i)] [Module R M₂]
  [∀ i, TopologicalSpace (M₁ i)] [TopologicalSpace M₂] extends MultilinearMap R M₁ M₂ where
  cont : Continuous toFun
goal: Continuous self.toFun

full_name: ContinuousMultilinearMap
code: /-- Continuous multilinear maps over the ring `R`, from `∀ i, M₁ i` to `M₂` where `M₁ i` and `M₂`
are modules over `R` with a topological structure. In applications, there will be compatibility
conditions between the algebraic and the topological structures, but this is not needed for the
definition. -/
structure ContinuousMultilinearMap (R : Type u) {ι : Type v} (M₁ : ι → Type w₁) (M₂ : Type w₂)
  [Semiring R] [∀ i, AddCommMonoid (M₁ i)] [AddCommMonoid M₂] [∀ i, Module R (M₁ i)] [Module R M₂]
  [∀ i, TopologicalSpace (M₁ i)] [TopologicalSpace M₂] extends MultilinearMap R M₁ M₂ where
  cont : Continuous toFun
goal: Type (max (max v w₁) w₂)

full_name: «_aux_Mathlib_Topology_Algebra_Module_Multilinear_Basic___macroRules_term_[×_]→L[_]__1»
code: @[inherit_doc]
notation:25 M "[×" n "]→L[" R "] " M' => ContinuousMultilinearMap R (fun i : Fin n => M) M'
goal: Lean.Macro

full_name: _aux_Mathlib_Topology_Algebra_Module_Multilinear_Basic___unexpand_ContinuousMultilinearMap_1
code: @[inherit_doc]
notation:25 M "[×" n "]→L[" R "] " M' => ContinuousMultilinearMap R (fun i : Fin n => M) M'
goal: Lean.PrettyPrinter.Unexpander

full_name: ContinuousMultilinearMap.toMultilinearMap_injective
code: theorem toMultilinearMap_injective :
    Function.Injective
      (ContinuousMultilinearMap.toMultilinearMap :
        ContinuousMultilinearMap R M₁ M₂ → MultilinearMap R M₁ M₂)
  
goal: Function.Injective ContinuousMultilinearMap.toMultilinearMap

full_name: ContinuousMultilinearMap.funLike
code: instance funLike : FunLike (ContinuousMultilinearMap R M₁ M₂) (∀ i, M₁ i) M₂ 
goal: FunLike (ContinuousMultilinearMap R M₁ M₂) ((i : ι) → M₁ i) M₂

full_name: ContinuousMultilinearMap.continuousMapClass
code: instance continuousMapClass :
    ContinuousMapClass (ContinuousMultilinearMap R M₁ M₂) (∀ i, M₁ i) M₂ 
goal: ContinuousMapClass (ContinuousMultilinearMap R M₁ M₂) ((i : ι) → M₁ i) M₂

full_name: ContinuousMultilinearMap.instCoeFunForallForall
code: instance : CoeFun (ContinuousMultilinearMap R M₁ M₂) fun _ => (∀ i, M₁ i) → M₂ 
goal: CoeFun (ContinuousMultilinearMap R M₁ M₂) fun x => ((i : ι) → M₁ i) → M₂

full_name: ContinuousMultilinearMap.Simps.apply
code: /-- See Note [custom simps projection]. We need to specify this projection explicitly in this case,
  because it is a composition of multiple projections. -/
def Simps.apply (L₁ : ContinuousMultilinearMap R M₁ M₂) (v : ∀ i, M₁ i) : M₂ 
goal: M₂

full_name: ContinuousMultilinearMap.coe_continuous
code: @[continuity]
theorem coe_continuous : Continuous (f : (∀ i, M₁ i) → M₂) 
goal: Continuous ⇑f

full_name: ContinuousMultilinearMap.coe_coe
code: @[simp]
theorem coe_coe : (f.toMultilinearMap : (∀ i, M₁ i) → M₂) = f 
goal: ⇑f.toMultilinearMap = ⇑f

full_name: ContinuousMultilinearMap.ext
code: @[ext]
theorem ext {f f' : ContinuousMultilinearMap R M₁ M₂} (H : ∀ x, f x = f' x) : f = f' 
goal: f = f'

full_name: ContinuousMultilinearMap.ext_iff
code: theorem ext_iff {f f' : ContinuousMultilinearMap R M₁ M₂} : f = f' ↔ ∀ x, f x = f' x 
goal: f = f' ↔ ∀ (x : (i : ι) → M₁ i), f x = f' x

full_name: ContinuousMultilinearMap.map_add
code: @[simp]
theorem map_add [DecidableEq ι] (m : ∀ i, M₁ i) (i : ι) (x y : M₁ i) :
    f (update m i (x + y)) = f (update m i x) + f (update m i y) 
goal: f (Function.update m i (x + y)) = f (Function.update m i x) + f (Function.update m i y)

full_name: ContinuousMultilinearMap.map_smul
code: @[simp]
theorem map_smul [DecidableEq ι] (m : ∀ i, M₁ i) (i : ι) (c : R) (x : M₁ i) :
    f (update m i (c • x)) = c • f (update m i x) 
goal: f (Function.update m i (c • x)) = c • f (Function.update m i x)

full_name: ContinuousMultilinearMap.map_coord_zero
code: theorem map_coord_zero {m : ∀ i, M₁ i} (i : ι) (h : m i = 0) : f m = 0 
goal: f m = 0

full_name: ContinuousMultilinearMap.map_zero
code: @[simp]
theorem map_zero [Nonempty ι] : f 0 = 0 
goal: f 0 = 0

full_name: ContinuousMultilinearMap.instZero
code: instance : Zero (ContinuousMultilinearMap R M₁ M₂) 
goal: Zero (ContinuousMultilinearMap R M₁ M₂)

full_name: ContinuousMultilinearMap.instInhabited
code: instance : Inhabited (ContinuousMultilinearMap R M₁ M₂) 
goal: Inhabited (ContinuousMultilinearMap R M₁ M₂)

full_name: ContinuousMultilinearMap.zero_apply
code: @[simp]
theorem zero_apply (m : ∀ i, M₁ i) : (0 : ContinuousMultilinearMap R M₁ M₂) m = 0 
goal: 0 m = 0

full_name: ContinuousMultilinearMap.toMultilinearMap_zero
code: @[simp]
theorem toMultilinearMap_zero : (0 : ContinuousMultilinearMap R M₁ M₂).toMultilinearMap = 0 
goal: ContinuousMultilinearMap.toMultilinearMap 0 = 0

full_name: ContinuousMultilinearMap.instSMul
code: instance : SMul R' (ContinuousMultilinearMap A M₁ M₂) 
goal: SMul R' (ContinuousMultilinearMap A M₁ M₂)

full_name: ContinuousMultilinearMap.smul_apply
code: @[simp]
theorem smul_apply (f : ContinuousMultilinearMap A M₁ M₂) (c : R') (m : ∀ i, M₁ i) :
    (c • f) m = c • f m 
goal: (c • f) m = c • f m

full_name: ContinuousMultilinearMap.toMultilinearMap_smul
code: @[simp]
theorem toMultilinearMap_smul (c : R') (f : ContinuousMultilinearMap A M₁ M₂) :
    (c • f).toMultilinearMap = c • f.toMultilinearMap 
goal: (c • f).toMultilinearMap = c • f.toMultilinearMap

full_name: ContinuousMultilinearMap.instSMulCommClass
code: instance [SMulCommClass R' R'' M₂] : SMulCommClass R' R'' (ContinuousMultilinearMap A M₁ M₂) 
goal: SMulCommClass R' R'' (ContinuousMultilinearMap A M₁ M₂)

full_name: ContinuousMultilinearMap.instIsScalarTower
code: instance [SMul R' R''] [IsScalarTower R' R'' M₂] :
    IsScalarTower R' R'' (ContinuousMultilinearMap A M₁ M₂) 
goal: IsScalarTower R' R'' (ContinuousMultilinearMap A M₁ M₂)

full_name: ContinuousMultilinearMap.instIsCentralScalar
code: instance [DistribMulAction R'ᵐᵒᵖ M₂] [IsCentralScalar R' M₂] :
    IsCentralScalar R' (ContinuousMultilinearMap A M₁ M₂) 
goal: IsCentralScalar R' (ContinuousMultilinearMap A M₁ M₂)

full_name: ContinuousMultilinearMap.instMulAction
code: instance : MulAction R' (ContinuousMultilinearMap A M₁ M₂) 
goal: MulAction R' (ContinuousMultilinearMap A M₁ M₂)

full_name: ContinuousMultilinearMap.instAdd
code: instance : Add (ContinuousMultilinearMap R M₁ M₂) 
goal: Add (ContinuousMultilinearMap R M₁ M₂)

full_name: ContinuousMultilinearMap.add_apply
code: @[simp]
theorem add_apply (m : ∀ i, M₁ i) : (f + f') m = f m + f' m 
goal: (f + f') m = f m + f' m

full_name: ContinuousMultilinearMap.toMultilinearMap_add
code: @[simp]
theorem toMultilinearMap_add (f g : ContinuousMultilinearMap R M₁ M₂) :
    (f + g).toMultilinearMap = f.toMultilinearMap + g.toMultilinearMap 
goal: (f + g).toMultilinearMap = f.toMultilinearMap + g.toMultilinearMap

full_name: ContinuousMultilinearMap.addCommMonoid
code: instance addCommMonoid : AddCommMonoid (ContinuousMultilinearMap R M₁ M₂) 
goal: AddCommMonoid (ContinuousMultilinearMap R M₁ M₂)

full_name: ContinuousMultilinearMap.applyAddHom
code: /-- Evaluation of a `ContinuousMultilinearMap` at a vector as an `AddMonoidHom`. -/
def applyAddHom (m : ∀ i, M₁ i) : ContinuousMultilinearMap R M₁ M₂ →+ M₂ 
goal: ContinuousMultilinearMap R M₁ M₂ →+ M₂

full_name: ContinuousMultilinearMap.sum_apply
code: @[simp]
theorem sum_apply {α : Type*} (f : α → ContinuousMultilinearMap R M₁ M₂) (m : ∀ i, M₁ i)
    {s : Finset α} : (∑ a ∈ s, f a) m = ∑ a ∈ s, f a m 
goal: (∑ a ∈ s, f a) m = ∑ a ∈ s, (f a) m

full_name: ContinuousMultilinearMap.toContinuousLinearMap
code: /-- If `f` is a continuous multilinear map, then `f.toContinuousLinearMap m i` is the continuous
linear map obtained by fixing all coordinates but `i` equal to those of `m`, and varying the
`i`-th coordinate. -/
def toContinuousLinearMap [DecidableEq ι] (m : ∀ i, M₁ i) (i : ι) : M₁ i →L[R] M₂ 
goal: M₁ i →L[R] M₂

full_name: ContinuousMultilinearMap.prod
code: /-- The cartesian product of two continuous multilinear maps, as a continuous multilinear map. -/
def prod (f : ContinuousMultilinearMap R M₁ M₂) (g : ContinuousMultilinearMap R M₁ M₃) :
    ContinuousMultilinearMap R M₁ (M₂ × M₃) 
goal: ContinuousMultilinearMap R M₁ (M₂ × M₃)

full_name: ContinuousMultilinearMap.prod_apply
code: @[simp]
theorem prod_apply (f : ContinuousMultilinearMap R M₁ M₂) (g : ContinuousMultilinearMap R M₁ M₃)
    (m : ∀ i, M₁ i) : (f.prod g) m = (f m, g m) 
goal: (f.prod g) m = (f m, g m)

full_name: ContinuousMultilinearMap.pi
code: /-- Combine a family of continuous multilinear maps with the same domain and codomains `M' i` into a
continuous multilinear map taking values in the space of functions `∀ i, M' i`. -/
def pi {ι' : Type*} {M' : ι' → Type*} [∀ i, AddCommMonoid (M' i)] [∀ i, TopologicalSpace (M' i)]
    [∀ i, Module R (M' i)] (f : ∀ i, ContinuousMultilinearMap R M₁ (M' i)) :
    ContinuousMultilinearMap R M₁ (∀ i, M' i) 
goal: ContinuousMultilinearMap R M₁ ((i : ι') → M' i)

full_name: ContinuousMultilinearMap.coe_pi
code: @[simp]
theorem coe_pi {ι' : Type*} {M' : ι' → Type*} [∀ i, AddCommMonoid (M' i)]
    [∀ i, TopologicalSpace (M' i)] [∀ i, Module R (M' i)]
    (f : ∀ i, ContinuousMultilinearMap R M₁ (M' i)) : ⇑(pi f) = fun m j => f j m 
goal: ⇑(ContinuousMultilinearMap.pi f) = fun m j => (f j) m

full_name: ContinuousMultilinearMap.pi_apply
code: theorem pi_apply {ι' : Type*} {M' : ι' → Type*} [∀ i, AddCommMonoid (M' i)]
    [∀ i, TopologicalSpace (M' i)] [∀ i, Module R (M' i)]
    (f : ∀ i, ContinuousMultilinearMap R M₁ (M' i)) (m : ∀ i, M₁ i) (j : ι') : pi f m j = f j m 
goal: (ContinuousMultilinearMap.pi f) m j = (f j) m

full_name: ContinuousMultilinearMap.codRestrict_toMultilinearMap
code: /-- Restrict the codomain of a continuous multilinear map to a submodule. -/
@[simps! toMultilinearMap apply_coe]
def codRestrict (f : ContinuousMultilinearMap R M₁ M₂) (p : Submodule R M₂) (h : ∀ v, f v ∈ p) :
    ContinuousMultilinearMap R M₁ p 
goal: (f.codRestrict p h).toMultilinearMap = f.codRestrict p h

full_name: ContinuousMultilinearMap.codRestrict
code: /-- Restrict the codomain of a continuous multilinear map to a submodule. -/
@[simps! toMultilinearMap apply_coe]
def codRestrict (f : ContinuousMultilinearMap R M₁ M₂) (p : Submodule R M₂) (h : ∀ v, f v ∈ p) :
    ContinuousMultilinearMap R M₁ p 
goal: ContinuousMultilinearMap R M₁ ↥p

full_name: ContinuousMultilinearMap.codRestrict_apply_coe
code: /-- Restrict the codomain of a continuous multilinear map to a submodule. -/
@[simps! toMultilinearMap apply_coe]
def codRestrict (f : ContinuousMultilinearMap R M₁ M₂) (p : Submodule R M₂) (h : ∀ v, f v ∈ p) :
    ContinuousMultilinearMap R M₁ p 
goal: ↑((f.codRestrict p h) v) = f v

full_name: ContinuousMultilinearMap.ofSubsingleton_symm_apply_apply
code: /-- The natural equivalence between continuous linear maps from `M₂` to `M₃`
and continuous 1-multilinear maps from `M₂` to `M₃`. -/
@[simps! apply_toMultilinearMap apply_apply symm_apply_apply]
def ofSubsingleton [Subsingleton ι] (i : ι) :
    (M₂ →L[R] M₃) ≃ ContinuousMultilinearMap R (fun _ : ι => M₂) M₃ 
goal: ((ContinuousMultilinearMap.ofSubsingleton R M₂ M₃ i).symm f) x = f fun x_1 => x

full_name: ContinuousMultilinearMap.ofSubsingleton_apply_apply
code: /-- The natural equivalence between continuous linear maps from `M₂` to `M₃`
and continuous 1-multilinear maps from `M₂` to `M₃`. -/
@[simps! apply_toMultilinearMap apply_apply symm_apply_apply]
def ofSubsingleton [Subsingleton ι] (i : ι) :
    (M₂ →L[R] M₃) ≃ ContinuousMultilinearMap R (fun _ : ι => M₂) M₃ 
goal: ((ContinuousMultilinearMap.ofSubsingleton R M₂ M₃ i) f) x = f (x i)

full_name: ContinuousMultilinearMap.ofSubsingleton_apply_toMultilinearMap
code: /-- The natural equivalence between continuous linear maps from `M₂` to `M₃`
and continuous 1-multilinear maps from `M₂` to `M₃`. -/
@[simps! apply_toMultilinearMap apply_apply symm_apply_apply]
def ofSubsingleton [Subsingleton ι] (i : ι) :
    (M₂ →L[R] M₃) ≃ ContinuousMultilinearMap R (fun _ : ι => M₂) M₃ 
goal: ((ContinuousMultilinearMap.ofSubsingleton R M₂ M₃ i) f).toMultilinearMap = (MultilinearMap.ofSubsingleton R M₂ M₃ i) ↑f

full_name: ContinuousMultilinearMap.ofSubsingleton
code: /-- The natural equivalence between continuous linear maps from `M₂` to `M₃`
and continuous 1-multilinear maps from `M₂` to `M₃`. -/
@[simps! apply_toMultilinearMap apply_apply symm_apply_apply]
def ofSubsingleton [Subsingleton ι] (i : ι) :
    (M₂ →L[R] M₃) ≃ ContinuousMultilinearMap R (fun _ : ι => M₂) M₃ 
goal: (M₂ →L[R] M₃) ≃ ContinuousMultilinearMap R (fun x => M₂) M₃

full_name: ContinuousMultilinearMap.constOfIsEmpty
code: /-- The constant map is multilinear when `ι` is empty. -/
@[simps! toMultilinearMap apply]
def constOfIsEmpty [IsEmpty ι] (m : M₂) : ContinuousMultilinearMap R M₁ M₂ 
goal: ContinuousMultilinearMap R M₁ M₂

full_name: ContinuousMultilinearMap.constOfIsEmpty_apply
code: /-- The constant map is multilinear when `ι` is empty. -/
@[simps! toMultilinearMap apply]
def constOfIsEmpty [IsEmpty ι] (m : M₂) : ContinuousMultilinearMap R M₁ M₂ 
goal: ∀ (a : (i : ι) → M₁ i), (ContinuousMultilinearMap.constOfIsEmpty R M₁ m) a = m

full_name: ContinuousMultilinearMap.constOfIsEmpty_toMultilinearMap
code: /-- The constant map is multilinear when `ι` is empty. -/
@[simps! toMultilinearMap apply]
def constOfIsEmpty [IsEmpty ι] (m : M₂) : ContinuousMultilinearMap R M₁ M₂ 
goal: (ContinuousMultilinearMap.constOfIsEmpty R M₁ m).toMultilinearMap = MultilinearMap.constOfIsEmpty R M₁ m

full_name: ContinuousMultilinearMap.compContinuousLinearMap
code: /-- If `g` is continuous multilinear and `f` is a collection of continuous linear maps,
then `g (f₁ m₁, ..., fₙ mₙ)` is again a continuous multilinear map, that we call
`g.compContinuousLinearMap f`. -/
def compContinuousLinearMap (g : ContinuousMultilinearMap R M₁' M₄)
    (f : ∀ i : ι, M₁ i →L[R] M₁' i) : ContinuousMultilinearMap R M₁ M₄ 
goal: ContinuousMultilinearMap R M₁ M₄

full_name: ContinuousMultilinearMap.compContinuousLinearMap_apply
code: @[simp]
theorem compContinuousLinearMap_apply (g : ContinuousMultilinearMap R M₁' M₄)
    (f : ∀ i : ι, M₁ i →L[R] M₁' i) (m : ∀ i, M₁ i) :
    g.compContinuousLinearMap f m = g fun i => f i <| m i 
goal: (g.compContinuousLinearMap f) m = g fun i => (f i) (m i)

full_name: ContinuousLinearMap.compContinuousMultilinearMap
code: /-- Composing a continuous multilinear map with a continuous linear map gives again a
continuous multilinear map. -/
def _root_.ContinuousLinearMap.compContinuousMultilinearMap (g : M₂ →L[R] M₃)
    (f : ContinuousMultilinearMap R M₁ M₂) : ContinuousMultilinearMap R M₁ M₃ 
goal: ContinuousMultilinearMap R M₁ M₃

full_name: ContinuousLinearMap.compContinuousMultilinearMap_coe
code: @[simp]
theorem _root_.ContinuousLinearMap.compContinuousMultilinearMap_coe (g : M₂ →L[R] M₃)
    (f : ContinuousMultilinearMap R M₁ M₂) :
    (g.compContinuousMultilinearMap f : (∀ i, M₁ i) → M₃) =
      (g : M₂ → M₃) ∘ (f : (∀ i, M₁ i) → M₂) 
goal: ⇑(g.compContinuousMultilinearMap f) = ⇑g ∘ ⇑f

full_name: ContinuousMultilinearMap.piEquiv_symm_apply
code: /-- `ContinuousMultilinearMap.pi` as an `Equiv`. -/
@[simps]
def piEquiv {ι' : Type*} {M' : ι' → Type*} [∀ i, AddCommMonoid (M' i)]
    [∀ i, TopologicalSpace (M' i)] [∀ i, Module R (M' i)] :
    (∀ i, ContinuousMultilinearMap R M₁ (M' i)) ≃ ContinuousMultilinearMap R M₁ (∀ i, M' i) 
goal: ContinuousMultilinearMap.piEquiv.symm f i = (ContinuousLinearMap.proj i).compContinuousMultilinearMap f

full_name: ContinuousMultilinearMap.piEquiv
code: /-- `ContinuousMultilinearMap.pi` as an `Equiv`. -/
@[simps]
def piEquiv {ι' : Type*} {M' : ι' → Type*} [∀ i, AddCommMonoid (M' i)]
    [∀ i, TopologicalSpace (M' i)] [∀ i, Module R (M' i)] :
    (∀ i, ContinuousMultilinearMap R M₁ (M' i)) ≃ ContinuousMultilinearMap R M₁ (∀ i, M' i) 
goal: ((i : ι') → ContinuousMultilinearMap R M₁ (M' i)) ≃ ContinuousMultilinearMap R M₁ ((i : ι') → M' i)

full_name: ContinuousMultilinearMap.piEquiv_apply
code: /-- `ContinuousMultilinearMap.pi` as an `Equiv`. -/
@[simps]
def piEquiv {ι' : Type*} {M' : ι' → Type*} [∀ i, AddCommMonoid (M' i)]
    [∀ i, TopologicalSpace (M' i)] [∀ i, Module R (M' i)] :
    (∀ i, ContinuousMultilinearMap R M₁ (M' i)) ≃ ContinuousMultilinearMap R M₁ (∀ i, M' i) 
goal: ContinuousMultilinearMap.piEquiv f = ContinuousMultilinearMap.pi f

full_name: ContinuousMultilinearMap.domDomCongr
code: /-- An equivalence of the index set defines an equivalence between the spaces of continuous
multilinear maps. This is the forward map of this equivalence. -/
@[simps! toMultilinearMap apply]
nonrec def domDomCongr {ι' : Type*} (e : ι ≃ ι')
    (f : ContinuousMultilinearMap R (fun _ : ι => M₂) M₃) :
    ContinuousMultilinearMap R (fun _ : ι' => M₂) M₃ 
goal: ContinuousMultilinearMap R (fun x => M₂) M₃

full_name: ContinuousMultilinearMap.domDomCongr_toMultilinearMap
code: /-- An equivalence of the index set defines an equivalence between the spaces of continuous
multilinear maps. This is the forward map of this equivalence. -/
@[simps! toMultilinearMap apply]
nonrec def domDomCongr {ι' : Type*} (e : ι ≃ ι')
    (f : ContinuousMultilinearMap R (fun _ : ι => M₂) M₃) :
    ContinuousMultilinearMap R (fun _ : ι' => M₂) M₃ 
goal: (ContinuousMultilinearMap.domDomCongr e f).toMultilinearMap = MultilinearMap.domDomCongr e f.toMultilinearMap

full_name: ContinuousMultilinearMap.domDomCongr_apply
code: /-- An equivalence of the index set defines an equivalence between the spaces of continuous
multilinear maps. This is the forward map of this equivalence. -/
@[simps! toMultilinearMap apply]
nonrec def domDomCongr {ι' : Type*} (e : ι ≃ ι')
    (f : ContinuousMultilinearMap R (fun _ : ι => M₂) M₃) :
    ContinuousMultilinearMap R (fun _ : ι' => M₂) M₃ 
goal: (ContinuousMultilinearMap.domDomCongr e f) v = f fun i => v (e i)

full_name: ContinuousMultilinearMap.domDomCongrEquiv
code: /-- An equivalence of the index set defines an equivalence between the spaces of continuous
multilinear maps. In case of normed spaces, this is a linear isometric equivalence, see
`ContinuousMultilinearMap.domDomCongrₗᵢ`. -/
@[simps]
def domDomCongrEquiv {ι' : Type*} (e : ι ≃ ι') :
    ContinuousMultilinearMap R (fun _ : ι => M₂) M₃ ≃
      ContinuousMultilinearMap R (fun _ : ι' => M₂) M₃ 
goal: ContinuousMultilinearMap R (fun x => M₂) M₃ ≃ ContinuousMultilinearMap R (fun x => M₂) M₃

full_name: ContinuousMultilinearMap.domDomCongrEquiv_apply
code: /-- An equivalence of the index set defines an equivalence between the spaces of continuous
multilinear maps. In case of normed spaces, this is a linear isometric equivalence, see
`ContinuousMultilinearMap.domDomCongrₗᵢ`. -/
@[simps]
def domDomCongrEquiv {ι' : Type*} (e : ι ≃ ι') :
    ContinuousMultilinearMap R (fun _ : ι => M₂) M₃ ≃
      ContinuousMultilinearMap R (fun _ : ι' => M₂) M₃ 
goal: (ContinuousMultilinearMap.domDomCongrEquiv e) f = ContinuousMultilinearMap.domDomCongr e f

full_name: ContinuousMultilinearMap.domDomCongrEquiv_symm_apply
code: /-- An equivalence of the index set defines an equivalence between the spaces of continuous
multilinear maps. In case of normed spaces, this is a linear isometric equivalence, see
`ContinuousMultilinearMap.domDomCongrₗᵢ`. -/
@[simps]
def domDomCongrEquiv {ι' : Type*} (e : ι ≃ ι') :
    ContinuousMultilinearMap R (fun _ : ι => M₂) M₃ ≃
      ContinuousMultilinearMap R (fun _ : ι' => M₂) M₃ 
goal: (ContinuousMultilinearMap.domDomCongrEquiv e).symm f = ContinuousMultilinearMap.domDomCongr e.symm f

full_name: ContinuousMultilinearMap.linearDeriv
code: /-- The derivative of a continuous multilinear map, as a continuous linear map
from `∀ i, M₁ i` to `M₂`; see `ContinuousMultilinearMap.hasFDerivAt`. -/
def linearDeriv : (∀ i, M₁ i) →L[R] M₂ 
goal: ((i : ι) → M₁ i) →L[R] M₂

full_name: ContinuousMultilinearMap.linearDeriv_apply
code: @[simp]
lemma linearDeriv_apply : f.linearDeriv x y = ∑ i, f (Function.update x i (y i)) 
goal: (f.linearDeriv x) y = ∑ i : ι, f (Function.update x i (y i))

full_name: ContinuousMultilinearMap.cons_add
code: /-- In the specific case of continuous multilinear maps on spaces indexed by `Fin (n+1)`, where one
can build an element of `(i : Fin (n+1)) → M i` using `cons`, one can express directly the
additivity of a multilinear map along the first variable. -/
theorem cons_add (f : ContinuousMultilinearMap R M M₂) (m : ∀ i : Fin n, M i.succ) (x y : M 0) :
    f (cons (x + y) m) = f (cons x m) + f (cons y m) 
goal: f (Fin.cons (x + y) m) = f (Fin.cons x m) + f (Fin.cons y m)

full_name: ContinuousMultilinearMap.cons_smul
code: /-- In the specific case of continuous multilinear maps on spaces indexed by `Fin (n+1)`, where one
can build an element of `(i : Fin (n+1)) → M i` using `cons`, one can express directly the
multiplicativity of a multilinear map along the first variable. -/
theorem cons_smul (f : ContinuousMultilinearMap R M M₂) (m : ∀ i : Fin n, M i.succ) (c : R)
    (x : M 0) : f (cons (c • x) m) = c • f (cons x m) 
goal: f (Fin.cons (c • x) m) = c • f (Fin.cons x m)

full_name: ContinuousMultilinearMap.map_piecewise_add
code: theorem map_piecewise_add [DecidableEq ι] (m m' : ∀ i, M₁ i) (t : Finset ι) :
    f (t.piecewise (m + m') m') = ∑ s ∈ t.powerset, f (s.piecewise m m') 
goal: f (t.piecewise (m + m') m') = ∑ s ∈ t.powerset, f (s.piecewise m m')

full_name: ContinuousMultilinearMap.map_add_univ
code: /-- Additivity of a continuous multilinear map along all coordinates at the same time,
writing `f (m + m')` as the sum of `f (s.piecewise m m')` over all sets `s`. -/
theorem map_add_univ [DecidableEq ι] [Fintype ι] (m m' : ∀ i, M₁ i) :
    f (m + m') = ∑ s : Finset ι, f (s.piecewise m m') 
goal: f (m + m') = ∑ s : Finset ι, f (s.piecewise m m')

full_name: ContinuousMultilinearMap.map_sum_finset
code: /-- If `f` is continuous multilinear, then `f (Σ_{j₁ ∈ A₁} g₁ j₁, ..., Σ_{jₙ ∈ Aₙ} gₙ jₙ)` is the
sum of `f (g₁ (r 1), ..., gₙ (r n))` where `r` ranges over all functions with `r 1 ∈ A₁`, ...,
`r n ∈ Aₙ`. This follows from multilinearity by expanding successively with respect to each
coordinate. -/
theorem map_sum_finset [DecidableEq ι] :
    (f fun i => ∑ j ∈ A i, g i j) = ∑ r ∈ piFinset A, f fun i => g i (r i) 
goal: (f fun i => ∑ j ∈ A i, g i j) = ∑ r ∈ Fintype.piFinset A, f fun i => g i (r i)

full_name: ContinuousMultilinearMap.map_sum
code: /-- If `f` is continuous multilinear, then `f (Σ_{j₁} g₁ j₁, ..., Σ_{jₙ} gₙ jₙ)` is the sum of
`f (g₁ (r 1), ..., gₙ (r n))` where `r` ranges over all functions `r`. This follows from
multilinearity by expanding successively with respect to each coordinate. -/
theorem map_sum [DecidableEq ι] [∀ i, Fintype (α i)] :
    (f fun i => ∑ j, g i j) = ∑ r : ∀ i, α i, f fun i => g i (r i) 
goal: (f fun i => ∑ j : α i, g i j) = ∑ r : (i : ι) → α i, f fun i => g i (r i)

full_name: ContinuousMultilinearMap.restrictScalars
code: /-- Reinterpret an `A`-multilinear map as an `R`-multilinear map, if `A` is an algebra over `R`
and their actions on all involved modules agree with the action of `R` on `A`. -/
def restrictScalars (f : ContinuousMultilinearMap A M₁ M₂) : ContinuousMultilinearMap R M₁ M₂ 
goal: ContinuousMultilinearMap R M₁ M₂

full_name: ContinuousMultilinearMap.coe_restrictScalars
code: @[simp]
theorem coe_restrictScalars (f : ContinuousMultilinearMap A M₁ M₂) : ⇑(f.restrictScalars R) = f 
goal: ⇑(ContinuousMultilinearMap.restrictScalars R f) = ⇑f

full_name: ContinuousMultilinearMap.map_sub
code: @[simp]
theorem map_sub [DecidableEq ι] (m : ∀ i, M₁ i) (i : ι) (x y : M₁ i) :
    f (update m i (x - y)) = f (update m i x) - f (update m i y) 
goal: f (Function.update m i (x - y)) = f (Function.update m i x) - f (Function.update m i y)

full_name: ContinuousMultilinearMap.instNeg
code: instance : Neg (ContinuousMultilinearMap R M₁ M₂) 
goal: Neg (ContinuousMultilinearMap R M₁ M₂)

full_name: ContinuousMultilinearMap.neg_apply
code: @[simp]
theorem neg_apply (m : ∀ i, M₁ i) : (-f) m = -f m 
goal: (-f) m = -f m

full_name: ContinuousMultilinearMap.instSub
code: instance : Sub (ContinuousMultilinearMap R M₁ M₂) 
goal: Sub (ContinuousMultilinearMap R M₁ M₂)

full_name: ContinuousMultilinearMap.sub_apply
code: @[simp]
theorem sub_apply (m : ∀ i, M₁ i) : (f - f') m = f m - f' m 
goal: (f - f') m = f m - f' m

full_name: ContinuousMultilinearMap.instAddCommGroup
code: instance : AddCommGroup (ContinuousMultilinearMap R M₁ M₂) 
goal: AddCommGroup (ContinuousMultilinearMap R M₁ M₂)

full_name: ContinuousMultilinearMap.map_piecewise_smul
code: theorem map_piecewise_smul [DecidableEq ι] (c : ι → R) (m : ∀ i, M₁ i) (s : Finset ι) :
    f (s.piecewise (fun i => c i • m i) m) = (∏ i ∈ s, c i) • f m 
goal: f (s.piecewise (fun i => c i • m i) m) = (∏ i ∈ s, c i) • f m

full_name: ContinuousMultilinearMap.map_smul_univ
code: /-- Multiplicativity of a continuous multilinear map along all coordinates at the same time,
writing `f (fun i ↦ c i • m i)` as `(∏ i, c i) • f m`. -/
theorem map_smul_univ [Fintype ι] (c : ι → R) (m : ∀ i, M₁ i) :
    (f fun i => c i • m i) = (∏ i, c i) • f m 
goal: (f fun i => c i • m i) = (∏ i : ι, c i) • f m

full_name: ContinuousMultilinearMap.instDistribMulAction
code: instance [ContinuousAdd M₂] : DistribMulAction R' (ContinuousMultilinearMap A M₁ M₂) 
goal: DistribMulAction R' (ContinuousMultilinearMap A M₁ M₂)

full_name: ContinuousMultilinearMap.instModule
code: /-- The space of continuous multilinear maps over an algebra over `R` is a module over `R`, for the
pointwise addition and scalar multiplication. -/
instance : Module R' (ContinuousMultilinearMap A M₁ M₂) 
goal: Module R' (ContinuousMultilinearMap A M₁ M₂)

full_name: ContinuousMultilinearMap.toMultilinearMapLinear
code: /-- Linear map version of the map `toMultilinearMap` associating to a continuous multilinear map
the corresponding multilinear map. -/
@[simps]
def toMultilinearMapLinear : ContinuousMultilinearMap A M₁ M₂ →ₗ[R'] MultilinearMap A M₁ M₂ 
goal: ContinuousMultilinearMap A M₁ M₂ →ₗ[R'] MultilinearMap A M₁ M₂

full_name: ContinuousMultilinearMap.toMultilinearMapLinear_apply
code: /-- Linear map version of the map `toMultilinearMap` associating to a continuous multilinear map
the corresponding multilinear map. -/
@[simps]
def toMultilinearMapLinear : ContinuousMultilinearMap A M₁ M₂ →ₗ[R'] MultilinearMap A M₁ M₂ 
goal: ContinuousMultilinearMap.toMultilinearMapLinear self = self.toMultilinearMap

full_name: ContinuousMultilinearMap.piLinearEquiv_apply
code: /-- `ContinuousMultilinearMap.pi` as a `LinearEquiv`. -/
@[simps (config := { simpRhs := true })]
def piLinearEquiv {ι' : Type*} {M' : ι' → Type*} [∀ i, AddCommMonoid (M' i)]
    [∀ i, TopologicalSpace (M' i)] [∀ i, ContinuousAdd (M' i)] [∀ i, Module R' (M' i)]
    [∀ i, Module A (M' i)] [∀ i, SMulCommClass A R' (M' i)] [∀ i, ContinuousConstSMul R' (M' i)] :
    (∀ i, ContinuousMultilinearMap A M₁ (M' i)) ≃ₗ[R'] ContinuousMultilinearMap A M₁ (∀ i, M' i) 
goal: ∀ (a : (i : ι') → ContinuousMultilinearMap A M₁ (M' i)),
  ContinuousMultilinearMap.piLinearEquiv a = ContinuousMultilinearMap.pi a

full_name: ContinuousMultilinearMap.piLinearEquiv
code: /-- `ContinuousMultilinearMap.pi` as a `LinearEquiv`. -/
@[simps (config := { simpRhs := true })]
def piLinearEquiv {ι' : Type*} {M' : ι' → Type*} [∀ i, AddCommMonoid (M' i)]
    [∀ i, TopologicalSpace (M' i)] [∀ i, ContinuousAdd (M' i)] [∀ i, Module R' (M' i)]
    [∀ i, Module A (M' i)] [∀ i, SMulCommClass A R' (M' i)] [∀ i, ContinuousConstSMul R' (M' i)] :
    (∀ i, ContinuousMultilinearMap A M₁ (M' i)) ≃ₗ[R'] ContinuousMultilinearMap A M₁ (∀ i, M' i) 
goal: ((i : ι') → ContinuousMultilinearMap A M₁ (M' i)) ≃ₗ[R'] ContinuousMultilinearMap A M₁ ((i : ι') → M' i)

full_name: ContinuousMultilinearMap.piLinearEquiv_symm_apply
code: /-- `ContinuousMultilinearMap.pi` as a `LinearEquiv`. -/
@[simps (config := { simpRhs := true })]
def piLinearEquiv {ι' : Type*} {M' : ι' → Type*} [∀ i, AddCommMonoid (M' i)]
    [∀ i, TopologicalSpace (M' i)] [∀ i, ContinuousAdd (M' i)] [∀ i, Module R' (M' i)]
    [∀ i, Module A (M' i)] [∀ i, SMulCommClass A R' (M' i)] [∀ i, ContinuousConstSMul R' (M' i)] :
    (∀ i, ContinuousMultilinearMap A M₁ (M' i)) ≃ₗ[R'] ContinuousMultilinearMap A M₁ (∀ i, M' i) 
goal: ∀ (a : ContinuousMultilinearMap A M₁ ((i : ι') → M' i)) (i : ι'),
  ContinuousMultilinearMap.piLinearEquiv.symm a i = (ContinuousLinearMap.proj i).compContinuousMultilinearMap a

full_name: ContinuousMultilinearMap.mkPiAlgebra
code: /-- The continuous multilinear map on `A^ι`, where `A` is a normed commutative algebra
over `𝕜`, associating to `m` the product of all the `m i`.

See also `ContinuousMultilinearMap.mkPiAlgebraFin`. -/
protected def mkPiAlgebra : ContinuousMultilinearMap R (fun _ : ι => A) A 
goal: ContinuousMultilinearMap R (fun x => A) A

full_name: ContinuousMultilinearMap.mkPiAlgebra_apply
code: @[simp]
theorem mkPiAlgebra_apply (m : ι → A) : ContinuousMultilinearMap.mkPiAlgebra R ι A m = ∏ i, m i 
goal: (ContinuousMultilinearMap.mkPiAlgebra R ι A) m = ∏ i : ι, m i

full_name: ContinuousMultilinearMap.mkPiAlgebraFin
code: /-- The continuous multilinear map on `A^n`, where `A` is a normed algebra over `𝕜`, associating to
`m` the product of all the `m i`.

See also: `ContinuousMultilinearMap.mkPiAlgebra`. -/
protected def mkPiAlgebraFin : A[×n]→L[R] A 
goal: ContinuousMultilinearMap R (fun i => A) A

full_name: ContinuousMultilinearMap.mkPiAlgebraFin_apply
code: @[simp]
theorem mkPiAlgebraFin_apply (m : Fin n → A) :
    ContinuousMultilinearMap.mkPiAlgebraFin R n A m = (List.ofFn m).prod 
goal: (ContinuousMultilinearMap.mkPiAlgebraFin R n A) m = (List.ofFn m).prod

full_name: ContinuousMultilinearMap.smulRight
code: /-- Given a continuous `R`-multilinear map `f` taking values in `R`, `f.smulRight z` is the
continuous multilinear map sending `m` to `f m • z`. -/
@[simps! toMultilinearMap apply]
def smulRight : ContinuousMultilinearMap R M₁ M₂ 
goal: ContinuousMultilinearMap R M₁ M₂

full_name: ContinuousMultilinearMap.smulRight_apply
code: /-- Given a continuous `R`-multilinear map `f` taking values in `R`, `f.smulRight z` is the
continuous multilinear map sending `m` to `f m • z`. -/
@[simps! toMultilinearMap apply]
def smulRight : ContinuousMultilinearMap R M₁ M₂ 
goal: ∀ (a : (i : ι) → M₁ i), (f.smulRight z) a = f a • z

full_name: ContinuousMultilinearMap.smulRight_toMultilinearMap
code: /-- Given a continuous `R`-multilinear map `f` taking values in `R`, `f.smulRight z` is the
continuous multilinear map sending `m` to `f m • z`. -/
@[simps! toMultilinearMap apply]
def smulRight : ContinuousMultilinearMap R M₁ M₂ 
goal: (f.smulRight z).toMultilinearMap = f.smulRight z

full_name: ContinuousMultilinearMap.mkPiRing
code: /-- The canonical continuous multilinear map on `R^ι`, associating to `m` the product of all the
`m i` (multiplied by a fixed reference element `z` in the target module) -/
protected def mkPiRing (z : M) : ContinuousMultilinearMap R (fun _ : ι => R) M 
goal: ContinuousMultilinearMap R (fun x => R) M

full_name: ContinuousMultilinearMap.mkPiRing_apply
code: @[simp]
theorem mkPiRing_apply (z : M) (m : ι → R) :
    (ContinuousMultilinearMap.mkPiRing R ι z : (ι → R) → M) m = (∏ i, m i) • z 
goal: (ContinuousMultilinearMap.mkPiRing R ι z) m = (∏ i : ι, m i) • z

full_name: ContinuousMultilinearMap.mkPiRing_apply_one_eq_self
code: theorem mkPiRing_apply_one_eq_self (f : ContinuousMultilinearMap R (fun _ : ι => R) M) :
    ContinuousMultilinearMap.mkPiRing R ι (f fun _ => 1) = f 
goal: ContinuousMultilinearMap.mkPiRing R ι (f fun x => 1) = f

full_name: ContinuousMultilinearMap.mkPiRing_eq_iff
code: theorem mkPiRing_eq_iff {z₁ z₂ : M} :
    ContinuousMultilinearMap.mkPiRing R ι z₁ = ContinuousMultilinearMap.mkPiRing R ι z₂ ↔
      z₁ = z₂ 
goal: ContinuousMultilinearMap.mkPiRing R ι z₁ = ContinuousMultilinearMap.mkPiRing R ι z₂ ↔ z₁ = z₂

full_name: ContinuousMultilinearMap.mkPiRing_zero
code: theorem mkPiRing_zero : ContinuousMultilinearMap.mkPiRing R ι (0 : M) = 0 
goal: ContinuousMultilinearMap.mkPiRing R ι 0 = 0

full_name: ContinuousMultilinearMap.mkPiRing_eq_zero_iff
code: theorem mkPiRing_eq_zero_iff (z : M) : ContinuousMultilinearMap.mkPiRing R ι z = 0 ↔ z = 0 
goal: ContinuousMultilinearMap.mkPiRing R ι z = 0 ↔ z = 0