File: Mathlib/LinearAlgebra/UnitaryGroup.lean

full_name: Matrix.unitaryGroup
code: /-- `Matrix.unitaryGroup n` is the group of `n` by `n` matrices where the star-transpose is the
inverse.
-/
abbrev unitaryGroup 
goal: Submonoid (Matrix n n α)

full_name: Matrix.mem_unitaryGroup_iff
code: theorem mem_unitaryGroup_iff : A ∈ Matrix.unitaryGroup n α ↔ A * star A = 1 
goal: A ∈ Matrix.unitaryGroup n α ↔ A * star A = 1

full_name: Matrix.mem_unitaryGroup_iff'
code: theorem mem_unitaryGroup_iff' : A ∈ Matrix.unitaryGroup n α ↔ star A * A = 1 
goal: A ∈ Matrix.unitaryGroup n α ↔ star A * A = 1

full_name: Matrix.det_of_mem_unitary
code: theorem det_of_mem_unitary {A : Matrix n n α} (hA : A ∈ Matrix.unitaryGroup n α) :
    A.det ∈ unitary α 
goal: A.det ∈ unitary α

full_name: Matrix.UnitaryGroup.coeMatrix
code: instance coeMatrix : Coe (unitaryGroup n α) (Matrix n n α) 
goal: Coe (↥(Matrix.unitaryGroup n α)) (Matrix n n α)

full_name: Matrix.UnitaryGroup.coeFun
code: instance coeFun : CoeFun (unitaryGroup n α) fun _ => n → n → α 
goal: CoeFun ↥(Matrix.unitaryGroup n α) fun x => n → n → α

full_name: Matrix.UnitaryGroup.toLin'
code: /-- `Matrix.UnitaryGroup.toLin' A` is matrix multiplication of vectors by `A`, as a linear map.

After the group structure on `Matrix.unitaryGroup n` is defined, we show in
`Matrix.UnitaryGroup.toLinearEquiv` that this gives a linear equivalence.
-/
def toLin' (A : unitaryGroup n α) 
goal: (n → α) →ₗ[α] n → α

full_name: Matrix.UnitaryGroup.ext_iff
code: theorem ext_iff (A B : unitaryGroup n α) : A = B ↔ ∀ i j, A i j = B i j 
goal: A = B ↔ ∀ (i j : n), ↑A i j = ↑B i j

full_name: Matrix.UnitaryGroup.ext
code: @[ext]
theorem ext (A B : unitaryGroup n α) : (∀ i j, A i j = B i j) → A = B 
goal: (∀ (i j : n), ↑A i j = ↑B i j) → A = B

full_name: Matrix.UnitaryGroup.star_mul_self
code: theorem star_mul_self (A : unitaryGroup n α) : star A.1 * A.1 = 1 
goal: star ↑A * ↑A = 1

full_name: Matrix.UnitaryGroup.det_isUnit
code: @[simp]
theorem det_isUnit (A : unitaryGroup n α) : IsUnit (A : Matrix n n α).det 
goal: IsUnit (↑A).det

full_name: Matrix.UnitaryGroup.inv_val
code: @[simp] theorem inv_val : ↑A⁻¹ = (star A : Matrix n n α) 
goal: ↑A⁻¹ = star ↑A

full_name: Matrix.UnitaryGroup.inv_apply
code: @[simp] theorem inv_apply : ⇑A⁻¹ = (star A : Matrix n n α) 
goal: ↑A⁻¹ = star ↑A

full_name: Matrix.UnitaryGroup.mul_val
code: @[simp] theorem mul_val : ↑(A * B) = A.1 * B.1 
goal: ↑(A * B) = ↑A * ↑B

full_name: Matrix.UnitaryGroup.mul_apply
code: @[simp] theorem mul_apply : ⇑(A * B) = A.1 * B.1 
goal: ↑(A * B) = ↑A * ↑B

full_name: Matrix.UnitaryGroup.one_val
code: @[simp] theorem one_val : ↑(1 : unitaryGroup n α) = (1 : Matrix n n α) 
goal: ↑1 = 1

full_name: Matrix.UnitaryGroup.one_apply
code: @[simp] theorem one_apply : ⇑(1 : unitaryGroup n α) = (1 : Matrix n n α) 
goal: ↑1 = 1

full_name: Matrix.UnitaryGroup.toLin'_mul
code: @[simp]
theorem toLin'_mul : toLin' (A * B) = (toLin' A).comp (toLin' B) 
goal: Matrix.UnitaryGroup.toLin' (A * B) = Matrix.UnitaryGroup.toLin' A ∘ₗ Matrix.UnitaryGroup.toLin' B

full_name: Matrix.UnitaryGroup.toLin'_one
code: @[simp]
theorem toLin'_one : toLin' (1 : unitaryGroup n α) = LinearMap.id 
goal: Matrix.UnitaryGroup.toLin' 1 = LinearMap.id

full_name: Matrix.UnitaryGroup.toLinearEquiv
code: /-- `Matrix.unitaryGroup.toLinearEquiv A` is matrix multiplication of vectors by `A`, as a linear
equivalence. -/
def toLinearEquiv (A : unitaryGroup n α) : (n → α) ≃ₗ[α] n → α 
goal: (n → α) ≃ₗ[α] n → α

full_name: Matrix.UnitaryGroup.toGL
code: /-- `Matrix.unitaryGroup.toGL` is the map from the unitary group to the general linear group -/
def toGL (A : unitaryGroup n α) : GeneralLinearGroup α (n → α) 
goal: LinearMap.GeneralLinearGroup α (n → α)

full_name: Matrix.UnitaryGroup.coe_toGL
code: theorem coe_toGL (A : unitaryGroup n α) : (toGL A).1 = toLin' A 
goal: ↑(Matrix.UnitaryGroup.toGL A) = Matrix.UnitaryGroup.toLin' A

full_name: Matrix.UnitaryGroup.toGL_one
code: @[simp]
theorem toGL_one : toGL (1 : unitaryGroup n α) = 1 
goal: Matrix.UnitaryGroup.toGL 1 = 1

full_name: Matrix.UnitaryGroup.toGL_mul
code: @[simp]
theorem toGL_mul (A B : unitaryGroup n α) : toGL (A * B) = toGL A * toGL B 
goal: Matrix.UnitaryGroup.toGL (A * B) = Matrix.UnitaryGroup.toGL A * Matrix.UnitaryGroup.toGL B

full_name: Matrix.UnitaryGroup.embeddingGL
code: /-- `Matrix.unitaryGroup.embeddingGL` is the embedding from `Matrix.unitaryGroup n α` to
`LinearMap.GeneralLinearGroup n α`. -/
def embeddingGL : unitaryGroup n α →* GeneralLinearGroup α (n → α) 
goal: ↥(Matrix.unitaryGroup n α) →* LinearMap.GeneralLinearGroup α (n → α)

full_name: Matrix.specialUnitaryGroup
code: /-- `Matrix.specialUnitaryGroup` is the group of unitary `n` by `n` matrices where the determinant
is 1. (This definition is only correct if 2 is invertible.)-/
abbrev specialUnitaryGroup 
goal: Submonoid (Matrix n n α)

full_name: Matrix.mem_specialUnitaryGroup_iff
code: theorem mem_specialUnitaryGroup_iff :
    A ∈ specialUnitaryGroup n α ↔ A ∈ unitaryGroup n α ∧ A.det = 1 
goal: A ∈ Matrix.specialUnitaryGroup n α ↔ A ∈ Matrix.unitaryGroup n α ∧ A.det = 1

full_name: Matrix.orthogonalGroup
code: /-- `Matrix.orthogonalGroup n` is the group of `n` by `n` matrices where the transpose is the
inverse. -/
abbrev orthogonalGroup 
goal: Submonoid (Matrix n n β)

full_name: Matrix.mem_orthogonalGroup_iff
code: theorem mem_orthogonalGroup_iff {A : Matrix n n β} :
    A ∈ Matrix.orthogonalGroup n β ↔ A * star A = 1 
goal: A ∈ Matrix.orthogonalGroup n β ↔ A * star A = 1

full_name: Matrix.mem_orthogonalGroup_iff'
code: theorem mem_orthogonalGroup_iff' {A : Matrix n n β} :
    A ∈ Matrix.orthogonalGroup n β ↔ star A * A = 1 
goal: A ∈ Matrix.orthogonalGroup n β ↔ star A * A = 1

full_name: Matrix.specialOrthogonalGroup
code: /-- `Matrix.specialOrthogonalGroup n` is the group of orthogonal `n` by `n` where the determinant
is one. (This definition is only correct if 2 is invertible.)-/
abbrev specialOrthogonalGroup 
goal: Submonoid (Matrix n n β)

full_name: Matrix.mem_specialOrthogonalGroup_iff
code: theorem mem_specialOrthogonalGroup_iff :
    A ∈ specialOrthogonalGroup n β ↔ A ∈ orthogonalGroup n β ∧ A.det = 1 
goal: A ∈ Matrix.specialOrthogonalGroup n β ↔ A ∈ Matrix.orthogonalGroup n β ∧ A.det = 1