ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/LinearAlgebra/TensorProduct/Matrix.lean

full_name: TensorProduct.toMatrix_map
code: /-- The linear map built from `TensorProduct.map` corresponds to the matrix built from
`Matrix.kronecker`. -/
theorem TensorProduct.toMatrix_map (f : M →ₗ[R] M') (g : N →ₗ[R] N') :
    toMatrix (bM.tensorProduct bN) (bM'.tensorProduct bN') (TensorProduct.map f g) =
      toMatrix bM bM' f ⊗ₖ toMatrix bN bN' g 
goal: (LinearMap.toMatrix (bM.tensorProduct bN) (bM'.tensorProduct bN')) (TensorProduct.map f g) =
  Matrix.kroneckerMap (fun x x_1 => x * x_1) ((LinearMap.toMatrix bM bM') f) ((LinearMap.toMatrix bN bN') g)

full_name: Matrix.toLin_kronecker
code: /-- The matrix built from `Matrix.kronecker` corresponds to the linear map built from
`TensorProduct.map`. -/
theorem Matrix.toLin_kronecker (A : Matrix ι' ι R) (B : Matrix κ' κ R) :
    toLin (bM.tensorProduct bN) (bM'.tensorProduct bN') (A ⊗ₖ B) =
      TensorProduct.map (toLin bM bM' A) (toLin bN bN' B) 
goal: (Matrix.toLin (bM.tensorProduct bN) (bM'.tensorProduct bN')) (Matrix.kroneckerMap (fun x x_1 => x * x_1) A B) =
  TensorProduct.map ((Matrix.toLin bM bM') A) ((Matrix.toLin bN bN') B)

full_name: TensorProduct.toMatrix_comm
code: /-- `TensorProduct.comm` corresponds to a permutation of the identity matrix. -/
theorem TensorProduct.toMatrix_comm :
    toMatrix (bM.tensorProduct bN) (bN.tensorProduct bM) (TensorProduct.comm R M N) =
      (1 : Matrix (ι × κ) (ι × κ) R).submatrix Prod.swap _root_.id 
goal: (LinearMap.toMatrix (bM.tensorProduct bN) (bN.tensorProduct bM)) ↑(TensorProduct.comm R M N) =
  Matrix.submatrix 1 Prod.swap id

full_name: TensorProduct.toMatrix_assoc
code: /-- `TensorProduct.assoc` corresponds to a permutation of the identity matrix. -/
theorem TensorProduct.toMatrix_assoc :
    toMatrix ((bM.tensorProduct bN).tensorProduct bP) (bM.tensorProduct (bN.tensorProduct bP))
        (TensorProduct.assoc R M N P) =
      (1 : Matrix (ι × κ × τ) (ι × κ × τ) R).submatrix _root_.id (Equiv.prodAssoc _ _ _) 
goal: (LinearMap.toMatrix ((bM.tensorProduct bN).tensorProduct bP) (bM.tensorProduct (bN.tensorProduct bP)))
    ↑(TensorProduct.assoc R M N P) =
  Matrix.submatrix 1 id ⇑(Equiv.prodAssoc ι κ τ)
File: Mathlib/LinearAlgebra/TensorProduct/Opposite.lean

full_name: Algebra.TensorProduct.opAlgEquiv
code: /-- `MulOpposite` distributes over `TensorProduct`. Note this is an `S`-algebra morphism, where
`A/S/R` is a tower of algebras. -/
def opAlgEquiv : Aᵐᵒᵖ ⊗[R] Bᵐᵒᵖ ≃ₐ[S] (A ⊗[R] B)ᵐᵒᵖ 
goal: Aᵐᵒᵖ ⊗[R] Bᵐᵒᵖ ≃ₐ[S] (A ⊗[R] B)ᵐᵒᵖ

full_name: Algebra.TensorProduct.opAlgEquiv_apply
code: theorem opAlgEquiv_apply (x : Aᵐᵒᵖ ⊗[R] Bᵐᵒᵖ) :
    opAlgEquiv R S A B x =
      op (_root_.TensorProduct.map
        (opLinearEquiv R).symm.toLinearMap (opLinearEquiv R).symm.toLinearMap x) 
goal: (Algebra.TensorProduct.opAlgEquiv R S A B) x =
  MulOpposite.op ((TensorProduct.map ↑(MulOpposite.opLinearEquiv R).symm ↑(MulOpposite.opLinearEquiv R).symm) x)

full_name: Algebra.TensorProduct.opAlgEquiv_symm_apply
code: theorem opAlgEquiv_symm_apply (x : (A ⊗[R] B)ᵐᵒᵖ) :
    (opAlgEquiv R S A B).symm x =
      _root_.TensorProduct.map (opLinearEquiv R).toLinearMap (opLinearEquiv R).toLinearMap x.unop 
goal: (Algebra.TensorProduct.opAlgEquiv R S A B).symm x =
  (TensorProduct.map ↑(MulOpposite.opLinearEquiv R) ↑(MulOpposite.opLinearEquiv R)) (MulOpposite.unop x)

full_name: Algebra.TensorProduct.opAlgEquiv_tmul
code: @[simp]
theorem opAlgEquiv_tmul (a : Aᵐᵒᵖ) (b : Bᵐᵒᵖ) :
    opAlgEquiv R S A B (a ⊗ₜ[R] b) = op (a.unop ⊗ₜ b.unop) 
goal: (Algebra.TensorProduct.opAlgEquiv R S A B) (a ⊗ₜ[R] b) = MulOpposite.op (MulOpposite.unop a ⊗ₜ[R] MulOpposite.unop b)

full_name: Algebra.TensorProduct.opAlgEquiv_symm_tmul
code: @[simp]
theorem opAlgEquiv_symm_tmul (a : A) (b : B) :
    (opAlgEquiv R S A B).symm (op <| a ⊗ₜ[R] b) = op a ⊗ₜ op b 
goal: (Algebra.TensorProduct.opAlgEquiv R S A B).symm (MulOpposite.op (a ⊗ₜ[R] b)) = MulOpposite.op a ⊗ₜ[R] MulOpposite.op b
File: Mathlib/LinearAlgebra/TensorProduct/Pi.lean

full_name: _private.Mathlib.LinearAlgebra.TensorProduct.Pi.0.TensorProduct.piScalarRightHomBil
code: private def piScalarRightHomBil : N →ₗ[S] (ι → R) →ₗ[R] (ι → N) 
goal: N →ₗ[S] (ι → R) →ₗ[R] ι → N

full_name: TensorProduct.piScalarRightHom
code: /-- For any `R`-module `N` and index type `ι`, there is a natural
linear map `N ⊗[R] (ι → R) →ₗ (ι → N)`. This map is an isomorphism if `ι` is finite. -/
noncomputable def piScalarRightHom : N ⊗[R] (ι → R) →ₗ[S] (ι → N) 
goal: TensorProduct R N (ι → R) →ₗ[S] ι → N

full_name: TensorProduct.piScalarRightHom_tmul
code: @[simp]
lemma piScalarRightHom_tmul (x : N) (f : ι → R) :
    piScalarRightHom R S N ι (x ⊗ₜ f) = (fun j ↦ f j • x) 
goal: (TensorProduct.piScalarRightHom R S N ι) (x ⊗ₜ[R] f) = fun j => f j • x

full_name: _private.Mathlib.LinearAlgebra.TensorProduct.Pi.0.TensorProduct.piScalarRightInv
code: private noncomputable
def piScalarRightInv : (ι → N) →ₗ[S] N ⊗[R] (ι → R) 
goal: (ι → N) →ₗ[S] TensorProduct R N (ι → R)

full_name: _private.Mathlib.LinearAlgebra.TensorProduct.Pi.0.TensorProduct.piScalarRightInv_single
code: @[simp]
private lemma piScalarRightInv_single (x : N) (i : ι) :
    piScalarRightInv R S N ι (Pi.single i x) = x ⊗ₜ Pi.single i 1 
goal: (TensorProduct.piScalarRightInv R S N ι) (Pi.single i x) = x ⊗ₜ[R] Pi.single i 1

full_name: TensorProduct.piScalarRight
code: /-- For any `R`-module `N` and finite index type `ι`, `N ⊗[R] (ι → R)` is canonically
isomorphic to `ι → N`. -/
noncomputable def piScalarRight : N ⊗[R] (ι → R) ≃ₗ[S] (ι → N) 
goal: TensorProduct R N (ι → R) ≃ₗ[S] ι → N

full_name: TensorProduct.piScalarRight_apply
code: @[simp]
lemma piScalarRight_apply (x : N ⊗[R] (ι → R)) :
    piScalarRight R S N ι x = piScalarRightHom R S N ι x 
goal: (TensorProduct.piScalarRight R S N ι) x = (TensorProduct.piScalarRightHom R S N ι) x

full_name: TensorProduct.piScalarRight_symm_single
code: @[simp]
lemma piScalarRight_symm_single (x : N) (i : ι) :
    (piScalarRight R S N ι).symm (Pi.single i x) = x ⊗ₜ Pi.single i 1 
goal: (TensorProduct.piScalarRight R S N ι).symm (Pi.single i x) = x ⊗ₜ[R] Pi.single i 1
File: Mathlib/LinearAlgebra/FinsuppVectorSpace.lean

full_name: Finsupp.linearIndependent_single
code: theorem linearIndependent_single {φ : ι → Type*} {f : ∀ ι, φ ι → M}
    (hf : ∀ i, LinearIndependent R (f i)) :
    LinearIndependent R fun ix : Σi, φ i => single ix.1 (f ix.1 ix.2) 
goal: LinearIndependent R fun ix => Finsupp.single ix.fst (f ix.fst ix.snd)

full_name: Finsupp.basis
code: /-- The basis on `ι →₀ M` with basis vectors `fun ⟨i, x⟩ ↦ single i (b i x)`. -/
protected def basis {φ : ι → Type*} (b : ∀ i, Basis (φ i) R M) : Basis (Σi, φ i) R (ι →₀ M) 
goal: Basis ((i : ι) × φ i) R (ι →₀ M)

full_name: Finsupp.basis_repr
code: @[simp]
theorem basis_repr {φ : ι → Type*} (b : ∀ i, Basis (φ i) R M) (g : ι →₀ M) (ix) :
    (Finsupp.basis b).repr g ix = (b ix.1).repr (g ix.1) ix.2 
goal: ((Finsupp.basis b).repr g) ix = ((b ix.fst).repr (g ix.fst)) ix.snd

full_name: Finsupp.coe_basis
code: @[simp]
theorem coe_basis {φ : ι → Type*} (b : ∀ i, Basis (φ i) R M) :
    ⇑(Finsupp.basis b) = fun ix : Σi, φ i => single ix.1 (b ix.1 ix.2) 
goal: ⇑(Finsupp.basis b) = fun ix => Finsupp.single ix.fst ((b ix.fst) ix.snd)

full_name: Finsupp.basisSingleOne
code: /-- The basis on `ι →₀ M` with basis vectors `fun i ↦ single i 1`. -/
@[simps]
protected def basisSingleOne : Basis ι R (ι →₀ R) 
goal: Basis ι R (ι →₀ R)

full_name: Finsupp.basisSingleOne_repr
code: /-- The basis on `ι →₀ M` with basis vectors `fun i ↦ single i 1`. -/
@[simps]
protected def basisSingleOne : Basis ι R (ι →₀ R) 
goal: Finsupp.basisSingleOne.repr = LinearEquiv.refl R (ι →₀ R)

full_name: Finsupp.coe_basisSingleOne
code: @[simp]
theorem coe_basisSingleOne : (Finsupp.basisSingleOne : ι → ι →₀ R) = fun i => Finsupp.single i 1 
goal: ⇑Finsupp.basisSingleOne = fun i => Finsupp.single i 1

full_name: DFinsupp.basis
code: /-- The direct sum of free modules is free.

Note that while this is stated for `DFinsupp` not `DirectSum`, the types are defeq. -/
noncomputable def basis {η : ι → Type*} (b : ∀ i, Basis (η i) R (M i)) :
    Basis (Σi, η i) R (Π₀ i, M i) 
goal: Basis ((i : ι) × η i) R (Π₀ (i : ι), M i)

full_name: Finset.sum_single_ite
code: theorem _root_.Finset.sum_single_ite [Fintype n] (a : R) (i : n) :
    (∑ x : n, Finsupp.single x (if i = x then a else 0)) = Finsupp.single i a 
goal: ∑ x : n, Finsupp.single x (if i = x then a else 0) = Finsupp.single i a

full_name: Basis.equivFun_symm_stdBasis
code: theorem equivFun_symm_stdBasis [Finite n] (b : Basis n R M) (i : n) :
    b.equivFun.symm (LinearMap.stdBasis R (fun _ => R) i 1) = b i 
goal: b.equivFun.symm ((LinearMap.stdBasis R (fun x => R) i) 1) = b i
File: Mathlib/LinearAlgebra/Charpoly/ToMatrix.lean

full_name: LinearMap.charpoly_toMatrix
code: /-- `charpoly f` is the characteristic polynomial of the matrix of `f` in any basis. -/
@[simp]
theorem charpoly_toMatrix {ι : Type w} [DecidableEq ι] [Fintype ι] (b : Basis ι R M) :
    (toMatrix b b f).charpoly = f.charpoly 
goal: ((LinearMap.toMatrix b b) f).charpoly = f.charpoly

full_name: LinearMap.charpoly_prodMap
code: lemma charpoly_prodMap (f₁ : M₁ →ₗ[R] M₁) (f₂ : M₂ →ₗ[R] M₂) :
    (f₁.prodMap f₂).charpoly = f₁.charpoly * f₂.charpoly 
goal: (f₁.prodMap f₂).charpoly = f₁.charpoly * f₂.charpoly

full_name: LinearEquiv.charpoly_conj
code: @[simp]
lemma LinearEquiv.charpoly_conj (e : M₁ ≃ₗ[R] M₂) (φ : Module.End R M₁) :
    (e.conj φ).charpoly = φ.charpoly 
goal: LinearMap.charpoly (e.conj φ) = LinearMap.charpoly φ
File: Mathlib/LinearAlgebra/TensorProduct/Basis.lean

full_name: Basis.tensorProduct
code: /-- If `b : ι → M` and `c : κ → N` are bases then so is `fun i ↦ b i.1 ⊗ₜ c i.2 : ι × κ → M ⊗ N`. -/
def Basis.tensorProduct (b : Basis ι S M) (c : Basis κ R N) :
    Basis (ι × κ) S (M ⊗[R] N) 
goal: Basis (ι × κ) S (TensorProduct R M N)

full_name: Basis.tensorProduct_apply
code: @[simp]
theorem Basis.tensorProduct_apply (b : Basis ι S M) (c : Basis κ R N) (i : ι) (j : κ) :
    Basis.tensorProduct b c (i, j) = b i ⊗ₜ c j 
goal: (b.tensorProduct c) (i, j) = b i ⊗ₜ[R] c j

full_name: Basis.tensorProduct_apply'
code: theorem Basis.tensorProduct_apply' (b : Basis ι S M) (c : Basis κ R N) (i : ι × κ) :
    Basis.tensorProduct b c i = b i.1 ⊗ₜ c i.2 
goal: (b.tensorProduct c) i = b i.1 ⊗ₜ[R] c i.2

full_name: Basis.tensorProduct_repr_tmul_apply
code: @[simp]
theorem Basis.tensorProduct_repr_tmul_apply (b : Basis ι S M) (c : Basis κ R N) (m : M) (n : N)
    (i : ι) (j : κ) :
    (Basis.tensorProduct b c).repr (m ⊗ₜ n) (i, j) = c.repr n j • b.repr m i 
goal: ((b.tensorProduct c).repr (m ⊗ₜ[R] n)) (i, j) = (c.repr n) j • (b.repr m) i

full_name: Basis.baseChange
code: /-- The lift of an `R`-basis of `M` to an `S`-basis of the base change `S ⊗[R] M`. -/
noncomputable
def Basis.baseChange (b : Basis ι R M) : Basis ι S (S ⊗[R] M) 
goal: Basis ι S (TensorProduct R S M)

full_name: Basis.baseChange_repr_tmul
code: @[simp]
lemma Basis.baseChange_repr_tmul (b : Basis ι R M) (x y i) :
    (b.baseChange S).repr (x ⊗ₜ y) i = b.repr y i • x 
goal: ((Basis.baseChange S b).repr (x ⊗ₜ[R] y)) i = (b.repr y) i • x

full_name: Basis.baseChange_apply
code: @[simp]
lemma Basis.baseChange_apply (b : Basis ι R M) (i) :
    b.baseChange S i = 1 ⊗ₜ b i 
goal: (Basis.baseChange S b) i = 1 ⊗ₜ[R] b i
File: Mathlib/LinearAlgebra/TensorProduct/Prod.lean

full_name: TensorProduct.prodRight
code: /-- Tensor products distribute over a product on the right. -/
def prodRight : M₁ ⊗[R] (M₂ × M₃) ≃ₗ[R] ((M₁ ⊗[R] M₂) × (M₁ ⊗[R] M₃)) 
goal: TensorProduct R M₁ (M₂ × M₃) ≃ₗ[R] TensorProduct R M₁ M₂ × TensorProduct R M₁ M₃

full_name: TensorProduct.prodRight_tmul
code: @[simp] theorem prodRight_tmul (m₁ : M₁) (m₂ : M₂) (m₃ : M₃) :
    prodRight R M₁ M₂ M₃ (m₁ ⊗ₜ (m₂, m₃)) = (m₁ ⊗ₜ m₂, m₁ ⊗ₜ m₃) 
goal: (TensorProduct.prodRight R M₁ M₂ M₃) (m₁ ⊗ₜ[R] (m₂, m₃)) = (m₁ ⊗ₜ[R] m₂, m₁ ⊗ₜ[R] m₃)

full_name: TensorProduct.prodRight_symm_tmul
code: @[simp] theorem prodRight_symm_tmul (m₁ : M₁) (m₂ : M₂) (m₃ : M₃) :
    (prodRight R M₁ M₂ M₃).symm (m₁ ⊗ₜ m₂, m₁ ⊗ₜ m₃) = (m₁ ⊗ₜ (m₂, m₃)) 
goal: (TensorProduct.prodRight R M₁ M₂ M₃).symm (m₁ ⊗ₜ[R] m₂, m₁ ⊗ₜ[R] m₃) = m₁ ⊗ₜ[R] (m₂, m₃)

full_name: TensorProduct.prodLeft
code: /-- Tensor products distribute over a product on the left . -/
def prodLeft : (M₁ × M₂) ⊗[R] M₃ ≃ₗ[R] ((M₁ ⊗[R] M₃) × (M₂ ⊗[R] M₃)) 
goal: TensorProduct R (M₁ × M₂) M₃ ≃ₗ[R] TensorProduct R M₁ M₃ × TensorProduct R M₂ M₃

full_name: TensorProduct.prodLeft_tmul
code: @[simp] theorem prodLeft_tmul (m₁ : M₁) (m₂ : M₂) (m₃ : M₃) :
    prodLeft R M₁ M₂ M₃ ((m₁, m₂) ⊗ₜ m₃) = (m₁ ⊗ₜ m₃, m₂ ⊗ₜ m₃) 
goal: (TensorProduct.prodLeft R M₁ M₂ M₃) ((m₁, m₂) ⊗ₜ[R] m₃) = (m₁ ⊗ₜ[R] m₃, m₂ ⊗ₜ[R] m₃)

full_name: TensorProduct.prodLeft_symm_tmul
code: @[simp] theorem prodLeft_symm_tmul (m₁ : M₁) (m₂ : M₂) (m₃ : M₃) :
    (prodLeft R M₁ M₂ M₃).symm (m₁ ⊗ₜ m₃, m₂ ⊗ₜ m₃) = ((m₁, m₂) ⊗ₜ m₃) 
goal: (TensorProduct.prodLeft R M₁ M₂ M₃).symm (m₁ ⊗ₜ[R] m₃, m₂ ⊗ₜ[R] m₃) = (m₁, m₂) ⊗ₜ[R] m₃
File: Mathlib/LinearAlgebra/Matrix/FiniteDimensional.lean

full_name: Matrix.finiteDimensional
code: instance finiteDimensional [Finite m] [Finite n] : FiniteDimensional R (Matrix m n R) 
goal: FiniteDimensional R (Matrix m n R)

full_name: LinearMap.finiteDimensional
code: instance finiteDimensional : FiniteDimensional K (V →ₗ[K] W) 
goal: FiniteDimensional K (V →ₗ[K] W)

full_name: LinearMap.finiteDimensional'
code: /-- Linear maps over a `k`-algebra are finite dimensional (over `k`) if both the source and
target are, as they form a subspace of all `k`-linear maps. -/
instance finiteDimensional' : FiniteDimensional K (V →ₗ[A] W) 
goal: FiniteDimensional K (V →ₗ[A] W)
File: Mathlib/LinearAlgebra/Matrix/InvariantBasisNumber.lean

full_name: Matrix.square_of_invertible
code: theorem Matrix.square_of_invertible (M : Matrix n m R) (N : Matrix m n R) (h : M * N = 1)
    (h' : N * M = 1) : Fintype.card n = Fintype.card m 
goal: Fintype.card n = Fintype.card m
File: Mathlib/LinearAlgebra/Matrix/Gershgorin.lean

full_name: eigenvalue_mem_ball
code: /-- **Gershgorin's circle theorem**: for any eigenvalue `μ` of a square matrix `A`, there exists an
index `k` such that `μ` lies in the closed ball of center the diagonal term `A k k` and of
radius the sum of the norms `∑ j ≠ k, ‖A k j‖. -/
theorem eigenvalue_mem_ball {μ : K} (hμ : Module.End.HasEigenvalue (Matrix.toLin' A) μ) :
    ∃ k, μ ∈ Metric.closedBall (A k k) (∑ j ∈ Finset.univ.erase k, ‖A k j‖) 
goal: ∃ k, μ ∈ Metric.closedBall (A k k) (∑ j ∈ Finset.univ.erase k, ‖A k j‖)

full_name: det_ne_zero_of_sum_row_lt_diag
code: /-- If `A` is a row strictly dominant diagonal matrix, then it's determinant is nonzero. -/
theorem det_ne_zero_of_sum_row_lt_diag (h : ∀ k, ∑ j ∈ Finset.univ.erase k, ‖A k j‖ < ‖A k k‖) :
    A.det ≠ 0 
goal: A.det ≠ 0

full_name: det_ne_zero_of_sum_col_lt_diag
code: /-- If `A` is a column strictly dominant diagonal matrix, then it's determinant is nonzero. -/
theorem det_ne_zero_of_sum_col_lt_diag (h : ∀ k, ∑ i ∈ Finset.univ.erase k, ‖A i k‖ < ‖A k k‖) :
    A.det ≠ 0 
goal: A.det ≠ 0
File: Mathlib/LinearAlgebra/Matrix/Charpoly/Minpoly.lean

full_name: Matrix.minpoly_toLin'
code: @[simp]
theorem minpoly_toLin' : minpoly R (toLin' M) = minpoly R M 
goal: minpoly R (Matrix.toLin' M) = minpoly R M

full_name: Matrix.minpoly_toLin
code: @[simp]
theorem minpoly_toLin (b : Basis n R N) (M : Matrix n n R) :
    minpoly R (toLin b b M) = minpoly R M 
goal: minpoly R ((Matrix.toLin b b) M) = minpoly R M

full_name: Matrix.isIntegral
code: theorem isIntegral : IsIntegral R M 
goal: IsIntegral R M

full_name: Matrix.minpoly_dvd_charpoly
code: theorem minpoly_dvd_charpoly {K : Type*} [Field K] (M : Matrix n n K) : minpoly K M ∣ M.charpoly 
goal: minpoly K M ∣ M.charpoly

full_name: LinearMap.minpoly_toMatrix'
code: @[simp]
theorem minpoly_toMatrix' (f : (n → R) →ₗ[R] n → R) : minpoly R (toMatrix' f) = minpoly R f 
goal: minpoly R (LinearMap.toMatrix' f) = minpoly R f

full_name: LinearMap.minpoly_toMatrix
code: @[simp]
theorem minpoly_toMatrix (b : Basis n R N) (f : N →ₗ[R] N) :
    minpoly R (toMatrix b b f) = minpoly R f 
goal: minpoly R ((LinearMap.toMatrix b b) f) = minpoly R f

full_name: charpoly_leftMulMatrix
code: /-- The characteristic polynomial of the map `fun x => a * x` is the minimal polynomial of `a`.

In combination with `det_eq_sign_charpoly_coeff` or `trace_eq_neg_charpoly_coeff`
and a bit of rewriting, this will allow us to conclude the
field norm resp. trace of `x` is the product resp. sum of `x`'s conjugates.
-/
theorem charpoly_leftMulMatrix {S : Type*} [Ring S] [Algebra R S] (h : PowerBasis R S) :
    (leftMulMatrix h.basis h.gen).charpoly = minpoly R h.gen 
goal: ((Algebra.leftMulMatrix h.basis) h.gen).charpoly = minpoly R h.gen
File: Mathlib/LinearAlgebra/Matrix/Charpoly/Eigs.lean

full_name: Matrix.det_eq_prod_roots_charpoly_of_splits
code: theorem det_eq_prod_roots_charpoly_of_splits (hAps : A.charpoly.Splits (RingHom.id R)) :
    A.det = (Matrix.charpoly A).roots.prod 
goal: A.det = A.charpoly.roots.prod

full_name: Matrix.trace_eq_sum_roots_charpoly_of_splits
code: theorem trace_eq_sum_roots_charpoly_of_splits (hAps : A.charpoly.Splits (RingHom.id R)) :
    A.trace = (Matrix.charpoly A).roots.sum 
goal: A.trace = A.charpoly.roots.sum

full_name: Matrix.det_eq_prod_roots_charpoly
code: theorem det_eq_prod_roots_charpoly [IsAlgClosed R] : A.det = (Matrix.charpoly A).roots.prod 
goal: A.det = A.charpoly.roots.prod

full_name: Matrix.trace_eq_sum_roots_charpoly
code: theorem trace_eq_sum_roots_charpoly [IsAlgClosed R] : A.trace = (Matrix.charpoly A).roots.sum 
goal: A.trace = A.charpoly.roots.sum
File: Mathlib/LinearAlgebra/Matrix/Charpoly/Univ.lean

full_name: Matrix.charpoly.univ
code: /-- The universal characteristic polynomial for `n × n`-matrices,
is the charactistic polynomial of `Matrix.mvPolynomialX n n ℤ` with entries `Xᵢⱼ`.

Its `i`-th coefficient is a homogeneous polynomial of degree `n - i`,
see `Matrix.charpoly.univ_coeff_isHomogeneous`.

By evaluating the coefficients at the entries of a matrix `M`,
one obtains the characteristic polynomial of `M`,
see `Matrix.charpoly.univ_map_eval₂Hom`. -/
noncomputable
abbrev univ : Polynomial (MvPolynomial (n × n) R) 
goal: Polynomial (MvPolynomial (n × n) R)

full_name: Matrix.charpoly.univ_map_eval₂Hom
code: @[simp]
lemma univ_map_eval₂Hom (M : n × n → S) :
    (univ R n).map (eval₂Hom f M) = charpoly (Matrix.of M.curry) 
goal: Polynomial.map (MvPolynomial.eval₂Hom f M) (Matrix.charpoly.univ R n) = (Matrix.of (Function.curry M)).charpoly

full_name: Matrix.charpoly.univ_map_map
code: lemma univ_map_map :
    (univ R n).map (MvPolynomial.map f) = univ S n 
goal: Polynomial.map (MvPolynomial.map f) (Matrix.charpoly.univ R n) = Matrix.charpoly.univ S n

full_name: Matrix.charpoly.univ_coeff_eval₂Hom
code: @[simp]
lemma univ_coeff_eval₂Hom (M : n × n → S) (i : ℕ) :
    MvPolynomial.eval₂Hom f M ((univ R n).coeff i) =
      (charpoly (Matrix.of M.curry)).coeff i 
goal: (MvPolynomial.eval₂Hom f M) ((Matrix.charpoly.univ R n).coeff i) = (Matrix.of (Function.curry M)).charpoly.coeff i

full_name: Matrix.charpoly.univ_monic
code: lemma univ_monic : (univ R n).Monic 
goal: (Matrix.charpoly.univ R n).Monic

full_name: Matrix.charpoly.univ_natDegree
code: lemma univ_natDegree [Nontrivial R] : (univ R n).natDegree = Fintype.card n 
goal: (Matrix.charpoly.univ R n).natDegree = Fintype.card n

full_name: Matrix.charpoly.univ_coeff_card
code: @[simp]
lemma univ_coeff_card : (univ R n).coeff (Fintype.card n) = 1 
goal: (Matrix.charpoly.univ R n).coeff (Fintype.card n) = 1

full_name: Matrix.charpoly.optionEquivLeft_symm_univ_isHomogeneous
code: lemma optionEquivLeft_symm_univ_isHomogeneous :
    ((optionEquivLeft R (n × n)).symm (univ R n)).IsHomogeneous (Fintype.card n) 
goal: ((MvPolynomial.optionEquivLeft R (n × n)).symm (Matrix.charpoly.univ R n)).IsHomogeneous (Fintype.card n)

full_name: Matrix.charpoly.univ_coeff_isHomogeneous
code: lemma univ_coeff_isHomogeneous (i j : ℕ) (h : i + j = Fintype.card n) :
    ((univ R n).coeff i).IsHomogeneous j 
goal: ((Matrix.charpoly.univ R n).coeff i).IsHomogeneous j
File: Mathlib/LinearAlgebra/Matrix/Charpoly/FiniteField.lean

full_name: FiniteField.Matrix.charpoly_pow_card
code: @[simp]
theorem FiniteField.Matrix.charpoly_pow_card {K : Type*} [Field K] [Fintype K] (M : Matrix n n K) :
    (M ^ Fintype.card K).charpoly = M.charpoly 
goal: (M ^ Fintype.card K).charpoly = M.charpoly

full_name: ZMod.charpoly_pow_card
code: @[simp]
theorem ZMod.charpoly_pow_card {p : ℕ} [Fact p.Prime] (M : Matrix n n (ZMod p)) :
    (M ^ p).charpoly = M.charpoly 
goal: (M ^ p).charpoly = M.charpoly

full_name: FiniteField.trace_pow_card
code: theorem FiniteField.trace_pow_card {K : Type*} [Field K] [Fintype K] (M : Matrix n n K) :
    trace (M ^ Fintype.card K) = trace M ^ Fintype.card K 
goal: (M ^ Fintype.card K).trace = M.trace ^ Fintype.card K

full_name: ZMod.trace_pow_card
code: theorem ZMod.trace_pow_card {p : ℕ} [Fact p.Prime] (M : Matrix n n (ZMod p)) :
    trace (M ^ p) = trace M ^ p 
goal: (M ^ p).trace = M.trace ^ p
File: Mathlib/LinearAlgebra/Matrix/Nondegenerate.lean

full_name: Matrix.Nondegenerate
code: /-- A matrix `M` is nondegenerate if for all `v ≠ 0`, there is a `w ≠ 0` with `w * M * v ≠ 0`. -/
def Nondegenerate (M : Matrix m m R) 
goal: Prop

full_name: Matrix.Nondegenerate.eq_zero_of_ortho
code: /-- If `M` is nondegenerate and `w * M * v = 0` for all `w`, then `v = 0`. -/
theorem Nondegenerate.eq_zero_of_ortho {M : Matrix m m R} (hM : Nondegenerate M) {v : m → R}
    (hv : ∀ w, Matrix.dotProduct v (M *ᵥ w) = 0) : v = 0 
goal: v = 0

full_name: Matrix.Nondegenerate.exists_not_ortho_of_ne_zero
code: /-- If `M` is nondegenerate and `v ≠ 0`, then there is some `w` such that `w * M * v ≠ 0`. -/
theorem Nondegenerate.exists_not_ortho_of_ne_zero {M : Matrix m m R} (hM : Nondegenerate M)
    {v : m → R} (hv : v ≠ 0) : ∃ w, Matrix.dotProduct v (M *ᵥ w) ≠ 0 
goal: ∃ w, Matrix.dotProduct v (M.mulVec w) ≠ 0

full_name: Matrix.nondegenerate_of_det_ne_zero
code: /-- If `M` has a nonzero determinant, then `M` as a bilinear form on `n → A` is nondegenerate.

See also `BilinForm.nondegenerateOfDetNeZero'` and `BilinForm.nondegenerateOfDetNeZero`.
-/
theorem nondegenerate_of_det_ne_zero [DecidableEq m] {M : Matrix m m A} (hM : M.det ≠ 0) :
    Nondegenerate M 
goal: M.Nondegenerate

full_name: Matrix.eq_zero_of_vecMul_eq_zero
code: theorem eq_zero_of_vecMul_eq_zero [DecidableEq m] {M : Matrix m m A} (hM : M.det ≠ 0) {v : m → A}
    (hv : v ᵥ* M = 0) : v = 0 
goal: v = 0

full_name: Matrix.eq_zero_of_mulVec_eq_zero
code: theorem eq_zero_of_mulVec_eq_zero [DecidableEq m] {M : Matrix m m A} (hM : M.det ≠ 0) {v : m → A}
    (hv : M *ᵥ v = 0) : v = 0 
goal: v = 0
File: Mathlib/LinearAlgebra/Matrix/GeneralLinearGroup/Basic.lean

full_name: Matrix.val_planeConformalMatrix
code: /-- The matrix [a, -b; b, a] (inspired by multiplication by a complex number); it is an element of
$GL_2(R)$ if `a ^ 2 + b ^ 2` is nonzero. -/
@[simps! (config := .asFn) val]
def planeConformalMatrix {R} [Field R] (a b : R) (hab : a ^ 2 + b ^ 2 ≠ 0) :
    Matrix.GeneralLinearGroup (Fin 2) R 
goal: ↑(Matrix.planeConformalMatrix a b hab) = !![a, -b; b, a]

full_name: Matrix.planeConformalMatrix
code: /-- The matrix [a, -b; b, a] (inspired by multiplication by a complex number); it is an element of
$GL_2(R)$ if `a ^ 2 + b ^ 2` is nonzero. -/
@[simps! (config := .asFn) val]
def planeConformalMatrix {R} [Field R] (a b : R) (hab : a ^ 2 + b ^ 2 ≠ 0) :
    Matrix.GeneralLinearGroup (Fin 2) R 
goal: GL (Fin 2) R