File: Mathlib/Algebra/Star/Basic.lean

full_name: Star.star
code: /-- Notation typeclass (with no default notation!) for an algebraic structure with a star operation.
-/
class Star (R : Type u) where
  star : R → R
goal: R → R

full_name: Star
code: /-- Notation typeclass (with no default notation!) for an algebraic structure with a star operation.
-/
class Star (R : Type u) where
  star : R → R
goal: Type u

full_name: StarMemClass.star_mem
code: /-- `StarMemClass S G` states `S` is a type of subsets `s ⊆ G` closed under star. -/
class StarMemClass (S R : Type*) [Star R] [SetLike S R] : Prop where
  /-- Closure under star. -/
  star_mem : ∀ {s : S} {r : R}, r ∈ s → star r ∈ s
goal: r ∈ s → star r ∈ s

full_name: StarMemClass
code: /-- `StarMemClass S G` states `S` is a type of subsets `s ⊆ G` closed under star. -/
class StarMemClass (S R : Type*) [Star R] [SetLike S R] : Prop where
  /-- Closure under star. -/
  star_mem : ∀ {s : S} {r : R}, r ∈ s → star r ∈ s
goal: Prop

full_name: StarMemClass.instStar
code: instance instStar : Star s 
goal: Star ↥s

full_name: StarMemClass.coe_star
code: @[simp] lemma coe_star (x : s) : star x = star (x : R) 
goal: ↑(star x) = star ↑x

full_name: InvolutiveStar.star_involutive
code: /-- Typeclass for a star operation with is involutive.
-/
class InvolutiveStar (R : Type u) extends Star R where
  /-- Involutive condition. -/
  star_involutive : Function.Involutive star
goal: Function.Involutive star

full_name: InvolutiveStar
code: /-- Typeclass for a star operation with is involutive.
-/
class InvolutiveStar (R : Type u) extends Star R where
  /-- Involutive condition. -/
  star_involutive : Function.Involutive star
goal: Type u

full_name: star_star
code: @[simp]
theorem star_star [InvolutiveStar R] (r : R) : star (star r) = r 
goal: star (star r) = r

full_name: star_injective
code: theorem star_injective [InvolutiveStar R] : Function.Injective (star : R → R) 
goal: Function.Injective star

full_name: star_inj
code: @[simp]
theorem star_inj [InvolutiveStar R] {x y : R} : star x = star y ↔ x = y 
goal: star x = star y ↔ x = y

full_name: Equiv.star
code: /-- `star` as an equivalence when it is involutive. -/
protected def Equiv.star [InvolutiveStar R] : Equiv.Perm R 
goal: Equiv.Perm R

full_name: eq_star_of_eq_star
code: theorem eq_star_of_eq_star [InvolutiveStar R] {r s : R} (h : r = star s) : s = star r 
goal: s = star r

full_name: eq_star_iff_eq_star
code: theorem eq_star_iff_eq_star [InvolutiveStar R] {r s : R} : r = star s ↔ s = star r 
goal: r = star s ↔ s = star r

full_name: star_eq_iff_star_eq
code: theorem star_eq_iff_star_eq [InvolutiveStar R] {r s : R} : star r = s ↔ star s = r 
goal: star r = s ↔ star s = r

full_name: TrivialStar.star_trivial
code: /-- Typeclass for a trivial star operation. This is mostly meant for `ℝ`.
-/
class TrivialStar (R : Type u) [Star R] : Prop where
  /-- Condition that star is trivial-/
  star_trivial : ∀ r : R, star r = r
goal: star r = r

full_name: TrivialStar
code: /-- Typeclass for a trivial star operation. This is mostly meant for `ℝ`.
-/
class TrivialStar (R : Type u) [Star R] : Prop where
  /-- Condition that star is trivial-/
  star_trivial : ∀ r : R, star r = r
goal: Prop

full_name: StarMul.star_mul
code: /-- A `*`-magma is a magma `R` with an involutive operation `star`
such that `star (r * s) = star s * star r`.
-/
class StarMul (R : Type u) [Mul R] extends InvolutiveStar R where
  /-- `star` skew-distributes over multiplication. -/
  star_mul : ∀ r s : R, star (r * s) = star s * star r
goal: star (r * s) = star s * star r

full_name: StarMul
code: /-- A `*`-magma is a magma `R` with an involutive operation `star`
such that `star (r * s) = star s * star r`.
-/
class StarMul (R : Type u) [Mul R] extends InvolutiveStar R where
  /-- `star` skew-distributes over multiplication. -/
  star_mul : ∀ r s : R, star (r * s) = star s * star r
goal: Type u

full_name: star_star_mul
code: theorem star_star_mul (x y : R) : star (star x * y) = star y * x 
goal: star (star x * y) = star y * x

full_name: star_mul_star
code: theorem star_mul_star (x y : R) : star (x * star y) = y * star x 
goal: star (x * star y) = y * star x

full_name: semiconjBy_star_star_star
code: @[simp]
theorem semiconjBy_star_star_star {x y z : R} :
    SemiconjBy (star x) (star z) (star y) ↔ SemiconjBy x y z 
goal: SemiconjBy (star x) (star z) (star y) ↔ SemiconjBy x y z

full_name: commute_star_star
code: @[simp]
theorem commute_star_star {x y : R} : Commute (star x) (star y) ↔ Commute x y 
goal: Commute (star x) (star y) ↔ Commute x y

full_name: commute_star_comm
code: theorem commute_star_comm {x y : R} : Commute (star x) y ↔ Commute x (star y) 
goal: Commute (star x) y ↔ Commute x (star y)

full_name: star_mul'
code: /-- In a commutative ring, make `simp` prefer leaving the order unchanged. -/
@[simp]
theorem star_mul' [CommSemigroup R] [StarMul R] (x y : R) : star (x * y) = star x * star y 
goal: star (x * y) = star x * star y

full_name: starMulEquiv
code: /-- `star` as a `MulEquiv` from `R` to `Rᵐᵒᵖ` -/
@[simps apply]
def starMulEquiv [Mul R] [StarMul R] : R ≃* Rᵐᵒᵖ 
goal: R ≃* Rᵐᵒᵖ

full_name: starMulEquiv_apply
code: /-- `star` as a `MulEquiv` from `R` to `Rᵐᵒᵖ` -/
@[simps apply]
def starMulEquiv [Mul R] [StarMul R] : R ≃* Rᵐᵒᵖ 
goal: starMulEquiv x = MulOpposite.op (star x)

full_name: starMulAut
code: /-- `star` as a `MulAut` for commutative `R`. -/
@[simps apply]
def starMulAut [CommSemigroup R] [StarMul R] : MulAut R 
goal: MulAut R

full_name: starMulAut_apply
code: /-- `star` as a `MulAut` for commutative `R`. -/
@[simps apply]
def starMulAut [CommSemigroup R] [StarMul R] : MulAut R 
goal: ∀ (a : R), starMulAut a = star a

full_name: star_one
code: @[simp]
theorem star_one [MulOneClass R] [StarMul R] : star (1 : R) = 1 
goal: star 1 = 1

full_name: star_pow
code: @[simp]
theorem star_pow [Monoid R] [StarMul R] (x : R) (n : ℕ) : star (x ^ n) = star x ^ n 
goal: star (x ^ n) = star x ^ n

full_name: star_inv
code: @[simp]
theorem star_inv [Group R] [StarMul R] (x : R) : star x⁻¹ = (star x)⁻¹ 
goal: star x⁻¹ = (star x)⁻¹

full_name: star_zpow
code: @[simp]
theorem star_zpow [Group R] [StarMul R] (x : R) (z : ℤ) : star (x ^ z) = star x ^ z 
goal: star (x ^ z) = star x ^ z

full_name: star_div
code: /-- When multiplication is commutative, `star` preserves division. -/
@[simp]
theorem star_div [CommGroup R] [StarMul R] (x y : R) : star (x / y) = star x / star y 
goal: star (x / y) = star x / star y

full_name: starMulOfComm
code: /-- Any commutative monoid admits the trivial `*`-structure.

See note [reducible non-instances].
-/
abbrev starMulOfComm {R : Type*} [CommMonoid R] : StarMul R 
goal: StarMul R

full_name: star_id_of_comm
code: /-- Note that since `starMulOfComm` is reducible, `simp` can already prove this. -/
theorem star_id_of_comm {R : Type*} [CommSemiring R] {x : R} : star x = x 
goal: star x = x

full_name: StarAddMonoid
code: /-- A `*`-additive monoid `R` is an additive monoid with an involutive `star` operation which
preserves addition.  -/
class StarAddMonoid (R : Type u) [AddMonoid R] extends InvolutiveStar R where
  /-- `star` commutes with addition -/
  star_add : ∀ r s : R, star (r + s) = star r + star s
goal: Type u

full_name: StarAddMonoid.star_add
code: /-- A `*`-additive monoid `R` is an additive monoid with an involutive `star` operation which
preserves addition.  -/
class StarAddMonoid (R : Type u) [AddMonoid R] extends InvolutiveStar R where
  /-- `star` commutes with addition -/
  star_add : ∀ r s : R, star (r + s) = star r + star s
goal: star (r + s) = star r + star s

full_name: starAddEquiv
code: /-- `star` as an `AddEquiv` -/
@[simps apply]
def starAddEquiv [AddMonoid R] [StarAddMonoid R] : R ≃+ R 
goal: R ≃+ R

full_name: starAddEquiv_apply
code: /-- `star` as an `AddEquiv` -/
@[simps apply]
def starAddEquiv [AddMonoid R] [StarAddMonoid R] : R ≃+ R 
goal: ∀ (a : R), starAddEquiv a = star a

full_name: star_zero
code: @[simp]
theorem star_zero [AddMonoid R] [StarAddMonoid R] : star (0 : R) = 0 
goal: star 0 = 0

full_name: star_eq_zero
code: @[simp]
theorem star_eq_zero [AddMonoid R] [StarAddMonoid R] {x : R} : star x = 0 ↔ x = 0 
goal: star x = 0 ↔ x = 0

full_name: star_ne_zero
code: theorem star_ne_zero [AddMonoid R] [StarAddMonoid R] {x : R} : star x ≠ 0 ↔ x ≠ 0 
goal: star x ≠ 0 ↔ x ≠ 0

full_name: star_neg
code: @[simp]
theorem star_neg [AddGroup R] [StarAddMonoid R] (r : R) : star (-r) = -star r 
goal: star (-r) = -star r

full_name: star_sub
code: @[simp]
theorem star_sub [AddGroup R] [StarAddMonoid R] (r s : R) : star (r - s) = star r - star s 
goal: star (r - s) = star r - star s

full_name: star_nsmul
code: @[simp]
theorem star_nsmul [AddMonoid R] [StarAddMonoid R] (x : R) (n : ℕ) : star (n • x) = n • star x 
goal: star (n • x) = n • star x

full_name: star_zsmul
code: @[simp]
theorem star_zsmul [AddGroup R] [StarAddMonoid R] (x : R) (n : ℤ) : star (n • x) = n • star x 
goal: star (n • x) = n • star x

full_name: StarRing.star_add
code: /-- A `*`-ring `R` is a non-unital, non-associative (semi)ring with an involutive `star` operation
which is additive which makes `R` with its multiplicative structure into a `*`-multiplication
(i.e. `star (r * s) = star s * star r`).  -/
class StarRing (R : Type u) [NonUnitalNonAssocSemiring R] extends StarMul R where
  /-- `star` commutes with addition -/
  star_add : ∀ r s : R, star (r + s) = star r + star s
goal: star (r + s) = star r + star s

full_name: StarRing
code: /-- A `*`-ring `R` is a non-unital, non-associative (semi)ring with an involutive `star` operation
which is additive which makes `R` with its multiplicative structure into a `*`-multiplication
(i.e. `star (r * s) = star s * star r`).  -/
class StarRing (R : Type u) [NonUnitalNonAssocSemiring R] extends StarMul R where
  /-- `star` commutes with addition -/
  star_add : ∀ r s : R, star (r + s) = star r + star s
goal: Type u

full_name: StarRing.toStarAddMonoid
code: instance (priority := 100) StarRing.toStarAddMonoid [NonUnitalNonAssocSemiring R] [StarRing R] :
    StarAddMonoid R 
goal: StarAddMonoid R

full_name: starRingEquiv_apply
code: /-- `star` as a `RingEquiv` from `R` to `Rᵐᵒᵖ` -/
@[simps apply]
def starRingEquiv [NonUnitalNonAssocSemiring R] [StarRing R] : R ≃+* Rᵐᵒᵖ 
goal: starRingEquiv x = MulOpposite.op (star x)

full_name: starRingEquiv
code: /-- `star` as a `RingEquiv` from `R` to `Rᵐᵒᵖ` -/
@[simps apply]
def starRingEquiv [NonUnitalNonAssocSemiring R] [StarRing R] : R ≃+* Rᵐᵒᵖ 
goal: R ≃+* Rᵐᵒᵖ

full_name: star_natCast
code: @[simp, norm_cast]
theorem star_natCast [NonAssocSemiring R] [StarRing R] (n : ℕ) : star (n : R) = n 
goal: star ↑n = ↑n

full_name: star_ofNat
code: @[simp]
theorem star_ofNat [NonAssocSemiring R] [StarRing R] (n : ℕ) [n.AtLeastTwo] :
    star (no_index (OfNat.ofNat n) : R) = OfNat.ofNat n 
goal: star (OfNat.ofNat n) = OfNat.ofNat n

full_name: star_intCast
code: @[simp, norm_cast]
theorem star_intCast [Ring R] [StarRing R] (z : ℤ) : star (z : R) = z 
goal: star ↑z = ↑z

full_name: starRingAut
code: /-- `star` as a ring automorphism, for commutative `R`. -/
@[simps apply]
def starRingAut : RingAut R 
goal: RingAut R

full_name: starRingAut_apply
code: /-- `star` as a ring automorphism, for commutative `R`. -/
@[simps apply]
def starRingAut : RingAut R 
goal: ∀ (a : R), starRingAut a = star a

full_name: starRingEnd
code: /-- `star` as a ring endomorphism, for commutative `R`. This is used to denote complex
conjugation, and is available under the notation `conj` in the locale `ComplexConjugate`.

Note that this is the preferred form (over `starRingAut`, available under the same hypotheses)
because the notation `E →ₗ⋆[R] F` for an `R`-conjugate-linear map (short for
`E →ₛₗ[starRingEnd R] F`) does not pretty-print if there is a coercion involved, as would be the
case for `(↑starRingAut : R →* R)`. -/
def starRingEnd : R →+* R 
goal: R →+* R

full_name: ComplexConjugate._aux_Mathlib_Algebra_Star_Basic___macroRules_ComplexConjugate_termConj_1
code: @[inherit_doc]
scoped[ComplexConjugate] notation "conj" => starRingEnd _
goal: Lean.Macro

full_name: ComplexConjugate._aux_Mathlib_Algebra_Star_Basic___unexpand_starRingEnd_1
code: @[inherit_doc]
scoped[ComplexConjugate] notation "conj" => starRingEnd _
goal: Lean.PrettyPrinter.Unexpander

full_name: starRingEnd_apply
code: /-- This is not a simp lemma, since we usually want simp to keep `starRingEnd` bundled.
 For example, for complex conjugation, we don't want simp to turn `conj x`
 into the bare function `star x` automatically since most lemmas are about `conj x`. -/
theorem starRingEnd_apply (x : R) : starRingEnd R x = star x 
goal: (starRingEnd R) x = star x

full_name: starRingEnd_self_apply
code: theorem starRingEnd_self_apply (x : R) : starRingEnd R (starRingEnd R x) = x 
goal: (starRingEnd R) ((starRingEnd R) x) = x

full_name: RingHom.involutiveStar
code: instance RingHom.involutiveStar {S : Type*} [NonAssocSemiring S] : InvolutiveStar (S →+* R) 
goal: InvolutiveStar (S →+* R)

full_name: RingHom.star_def
code: theorem RingHom.star_def {S : Type*} [NonAssocSemiring S] (f : S →+* R) :
    Star.star f = RingHom.comp (starRingEnd R) f 
goal: star f = (starRingEnd R).comp f

full_name: RingHom.star_apply
code: theorem RingHom.star_apply {S : Type*} [NonAssocSemiring S] (f : S →+* R) (s : S) :
    star f s = star (f s) 
goal: (star f) s = star (f s)

full_name: conj_trivial
code: @[simp] lemma conj_trivial [TrivialStar R] (a : R) : conj a = a 
goal: (starRingEnd R) a = a

full_name: star_inv'
code: @[simp]
theorem star_inv' [DivisionSemiring R] [StarRing R] (x : R) : star x⁻¹ = (star x)⁻¹ 
goal: star x⁻¹ = (star x)⁻¹

full_name: star_zpow₀
code: @[simp]
theorem star_zpow₀ [DivisionSemiring R] [StarRing R] (x : R) (z : ℤ) : star (x ^ z) = star x ^ z 
goal: star (x ^ z) = star x ^ z

full_name: star_div'
code: /-- When multiplication is commutative, `star` preserves division. -/
@[simp]
theorem star_div' [Semifield R] [StarRing R] (x y : R) : star (x / y) = star x / star y 
goal: star (x / y) = star x / star y

full_name: starRingOfComm
code: /-- Any commutative semiring admits the trivial `*`-structure.

See note [reducible non-instances].
-/
abbrev starRingOfComm {R : Type*} [CommSemiring R] : StarRing R 
goal: StarRing R

full_name: Nat.instStarRing
code: instance Nat.instStarRing : StarRing ℕ 
goal: StarRing ℕ

full_name: Int.instStarRing
code: instance Int.instStarRing : StarRing ℤ 
goal: StarRing ℤ

full_name: Nat.instTrivialStar
code: instance Nat.instTrivialStar : TrivialStar ℕ 
goal: TrivialStar ℕ

full_name: Int.instTrivialStar
code: instance Int.instTrivialStar : TrivialStar ℤ 
goal: TrivialStar ℤ

full_name: StarModule.star_smul
code: /-- A star module `A` over a star ring `R` is a module which is a star add monoid,
and the two star structures are compatible in the sense
`star (r • a) = star r • star a`.

Note that it is up to the user of this typeclass to enforce
`[Semiring R] [StarRing R] [AddCommMonoid A] [StarAddMonoid A] [Module R A]`, and that
the statement only requires `[Star R] [Star A] [SMul R A]`.

If used as `[CommRing R] [StarRing R] [Semiring A] [StarRing A] [Algebra R A]`, this represents a
star algebra.
-/

class StarModule (R : Type u) (A : Type v) [Star R] [Star A] [SMul R A] : Prop where
  /-- `star` commutes with scalar multiplication -/
  star_smul : ∀ (r : R) (a : A), star (r • a) = star r • star a
goal: star (r • a) = star r • star a

full_name: StarModule
code: /-- A star module `A` over a star ring `R` is a module which is a star add monoid,
and the two star structures are compatible in the sense
`star (r • a) = star r • star a`.

Note that it is up to the user of this typeclass to enforce
`[Semiring R] [StarRing R] [AddCommMonoid A] [StarAddMonoid A] [Module R A]`, and that
the statement only requires `[Star R] [Star A] [SMul R A]`.

If used as `[CommRing R] [StarRing R] [Semiring A] [StarRing A] [Algebra R A]`, this represents a
star algebra.
-/

class StarModule (R : Type u) (A : Type v) [Star R] [Star A] [SMul R A] : Prop where
  /-- `star` commutes with scalar multiplication -/
  star_smul : ∀ (r : R) (a : A), star (r • a) = star r • star a
goal: Prop

full_name: StarMul.toStarModule
code: /-- A commutative star monoid is a star module over itself via `Monoid.toMulAction`. -/
instance StarMul.toStarModule [CommMonoid R] [StarMul R] : StarModule R R 
goal: StarModule R R

full_name: StarAddMonoid.toStarModuleNat
code: instance StarAddMonoid.toStarModuleNat {α} [AddCommMonoid α] [StarAddMonoid α] : StarModule ℕ α 
goal: StarModule ℕ α

full_name: RingHomInvPair.instStarRingEnd
code: /-- Instance needed to define star-linear maps over a commutative star ring
(ex: conjugate-linear maps when R = ℂ).  -/
instance [CommSemiring R] [StarRing R] : RingHomInvPair (starRingEnd R) (starRingEnd R) 
goal: RingHomInvPair (starRingEnd R) (starRingEnd R)

full_name: StarHomClass
code: /-- `StarHomClass F R S` states that `F` is a type of `star`-preserving maps from `R` to `S`. -/
class StarHomClass (F : Type*) (R S : outParam Type*) [Star R] [Star S] [FunLike F R S] : Prop where
  /-- the maps preserve star -/
  map_star : ∀ (f : F) (r : R), f (star r) = star (f r)
goal: Prop

full_name: StarHomClass.map_star
code: /-- `StarHomClass F R S` states that `F` is a type of `star`-preserving maps from `R` to `S`. -/
class StarHomClass (F : Type*) (R S : outParam Type*) [Star R] [Star S] [FunLike F R S] : Prop where
  /-- the maps preserve star -/
  map_star : ∀ (f : F) (r : R), f (star r) = star (f r)
goal: f (star r) = star (f r)

full_name: Units.instStarMul
code: instance : StarMul Rˣ 
goal: StarMul Rˣ

full_name: Units.coe_star
code: @[simp]
theorem coe_star (u : Rˣ) : ↑(star u) = (star ↑u : R) 
goal: ↑(star u) = star ↑u

full_name: Units.coe_star_inv
code: @[simp]
theorem coe_star_inv (u : Rˣ) : ↑(star u)⁻¹ = (star ↑u⁻¹ : R) 
goal: ↑(star u)⁻¹ = star ↑u⁻¹

full_name: Units.instStarModule
code: instance {A : Type*} [Star A] [SMul R A] [StarModule R A] : StarModule Rˣ A 
goal: StarModule Rˣ A

full_name: IsUnit.star
code: protected theorem IsUnit.star [Monoid R] [StarMul R] {a : R} : IsUnit a → IsUnit (star a)
  
goal: IsUnit a → IsUnit (star a)

full_name: isUnit_star
code: @[simp]
theorem isUnit_star [Monoid R] [StarMul R] {a : R} : IsUnit (star a) ↔ IsUnit a 
goal: IsUnit (star a) ↔ IsUnit a

full_name: Ring.inverse_star
code: theorem Ring.inverse_star [Semiring R] [StarRing R] (a : R) :
    Ring.inverse (star a) = star (Ring.inverse a) 
goal: Ring.inverse (star a) = star (Ring.inverse a)

full_name: Invertible.star
code: protected instance Invertible.star {R : Type*} [MulOneClass R] [StarMul R] (r : R) [Invertible r] :
    Invertible (star r) 
goal: Invertible (star r)

full_name: star_invOf
code: theorem star_invOf {R : Type*} [Monoid R] [StarMul R] (r : R) [Invertible r]
    [Invertible (star r)] : star (⅟ r) = ⅟ (star r) 
goal: star ⅟r = ⅟(star r)

full_name: IsLeftRegular.star
code: protected theorem IsLeftRegular.star [Mul R] [StarMul R] {x : R} (hx : IsLeftRegular x) :
    IsRightRegular (star x) 
goal: IsRightRegular (star x)

full_name: IsRightRegular.star
code: protected theorem IsRightRegular.star [Mul R] [StarMul R] {x : R} (hx : IsRightRegular x) :
    IsLeftRegular (star x) 
goal: IsLeftRegular (star x)

full_name: IsRegular.star
code: protected theorem IsRegular.star [Mul R] [StarMul R] {x : R} (hx : IsRegular x) :
    IsRegular (star x) 
goal: IsRegular (star x)

full_name: isRightRegular_star_iff
code: @[simp]
theorem isRightRegular_star_iff [Mul R] [StarMul R] {x : R} :
    IsRightRegular (star x) ↔ IsLeftRegular x 
goal: IsRightRegular (star x) ↔ IsLeftRegular x

full_name: isLeftRegular_star_iff
code: @[simp]
theorem isLeftRegular_star_iff [Mul R] [StarMul R] {x : R} :
    IsLeftRegular (star x) ↔ IsRightRegular x 
goal: IsLeftRegular (star x) ↔ IsRightRegular x

full_name: isRegular_star_iff
code: @[simp]
theorem isRegular_star_iff [Mul R] [StarMul R] {x : R} :
    IsRegular (star x) ↔ IsRegular x 
goal: IsRegular (star x) ↔ IsRegular x

full_name: MulOpposite.instStar
code: /-- The opposite type carries the same star operation. -/
instance [Star R] : Star Rᵐᵒᵖ 
goal: Star Rᵐᵒᵖ

full_name: MulOpposite.unop_star
code: @[simp]
theorem unop_star [Star R] (r : Rᵐᵒᵖ) : unop (star r) = star (unop r) 
goal: MulOpposite.unop (star r) = star (MulOpposite.unop r)

full_name: MulOpposite.op_star
code: @[simp]
theorem op_star [Star R] (r : R) : op (star r) = star (op r) 
goal: MulOpposite.op (star r) = star (MulOpposite.op r)

full_name: MulOpposite.instInvolutiveStar
code: instance [InvolutiveStar R] : InvolutiveStar Rᵐᵒᵖ 
goal: InvolutiveStar Rᵐᵒᵖ

full_name: MulOpposite.instStarMul
code: instance [Mul R] [StarMul R] : StarMul Rᵐᵒᵖ 
goal: StarMul Rᵐᵒᵖ

full_name: MulOpposite.instStarAddMonoid
code: instance [AddMonoid R] [StarAddMonoid R] : StarAddMonoid Rᵐᵒᵖ 
goal: StarAddMonoid Rᵐᵒᵖ

full_name: MulOpposite.instStarRing
code: instance [Semiring R] [StarRing R] : StarRing Rᵐᵒᵖ 
goal: StarRing Rᵐᵒᵖ

full_name: StarSemigroup.toOpposite_starModule
code: /-- A commutative star monoid is a star module over its opposite via
`Monoid.toOppositeMulAction`. -/
instance StarSemigroup.toOpposite_starModule [CommMonoid R] [StarMul R] :
    StarModule Rᵐᵒᵖ R 
goal: StarModule Rᵐᵒᵖ R