File: Mathlib/Algebra/Group/Action/Opposite.lean

full_name: AddOpposite.instAddAction
code: @[to_additive]
instance instMulAction [Monoid M] [MulAction M α] : MulAction M αᵐᵒᵖ 
goal: AddAction M αᵃᵒᵖ

full_name: MulOpposite.instMulAction
code: @[to_additive]
instance instMulAction [Monoid M] [MulAction M α] : MulAction M αᵐᵒᵖ 
goal: MulAction M αᵐᵒᵖ

full_name: MulOpposite.instIsScalarTower
code: @[to_additive]
instance instIsScalarTower [SMul M N] [SMul M α] [SMul N α] [IsScalarTower M N α] :
    IsScalarTower M N αᵐᵒᵖ 
goal: IsScalarTower M N αᵐᵒᵖ

full_name: AddOpposite.instIsScalarTower
code: @[to_additive]
instance instIsScalarTower [SMul M N] [SMul M α] [SMul N α] [IsScalarTower M N α] :
    IsScalarTower M N αᵐᵒᵖ 
goal: VAddAssocClass M N αᵃᵒᵖ

full_name: MulOpposite.instSMulCommClass
code: @[to_additive]
instance instSMulCommClass [SMul M α] [SMul N α] [SMulCommClass M N α] :
    SMulCommClass M N αᵐᵒᵖ 
goal: SMulCommClass M N αᵐᵒᵖ

full_name: AddOpposite.instVAddCommClass
code: @[to_additive]
instance instSMulCommClass [SMul M α] [SMul N α] [SMulCommClass M N α] :
    SMulCommClass M N αᵐᵒᵖ 
goal: VAddCommClass M N αᵃᵒᵖ

full_name: MulOpposite.instIsCentralScalar
code: @[to_additive]
instance instIsCentralScalar [SMul M α] [SMul Mᵐᵒᵖ α] [IsCentralScalar M α] :
    IsCentralScalar M αᵐᵒᵖ 
goal: IsCentralScalar M αᵐᵒᵖ

full_name: AddOpposite.instIsCentralVAdd
code: @[to_additive]
instance instIsCentralScalar [SMul M α] [SMul Mᵐᵒᵖ α] [IsCentralScalar M α] :
    IsCentralScalar M αᵐᵒᵖ 
goal: IsCentralVAdd M αᵃᵒᵖ

full_name: MulOpposite.op_smul_eq_op_smul_op
code: @[to_additive]
lemma op_smul_eq_op_smul_op [SMul M α] [SMul Mᵐᵒᵖ α] [IsCentralScalar M α] (r : M) (a : α) :
    op (r • a) = op r • op a 
goal: MulOpposite.op (r • a) = MulOpposite.op r • MulOpposite.op a

full_name: AddOpposite.op_vadd_eq_op_vadd_op
code: @[to_additive]
lemma op_smul_eq_op_smul_op [SMul M α] [SMul Mᵐᵒᵖ α] [IsCentralScalar M α] (r : M) (a : α) :
    op (r • a) = op r • op a 
goal: AddOpposite.op (r +ᵥ a) = AddOpposite.op r +ᵥ AddOpposite.op a

full_name: MulOpposite.unop_smul_eq_unop_smul_unop
code: @[to_additive]
lemma unop_smul_eq_unop_smul_unop [SMul M α] [SMul Mᵐᵒᵖ α] [IsCentralScalar M α] (r : Mᵐᵒᵖ)
    (a : αᵐᵒᵖ) : unop (r • a) = unop r • unop a 
goal: MulOpposite.unop (r • a) = MulOpposite.unop r • MulOpposite.unop a

full_name: AddOpposite.unop_vadd_eq_unop_vadd_unop
code: @[to_additive]
lemma unop_smul_eq_unop_smul_unop [SMul M α] [SMul Mᵐᵒᵖ α] [IsCentralScalar M α] (r : Mᵐᵒᵖ)
    (a : αᵐᵒᵖ) : unop (r • a) = unop r • unop a 
goal: AddOpposite.unop (r +ᵥ a) = AddOpposite.unop r +ᵥ AddOpposite.unop a

full_name: RightActions.«_aux_Mathlib_Algebra_Group_Action_Opposite___macroRules_RightActions_term_•>__1»
code: /-- With `open scoped RightActions`, an alternative symbol for left actions, `r • m`.

In lemma names this is still called `smul`. -/
scoped notation3:74 r:75 " •> " m:74 => r • m
goal: Lean.Macro

full_name: RightActions.«_aux_Mathlib_Algebra_Group_Action_Opposite___macroRules_RightActions_term_<•__1»
code: /-- With `open scoped RightActions`, a shorthand for right actions, `op r • m`.

In lemma names this is still called `op_smul`. -/
scoped notation3:73 m:73 " <• " r:74 => MulOpposite.op r • m
goal: Lean.Macro

full_name: RightActions.«_aux_Mathlib_Algebra_Group_Action_Opposite___macroRules_RightActions_term_+ᵥ>__1»
code: /-- With `open scoped RightActions`, an alternative symbol for left actions, `r • m`.

In lemma names this is still called `vadd`. -/
scoped notation3:74 r:75 " +ᵥ> " m:74 => r +ᵥ m
goal: Lean.Macro

full_name: RightActions.«_aux_Mathlib_Algebra_Group_Action_Opposite___macroRules_RightActions_term_<+ᵥ__1»
code: /-- With `open scoped RightActions`, a shorthand for right actions, `op r +ᵥ m`.

In lemma names this is still called `op_vadd`. -/
scoped notation3:73 m:73 " <+ᵥ " r:74 => AddOpposite.op r +ᵥ m
goal: Lean.Macro

full_name: op_smul_op_smul
code: @[to_additive]
lemma op_smul_op_smul (b : β) (a₁ a₂ : α) : b <• a₁ <• a₂ = b <• (a₁ * a₂) 
goal: MulOpposite.op a₂ • MulOpposite.op a₁ • b = MulOpposite.op (a₁ * a₂) • b

full_name: op_vadd_op_vadd
code: @[to_additive]
lemma op_smul_op_smul (b : β) (a₁ a₂ : α) : b <• a₁ <• a₂ = b <• (a₁ * a₂) 
goal: AddOpposite.op a₂ +ᵥ (AddOpposite.op a₁ +ᵥ b) = AddOpposite.op (a₁ + a₂) +ᵥ b

full_name: op_vadd_add
code: @[to_additive]
lemma op_smul_mul (b : β) (a₁ a₂ : α) : b <• (a₁ * a₂) = b <• a₁ <• a₂ 
goal: AddOpposite.op (a₁ + a₂) +ᵥ b = AddOpposite.op a₂ +ᵥ (AddOpposite.op a₁ +ᵥ b)

full_name: op_smul_mul
code: @[to_additive]
lemma op_smul_mul (b : β) (a₁ a₂ : α) : b <• (a₁ * a₂) = b <• a₁ <• a₂ 
goal: MulOpposite.op (a₁ * a₂) • b = MulOpposite.op a₂ • MulOpposite.op a₁ • b

full_name: Mul.toHasOppositeSMul
code: /-- Like `Mul.toSMul`, but multiplies on the right.

See also `Monoid.toOppositeMulAction` and `MonoidWithZero.toOppositeMulActionWithZero`. -/
@[to_additive "Like `Add.toVAdd`, but adds on the right.

  See also `AddMonoid.toOppositeAddAction`."]
instance Mul.toHasOppositeSMul [Mul α] : SMul αᵐᵒᵖ α 
goal: SMul αᵐᵒᵖ α

full_name: Add.toHasOppositeVAdd
code: /-- Like `Mul.toSMul`, but multiplies on the right.

See also `Monoid.toOppositeMulAction` and `MonoidWithZero.toOppositeMulActionWithZero`. -/
@[to_additive "Like `Add.toVAdd`, but adds on the right.

  See also `AddMonoid.toOppositeAddAction`."]
instance Mul.toHasOppositeSMul [Mul α] : SMul αᵐᵒᵖ α 
goal: VAdd αᵃᵒᵖ α

full_name: op_smul_eq_mul
code: @[to_additive] lemma op_smul_eq_mul [Mul α] {a a' : α} : op a • a' = a' * a 
goal: MulOpposite.op a • a' = a' * a

full_name: op_vadd_eq_add
code: @[to_additive] lemma op_smul_eq_mul [Mul α] {a a' : α} : op a • a' = a' * a 
goal: AddOpposite.op a +ᵥ a' = a' + a

full_name: MulOpposite.smul_eq_mul_unop
code: @[to_additive (attr := simp)]
lemma MulOpposite.smul_eq_mul_unop [Mul α] {a : αᵐᵒᵖ} {a' : α} : a • a' = a' * a.unop 
goal: a • a' = a' * MulOpposite.unop a

full_name: AddOpposite.vadd_eq_add_unop
code: @[to_additive (attr := simp)]
lemma MulOpposite.smul_eq_mul_unop [Mul α] {a : αᵐᵒᵖ} {a' : α} : a • a' = a' * a.unop 
goal: a +ᵥ a' = a' + AddOpposite.unop a

full_name: MulAction.OppositeRegular.isPretransitive
code: /-- The right regular action of a group on itself is transitive. -/
@[to_additive "The right regular action of an additive group on itself is transitive."]
instance MulAction.OppositeRegular.isPretransitive {G : Type*} [Group G] : IsPretransitive Gᵐᵒᵖ G 
goal: MulAction.IsPretransitive Gᵐᵒᵖ G

full_name: AddAction.OppositeRegular.isPretransitive
code: /-- The right regular action of a group on itself is transitive. -/
@[to_additive "The right regular action of an additive group on itself is transitive."]
instance MulAction.OppositeRegular.isPretransitive {G : Type*} [Group G] : IsPretransitive Gᵐᵒᵖ G 
goal: AddAction.IsPretransitive Gᵃᵒᵖ G

full_name: Semigroup.opposite_smulCommClass
code: @[to_additive]
instance Semigroup.opposite_smulCommClass [Semigroup α] : SMulCommClass αᵐᵒᵖ α α 
goal: SMulCommClass αᵐᵒᵖ α α

full_name: AddSemigroup.opposite_vaddCommClass
code: @[to_additive]
instance Semigroup.opposite_smulCommClass [Semigroup α] : SMulCommClass αᵐᵒᵖ α α 
goal: VAddCommClass αᵃᵒᵖ α α

full_name: Semigroup.opposite_smulCommClass'
code: @[to_additive]
instance Semigroup.opposite_smulCommClass' [Semigroup α] : SMulCommClass α αᵐᵒᵖ α 
goal: SMulCommClass α αᵐᵒᵖ α

full_name: AddSemigroup.opposite_vaddCommClass'
code: @[to_additive]
instance Semigroup.opposite_smulCommClass' [Semigroup α] : SMulCommClass α αᵐᵒᵖ α 
goal: VAddCommClass α αᵃᵒᵖ α

full_name: AddCommSemigroup.isCentralVAdd
code: @[to_additive]
instance CommSemigroup.isCentralScalar [CommSemigroup α] : IsCentralScalar α α 
goal: IsCentralVAdd α α

full_name: CommSemigroup.isCentralScalar
code: @[to_additive]
instance CommSemigroup.isCentralScalar [CommSemigroup α] : IsCentralScalar α α 
goal: IsCentralScalar α α

full_name: Monoid.toOppositeMulAction
code: /-- Like `Monoid.toMulAction`, but multiplies on the right. -/
@[to_additive "Like `AddMonoid.toAddAction`, but adds on the right."]
instance Monoid.toOppositeMulAction [Monoid α] : MulAction αᵐᵒᵖ α 
goal: MulAction αᵐᵒᵖ α

full_name: AddMonoid.toOppositeAddAction
code: /-- Like `Monoid.toMulAction`, but multiplies on the right. -/
@[to_additive "Like `AddMonoid.toAddAction`, but adds on the right."]
instance Monoid.toOppositeMulAction [Monoid α] : MulAction αᵐᵒᵖ α 
goal: AddAction αᵃᵒᵖ α

full_name: IsScalarTower.opposite_mid
code: @[to_additive]
instance IsScalarTower.opposite_mid {M N} [Mul N] [SMul M N] [SMulCommClass M N N] :
    IsScalarTower M Nᵐᵒᵖ N 
goal: IsScalarTower M Nᵐᵒᵖ N

full_name: VAddAssocClass.opposite_mid
code: @[to_additive]
instance IsScalarTower.opposite_mid {M N} [Mul N] [SMul M N] [SMulCommClass M N N] :
    IsScalarTower M Nᵐᵒᵖ N 
goal: VAddAssocClass M Nᵃᵒᵖ N

full_name: VAddCommClass.opposite_mid
code: @[to_additive]
instance SMulCommClass.opposite_mid {M N} [Mul N] [SMul M N] [IsScalarTower M N N] :
    SMulCommClass M Nᵐᵒᵖ N 
goal: VAddCommClass M Nᵃᵒᵖ N

full_name: SMulCommClass.opposite_mid
code: @[to_additive]
instance SMulCommClass.opposite_mid {M N} [Mul N] [SMul M N] [IsScalarTower M N N] :
    SMulCommClass M Nᵐᵒᵖ N 
goal: SMulCommClass M Nᵐᵒᵖ N

full_name: LeftCancelMonoid.toFaithfulSMul_opposite
code: /-- `Monoid.toOppositeMulAction` is faithful on cancellative monoids. -/
@[to_additive "`AddMonoid.toOppositeAddAction` is faithful on cancellative monoids."]
instance LeftCancelMonoid.toFaithfulSMul_opposite [LeftCancelMonoid α] :
    FaithfulSMul αᵐᵒᵖ α 
goal: FaithfulSMul αᵐᵒᵖ α

full_name: AddLeftCancelMonoid.toFaithfulVAdd_opposite
code: /-- `Monoid.toOppositeMulAction` is faithful on cancellative monoids. -/
@[to_additive "`AddMonoid.toOppositeAddAction` is faithful on cancellative monoids."]
instance LeftCancelMonoid.toFaithfulSMul_opposite [LeftCancelMonoid α] :
    FaithfulSMul αᵐᵒᵖ α 
goal: FaithfulVAdd αᵃᵒᵖ α