File: Mathlib/RingTheory/MatrixAlgebra.lean

full_name: MatrixEquivTensor.toFunBilinear
code: /-- (Implementation detail).
The function underlying `(A ⊗[R] Matrix n n R) →ₐ[R] Matrix n n A`,
as an `R`-bilinear map.
-/
def toFunBilinear : A →ₗ[R] Matrix n n R →ₗ[R] Matrix n n A 
goal: A →ₗ[R] Matrix n n R →ₗ[R] Matrix n n A

full_name: MatrixEquivTensor.toFunBilinear_apply
code: @[simp]
theorem toFunBilinear_apply (a : A) (m : Matrix n n R) :
    toFunBilinear R A n a m = a • m.map (algebraMap R A) 
goal: ((MatrixEquivTensor.toFunBilinear R A n) a) m = a • m.map ⇑(algebraMap R A)

full_name: MatrixEquivTensor.toFunLinear
code: /-- (Implementation detail).
The function underlying `(A ⊗[R] Matrix n n R) →ₐ[R] Matrix n n A`,
as an `R`-linear map.
-/
def toFunLinear : A ⊗[R] Matrix n n R →ₗ[R] Matrix n n A 
goal: A ⊗[R] Matrix n n R →ₗ[R] Matrix n n A

full_name: MatrixEquivTensor.toFunAlgHom
code: /-- The function `(A ⊗[R] Matrix n n R) →ₐ[R] Matrix n n A`, as an algebra homomorphism.
-/
def toFunAlgHom : A ⊗[R] Matrix n n R →ₐ[R] Matrix n n A 
goal: A ⊗[R] Matrix n n R →ₐ[R] Matrix n n A

full_name: MatrixEquivTensor.toFunAlgHom_apply
code: @[simp]
theorem toFunAlgHom_apply (a : A) (m : Matrix n n R) :
    toFunAlgHom R A n (a ⊗ₜ m) = a • m.map (algebraMap R A) 
goal: (MatrixEquivTensor.toFunAlgHom R A n) (a ⊗ₜ[R] m) = a • m.map ⇑(algebraMap R A)

full_name: MatrixEquivTensor.invFun
code: /-- (Implementation detail.)

The bare function `Matrix n n A → A ⊗[R] Matrix n n R`.
(We don't need to show that it's an algebra map, thankfully --- just that it's an inverse.)
-/
def invFun (M : Matrix n n A) : A ⊗[R] Matrix n n R 
goal: A ⊗[R] Matrix n n R

full_name: MatrixEquivTensor.invFun_zero
code: @[simp]
theorem invFun_zero : invFun R A n 0 = 0 
goal: MatrixEquivTensor.invFun R A n 0 = 0

full_name: MatrixEquivTensor.invFun_add
code: @[simp]
theorem invFun_add (M N : Matrix n n A) :
    invFun R A n (M + N) = invFun R A n M + invFun R A n N 
goal: MatrixEquivTensor.invFun R A n (M + N) = MatrixEquivTensor.invFun R A n M + MatrixEquivTensor.invFun R A n N

full_name: MatrixEquivTensor.invFun_smul
code: @[simp]
theorem invFun_smul (a : A) (M : Matrix n n A) :
    invFun R A n (a • M) = a ⊗ₜ 1 * invFun R A n M 
goal: MatrixEquivTensor.invFun R A n (a • M) = a ⊗ₜ[R] 1 * MatrixEquivTensor.invFun R A n M

full_name: MatrixEquivTensor.invFun_algebraMap
code: @[simp]
theorem invFun_algebraMap (M : Matrix n n R) : invFun R A n (M.map (algebraMap R A)) = 1 ⊗ₜ M 
goal: MatrixEquivTensor.invFun R A n (M.map ⇑(algebraMap R A)) = 1 ⊗ₜ[R] M

full_name: MatrixEquivTensor.right_inv
code: theorem right_inv (M : Matrix n n A) : (toFunAlgHom R A n) (invFun R A n M) = M 
goal: (MatrixEquivTensor.toFunAlgHom R A n) (MatrixEquivTensor.invFun R A n M) = M

full_name: MatrixEquivTensor.left_inv
code: theorem left_inv (M : A ⊗[R] Matrix n n R) : invFun R A n (toFunAlgHom R A n M) = M 
goal: MatrixEquivTensor.invFun R A n ((MatrixEquivTensor.toFunAlgHom R A n) M) = M

full_name: MatrixEquivTensor.equiv
code: /-- (Implementation detail)

The equivalence, ignoring the algebra structure, `(A ⊗[R] Matrix n n R) ≃ Matrix n n A`.
-/
def equiv : A ⊗[R] Matrix n n R ≃ Matrix n n A 
goal: A ⊗[R] Matrix n n R ≃ Matrix n n A

full_name: matrixEquivTensor
code: /-- The `R`-algebra isomorphism `Matrix n n A ≃ₐ[R] (A ⊗[R] Matrix n n R)`.
-/
def matrixEquivTensor : Matrix n n A ≃ₐ[R] A ⊗[R] Matrix n n R 
goal: Matrix n n A ≃ₐ[R] A ⊗[R] Matrix n n R

full_name: matrixEquivTensor_apply
code: @[simp]
theorem matrixEquivTensor_apply (M : Matrix n n A) :
    matrixEquivTensor R A n M = ∑ p : n × n, M p.1 p.2 ⊗ₜ stdBasisMatrix p.1 p.2 1 
goal: (matrixEquivTensor R A n) M = ∑ p : n × n, M p.1 p.2 ⊗ₜ[R] Matrix.stdBasisMatrix p.1 p.2 1

full_name: matrixEquivTensor_apply_std_basis
code: @[simp (high)]
theorem matrixEquivTensor_apply_std_basis (i j : n) (x : A) :
    matrixEquivTensor R A n (stdBasisMatrix i j x) = x ⊗ₜ stdBasisMatrix i j 1 
goal: (matrixEquivTensor R A n) (Matrix.stdBasisMatrix i j x) = x ⊗ₜ[R] Matrix.stdBasisMatrix i j 1

full_name: matrixEquivTensor_apply_symm
code: @[simp]
theorem matrixEquivTensor_apply_symm (a : A) (M : Matrix n n R) :
    (matrixEquivTensor R A n).symm (a ⊗ₜ M) = M.map fun x => a * algebraMap R A x 
goal: (matrixEquivTensor R A n).symm (a ⊗ₜ[R] M) = M.map fun x => a * (algebraMap R A) x