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

full_name: ContinuousAlternatingMap
code: /-- A continuous alternating map from `ι → M` to `N`, denoted `M [⋀^ι]→L[R] N`,
is a continuous map that is

- multilinear : `f (update m i (c • x)) = c • f (update m i x)` and
  `f (update m i (x + y)) = f (update m i x) + f (update m i y)`;
- alternating : `f v = 0` whenever `v` has two equal coordinates.
-/
structure ContinuousAlternatingMap (R M N ι : Type*) [Semiring R] [AddCommMonoid M] [Module R M]
    [TopologicalSpace M] [AddCommMonoid N] [Module R N] [TopologicalSpace N] extends
    ContinuousMultilinearMap R (fun _ : ι => M) N, M [⋀^ι]→ₗ[R] N where
goal: Type (max (max u_2 u_3) u_4)

full_name: «_aux_Mathlib_Topology_Algebra_Module_Alternating_Basic___macroRules_term_[⋀^_]→L[_]__1»
code: @[inherit_doc]
notation M " [⋀^" ι "]→L[" R "] " N:100 => ContinuousAlternatingMap R M N ι
goal: Lean.Macro

full_name: _aux_Mathlib_Topology_Algebra_Module_Alternating_Basic___unexpand_ContinuousAlternatingMap_1
code: @[inherit_doc]
notation M " [⋀^" ι "]→L[" R "] " N:100 => ContinuousAlternatingMap R M N ι
goal: Lean.PrettyPrinter.Unexpander

full_name: ContinuousAlternatingMap.toContinuousMultilinearMap_injective
code: theorem toContinuousMultilinearMap_injective :
    Injective (ContinuousAlternatingMap.toContinuousMultilinearMap :
      M [⋀^ι]→L[R] N → ContinuousMultilinearMap R (fun _ : ι => M) N)
  
goal: Function.Injective ContinuousAlternatingMap.toContinuousMultilinearMap

full_name: ContinuousAlternatingMap.range_toContinuousMultilinearMap
code: theorem range_toContinuousMultilinearMap :
    Set.range
        (toContinuousMultilinearMap :
          M [⋀^ι]→L[R] N → ContinuousMultilinearMap R (fun _ : ι => M) N) =
      {f | ∀ (v : ι → M) (i j : ι), v i = v j → i ≠ j → f v = 0} 
goal: Set.range ContinuousAlternatingMap.toContinuousMultilinearMap =
  {f | ∀ (v : ι → M) (i j : ι), v i = v j → i ≠ j → f v = 0}

full_name: ContinuousAlternatingMap.funLike
code: instance funLike : FunLike (M [⋀^ι]→L[R] N) (ι → M) N 
goal: FunLike (M [⋀^ι]→L[R] N) (ι → M) N

full_name: ContinuousAlternatingMap.continuousMapClass
code: instance continuousMapClass : ContinuousMapClass (M [⋀^ι]→L[R] N) (ι → M) N 
goal: ContinuousMapClass (M [⋀^ι]→L[R] N) (ι → M) N

full_name: ContinuousAlternatingMap.coe_continuous
code: @[continuity]
theorem coe_continuous : Continuous f 
goal: Continuous ⇑f

full_name: ContinuousAlternatingMap.coe_toContinuousMultilinearMap
code: @[simp]
theorem coe_toContinuousMultilinearMap : ⇑f.toContinuousMultilinearMap = f 
goal: ⇑f.toContinuousMultilinearMap = ⇑f

full_name: ContinuousAlternatingMap.coe_mk
code: @[simp]
theorem coe_mk (f : ContinuousMultilinearMap R (fun _ : ι => M) N) (h) : ⇑(mk f h) = f 
goal: ⇑{ toContinuousMultilinearMap := f, map_eq_zero_of_eq' := h } = ⇑f

full_name: ContinuousAlternatingMap.coe_toAlternatingMap
code: theorem coe_toAlternatingMap : ⇑f.toAlternatingMap = f 
goal: ⇑f.toAlternatingMap = ⇑f

full_name: ContinuousAlternatingMap.ext
code: @[ext]
theorem ext {f g : M [⋀^ι]→L[R] N} (H : ∀ x, f x = g x) : f = g 
goal: f = g

full_name: ContinuousAlternatingMap.ext_iff
code: theorem ext_iff {f g : M [⋀^ι]→L[R] N} : f = g ↔ ∀ x, f x = g x 
goal: f = g ↔ ∀ (x : ι → M), f x = g x

full_name: ContinuousAlternatingMap.toAlternatingMap_injective
code: theorem toAlternatingMap_injective :
    Injective (toAlternatingMap : (M [⋀^ι]→L[R] N) → (M [⋀^ι]→ₗ[R] N)) 
goal: Function.Injective ContinuousAlternatingMap.toAlternatingMap

full_name: ContinuousAlternatingMap.range_toAlternatingMap
code: @[simp]
theorem range_toAlternatingMap :
    Set.range (toAlternatingMap : M [⋀^ι]→L[R] N → (M [⋀^ι]→ₗ[R] N)) =
      {f : M [⋀^ι]→ₗ[R] N | Continuous f} 
goal: Set.range ContinuousAlternatingMap.toAlternatingMap = {f | Continuous ⇑f}

full_name: ContinuousAlternatingMap.map_add
code: @[simp]
theorem map_add [DecidableEq ι] (m : ι → M) (i : ι) (x y : M) :
    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: ContinuousAlternatingMap.map_smul
code: @[simp]
theorem map_smul [DecidableEq ι] (m : ι → M) (i : ι) (c : R) (x : M) :
    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: ContinuousAlternatingMap.map_coord_zero
code: theorem map_coord_zero {m : ι → M} (i : ι) (h : m i = 0) : f m = 0 
goal: f m = 0

full_name: ContinuousAlternatingMap.map_update_zero
code: @[simp]
theorem map_update_zero [DecidableEq ι] (m : ι → M) (i : ι) : f (update m i 0) = 0 
goal: f (Function.update m i 0) = 0

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

full_name: ContinuousAlternatingMap.map_eq_zero_of_eq
code: theorem map_eq_zero_of_eq (v : ι → M) {i j : ι} (h : v i = v j) (hij : i ≠ j) : f v = 0 
goal: f v = 0

full_name: ContinuousAlternatingMap.map_eq_zero_of_not_injective
code: theorem map_eq_zero_of_not_injective (v : ι → M) (hv : ¬Function.Injective v) : f v = 0 
goal: f v = 0

full_name: ContinuousAlternatingMap.codRestrict
code: /-- Restrict the codomain of a continuous alternating map to a submodule. -/
@[simps!]
def codRestrict (f : M [⋀^ι]→L[R] N) (p : Submodule R N) (h : ∀ v, f v ∈ p) : M [⋀^ι]→L[R] p 
goal: M [⋀^ι]→L[R] ↥p

full_name: ContinuousAlternatingMap.codRestrict_apply_coe
code: /-- Restrict the codomain of a continuous alternating map to a submodule. -/
@[simps!]
def codRestrict (f : M [⋀^ι]→L[R] N) (p : Submodule R N) (h : ∀ v, f v ∈ p) : M [⋀^ι]→L[R] p 
goal: ↑((f.codRestrict p h) v) = f v

full_name: ContinuousAlternatingMap.instZero
code: instance : Zero (M [⋀^ι]→L[R] N) 
goal: Zero (M [⋀^ι]→L[R] N)

full_name: ContinuousAlternatingMap.instInhabited
code: instance : Inhabited (M [⋀^ι]→L[R] N) 
goal: Inhabited (M [⋀^ι]→L[R] N)

full_name: ContinuousAlternatingMap.coe_zero
code: @[simp]
theorem coe_zero : ⇑(0 : M [⋀^ι]→L[R] N) = 0 
goal: ⇑0 = 0

full_name: ContinuousAlternatingMap.toContinuousMultilinearMap_zero
code: @[simp]
theorem toContinuousMultilinearMap_zero : (0 : M [⋀^ι]→L[R] N).toContinuousMultilinearMap = 0 
goal: ContinuousAlternatingMap.toContinuousMultilinearMap 0 = 0

full_name: ContinuousAlternatingMap.toAlternatingMap_zero
code: @[simp]
theorem toAlternatingMap_zero : (0 : M [⋀^ι]→L[R] N).toAlternatingMap = 0 
goal: ContinuousAlternatingMap.toAlternatingMap 0 = 0

full_name: ContinuousAlternatingMap.instSMul
code: instance : SMul R' (M [⋀^ι]→L[A] N) 
goal: SMul R' (M [⋀^ι]→L[A] N)

full_name: ContinuousAlternatingMap.coe_smul
code: @[simp]
theorem coe_smul (f : M [⋀^ι]→L[A] N) (c : R') : ⇑(c • f) = c • ⇑f 
goal: ⇑(c • f) = c • ⇑f

full_name: ContinuousAlternatingMap.smul_apply
code: theorem smul_apply (f : M [⋀^ι]→L[A] N) (c : R') (v : ι → M) : (c • f) v = c • f v 
goal: (c • f) v = c • f v

full_name: ContinuousAlternatingMap.toContinuousMultilinearMap_smul
code: @[simp]
theorem toContinuousMultilinearMap_smul (c : R') (f : M [⋀^ι]→L[A] N) :
    (c • f).toContinuousMultilinearMap = c • f.toContinuousMultilinearMap 
goal: (c • f).toContinuousMultilinearMap = c • f.toContinuousMultilinearMap

full_name: ContinuousAlternatingMap.toAlternatingMap_smul
code: @[simp]
theorem toAlternatingMap_smul (c : R') (f : M [⋀^ι]→L[A] N) :
    (c • f).toAlternatingMap = c • f.toAlternatingMap 
goal: (c • f).toAlternatingMap = c • f.toAlternatingMap

full_name: ContinuousAlternatingMap.instSMulCommClass
code: instance [SMulCommClass R' R'' N] : SMulCommClass R' R'' (M [⋀^ι]→L[A] N) 
goal: SMulCommClass R' R'' (M [⋀^ι]→L[A] N)

full_name: ContinuousAlternatingMap.instIsScalarTower
code: instance [SMul R' R''] [IsScalarTower R' R'' N] : IsScalarTower R' R'' (M [⋀^ι]→L[A] N) 
goal: IsScalarTower R' R'' (M [⋀^ι]→L[A] N)

full_name: ContinuousAlternatingMap.instIsCentralScalar
code: instance [DistribMulAction R'ᵐᵒᵖ N] [IsCentralScalar R' N] : IsCentralScalar R' (M [⋀^ι]→L[A] N) 
goal: IsCentralScalar R' (M [⋀^ι]→L[A] N)

full_name: ContinuousAlternatingMap.instMulAction
code: instance : MulAction R' (M [⋀^ι]→L[A] N) 
goal: MulAction R' (M [⋀^ι]→L[A] N)

full_name: ContinuousAlternatingMap.instAdd
code: instance : Add (M [⋀^ι]→L[R] N) 
goal: Add (M [⋀^ι]→L[R] N)

full_name: ContinuousAlternatingMap.coe_add
code: @[simp]
theorem coe_add : ⇑(f + g) = ⇑f + ⇑g 
goal: ⇑(f + g) = ⇑f + ⇑g

full_name: ContinuousAlternatingMap.add_apply
code: @[simp]
theorem add_apply (v : ι → M) : (f + g) v = f v + g v 
goal: (f + g) v = f v + g v

full_name: ContinuousAlternatingMap.toContinuousMultilinearMap_add
code: @[simp]
theorem toContinuousMultilinearMap_add (f g : M [⋀^ι]→L[R] N) : (f + g).1 = f.1 + g.1 
goal: (f + g).toContinuousMultilinearMap = f.toContinuousMultilinearMap + g.toContinuousMultilinearMap

full_name: ContinuousAlternatingMap.toAlternatingMap_add
code: @[simp]
theorem toAlternatingMap_add (f g : M [⋀^ι]→L[R] N) :
    (f + g).toAlternatingMap = f.toAlternatingMap + g.toAlternatingMap 
goal: (f + g).toAlternatingMap = f.toAlternatingMap + g.toAlternatingMap

full_name: ContinuousAlternatingMap.addCommMonoid
code: instance addCommMonoid : AddCommMonoid (M [⋀^ι]→L[R] N) 
goal: AddCommMonoid (M [⋀^ι]→L[R] N)

full_name: ContinuousAlternatingMap.applyAddHom
code: /-- Evaluation of a `ContinuousAlternatingMap` at a vector as an `AddMonoidHom`. -/
def applyAddHom (v : ι → M) : M [⋀^ι]→L[R] N →+ N 
goal: M [⋀^ι]→L[R] N →+ N

full_name: ContinuousAlternatingMap.sum_apply
code: @[simp]
theorem sum_apply {α : Type*} (f : α → M [⋀^ι]→L[R] N) (m : ι → M) {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: ContinuousAlternatingMap.toMultilinearAddHom_apply
code: /-- Projection to `ContinuousMultilinearMap`s as a bundled `AddMonoidHom`. -/
@[simps]
def toMultilinearAddHom : M [⋀^ι]→L[R] N →+ ContinuousMultilinearMap R (fun _ : ι => M) N 
goal: ContinuousAlternatingMap.toMultilinearAddHom f = f.toContinuousMultilinearMap

full_name: ContinuousAlternatingMap.toMultilinearAddHom
code: /-- Projection to `ContinuousMultilinearMap`s as a bundled `AddMonoidHom`. -/
@[simps]
def toMultilinearAddHom : M [⋀^ι]→L[R] N →+ ContinuousMultilinearMap R (fun _ : ι => M) N 
goal: M [⋀^ι]→L[R] N →+ ContinuousMultilinearMap R (fun x => M) N

full_name: ContinuousAlternatingMap.toContinuousLinearMap
code: /-- If `f` is a continuous alternating 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. -/
@[simps! apply]
def toContinuousLinearMap [DecidableEq ι] (m : ι → M) (i : ι) : M →L[R] N 
goal: M →L[R] N

full_name: ContinuousAlternatingMap.toContinuousLinearMap_apply
code: /-- If `f` is a continuous alternating 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. -/
@[simps! apply]
def toContinuousLinearMap [DecidableEq ι] (m : ι → M) (i : ι) : M →L[R] N 
goal: (f.toContinuousLinearMap m i) x = f (Function.update m i x)

full_name: ContinuousAlternatingMap.prod_apply
code: /-- The cartesian product of two continuous alternating maps, as a continuous alternating map. -/
@[simps!]
def prod (f : M [⋀^ι]→L[R] N) (g : M [⋀^ι]→L[R] N') : M [⋀^ι]→L[R] (N × N') 
goal: (f.prod g) m = (f m, g m)

full_name: ContinuousAlternatingMap.prod
code: /-- The cartesian product of two continuous alternating maps, as a continuous alternating map. -/
@[simps!]
def prod (f : M [⋀^ι]→L[R] N) (g : M [⋀^ι]→L[R] N') : M [⋀^ι]→L[R] (N × N') 
goal: M [⋀^ι]→L[R] (N × N')

full_name: ContinuousAlternatingMap.pi
code: /-- Combine a family of continuous alternating maps with the same domain and codomains `M' i` into a
continuous alternating 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, M [⋀^ι]→L[R] M' i) : M [⋀^ι]→L[R] ∀ i, M' i 
goal: M [⋀^ι]→L[R] ((i : ι') → M' i)

full_name: ContinuousAlternatingMap.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, M [⋀^ι]→L[R] M' i) :
    ⇑(pi f) = fun m j => f j m 
goal: ⇑(ContinuousAlternatingMap.pi f) = fun m j => (f j) m

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

full_name: ContinuousAlternatingMap.ofSubsingleton_apply_toContinuousMultilinearMap
code: /-- The natural equivalence between continuous linear maps from `M` to `N`
and continuous 1-multilinear alternating maps from `M` to `N`. -/
@[simps! apply_apply symm_apply_apply apply_toContinuousMultilinearMap]
def ofSubsingleton [Subsingleton ι] (i : ι) :
    (M →L[R] N) ≃ M [⋀^ι]→L[R] N 
goal: ((ContinuousAlternatingMap.ofSubsingleton R M N i) f).toContinuousMultilinearMap =
  (ContinuousMultilinearMap.ofSubsingleton R M N i) f

full_name: ContinuousAlternatingMap.ofSubsingleton
code: /-- The natural equivalence between continuous linear maps from `M` to `N`
and continuous 1-multilinear alternating maps from `M` to `N`. -/
@[simps! apply_apply symm_apply_apply apply_toContinuousMultilinearMap]
def ofSubsingleton [Subsingleton ι] (i : ι) :
    (M →L[R] N) ≃ M [⋀^ι]→L[R] N 
goal: (M →L[R] N) ≃ M [⋀^ι]→L[R] N

full_name: ContinuousAlternatingMap.ofSubsingleton_apply_apply
code: /-- The natural equivalence between continuous linear maps from `M` to `N`
and continuous 1-multilinear alternating maps from `M` to `N`. -/
@[simps! apply_apply symm_apply_apply apply_toContinuousMultilinearMap]
def ofSubsingleton [Subsingleton ι] (i : ι) :
    (M →L[R] N) ≃ M [⋀^ι]→L[R] N 
goal: ((ContinuousAlternatingMap.ofSubsingleton R M N i) f) x = f (x i)

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

full_name: ContinuousAlternatingMap.ofSubsingleton_toAlternatingMap
code: @[simp]
theorem ofSubsingleton_toAlternatingMap [Subsingleton ι] (i : ι) (f : M →L[R] N) :
    (ofSubsingleton R M N i f).toAlternatingMap = AlternatingMap.ofSubsingleton R M N i f 
goal: ((ContinuousAlternatingMap.ofSubsingleton R M N i) f).toAlternatingMap = (AlternatingMap.ofSubsingleton R M N i) ↑f

full_name: ContinuousAlternatingMap.constOfIsEmpty_apply
code: /-- The constant map is alternating when `ι` is empty. -/
@[simps! toContinuousMultilinearMap apply]
def constOfIsEmpty [IsEmpty ι] (m : N) : M [⋀^ι]→L[R] N 
goal: ∀ (a : (i : ι) → (fun x => M) i), (ContinuousAlternatingMap.constOfIsEmpty R M ι m) a = m

full_name: ContinuousAlternatingMap.constOfIsEmpty
code: /-- The constant map is alternating when `ι` is empty. -/
@[simps! toContinuousMultilinearMap apply]
def constOfIsEmpty [IsEmpty ι] (m : N) : M [⋀^ι]→L[R] N 
goal: M [⋀^ι]→L[R] N

full_name: ContinuousAlternatingMap.constOfIsEmpty_toContinuousMultilinearMap
code: /-- The constant map is alternating when `ι` is empty. -/
@[simps! toContinuousMultilinearMap apply]
def constOfIsEmpty [IsEmpty ι] (m : N) : M [⋀^ι]→L[R] N 
goal: (ContinuousAlternatingMap.constOfIsEmpty R M ι m).toContinuousMultilinearMap =
  ContinuousMultilinearMap.constOfIsEmpty R (fun x => M) m

full_name: ContinuousAlternatingMap.constOfIsEmpty_toAlternatingMap
code: @[simp]
theorem constOfIsEmpty_toAlternatingMap [IsEmpty ι] (m : N) :
    (constOfIsEmpty R M ι m).toAlternatingMap = AlternatingMap.constOfIsEmpty R M ι m 
goal: (ContinuousAlternatingMap.constOfIsEmpty R M ι m).toAlternatingMap = AlternatingMap.constOfIsEmpty R M ι m

full_name: ContinuousAlternatingMap.compContinuousLinearMap
code: /-- If `g` is continuous alternating and `f` is a continuous linear map, then `g (f m₁, ..., f mₙ)`
is again a continuous alternating map, that we call `g.compContinuousLinearMap f`. -/
def compContinuousLinearMap (g : M [⋀^ι]→L[R] N) (f : M' →L[R] M) : M' [⋀^ι]→L[R] N 
goal: M' [⋀^ι]→L[R] N

full_name: ContinuousAlternatingMap.compContinuousLinearMap_apply
code: @[simp]
theorem compContinuousLinearMap_apply (g : M [⋀^ι]→L[R] N) (f : M' →L[R] M) (m : ι → M') :
    g.compContinuousLinearMap f m = g (f ∘ m) 
goal: (g.compContinuousLinearMap f) m = g (⇑f ∘ m)

full_name: ContinuousLinearMap.compContinuousAlternatingMap
code: /-- Composing a continuous alternating map with a continuous linear map gives again a
continuous alternating map. -/
def _root_.ContinuousLinearMap.compContinuousAlternatingMap (g : N →L[R] N') (f : M [⋀^ι]→L[R] N) :
    M [⋀^ι]→L[R] N' 
goal: M [⋀^ι]→L[R] N'

full_name: ContinuousLinearMap.compContinuousAlternatingMap_coe
code: @[simp]
theorem _root_.ContinuousLinearMap.compContinuousAlternatingMap_coe (g : N →L[R] N')
    (f : M [⋀^ι]→L[R] N) : ⇑(g.compContinuousAlternatingMap f) = g ∘ f 
goal: ⇑(g.compContinuousAlternatingMap f) = ⇑g ∘ ⇑f

full_name: ContinuousLinearEquiv.continuousAlternatingMapComp
code: /-- A continuous linear equivalence of domains defines an equivalence between continuous
alternating maps. -/
def _root_.ContinuousLinearEquiv.continuousAlternatingMapComp (e : M ≃L[R] M') :
    M [⋀^ι]→L[R] N ≃ M' [⋀^ι]→L[R] N 
goal: M [⋀^ι]→L[R] N ≃ M' [⋀^ι]→L[R] N

full_name: ContinuousLinearEquiv.compContinuousAlternatingMap
code: /-- A continuous linear equivalence of codomains defines an equivalence between continuous
alternating maps. -/
def _root_.ContinuousLinearEquiv.compContinuousAlternatingMap (e : N ≃L[R] N') :
    M [⋀^ι]→L[R] N ≃ M [⋀^ι]→L[R] N' 
goal: M [⋀^ι]→L[R] N ≃ M [⋀^ι]→L[R] N'

full_name: ContinuousLinearEquiv.compContinuousAlternatingMap_coe
code: @[simp]
theorem _root_.ContinuousLinearEquiv.compContinuousAlternatingMap_coe
    (e : N ≃L[R] N') (f : M [⋀^ι]→L[R] N) : ⇑(e.compContinuousAlternatingMap f) = e ∘ f 
goal: ⇑(e.compContinuousAlternatingMap f) = ⇑e ∘ ⇑f

full_name: ContinuousLinearEquiv.continuousAlternatingMapCongr
code: /-- Continuous linear equivalences between domains and codomains define an equivalence between the
spaces of continuous alternating maps. -/
def _root_.ContinuousLinearEquiv.continuousAlternatingMapCongr (e : M ≃L[R] M') (e' : N ≃L[R] N') :
    M [⋀^ι]→L[R] N ≃ M' [⋀^ι]→L[R] N' 
goal: M [⋀^ι]→L[R] N ≃ M' [⋀^ι]→L[R] N'

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

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

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

full_name: ContinuousAlternatingMap.cons_add
code: /-- In the specific case of continuous alternating 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 an alternating map along the first variable. -/
theorem cons_add (f : ContinuousAlternatingMap R M N (Fin (n + 1))) (m : Fin n → M) (x y : M) :
    f (Fin.cons (x + y) m) = f (Fin.cons x m) + f (Fin.cons y m) 
goal: f (Fin.cons (x + y) m) = f (Fin.cons x m) + f (Fin.cons y m)

full_name: ContinuousAlternatingMap.vecCons_add
code: /-- In the specific case of continuous alternating 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 an alternating map along the first variable. -/
theorem vecCons_add (f : ContinuousAlternatingMap R M N (Fin (n + 1))) (m : Fin n → M) (x y : M) :
    f (vecCons (x + y) m) = f (vecCons x m) + f (vecCons y m) 
goal: f (Matrix.vecCons (x + y) m) = f (Matrix.vecCons x m) + f (Matrix.vecCons y m)

full_name: ContinuousAlternatingMap.cons_smul
code: /-- In the specific case of continuous alternating 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 an alternating map along the first variable. -/
theorem cons_smul (f : ContinuousAlternatingMap R M N (Fin (n + 1))) (m : Fin n → M) (c : R)
    (x : M) : f (Fin.cons (c • x) m) = c • f (Fin.cons x m) 
goal: f (Fin.cons (c • x) m) = c • f (Fin.cons x m)

full_name: ContinuousAlternatingMap.vecCons_smul
code: /-- In the specific case of continuous alternating 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 an alternating map along the first variable. -/
theorem vecCons_smul (f : ContinuousAlternatingMap R M N (Fin (n + 1))) (m : Fin n → M) (c : R)
    (x : M) : f (vecCons (c • x) m) = c • f (vecCons x m) 
goal: f (Matrix.vecCons (c • x) m) = c • f (Matrix.vecCons x m)

full_name: ContinuousAlternatingMap.map_piecewise_add
code: theorem map_piecewise_add [DecidableEq ι] (m m' : ι → M) (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: ContinuousAlternatingMap.map_add_univ
code: /-- Additivity of a continuous alternating 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' : ι → M) :
    f (m + m') = ∑ s : Finset ι, f (s.piecewise m m') 
goal: f (m + m') = ∑ s : Finset ι, f (s.piecewise m m')

full_name: ContinuousAlternatingMap.map_sum_finset
code: /-- If `f` is continuous alternating, 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 :
    (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: ContinuousAlternatingMap.map_sum
code: /-- If `f` is continuous alternating, 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 [∀ 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: ContinuousAlternatingMap.restrictScalars
code: /-- Reinterpret a continuous `A`-alternating map as a continuous `R`-alternating 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 : M [⋀^ι]→L[A] N) : M [⋀^ι]→L[R] N 
goal: M [⋀^ι]→L[R] N

full_name: ContinuousAlternatingMap.coe_restrictScalars
code: @[simp]
theorem coe_restrictScalars (f : M [⋀^ι]→L[A] N) : ⇑(f.restrictScalars R) = f 
goal: ⇑(ContinuousAlternatingMap.restrictScalars R f) = ⇑f

full_name: ContinuousAlternatingMap.map_sub
code: @[simp]
theorem map_sub [DecidableEq ι] (m : ι → M) (i : ι) (x y : M) :
    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: ContinuousAlternatingMap.instNeg
code: instance : Neg (M [⋀^ι]→L[R] N) 
goal: Neg (M [⋀^ι]→L[R] N)

full_name: ContinuousAlternatingMap.coe_neg
code: @[simp]
theorem coe_neg : ⇑(-f) = -f 
goal: ⇑(-f) = -⇑f

full_name: ContinuousAlternatingMap.neg_apply
code: theorem neg_apply (m : ι → M) : (-f) m = -f m 
goal: (-f) m = -f m

full_name: ContinuousAlternatingMap.instSub
code: instance : Sub (M [⋀^ι]→L[R] N) 
goal: Sub (M [⋀^ι]→L[R] N)

full_name: ContinuousAlternatingMap.coe_sub
code: @[simp] theorem coe_sub : ⇑(f - g) = ⇑f - ⇑g 
goal: ⇑(f - g) = ⇑f - ⇑g

full_name: ContinuousAlternatingMap.sub_apply
code: theorem sub_apply (m : ι → M) : (f - g) m = f m - g m 
goal: (f - g) m = f m - g m

full_name: ContinuousAlternatingMap.instAddCommGroup
code: instance : AddCommGroup (M [⋀^ι]→L[R] N) 
goal: AddCommGroup (M [⋀^ι]→L[R] N)

full_name: ContinuousAlternatingMap.map_piecewise_smul
code: theorem map_piecewise_smul [DecidableEq ι] (c : ι → R) (m : ι → M) (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: ContinuousAlternatingMap.map_smul_univ
code: /-- Multiplicativity of a continuous alternating 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 : ι → M) :
    (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: ContinuousAlternatingMap.instDistribMulAction
code: instance [ContinuousAdd N] : DistribMulAction R (M [⋀^ι]→L[A] N) 
goal: DistribMulAction R (M [⋀^ι]→L[A] N)

full_name: ContinuousAlternatingMap.instModule
code: /-- The space of continuous alternating maps over an algebra over `R` is a module over `R`, for the
pointwise addition and scalar multiplication. -/
instance : Module R (M [⋀^ι]→L[A] N) 
goal: Module R (M [⋀^ι]→L[A] N)

full_name: ContinuousAlternatingMap.toContinuousMultilinearMapLinear_apply
code: /-- Linear map version of the map `toMultilinearMap` associating to a continuous alternating map
the corresponding multilinear map. -/
@[simps]
def toContinuousMultilinearMapLinear :
    M [⋀^ι]→L[A] N →ₗ[R] ContinuousMultilinearMap A (fun _ : ι => M) N 
goal: ContinuousAlternatingMap.toContinuousMultilinearMapLinear self = self.toContinuousMultilinearMap

full_name: ContinuousAlternatingMap.toContinuousMultilinearMapLinear
code: /-- Linear map version of the map `toMultilinearMap` associating to a continuous alternating map
the corresponding multilinear map. -/
@[simps]
def toContinuousMultilinearMapLinear :
    M [⋀^ι]→L[A] N →ₗ[R] ContinuousMultilinearMap A (fun _ : ι => M) N 
goal: M [⋀^ι]→L[A] N →ₗ[R] ContinuousMultilinearMap A (fun x => M) N

full_name: ContinuousAlternatingMap.toAlternatingMapLinear
code: /-- Linear map version of the map `toAlternatingMap`
associating to a continuous alternating map the corresponding alternating map. -/
@[simps (config := .asFn) apply]
def toAlternatingMapLinear : (M [⋀^ι]→L[A] N) →ₗ[R] (M [⋀^ι]→ₗ[A] N) 
goal: M [⋀^ι]→L[A] N →ₗ[R] M [⋀^ι]→ₗ[A] N

full_name: ContinuousAlternatingMap.toAlternatingMapLinear_apply
code: /-- Linear map version of the map `toAlternatingMap`
associating to a continuous alternating map the corresponding alternating map. -/
@[simps (config := .asFn) apply]
def toAlternatingMapLinear : (M [⋀^ι]→L[A] N) →ₗ[R] (M [⋀^ι]→ₗ[A] N) 
goal: ⇑ContinuousAlternatingMap.toAlternatingMapLinear = ContinuousAlternatingMap.toAlternatingMap

full_name: ContinuousAlternatingMap.piLinearEquiv_apply
code: /-- `ContinuousAlternatingMap.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, M [⋀^ι]→L[A] M' i) ≃ₗ[R] M [⋀^ι]→L[A] ∀ i, M' i 
goal: ∀ (a : (i : ι') → M [⋀^ι]→L[A] M' i), ContinuousAlternatingMap.piLinearEquiv a = ContinuousAlternatingMap.pi a

full_name: ContinuousAlternatingMap.piLinearEquiv
code: /-- `ContinuousAlternatingMap.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, M [⋀^ι]→L[A] M' i) ≃ₗ[R] M [⋀^ι]→L[A] ∀ i, M' i 
goal: ((i : ι') → M [⋀^ι]→L[A] M' i) ≃ₗ[R] M [⋀^ι]→L[A] ((i : ι') → M' i)

full_name: ContinuousAlternatingMap.piLinearEquiv_symm_apply
code: /-- `ContinuousAlternatingMap.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, M [⋀^ι]→L[A] M' i) ≃ₗ[R] M [⋀^ι]→L[A] ∀ i, M' i 
goal: ∀ (a : M [⋀^ι]→L[A] ((i : ι') → M' i)) (i : ι'),
  ContinuousAlternatingMap.piLinearEquiv.symm a i = (ContinuousLinearMap.proj i).compContinuousAlternatingMap a

full_name: ContinuousAlternatingMap.smulRight_apply
code: /-- Given a continuous `R`-alternating map `f` taking values in `R`, `f.smulRight z` is the
continuous alternating map sending `m` to `f m • z`. -/
@[simps! toContinuousMultilinearMap apply]
def smulRight : M [⋀^ι]→L[R] N 
goal: ∀ (a : (i : ι) → (fun x => M) i), (f.smulRight z) a = f a • z

full_name: ContinuousAlternatingMap.smulRight_toContinuousMultilinearMap
code: /-- Given a continuous `R`-alternating map `f` taking values in `R`, `f.smulRight z` is the
continuous alternating map sending `m` to `f m • z`. -/
@[simps! toContinuousMultilinearMap apply]
def smulRight : M [⋀^ι]→L[R] N 
goal: (f.smulRight z).toContinuousMultilinearMap = f.smulRight z

full_name: ContinuousAlternatingMap.smulRight
code: /-- Given a continuous `R`-alternating map `f` taking values in `R`, `f.smulRight z` is the
continuous alternating map sending `m` to `f m • z`. -/
@[simps! toContinuousMultilinearMap apply]
def smulRight : M [⋀^ι]→L[R] N 
goal: M [⋀^ι]→L[R] N

full_name: ContinuousAlternatingMap.compContinuousLinearMapₗ
code: /-- `ContinuousAlternatingMap.compContinuousLinearMap` as a bundled `LinearMap`. -/
@[simps]
def compContinuousLinearMapₗ (f : M →L[R] M') : (M' [⋀^ι]→L[R] N) →ₗ[R] (M [⋀^ι]→L[R] N) 
goal: M' [⋀^ι]→L[R] N →ₗ[R] M [⋀^ι]→L[R] N

full_name: ContinuousAlternatingMap.compContinuousLinearMapₗ_apply
code: /-- `ContinuousAlternatingMap.compContinuousLinearMap` as a bundled `LinearMap`. -/
@[simps]
def compContinuousLinearMapₗ (f : M →L[R] M') : (M' [⋀^ι]→L[R] N) →ₗ[R] (M [⋀^ι]→L[R] N) 
goal: (ContinuousAlternatingMap.compContinuousLinearMapₗ f) g = g.compContinuousLinearMap f

full_name: ContinuousLinearMap.compContinuousAlternatingMapₗ
code: /-- `ContinuousLinearMap.compContinuousAlternatingMap` as a bundled bilinear map. -/
def _root_.ContinuousLinearMap.compContinuousAlternatingMapₗ :
    (N →L[R] N') →ₗ[R] (M [⋀^ι]→L[R] N) →ₗ[R] (M [⋀^ι]→L[R] N') 
goal: (N →L[R] N') →ₗ[R] M [⋀^ι]→L[R] N →ₗ[R] M [⋀^ι]→L[R] N'

full_name: ContinuousMultilinearMap.alternatization_apply_toContinuousMultilinearMap
code: /-- Alternatization of a continuous multilinear map. -/
@[simps (config := .lemmasOnly) apply_toContinuousMultilinearMap]
def alternatization : ContinuousMultilinearMap R (fun _ : ι => M) N →+ M [⋀^ι]→L[R] N 
goal: (ContinuousMultilinearMap.alternatization f).toContinuousMultilinearMap =
  ∑ σ : Equiv.Perm ι, Equiv.Perm.sign σ • ContinuousMultilinearMap.domDomCongr σ f

full_name: ContinuousMultilinearMap.alternatization
code: /-- Alternatization of a continuous multilinear map. -/
@[simps (config := .lemmasOnly) apply_toContinuousMultilinearMap]
def alternatization : ContinuousMultilinearMap R (fun _ : ι => M) N →+ M [⋀^ι]→L[R] N 
goal: ContinuousMultilinearMap R (fun x => M) N →+ M [⋀^ι]→L[R] N

full_name: ContinuousMultilinearMap.alternatization_apply_apply
code: theorem alternatization_apply_apply (v : ι → M) :
    alternatization f v = ∑ σ : Equiv.Perm ι, Equiv.Perm.sign σ • f (v ∘ σ) 
goal: (ContinuousMultilinearMap.alternatization f) v = ∑ σ : Equiv.Perm ι, Equiv.Perm.sign σ • f (v ∘ ⇑σ)

full_name: ContinuousMultilinearMap.alternatization_apply_toAlternatingMap
code: @[simp]
theorem alternatization_apply_toAlternatingMap :
    (alternatization f).toAlternatingMap = MultilinearMap.alternatization f.1 
goal: (ContinuousMultilinearMap.alternatization f).toAlternatingMap = MultilinearMap.alternatization f.toMultilinearMap