File: Mathlib/LinearAlgebra/ExteriorAlgebra/Basic.lean

full_name: ExteriorAlgebra
code: /-- The exterior algebra of an `R`-module `M`.
-/
abbrev ExteriorAlgebra 
goal: Type (max u2 u1)

full_name: ExteriorAlgebra.ι
code: /-- The canonical linear map `M →ₗ[R] ExteriorAlgebra R M`.
-/
abbrev ι : M →ₗ[R] ExteriorAlgebra R M 
goal: M →ₗ[R] ExteriorAlgebra R M

full_name: ExteriorAlgebra.exteriorPower
code: /-- Definition of the `n`th exterior power of a `R`-module `N`. We introduce the notation
`⋀[R]^n M` for `exteriorPower R n M`. -/
abbrev exteriorPower : Submodule R (ExteriorAlgebra R M) 
goal: Submodule R (ExteriorAlgebra R M)

full_name: ExteriorAlgebra._aux_Mathlib_LinearAlgebra_ExteriorAlgebra_Basic___unexpand_ExteriorAlgebra_exteriorPower_1
code: @[inherit_doc exteriorPower]
notation:max "⋀[" R "]^" n:arg => exteriorPower R n
goal: Lean.PrettyPrinter.Unexpander

full_name: ExteriorAlgebra.«_aux_Mathlib_LinearAlgebra_ExteriorAlgebra_Basic___macroRules_ExteriorAlgebra_term⋀[_]^__1»
code: @[inherit_doc exteriorPower]
notation:max "⋀[" R "]^" n:arg => exteriorPower R n
goal: Lean.Macro

full_name: ExteriorAlgebra.ι_sq_zero
code: /-- As well as being linear, `ι m` squares to zero. -/
-- @[simp] -- Porting note (#10618): simp can prove this
theorem ι_sq_zero (m : M) : ι R m * ι R m = 0 
goal: (ExteriorAlgebra.ι R) m * (ExteriorAlgebra.ι R) m = 0

full_name: ExteriorAlgebra.comp_ι_sq_zero
code: theorem comp_ι_sq_zero (g : ExteriorAlgebra R M →ₐ[R] A) (m : M) : g (ι R m) * g (ι R m) = 0 
goal: g ((ExteriorAlgebra.ι R) m) * g ((ExteriorAlgebra.ι R) m) = 0

full_name: ExteriorAlgebra.lift
code: /-- Given a linear map `f : M →ₗ[R] A` into an `R`-algebra `A`, which satisfies the condition:
`cond : ∀ m : M, f m * f m = 0`, this is the canonical lift of `f` to a morphism of `R`-algebras
from `ExteriorAlgebra R M` to `A`.
-/
@[simps! symm_apply]
def lift : { f : M →ₗ[R] A // ∀ m, f m * f m = 0 } ≃ (ExteriorAlgebra R M →ₐ[R] A) 
goal: { f // ∀ (m : M), f m * f m = 0 } ≃ (ExteriorAlgebra R M →ₐ[R] A)

full_name: ExteriorAlgebra.lift_symm_apply
code: /-- Given a linear map `f : M →ₗ[R] A` into an `R`-algebra `A`, which satisfies the condition:
`cond : ∀ m : M, f m * f m = 0`, this is the canonical lift of `f` to a morphism of `R`-algebras
from `ExteriorAlgebra R M` to `A`.
-/
@[simps! symm_apply]
def lift : { f : M →ₗ[R] A // ∀ m, f m * f m = 0 } ≃ (ExteriorAlgebra R M →ₐ[R] A) 
goal: ∀ (a : ExteriorAlgebra R M →ₐ[R] A), (ExteriorAlgebra.lift R).symm a = ⟨↑((CliffordAlgebra.lift 0).symm a), ⋯⟩

full_name: ExteriorAlgebra.ι_comp_lift
code: @[simp]
theorem ι_comp_lift (f : M →ₗ[R] A) (cond : ∀ m, f m * f m = 0) :
    (lift R ⟨f, cond⟩).toLinearMap.comp (ι R) = f 
goal: ((ExteriorAlgebra.lift R) ⟨f, cond⟩).toLinearMap ∘ₗ ExteriorAlgebra.ι R = f

full_name: ExteriorAlgebra.lift_ι_apply
code: @[simp]
theorem lift_ι_apply (f : M →ₗ[R] A) (cond : ∀ m, f m * f m = 0) (x) :
    lift R ⟨f, cond⟩ (ι R x) = f x 
goal: ((ExteriorAlgebra.lift R) ⟨f, cond⟩) ((ExteriorAlgebra.ι R) x) = f x

full_name: ExteriorAlgebra.lift_unique
code: @[simp]
theorem lift_unique (f : M →ₗ[R] A) (cond : ∀ m, f m * f m = 0) (g : ExteriorAlgebra R M →ₐ[R] A) :
    g.toLinearMap.comp (ι R) = f ↔ g = lift R ⟨f, cond⟩ 
goal: g.toLinearMap ∘ₗ ExteriorAlgebra.ι R = f ↔ g = (ExteriorAlgebra.lift R) ⟨f, cond⟩

full_name: ExteriorAlgebra.lift_comp_ι
code: @[simp]
theorem lift_comp_ι (g : ExteriorAlgebra R M →ₐ[R] A) :
    lift R ⟨g.toLinearMap.comp (ι R), comp_ι_sq_zero _⟩ = g 
goal: (ExteriorAlgebra.lift R) ⟨g.toLinearMap ∘ₗ ExteriorAlgebra.ι R, ⋯⟩ = g

full_name: ExteriorAlgebra.hom_ext
code: /-- See note [partially-applied ext lemmas]. -/
@[ext]
theorem hom_ext {f g : ExteriorAlgebra R M →ₐ[R] A}
    (h : f.toLinearMap.comp (ι R) = g.toLinearMap.comp (ι R)) : f = g 
goal: f = g

full_name: ExteriorAlgebra.induction
code: /-- If `C` holds for the `algebraMap` of `r : R` into `ExteriorAlgebra R M`, the `ι` of `x : M`,
and is preserved under addition and muliplication, then it holds for all of `ExteriorAlgebra R M`.
-/
@[elab_as_elim]
theorem induction {C : ExteriorAlgebra R M → Prop}
    (algebraMap : ∀ r, C (algebraMap R (ExteriorAlgebra R M) r)) (ι : ∀ x, C (ι R x))
    (mul : ∀ a b, C a → C b → C (a * b)) (add : ∀ a b, C a → C b → C (a + b))
    (a : ExteriorAlgebra R M) : C a 
goal: C a

full_name: ExteriorAlgebra.algebraMapInv
code: /-- The left-inverse of `algebraMap`. -/
def algebraMapInv : ExteriorAlgebra R M →ₐ[R] R 
goal: ExteriorAlgebra R M →ₐ[R] R

full_name: ExteriorAlgebra.algebraMap_leftInverse
code: theorem algebraMap_leftInverse :
    Function.LeftInverse algebraMapInv (algebraMap R <| ExteriorAlgebra R M) 
goal: Function.LeftInverse ⇑ExteriorAlgebra.algebraMapInv ⇑(algebraMap R (ExteriorAlgebra R M))

full_name: ExteriorAlgebra.algebraMap_inj
code: @[simp]
theorem algebraMap_inj (x y : R) :
    algebraMap R (ExteriorAlgebra R M) x = algebraMap R (ExteriorAlgebra R M) y ↔ x = y 
goal: (algebraMap R (ExteriorAlgebra R M)) x = (algebraMap R (ExteriorAlgebra R M)) y ↔ x = y

full_name: ExteriorAlgebra.algebraMap_eq_zero_iff
code: @[simp]
theorem algebraMap_eq_zero_iff (x : R) : algebraMap R (ExteriorAlgebra R M) x = 0 ↔ x = 0 
goal: (algebraMap R (ExteriorAlgebra R M)) x = 0 ↔ x = 0

full_name: ExteriorAlgebra.algebraMap_eq_one_iff
code: @[simp]
theorem algebraMap_eq_one_iff (x : R) : algebraMap R (ExteriorAlgebra R M) x = 1 ↔ x = 1 
goal: (algebraMap R (ExteriorAlgebra R M)) x = 1 ↔ x = 1

full_name: ExteriorAlgebra.isUnit_algebraMap
code: theorem isUnit_algebraMap (r : R) : IsUnit (algebraMap R (ExteriorAlgebra R M) r) ↔ IsUnit r 
goal: IsUnit ((algebraMap R (ExteriorAlgebra R M)) r) ↔ IsUnit r

full_name: ExteriorAlgebra.invertibleAlgebraMapEquiv
code: /-- Invertibility in the exterior algebra is the same as invertibility of the base ring. -/
@[simps!]
def invertibleAlgebraMapEquiv (r : R) :
    Invertible (algebraMap R (ExteriorAlgebra R M) r) ≃ Invertible r 
goal: Invertible ((algebraMap R (ExteriorAlgebra R M)) r) ≃ Invertible r

full_name: ExteriorAlgebra.invertibleAlgebraMapEquiv_apply_invOf
code: /-- Invertibility in the exterior algebra is the same as invertibility of the base ring. -/
@[simps!]
def invertibleAlgebraMapEquiv (r : R) :
    Invertible (algebraMap R (ExteriorAlgebra R M) r) ≃ Invertible r 
goal: ∀ (x : Invertible ((algebraMap R (ExteriorAlgebra R M)) r)),
  ⅟r = ⅟(ExteriorAlgebra.algebraMapInv ((algebraMap R (ExteriorAlgebra R M)) r))

full_name: ExteriorAlgebra.invertibleAlgebraMapEquiv_symm_apply_invOf_toQuot
code: /-- Invertibility in the exterior algebra is the same as invertibility of the base ring. -/
@[simps!]
def invertibleAlgebraMapEquiv (r : R) :
    Invertible (algebraMap R (ExteriorAlgebra R M) r) ≃ Invertible r 
goal: ∀ (x : Invertible r),
  (⅟((algebraMap R (ExteriorAlgebra R M)) r)).toQuot =
    Quot.mk (RingQuot.Rel (CliffordAlgebra.Rel 0)) ((algebraMap R (TensorAlgebra R M)) ⅟r)

full_name: ExteriorAlgebra.toTrivSqZeroExt
code: /-- The canonical map from `ExteriorAlgebra R M` into `TrivSqZeroExt R M` that sends
`ExteriorAlgebra.ι` to `TrivSqZeroExt.inr`. -/
def toTrivSqZeroExt [Module Rᵐᵒᵖ M] [IsCentralScalar R M] :
    ExteriorAlgebra R M →ₐ[R] TrivSqZeroExt R M 
goal: ExteriorAlgebra R M →ₐ[R] TrivSqZeroExt R M

full_name: ExteriorAlgebra.toTrivSqZeroExt_ι
code: @[simp]
theorem toTrivSqZeroExt_ι [Module Rᵐᵒᵖ M] [IsCentralScalar R M] (x : M) :
    toTrivSqZeroExt (ι R x) = TrivSqZeroExt.inr x 
goal: ExteriorAlgebra.toTrivSqZeroExt ((ExteriorAlgebra.ι R) x) = TrivSqZeroExt.inr x

full_name: ExteriorAlgebra.ιInv
code: /-- The left-inverse of `ι`.

As an implementation detail, we implement this using `TrivSqZeroExt` which has a suitable
algebra structure. -/
def ιInv : ExteriorAlgebra R M →ₗ[R] M 
goal: ExteriorAlgebra R M →ₗ[R] M

full_name: ExteriorAlgebra.ι_leftInverse
code: theorem ι_leftInverse : Function.LeftInverse ιInv (ι R : M → ExteriorAlgebra R M) 
goal: Function.LeftInverse ⇑ExteriorAlgebra.ιInv ⇑(ExteriorAlgebra.ι R)

full_name: ExteriorAlgebra.ι_inj
code: @[simp]
theorem ι_inj (x y : M) : ι R x = ι R y ↔ x = y 
goal: (ExteriorAlgebra.ι R) x = (ExteriorAlgebra.ι R) y ↔ x = y

full_name: ExteriorAlgebra.ι_eq_zero_iff
code: @[simp]
theorem ι_eq_zero_iff (x : M) : ι R x = 0 ↔ x = 0 
goal: (ExteriorAlgebra.ι R) x = 0 ↔ x = 0

full_name: ExteriorAlgebra.ι_eq_algebraMap_iff
code: @[simp]
theorem ι_eq_algebraMap_iff (x : M) (r : R) : ι R x = algebraMap R _ r ↔ x = 0 ∧ r = 0 
goal: (ExteriorAlgebra.ι R) x = (algebraMap R (ExteriorAlgebra R M)) r ↔ x = 0 ∧ r = 0

full_name: ExteriorAlgebra.ι_ne_one
code: @[simp]
theorem ι_ne_one [Nontrivial R] (x : M) : ι R x ≠ 1 
goal: (ExteriorAlgebra.ι R) x ≠ 1

full_name: ExteriorAlgebra.ι_range_disjoint_one
code: /-- The generators of the exterior algebra are disjoint from its scalars. -/
theorem ι_range_disjoint_one :
    Disjoint (LinearMap.range (ι R : M →ₗ[R] ExteriorAlgebra R M))
      (1 : Submodule R (ExteriorAlgebra R M)) 
goal: Disjoint (LinearMap.range (ExteriorAlgebra.ι R)) 1

full_name: ExteriorAlgebra.ι_add_mul_swap
code: @[simp]
theorem ι_add_mul_swap (x y : M) : ι R x * ι R y + ι R y * ι R x = 0 
goal: (ExteriorAlgebra.ι R) x * (ExteriorAlgebra.ι R) y + (ExteriorAlgebra.ι R) y * (ExteriorAlgebra.ι R) x = 0

full_name: ExteriorAlgebra.ι_mul_prod_list
code: theorem ι_mul_prod_list {n : ℕ} (f : Fin n → M) (i : Fin n) :
    (ι R <| f i) * (List.ofFn fun i => ι R <| f i).prod = 0 
goal: (ExteriorAlgebra.ι R) (f i) * (List.ofFn fun i => (ExteriorAlgebra.ι R) (f i)).prod = 0

full_name: ExteriorAlgebra.ιMulti
code: /-- The product of `n` terms of the form `ι R m` is an alternating map.

This is a special case of `MultilinearMap.mkPiAlgebraFin`, and the exterior algebra version of
`TensorAlgebra.tprod`. -/
def ιMulti (n : ℕ) : M [⋀^Fin n]→ₗ[R] ExteriorAlgebra R M 
goal: M [⋀^Fin n]→ₗ[R] ExteriorAlgebra R M

full_name: ExteriorAlgebra.ιMulti_apply
code: theorem ιMulti_apply {n : ℕ} (v : Fin n → M) : ιMulti R n v = (List.ofFn fun i => ι R (v i)).prod 
goal: (ExteriorAlgebra.ιMulti R n) v = (List.ofFn fun i => (ExteriorAlgebra.ι R) (v i)).prod

full_name: ExteriorAlgebra.ιMulti_zero_apply
code: @[simp]
theorem ιMulti_zero_apply (v : Fin 0 → M) : ιMulti R 0 v = 1 
goal: (ExteriorAlgebra.ιMulti R 0) v = 1

full_name: ExteriorAlgebra.ιMulti_succ_apply
code: @[simp]
theorem ιMulti_succ_apply {n : ℕ} (v : Fin n.succ → M) :
    ιMulti R _ v = ι R (v 0) * ιMulti R _ (Matrix.vecTail v) 
goal: (ExteriorAlgebra.ιMulti R n.succ) v = (ExteriorAlgebra.ι R) (v 0) * (ExteriorAlgebra.ιMulti R n) (Matrix.vecTail v)

full_name: ExteriorAlgebra.ιMulti_succ_curryLeft
code: theorem ιMulti_succ_curryLeft {n : ℕ} (m : M) :
    (ιMulti R n.succ).curryLeft m = (LinearMap.mulLeft R (ι R m)).compAlternatingMap (ιMulti R n) 
goal: (ExteriorAlgebra.ιMulti R n.succ).curryLeft m =
  (LinearMap.mulLeft R ((ExteriorAlgebra.ι R) m)).compAlternatingMap (ExteriorAlgebra.ιMulti R n)

full_name: ExteriorAlgebra.ιMulti_range
code: /-- The image of `ExteriorAlgebra.ιMulti R n` is contained in the `n`th exterior power. -/
lemma ιMulti_range (n : ℕ) :
    Set.range (ιMulti R n (M := M)) ⊆ ↑(⋀[R]^n M) 
goal: Set.range ⇑(ExteriorAlgebra.ιMulti R n) ⊆ ↑(⋀[R]^n M)

full_name: ExteriorAlgebra.ιMulti_span_fixedDegree
code: /-- The image of `ExteriorAlgebra.ιMulti R n` spans the `n`th exterior power, as a submodule
of the exterior algebra. -/
lemma ιMulti_span_fixedDegree (n : ℕ) :
    Submodule.span R (Set.range (ιMulti R n)) = ⋀[R]^n M 
goal: Submodule.span R (Set.range ⇑(ExteriorAlgebra.ιMulti R n)) = ⋀[R]^n M

full_name: ExteriorAlgebra.ιMulti_family
code: /-- Given a linearly ordered family `v` of vectors of `M` and a natural number `n`, produce the
family of `n`fold exterior products of elements of `v`, seen as members of the exterior algebra. -/
abbrev ιMulti_family (n : ℕ) {I : Type*} [LinearOrder I] (v : I → M)
    (s : {s : Finset I // Finset.card s = n}) : ExteriorAlgebra R M 
goal: ExteriorAlgebra R M

full_name: ExteriorAlgebra.instNontrivial
code: /-- An `ExteriorAlgebra` over a nontrivial ring is nontrivial. -/
instance [Nontrivial R] : Nontrivial (ExteriorAlgebra R M) 
goal: Nontrivial (ExteriorAlgebra R M)

full_name: ExteriorAlgebra.map
code: /-- The morphism of exterior algebras induced by a linear map. -/
def map (f : M →ₗ[R] N) : ExteriorAlgebra R M →ₐ[R] ExteriorAlgebra R N 
goal: ExteriorAlgebra R M →ₐ[R] ExteriorAlgebra R N

full_name: ExteriorAlgebra.map_comp_ι
code: @[simp]
theorem map_comp_ι (f : M →ₗ[R] N) : (map f).toLinearMap ∘ₗ ι R = ι R ∘ₗ f 
goal: (ExteriorAlgebra.map f).toLinearMap ∘ₗ ExteriorAlgebra.ι R = ExteriorAlgebra.ι R ∘ₗ f

full_name: ExteriorAlgebra.map_apply_ι
code: @[simp]
theorem map_apply_ι (f : M →ₗ[R] N) (m : M) : map f (ι R m) = ι R (f m) 
goal: (ExteriorAlgebra.map f) ((ExteriorAlgebra.ι R) m) = (ExteriorAlgebra.ι R) (f m)

full_name: ExteriorAlgebra.map_apply_ιMulti
code: @[simp]
theorem map_apply_ιMulti {n : ℕ} (f : M →ₗ[R] N) (m : Fin n → M) :
    map f (ιMulti R n m) = ιMulti R n (f ∘ m) 
goal: (ExteriorAlgebra.map f) ((ExteriorAlgebra.ιMulti R n) m) = (ExteriorAlgebra.ιMulti R n) (⇑f ∘ m)

full_name: ExteriorAlgebra.map_comp_ιMulti
code: @[simp]
theorem map_comp_ιMulti {n : ℕ} (f : M →ₗ[R] N) :
    (map f).toLinearMap.compAlternatingMap (ιMulti R n (M := M)) =
    (ιMulti R n (M := N)).compLinearMap f 
goal: (ExteriorAlgebra.map f).toLinearMap.compAlternatingMap (ExteriorAlgebra.ιMulti R n) =
  (ExteriorAlgebra.ιMulti R n).compLinearMap f

full_name: ExteriorAlgebra.map_id
code: @[simp]
theorem map_id :
    map LinearMap.id = AlgHom.id R (ExteriorAlgebra R M) 
goal: ExteriorAlgebra.map LinearMap.id = AlgHom.id R (ExteriorAlgebra R M)

full_name: ExteriorAlgebra.map_comp_map
code: @[simp]
theorem map_comp_map (f : M →ₗ[R] N) (g : N →ₗ[R] N') :
    AlgHom.comp (map g) (map f) = map (LinearMap.comp g f) 
goal: (ExteriorAlgebra.map g).comp (ExteriorAlgebra.map f) = ExteriorAlgebra.map (g ∘ₗ f)

full_name: ExteriorAlgebra.ι_range_map_map
code: @[simp]
theorem ι_range_map_map (f : M →ₗ[R] N) :
    Submodule.map (AlgHom.toLinearMap (map f)) (LinearMap.range (ι R (M := M))) =
    Submodule.map (ι R) (LinearMap.range f) 
goal: Submodule.map (ExteriorAlgebra.map f).toLinearMap (LinearMap.range (ExteriorAlgebra.ι R)) =
  Submodule.map (ExteriorAlgebra.ι R) (LinearMap.range f)

full_name: ExteriorAlgebra.toTrivSqZeroExt_comp_map
code: theorem toTrivSqZeroExt_comp_map [Module Rᵐᵒᵖ M] [IsCentralScalar R M] [Module Rᵐᵒᵖ N]
    [IsCentralScalar R N] (f : M →ₗ[R] N) :
    toTrivSqZeroExt.comp (map f) = (TrivSqZeroExt.map f).comp toTrivSqZeroExt 
goal: ExteriorAlgebra.toTrivSqZeroExt.comp (ExteriorAlgebra.map f) =
  (TrivSqZeroExt.map f).comp ExteriorAlgebra.toTrivSqZeroExt

full_name: ExteriorAlgebra.ιInv_comp_map
code: theorem ιInv_comp_map (f : M →ₗ[R] N) :
    ιInv.comp (map f).toLinearMap = f.comp ιInv 
goal: ExteriorAlgebra.ιInv ∘ₗ (ExteriorAlgebra.map f).toLinearMap = f ∘ₗ ExteriorAlgebra.ιInv

full_name: ExteriorAlgebra.leftInverse_map_iff
code: /-- For a linear map `f` from `M` to `N`,
`ExteriorAlgebra.map g` is a retraction of `ExteriorAlgebra.map f` iff
`g` is a retraction of `f`. -/
@[simp]
lemma leftInverse_map_iff {f : M →ₗ[R] N} {g : N →ₗ[R] M} :
    LeftInverse (map g) (map f) ↔ LeftInverse g f 
goal: Function.LeftInverse ⇑(ExteriorAlgebra.map g) ⇑(ExteriorAlgebra.map f) ↔ Function.LeftInverse ⇑g ⇑f

full_name: ExteriorAlgebra.map_injective
code: /-- A morphism of modules that admits a linear retraction induces an injective morphism of
exterior algebras. -/
lemma map_injective {f : M →ₗ[R] N} (hf : ∃ (g : N →ₗ[R] M), g.comp f = LinearMap.id) :
    Function.Injective (map f) 
goal: Function.Injective ⇑(ExteriorAlgebra.map f)

full_name: ExteriorAlgebra.map_surjective_iff
code: /-- A morphism of modules is surjective if and only the morphism of exterior algebras that it
induces is surjective. -/
@[simp]
lemma map_surjective_iff {f : M →ₗ[R] N} :
    Function.Surjective (map f) ↔ Function.Surjective f 
goal: Function.Surjective ⇑(ExteriorAlgebra.map f) ↔ Function.Surjective ⇑f

full_name: ExteriorAlgebra.map_injective_field
code: /-- An injective morphism of vector spaces induces an injective morphism of exterior algebras. -/
lemma map_injective_field {f : E →ₗ[K] F} (hf : LinearMap.ker f = ⊥) :
    Function.Injective (map f) 
goal: Function.Injective ⇑(ExteriorAlgebra.map f)

full_name: TensorAlgebra.toExterior
code: /-- The canonical image of the `TensorAlgebra` in the `ExteriorAlgebra`, which maps
`TensorAlgebra.ι R x` to `ExteriorAlgebra.ι R x`. -/
def toExterior : TensorAlgebra R M →ₐ[R] ExteriorAlgebra R M 
goal: TensorAlgebra R M →ₐ[R] ExteriorAlgebra R M

full_name: TensorAlgebra.toExterior_ι
code: @[simp]
theorem toExterior_ι (m : M) :
    TensorAlgebra.toExterior (TensorAlgebra.ι R m) = ExteriorAlgebra.ι R m 
goal: TensorAlgebra.toExterior ((TensorAlgebra.ι R) m) = (ExteriorAlgebra.ι R) m