File: Mathlib/Algebra/Star/StarAlgHom.lean

full_name: NonUnitalStarAlgHom
code: /-- A *non-unital ⋆-algebra homomorphism* is a non-unital algebra homomorphism between
non-unital `R`-algebras `A` and `B` equipped with a `star` operation, and this homomorphism is
also `star`-preserving. -/
structure NonUnitalStarAlgHom (R A B : Type*) [Monoid R] [NonUnitalNonAssocSemiring A]
  [DistribMulAction R A] [Star A] [NonUnitalNonAssocSemiring B] [DistribMulAction R B]
  [Star B] extends A →ₙₐ[R] B where
  /-- By definition, a non-unital ⋆-algebra homomorphism preserves the `star` operation. -/
  map_star' : ∀ a : A, toFun (star a) = star (toFun a)
goal: Type (max u_2 u_3)

full_name: NonUnitalStarAlgHom.map_star'
code: /-- A *non-unital ⋆-algebra homomorphism* is a non-unital algebra homomorphism between
non-unital `R`-algebras `A` and `B` equipped with a `star` operation, and this homomorphism is
also `star`-preserving. -/
structure NonUnitalStarAlgHom (R A B : Type*) [Monoid R] [NonUnitalNonAssocSemiring A]
  [DistribMulAction R A] [Star A] [NonUnitalNonAssocSemiring B] [DistribMulAction R B]
  [Star B] extends A →ₙₐ[R] B where
  /-- By definition, a non-unital ⋆-algebra homomorphism preserves the `star` operation. -/
  map_star' : ∀ a : A, toFun (star a) = star (toFun a)
goal: self.toFun (star a) = star (self.toFun a)

full_name: «_aux_Mathlib_Algebra_Star_StarAlgHom___macroRules_term_→⋆ₙₐ__1»
code: @[inherit_doc NonUnitalStarAlgHom] infixr:25 " →⋆ₙₐ " => NonUnitalStarAlgHom _
goal: Lean.Macro

full_name: _aux_Mathlib_Algebra_Star_StarAlgHom___unexpand_NonUnitalStarAlgHom_1
code: @[inherit_doc] notation:25 A " →⋆ₙₐ[" R "] " B => NonUnitalStarAlgHom R A B
goal: Lean.PrettyPrinter.Unexpander

full_name: «_aux_Mathlib_Algebra_Star_StarAlgHom___macroRules_term_→⋆ₙₐ[_]__1»
code: @[inherit_doc] notation:25 A " →⋆ₙₐ[" R "] " B => NonUnitalStarAlgHom R A B
goal: Lean.Macro

full_name: NonUnitalStarAlgHomClass
code: /-- `NonUnitalStarAlgHomClass F R A B` asserts `F` is a type of bundled non-unital ⋆-algebra
homomorphisms from `A` to `B`. -/
class NonUnitalStarAlgHomClass (F : Type*) (R A B : outParam Type*)
  [Monoid R] [Star A] [Star B] [NonUnitalNonAssocSemiring A] [NonUnitalNonAssocSemiring B]
  [DistribMulAction R A] [DistribMulAction R B] [FunLike F A B] [NonUnitalAlgHomClass F R A B]
  extends StarHomClass F A B : Prop
goal: Prop

full_name: NonUnitalStarAlgHomClass.toNonUnitalStarAlgHom
code: /-- Turn an element of a type `F` satisfying `NonUnitalStarAlgHomClass F R A B` into an actual
`NonUnitalStarAlgHom`. This is declared as the default coercion from `F` to `A →⋆ₙₐ[R] B`. -/
@[coe]
def toNonUnitalStarAlgHom [NonUnitalStarAlgHomClass F R A B] (f : F) : A →⋆ₙₐ[R] B 
goal: A →⋆ₙₐ[R] B

full_name: NonUnitalStarAlgHomClass.instCoeTCNonUnitalStarAlgHom
code: instance [NonUnitalStarAlgHomClass F R A B] : CoeTC F (A →⋆ₙₐ[R] B) 
goal: CoeTC F (A →⋆ₙₐ[R] B)

full_name: NonUnitalStarAlgHomClass.instNonUnitalStarRingHomClass
code: instance [NonUnitalStarAlgHomClass F R A B] : NonUnitalStarRingHomClass F A B 
goal: NonUnitalStarRingHomClass F A B

full_name: NonUnitalStarAlgHom.instFunLike
code: instance : FunLike (A →⋆ₙₐ[R] B) A B 
goal: FunLike (A →⋆ₙₐ[R] B) A B

full_name: NonUnitalStarAlgHom.instNonUnitalAlgHomClass
code: instance : NonUnitalAlgHomClass (A →⋆ₙₐ[R] B) R A B 
goal: NonUnitalAlgHomClass (A →⋆ₙₐ[R] B) R A B

full_name: NonUnitalStarAlgHom.instNonUnitalStarAlgHomClass
code: instance : NonUnitalStarAlgHomClass (A →⋆ₙₐ[R] B) R A B 
goal: NonUnitalStarAlgHomClass (A →⋆ₙₐ[R] B) R A B

full_name: NonUnitalStarAlgHom.Simps.apply
code: /-- See Note [custom simps projection] -/
def Simps.apply (f : A →⋆ₙₐ[R] B) : A → B 
goal: A → B

full_name: NonUnitalStarAlgHom.coe_coe
code: @[simp]
protected theorem coe_coe {F : Type*} [FunLike F A B] [NonUnitalAlgHomClass F R A B]
    [NonUnitalStarAlgHomClass F R A B] (f : F) :
    ⇑(f : A →⋆ₙₐ[R] B) = f 
goal: ⇑↑f = ⇑f

full_name: NonUnitalStarAlgHom.coe_toNonUnitalAlgHom
code: @[simp]
theorem coe_toNonUnitalAlgHom {f : A →⋆ₙₐ[R] B} : (f.toNonUnitalAlgHom : A → B) = f 
goal: ⇑f.toNonUnitalAlgHom = ⇑f

full_name: NonUnitalStarAlgHom.ext
code: @[ext]
theorem ext {f g : A →⋆ₙₐ[R] B} (h : ∀ x, f x = g x) : f = g 
goal: f = g

full_name: NonUnitalStarAlgHom.copy
code: /-- Copy of a `NonUnitalStarAlgHom` with a new `toFun` equal to the old one. Useful
to fix definitional equalities. -/
protected def copy (f : A →⋆ₙₐ[R] B) (f' : A → B) (h : f' = f) : A →⋆ₙₐ[R] B 
goal: A →⋆ₙₐ[R] B

full_name: NonUnitalStarAlgHom.coe_copy
code: @[simp]
theorem coe_copy (f : A →⋆ₙₐ[R] B) (f' : A → B) (h : f' = f) : ⇑(f.copy f' h) = f' 
goal: ⇑(f.copy f' h) = f'

full_name: NonUnitalStarAlgHom.copy_eq
code: theorem copy_eq (f : A →⋆ₙₐ[R] B) (f' : A → B) (h : f' = f) : f.copy f' h = f 
goal: f.copy f' h = f

full_name: NonUnitalStarAlgHom.coe_mk
code: @[simp]
theorem coe_mk (f : A → B) (h₁ h₂ h₃ h₄ h₅) :
    ((⟨⟨⟨⟨f, h₁⟩, h₂, h₃⟩, h₄⟩, h₅⟩ : A →⋆ₙₐ[R] B) : A → B) = f 
goal: ⇑{ toFun := f, map_smul' := h₁, map_zero' := h₂, map_add' := h₃, map_mul' := h₄, map_star' := h₅ } = f

full_name: NonUnitalStarAlgHom.coe_mk'
code: @[simp]
theorem coe_mk' (f : A →ₙₐ[R] B) (h) :
    ((⟨f, h⟩ : A →⋆ₙₐ[R] B) : A → B) = f 
goal: ⇑{ toNonUnitalAlgHom := f, map_star' := h } = ⇑f

full_name: NonUnitalStarAlgHom.mk_coe
code: @[simp]
theorem mk_coe (f : A →⋆ₙₐ[R] B) (h₁ h₂ h₃ h₄ h₅) :
    (⟨⟨⟨⟨f, h₁⟩, h₂, h₃⟩, h₄⟩, h₅⟩ : A →⋆ₙₐ[R] B) = f 
goal: { toFun := ⇑f, map_smul' := h₁, map_zero' := h₂, map_add' := h₃, map_mul' := h₄, map_star' := h₅ } = f

full_name: NonUnitalStarAlgHom.id
code: /-- The identity as a non-unital ⋆-algebra homomorphism. -/
protected def id : A →⋆ₙₐ[R] A 
goal: A →⋆ₙₐ[R] A

full_name: NonUnitalStarAlgHom.coe_id
code: @[simp]
theorem coe_id : ⇑(NonUnitalStarAlgHom.id R A) = id 
goal: ⇑(NonUnitalStarAlgHom.id R A) = id

full_name: NonUnitalStarAlgHom.comp
code: /-- The composition of non-unital ⋆-algebra homomorphisms, as a non-unital ⋆-algebra
homomorphism. -/
def comp (f : B →⋆ₙₐ[R] C) (g : A →⋆ₙₐ[R] B) : A →⋆ₙₐ[R] C 
goal: A →⋆ₙₐ[R] C

full_name: NonUnitalStarAlgHom.coe_comp
code: @[simp]
theorem coe_comp (f : B →⋆ₙₐ[R] C) (g : A →⋆ₙₐ[R] B) : ⇑(comp f g) = f ∘ g 
goal: ⇑(f.comp g) = ⇑f ∘ ⇑g

full_name: NonUnitalStarAlgHom.comp_apply
code: @[simp]
theorem comp_apply (f : B →⋆ₙₐ[R] C) (g : A →⋆ₙₐ[R] B) (a : A) : comp f g a = f (g a) 
goal: (f.comp g) a = f (g a)

full_name: NonUnitalStarAlgHom.comp_assoc
code: @[simp]
theorem comp_assoc (f : C →⋆ₙₐ[R] D) (g : B →⋆ₙₐ[R] C) (h : A →⋆ₙₐ[R] B) :
    (f.comp g).comp h = f.comp (g.comp h) 
goal: (f.comp g).comp h = f.comp (g.comp h)

full_name: NonUnitalStarAlgHom.id_comp
code: @[simp]
theorem id_comp (f : A →⋆ₙₐ[R] B) : (NonUnitalStarAlgHom.id _ _).comp f = f 
goal: (NonUnitalStarAlgHom.id R B).comp f = f

full_name: NonUnitalStarAlgHom.comp_id
code: @[simp]
theorem comp_id (f : A →⋆ₙₐ[R] B) : f.comp (NonUnitalStarAlgHom.id _ _) = f 
goal: f.comp (NonUnitalStarAlgHom.id R A) = f

full_name: NonUnitalStarAlgHom.instMonoid
code: instance : Monoid (A →⋆ₙₐ[R] A) 
goal: Monoid (A →⋆ₙₐ[R] A)

full_name: NonUnitalStarAlgHom.coe_one
code: @[simp]
theorem coe_one : ((1 : A →⋆ₙₐ[R] A) : A → A) = id 
goal: ⇑1 = id

full_name: NonUnitalStarAlgHom.one_apply
code: theorem one_apply (a : A) : (1 : A →⋆ₙₐ[R] A) a = a 
goal: 1 a = a

full_name: NonUnitalStarAlgHom.instZero
code: instance : Zero (A →⋆ₙₐ[R] B) 
goal: Zero (A →⋆ₙₐ[R] B)

full_name: NonUnitalStarAlgHom.instInhabited
code: instance : Inhabited (A →⋆ₙₐ[R] B) 
goal: Inhabited (A →⋆ₙₐ[R] B)

full_name: NonUnitalStarAlgHom.instMonoidWithZero
code: instance : MonoidWithZero (A →⋆ₙₐ[R] A) 
goal: MonoidWithZero (A →⋆ₙₐ[R] A)

full_name: NonUnitalStarAlgHom.coe_zero
code: @[simp]
theorem coe_zero : ((0 : A →⋆ₙₐ[R] B) : A → B) = 0 
goal: ⇑0 = 0

full_name: NonUnitalStarAlgHom.zero_apply
code: theorem zero_apply (a : A) : (0 : A →⋆ₙₐ[R] B) a = 0 
goal: 0 a = 0

full_name: NonUnitalStarAlgHom.restrictScalars
code: /-- If a monoid `R` acts on another monoid `S`, then a non-unital star algebra homomorphism
over `S` can be viewed as a non-unital star algebra homomorphism over `R`.  -/
def restrictScalars (f : A →⋆ₙₐ[S] B) : A →⋆ₙₐ[R] B 
goal: A →⋆ₙₐ[R] B

full_name: NonUnitalStarAlgHom.restrictScalars_apply
code: @[simp]
lemma restrictScalars_apply (f : A →⋆ₙₐ[S] B) (x : A) : f.restrictScalars R x = f x 
goal: (NonUnitalStarAlgHom.restrictScalars R f) x = f x

full_name: NonUnitalStarAlgHom.coe_restrictScalars
code: lemma coe_restrictScalars (f : A →⋆ₙₐ[S] B) : (f.restrictScalars R : A →ₙ+* B) = f 
goal: ↑(NonUnitalStarAlgHom.restrictScalars R f) = ↑f

full_name: NonUnitalStarAlgHom.coe_restrictScalars'
code: lemma coe_restrictScalars' (f : A →⋆ₙₐ[S] B) : (f.restrictScalars R : A → B) = f 
goal: ⇑(NonUnitalStarAlgHom.restrictScalars R f) = ⇑f

full_name: NonUnitalStarAlgHom.restrictScalars_injective
code: theorem restrictScalars_injective :
    Function.Injective (restrictScalars R : (A →⋆ₙₐ[S] B) → A →⋆ₙₐ[R] B) 
goal: Function.Injective (NonUnitalStarAlgHom.restrictScalars R)

full_name: StarAlgHom
code: /-- A *⋆-algebra homomorphism* is an algebra homomorphism between `R`-algebras `A` and `B`
equipped with a `star` operation, and this homomorphism is also `star`-preserving. -/
structure StarAlgHom (R A B : Type*) [CommSemiring R] [Semiring A] [Algebra R A] [Star A]
  [Semiring B] [Algebra R B] [Star B] extends AlgHom R A B where
  /-- By definition, a ⋆-algebra homomorphism preserves the `star` operation. -/
  map_star' : ∀ x : A, toFun (star x) = star (toFun x)
goal: Type (max u_2 u_3)

full_name: StarAlgHom.map_star'
code: /-- A *⋆-algebra homomorphism* is an algebra homomorphism between `R`-algebras `A` and `B`
equipped with a `star` operation, and this homomorphism is also `star`-preserving. -/
structure StarAlgHom (R A B : Type*) [CommSemiring R] [Semiring A] [Algebra R A] [Star A]
  [Semiring B] [Algebra R B] [Star B] extends AlgHom R A B where
  /-- By definition, a ⋆-algebra homomorphism preserves the `star` operation. -/
  map_star' : ∀ x : A, toFun (star x) = star (toFun x)
goal: (↑↑self.toRingHom).toFun (star x) = star ((↑↑self.toRingHom).toFun x)

full_name: «_aux_Mathlib_Algebra_Star_StarAlgHom___macroRules_term_→⋆ₐ__1»
code: @[inherit_doc StarAlgHom] infixr:25 " →⋆ₐ " => StarAlgHom _
goal: Lean.Macro

full_name: «_aux_Mathlib_Algebra_Star_StarAlgHom___macroRules_term_→⋆ₐ[_]__1»
code: @[inherit_doc] notation:25 A " →⋆ₐ[" R "] " B => StarAlgHom R A B
goal: Lean.Macro

full_name: _aux_Mathlib_Algebra_Star_StarAlgHom___unexpand_StarAlgHom_1
code: @[inherit_doc] notation:25 A " →⋆ₐ[" R "] " B => StarAlgHom R A B
goal: Lean.PrettyPrinter.Unexpander

full_name: StarAlgHomClass
code: /-- `StarAlgHomClass F R A B` states that `F` is a type of ⋆-algebra homomorphisms.

You should also extend this typeclass when you extend `StarAlgHom`. -/
class StarAlgHomClass (F : Type*) (R A B : outParam Type*)
    [CommSemiring R] [Semiring A] [Algebra R A] [Star A] [Semiring B] [Algebra R B] [Star B]
    [FunLike F A B] [AlgHomClass F R A B] extends StarHomClass F A B : Prop
goal: Prop

full_name: StarAlgHomClass.toNonUnitalStarAlgHomClass
code: instance (priority := 100) toNonUnitalStarAlgHomClass [CommSemiring R] [Semiring A] [Algebra R A]
  [Star A] [Semiring B] [Algebra R B] [Star B] [FunLike F A B] [AlgHomClass F R A B]
  [StarAlgHomClass F R A B] :
  NonUnitalStarAlgHomClass F R A B 
goal: NonUnitalStarAlgHomClass F R A B

full_name: StarAlgHomClass.toStarAlgHom
code: /-- Turn an element of a type `F` satisfying `StarAlgHomClass F R A B` into an actual
`StarAlgHom`. This is declared as the default coercion from `F` to `A →⋆ₐ[R] B`. -/
@[coe]
def toStarAlgHom (f : F) : A →⋆ₐ[R] B 
goal: A →⋆ₐ[R] B

full_name: StarAlgHomClass.instCoeTCStarAlgHom
code: instance : CoeTC F (A →⋆ₐ[R] B) 
goal: CoeTC F (A →⋆ₐ[R] B)

full_name: StarAlgHom.instFunLike
code: instance : FunLike (A →⋆ₐ[R] B) A B 
goal: FunLike (A →⋆ₐ[R] B) A B

full_name: StarAlgHom.instAlgHomClass
code: instance : AlgHomClass (A →⋆ₐ[R] B) R A B 
goal: AlgHomClass (A →⋆ₐ[R] B) R A B

full_name: StarAlgHom.instStarAlgHomClass
code: instance : StarAlgHomClass (A →⋆ₐ[R] B) R A B 
goal: StarAlgHomClass (A →⋆ₐ[R] B) R A B

full_name: StarAlgHom.coe_coe
code: @[simp]
protected theorem coe_coe {F : Type*} [FunLike F A B] [AlgHomClass F R A B]
    [StarAlgHomClass F R A B] (f : F) :
    ⇑(f : A →⋆ₐ[R] B) = f 
goal: ⇑↑f = ⇑f

full_name: StarAlgHom.Simps.apply
code: /-- See Note [custom simps projection] -/
def Simps.apply (f : A →⋆ₐ[R] B) : A → B 
goal: A → B

full_name: StarAlgHom.coe_toAlgHom
code: @[simp]
theorem coe_toAlgHom {f : A →⋆ₐ[R] B} : (f.toAlgHom : A → B) = f 
goal: ⇑f.toAlgHom = ⇑f

full_name: StarAlgHom.ext
code: @[ext]
theorem ext {f g : A →⋆ₐ[R] B} (h : ∀ x, f x = g x) : f = g 
goal: f = g

full_name: StarAlgHom.copy
code: /-- Copy of a `StarAlgHom` with a new `toFun` equal to the old one. Useful
to fix definitional equalities. -/
protected def copy (f : A →⋆ₐ[R] B) (f' : A → B) (h : f' = f) : A →⋆ₐ[R] B 
goal: A →⋆ₐ[R] B

full_name: StarAlgHom.coe_copy
code: @[simp]
theorem coe_copy (f : A →⋆ₐ[R] B) (f' : A → B) (h : f' = f) : ⇑(f.copy f' h) = f' 
goal: ⇑(f.copy f' h) = f'

full_name: StarAlgHom.copy_eq
code: theorem copy_eq (f : A →⋆ₐ[R] B) (f' : A → B) (h : f' = f) : f.copy f' h = f 
goal: f.copy f' h = f

full_name: StarAlgHom.coe_mk
code: @[simp]
theorem coe_mk (f : A → B) (h₁ h₂ h₃ h₄ h₅ h₆) :
    ((⟨⟨⟨⟨⟨f, h₁⟩, h₂⟩, h₃, h₄⟩, h₅⟩, h₆⟩ : A →⋆ₐ[R] B) : A → B) = f 
goal: ⇑{ toFun := f, map_one' := h₁, map_mul' := h₂, map_zero' := h₃, map_add' := h₄, commutes' := h₅, map_star' := h₆ } = f

full_name: StarAlgHom.coe_mk'
code: @[simp]
theorem coe_mk' (f : A →ₐ[R] B) (h) :
    ((⟨f, h⟩ : A →⋆ₐ[R] B) : A → B) = f 
goal: ⇑{ toAlgHom := f, map_star' := h } = ⇑f

full_name: StarAlgHom.mk_coe
code: @[simp]
theorem mk_coe (f : A →⋆ₐ[R] B) (h₁ h₂ h₃ h₄ h₅ h₆) :
    (⟨⟨⟨⟨⟨f, h₁⟩, h₂⟩, h₃, h₄⟩, h₅⟩, h₆⟩ : A →⋆ₐ[R] B) = f 
goal: { toFun := ⇑f, map_one' := h₁, map_mul' := h₂, map_zero' := h₃, map_add' := h₄, commutes' := h₅, map_star' := h₆ } = f

full_name: StarAlgHom.id
code: /-- The identity as a `StarAlgHom`. -/
protected def id : A →⋆ₐ[R] A 
goal: A →⋆ₐ[R] A

full_name: StarAlgHom.coe_id
code: @[simp]
theorem coe_id : ⇑(StarAlgHom.id R A) = id 
goal: ⇑(StarAlgHom.id R A) = id

full_name: StarAlgHom.ofId
code: /-- `algebraMap R A` as a `StarAlgHom` when `A` is a star algebra over `R`. -/
@[simps]
def ofId (R A : Type*) [CommSemiring R] [StarRing R] [Semiring A] [StarMul A]
    [Algebra R A] [StarModule R A] : R →⋆ₐ[R] A 
goal: R →⋆ₐ[R] A

full_name: StarAlgHom.ofId_apply
code: /-- `algebraMap R A` as a `StarAlgHom` when `A` is a star algebra over `R`. -/
@[simps]
def ofId (R A : Type*) [CommSemiring R] [StarRing R] [Semiring A] [StarMul A]
    [Algebra R A] [StarModule R A] : R →⋆ₐ[R] A 
goal: (StarAlgHom.ofId R A) a = (algebraMap R A) a

full_name: StarAlgHom.instInhabited
code: instance : Inhabited (A →⋆ₐ[R] A) 
goal: Inhabited (A →⋆ₐ[R] A)

full_name: StarAlgHom.comp
code: /-- The composition of ⋆-algebra homomorphisms, as a ⋆-algebra homomorphism. -/
def comp (f : B →⋆ₐ[R] C) (g : A →⋆ₐ[R] B) : A →⋆ₐ[R] C 
goal: A →⋆ₐ[R] C

full_name: StarAlgHom.coe_comp
code: @[simp]
theorem coe_comp (f : B →⋆ₐ[R] C) (g : A →⋆ₐ[R] B) : ⇑(comp f g) = f ∘ g 
goal: ⇑(f.comp g) = ⇑f ∘ ⇑g

full_name: StarAlgHom.comp_apply
code: @[simp]
theorem comp_apply (f : B →⋆ₐ[R] C) (g : A →⋆ₐ[R] B) (a : A) : comp f g a = f (g a) 
goal: (f.comp g) a = f (g a)

full_name: StarAlgHom.comp_assoc
code: @[simp]
theorem comp_assoc (f : C →⋆ₐ[R] D) (g : B →⋆ₐ[R] C) (h : A →⋆ₐ[R] B) :
    (f.comp g).comp h = f.comp (g.comp h) 
goal: (f.comp g).comp h = f.comp (g.comp h)

full_name: StarAlgHom.id_comp
code: @[simp]
theorem id_comp (f : A →⋆ₐ[R] B) : (StarAlgHom.id _ _).comp f = f 
goal: (StarAlgHom.id R B).comp f = f

full_name: StarAlgHom.comp_id
code: @[simp]
theorem comp_id (f : A →⋆ₐ[R] B) : f.comp (StarAlgHom.id _ _) = f 
goal: f.comp (StarAlgHom.id R A) = f

full_name: StarAlgHom.instMonoid
code: instance : Monoid (A →⋆ₐ[R] A) 
goal: Monoid (A →⋆ₐ[R] A)

full_name: StarAlgHom.toNonUnitalStarAlgHom
code: /-- A unital morphism of ⋆-algebras is a `NonUnitalStarAlgHom`. -/
def toNonUnitalStarAlgHom (f : A →⋆ₐ[R] B) : A →⋆ₙₐ[R] B 
goal: A →⋆ₙₐ[R] B

full_name: StarAlgHom.coe_toNonUnitalStarAlgHom
code: @[simp]
theorem coe_toNonUnitalStarAlgHom (f : A →⋆ₐ[R] B) : (f.toNonUnitalStarAlgHom : A → B) = f 
goal: ⇑f.toNonUnitalStarAlgHom = ⇑f

full_name: NonUnitalStarAlgHom.fst_apply
code: /-- The first projection of a product is a non-unital ⋆-algebra homomorphism. -/
@[simps!]
def fst : A × B →⋆ₙₐ[R] A 
goal: (NonUnitalStarAlgHom.fst R A B) self = self.1

full_name: NonUnitalStarAlgHom.fst
code: /-- The first projection of a product is a non-unital ⋆-algebra homomorphism. -/
@[simps!]
def fst : A × B →⋆ₙₐ[R] A 
goal: A × B →⋆ₙₐ[R] A

full_name: NonUnitalStarAlgHom.snd_apply
code: /-- The second projection of a product is a non-unital ⋆-algebra homomorphism. -/
@[simps!]
def snd : A × B →⋆ₙₐ[R] B 
goal: (NonUnitalStarAlgHom.snd R A B) self = self.2

full_name: NonUnitalStarAlgHom.snd
code: /-- The second projection of a product is a non-unital ⋆-algebra homomorphism. -/
@[simps!]
def snd : A × B →⋆ₙₐ[R] B 
goal: A × B →⋆ₙₐ[R] B

full_name: NonUnitalStarAlgHom.prod_apply
code: /-- The `Pi.prod` of two morphisms is a morphism. -/
@[simps!]
def prod (f : A →⋆ₙₐ[R] B) (g : A →⋆ₙₐ[R] C) : A →⋆ₙₐ[R] B × C 
goal: (f.prod g) i = (f i, g i)

full_name: NonUnitalStarAlgHom.prod
code: /-- The `Pi.prod` of two morphisms is a morphism. -/
@[simps!]
def prod (f : A →⋆ₙₐ[R] B) (g : A →⋆ₙₐ[R] C) : A →⋆ₙₐ[R] B × C 
goal: A →⋆ₙₐ[R] B × C

full_name: NonUnitalStarAlgHom.coe_prod
code: theorem coe_prod (f : A →⋆ₙₐ[R] B) (g : A →⋆ₙₐ[R] C) : ⇑(f.prod g) = Pi.prod f g 
goal: ⇑(f.prod g) = Pi.prod ⇑f ⇑g

full_name: NonUnitalStarAlgHom.fst_prod
code: @[simp]
theorem fst_prod (f : A →⋆ₙₐ[R] B) (g : A →⋆ₙₐ[R] C) : (fst R B C).comp (prod f g) = f 
goal: (NonUnitalStarAlgHom.fst R B C).comp (f.prod g) = f

full_name: NonUnitalStarAlgHom.snd_prod
code: @[simp]
theorem snd_prod (f : A →⋆ₙₐ[R] B) (g : A →⋆ₙₐ[R] C) : (snd R B C).comp (prod f g) = g 
goal: (NonUnitalStarAlgHom.snd R B C).comp (f.prod g) = g

full_name: NonUnitalStarAlgHom.prod_fst_snd
code: @[simp]
theorem prod_fst_snd : prod (fst R A B) (snd R A B) = 1 
goal: (NonUnitalStarAlgHom.fst R A B).prod (NonUnitalStarAlgHom.snd R A B) = 1

full_name: NonUnitalStarAlgHom.prodEquiv_apply
code: /-- Taking the product of two maps with the same domain is equivalent to taking the product of
their codomains. -/
@[simps]
def prodEquiv : (A →⋆ₙₐ[R] B) × (A →⋆ₙₐ[R] C) ≃ (A →⋆ₙₐ[R] B × C) 
goal: NonUnitalStarAlgHom.prodEquiv f = f.1.prod f.2

full_name: NonUnitalStarAlgHom.prodEquiv_symm_apply
code: /-- Taking the product of two maps with the same domain is equivalent to taking the product of
their codomains. -/
@[simps]
def prodEquiv : (A →⋆ₙₐ[R] B) × (A →⋆ₙₐ[R] C) ≃ (A →⋆ₙₐ[R] B × C) 
goal: NonUnitalStarAlgHom.prodEquiv.symm f = ((NonUnitalStarAlgHom.fst R B C).comp f, (NonUnitalStarAlgHom.snd R B C).comp f)

full_name: NonUnitalStarAlgHom.prodEquiv
code: /-- Taking the product of two maps with the same domain is equivalent to taking the product of
their codomains. -/
@[simps]
def prodEquiv : (A →⋆ₙₐ[R] B) × (A →⋆ₙₐ[R] C) ≃ (A →⋆ₙₐ[R] B × C) 
goal: (A →⋆ₙₐ[R] B) × (A →⋆ₙₐ[R] C) ≃ (A →⋆ₙₐ[R] B × C)

full_name: NonUnitalStarAlgHom.inl
code: /-- The left injection into a product is a non-unital algebra homomorphism. -/
def inl : A →⋆ₙₐ[R] A × B 
goal: A →⋆ₙₐ[R] A × B

full_name: NonUnitalStarAlgHom.inr
code: /-- The right injection into a product is a non-unital algebra homomorphism. -/
def inr : B →⋆ₙₐ[R] A × B 
goal: B →⋆ₙₐ[R] A × B

full_name: NonUnitalStarAlgHom.coe_inl
code: @[simp]
theorem coe_inl : (inl R A B : A → A × B) = fun x => (x, 0) 
goal: ⇑(NonUnitalStarAlgHom.inl R A B) = fun x => (x, 0)

full_name: NonUnitalStarAlgHom.inl_apply
code: theorem inl_apply (x : A) : inl R A B x = (x, 0) 
goal: (NonUnitalStarAlgHom.inl R A B) x = (x, 0)

full_name: NonUnitalStarAlgHom.coe_inr
code: @[simp]
theorem coe_inr : (inr R A B : B → A × B) = Prod.mk 0 
goal: ⇑(NonUnitalStarAlgHom.inr R A B) = Prod.mk 0

full_name: NonUnitalStarAlgHom.inr_apply
code: theorem inr_apply (x : B) : inr R A B x = (0, x) 
goal: (NonUnitalStarAlgHom.inr R A B) x = (0, x)

full_name: StarAlgHom.fst_apply
code: /-- The first projection of a product is a ⋆-algebra homomorphism. -/
@[simps!]
def fst : A × B →⋆ₐ[R] A 
goal: (StarAlgHom.fst R A B) self = self.1

full_name: StarAlgHom.fst
code: /-- The first projection of a product is a ⋆-algebra homomorphism. -/
@[simps!]
def fst : A × B →⋆ₐ[R] A 
goal: A × B →⋆ₐ[R] A

full_name: StarAlgHom.snd_apply
code: /-- The second projection of a product is a ⋆-algebra homomorphism. -/
@[simps!]
def snd : A × B →⋆ₐ[R] B 
goal: (StarAlgHom.snd R A B) self = self.2

full_name: StarAlgHom.snd
code: /-- The second projection of a product is a ⋆-algebra homomorphism. -/
@[simps!]
def snd : A × B →⋆ₐ[R] B 
goal: A × B →⋆ₐ[R] B

full_name: StarAlgHom.prod
code: /-- The `Pi.prod` of two morphisms is a morphism. -/
@[simps!]
def prod (f : A →⋆ₐ[R] B) (g : A →⋆ₐ[R] C) : A →⋆ₐ[R] B × C 
goal: A →⋆ₐ[R] B × C

full_name: StarAlgHom.prod_apply
code: /-- The `Pi.prod` of two morphisms is a morphism. -/
@[simps!]
def prod (f : A →⋆ₐ[R] B) (g : A →⋆ₐ[R] C) : A →⋆ₐ[R] B × C 
goal: (f.prod g) x = (f x, g x)

full_name: StarAlgHom.coe_prod
code: theorem coe_prod (f : A →⋆ₐ[R] B) (g : A →⋆ₐ[R] C) : ⇑(f.prod g) = Pi.prod f g 
goal: ⇑(f.prod g) = Pi.prod ⇑f ⇑g

full_name: StarAlgHom.fst_prod
code: @[simp]
theorem fst_prod (f : A →⋆ₐ[R] B) (g : A →⋆ₐ[R] C) : (fst R B C).comp (prod f g) = f 
goal: (StarAlgHom.fst R B C).comp (f.prod g) = f

full_name: StarAlgHom.snd_prod
code: @[simp]
theorem snd_prod (f : A →⋆ₐ[R] B) (g : A →⋆ₐ[R] C) : (snd R B C).comp (prod f g) = g 
goal: (StarAlgHom.snd R B C).comp (f.prod g) = g

full_name: StarAlgHom.prod_fst_snd
code: @[simp]
theorem prod_fst_snd : prod (fst R A B) (snd R A B) = 1 
goal: (StarAlgHom.fst R A B).prod (StarAlgHom.snd R A B) = 1

full_name: StarAlgHom.prodEquiv_apply
code: /-- Taking the product of two maps with the same domain is equivalent to taking the product of
their codomains. -/
@[simps]
def prodEquiv : (A →⋆ₐ[R] B) × (A →⋆ₐ[R] C) ≃ (A →⋆ₐ[R] B × C) 
goal: StarAlgHom.prodEquiv f = f.1.prod f.2

full_name: StarAlgHom.prodEquiv_symm_apply
code: /-- Taking the product of two maps with the same domain is equivalent to taking the product of
their codomains. -/
@[simps]
def prodEquiv : (A →⋆ₐ[R] B) × (A →⋆ₐ[R] C) ≃ (A →⋆ₐ[R] B × C) 
goal: StarAlgHom.prodEquiv.symm f = ((StarAlgHom.fst R B C).comp f, (StarAlgHom.snd R B C).comp f)

full_name: StarAlgHom.prodEquiv
code: /-- Taking the product of two maps with the same domain is equivalent to taking the product of
their codomains. -/
@[simps]
def prodEquiv : (A →⋆ₐ[R] B) × (A →⋆ₐ[R] C) ≃ (A →⋆ₐ[R] B × C) 
goal: (A →⋆ₐ[R] B) × (A →⋆ₐ[R] C) ≃ (A →⋆ₐ[R] B × C)

full_name: StarAlgEquiv
code: /-- A *⋆-algebra* equivalence is an equivalence preserving addition, multiplication, scalar
multiplication and the star operation, which allows for considering both unital and non-unital
equivalences with a single structure. Currently, `AlgEquiv` requires unital algebras, which is
why this structure does not extend it. -/
structure StarAlgEquiv (R A B : Type*) [Add A] [Add B] [Mul A] [Mul B] [SMul R A] [SMul R B]
  [Star A] [Star B] extends A ≃+* B where
  /-- By definition, a ⋆-algebra equivalence preserves the `star` operation. -/
  map_star' : ∀ a : A, toFun (star a) = star (toFun a)
  /-- By definition, a ⋆-algebra equivalence commutes with the action of scalars. -/
  map_smul' : ∀ (r : R) (a : A), toFun (r • a) = r • toFun a
goal: Type (max u_2 u_3)

full_name: StarAlgEquiv.map_smul'
code: /-- A *⋆-algebra* equivalence is an equivalence preserving addition, multiplication, scalar
multiplication and the star operation, which allows for considering both unital and non-unital
equivalences with a single structure. Currently, `AlgEquiv` requires unital algebras, which is
why this structure does not extend it. -/
structure StarAlgEquiv (R A B : Type*) [Add A] [Add B] [Mul A] [Mul B] [SMul R A] [SMul R B]
  [Star A] [Star B] extends A ≃+* B where
  /-- By definition, a ⋆-algebra equivalence preserves the `star` operation. -/
  map_star' : ∀ a : A, toFun (star a) = star (toFun a)
  /-- By definition, a ⋆-algebra equivalence commutes with the action of scalars. -/
  map_smul' : ∀ (r : R) (a : A), toFun (r • a) = r • toFun a
goal: self.toFun (r • a) = r • self.toFun a

full_name: StarAlgEquiv.map_star'
code: /-- A *⋆-algebra* equivalence is an equivalence preserving addition, multiplication, scalar
multiplication and the star operation, which allows for considering both unital and non-unital
equivalences with a single structure. Currently, `AlgEquiv` requires unital algebras, which is
why this structure does not extend it. -/
structure StarAlgEquiv (R A B : Type*) [Add A] [Add B] [Mul A] [Mul B] [SMul R A] [SMul R B]
  [Star A] [Star B] extends A ≃+* B where
  /-- By definition, a ⋆-algebra equivalence preserves the `star` operation. -/
  map_star' : ∀ a : A, toFun (star a) = star (toFun a)
  /-- By definition, a ⋆-algebra equivalence commutes with the action of scalars. -/
  map_smul' : ∀ (r : R) (a : A), toFun (r • a) = r • toFun a
goal: self.toFun (star a) = star (self.toFun a)

full_name: «_aux_Mathlib_Algebra_Star_StarAlgHom___macroRules_term_≃⋆ₐ__1»
code: @[inherit_doc StarAlgEquiv] infixr:25 " ≃⋆ₐ " => StarAlgEquiv _
goal: Lean.Macro

full_name: _aux_Mathlib_Algebra_Star_StarAlgHom___unexpand_StarAlgEquiv_1
code: @[inherit_doc] notation:25 A " ≃⋆ₐ[" R "] " B => StarAlgEquiv R A B
goal: Lean.PrettyPrinter.Unexpander

full_name: «_aux_Mathlib_Algebra_Star_StarAlgHom___macroRules_term_≃⋆ₐ[_]__1»
code: @[inherit_doc] notation:25 A " ≃⋆ₐ[" R "] " B => StarAlgEquiv R A B
goal: Lean.Macro

full_name: NonUnitalAlgEquivClass
code: /-- The class that directly extends `RingEquivClass` and `SMulHomClass`.

Mostly an implementation detail for `StarAlgEquivClass`.
-/
class NonUnitalAlgEquivClass (F : Type*) (R A B : outParam Type*)
  [Add A] [Mul A] [SMul R A] [Add B] [Mul B] [SMul R B] [EquivLike F A B]
  extends RingEquivClass F A B, MulActionSemiHomClass F (@id R) A B : Prop where
goal: Prop

full_name: StarAlgEquivClass.map_star
code: /-- `StarAlgEquivClass F R A B` asserts `F` is a type of bundled ⋆-algebra equivalences between
`A` and `B`.

You should also extend this typeclass when you extend `StarAlgEquiv`. -/
class StarAlgEquivClass (F : Type*) (R A B : outParam Type*)
  [Add A] [Mul A] [SMul R A] [Star A] [Add B] [Mul B] [SMul R B]
  [Star B] [EquivLike F A B] [NonUnitalAlgEquivClass F R A B] : Prop where
  /-- By definition, a ⋆-algebra equivalence preserves the `star` operation. -/
  map_star : ∀ (f : F) (a : A), f (star a) = star (f a)
goal: f (star a) = star (f a)

full_name: StarAlgEquivClass
code: /-- `StarAlgEquivClass F R A B` asserts `F` is a type of bundled ⋆-algebra equivalences between
`A` and `B`.

You should also extend this typeclass when you extend `StarAlgEquiv`. -/
class StarAlgEquivClass (F : Type*) (R A B : outParam Type*)
  [Add A] [Mul A] [SMul R A] [Star A] [Add B] [Mul B] [SMul R B]
  [Star B] [EquivLike F A B] [NonUnitalAlgEquivClass F R A B] : Prop where
  /-- By definition, a ⋆-algebra equivalence preserves the `star` operation. -/
  map_star : ∀ (f : F) (a : A), f (star a) = star (f a)
goal: Prop

full_name: StarAlgEquivClass.instStarHomClass
code: instance (priority := 50) {F R A B : Type*} [Add A] [Mul A] [SMul R A] [Star A] [Add B] [Mul B]
    [SMul R B] [Star B] [EquivLike F A B] [NonUnitalAlgEquivClass F R A B]
    [hF : StarAlgEquivClass F R A B] :
    StarHomClass F A B 
goal: StarHomClass F A B

full_name: StarAlgEquivClass.instNonUnitalAlgHomClassOfNonUnitalAlgEquivClass
code: instance (priority := 100) {F R A B : Type*} [Monoid R] [NonUnitalNonAssocSemiring A]
    [DistribMulAction R A] [NonUnitalNonAssocSemiring B] [DistribMulAction R B] [EquivLike F A B]
    [NonUnitalAlgEquivClass F R A B] :
    NonUnitalAlgHomClass F R A B 
goal: NonUnitalAlgHomClass F R A B

full_name: StarAlgEquivClass.instNonUnitalStarAlgHomClass
code: instance (priority := 100) {F R A B : Type*} [Monoid R] [NonUnitalNonAssocSemiring A]
    [DistribMulAction R A] [Star A] [NonUnitalNonAssocSemiring B] [DistribMulAction R B] [Star B]
    [EquivLike F A B] [NonUnitalAlgEquivClass F R A B] [StarAlgEquivClass F R A B] :
    NonUnitalStarAlgHomClass F R A B 
goal: NonUnitalStarAlgHomClass F R A B

full_name: StarAlgEquivClass.instAlgHomClass
code: instance (priority := 100) instAlgHomClass (F R A B : Type*) [CommSemiring R] [Semiring A]
    [Algebra R A] [Semiring B] [Algebra R B] [EquivLike F A B] [NonUnitalAlgEquivClass F R A B] :
    AlgEquivClass F R A B 
goal: AlgEquivClass F R A B

full_name: StarAlgEquivClass.instStarAlgHomClass
code: instance (priority := 100) instStarAlgHomClass (F R A B : Type*) [CommSemiring R] [Semiring A]
    [Algebra R A] [Star A] [Semiring B] [Algebra R B] [Star B] [EquivLike F A B]
    [NonUnitalAlgEquivClass F R A B] [StarAlgEquivClass F R A B] :
    StarAlgHomClass F R A B 
goal: StarAlgHomClass F R A B

full_name: StarAlgEquivClass.toStarAlgEquiv
code: /-- Turn an element of a type `F` satisfying `StarAlgEquivClass F R A B` into an actual
`StarAlgEquiv`. This is declared as the default coercion from `F` to `A ≃⋆ₐ[R] B`. -/
@[coe]
def toStarAlgEquiv {F R A B : Type*} [Add A] [Mul A] [SMul R A] [Star A] [Add B] [Mul B] [SMul R B]
    [Star B] [EquivLike F A B] [NonUnitalAlgEquivClass F R A B] [StarAlgEquivClass F R A B]
    (f : F) : A ≃⋆ₐ[R] B 
goal: A ≃⋆ₐ[R] B

full_name: StarAlgEquivClass.instCoeHead
code: /-- Any type satisfying `StarAlgEquivClass` can be cast into `StarAlgEquiv` via
`StarAlgEquivClass.toStarAlgEquiv`. -/
instance instCoeHead {F R A B : Type*} [Add A] [Mul A] [SMul R A] [Star A] [Add B] [Mul B]
    [SMul R B] [Star B] [EquivLike F A B] [NonUnitalAlgEquivClass F R A B]
    [StarAlgEquivClass F R A B] : CoeHead F (A ≃⋆ₐ[R] B) 
goal: CoeHead F (A ≃⋆ₐ[R] B)

full_name: StarAlgEquiv.instEquivLike
code: instance : EquivLike (A ≃⋆ₐ[R] B) A B 
goal: EquivLike (A ≃⋆ₐ[R] B) A B

full_name: StarAlgEquiv.instNonUnitalAlgEquivClass
code: instance : NonUnitalAlgEquivClass (A ≃⋆ₐ[R] B) R A B 
goal: NonUnitalAlgEquivClass (A ≃⋆ₐ[R] B) R A B

full_name: StarAlgEquiv.instStarAlgEquivClass
code: instance : StarAlgEquivClass (A ≃⋆ₐ[R] B) R A B 
goal: StarAlgEquivClass (A ≃⋆ₐ[R] B) R A B

full_name: StarAlgEquiv.instFunLike
code: /-- Helper instance for cases where the inference via `EquivLike` is too hard. -/
instance : FunLike (A ≃⋆ₐ[R] B) A B 
goal: FunLike (A ≃⋆ₐ[R] B) A B

full_name: StarAlgEquiv.toRingEquiv_eq_coe
code: @[simp]
theorem toRingEquiv_eq_coe (e : A ≃⋆ₐ[R] B) : e.toRingEquiv = e 
goal: e.toRingEquiv = ↑e

full_name: StarAlgEquiv.ext
code: @[ext]
theorem ext {f g : A ≃⋆ₐ[R] B} (h : ∀ a, f a = g a) : f = g 
goal: f = g

full_name: StarAlgEquiv.ext_iff
code: theorem ext_iff {f g : A ≃⋆ₐ[R] B} : f = g ↔ ∀ a, f a = g a 
goal: f = g ↔ ∀ (a : A), f a = g a

full_name: StarAlgEquiv.refl
code: /-- The identity map is a star algebra isomorphism. -/
@[refl]
def refl : A ≃⋆ₐ[R] A 
goal: A ≃⋆ₐ[R] A

full_name: StarAlgEquiv.instInhabited
code: instance : Inhabited (A ≃⋆ₐ[R] A) 
goal: Inhabited (A ≃⋆ₐ[R] A)

full_name: StarAlgEquiv.coe_refl
code: @[simp]
theorem coe_refl : ⇑(refl : A ≃⋆ₐ[R] A) = id 
goal: ⇑StarAlgEquiv.refl = id

full_name: StarAlgEquiv.symm
code: /-- The inverse of a star algebra isomorphism is a star algebra isomorphism. -/
@[symm]
nonrec def symm (e : A ≃⋆ₐ[R] B) : B ≃⋆ₐ[R] A 
goal: B ≃⋆ₐ[R] A

full_name: StarAlgEquiv.Simps.apply
code: /-- See Note [custom simps projection] -/
def Simps.apply (e : A ≃⋆ₐ[R] B) : A → B 
goal: A → B

full_name: StarAlgEquiv.Simps.symm_apply
code: /-- See Note [custom simps projection] -/
def Simps.symm_apply (e : A ≃⋆ₐ[R] B) : B → A 
goal: B → A

full_name: StarAlgEquiv.invFun_eq_symm
code: @[simp]
theorem invFun_eq_symm {e : A ≃⋆ₐ[R] B} : EquivLike.inv e = e.symm 
goal: EquivLike.inv e = ⇑e.symm

full_name: StarAlgEquiv.symm_symm
code: @[simp]
theorem symm_symm (e : A ≃⋆ₐ[R] B) : e.symm.symm = e 
goal: e.symm.symm = e

full_name: StarAlgEquiv.symm_bijective
code: theorem symm_bijective : Function.Bijective (symm : (A ≃⋆ₐ[R] B) → B ≃⋆ₐ[R] A) 
goal: Function.Bijective StarAlgEquiv.symm

full_name: StarAlgEquiv.coe_mk
code: @[simp]
theorem coe_mk (e h₁ h₂) : ⇑(⟨e, h₁, h₂⟩ : A ≃⋆ₐ[R] B) = e 
goal: ⇑{ toRingEquiv := e, map_star' := h₁, map_smul' := h₂ } = ⇑e

full_name: StarAlgEquiv.mk_coe
code: @[simp]
theorem mk_coe (e : A ≃⋆ₐ[R] B) (e' h₁ h₂ h₃ h₄ h₅ h₆) :
    (⟨⟨⟨e, e', h₁, h₂⟩, h₃, h₄⟩, h₅, h₆⟩ : A ≃⋆ₐ[R] B) = e 
goal: { toFun := ⇑e, invFun := e', left_inv := h₁, right_inv := h₂, map_mul' := h₃, map_add' := h₄, map_star' := h₅,
    map_smul' := h₆ } =
  e

full_name: StarAlgEquiv.symm_mk.aux
code: /-- Auxilliary definition to avoid looping in `dsimp` with `StarAlgEquiv.symm_mk`. -/
protected def symm_mk.aux (f f') (h₁ h₂ h₃ h₄ h₅ h₆) 
goal: B ≃⋆ₐ[R] A

full_name: StarAlgEquiv.symm_mk
code: @[simp]
theorem symm_mk (f f') (h₁ h₂ h₃ h₄ h₅ h₆) :
    (⟨⟨⟨f, f', h₁, h₂⟩, h₃, h₄⟩, h₅, h₆⟩ : A ≃⋆ₐ[R] B).symm =
      { symm_mk.aux f f' h₁ h₂ h₃ h₄ h₅ h₆ with
        toFun := f'
        invFun := f } 
goal: { toFun := f, invFun := f', left_inv := h₁, right_inv := h₂, map_mul' := h₃, map_add' := h₄, map_star' := h₅,
      map_smul' := h₆ }.symm =
  let __src := StarAlgEquiv.symm_mk.aux f f' h₁ h₂ h₃ h₄ h₅ h₆;
  { toFun := f', invFun := f, left_inv := ⋯, right_inv := ⋯, map_mul' := ⋯, map_add' := ⋯, map_star' := ⋯,
    map_smul' := ⋯ }

full_name: StarAlgEquiv.refl_symm
code: @[simp]
theorem refl_symm : (StarAlgEquiv.refl : A ≃⋆ₐ[R] A).symm = StarAlgEquiv.refl 
goal: StarAlgEquiv.refl.symm = StarAlgEquiv.refl

full_name: StarAlgEquiv.to_ringEquiv_symm
code: theorem to_ringEquiv_symm (f : A ≃⋆ₐ[R] B) : (f : A ≃+* B).symm = f.symm 
goal: (↑f).symm = ↑f.symm

full_name: StarAlgEquiv.symm_to_ringEquiv
code: @[simp]
theorem symm_to_ringEquiv (e : A ≃⋆ₐ[R] B) : (e.symm : B ≃+* A) = (e : A ≃+* B).symm 
goal: ↑e.symm = (↑e).symm

full_name: StarAlgEquiv.trans
code: /-- Transitivity of `StarAlgEquiv`. -/
@[trans]
def trans (e₁ : A ≃⋆ₐ[R] B) (e₂ : B ≃⋆ₐ[R] C) : A ≃⋆ₐ[R] C 
goal: A ≃⋆ₐ[R] C

full_name: StarAlgEquiv.apply_symm_apply
code: @[simp]
theorem apply_symm_apply (e : A ≃⋆ₐ[R] B) : ∀ x, e (e.symm x) = x 
goal: e (e.symm x) = x

full_name: StarAlgEquiv.symm_apply_apply
code: @[simp]
theorem symm_apply_apply (e : A ≃⋆ₐ[R] B) : ∀ x, e.symm (e x) = x 
goal: e.symm (e x) = x

full_name: StarAlgEquiv.symm_trans_apply
code: @[simp]
theorem symm_trans_apply (e₁ : A ≃⋆ₐ[R] B) (e₂ : B ≃⋆ₐ[R] C) (x : C) :
    (e₁.trans e₂).symm x = e₁.symm (e₂.symm x) 
goal: (e₁.trans e₂).symm x = e₁.symm (e₂.symm x)

full_name: StarAlgEquiv.coe_trans
code: @[simp]
theorem coe_trans (e₁ : A ≃⋆ₐ[R] B) (e₂ : B ≃⋆ₐ[R] C) : ⇑(e₁.trans e₂) = e₂ ∘ e₁ 
goal: ⇑(e₁.trans e₂) = ⇑e₂ ∘ ⇑e₁

full_name: StarAlgEquiv.trans_apply
code: @[simp]
theorem trans_apply (e₁ : A ≃⋆ₐ[R] B) (e₂ : B ≃⋆ₐ[R] C) (x : A) : (e₁.trans e₂) x = e₂ (e₁ x) 
goal: (e₁.trans e₂) x = e₂ (e₁ x)

full_name: StarAlgEquiv.leftInverse_symm
code: theorem leftInverse_symm (e : A ≃⋆ₐ[R] B) : Function.LeftInverse e.symm e 
goal: Function.LeftInverse ⇑e.symm ⇑e

full_name: StarAlgEquiv.rightInverse_symm
code: theorem rightInverse_symm (e : A ≃⋆ₐ[R] B) : Function.RightInverse e.symm e 
goal: Function.RightInverse ⇑e.symm ⇑e

full_name: StarAlgEquiv.ofStarAlgHom
code: /-- If a (unital or non-unital) star algebra morphism has an inverse, it is an isomorphism of
star algebras. -/
@[simps]
def ofStarAlgHom (f : F) (g : G) (h₁ : ∀ x, g (f x) = x) (h₂ : ∀ x, f (g x) = x) : A ≃⋆ₐ[R] B 
goal: A ≃⋆ₐ[R] B

full_name: StarAlgEquiv.ofStarAlgHom_symm_apply
code: /-- If a (unital or non-unital) star algebra morphism has an inverse, it is an isomorphism of
star algebras. -/
@[simps]
def ofStarAlgHom (f : F) (g : G) (h₁ : ∀ x, g (f x) = x) (h₂ : ∀ x, f (g x) = x) : A ≃⋆ₐ[R] B 
goal: (StarAlgEquiv.ofStarAlgHom f g h₁ h₂).symm a = g a

full_name: StarAlgEquiv.ofStarAlgHom_apply
code: /-- If a (unital or non-unital) star algebra morphism has an inverse, it is an isomorphism of
star algebras. -/
@[simps]
def ofStarAlgHom (f : F) (g : G) (h₁ : ∀ x, g (f x) = x) (h₂ : ∀ x, f (g x) = x) : A ≃⋆ₐ[R] B 
goal: (StarAlgEquiv.ofStarAlgHom f g h₁ h₂) a = f a

full_name: StarAlgEquiv.ofBijective
code: /-- Promote a bijective star algebra homomorphism to a star algebra equivalence. -/
noncomputable def ofBijective (f : F) (hf : Function.Bijective f) : A ≃⋆ₐ[R] B 
goal: A ≃⋆ₐ[R] B

full_name: StarAlgEquiv.coe_ofBijective
code: @[simp]
theorem coe_ofBijective {f : F} (hf : Function.Bijective f) :
    (StarAlgEquiv.ofBijective f hf : A → B) = f 
goal: ⇑(StarAlgEquiv.ofBijective f hf) = ⇑f

full_name: StarAlgEquiv.ofBijective_apply
code: theorem ofBijective_apply {f : F} (hf : Function.Bijective f) (a : A) :
    (StarAlgEquiv.ofBijective f hf) a = f a 
goal: (StarAlgEquiv.ofBijective f hf) a = f a