File: Mathlib/LinearAlgebra/Determinant.lean

full_name: equivOfPiLEquivPi
code: /-- If `R^m` and `R^n` are linearly equivalent, then `m` and `n` are also equivalent. -/
def equivOfPiLEquivPi {R : Type*} [Finite m] [Finite n] [CommRing R] [Nontrivial R]
    (e : (m → R) ≃ₗ[R] n → R) : m ≃ n 
goal: m ≃ n

full_name: Matrix.indexEquivOfInv
code: /-- If `M` and `M'` are each other's inverse matrices, they are square matrices up to
equivalence of types. -/
def indexEquivOfInv [Nontrivial A] [DecidableEq m] [DecidableEq n] {M : Matrix m n A}
    {M' : Matrix n m A} (hMM' : M * M' = 1) (hM'M : M' * M = 1) : m ≃ n 
goal: m ≃ n

full_name: Matrix.det_comm
code: theorem det_comm [DecidableEq n] (M N : Matrix n n A) : det (M * N) = det (N * M) 
goal: (M * N).det = (N * M).det

full_name: Matrix.det_comm'
code: /-- If there exists a two-sided inverse `M'` for `M` (indexed differently),
then `det (N * M) = det (M * N)`. -/
theorem det_comm' [DecidableEq m] [DecidableEq n] {M : Matrix n m A} {N : Matrix m n A}
    {M' : Matrix m n A} (hMM' : M * M' = 1) (hM'M : M' * M = 1) : det (M * N) = det (N * M) 
goal: (M * N).det = (N * M).det

full_name: Matrix.det_conj_of_mul_eq_one
code: /-- If `M'` is a two-sided inverse for `M` (indexed differently), `det (M * N * M') = det N`.

See `Matrix.det_conj` and `Matrix.det_conj'` for the case when `M' = M⁻¹` or vice versa. -/
theorem det_conj_of_mul_eq_one [DecidableEq m] [DecidableEq n] {M : Matrix m n A}
    {M' : Matrix n m A} {N : Matrix n n A} (hMM' : M * M' = 1) (hM'M : M' * M = 1) :
    det (M * N * M') = det N 
goal: (M * N * M').det = N.det

full_name: LinearMap.det_toMatrix_eq_det_toMatrix
code: /-- The determinant of `LinearMap.toMatrix` does not depend on the choice of basis. -/
theorem det_toMatrix_eq_det_toMatrix [DecidableEq κ] (b : Basis ι A M) (c : Basis κ A M)
    (f : M →ₗ[A] M) : det (LinearMap.toMatrix b b f) = det (LinearMap.toMatrix c c f) 
goal: ((LinearMap.toMatrix b b) f).det = ((LinearMap.toMatrix c c) f).det

full_name: LinearMap.detAux_def
code: /-- The determinant of an endomorphism given a basis.

See `LinearMap.det` for a version that populates the basis non-computably.

Although the `Trunc (Basis ι A M)` parameter makes it slightly more convenient to switch bases,
there is no good way to generalize over universe parameters, so we can't fully state in `detAux`'s
type that it does not depend on the choice of basis. Instead you can use the `detAux_def''` lemma,
or avoid mentioning a basis at all using `LinearMap.det`.
-/
irreducible_def detAux : Trunc (Basis ι A M) → (M →ₗ[A] M) →* A 
goal: LinearMap.detAux = Trunc.lift (fun b => Matrix.detMonoidHom.comp ↑(LinearMap.toMatrixAlgEquiv b)) ⋯

full_name: LinearMap.detAux
code: /-- The determinant of an endomorphism given a basis.

See `LinearMap.det` for a version that populates the basis non-computably.

Although the `Trunc (Basis ι A M)` parameter makes it slightly more convenient to switch bases,
there is no good way to generalize over universe parameters, so we can't fully state in `detAux`'s
type that it does not depend on the choice of basis. Instead you can use the `detAux_def''` lemma,
or avoid mentioning a basis at all using `LinearMap.det`.
-/
irreducible_def detAux : Trunc (Basis ι A M) → (M →ₗ[A] M) →* A 
goal: Trunc (Basis ι A M) → (M →ₗ[A] M) →* A

full_name: LinearMap.definition._@.Mathlib.LinearAlgebra.Determinant._hyg.1152
code: /-- The determinant of an endomorphism given a basis.

See `LinearMap.det` for a version that populates the basis non-computably.

Although the `Trunc (Basis ι A M)` parameter makes it slightly more convenient to switch bases,
there is no good way to generalize over universe parameters, so we can't fully state in `detAux`'s
type that it does not depend on the choice of basis. Instead you can use the `detAux_def''` lemma,
or avoid mentioning a basis at all using `LinearMap.det`.
-/
irreducible_def detAux : Trunc (Basis ι A M) → (M →ₗ[A] M) →* A 
goal: Trunc (Basis ι A M) → (M →ₗ[A] M) →* A

full_name: LinearMap.wrapped._@.Mathlib.LinearAlgebra.Determinant._hyg.1152
code: /-- The determinant of an endomorphism given a basis.

See `LinearMap.det` for a version that populates the basis non-computably.

Although the `Trunc (Basis ι A M)` parameter makes it slightly more convenient to switch bases,
there is no good way to generalize over universe parameters, so we can't fully state in `detAux`'s
type that it does not depend on the choice of basis. Instead you can use the `detAux_def''` lemma,
or avoid mentioning a basis at all using `LinearMap.det`.
-/
irreducible_def detAux : Trunc (Basis ι A M) → (M →ₗ[A] M) →* A 
goal: Subtype (Eq @LinearMap.definition✝)

full_name: LinearMap.detAux_def'
code: /-- Unfold lemma for `detAux`.

See also `detAux_def''` which allows you to vary the basis.
-/
theorem detAux_def' (b : Basis ι A M) (f : M →ₗ[A] M) :
    LinearMap.detAux (Trunc.mk b) f = Matrix.det (LinearMap.toMatrix b b f) 
goal: (LinearMap.detAux (Trunc.mk b)) f = ((LinearMap.toMatrix b b) f).det

full_name: LinearMap.detAux_def''
code: theorem detAux_def'' {ι' : Type*} [Fintype ι'] [DecidableEq ι'] (tb : Trunc <| Basis ι A M)
    (b' : Basis ι' A M) (f : M →ₗ[A] M) :
    LinearMap.detAux tb f = Matrix.det (LinearMap.toMatrix b' b' f) 
goal: (LinearMap.detAux tb) f = ((LinearMap.toMatrix b' b') f).det

full_name: LinearMap.detAux_id
code: @[simp]
theorem detAux_id (b : Trunc <| Basis ι A M) : LinearMap.detAux b LinearMap.id = 1 
goal: (LinearMap.detAux b) LinearMap.id = 1

full_name: LinearMap.detAux_comp
code: @[simp]
theorem detAux_comp (b : Trunc <| Basis ι A M) (f g : M →ₗ[A] M) :
    LinearMap.detAux b (f.comp g) = LinearMap.detAux b f * LinearMap.detAux b g 
goal: (LinearMap.detAux b) (f ∘ₗ g) = (LinearMap.detAux b) f * (LinearMap.detAux b) g

full_name: LinearMap.det
code: /-- The determinant of an endomorphism independent of basis.

If there is no finite basis on `M`, the result is `1` instead.
-/
protected irreducible_def det : (M →ₗ[A] M) →* A 
goal: (M →ₗ[A] M) →* A

full_name: LinearMap.wrapped._@.Mathlib.LinearAlgebra.Determinant._hyg.1915
code: /-- The determinant of an endomorphism independent of basis.

If there is no finite basis on `M`, the result is `1` instead.
-/
protected irreducible_def det : (M →ₗ[A] M) →* A 
goal: Subtype (Eq @LinearMap.definition✝)

full_name: LinearMap.det_def
code: /-- The determinant of an endomorphism independent of basis.

If there is no finite basis on `M`, the result is `1` instead.
-/
protected irreducible_def det : (M →ₗ[A] M) →* A 
goal: LinearMap.det = if H : ∃ s, Nonempty (Basis { x // x ∈ s } A M) then LinearMap.detAux (Trunc.mk ⋯.some) else 1

full_name: LinearMap.definition._@.Mathlib.LinearAlgebra.Determinant._hyg.1915
code: /-- The determinant of an endomorphism independent of basis.

If there is no finite basis on `M`, the result is `1` instead.
-/
protected irreducible_def det : (M →ₗ[A] M) →* A 
goal: (M →ₗ[A] M) →* A

full_name: LinearMap.coe_det
code: theorem coe_det [DecidableEq M] :
    ⇑(LinearMap.det : (M →ₗ[A] M) →* A) =
      if H : ∃ s : Finset M, Nonempty (Basis s A M) then
        LinearMap.detAux (Trunc.mk H.choose_spec.some)
      else 1 
goal: ⇑LinearMap.det = ⇑(if H : ∃ s, Nonempty (Basis { x // x ∈ s } A M) then LinearMap.detAux (Trunc.mk ⋯.some) else 1)

full_name: LinearMap.det_eq_det_toMatrix_of_finset
code: theorem det_eq_det_toMatrix_of_finset [DecidableEq M] {s : Finset M} (b : Basis s A M)
    (f : M →ₗ[A] M) : LinearMap.det f = Matrix.det (LinearMap.toMatrix b b f) 
goal: LinearMap.det f = ((LinearMap.toMatrix b b) f).det

full_name: LinearMap.det_toMatrix
code: @[simp]
theorem det_toMatrix (b : Basis ι A M) (f : M →ₗ[A] M) :
    Matrix.det (toMatrix b b f) = LinearMap.det f 
goal: ((LinearMap.toMatrix b b) f).det = LinearMap.det f

full_name: LinearMap.det_toMatrix'
code: @[simp]
theorem det_toMatrix' {ι : Type*} [Fintype ι] [DecidableEq ι] (f : (ι → A) →ₗ[A] ι → A) :
    Matrix.det (LinearMap.toMatrix' f) = LinearMap.det f 
goal: (LinearMap.toMatrix' f).det = LinearMap.det f

full_name: LinearMap.det_toLin
code: @[simp]
theorem det_toLin (b : Basis ι R M) (f : Matrix ι ι R) :
    LinearMap.det (Matrix.toLin b b f) = f.det 
goal: LinearMap.det ((Matrix.toLin b b) f) = f.det

full_name: LinearMap.det_toLin'
code: @[simp]
theorem det_toLin' (f : Matrix ι ι R) : LinearMap.det (Matrix.toLin' f) = Matrix.det f 
goal: LinearMap.det (Matrix.toLin' f) = f.det

full_name: LinearMap.det_cases
code: /-- To show `P (LinearMap.det f)` it suffices to consider `P (Matrix.det (toMatrix _ _ f))` and
`P 1`. -/
-- @[elab_as_elim] -- Porting note: This attr can't be applied.
theorem det_cases [DecidableEq M] {P : A → Prop} (f : M →ₗ[A] M)
    (hb : ∀ (s : Finset M) (b : Basis s A M), P (Matrix.det (toMatrix b b f))) (h1 : P 1) :
    P (LinearMap.det f) 
goal: P (LinearMap.det f)

full_name: LinearMap.det_comp
code: @[simp]
theorem det_comp (f g : M →ₗ[A] M) :
    LinearMap.det (f.comp g) = LinearMap.det f * LinearMap.det g 
goal: LinearMap.det (f ∘ₗ g) = LinearMap.det f * LinearMap.det g

full_name: LinearMap.det_id
code: @[simp]
theorem det_id : LinearMap.det (LinearMap.id : M →ₗ[A] M) = 1 
goal: LinearMap.det LinearMap.id = 1

full_name: LinearMap.det_smul
code: /-- Multiplying a map by a scalar `c` multiplies its determinant by `c ^ dim M`. -/
@[simp]
theorem det_smul {𝕜 : Type*} [Field 𝕜] {M : Type*} [AddCommGroup M] [Module 𝕜 M] (c : 𝕜)
    (f : M →ₗ[𝕜] M) :
    LinearMap.det (c • f) = c ^ FiniteDimensional.finrank 𝕜 M * LinearMap.det f 
goal: LinearMap.det (c • f) = c ^ FiniteDimensional.finrank 𝕜 M * LinearMap.det f

full_name: LinearMap.det_zero'
code: theorem det_zero' {ι : Type*} [Finite ι] [Nonempty ι] (b : Basis ι A M) :
    LinearMap.det (0 : M →ₗ[A] M) = 0 
goal: LinearMap.det 0 = 0

full_name: LinearMap.det_zero
code: /-- In a finite-dimensional vector space, the zero map has determinant `1` in dimension `0`,
and `0` otherwise. We give a formula that also works in infinite dimension, where we define
the determinant to be `1`. -/
@[simp]
theorem det_zero {𝕜 : Type*} [Field 𝕜] {M : Type*} [AddCommGroup M] [Module 𝕜 M] :
    LinearMap.det (0 : M →ₗ[𝕜] M) = (0 : 𝕜) ^ FiniteDimensional.finrank 𝕜 M 
goal: LinearMap.det 0 = 0 ^ FiniteDimensional.finrank 𝕜 M

full_name: LinearMap.det_eq_one_of_subsingleton
code: theorem det_eq_one_of_subsingleton [Subsingleton M] (f : M →ₗ[R] M) :
    LinearMap.det (f : M →ₗ[R] M) = 1 
goal: LinearMap.det f = 1

full_name: LinearMap.det_eq_one_of_finrank_eq_zero
code: theorem det_eq_one_of_finrank_eq_zero {𝕜 : Type*} [Field 𝕜] {M : Type*} [AddCommGroup M]
    [Module 𝕜 M] (h : FiniteDimensional.finrank 𝕜 M = 0) (f : M →ₗ[𝕜] M) :
    LinearMap.det (f : M →ₗ[𝕜] M) = 1 
goal: LinearMap.det f = 1

full_name: LinearMap.det_conj
code: /-- Conjugating a linear map by a linear equiv does not change its determinant. -/
@[simp]
theorem det_conj {N : Type*} [AddCommGroup N] [Module A N] (f : M →ₗ[A] M) (e : M ≃ₗ[A] N) :
    LinearMap.det ((e : M →ₗ[A] N) ∘ₗ f ∘ₗ (e.symm : N →ₗ[A] M)) = LinearMap.det f 
goal: LinearMap.det (↑e ∘ₗ f ∘ₗ ↑e.symm) = LinearMap.det f

full_name: LinearMap.isUnit_det
code: /-- If a linear map is invertible, so is its determinant. -/
theorem isUnit_det {A : Type*} [CommRing A] [Module A M] (f : M →ₗ[A] M) (hf : IsUnit f) :
    IsUnit (LinearMap.det f) 
goal: IsUnit (LinearMap.det f)

full_name: LinearMap.finiteDimensional_of_det_ne_one
code: /-- If a linear map has determinant different from `1`, then the space is finite-dimensional. -/
theorem finiteDimensional_of_det_ne_one {𝕜 : Type*} [Field 𝕜] [Module 𝕜 M] (f : M →ₗ[𝕜] M)
    (hf : LinearMap.det f ≠ 1) : FiniteDimensional 𝕜 M 
goal: FiniteDimensional 𝕜 M

full_name: LinearMap.range_lt_top_of_det_eq_zero
code: /-- If the determinant of a map vanishes, then the map is not onto. -/
theorem range_lt_top_of_det_eq_zero {𝕜 : Type*} [Field 𝕜] [Module 𝕜 M] {f : M →ₗ[𝕜] M}
    (hf : LinearMap.det f = 0) : LinearMap.range f < ⊤ 
goal: LinearMap.range f < ⊤

full_name: LinearMap.bot_lt_ker_of_det_eq_zero
code: /-- If the determinant of a map vanishes, then the map is not injective. -/
theorem bot_lt_ker_of_det_eq_zero {𝕜 : Type*} [Field 𝕜] [Module 𝕜 M] {f : M →ₗ[𝕜] M}
    (hf : LinearMap.det f = 0) : ⊥ < LinearMap.ker f 
goal: ⊥ < LinearMap.ker f

full_name: LinearEquiv.det
code: /-- On a `LinearEquiv`, the domain of `LinearMap.det` can be promoted to `Rˣ`. -/
protected def det : (M ≃ₗ[R] M) →* Rˣ 
goal: (M ≃ₗ[R] M) →* Rˣ

full_name: LinearEquiv.coe_det
code: @[simp]
theorem coe_det (f : M ≃ₗ[R] M) : ↑(LinearEquiv.det f) = LinearMap.det (f : M →ₗ[R] M) 
goal: ↑(LinearEquiv.det f) = LinearMap.det ↑f

full_name: LinearEquiv.coe_inv_det
code: @[simp]
theorem coe_inv_det (f : M ≃ₗ[R] M) : ↑(LinearEquiv.det f)⁻¹ = LinearMap.det (f.symm : M →ₗ[R] M) 
goal: ↑(LinearEquiv.det f)⁻¹ = LinearMap.det ↑f.symm

full_name: LinearEquiv.det_refl
code: @[simp]
theorem det_refl : LinearEquiv.det (LinearEquiv.refl R M) = 1 
goal: LinearEquiv.det (LinearEquiv.refl R M) = 1

full_name: LinearEquiv.det_trans
code: @[simp]
theorem det_trans (f g : M ≃ₗ[R] M) :
    LinearEquiv.det (f.trans g) = LinearEquiv.det g * LinearEquiv.det f 
goal: LinearEquiv.det (f ≪≫ₗ g) = LinearEquiv.det g * LinearEquiv.det f

full_name: LinearEquiv.det_symm
code: @[simp]
theorem det_symm (f : M ≃ₗ[R] M) : LinearEquiv.det f.symm = LinearEquiv.det f⁻¹ 
goal: LinearEquiv.det f.symm = LinearEquiv.det f⁻¹

full_name: LinearEquiv.det_conj
code: /-- Conjugating a linear equiv by a linear equiv does not change its determinant. -/
@[simp]
theorem det_conj (f : M ≃ₗ[R] M) (e : M ≃ₗ[R] M') :
    LinearEquiv.det ((e.symm.trans f).trans e) = LinearEquiv.det f 
goal: LinearEquiv.det (e.symm ≪≫ₗ f ≪≫ₗ e) = LinearEquiv.det f

full_name: LinearEquiv.det_mul_det_symm
code: /-- The determinants of a `LinearEquiv` and its inverse multiply to 1. -/
@[simp]
theorem LinearEquiv.det_mul_det_symm {A : Type*} [CommRing A] [Module A M] (f : M ≃ₗ[A] M) :
    LinearMap.det (f : M →ₗ[A] M) * LinearMap.det (f.symm : M →ₗ[A] M) = 1 
goal: LinearMap.det ↑f * LinearMap.det ↑f.symm = 1

full_name: LinearEquiv.det_symm_mul_det
code: /-- The determinants of a `LinearEquiv` and its inverse multiply to 1. -/
@[simp]
theorem LinearEquiv.det_symm_mul_det {A : Type*} [CommRing A] [Module A M] (f : M ≃ₗ[A] M) :
    LinearMap.det (f.symm : M →ₗ[A] M) * LinearMap.det (f : M →ₗ[A] M) = 1 
goal: LinearMap.det ↑f.symm * LinearMap.det ↑f = 1

full_name: LinearEquiv.isUnit_det
code: theorem LinearEquiv.isUnit_det (f : M ≃ₗ[R] M') (v : Basis ι R M) (v' : Basis ι R M') :
    IsUnit (LinearMap.toMatrix v v' f).det 
goal: IsUnit ((LinearMap.toMatrix v v') ↑f).det

full_name: LinearEquiv.isUnit_det'
code: /-- Specialization of `LinearEquiv.isUnit_det` -/
theorem LinearEquiv.isUnit_det' {A : Type*} [CommRing A] [Module A M] (f : M ≃ₗ[A] M) :
    IsUnit (LinearMap.det (f : M →ₗ[A] M)) 
goal: IsUnit (LinearMap.det ↑f)

full_name: LinearEquiv.det_coe_symm
code: /-- The determinant of `f.symm` is the inverse of that of `f` when `f` is a linear equiv. -/
theorem LinearEquiv.det_coe_symm {𝕜 : Type*} [Field 𝕜] [Module 𝕜 M] (f : M ≃ₗ[𝕜] M) :
    LinearMap.det (f.symm : M →ₗ[𝕜] M) = (LinearMap.det (f : M →ₗ[𝕜] M))⁻¹ 
goal: LinearMap.det ↑f.symm = (LinearMap.det ↑f)⁻¹

full_name: LinearEquiv.ofIsUnitDet
code: /-- Builds a linear equivalence from a linear map whose determinant in some bases is a unit. -/
@[simps]
def LinearEquiv.ofIsUnitDet {f : M →ₗ[R] M'} {v : Basis ι R M} {v' : Basis ι R M'}
    (h : IsUnit (LinearMap.toMatrix v v' f).det) : M ≃ₗ[R] M' 
goal: M ≃ₗ[R] M'

full_name: LinearEquiv.ofIsUnitDet_symm_apply
code: /-- Builds a linear equivalence from a linear map whose determinant in some bases is a unit. -/
@[simps]
def LinearEquiv.ofIsUnitDet {f : M →ₗ[R] M'} {v : Basis ι R M} {v' : Basis ι R M'}
    (h : IsUnit (LinearMap.toMatrix v v' f).det) : M ≃ₗ[R] M' 
goal: (LinearEquiv.ofIsUnitDet h).symm a = ((Matrix.toLin v' v) ((LinearMap.toMatrix v v') f)⁻¹) a

full_name: LinearEquiv.ofIsUnitDet_apply
code: /-- Builds a linear equivalence from a linear map whose determinant in some bases is a unit. -/
@[simps]
def LinearEquiv.ofIsUnitDet {f : M →ₗ[R] M'} {v : Basis ι R M} {v' : Basis ι R M'}
    (h : IsUnit (LinearMap.toMatrix v v' f).det) : M ≃ₗ[R] M' 
goal: (LinearEquiv.ofIsUnitDet h) a = f a

full_name: LinearEquiv.coe_ofIsUnitDet
code: @[simp]
theorem LinearEquiv.coe_ofIsUnitDet {f : M →ₗ[R] M'} {v : Basis ι R M} {v' : Basis ι R M'}
    (h : IsUnit (LinearMap.toMatrix v v' f).det) :
    (LinearEquiv.ofIsUnitDet h : M →ₗ[R] M') = f 
goal: ↑(LinearEquiv.ofIsUnitDet h) = f

full_name: LinearMap.equivOfDetNeZero
code: /-- Builds a linear equivalence from a linear map on a finite-dimensional vector space whose
determinant is nonzero. -/
abbrev LinearMap.equivOfDetNeZero {𝕜 : Type*} [Field 𝕜] {M : Type*} [AddCommGroup M] [Module 𝕜 M]
    [FiniteDimensional 𝕜 M] (f : M →ₗ[𝕜] M) (hf : LinearMap.det f ≠ 0) : M ≃ₗ[𝕜] M 
goal: M ≃ₗ[𝕜] M

full_name: LinearMap.associated_det_of_eq_comp
code: theorem LinearMap.associated_det_of_eq_comp (e : M ≃ₗ[R] M) (f f' : M →ₗ[R] M)
    (h : ∀ x, f x = f' (e x)) : Associated (LinearMap.det f) (LinearMap.det f') 
goal: Associated (LinearMap.det f) (LinearMap.det f')

full_name: LinearMap.associated_det_comp_equiv
code: theorem LinearMap.associated_det_comp_equiv {N : Type*} [AddCommGroup N] [Module R N]
    (f : N →ₗ[R] M) (e e' : M ≃ₗ[R] N) :
    Associated (LinearMap.det (f ∘ₗ ↑e)) (LinearMap.det (f ∘ₗ ↑e')) 
goal: Associated (LinearMap.det (f ∘ₗ ↑e)) (LinearMap.det (f ∘ₗ ↑e'))

full_name: Basis.det
code: /-- The determinant of a family of vectors with respect to some basis, as an alternating
multilinear map. -/
nonrec def Basis.det : M [⋀^ι]→ₗ[R] R 
goal: M [⋀^ι]→ₗ[R] R

full_name: Basis.det_apply
code: theorem Basis.det_apply (v : ι → M) : e.det v = Matrix.det (e.toMatrix v) 
goal: e.det v = (e.toMatrix v).det

full_name: Basis.det_self
code: theorem Basis.det_self : e.det e = 1 
goal: e.det ⇑e = 1

full_name: Basis.det_isEmpty
code: @[simp]
theorem Basis.det_isEmpty [IsEmpty ι] : e.det = AlternatingMap.constOfIsEmpty R M ι 1 
goal: e.det = AlternatingMap.constOfIsEmpty R M ι 1

full_name: Basis.det_ne_zero
code: /-- `Basis.det` is not the zero map. -/
theorem Basis.det_ne_zero [Nontrivial R] : e.det ≠ 0 
goal: e.det ≠ 0

full_name: Basis.smul_det
code: theorem Basis.smul_det {G} [Group G] [DistribMulAction G M] [SMulCommClass G R M]
    (g : G) (v : ι → M) :
    (g • e).det v = e.det (g⁻¹ • v) 
goal: (g • e).det v = e.det (g⁻¹ • v)

full_name: is_basis_iff_det
code: theorem is_basis_iff_det {v : ι → M} :
    LinearIndependent R v ∧ span R (Set.range v) = ⊤ ↔ IsUnit (e.det v) 
goal: LinearIndependent R v ∧ Submodule.span R (Set.range v) = ⊤ ↔ IsUnit (e.det v)

full_name: Basis.isUnit_det
code: theorem Basis.isUnit_det (e' : Basis ι R M) : IsUnit (e.det e') 
goal: IsUnit (e.det ⇑e')

full_name: AlternatingMap.eq_smul_basis_det
code: /-- Any alternating map to `R` where `ι` has the cardinality of a basis equals the determinant
map with respect to that basis, multiplied by the value of that alternating map on that basis. -/
theorem AlternatingMap.eq_smul_basis_det (f : M [⋀^ι]→ₗ[R] R) : f = f e • e.det 
goal: f = f ⇑e • e.det

full_name: AlternatingMap.map_basis_eq_zero_iff
code: @[simp]
theorem AlternatingMap.map_basis_eq_zero_iff {ι : Type*} [Finite ι] (e : Basis ι R M)
    (f : M [⋀^ι]→ₗ[R] R) : f e = 0 ↔ f = 0 
goal: f ⇑e = 0 ↔ f = 0

full_name: AlternatingMap.map_basis_ne_zero_iff
code: theorem AlternatingMap.map_basis_ne_zero_iff {ι : Type*} [Finite ι] (e : Basis ι R M)
    (f : M [⋀^ι]→ₗ[R] R) : f e ≠ 0 ↔ f ≠ 0 
goal: f ⇑e ≠ 0 ↔ f ≠ 0

full_name: Basis.det_comp
code: @[simp]
theorem Basis.det_comp (e : Basis ι A M) (f : M →ₗ[A] M) (v : ι → M) :
    e.det (f ∘ v) = (LinearMap.det f) * e.det v 
goal: e.det (⇑f ∘ v) = LinearMap.det f * e.det v

full_name: Basis.det_comp_basis
code: @[simp]
theorem Basis.det_comp_basis [Module A M'] (b : Basis ι A M) (b' : Basis ι A M') (f : M →ₗ[A] M') :
    b'.det (f ∘ b) = LinearMap.det (f ∘ₗ (b'.equiv b (Equiv.refl ι) : M' →ₗ[A] M)) 
goal: b'.det (⇑f ∘ ⇑b) = LinearMap.det (f ∘ₗ ↑(b'.equiv b (Equiv.refl ι)))

full_name: Basis.det_reindex
code: theorem Basis.det_reindex {ι' : Type*} [Fintype ι'] [DecidableEq ι'] (b : Basis ι R M) (v : ι' → M)
    (e : ι ≃ ι') : (b.reindex e).det v = b.det (v ∘ e) 
goal: (b.reindex e).det v = b.det (v ∘ ⇑e)

full_name: Basis.det_reindex'
code: theorem Basis.det_reindex' {ι' : Type*} [Fintype ι'] [DecidableEq ι'] (b : Basis ι R M)
    (e : ι ≃ ι') : (b.reindex e).det = b.det.domDomCongr e 
goal: (b.reindex e).det = AlternatingMap.domDomCongr e b.det

full_name: Basis.det_reindex_symm
code: theorem Basis.det_reindex_symm {ι' : Type*} [Fintype ι'] [DecidableEq ι'] (b : Basis ι R M)
    (v : ι → M) (e : ι' ≃ ι) : (b.reindex e.symm).det (v ∘ e) = b.det v 
goal: (b.reindex e.symm).det (v ∘ ⇑e) = b.det v

full_name: Basis.det_map
code: @[simp]
theorem Basis.det_map (b : Basis ι R M) (f : M ≃ₗ[R] M') (v : ι → M') :
    (b.map f).det v = b.det (f.symm ∘ v) 
goal: (b.map f).det v = b.det (⇑f.symm ∘ v)

full_name: Basis.det_map'
code: theorem Basis.det_map' (b : Basis ι R M) (f : M ≃ₗ[R] M') :
    (b.map f).det = b.det.compLinearMap f.symm 
goal: (b.map f).det = b.det.compLinearMap ↑f.symm

full_name: Pi.basisFun_det
code: @[simp]
theorem Pi.basisFun_det : (Pi.basisFun R ι).det = Matrix.detRowAlternating 
goal: (Pi.basisFun R ι).det = Matrix.detRowAlternating

full_name: Basis.det_smul_mk_coord_eq_det_update
code: /-- If we fix a background basis `e`, then for any other basis `v`, we can characterise the
coordinates provided by `v` in terms of determinants relative to `e`. -/
theorem Basis.det_smul_mk_coord_eq_det_update {v : ι → M} (hli : LinearIndependent R v)
    (hsp : ⊤ ≤ span R (range v)) (i : ι) :
    e.det v • (Basis.mk hli hsp).coord i = e.det.toMultilinearMap.toLinearMap v i 
goal: e.det v • (Basis.mk hli hsp).coord i = (↑e.det).toLinearMap v i

full_name: Basis.det_unitsSMul
code: /-- If a basis is multiplied columnwise by scalars `w : ι → Rˣ`, then the determinant with respect
to this basis is multiplied by the product of the inverse of these scalars. -/
theorem Basis.det_unitsSMul (e : Basis ι R M) (w : ι → Rˣ) :
    (e.unitsSMul w).det = (↑(∏ i, w i)⁻¹ : R) • e.det 
goal: (e.unitsSMul w).det = ↑(∏ i : ι, w i)⁻¹ • e.det

full_name: Basis.det_unitsSMul_self
code: /-- The determinant of a basis constructed by `unitsSMul` is the product of the given units. -/
@[simp]
theorem Basis.det_unitsSMul_self (w : ι → Rˣ) : e.det (e.unitsSMul w) = ∏ i, (w i : R) 
goal: e.det ⇑(e.unitsSMul w) = ∏ i : ι, ↑(w i)

full_name: Basis.det_isUnitSMul
code: /-- The determinant of a basis constructed by `isUnitSMul` is the product of the given units. -/
@[simp]
theorem Basis.det_isUnitSMul {w : ι → R} (hw : ∀ i, IsUnit (w i)) :
    e.det (e.isUnitSMul hw) = ∏ i, w i 
goal: e.det ⇑(e.isUnitSMul hw) = ∏ i : ι, w i