File: Mathlib/Algebra/Star/Unitary.lean

full_name: unitary
code: /-- In a *-monoid, `unitary R` is the submonoid consisting of all the elements `U` of
`R` such that `star U * U = 1` and `U * star U = 1`.
-/
def unitary (R : Type*) [Monoid R] [StarMul R] : Submonoid R 
goal: Submonoid R

full_name: unitary.mem_iff
code: theorem mem_iff {U : R} : U ∈ unitary R ↔ star U * U = 1 ∧ U * star U = 1 
goal: U ∈ unitary R ↔ star U * U = 1 ∧ U * star U = 1

full_name: unitary.star_mul_self_of_mem
code: @[simp]
theorem star_mul_self_of_mem {U : R} (hU : U ∈ unitary R) : star U * U = 1 
goal: star U * U = 1

full_name: unitary.mul_star_self_of_mem
code: @[simp]
theorem mul_star_self_of_mem {U : R} (hU : U ∈ unitary R) : U * star U = 1 
goal: U * star U = 1

full_name: unitary.star_mem
code: theorem star_mem {U : R} (hU : U ∈ unitary R) : star U ∈ unitary R 
goal: star U ∈ unitary R

full_name: unitary.star_mem_iff
code: @[simp]
theorem star_mem_iff {U : R} : star U ∈ unitary R ↔ U ∈ unitary R 
goal: star U ∈ unitary R ↔ U ∈ unitary R

full_name: unitary.instStarSubtypeMemSubmonoid
code: instance : Star (unitary R) 
goal: Star ↥(unitary R)

full_name: unitary.coe_star
code: @[simp, norm_cast]
theorem coe_star {U : unitary R} : ↑(star U) = (star U : R) 
goal: ↑(star U) = star ↑U

full_name: unitary.coe_star_mul_self
code: theorem coe_star_mul_self (U : unitary R) : (star U : R) * U = 1 
goal: star ↑U * ↑U = 1

full_name: unitary.coe_mul_star_self
code: theorem coe_mul_star_self (U : unitary R) : (U : R) * star U = 1 
goal: ↑U * ↑(star U) = 1

full_name: unitary.star_mul_self
code: @[simp]
theorem star_mul_self (U : unitary R) : star U * U = 1 
goal: star U * U = 1

full_name: unitary.mul_star_self
code: @[simp]
theorem mul_star_self (U : unitary R) : U * star U = 1 
goal: U * star U = 1

full_name: unitary.instGroupSubtypeMemSubmonoid
code: instance : Group (unitary R) 
goal: Group ↥(unitary R)

full_name: unitary.instInvolutiveStarSubtypeMemSubmonoid
code: instance : InvolutiveStar (unitary R) 
goal: InvolutiveStar ↥(unitary R)

full_name: unitary.instStarMulSubtypeMemSubmonoid
code: instance : StarMul (unitary R) 
goal: StarMul ↥(unitary R)

full_name: unitary.instInhabitedSubtypeMemSubmonoid
code: instance : Inhabited (unitary R) 
goal: Inhabited ↥(unitary R)

full_name: unitary.star_eq_inv
code: theorem star_eq_inv (U : unitary R) : star U = U⁻¹ 
goal: star U = U⁻¹

full_name: unitary.star_eq_inv'
code: theorem star_eq_inv' : (star : unitary R → unitary R) = Inv.inv 
goal: star = Inv.inv

full_name: unitary.toUnits
code: /-- The unitary elements embed into the units. -/
@[simps]
def toUnits : unitary R →* Rˣ 
goal: ↥(unitary R) →* Rˣ

full_name: unitary.val_toUnits_apply
code: /-- The unitary elements embed into the units. -/
@[simps]
def toUnits : unitary R →* Rˣ 
goal: ↑(unitary.toUnits x) = ↑x

full_name: unitary.val_inv_toUnits_apply
code: /-- The unitary elements embed into the units. -/
@[simps]
def toUnits : unitary R →* Rˣ 
goal: ↑(unitary.toUnits x)⁻¹ = ↑x⁻¹

full_name: unitary.toUnits_injective
code: theorem toUnits_injective : Function.Injective (toUnits : unitary R → Rˣ) 
goal: Function.Injective ⇑unitary.toUnits

full_name: IsUnit.mem_unitary_of_star_mul_self
code: theorem _root_.IsUnit.mem_unitary_of_star_mul_self  {u : R} (hu : IsUnit u)
    (h_mul : star u * u = 1) : u ∈ unitary R 
goal: u ∈ unitary R

full_name: IsUnit.mem_unitary_of_mul_star_self
code: theorem _root_.IsUnit.mem_unitary_of_mul_star_self {u : R} (hu : IsUnit u)
    (h_mul : u * star u = 1) : u ∈ unitary R 
goal: u ∈ unitary R

full_name: unitary.instIsStarNormal
code: instance instIsStarNormal (u : unitary R) : IsStarNormal u 
goal: IsStarNormal u

full_name: unitary.coe_isStarNormal
code: instance coe_isStarNormal (u : unitary R) : IsStarNormal (u : R) 
goal: IsStarNormal ↑u

full_name: isStarNormal_of_mem_unitary
code: lemma _root_.isStarNormal_of_mem_unitary {u : R} (hu : u ∈ unitary R) : IsStarNormal u 
goal: IsStarNormal u

full_name: unitary.map_mem
code: lemma map_mem {r : R} (hr : r ∈ unitary R) : f r ∈ unitary S 
goal: f r ∈ unitary S

full_name: unitary.map
code: /-- The group homomorphism between unitary subgroups of star monoids induced by a star
homomorphism -/
@[simps]
def map : unitary R →* unitary S 
goal: ↥(unitary R) →* ↥(unitary S)

full_name: unitary.map_apply
code: /-- The group homomorphism between unitary subgroups of star monoids induced by a star
homomorphism -/
@[simps]
def map : unitary R →* unitary S 
goal: ∀ (a : ↥(unitary R)), (unitary.map f) a = Subtype.map ⇑f ⋯ a

full_name: unitary.toUnits_comp_map
code: lemma toUnits_comp_map : toUnits.comp (map f) = (Units.map f).comp toUnits 
goal: unitary.toUnits.comp (unitary.map f) = (Units.map ↑f).comp unitary.toUnits

full_name: unitary.instCommGroupSubtypeMemSubmonoid
code: instance : CommGroup (unitary R) 
goal: CommGroup ↥(unitary R)

full_name: unitary.mem_iff_star_mul_self
code: theorem mem_iff_star_mul_self {U : R} : U ∈ unitary R ↔ star U * U = 1 
goal: U ∈ unitary R ↔ star U * U = 1

full_name: unitary.mem_iff_self_mul_star
code: theorem mem_iff_self_mul_star {U : R} : U ∈ unitary R ↔ U * star U = 1 
goal: U ∈ unitary R ↔ U * star U = 1

full_name: unitary.coe_inv
code: @[norm_cast]
theorem coe_inv (U : unitary R) : ↑U⁻¹ = (U⁻¹ : R) 
goal: ↑U⁻¹ = (↑U)⁻¹

full_name: unitary.coe_div
code: @[norm_cast]
theorem coe_div (U₁ U₂ : unitary R) : ↑(U₁ / U₂) = (U₁ / U₂ : R) 
goal: ↑(U₁ / U₂) = ↑U₁ / ↑U₂

full_name: unitary.coe_zpow
code: @[norm_cast]
theorem coe_zpow (U : unitary R) (z : ℤ) : ↑(U ^ z) = (U : R) ^ z 
goal: ↑(U ^ z) = ↑U ^ z

full_name: unitary.instNegSubtypeMemSubmonoid
code: instance : Neg (unitary R) 
goal: Neg ↥(unitary R)

full_name: unitary.coe_neg
code: @[norm_cast]
theorem coe_neg (U : unitary R) : ↑(-U) = (-U : R) 
goal: ↑(-U) = -↑U

full_name: unitary.instHasDistribNegSubtypeMemSubmonoid
code: instance : HasDistribNeg (unitary R) 
goal: HasDistribNeg ↥(unitary R)

full_name: unitary.spectrum.unitary_conjugate
code: /-- Unitary conjugation preserves the spectrum, star on left. -/
@[simp]
lemma spectrum.unitary_conjugate {a : A} {u : unitary A} :
    spectrum R (u * a * (star u : A)) = spectrum R a 
goal: spectrum R (↑u * a * star ↑u) = spectrum R a

full_name: unitary.spectrum.unitary_conjugate'
code: /-- Unitary conjugation preserves the spectrum, star on right. -/
@[simp]
lemma spectrum.unitary_conjugate' {a : A} {u : unitary A} :
    spectrum R ((star u : A) * a * u) = spectrum R a 
goal: spectrum R (star ↑u * a * ↑u) = spectrum R a