File: Mathlib/LinearAlgebra/Alternating/Basic.lean

full_name: AlternatingMap
code: /-- An alternating map from `ι → M` to `N`, denoted `M [⋀^ι]→ₗ[R] N`,
is a multilinear map that vanishes when two of its arguments are equal. -/
structure AlternatingMap extends MultilinearMap R (fun _ : ι => M) N where
  /-- The map is alternating: if `v` has two equal coordinates, then `f v = 0`. -/
  map_eq_zero_of_eq' : ∀ (v : ι → M) (i j : ι), v i = v j → i ≠ j → toFun v = 0
goal: Type (max (max u_2 u_3) u_7)

full_name: AlternatingMap.map_eq_zero_of_eq'
code: /-- An alternating map from `ι → M` to `N`, denoted `M [⋀^ι]→ₗ[R] N`,
is a multilinear map that vanishes when two of its arguments are equal. -/
structure AlternatingMap extends MultilinearMap R (fun _ : ι => M) N where
  /-- The map is alternating: if `v` has two equal coordinates, then `f v = 0`. -/
  map_eq_zero_of_eq' : ∀ (v : ι → M) (i j : ι), v i = v j → i ≠ j → toFun v = 0
goal: v i = v j → i ≠ j → (↑self).toFun v = 0

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

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

full_name: AlternatingMap.instFunLike
code: instance instFunLike : FunLike (M [⋀^ι]→ₗ[R] N) (ι → M) N 
goal: FunLike (M [⋀^ι]→ₗ[R] N) (ι → M) N

full_name: AlternatingMap.coeFun
code: instance coeFun : CoeFun (M [⋀^ι]→ₗ[R] N) fun _ => (ι → M) → N 
goal: CoeFun (M [⋀^ι]→ₗ[R] N) fun x => (ι → M) → N

full_name: AlternatingMap.toFun_eq_coe
code: @[simp]
theorem toFun_eq_coe : f.toFun = f 
goal: (↑f).toFun = ⇑f

full_name: AlternatingMap.coe_mk
code: @[simp]
theorem coe_mk (f : MultilinearMap R (fun _ : ι => M) N) (h) :
    ⇑(⟨f, h⟩ : M [⋀^ι]→ₗ[R] N) = f 
goal: ⇑{ toMultilinearMap := f, map_eq_zero_of_eq' := h } = ⇑f

full_name: AlternatingMap.congr_fun
code: protected theorem congr_fun {f g : M [⋀^ι]→ₗ[R] N} (h : f = g) (x : ι → M) : f x = g x 
goal: f x = g x

full_name: AlternatingMap.congr_arg
code: protected theorem congr_arg (f : M [⋀^ι]→ₗ[R] N) {x y : ι → M} (h : x = y) : f x = f y 
goal: f x = f y

full_name: AlternatingMap.coe_injective
code: theorem coe_injective : Injective ((↑) : M [⋀^ι]→ₗ[R] N → (ι → M) → N) 
goal: Function.Injective DFunLike.coe

full_name: AlternatingMap.coe_inj
code: @[norm_cast] -- @[simp] -- Porting note (#10618): simp can prove this
theorem coe_inj {f g : M [⋀^ι]→ₗ[R] N} : (f : (ι → M) → N) = g ↔ f = g 
goal: ⇑f = ⇑g ↔ f = g

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

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

full_name: AlternatingMap.coe
code: instance coe : Coe (M [⋀^ι]→ₗ[R] N) (MultilinearMap R (fun _ : ι => M) N) 
goal: Coe (M [⋀^ι]→ₗ[R] N) (MultilinearMap R (fun x => M) N)

full_name: AlternatingMap.coe_multilinearMap
code: @[simp, norm_cast]
theorem coe_multilinearMap : ⇑(f : MultilinearMap R (fun _ : ι => M) N) = f 
goal: ⇑↑f = ⇑f

full_name: AlternatingMap.coe_multilinearMap_injective
code: theorem coe_multilinearMap_injective :
    Function.Injective ((↑) : M [⋀^ι]→ₗ[R] N → MultilinearMap R (fun _ : ι => M) N) 
goal: Function.Injective AlternatingMap.toMultilinearMap

full_name: AlternatingMap.coe_multilinearMap_mk
code: theorem coe_multilinearMap_mk (f : (ι → M) → N) (h₁ h₂ h₃) :
    ((⟨⟨f, h₁, h₂⟩, h₃⟩ : M [⋀^ι]→ₗ[R] N) : MultilinearMap R (fun _ : ι => M) N) =
      ⟨f, @h₁, @h₂⟩ 
goal: ↑{ toFun := f, map_add' := ⋯, map_smul' := ⋯, map_eq_zero_of_eq' := h₃ } =
  { toFun := f, map_add' := h₁, map_smul' := h₂ }

full_name: AlternatingMap.map_add
code: @[simp]
theorem map_add [DecidableEq ι] (i : ι) (x y : M) :
    f (update v i (x + y)) = f (update v i x) + f (update v i y) 
goal: f (Function.update v i (x + y)) = f (Function.update v i x) + f (Function.update v i y)

full_name: AlternatingMap.map_sub
code: @[simp]
theorem map_sub [DecidableEq ι] (i : ι) (x y : M') :
    g' (update v' i (x - y)) = g' (update v' i x) - g' (update v' i y) 
goal: g' (Function.update v' i (x - y)) = g' (Function.update v' i x) - g' (Function.update v' i y)

full_name: AlternatingMap.map_neg
code: @[simp]
theorem map_neg [DecidableEq ι] (i : ι) (x : M') : g' (update v' i (-x)) = -g' (update v' i x) 
goal: g' (Function.update v' i (-x)) = -g' (Function.update v' i x)

full_name: AlternatingMap.map_smul
code: @[simp]
theorem map_smul [DecidableEq ι] (i : ι) (r : R) (x : M) :
    f (update v i (r • x)) = r • f (update v i x) 
goal: f (Function.update v i (r • x)) = r • f (Function.update v i x)

full_name: AlternatingMap.map_eq_zero_of_eq
code: @[simp]
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: AlternatingMap.map_coord_zero
code: theorem map_coord_zero {m : ι → M} (i : ι) (h : m i = 0) : f m = 0 
goal: f m = 0

full_name: AlternatingMap.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: AlternatingMap.map_zero
code: @[simp]
theorem map_zero [Nonempty ι] : f 0 = 0 
goal: f 0 = 0

full_name: AlternatingMap.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: AlternatingMap.smul
code: instance smul : SMul S (M [⋀^ι]→ₗ[R] N) 
goal: SMul S (M [⋀^ι]→ₗ[R] N)

full_name: AlternatingMap.smul_apply
code: @[simp]
theorem smul_apply (c : S) (m : ι → M) : (c • f) m = c • f m 
goal: (c • f) m = c • f m

full_name: AlternatingMap.coe_smul
code: @[norm_cast]
theorem coe_smul (c : S) : ↑(c • f) = c • (f : MultilinearMap R (fun _ : ι => M) N) 
goal: ↑(c • f) = c • ↑f

full_name: AlternatingMap.coeFn_smul
code: theorem coeFn_smul (c : S) (f : M [⋀^ι]→ₗ[R] N) : ⇑(c • f) = c • ⇑f 
goal: ⇑(c • f) = c • ⇑f

full_name: AlternatingMap.isCentralScalar
code: instance isCentralScalar [DistribMulAction Sᵐᵒᵖ N] [IsCentralScalar S N] :
    IsCentralScalar S (M [⋀^ι]→ₗ[R] N) 
goal: IsCentralScalar S (M [⋀^ι]→ₗ[R] N)

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

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

full_name: AlternatingMap.coe_prod
code: @[simp]
theorem coe_prod (f : M [⋀^ι]→ₗ[R] N) (g : M [⋀^ι]→ₗ[R] P) :
    (f.prod g : MultilinearMap R (fun _ : ι => M) (N × P)) = MultilinearMap.prod f g 
goal: ↑(f.prod g) = (↑f).prod ↑g

full_name: AlternatingMap.pi_apply
code: /-- Combine a family of alternating maps with the same domain and codomains `N i` into an
alternating map taking values in the space of functions `Π i, N i`. -/
@[simps!]
def pi {ι' : Type*} {N : ι' → Type*} [∀ i, AddCommMonoid (N i)] [∀ i, Module R (N i)]
    (f : ∀ i, M [⋀^ι]→ₗ[R] N i) : M [⋀^ι]→ₗ[R] (∀ i, N i) 
goal: (AlternatingMap.pi f) m i = (f i) m

full_name: AlternatingMap.pi
code: /-- Combine a family of alternating maps with the same domain and codomains `N i` into an
alternating map taking values in the space of functions `Π i, N i`. -/
@[simps!]
def pi {ι' : Type*} {N : ι' → Type*} [∀ i, AddCommMonoid (N i)] [∀ i, Module R (N i)]
    (f : ∀ i, M [⋀^ι]→ₗ[R] N i) : M [⋀^ι]→ₗ[R] (∀ i, N i) 
goal: M [⋀^ι]→ₗ[R] ((i : ι') → N i)

full_name: AlternatingMap.coe_pi
code: @[simp]
theorem coe_pi {ι' : Type*} {N : ι' → Type*} [∀ i, AddCommMonoid (N i)] [∀ i, Module R (N i)]
    (f : ∀ i, M [⋀^ι]→ₗ[R] N i) :
    (pi f : MultilinearMap R (fun _ : ι => M) (∀ i, N i)) = MultilinearMap.pi fun a => f a 
goal: ↑(AlternatingMap.pi f) = MultilinearMap.pi fun a => ↑(f a)

full_name: AlternatingMap.smulRight_apply
code: /-- Given an alternating `R`-multilinear map `f` taking values in `R`, `f.smul_right z` is the map
sending `m` to `f m • z`. -/
@[simps!]
def smulRight {R M₁ M₂ ι : Type*} [CommSemiring R] [AddCommMonoid M₁] [AddCommMonoid M₂]
    [Module R M₁] [Module R M₂] (f : M₁ [⋀^ι]→ₗ[R] R) (z : M₂) : M₁ [⋀^ι]→ₗ[R] M₂ 
goal: ∀ (a : (i : ι) → (fun x => M₁) i), (f.smulRight z) a = f a • z

full_name: AlternatingMap.smulRight
code: /-- Given an alternating `R`-multilinear map `f` taking values in `R`, `f.smul_right z` is the map
sending `m` to `f m • z`. -/
@[simps!]
def smulRight {R M₁ M₂ ι : Type*} [CommSemiring R] [AddCommMonoid M₁] [AddCommMonoid M₂]
    [Module R M₁] [Module R M₂] (f : M₁ [⋀^ι]→ₗ[R] R) (z : M₂) : M₁ [⋀^ι]→ₗ[R] M₂ 
goal: M₁ [⋀^ι]→ₗ[R] M₂

full_name: AlternatingMap.coe_smulRight
code: @[simp]
theorem coe_smulRight {R M₁ M₂ ι : Type*} [CommSemiring R] [AddCommMonoid M₁] [AddCommMonoid M₂]
    [Module R M₁] [Module R M₂] (f : M₁ [⋀^ι]→ₗ[R] R) (z : M₂) :
    (f.smulRight z : MultilinearMap R (fun _ : ι => M₁) M₂) = MultilinearMap.smulRight f z 
goal: ↑(f.smulRight z) = (↑f).smulRight z

full_name: AlternatingMap.add
code: instance add : Add (M [⋀^ι]→ₗ[R] N) 
goal: Add (M [⋀^ι]→ₗ[R] N)

full_name: AlternatingMap.add_apply
code: @[simp]
theorem add_apply : (f + f') v = f v + f' v 
goal: (f + f') v = f v + f' v

full_name: AlternatingMap.coe_add
code: @[norm_cast]
theorem coe_add : (↑(f + f') : MultilinearMap R (fun _ : ι => M) N) = f + f' 
goal: ↑(f + f') = ↑f + ↑f'

full_name: AlternatingMap.zero
code: instance zero : Zero (M [⋀^ι]→ₗ[R] N) 
goal: Zero (M [⋀^ι]→ₗ[R] N)

full_name: AlternatingMap.zero_apply
code: @[simp]
theorem zero_apply : (0 : M [⋀^ι]→ₗ[R] N) v = 0 
goal: 0 v = 0

full_name: AlternatingMap.coe_zero
code: @[norm_cast]
theorem coe_zero : ((0 : M [⋀^ι]→ₗ[R] N) : MultilinearMap R (fun _ : ι => M) N) = 0 
goal: ↑0 = 0

full_name: AlternatingMap.mk_zero
code: @[simp]
theorem mk_zero :
    mk (0 : MultilinearMap R (fun _ : ι ↦ M) N) (0 : M [⋀^ι]→ₗ[R] N).2 = 0 
goal: { toMultilinearMap := 0, map_eq_zero_of_eq' := ⋯ } = 0

full_name: AlternatingMap.inhabited
code: instance inhabited : Inhabited (M [⋀^ι]→ₗ[R] N) 
goal: Inhabited (M [⋀^ι]→ₗ[R] N)

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

full_name: AlternatingMap.neg
code: instance neg : Neg (M [⋀^ι]→ₗ[R] N') 
goal: Neg (M [⋀^ι]→ₗ[R] N')

full_name: AlternatingMap.neg_apply
code: @[simp]
theorem neg_apply (m : ι → M) : (-g) m = -g m 
goal: (-g) m = -g m

full_name: AlternatingMap.coe_neg
code: @[norm_cast]
theorem coe_neg : ((-g : M [⋀^ι]→ₗ[R] N') : MultilinearMap R (fun _ : ι => M) N') = -g 
goal: ↑(-g) = -↑g

full_name: AlternatingMap.sub
code: instance sub : Sub (M [⋀^ι]→ₗ[R] N') 
goal: Sub (M [⋀^ι]→ₗ[R] N')

full_name: AlternatingMap.sub_apply
code: @[simp]
theorem sub_apply (m : ι → M) : (g - g₂) m = g m - g₂ m 
goal: (g - g₂) m = g m - g₂ m

full_name: AlternatingMap.coe_sub
code: @[norm_cast]
theorem coe_sub : (↑(g - g₂) : MultilinearMap R (fun _ : ι => M) N') = g - g₂ 
goal: ↑(g - g₂) = ↑g - ↑g₂

full_name: AlternatingMap.addCommGroup
code: instance addCommGroup : AddCommGroup (M [⋀^ι]→ₗ[R] N') 
goal: AddCommGroup (M [⋀^ι]→ₗ[R] N')

full_name: AlternatingMap.distribMulAction
code: instance distribMulAction : DistribMulAction S (M [⋀^ι]→ₗ[R] N) 
goal: DistribMulAction S (M [⋀^ι]→ₗ[R] N)

full_name: AlternatingMap.module
code: /-- The space of multilinear maps over an algebra over `R` is a module over `R`, for the pointwise
addition and scalar multiplication. -/
instance module : Module S (M [⋀^ι]→ₗ[R] N) 
goal: Module S (M [⋀^ι]→ₗ[R] N)

full_name: AlternatingMap.noZeroSMulDivisors
code: instance noZeroSMulDivisors [NoZeroSMulDivisors S N] :
    NoZeroSMulDivisors S (M [⋀^ι]→ₗ[R] N) 
goal: NoZeroSMulDivisors S (M [⋀^ι]→ₗ[R] N)

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

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

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

full_name: AlternatingMap.constOfIsEmpty_apply
code: /-- The constant map is alternating when `ι` is empty. -/
@[simps (config := .asFn)]
def constOfIsEmpty [IsEmpty ι] (m : N) : M [⋀^ι]→ₗ[R] N 
goal: ⇑(AlternatingMap.constOfIsEmpty R M ι m) = Function.const (ι → M) m

full_name: AlternatingMap.constOfIsEmpty
code: /-- The constant map is alternating when `ι` is empty. -/
@[simps (config := .asFn)]
def constOfIsEmpty [IsEmpty ι] (m : N) : M [⋀^ι]→ₗ[R] N 
goal: M [⋀^ι]→ₗ[R] N

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

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

full_name: LinearMap.compAlternatingMap
code: /-- Composing an alternating map with a linear map on the left gives again an alternating map. -/
def compAlternatingMap (g : N →ₗ[R] N₂) : (M [⋀^ι]→ₗ[R] N) →+ (M [⋀^ι]→ₗ[R] N₂) 
goal: M [⋀^ι]→ₗ[R] N →+ M [⋀^ι]→ₗ[R] N₂

full_name: LinearMap.coe_compAlternatingMap
code: @[simp]
theorem coe_compAlternatingMap (g : N →ₗ[R] N₂) (f : M [⋀^ι]→ₗ[R] N) :
    ⇑(g.compAlternatingMap f) = g ∘ f 
goal: ⇑(g.compAlternatingMap f) = ⇑g ∘ ⇑f

full_name: LinearMap.compAlternatingMap_apply
code: @[simp]
theorem compAlternatingMap_apply (g : N →ₗ[R] N₂) (f : M [⋀^ι]→ₗ[R] N) (m : ι → M) :
    g.compAlternatingMap f m = g (f m) 
goal: (g.compAlternatingMap f) m = g (f m)

full_name: LinearMap.smulRight_eq_comp
code: theorem smulRight_eq_comp {R M₁ M₂ ι : Type*} [CommSemiring R] [AddCommMonoid M₁]
    [AddCommMonoid M₂] [Module R M₁] [Module R M₂] (f : M₁ [⋀^ι]→ₗ[R] R) (z : M₂) :
    f.smulRight z = (LinearMap.id.smulRight z).compAlternatingMap f 
goal: f.smulRight z = (LinearMap.id.smulRight z).compAlternatingMap f

full_name: LinearMap.subtype_compAlternatingMap_codRestrict
code: @[simp]
theorem subtype_compAlternatingMap_codRestrict (f : M [⋀^ι]→ₗ[R] N) (p : Submodule R N)
    (h) : p.subtype.compAlternatingMap (f.codRestrict p h) = f 
goal: p.subtype.compAlternatingMap (f.codRestrict p h) = f

full_name: LinearMap.compAlternatingMap_codRestrict
code: @[simp]
theorem compAlternatingMap_codRestrict (g : N →ₗ[R] N₂) (f : M [⋀^ι]→ₗ[R] N)
    (p : Submodule R N₂) (h) :
    (g.codRestrict p h).compAlternatingMap f =
      (g.compAlternatingMap f).codRestrict p fun v => h (f v) 
goal: (LinearMap.codRestrict p g h).compAlternatingMap f = (g.compAlternatingMap f).codRestrict p ⋯

full_name: AlternatingMap.compLinearMap
code: /-- Composing an alternating map with the same linear map on each argument gives again an
alternating map. -/
def compLinearMap (f : M [⋀^ι]→ₗ[R] N) (g : M₂ →ₗ[R] M) : M₂ [⋀^ι]→ₗ[R] N 
goal: M₂ [⋀^ι]→ₗ[R] N

full_name: AlternatingMap.coe_compLinearMap
code: theorem coe_compLinearMap (f : M [⋀^ι]→ₗ[R] N) (g : M₂ →ₗ[R] M) :
    ⇑(f.compLinearMap g) = f ∘ (g ∘ ·) 
goal: ⇑(f.compLinearMap g) = ⇑f ∘ fun x => ⇑g ∘ x

full_name: AlternatingMap.compLinearMap_apply
code: @[simp]
theorem compLinearMap_apply (f : M [⋀^ι]→ₗ[R] N) (g : M₂ →ₗ[R] M) (v : ι → M₂) :
    f.compLinearMap g v = f fun i => g (v i) 
goal: (f.compLinearMap g) v = f fun i => g (v i)

full_name: AlternatingMap.compLinearMap_assoc
code: /-- Composing an alternating map twice with the same linear map in each argument is
the same as composing with their composition. -/
theorem compLinearMap_assoc (f : M [⋀^ι]→ₗ[R] N) (g₁ : M₂ →ₗ[R] M) (g₂ : M₃ →ₗ[R] M₂) :
    (f.compLinearMap g₁).compLinearMap g₂ = f.compLinearMap (g₁ ∘ₗ g₂) 
goal: (f.compLinearMap g₁).compLinearMap g₂ = f.compLinearMap (g₁ ∘ₗ g₂)

full_name: AlternatingMap.zero_compLinearMap
code: @[simp]
theorem zero_compLinearMap (g : M₂ →ₗ[R] M) : (0 : M [⋀^ι]→ₗ[R] N).compLinearMap g = 0 
goal: AlternatingMap.compLinearMap 0 g = 0

full_name: AlternatingMap.add_compLinearMap
code: @[simp]
theorem add_compLinearMap (f₁ f₂ : M [⋀^ι]→ₗ[R] N) (g : M₂ →ₗ[R] M) :
    (f₁ + f₂).compLinearMap g = f₁.compLinearMap g + f₂.compLinearMap g 
goal: (f₁ + f₂).compLinearMap g = f₁.compLinearMap g + f₂.compLinearMap g

full_name: AlternatingMap.compLinearMap_zero
code: @[simp]
theorem compLinearMap_zero [Nonempty ι] (f : M [⋀^ι]→ₗ[R] N) :
    f.compLinearMap (0 : M₂ →ₗ[R] M) = 0 
goal: f.compLinearMap 0 = 0

full_name: AlternatingMap.compLinearMap_id
code: /-- Composing an alternating map with the identity linear map in each argument. -/
@[simp]
theorem compLinearMap_id (f : M [⋀^ι]→ₗ[R] N) : f.compLinearMap LinearMap.id = f 
goal: f.compLinearMap LinearMap.id = f

full_name: AlternatingMap.compLinearMap_injective
code: /-- Composing with a surjective linear map is injective. -/
theorem compLinearMap_injective (f : M₂ →ₗ[R] M) (hf : Function.Surjective f) :
    Function.Injective fun g : M [⋀^ι]→ₗ[R] N => g.compLinearMap f 
goal: Function.Injective fun g => g.compLinearMap f

full_name: AlternatingMap.compLinearMap_inj
code: theorem compLinearMap_inj (f : M₂ →ₗ[R] M) (hf : Function.Surjective f)
    (g₁ g₂ : M [⋀^ι]→ₗ[R] N) : g₁.compLinearMap f = g₂.compLinearMap f ↔ g₁ = g₂ 
goal: g₁.compLinearMap f = g₂.compLinearMap f ↔ g₁ = g₂

full_name: AlternatingMap.domLCongr
code: /-- Construct a linear equivalence between maps from a linear equivalence between domains. -/
@[simps apply]
def domLCongr (e : M ≃ₗ[R] M₂) : M [⋀^ι]→ₗ[R] N ≃ₗ[S] (M₂ [⋀^ι]→ₗ[R] N) 
goal: M [⋀^ι]→ₗ[R] N ≃ₗ[S] M₂ [⋀^ι]→ₗ[R] N

full_name: AlternatingMap.domLCongr_apply
code: /-- Construct a linear equivalence between maps from a linear equivalence between domains. -/
@[simps apply]
def domLCongr (e : M ≃ₗ[R] M₂) : M [⋀^ι]→ₗ[R] N ≃ₗ[S] (M₂ [⋀^ι]→ₗ[R] N) 
goal: (AlternatingMap.domLCongr R N ι S e) f = f.compLinearMap ↑e.symm

full_name: AlternatingMap.domLCongr_refl
code: @[simp]
theorem domLCongr_refl : domLCongr R N ι S (LinearEquiv.refl R M) = LinearEquiv.refl S _ 
goal: AlternatingMap.domLCongr R N ι S (LinearEquiv.refl R M) = LinearEquiv.refl S (M [⋀^ι]→ₗ[R] N)

full_name: AlternatingMap.domLCongr_symm
code: @[simp]
theorem domLCongr_symm (e : M ≃ₗ[R] M₂) : (domLCongr R N ι S e).symm = domLCongr R N ι S e.symm 
goal: (AlternatingMap.domLCongr R N ι S e).symm = AlternatingMap.domLCongr R N ι S e.symm

full_name: AlternatingMap.domLCongr_trans
code: theorem domLCongr_trans (e : M ≃ₗ[R] M₂) (f : M₂ ≃ₗ[R] M₃) :
    (domLCongr R N ι S e).trans (domLCongr R N ι S f) = domLCongr R N ι S (e.trans f) 
goal: AlternatingMap.domLCongr R N ι S e ≪≫ₗ AlternatingMap.domLCongr R N ι S f = AlternatingMap.domLCongr R N ι S (e ≪≫ₗ f)

full_name: AlternatingMap.compLinearEquiv_eq_zero_iff
code: /-- Composing an alternating map with the same linear equiv on each argument gives the zero map
if and only if the alternating map is the zero map. -/
@[simp]
theorem compLinearEquiv_eq_zero_iff (f : M [⋀^ι]→ₗ[R] N) (g : M₂ ≃ₗ[R] M) :
    f.compLinearMap (g : M₂ →ₗ[R] M) = 0 ↔ f = 0 
goal: f.compLinearMap ↑g = 0 ↔ f = 0

full_name: AlternatingMap.map_update_sum
code: theorem map_update_sum {α : Type*} [DecidableEq ι] (t : Finset α) (i : ι) (g : α → M) (m : ι → M) :
    f (update m i (∑ a ∈ t, g a)) = ∑ a ∈ t, f (update m i (g a)) 
goal: f (Function.update m i (∑ a ∈ t, g a)) = ∑ a ∈ t, f (Function.update m i (g a))

full_name: AlternatingMap.map_update_self
code: theorem map_update_self [DecidableEq ι] {i j : ι} (hij : i ≠ j) :
    f (Function.update v i (v j)) = 0 
goal: f (Function.update v i (v j)) = 0

full_name: AlternatingMap.map_update_update
code: theorem map_update_update [DecidableEq ι] {i j : ι} (hij : i ≠ j) (m : M) :
    f (Function.update (Function.update v i m) j m) = 0 
goal: f (Function.update (Function.update v i m) j m) = 0

full_name: AlternatingMap.map_swap_add
code: theorem map_swap_add [DecidableEq ι] {i j : ι} (hij : i ≠ j) :
    f (v ∘ Equiv.swap i j) + f v = 0 
goal: f (v ∘ ⇑(Equiv.swap i j)) + f v = 0

full_name: AlternatingMap.map_add_swap
code: theorem map_add_swap [DecidableEq ι] {i j : ι} (hij : i ≠ j) :
    f v + f (v ∘ Equiv.swap i j) = 0 
goal: f v + f (v ∘ ⇑(Equiv.swap i j)) = 0

full_name: AlternatingMap.map_swap
code: theorem map_swap [DecidableEq ι] {i j : ι} (hij : i ≠ j) : g (v ∘ Equiv.swap i j) = -g v 
goal: g (v ∘ ⇑(Equiv.swap i j)) = -g v

full_name: AlternatingMap.map_perm
code: theorem map_perm [DecidableEq ι] [Fintype ι] (v : ι → M) (σ : Equiv.Perm ι) :
    g (v ∘ σ) = Equiv.Perm.sign σ • g v 
goal: g (v ∘ ⇑σ) = Equiv.Perm.sign σ • g v

full_name: AlternatingMap.map_congr_perm
code: theorem map_congr_perm [DecidableEq ι] [Fintype ι] (σ : Equiv.Perm ι) :
    g v = Equiv.Perm.sign σ • g (v ∘ σ) 
goal: g v = Equiv.Perm.sign σ • g (v ∘ ⇑σ)

full_name: AlternatingMap.domDomCongr
code: /-- Transfer the arguments to a map along an equivalence between argument indices.

This is the alternating version of `MultilinearMap.domDomCongr`. -/
@[simps]
def domDomCongr (σ : ι ≃ ι') (f : M [⋀^ι]→ₗ[R] N) : M [⋀^ι']→ₗ[R] N 
goal: M [⋀^ι']→ₗ[R] N

full_name: AlternatingMap.domDomCongr_apply
code: /-- Transfer the arguments to a map along an equivalence between argument indices.

This is the alternating version of `MultilinearMap.domDomCongr`. -/
@[simps]
def domDomCongr (σ : ι ≃ ι') (f : M [⋀^ι]→ₗ[R] N) : M [⋀^ι']→ₗ[R] N 
goal: (AlternatingMap.domDomCongr σ f) v = f (v ∘ ⇑σ)

full_name: AlternatingMap.domDomCongr_refl
code: @[simp]
theorem domDomCongr_refl (f : M [⋀^ι]→ₗ[R] N) : f.domDomCongr (Equiv.refl ι) = f 
goal: AlternatingMap.domDomCongr (Equiv.refl ι) f = f

full_name: AlternatingMap.domDomCongr_trans
code: theorem domDomCongr_trans (σ₁ : ι ≃ ι') (σ₂ : ι' ≃ ι'') (f : M [⋀^ι]→ₗ[R] N) :
    f.domDomCongr (σ₁.trans σ₂) = (f.domDomCongr σ₁).domDomCongr σ₂ 
goal: AlternatingMap.domDomCongr (σ₁.trans σ₂) f = AlternatingMap.domDomCongr σ₂ (AlternatingMap.domDomCongr σ₁ f)

full_name: AlternatingMap.domDomCongr_zero
code: @[simp]
theorem domDomCongr_zero (σ : ι ≃ ι') : (0 : M [⋀^ι]→ₗ[R] N).domDomCongr σ = 0 
goal: AlternatingMap.domDomCongr σ 0 = 0

full_name: AlternatingMap.domDomCongr_add
code: @[simp]
theorem domDomCongr_add (σ : ι ≃ ι') (f g : M [⋀^ι]→ₗ[R] N) :
    (f + g).domDomCongr σ = f.domDomCongr σ + g.domDomCongr σ 
goal: AlternatingMap.domDomCongr σ (f + g) = AlternatingMap.domDomCongr σ f + AlternatingMap.domDomCongr σ g

full_name: AlternatingMap.domDomCongr_smul
code: @[simp]
theorem domDomCongr_smul {S : Type*} [Monoid S] [DistribMulAction S N] [SMulCommClass R S N]
    (σ : ι ≃ ι') (c : S) (f : M [⋀^ι]→ₗ[R] N) :
    (c • f).domDomCongr σ = c • f.domDomCongr σ 
goal: AlternatingMap.domDomCongr σ (c • f) = c • AlternatingMap.domDomCongr σ f

full_name: AlternatingMap.domDomCongrEquiv_apply
code: /-- `AlternatingMap.domDomCongr` as an equivalence.

This is declared separately because it does not work with dot notation. -/
@[simps apply symm_apply]
def domDomCongrEquiv (σ : ι ≃ ι') : M [⋀^ι]→ₗ[R] N ≃+ M [⋀^ι']→ₗ[R] N 
goal: (AlternatingMap.domDomCongrEquiv σ) f = AlternatingMap.domDomCongr σ f

full_name: AlternatingMap.domDomCongrEquiv
code: /-- `AlternatingMap.domDomCongr` as an equivalence.

This is declared separately because it does not work with dot notation. -/
@[simps apply symm_apply]
def domDomCongrEquiv (σ : ι ≃ ι') : M [⋀^ι]→ₗ[R] N ≃+ M [⋀^ι']→ₗ[R] N 
goal: M [⋀^ι]→ₗ[R] N ≃+ M [⋀^ι']→ₗ[R] N

full_name: AlternatingMap.domDomCongrEquiv_symm_apply
code: /-- `AlternatingMap.domDomCongr` as an equivalence.

This is declared separately because it does not work with dot notation. -/
@[simps apply symm_apply]
def domDomCongrEquiv (σ : ι ≃ ι') : M [⋀^ι]→ₗ[R] N ≃+ M [⋀^ι']→ₗ[R] N 
goal: (AlternatingMap.domDomCongrEquiv σ).symm f = AlternatingMap.domDomCongr σ.symm f

full_name: AlternatingMap.domDomCongrₗ_apply
code: /-- `AlternatingMap.domDomCongr` as a linear equivalence. -/
@[simps apply symm_apply]
def domDomCongrₗ (σ : ι ≃ ι') : M [⋀^ι]→ₗ[R] N ≃ₗ[S] M [⋀^ι']→ₗ[R] N 
goal: (AlternatingMap.domDomCongrₗ S σ) f = AlternatingMap.domDomCongr σ f

full_name: AlternatingMap.domDomCongrₗ_symm_apply
code: /-- `AlternatingMap.domDomCongr` as a linear equivalence. -/
@[simps apply symm_apply]
def domDomCongrₗ (σ : ι ≃ ι') : M [⋀^ι]→ₗ[R] N ≃ₗ[S] M [⋀^ι']→ₗ[R] N 
goal: (AlternatingMap.domDomCongrₗ S σ).symm f = AlternatingMap.domDomCongr σ.symm f

full_name: AlternatingMap.domDomCongrₗ
code: /-- `AlternatingMap.domDomCongr` as a linear equivalence. -/
@[simps apply symm_apply]
def domDomCongrₗ (σ : ι ≃ ι') : M [⋀^ι]→ₗ[R] N ≃ₗ[S] M [⋀^ι']→ₗ[R] N 
goal: M [⋀^ι]→ₗ[R] N ≃ₗ[S] M [⋀^ι']→ₗ[R] N

full_name: AlternatingMap.domDomCongrₗ_refl
code: @[simp]
theorem domDomCongrₗ_refl :
    (domDomCongrₗ S (Equiv.refl ι) : M [⋀^ι]→ₗ[R] N ≃ₗ[S] M [⋀^ι]→ₗ[R] N) =
      LinearEquiv.refl _ _ 
goal: AlternatingMap.domDomCongrₗ S (Equiv.refl ι) = LinearEquiv.refl S (M [⋀^ι]→ₗ[R] N)

full_name: AlternatingMap.domDomCongrₗ_toAddEquiv
code: @[simp]
theorem domDomCongrₗ_toAddEquiv (σ : ι ≃ ι') :
    (↑(domDomCongrₗ S σ : M [⋀^ι]→ₗ[R] N ≃ₗ[S] _) : M [⋀^ι]→ₗ[R] N ≃+ _) =
      domDomCongrEquiv σ 
goal: ↑(AlternatingMap.domDomCongrₗ S σ) = AlternatingMap.domDomCongrEquiv σ

full_name: AlternatingMap.domDomCongr_eq_iff
code: /-- The results of applying `domDomCongr` to two maps are equal if and only if those maps are. -/
@[simp]
theorem domDomCongr_eq_iff (σ : ι ≃ ι') (f g : M [⋀^ι]→ₗ[R] N) :
    f.domDomCongr σ = g.domDomCongr σ ↔ f = g 
goal: AlternatingMap.domDomCongr σ f = AlternatingMap.domDomCongr σ g ↔ f = g

full_name: AlternatingMap.domDomCongr_eq_zero_iff
code: @[simp]
theorem domDomCongr_eq_zero_iff (σ : ι ≃ ι') (f : M [⋀^ι]→ₗ[R] N) :
    f.domDomCongr σ = 0 ↔ f = 0 
goal: AlternatingMap.domDomCongr σ f = 0 ↔ f = 0

full_name: AlternatingMap.domDomCongr_perm
code: theorem domDomCongr_perm [Fintype ι] [DecidableEq ι] (σ : Equiv.Perm ι) :
    g.domDomCongr σ = Equiv.Perm.sign σ • g 
goal: AlternatingMap.domDomCongr σ g = Equiv.Perm.sign σ • g

full_name: AlternatingMap.coe_domDomCongr
code: @[norm_cast]
theorem coe_domDomCongr (σ : ι ≃ ι') :
    ↑(f.domDomCongr σ) = (f : MultilinearMap R (fun _ : ι => M) N).domDomCongr σ 
goal: ↑(AlternatingMap.domDomCongr σ f) = MultilinearMap.domDomCongr σ ↑f

full_name: AlternatingMap.map_linearDependent
code: /-- If the arguments are linearly dependent then the result is `0`. -/
theorem map_linearDependent {K : Type*} [Ring K] {M : Type*} [AddCommGroup M] [Module K M]
    {N : Type*} [AddCommGroup N] [Module K N] [NoZeroSMulDivisors K N] (f : M [⋀^ι]→ₗ[K] N)
    (v : ι → M) (h : ¬LinearIndependent K v) : f v = 0 
goal: f v = 0

full_name: AlternatingMap.map_vecCons_add
code: /-- A version of `MultilinearMap.cons_add` for `AlternatingMap`. -/
theorem map_vecCons_add {n : ℕ} (f : M [⋀^Fin n.succ]→ₗ[R] N) (m : Fin n → M) (x y : M) :
    f (Matrix.vecCons (x + y) m) = f (Matrix.vecCons x m) + f (Matrix.vecCons y m) 
goal: f (Matrix.vecCons (x + y) m) = f (Matrix.vecCons x m) + f (Matrix.vecCons y m)

full_name: AlternatingMap.map_vecCons_smul
code: /-- A version of `MultilinearMap.cons_smul` for `AlternatingMap`. -/
theorem map_vecCons_smul {n : ℕ} (f : M [⋀^Fin n.succ]→ₗ[R] N) (m : Fin n → M) (c : R)
    (x : M) : f (Matrix.vecCons (c • x) m) = c • f (Matrix.vecCons x m) 
goal: f (Matrix.vecCons (c • x) m) = c • f (Matrix.vecCons x m)

full_name: _private.Mathlib.LinearAlgebra.Alternating.Basic.0.MultilinearMap.alternization_map_eq_zero_of_eq_aux
code: private theorem alternization_map_eq_zero_of_eq_aux (m : MultilinearMap R (fun _ : ι => M) N')
    (v : ι → M) (i j : ι) (i_ne_j : i ≠ j) (hv : v i = v j) :
    (∑ σ : Perm ι, Equiv.Perm.sign σ • m.domDomCongr σ) v = 0 
goal: (∑ σ : Equiv.Perm ι, Equiv.Perm.sign σ • MultilinearMap.domDomCongr σ m) v = 0

full_name: MultilinearMap.alternatization
code: /-- Produce an `AlternatingMap` out of a `MultilinearMap`, by summing over all argument
permutations. -/
def alternatization : MultilinearMap R (fun _ : ι => M) N' →+ M [⋀^ι]→ₗ[R] N' 
goal: MultilinearMap R (fun x => M) N' →+ M [⋀^ι]→ₗ[R] N'

full_name: MultilinearMap.alternatization_def
code: theorem alternatization_def (m : MultilinearMap R (fun _ : ι => M) N') :
    ⇑(alternatization m) = (∑ σ : Perm ι, Equiv.Perm.sign σ • m.domDomCongr σ : _) 
goal: ⇑(MultilinearMap.alternatization m) = ⇑(∑ σ : Equiv.Perm ι, Equiv.Perm.sign σ • MultilinearMap.domDomCongr σ m)

full_name: MultilinearMap.alternatization_coe
code: theorem alternatization_coe (m : MultilinearMap R (fun _ : ι => M) N') :
    ↑(alternatization m) = (∑ σ : Perm ι, Equiv.Perm.sign σ • m.domDomCongr σ : _) 
goal: ↑(MultilinearMap.alternatization m) = ∑ σ : Equiv.Perm ι, Equiv.Perm.sign σ • MultilinearMap.domDomCongr σ m

full_name: MultilinearMap.alternatization_apply
code: theorem alternatization_apply (m : MultilinearMap R (fun _ : ι => M) N') (v : ι → M) :
    alternatization m v = ∑ σ : Perm ι, Equiv.Perm.sign σ • m.domDomCongr σ v 
goal: (MultilinearMap.alternatization m) v = ∑ σ : Equiv.Perm ι, Equiv.Perm.sign σ • (MultilinearMap.domDomCongr σ m) v

full_name: AlternatingMap.coe_alternatization
code: /-- Alternatizing a multilinear map that is already alternating results in a scale factor of `n!`,
where `n` is the number of inputs. -/
theorem coe_alternatization [DecidableEq ι] [Fintype ι] (a : M [⋀^ι]→ₗ[R] N') :
    MultilinearMap.alternatization (a : MultilinearMap R (fun _ => M) N')
    = Nat.factorial (Fintype.card ι) • a 
goal: MultilinearMap.alternatization ↑a = (Fintype.card ι).factorial • a

full_name: LinearMap.compMultilinearMap_alternatization
code: /-- Composition with a linear map before and after alternatization are equivalent. -/
theorem compMultilinearMap_alternatization (g : N' →ₗ[R] N'₂)
    (f : MultilinearMap R (fun _ : ι => M) N') :
    MultilinearMap.alternatization (g.compMultilinearMap f)
      = g.compAlternatingMap (MultilinearMap.alternatization f) 
goal: MultilinearMap.alternatization (g.compMultilinearMap f) = g.compAlternatingMap (MultilinearMap.alternatization f)

full_name: Basis.ext_alternating
code: /-- Two alternating maps indexed by a `Fintype` are equal if they are equal when all arguments
are distinct basis vectors. -/
theorem Basis.ext_alternating {f g : N₁ [⋀^ι]→ₗ[R'] N₂} (e : Basis ι₁ R' N₁)
    (h : ∀ v : ι → ι₁, Function.Injective v → (f fun i => e (v i)) = g fun i => e (v i)) :
    f = g 
goal: f = g

full_name: AlternatingMap.curryLeft_apply_apply
code: /-- Given an alternating map `f` in `n+1` variables, split the first variable to obtain
a linear map into alternating maps in `n` variables, given by `x ↦ (m ↦ f (Matrix.vecCons x m))`.
It can be thought of as a map $Hom(\bigwedge^{n+1} M, N) \to Hom(M, Hom(\bigwedge^n M, N))$.

This is `MultilinearMap.curryLeft` for `AlternatingMap`. See also
`AlternatingMap.curryLeftLinearMap`. -/
@[simps]
def curryLeft {n : ℕ} (f : M'' [⋀^Fin n.succ]→ₗ[R'] N'') :
    M'' →ₗ[R'] M'' [⋀^Fin n]→ₗ[R'] N'' 
goal: (f.curryLeft m) v = f (Matrix.vecCons m v)

full_name: AlternatingMap.curryLeft
code: /-- Given an alternating map `f` in `n+1` variables, split the first variable to obtain
a linear map into alternating maps in `n` variables, given by `x ↦ (m ↦ f (Matrix.vecCons x m))`.
It can be thought of as a map $Hom(\bigwedge^{n+1} M, N) \to Hom(M, Hom(\bigwedge^n M, N))$.

This is `MultilinearMap.curryLeft` for `AlternatingMap`. See also
`AlternatingMap.curryLeftLinearMap`. -/
@[simps]
def curryLeft {n : ℕ} (f : M'' [⋀^Fin n.succ]→ₗ[R'] N'') :
    M'' →ₗ[R'] M'' [⋀^Fin n]→ₗ[R'] N'' 
goal: M'' →ₗ[R'] M'' [⋀^Fin n]→ₗ[R'] N''

full_name: AlternatingMap.curryLeft_zero
code: @[simp]
theorem curryLeft_zero {n : ℕ} : curryLeft (0 : M'' [⋀^Fin n.succ]→ₗ[R'] N'') = 0 
goal: AlternatingMap.curryLeft 0 = 0

full_name: AlternatingMap.curryLeft_add
code: @[simp]
theorem curryLeft_add {n : ℕ} (f g : M'' [⋀^Fin n.succ]→ₗ[R'] N'') :
    curryLeft (f + g) = curryLeft f + curryLeft g 
goal: (f + g).curryLeft = f.curryLeft + g.curryLeft

full_name: AlternatingMap.curryLeft_smul
code: @[simp]
theorem curryLeft_smul {n : ℕ} (r : R') (f : M'' [⋀^Fin n.succ]→ₗ[R'] N'') :
    curryLeft (r • f) = r • curryLeft f 
goal: (r • f).curryLeft = r • f.curryLeft

full_name: AlternatingMap.curryLeftLinearMap
code: /-- `AlternatingMap.curryLeft` as a `LinearMap`. This is a separate definition as dot notation
does not work for this version. -/
@[simps]
def curryLeftLinearMap {n : ℕ} :
    (M'' [⋀^Fin n.succ]→ₗ[R'] N'') →ₗ[R'] M'' →ₗ[R'] M'' [⋀^Fin n]→ₗ[R'] N'' 
goal: M'' [⋀^Fin n.succ]→ₗ[R'] N'' →ₗ[R'] M'' →ₗ[R'] M'' [⋀^Fin n]→ₗ[R'] N''

full_name: AlternatingMap.curryLeftLinearMap_apply
code: /-- `AlternatingMap.curryLeft` as a `LinearMap`. This is a separate definition as dot notation
does not work for this version. -/
@[simps]
def curryLeftLinearMap {n : ℕ} :
    (M'' [⋀^Fin n.succ]→ₗ[R'] N'') →ₗ[R'] M'' →ₗ[R'] M'' [⋀^Fin n]→ₗ[R'] N'' 
goal: AlternatingMap.curryLeftLinearMap f = f.curryLeft

full_name: AlternatingMap.curryLeft_same
code: /-- Currying with the same element twice gives the zero map. -/
@[simp]
theorem curryLeft_same {n : ℕ} (f : M'' [⋀^Fin n.succ.succ]→ₗ[R'] N'') (m : M'') :
    (f.curryLeft m).curryLeft m = 0 
goal: (f.curryLeft m).curryLeft m = 0

full_name: AlternatingMap.curryLeft_compAlternatingMap
code: @[simp]
theorem curryLeft_compAlternatingMap {n : ℕ} (g : N'' →ₗ[R'] N₂'')
    (f : M'' [⋀^Fin n.succ]→ₗ[R'] N'') (m : M'') :
    (g.compAlternatingMap f).curryLeft m = g.compAlternatingMap (f.curryLeft m) 
goal: (g.compAlternatingMap f).curryLeft m = g.compAlternatingMap (f.curryLeft m)

full_name: AlternatingMap.curryLeft_compLinearMap
code: @[simp]
theorem curryLeft_compLinearMap {n : ℕ} (g : M₂'' →ₗ[R'] M'')
    (f : M'' [⋀^Fin n.succ]→ₗ[R'] N'') (m : M₂'') :
    (f.compLinearMap g).curryLeft m = (f.curryLeft (g m)).compLinearMap g 
goal: (f.compLinearMap g).curryLeft m = (f.curryLeft (g m)).compLinearMap g

full_name: AlternatingMap.constLinearEquivOfIsEmpty
code: /-- The space of constant maps is equivalent to the space of maps that are alternating with respect
to an empty family. -/
@[simps]
def constLinearEquivOfIsEmpty [IsEmpty ι] : N'' ≃ₗ[R'] (M'' [⋀^ι]→ₗ[R'] N'') 
goal: N'' ≃ₗ[R'] M'' [⋀^ι]→ₗ[R'] N''

full_name: AlternatingMap.constLinearEquivOfIsEmpty_symm_apply
code: /-- The space of constant maps is equivalent to the space of maps that are alternating with respect
to an empty family. -/
@[simps]
def constLinearEquivOfIsEmpty [IsEmpty ι] : N'' ≃ₗ[R'] (M'' [⋀^ι]→ₗ[R'] N'') 
goal: AlternatingMap.constLinearEquivOfIsEmpty.symm f = f 0

full_name: AlternatingMap.constLinearEquivOfIsEmpty_apply
code: /-- The space of constant maps is equivalent to the space of maps that are alternating with respect
to an empty family. -/
@[simps]
def constLinearEquivOfIsEmpty [IsEmpty ι] : N'' ≃ₗ[R'] (M'' [⋀^ι]→ₗ[R'] N'') 
goal: AlternatingMap.constLinearEquivOfIsEmpty m = AlternatingMap.constOfIsEmpty R' M'' ι m